Index: doc/theses/andrew_beach_MMath/performance.tex
===================================================================
--- doc/theses/andrew_beach_MMath/performance.tex	(revision dac16a03590d6ce44545e784580dac95a937d428)
+++ doc/theses/andrew_beach_MMath/performance.tex	(revision 2f19e039f86a037de887ae92e18415228b7d780f)
@@ -6,37 +6,37 @@
 
 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 goal has been to get the features working.
+The only performance
+requirements is to ensure the exception tests for correctness ran 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.
+Much of the implementation is still reasonable and could be used for similar prototypes.
+Hence,
+the work still has some use.
+To get a rough idea about the \CFA implementation, tests are run on \CFA, C++ and Java, which have similar termination-handling exceptions.
+Tests are also run on \CFA and uC++, which has similar resumption-handling exceptions.
 
-\section{Test Set-Up}
-Tests will be run on \CFA, C++ and Java.
-
+\section{Termination Comparison}
 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.}
+The Java comparison is an opportunity to compare a managed memory model with unmanaged,
+to see if there are any effects related to the exception model.
 
-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
+\subsection{Test Set-Up}
+All tests are run inside a main loop that performs the test
+repeatedly. This design avoids start-up or tear-down time from
 affecting the timing results.
-This also means that tests cannot terminate the program, which does limit
+A consequence 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 the program.
+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 this test are always a new 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(...)}).
 
@@ -44,9 +44,13 @@
 hot.
 
-\section{Tests}
+\subsection{Tests}
+The following tests capture the most important aspects of exception handling and should provide
+a reasonable guide to programmers of where EHM costs occur.
+
 \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
+There are a number of factors that can effect this.
+For \CFA this includes
 the type of raise,
 
@@ -61,5 +65,5 @@
 This has the same set-up as the raise/handle test except the intermediate
 stack frames contain either an object declaration with a destructor or a
-try statement with no handlers except for a finally clause.
+@try@ statement with no handlers except and a @finally@ clause.
 
 \paragraph{Enter/Leave}
@@ -67,5 +71,5 @@
 is thrown?
 
-This is the simplist pattern to test as it is a simple matter of entering
+The test is a simple matter of entering
 and leaving a try statement.
 
@@ -74,9 +78,9 @@
 
 \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
 through a re-throw or a conditional-catch.
-Where \CFA uses its condition other languages will have to unconditionally
+Where \CFA uses its condition, other languages must unconditionally
 catch the exception then re-throw if the condition if the condition is false.
 
@@ -86,5 +90,5 @@
 % We could do a Cforall test without the catch all and a new default handler
 % that does a catch all.
-As a point of comparison one of the raise/handle tests (which one?) has
+As a point of comparison, one of the raise/handle tests (which one?) has
 same layout but never catches anything.
 
@@ -100,2 +104,10 @@
 %(I haven't actually figured out how to compare this, probably using something
 %related to -fexceptions.)
+
+
+\section{Resumption Comparison}
+% 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.}
