Changeset bbe856c

Timestamp:

Apr 14, 2017, 5:03:36 PM (8 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

1504536

Parents:

3895b8b5

Message:

more changes to evaluation

File:

• doc/generic_types/generic_types.tex (modified) (3 diffs)

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 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 experiments are:
+\begin{enumerate}
+\item
+N stack pushes of int, where N = 40M
+\item
+copy int stack 
+\item
+clear int stack
+\item
+N stack pops of int
+\end{enumerate}
 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;
@@ -962 +973 @@
 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)) s, t;
+        pair(_Bool, char) max = { (_Bool)0, '\0' };
+        REPEAT_TIMED( "push_pair", push( &s, (pair(_Bool, char)){ 42, 42 } ); )
+        TIMED( "copy_pair", t = s; )
+        TIMED( "clear_pair", clear( &s ); )
+        REPEAT_TIMED( "pop_pair", max = max( max, pop( &t ) ); )
+
+        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)){ 42, 42 }, ":", (pair(_Bool, char)){ 42, 42 }, "\n" ); )
+        fclose(out);
+}
+\end{lstlisting}
+\caption{Micro-Benchmark}
+\label{fig:MicroBenchmark}
+\end{figure}
 
 \begin{figure}
@@ -1050 +1089 @@
 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.