Changeset 553f8abe

Timestamp:

Jun 3, 2021, 4:23:07 PM (3 years ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

4ed7946e

Parents:

3f4bf57

Message:

Andrew MMath: Responding to Peter's suggestions on the introduction.

Location:

doc/theses/andrew_beach_MMath

Files:

• existing.tex (modified) (3 diffs)
• features.tex (modified) (1 diff)
• future.tex (modified) (1 diff)
• implement.tex (modified) (1 diff)
• intro.tex (modified) (2 diffs)

doc/theses/andrew_beach_MMath/existing.tex

@@ -1 +1 @@
 \chapter{\CFA Existing Features}
+\label{c:existing}
 
 \CFA (C-for-all)~\cite{Cforall} is an open-source project extending ISO C with
@@ -58 +59 @@
 with a @&@ and then assigning a pointer too them.
 
-\begin{minipage}{0,5\textwidth}
+\begin{minipage}{0,45\textwidth}
 With references:
 \begin{cfa}
@@ -69 +70 @@
 \end{cfa}
 \end{minipage}
-\begin{minipage}{0,5\textwidth}
+\begin{minipage}{0,45\textwidth}
 With pointers:
 \begin{cfa}

doc/theses/andrew_beach_MMath/features.tex

@@ -1 +1 @@
 \chapter{Exception Features}
+\label{c:features}
 
 This chapter covers the design and user interface of the \CFA

doc/theses/andrew_beach_MMath/future.tex

@@ -1 +1 @@
 \chapter{Future Work}
+\label{c:future}
 
 \section{Language Improvements}

doc/theses/andrew_beach_MMath/implement.tex

@@ -1 +1 @@
 \chapter{Implementation}
-% Goes over how all the features are implemented.
+\label{c:implement}
 
 The implementation work for this thesis covers two components: the virtual

doc/theses/andrew_beach_MMath/intro.tex

@@ -4 +4 @@
 This thesis goes over the design and implementation of the exception handling
 mechanism (EHM) of
-\CFA (pronounced see-for-all and also written Cforall or CFA).
-Exception handling provides more complex dynamic inter-function control flow.
-For example, normally function call is a strict linear form: function @h@ calls @g@,
-@g@ calls @f@, @f@ returns to @g@ and @g@ to @h@.
+\CFA (pernounced sea-for-all and may be written Cforall or CFA).
+Exception handling provides dynamic inter-function control flow.
+There are two forms of exception handling covered in this thesis:
+termination, which acts as a multi-level return,
+and resumption, which is a dynamic function call.
+This seperation is uncommon because termination exception handling is so
+much more common that it is often assumed.
+
+Termination exception handling allows control to return to any previous
+function on the stack directly, skipping any functions between it and the
+current function.
 \begin{center}
 \input{callreturn}
 \end{center}
-Exception handling allows deviations,
-such as @f@ returning directly to @h@ and the intervening call to @g@ is unwound.
-Other derivations include dynamic function call (old Lisp~\cite{CommonLisp} call) versus static or continuation passing.
-Basically, any non-linear form of call-return can be part of an EHM.
 
-Although
-powerful, an EHM tends to be conceptually more complex and expensive to use, and hence often limited
-to unusual or ``exceptional" cases.
+Resumption exception handling calls a function, but asks the functions on the
+stack what function that is.
+\todo{Add a diagram showing control flow for resumption.}
+
+Although a powerful feature, exception handling tends to be complex to set up
+and expensive to use
+so they are often limited to unusual or ``exceptional" cases.
 The classic example of this is error handling, exceptions can be used to
-remove error-handling logic from the main execution path and paying a higher
-performance cost only when the error actually occurs.
-
-\section{Background}
-
-Programming languages that provide different forms of EHM are: ...
-
-Mention the popular ``return union'' approach, which does not change the call/return control-flow.
-
-\section{New Work}
+remove error handling logic from the main execution path and while paying
+most of the cost only when the error actually occurs.
 
 % Overview of exceptions in Cforall.
-This thesis describes the design and implementation of the \CFA EHM.
-The work implements all of the common exception features (or an
+This work describes the design and implementation of the \CFA EHM.
+The \CFA EHM implements all of the common exception features (or an
 equivalent) found in most other EHMs and adds some features of its own.
 The design of all the features had to be adapted to \CFA's feature set as
@@ -53 +52 @@
 
 % A note that yes, that was a very fast overview.
-The design and implementation of all of \CFA's EHM's features are
-described in detail throughout in this thesis, whether they are a common feature
+All the design and implementation of all of \CFA's EHM's features are
+described in detail throughout this thesis, whether they are a common feature
 or one unique to \CFA.
 
 % The current state of the project and what it contributes.
-All of these features have been implemented in \CFA, along with
-a suite of test cases, as part of this thesis.
+All of these features have been added to the \CFA implemenation, along with
+a suite of test cases as part of this project.
 The implementation techniques are generally applicable in other programming
-languages and much of the design as well. Although some of \CFA's more unusual EHM feature
-would not be found in other programming languages.
+languages and much of the design is as well.
+Some parts of the EHM use other features unique to \CFA and these would be
+harder to replicate in other programming languages.
 
-\section{Contributions}
+% Talk about other programming languages.
+Some existing programming languages that include EHMs/exception handling
+include C++, Java and Python. All three examples focus on termination
+exceptions which unwind the stack as part of the
+Exceptions also can replace return codes and return unions.
+In functional languages will also sometimes fold exceptions into monads.
 
 The contributions of this work are:
 \begin{enumerate}
-\item
-\item
-\item
-\item
+\item Designing \CFA's exception handling mechanism, adapting designs from
+other programming languages and the creation of new features.
+\item Implementing stack unwinding and the EHM in \CFA, including updating
+the compiler and the run-time environment.
+\item Designed and implemented a prototype virtual system.
+% I think the virtual system and per-call site default handlers are the only
+% "new" features, everything else is a matter of implementation.
 \end{enumerate}
 
-\section{Road Map}
+\todo{I can't figure out a good lead-in to the overview.}
+Covering the existing \CFA features in \autoref{c:existing}.
+Then the new features are introduce in \autoref{c:features}, explaining their
+usage and design.
+That is followed by the implementation of those features in
+\autoref{c:implement}.
+% Future Work \autoref{c:future}