Context Navigation

-                      rbb85f76
+                      ra7d93cb
 @strcat@, @strncat@             & @+@                                   & @+@               & @+@       \\
 @strcmp@, @strncmp@             & @==@, @!=@, @<@, @<=@, @>@, @>=@
+                                                & @equals@, @compareTo@
+                                                                                                                    & @==@, @!=@, @<@, @<=@, @>@, @>=@ \\
+                                                & @equals@, @compareTo@  & @==@, @!=@, @<@, @<=@, @>@, @>=@ \\
 @strlen@                                & @length@, @size@              & @length@                      & @size@        \\
 @[ ]@                                   & @[ ]@                                 & @charAt@          & @[ ]@     \\
 …
 \begin{figure}
 \includegraphics{memmgr-basic}
+\includegraphics{memmgr-basic.pdf}
 \caption{String memory-management data structures}
 \label{f:memmgr-basic}
 …
 The \emph{append} tests use the varying-from-1 corpus construction, \ie they do not assume away the STL's advantage for small-string optimization.
 \PAB{To discuss: any other case variables introduced in the performance intro}
 Figure \ref{fig:string-graph-peq-cppemu} shows this behaviour, by the STL and by \CFA in STL emulation mode.
+\VRef[Figure]{fig:string-graph-peq-cppemu} shows this behaviour, by the STL and by \CFA in STL emulation mode.
 \CFA reproduces STL's performance, up to a 15\% penalty averaged over the cases shown, diminishing with larger strings, and 50\% in the worst case.
 This penalty characterizes the amount of implementation fine tuning done with STL and not done with \CFA in present state.
 The larger inherent penalty, for a user mismanaging reuse, is 40\% averaged over the cases shown, is minimally 24\%, shows up consistently between the STL and \CFA implementations, and increases with larger strings.
-\PAB{Most of your graphs are unreadable. gnuplot is a good tool for generating high quality graphs.}
 \begin{figure}
+        \includegraphics[width=\textwidth]{string-graph-peq-cppemu.png}
+        \caption{Average time per iteration with one \lstinline{x += y} invocation, comparing \CFA with STL implementations (given \CFA running in STL emulation mode), and comparing the ``fresh'' with ``reused'' reset styles, at various string sizes.}
+\centering
+        \includegraphics{string-graph-peq-cppemu.pdf}
+%       \includegraphics[width=\textwidth]{string-graph-peq-cppemu.png}
+        \caption{Average time per iteration (lower is better) with one \lstinline{x += y} invocation, comparing \CFA with STL implementations (given \CFA running in STL emulation mode), and comparing the ``fresh'' with ``reused'' reset styles, at various string sizes.}
         \label{fig:string-graph-peq-cppemu}
 \end{figure}
 \begin{figure}
+        \includegraphics[width=\textwidth]{string-graph-peq-sharing.png}
+        \caption{Average time per iteration with one \lstinline{x += y} invocation, comparing \CFA (having implicit sharing activated) with STL, and comparing the ``fresh'' with ``reused'' reset styles, at various string sizes.}
+\centering
+        \includegraphics{string-graph-peq-sharing.pdf}
+%       \includegraphics[width=\textwidth]{string-graph-peq-sharing.png}
+        \caption{Average time per iteration (lower is better) with one \lstinline{x += y} invocation, comparing \CFA (having implicit sharing activated) with STL, and comparing the ``fresh'' with ``reused'' reset styles, at various string sizes.}
         \label{fig:string-graph-peq-sharing}
 \end{figure}
 In sharing mode, \CFA makes the fresh/reuse difference disappear, as shown in Figure \ref{fig:string-graph-peq-sharing}.
+In sharing mode, \CFA makes the fresh/reuse difference disappear, as shown in \VRef[Figure]{fig:string-graph-peq-sharing}.
 At append lengths 5 and above, \CFA not only splits the two baseline STL cases, but its slowdown of 16\% over (STL with user-managed reuse) is close to the \CFA-v-STL implementation difference seen with \CFA in STL-emulation mode.
 \begin{figure}
+        \includegraphics[width=\textwidth]{string-graph-pta-sharing.png}
+        \caption{Average time per iteration with one \lstinline{x = x + y} invocation (new, purple bands), comparing \CFA (having implicit sharing activated) with STL.
+For context, the results from Figure \ref{fig:string-graph-peq-sharing} are repeated as the bottom bands.
+\centering
+        \includegraphics{string-graph-pta-sharing.pdf}
+%       \includegraphics[width=\textwidth]{string-graph-pta-sharing.png}
+        \caption{Average time per iteration (lower is better) with one \lstinline{x = x + y} invocation (new, purple bands), comparing \CFA (having implicit sharing activated) with STL.
+For context, the results from \VRef[Figure]{fig:string-graph-peq-sharing} are repeated as the bottom bands.
 While not a design goal, and not graphed out, \CFA in STL-emulation mode outperformed STL in this case; user-managed allocation reuse did not affect any of the implementations in this case.}
         \label{fig:string-graph-pta-sharing}
 \end{figure}
 When the user takes a further step beyond the STL's optimal zone, by running @x = x + y@, as in Figure \ref{fig:string-graph-pta-sharing}, the STL's penalty is above $15 \times$ while \CFA's (with sharing) is under $2 \times$, averaged across the cases shown here.
+When the user takes a further step beyond the STL's optimal zone, by running @x = x + y@, as in \VRef[Figure]{fig:string-graph-pta-sharing}, the STL's penalty is above $15 \times$ while \CFA's (with sharing) is under $2 \times$, averaged across the cases shown here.
 Moreover, the STL's gap increases with string size, while \CFA's converges.
 \subsubsection{Test: Pass argument}
 …
 \begin{figure}
+        \includegraphics[width=\textwidth]{string-graph-pbv.png}
+        \caption{Average time per iteration with one call to a function that takes a by-value string argument, comparing \CFA (having implicit sharing activated) with STL.
+\centering
+        \includegraphics{string-graph-pbv.pdf}
+%       \includegraphics[width=\textwidth]{string-graph-pbv.png}
+        \caption{Average time per iteration (lower is better) with one call to a function that takes a by-value string argument, comparing \CFA (having implicit sharing activated) with STL.
 (a) With \emph{Varying-from-1} corpus construction, in which the STL-only benefit of small-string optimization occurs, in varying degrees, at all string sizes.
 (b) With \emph{Fixed-size} corpus construction, in which this benefit applies exactly to strings with length below 16.
 …
 \end{figure}
 Figure \ref{fig:string-graph-pbv} shows the costs for calling a function that receives a string argument by value.
+\VRef[Figure]{fig:string-graph-pbv} shows the costs for calling a function that receives a string argument by value.
 STL's performance worsens as string length increases, while \CFA has the same performance at all sizes.
 …
 \begin{figure}
+\centering
   \includegraphics[width=\textwidth]{string-graph-allocn.png}
   \caption{Space and time performance, under varying fraction-live targets, for the five string lengths shown, at (\emph{Fixed-size} corpus construction.
 …
 \end{figure}
 Figure \ref{fig:string-graph-allocn} shows the results of this experiment.
+\VRef[Figure]{fig:string-graph-allocn} shows the results of this experiment.
 At all string sizes, varying the liveness threshold gives offers speed-for-space tradeoffs relative to STL.
 At the default liveness threshold, all measured string sizes see a ??\%--??\% speedup for a ??\%--??\% increase in memory footprint.

Note: See TracChangeset for help on using the changeset viewer.

Context Navigation

Changeset a7d93cb for doc/theses/mike_brooks_MMath/string.tex

Legend:

TabularUnified doc/theses/mike_brooks_MMath/string.tex ¶

Download in other formats: