Changes in doc/papers/general/Paper.tex [d52a55b:aa5fdac]

File:

• doc/papers/general/Paper.tex (modified) (24 diffs)

doc/papers/general/Paper.tex

@@ -228 +228 @@
 Nevertheless, C, first standardized over thirty years ago, lacks many features that make programming in more modern languages safer and more productive.
 
-\CFA (pronounced ``C-for-all'', and written \CFA or Cforall) is an evolutionary extension of the C programming language that adds modern language-features to C, while maintaining both source and runtime compatibility with C and a familiar programming model for programmers.
+\CFA (pronounced ``C-for-all'', and written \CFA or Cforall) is an evolutionary extension of the C programming language that aims to add modern language features to C, while maintaining both source and runtime compatibility with C and a familiar programming model for programmers.
 The four key design goals for \CFA~\cite{Bilson03} are:
 (1) The behaviour of standard C code must remain the same when translated by a \CFA compiler as when translated by a C compiler;
@@ -237 +237 @@
 \CC is used similarly, but has the disadvantages of multiple legacy design-choices that cannot be updated and active divergence of the language model from C, requiring significant effort and training to incrementally add \CC to a C-based project.
 
-All languages features discussed in this paper are working, except some advanced exception-handling features.
-Not discussed in this paper are the integrated concurrency-constructs and user-level threading-library~\cite{Delisle18}.
 \CFA is an \emph{open-source} project implemented as an source-to-source translator from \CFA to the gcc-dialect of C~\cite{GCCExtensions}, allowing it to leverage the portability and code optimizations provided by gcc, meeting goals (1)--(3).
 Ultimately, a compiler is necessary for advanced features and optimal performance.
-% @plg2[9]% cd cfa-cc/src; cloc ArgTweak CodeGen CodeTools Common Concurrency ControlStruct Designators GenPoly InitTweak MakeLibCfa.cc MakeLibCfa.h Parser ResolvExpr SymTab SynTree Tuples driver prelude main.cc 
-% -------------------------------------------------------------------------------
-% Language                     files          blank        comment           code
-% -------------------------------------------------------------------------------
-% C++                            108           5420           5232          34961
-% C/C++ Header                    86           2379           2450           8464
-% Teamcenter def                   2            115             65           1387
-% make                             5            168             87           1052
-% C                               20            109            403            488
-% awk                              1             12             26            121
-% sed                              1              0              0              6
-% -------------------------------------------------------------------------------
-% SUM:                           223           8203           8263          46479
-% -------------------------------------------------------------------------------
-The \CFA translator is 200+ files and 46,000+ lines of code written in C/\CC.
-Starting with a translator versus a compiler makes it easier and faster to generate and debug C object-code rather than intermediate, assembler or machine code.
-The translator design is based on the \emph{visitor pattern}, allowing multiple passes over the abstract code-tree, which works well for incrementally adding new feature through additional visitor passes.
-At the heart of the translator is the type resolver, which handles the polymorphic routine/type overload-resolution.
-% @plg2[8]% cd cfa-cc/src; cloc libcfa
-% -------------------------------------------------------------------------------
-% Language                     files          blank        comment           code
-% -------------------------------------------------------------------------------
-% C                               35           1256           1240           9116
-% C/C++ Header                    54            358           1106           1198
-% make                             2            201            325           1167
-% C++                              3             18             17            124
-% Assembly                         3             56             97            111
-% Bourne Shell                     2              2              0             25
-% awk                              1              4              0             22
-% -------------------------------------------------------------------------------
-% SUM:                           100           1895           2785          11763
-% -------------------------------------------------------------------------------
-The \CFA runtime system is 100+ files and 11,000+ lines of code, written in \CFA.
-Currently, the \CFA runtime is the largest \emph{user} of \CFA providing a vehicle to test the language features and implementation.
-% @plg2[6]% cd cfa-cc/src; cloc tests examples benchmark
-% -------------------------------------------------------------------------------
-% Language                     files          blank        comment           code
-% -------------------------------------------------------------------------------
-% C                              237          12260           2869          23286
-% make                             8            464            245           2838
-% C/C++ Header                    22            225            175            785
-% Python                           5            131             93            420
-% C++                             10             48              5            201
-% Lua                              2             31              4            126
-% Java                             4              5              0             80
-% Go                               2             11              9             40
-% -------------------------------------------------------------------------------
-% SUM:                           290          13175           3400          27776
-% -------------------------------------------------------------------------------
-The \CFA tests are 290+ files and 27,000+ lines of code.
-The tests illustrate syntactic and semantic features in \CFA, plus a growing number of runtime benchmarks.
-The tests check for correctness and are used for daily regression testing of commits (3800+).
+All features discussed in this paper are working, unless otherwise stated as under construction.
 
 Finally, it is impossible to describe a programming language without usages before definitions.
@@ -313 +260 @@
 There are only two hard things in Computer Science: cache invalidation and \emph{naming things} -- Phil Karlton
 \end{quote}
-\vspace{-10pt}
 C already has a limited form of ad-hoc polymorphism in the form of its basic arithmetic operators, which apply to a variety of different types using identical syntax. 
 \CFA extends the built-in operator overloading by allowing users to define overloads for any function, not just operators, and even any variable;
@@ -408 +354 @@
 
 \CFA has replacement libraries condensing hundreds of existing C functions into tens of \CFA overloaded functions, all without rewriting the actual computations (see Section~\ref{sec:libraries}).
-For example, it is possible to write a type-safe \CFA wrapper @malloc@ based on the C @malloc@, where the return type supplies the type/size of the allocation, which is impossible in most type systems.
+For example, it is possible to write a type-safe \CFA wrapper @malloc@ based on the C @malloc@:
 \begin{cfa}
 forall( dtype T | sized(T) ) T * malloc( void ) { return (T *)malloc( sizeof(T) ); }
-// select type and size from left-hand side
-int * ip = malloc();  double * dp = malloc();  struct S {...} * sp = malloc();
-\end{cfa}
+int * ip = malloc();                                            $\C{// select type and size from left-hand side}$
+double * dp = malloc();
+struct S {...} * sp = malloc();
+\end{cfa}
+where the return type supplies the type/size of the allocation, which is impossible in most type systems.
 
 Call-site inferencing and nested functions provide a localized form of inheritance.
@@ -425 +373 @@
 }
 \end{cfa}
-The local version of @?<?@ performs @?>?@ overriding the built-in @?<?@ so it is passed to @qsort@.
+Within the block, the nested version of @?<?@ performs @?>?@ and this local version overrides the built-in @?<?@ so it is passed to @qsort@.
 Hence, programmers can easily form local environments, adding and modifying appropriate functions, to maximize reuse of other existing functions and types.
 
@@ -434 +382 @@
         inline {                                                                        $\C{// nested distribution block, add forall/inline to declarations}$
                 void push( stack(`T`) & s, `T` value ) ...      $\C{// generic operations}$
+                T pop( stack(`T`) & s ) ...
         }
 }
@@ -439 +388 @@
 
 
-\vspace*{-2pt}
 \subsection{Traits}
 
 \CFA provides \newterm{traits} to name a group of type assertions, where the trait name allows specifying the same set of assertions in multiple locations, preventing repetition mistakes at each function declaration:
-
 \begin{cquote}
 \lstDeleteShortInline@%
@@ -515 +462 @@
 
 
-\vspace*{-2pt}
 \section{Generic Types}
 
@@ -528 +474 @@
 
 \CC, Java, and other languages use \newterm{generic types} to produce type-safe abstract data-types.
-\CFA generic types integrate efficiently and naturally with the existing polymorphic functions, while retaining backwards compatibility with C and providing separate compilation.
+\CFA also implements generic types that integrate efficiently and naturally with the existing polymorphic functions, while retaining backwards compatibility with C and providing separate compilation.
 However, for known concrete parameters, the generic-type definition can be inlined, like \CC templates.
 
@@ -534 +480 @@
 \begin{cquote}
 \lstDeleteShortInline@%
-\begin{tabular}{@{}l|@{\hspace{2\parindentlnth}}l@{}}
+\begin{tabular}{@{}l@{\hspace{2\parindentlnth}}l@{}}
 \begin{cfa}
 forall( otype R, otype S ) struct pair {
@@ -1427 +1373 @@
 resume( $\emph{alternate-stack}$ )
 \end{cfa}
-These overloads of @resume@ raise the specified exception or the currently propagating exception (reresume) at another \CFA coroutine or task~\cite{Delisle18}.
+These overloads of @resume@ raise the specified exception or the currently propagating exception (reresume) at another \CFA coroutine or task\footnote{\CFA coroutine and concurrency features are discussed in a separately submitted paper.}~\cite{Delisle18}.
 Nonlocal raise is restricted to resumption to provide the exception handler the greatest flexibility because processing the exception does not unwind its stack, allowing it to continue after the handler returns.
 
@@ -2094 +2040 @@
 
 
-\begin{comment}
 \subsection{Integral Suffixes}
 
@@ -2128 +2073 @@
 \lstMakeShortInline@%
 \end{cquote}
-\end{comment}
 
 
@@ -2700 +2644 @@
 Figure~\ref{fig:eval} and Table~\ref{tab:eval} show the results of running the benchmark in Figure~\ref{fig:BenchmarkTest} and its C, \CC, and \CCV equivalents.
 The graph plots the median of 5 consecutive runs of each program, with an initial warm-up run omitted.
-All code is compiled at \texttt{-O2} by gcc or g++ 6.4.0, with all \CC code compiled as \CCfourteen.
+All code is compiled at \texttt{-O2} by gcc or g++ 6.3.0, with all \CC code compiled as \CCfourteen.
 The benchmarks are run on an Ubuntu 16.04 workstation with 16 GB of RAM and a 6-core AMD FX-6300 CPU with 3.5 GHz maximum clock frequency.
 
@@ -2718 +2662 @@
                                                                         & \CT{C}        & \CT{\CFA}     & \CT{\CC}      & \CT{\CCV}             \\ \hline
 maximum memory usage (MB)                       & 10,001        & 2,502         & 2,503         & 11,253                \\
-source code size (lines)                        & 201           & 191           & 125           & 294                   \\
+source code size (lines)                        & 196           & 186           & 125           & 290                   \\
 redundant type annotations (lines)      & 27            & 0                     & 2                     & 16                    \\
 binary size (KB)                                        & 14            & 257           & 14            & 37                    \\
@@ -2821 +2765 @@
 data-parallel features have not yet been added to \CFA, but are easily incorporated within its design, while concurrency primitives similar to those in $\mu$\CC have already been added~\cite{Delisle18}.
 Finally, CCured~\cite{Necula02} and Ironclad \CC~\cite{DeLozier13} attempt to provide a more memory-safe C by annotating pointer types with garbage collection information; type-checked polymorphism in \CFA covers several of C's memory-safety issues, but more aggressive approaches such as annotating all pointer types with their nullability or requiring runtime garbage collection are contradictory to \CFA's backwards compatibility goals.
+
+
+\begin{comment}
+\subsection{Control Structures / Declarations / Literals}
+
+Java has default fall through like C/\CC.
+Pascal/Ada/Go/Rust do not have default fall through.
+\Csharp does not have fall through but still requires a break.
+Python uses dictionary mapping. \\
+\CFA choose is like Rust match.
+
+Java has labelled break/continue. \\
+Languages with and without exception handling.
+
+Alternative C declarations. \\
+Different references \\
+Constructors/destructors
+
+0/1 Literals \\
+user defined: D, Objective-C
+\end{comment}
 
 
@@ -2910 +2875 @@
 }
 _Bool stack_empty( const stack * s ) {
-        return s->head == NULL;
+         return s->head == NULL;
 }
 void push_stack( stack * s, void * v ) {
-        node * n = malloc( sizeof(node) ); /***/
+        node * n = malloc(sizeof(node)); /***/
         *n = (node){ v, s->head }; /***/
         s->head = n;
@@ -2943 +2908 @@
         };
         struct stack { node(T) * head; };
-        void ?{}( stack(T) & s, stack(T) t ) { // copy
+        void ?{}( stack(T) & s ) { (s.head){ 0 }; }
+        void ?{}( stack(T) & s, stack(T) t ) {
                 node(T) ** cr = &s.head;
                 for ( node(T) * nx = t.head; nx; nx = nx->next ) {
@@ -2957 +2923 @@
                         nx = cr->next;
                         ^(*cr){};
-                        free( cr );
+                        free(cr);
                 }
                 head = 0;
         }
-
 \end{cfa}
 &
 \begin{cfa}[xleftmargin=0pt,aboveskip=0pt,belowskip=0pt]
-        void ?{}( stack(T) & s ) { (s.head){ 0 }; }
         void ^?{}( stack(T) & s) { clear( s ); }
         stack(T) ?=?( stack(T) & s, stack(T) t ) {
@@ -2990 +2954 @@
         }
 }
+
 \end{cfa}
 \end{tabular}
@@ -3038 +3003 @@
                 return *this;
         }
-        bool empty() const {
-                return head == nullptr;
-        }
+        bool empty() const { return head == nullptr; }
         void push( const T & value ) {
                 head = new node{ value, head };  /***/
@@ -3052 +3015 @@
         }
 };
+
+
 
 \end{cfa}
@@ -3101 +3066 @@
                 return *this;
         }
-        bool empty() const {
-                return head == nullptr;
-        }
+        bool empty() const { return head == nullptr; }
         void push( const object & value ) {
                 head = new node{ value, head }; /***/
@@ -3116 +3079 @@
 };
 
+
+
 \end{cfa}
 \end{tabular}