Changeset b51e389c for doc/theses/andrew_beach_MMath/performance.tex

Timestamp:

Jun 15, 2021, 4:17:05 PM (3 years ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

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

Children:

6071efc

Parents:

2f19e03

Message:

Revert "proofread Andrew's implement, performance and future chapters", changes saved locally.

This reverts commit b6749fdf08185c0beb48a79dbf340a15f5b3b943.

File:

• doc/theses/andrew_beach_MMath/performance.tex (modified) (7 diffs)

doc/theses/andrew_beach_MMath/performance.tex

@@ -6 +6 @@
 
 Performance has been of secondary importance for most of this project.
-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
+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
 amount of time.
-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.
+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.
+
 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.
 
-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.
+% 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.}
 
-\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
+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
 affecting the timing results.
-A consequence is that tests cannot terminate the program, which does limit
+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 tests.
+exceptions from terminating the program.
 
-The exceptions used in this test are always a new exception based off of
-the base exception. This requirement minimizes performance differences based
+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
 on the object model.
-Catch-alls are done by catching the root exception type (not using \Cpp's
+Catch-alls will be done by catching the root exception type (not using \Cpp's
 \code{C++}{catch(...)}).
 
@@ -44 +44 @@
 hot.
 
-\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.
-
+\section{Tests}
 \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,
 
@@ -65 +61 @@
 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 and a @finally@ clause.
+try statement with no handlers except for a finally clause.
 
 \paragraph{Enter/Leave}
@@ -71 +67 @@
 is thrown?
 
-The test is a simple matter of entering
+This is the simplist pattern to test as it is a simple matter of entering
 and leaving a try statement.
 
@@ -78 +74 @@
 
 \paragraph{Re-throw and Conditional-Catch}
-How expensive it is to run a non-exception type check for a handler?
+How expencive 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 must unconditionally
+Where \CFA uses its condition other languages will have to unconditionally
 catch the exception then re-throw if the condition if the condition is false.
 
@@ -90 +86 @@
 % 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.
 
@@ -104 +100 @@
 %(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.}