source: doc/theses/andrew_beach_MMath/future.tex @ 565acf59

arm-ehjacob/cs343-translationnew-ast-unique-expr
Last change on this file since 565acf59 was 29c9b23, checked in by Andrew Beach <ajbeach@…>, 10 months ago

Andrew MMath: Supposed to be focused on features but it ended up leaking out.

  • Property mode set to 100644
File size: 7.1 KB
Line 
1\chapter{Future Work}
2
3\section{Language Improvements}
4\CFA is a developing programming language. As such, there are partially or
5unimplemented features of the language (including several broken components)
6that I had to workaround while building an exception handling system largely in
7the \CFA language (some C components).  The following are a few of these
8issues, and once implemented/fixed, how this would affect the exception system.
9\begin{itemize}
10\item
11The implementation of termination is not portable because it includes
12hand-crafted assembly statements. These sections must be ported by hand to
13support more hardware architectures, such as the ARM processor.
14\item
15Due to a type-system problem, the catch clause cannot bind the exception to a
16reference instead of a pointer. Since \CFA has a very general reference
17capability, programmers will want to use it. Once fixed, this capability should
18result in little or no change in the exception system.
19\item
20Termination handlers cannot use local control-flow transfers, \eg by @break@,
21@return@, \etc. The reason is that current code generation hoists a handler
22into a nested function for convenience (versus assemble-code generation at the
23@try@ statement). Hence, when the handler runs, its code is not in the lexical
24scope of the @try@ statement, where the local control-flow transfers are
25meaningful.
26\item
27There is no detection of colliding unwinds. It is possible for clean-up code
28run during an unwind to trigger another unwind that escapes the clean-up code
29itself; such as a termination exception caught further down the stack or a
30cancellation. There do exist ways to handle this but currently they are not
31even detected and the first unwind will simply be forgotten, often leaving
32it in a bad state.
33\item
34Also the exception system did not have a lot of time to be tried and tested.
35So just letting people use the exception system more will reveal new
36quality of life upgrades that can be made with time.
37\end{itemize}
38
39\section{Complete Virtual System}
40The virtual system should be completed. It was not supposed to be part of this
41project, but was thrust upon it to do exception inheritance; hence, only
42minimal work was done. A draft for a complete virtual system is available but
43it is not finalized.  A future \CFA project is to complete that work and then
44update the exception system that uses the current version.
45
46There are several improvements to the virtual system that would improve the
47exception traits. The most important one is an assertion to check one virtual
48type is a child of another. This check precisely captures many of the
49correctness requirements.
50
51The full virtual system might also include other improvement like associated
52types to allow traits to refer to types not listed in their header. This
53feature allows exception traits to not refer to the virtual-table type
54explicitly, removing the need for the current interface macros.
55
56\section{Additional Raises}
57Several other kinds of exception raises were considered beyond termination
58(@throw@), resumption (@throwResume@), and reraise.
59
60The first is a non-local/concurrent raise providing asynchronous exceptions,
61\ie raising an exception on another stack. This semantics acts like signals
62allowing for out-of-band communication among coroutines and threads. This kind
63of raise is often restricted to resumption to allow the target stack to
64continue execution normally after the exception has been handled. That is,
65allowing one coroutine/thread to unwind the stack of another via termination is
66bad software engineering.
67
68Non-local/concurrent requires more coordination between the concurrency system
69and the exception system. Many of the interesting design decisions centre
70around masking (controlling which exceptions may be thrown at a stack). It
71would likely require more of the virtual system and would also effect how
72default handlers are set.
73
74Other raises were considered to mimic bidirectional algebraic effects.
75Algebraic effects are used in some functional languages allowing one function
76to have another function on the stack resolve an effect (which is defined with
77a functional-like interface).  This semantics can be mimicked with resumptions
78and new raises were discussed to mimic bidirectional algebraic-effects, where
79control can go back and forth between the function-effect caller and handler
80while the effect is underway.
81% resume-top & resume-reply
82These raises would be like the resumption raise except using different search
83patterns to find the handler.
84
85\section{Zero-Cost Try}
86\CFA does not have zero-cost try-statements because the compiler generates C
87code rather than assembler code \see{\VPageref{p:zero-cost}}. When the compiler
88does create its own assembly (or LLVM byte-code), then zero-cost try-statements
89are possible. The downside of zero-cost try-statements is the LSDA complexity,
90its size (program bloat), and the high cost of raising an exception.
91
92Alternatively, some research could be done into the simpler alternative method
93with a non-zero-cost try-statement but much lower cost exception raise. For
94example, programs are starting to use exception in the normal control path, so
95more exceptions are thrown. In these cases, the cost balance switches towards
96low-cost raise. Unfortunately, while exceptions remain exceptional, the
97libunwind model will probably remain the most effective option.
98
99Zero-cost resumptions is still an open problem. First, because libunwind does
100not support a successful-exiting stack-search without doing an unwind.
101Workarounds are possible but awkward. Ideally an extension to libunwind could
102be made, but that would either require separate maintenance or gain enough
103support to have it folded into the standard.
104
105Also new techniques to skip previously searched parts of the stack need to be
106developed to handle the recursive resume problem and support advanced algebraic
107effects.
108
109\section{Signal Exceptions}
110Goodenough~\cite{Goodenough75} suggests three types of exceptions: escape,
111notify and signal.  Escape are termination exceptions, notify are resumption
112exceptions, leaving signal unimplemented.
113
114A signal exception allows either behaviour, \ie after an exception is handled,
115the handler has the option of returning to the raise or after the @try@
116statement. Currently, \CFA fixes the semantics of the handler return
117syntactically by the @catch@ or @catchResume@ clause.
118
119Signal exception should be reexamined and possibly be supported in \CFA. A very
120direct translation is to have a new raise and catch pair, and a new statement
121(or statements) would indicate if the handler returns to the raise or continues
122where it is; but there may be other options.
123
124For instance, resumption could be extended to cover this use by allowing local
125control flow out of it. This approach would require an unwind as part of the
126transition as there are stack frames that have to be removed.  This approach
127means there is no notify raise, but because \CFA does not have exception
128signatures, a termination can be thrown from within any resumption handler so
129there is already a way to do mimic this in existing \CFA.
130
131% Maybe talk about the escape; and escape CONTROL_STMT; statements or how
132% if we could choose if _Unwind_Resume proceeded to the clean-up stage this
133% would be much easier to implement.
Note: See TracBrowser for help on using the repository browser.