Changes in / [e3de500:4570131]

Location:

doc/generic_types

Files:

• evaluation/timing.gp (modified) (2 diffs)
• generic_types.tex (modified) (5 diffs)

doc/generic_types/evaluation/timing.gp

@@ -12 +12 @@
 set boxwidth 0.8
 
-set ylabel "milliseconds"
 set key top left reverse Left
 
@@ -21 +20 @@
 set linetype 4 lc rgb 'green'
 
+set ylabel "milli-seconds"
+set yrange [0:*] ;
+
 set datafile separator ","
 plot for [COL=2:5] 'evaluation/timing.csv' using COL:xticlabels(1) title columnheader

doc/generic_types/generic_types.tex

@@ -954 +954 @@
 Since all these languages share a subset comprising most of standard C, maximal-performance benchmarks would show little runtime variance, other than in length and clarity of source code.
 Instead, the presented benchmarks show the costs of idiomatic use of each language's features to examine common usage.
-The benchmarks test a generic stack based on a singly linked-list, a generic pair-data-structure, and a variadic @print@ routine similar to that in Section~\ref{sec:variadic-tuples}.
+Figure~\ref{fig:MicroBenchmark} shows the \CFA benchmark tests for a generic stack based on a singly linked-list, a generic pair-data-structure, and a variadic @print@ routine similar to that in Section~\ref{sec:variadic-tuples}.
+The tests are similar for C and \CC.
+The first two experiments use element types @int@ and @pair( _Bool, char)@, and push $N=40M$ elements on a generic stack, copy the stack, clear one of the stacks, and find the maximum value in the other stack.
+The last experiment creates a file and prints $N=40M$ elements of type @int@ and @pair( _Bool, char)@ using a variadic print.
+
 The structure of each implemented is: C with @void *@-based polymorphism, \CFA with the different presented features, \CC with templates, and \CC using only class inheritance for polymorphism, called \CCV.
 The \CCV variant illustrates an alternative object-oriented idiom where all objects inherit from a base @object@ class, mimicking a Java-like interface;
 hence runtime checks are necessary to safely down-cast objects.
-The most notable difference among the implementations is in memory layout of generic types: \CFA and \CC inline the stack and pair elements into corresponding list and pair nodes, while C and \CCV lack such a capability and store generic objects via pointers to separately-allocated objects instead.
-For the print benchmark, idiomatic printing is used: the C and \CFA variants use @stdio.h@, while the \CC and \CCV variants use @iostream@.
-Preliminary tests show this difference has little runtime effect.
+The most notable difference among the implementations is in optimizations: \CFA and \CC inline the stack and pair elements into corresponding list and pair nodes, while the C and \CCV lack generic-type capability {\color{red}(AWKWARD) to store generic objects via pointers to separately-allocated objects}.
+For the print benchmark, idiomatic printing is used: the C and \CFA variants used @cstdio.h@, while the \CC and \CCV variants used @iostream@.
+Preliminary tests show the difference has little runtime effect.
 Finally, the C @rand@ function is used generate random numbers.
+
+\begin{figure}
+\begin{lstlisting}[xleftmargin=3\parindentlnth,aboveskip=0pt,belowskip=0pt,numbers=left,numberstyle=\tt\small,numberblanklines=false]
+int main( int argc, char *argv[] ) {
+        int max = 0;
+        stack(int) s, t;
+        REPEAT_TIMED( "push_int", push( &s, 42 ); )
+        TIMED( "copy_int", t = s; )
+        TIMED( "clear_int", clear( &s ); )
+        REPEAT_TIMED( "pop_int", max = max( max, pop( &t ) ); )
+
+        stack(pair(_Bool, char)) s1, t1;
+        pair(_Bool, char) max = { (_Bool)0, '\0' };
+        REPEAT_TIMED( "push_pair", push( &s1, (pair(_Bool, char)){ (_Bool)0, 'a' } ); )
+        TIMED( "copy_pair", t1 = s1; )
+        TIMED( "clear_pair", clear( &s1 ); )
+        REPEAT_TIMED( "pop_pair", max = max( max, pop( &t1 ) ); )
+
+        FILE * out = fopen( "cfa-out.txt", "w" );
+        REPEAT_TIMED( "print_int", print( out, 42, ":", 42, "\n" ); )
+        REPEAT_TIMED( "print_pair", print( out, (pair(_Bool, char)){ (_Bool)0, 'a' }, ":",
+                                                         (pair(_Bool, char)){ (_Bool)0, 'a' }, "\n" ); )
+        fclose(out);
+}
+\end{lstlisting}
+\caption{Micro-Benchmark}
+\label{fig:MicroBenchmark}
+\end{figure}
 
 \begin{figure}
@@ -975 +1007 @@
 \newcommand{\CT}[1]{\multicolumn{1}{c}{#1}}
 \begin{tabular}{r|rrrr}
-                                                                        & \CT{C}        & \CT{\CFA}     & \CT{\CC}      &       \CT{\CCV}       \\ \hline
-maximum memory usage (MB)                       & 10001         & 2501          & 2503          &       11253           \\
-source code size (lines)                        & 301           & 224           & 188           &       437                     \\
+                                                        & \CT{C}        & \CT{\CFA}     & \CT{\CC}      &       \CT{\CCV}       \\ \hline
+maximum memory usage (MB)       & 10001         & 2501          & 2503          &       11253           \\
+source code size (lines)        & 301           & 224           & 188           &       437                     \\
 redundant type annotations (lines)      & 46            & 3                     & 2                     &       15                      \\
-binary size (KB)                                        & 18            & 234           & 18            &       42                      \\
+binary size (KB)                        & 18            & 234           & 18            &       42                      \\
 \end{tabular}
 \end{table}
@@ -1051 +1083 @@
 SETL~\cite{SETL} is a high-level mathematical programming language, with tuples being one of the primary data types.
 Tuples in SETL allow subscripting, dynamic expansion, and multiple assignment.
-C provides variadic functions through @va_list@ objects, but the programmer is responsible for managing the number of arguments and their types.
+C provides variadic functions through @va_list@ objects, but the programmer is responsible for managing the number of arguments and their types, so the mechanism is not type-safe.
 KW-C~\cite{Buhr94a}, a predecessor of \CFA, introduced tuples to C as an extension of the C syntax, taking much of its inspiration from SETL.
 The main contributions of that work were adding MRVF, tuple mass and multiple assignment, and record-field access.
@@ -1087 +1119 @@
 
 
+\bibliographystyle{ACM-Reference-Format}
+\bibliography{cfa}
+
+
 \appendix
+
 
 \section{BenchMarks}
@@ -1093 +1130 @@
 
 TODO
-
-
-\bibliographystyle{ACM-Reference-Format}
-\bibliography{cfa}
 
 \end{document}