Index: doc/theses/colby_parsons_MMAth/text/actors.tex
===================================================================
--- doc/theses/colby_parsons_MMAth/text/actors.tex	(revision d6d21367960452626d09f23400e280c3999d7428)
+++ doc/theses/colby_parsons_MMAth/text/actors.tex	(revision 60a91645c3269e9d866e778c7c0e98249e2756be)
@@ -1286,5 +1286,5 @@
 
 Two pathological unbalanced cases are created, and compared using vanilla and randomized work stealing in \CFA.
-These benchmarks adversarially takes advantage of the round-robin assignment of actors to workers to load actors only on specific cores (there is one worker per core).
+These benchmarks adversarially takes advantage of the round-robin assignment of actors to workers by loading actors only on specific cores (there is one worker per core).
 The workload on the loaded cores is the same as the executor benchmark described in \ref{s:executorPerf}, but with fewer rounds.
 
@@ -1326,5 +1326,5 @@
 On Intel in Figure~\ref{f:BalanceOneIntel}, above 32 cores the performance gets worse for all variants due to hyperthreading.
 Here, the longest-victim and random heuristic are the same.
-Note, the non-stealing variation of balance-one slows down slightly (no decrease in graph) as the cores increase, since a few "dummy" actors need to be made for each of the extra cores beyond the first to adversarially layout all loaded actors on the first core.
+Note, the non-stealing variation of balance-one slows down slightly (no decrease in graph) as the cores increase, since a few ``dummy'' actors need to be made for each of the extra cores beyond the first to adversarially layout all loaded actors on the first core.
 
 For the balance-multi benchmark in Figures~\ref{f:BalanceMultiAMD} and~\ref{f:BalanceMultiIntel}, the random heuristic outperforms the longest victim.
@@ -1343,4 +1343,5 @@
 	}
 	\caption{Executor benchmark comparing \CFA stealing heuristics (lower is better).}
+	\label{f:ExecutorBenchmark}
 \end{figure}
 
@@ -1359,4 +1360,5 @@
 	}
 	\caption{The repeat benchmark comparing \CFA stealing heuristics (lower is better).}
+	\label{f:RepeatBenchmark}
 \end{figure}
 
@@ -1365,19 +1367,19 @@
 The worst-case scenario is if the actor doing the majority of work or its mail queue is stolen by the work stealing system, as this incurs a huge cost to move the work and refill the local cache.
 This worst-case steal is likely to happen since there is little other work in the system between scatter/gather rounds.
-
-All \CFA variants are comparable in performance on the repeat benchmark.
-This is surprising, since this is a pathological case for work stealing, and one would expect the No-Stealing variant to have better performance.
-It is likely that the \CFA No-Stealing variant may be minorly impacted by other design decisions in the \CFA actor system that were made with work stealing in mind.
-Work stealing performance in the repeat benchmark can be further examined by discussing Figures \ref{f:RepeatAMD} and \ref{f:RepeatIntel}.
-
-In particular, on the Intel machine in Figure~\ref{f:RepeatIntel}, the cost of stealing is higher, which can be seen in the vertical shift of Akka, CAF and \CFA when comparing the AMD results in Figure~\ref{f:RepeatAMD} results in Figure~\ref{f:RepeatIntel} (\uC and ProtoActor do not have work stealing).
+However, all heuristics are comparable in performance on the repeat benchmark.
+This result is surprising especially for the No-Stealing variant, which should have better performance than the stealing variants.
+It is likely the No-Stealing variant is impacted by other design decisions in the \CFA actor system related to work stealing.
+
+Work stealing performance can be further analyzed by reexamining the executor and repeat benchmarks in Figures~\ref{f:ExecutorBenchmark} and \ref{f:RepeatBenchmark}, respectively.
+In both, benchmarks CAF performs poorly.
+It is hypothesized that CAF has an aggressive work stealing algorithm that eagerly attempts to steal.
+This results in the poor performance with small messages containing little work per message in both of these benchmarks.
+In comparison with the other systems, \uC does well on both benchmarks since it does not have work stealing.
+
+\PAB{In particular, on the Intel machine in Figure~\ref{f:RepeatIntel}, the cost of stealing is significantly higher, which can be seen in the vertical shift of Akka, CAF and \CFA compared to the AMD results in Figure~\ref{f:RepeatAMD} (\uC and ProtoActor do not have work stealing).
 The shift for CAF is particularly large, which supports the hypothesis that CAF's work stealing is particularly eager.
-In both the executor and the repeat benchmark CAF performs poorly.
-It is hypothesized that CAF has an aggressive work stealing algorithm, that eagerly attempts to steal.
-This results in poor performance in benchmarks with small messages containing little work per message.
-In comparison with the other systems \uC does well on the repeat benchmark since it does not have work stealing.
 The client of this experiment is long running and maintains a lot of state, as it needs to know the handles of all the servers.
 When stealing the client or its respective queue (in \CFA's inverted model), moving the client incurs a high cost due to cache invalidation.
-As such stealing the client can result in a hit in performance.
+As such stealing the client can result in a hit in performance.}
 
 Finally, Figures~\ref{f:cfaMatrixAMD} and~\ref{f:cfaMatrixIntel} show the effects of the stealing heuristics for the matrix-multiply benchmark.