Index: doc/theses/andrew_beach_MMath/performance.tex
===================================================================
--- doc/theses/andrew_beach_MMath/performance.tex	(revision edebbf7457a2b240c384c9ad94a2aaea86869e2d)
+++ doc/theses/andrew_beach_MMath/performance.tex	(revision 029cbc0219b6d11a494475fbda508b4d79d19184)
@@ -4,12 +4,13 @@
 \textbf{Just because of the stage of testing there are design notes for
 the tests as well as commentary on them.}
+\todo{Revisit organization of the performance chapter once tests are chosen.}
+% What are good tests for resumption?
 
 Performance has been of secondary importance for most of this project.
-The driving for has been to get the features working, the only performance
-requirements were to make sure the tests for correctness rain in a reasonable
+Instead, the focus has been to get the features working. The only performance
+requirements is to ensure the tests for correctness run in a reasonable
 amount of time.
-Still this is an implementation others could use for similar prototypes and
-so the results still have some use.
 
+%\section{Termination Comparison}
 \section{Test Set-Up}
 Tests will be run on \CFA, C++ and Java.
@@ -17,26 +18,27 @@
 C++ is the most comparable language because both it and \CFA use the same
 framework, libunwind.
-In fact the comparison is almost entirely a quality of implementation
+In fact, the comparison is almost entirely a quality of implementation
 comparison. \CFA's EHM has had significantly less time to be optimized and
 does not generate its own assembly. It does have a slight advantage in that
 there are some features it does not handle.
 
-% Some languages I left out:
-% Python: Its a scripting language, different
-% uC++: Not well known and should the same results as C++, except for
-%   resumption which should be the same.
-\todo{Can we find a good language to compare resumptions in.}
+Java is another very popular language with similar termination semantics.
+It is implemented in a very different environment, a virtual machine with
+garbage collection.
+It also implements the finally clause on try blocks allowing for a direct
+feature-to-feature comparison.
 
-All tests will be run inside a main loop which will perform the test
-repeatedly. This is to avoid letting and start-up or tear-down time from
+All tests are run inside a main loop which will perform the test
+repeatedly. This is to avoids start-up or tear-down time from
 affecting the timing results.
-This also means that tests cannot terminate the program, which does limit
-how tests can be implemented. There are catch-alls to keep unhandled
-exceptions from terminating the program.
+A consequence of this is that tests cannot terminate the program,
+which does limit how tests can be implemented.
+There are catch-alls to keep unhandled
+exceptions from terminating tests.
 
-The exceptions used in this test will always be a new exception based off of
-the base exception. This should minimize and preformance differences based
+The exceptions used in these tests will always be a exception based off of
+the base exception. This requirement minimizes performance differences based
 on the object model.
-Catch-alls will be done by catching the root exception type (not using \Cpp's
+Catch-alls are done by catching the root exception type (not using \Cpp's
 \code{C++}{catch(...)}).
 
@@ -45,9 +47,13 @@
 
 \section{Tests}
+The following tests were selected to test the performance of different
+components of the exception system.
+The should provide a guide as to where the EHM's costs can be found.
+
 \paragraph{Raise/Handle}
 What is the basic cost to raise and handle an exception?
 
-There are a number of factors that can effect this, for \CFA this includes
-the type of raise,
+There are a number of factors that can effect this.
+For \CFA this includes the type of raise,
 
 Main loop, pass through a catch-all, call through some empty helper functions
@@ -67,5 +73,5 @@
 is thrown?
 
-This is the simplist pattern to test as it is a simple matter of entering
+This test is a simple pattern of entering
 and leaving a try statement.
 
@@ -74,5 +80,5 @@
 
 \paragraph{Re-throw and Conditional-Catch}
-How expencive it is to run a non-exception type check for a handler?
+How expensive it is to run a non-exception type check for a handler?
 
 In this case different languages approach this problem differently, either
@@ -100,2 +106,10 @@
 %(I haven't actually figured out how to compare this, probably using something
 %related to -fexceptions.)
+
+% Some languages I left out:
+% Python: Its a scripting language, different
+% uC++: Not well known and should the same results as C++, except for
+%   resumption which should be the same.
+
+%\section{Resumption Comparison}
+\todo{Can we find a good language to compare resumptions in.}