Changeset 39c4dac
- Timestamp:
- Aug 20, 2018, 1:30:29 PM (6 years ago)
- 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, no_list, persistent-indexer, pthread-emulation, qualifiedEnum
- Children:
- 51a455c
- Parents:
- 550e819 (diff), 69efc321 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the(diff)
links above to see all the changes relative to each parent. - Files:
-
- 1 added
- 6 edited
Legend:
- Unmodified
- Added
- Removed
-
doc/bibliography/pl.bib
r550e819 r39c4dac 929 929 title = {\textsf{C}$\mathbf{\forall}$ Stack Evaluation Programs}, 930 930 year = 2018, 931 howpublished= {\href{https://cforall.uwaterloo.ca/CFAStackEvaluation.zip}{ \textcolor{blue}{Q4: https://cforall.uwaterloo.ca/\-CFAStackEvaluation.zip}}},931 howpublished= {\href{https://cforall.uwaterloo.ca/CFAStackEvaluation.zip}{https://cforall.uwaterloo.ca/\-CFAStackEvaluation.zip}}, 932 932 optnote = {[Accessed May 2018]}, 933 933 } -
doc/papers/general/Paper.tex
r550e819 r39c4dac 196 196 \author[1]{Robert Schluntz} 197 197 \author[1]{Peter A. Buhr} 198 \author[]{\textcolor{blue}{Q1 AUTHOR NAMES CORRECT}}199 198 \authormark{MOSS \textsc{et al}} 200 199 … … 208 207 The C programming language is a foundational technology for modern computing with millions of lines of code implementing everything from hobby projects to commercial operating systems. 209 208 This installation base and the programmers producing it represent a massive software engineering investment spanning decades and likely to continue for decades more. 210 Nevertheless, C, which was first standardized almost 30 \textcolor{blue}{CHANGE ``40'' TO ``30''}years ago, lacks many features that make programming in more modern languages safer and more productive.209 Nevertheless, C, which was first standardized almost 30 years ago, lacks many features that make programming in more modern languages safer and more productive. 211 210 The goal of the \CFA project (pronounced ``C for all'') is to create an extension of C that provides modern safety and productivity features while still ensuring strong backward compatibility with C and its programmers. 212 211 Prior projects have attempted similar goals but failed to honor the C programming style; … … 226 225 227 226 227 \vspace*{-10pt} 228 228 \section{Introduction} 229 229 230 230 The C programming language is a foundational technology for modern computing with millions of lines of code implementing everything from hobby projects to commercial operating systems. 231 231 This installation base and the programmers producing it represent a massive software engineering investment spanning decades and likely to continue for decades more. 232 The TIOBE index~\cite{TIOBE} \textcolor{blue}{CHANGE ``TIOBE'' TO ``The TIOBE index''}ranks the top five most \emph{popular} programming languages as Java 15\%, \Textbf{C 12\%}, \Textbf{\CC 5.5\%}, and Python 5\%, \Csharp 4.5\% = 42\%, where the next 50 languages are less than 4\% each with a long tail.232 The TIOBE index~\cite{TIOBE} ranks the top five most \emph{popular} programming languages as Java 15\%, \Textbf{C 12\%}, \Textbf{\CC 5.5\%}, and Python 5\%, \Csharp 4.5\% = 42\%, where the next 50 languages are less than 4\% each with a long tail. 233 233 The top three rankings over the past 30 years are as follows. 234 \newpage235 \textcolor{blue}{MOVE TABLE HERE}236 234 \begin{center} 237 235 \setlength{\tabcolsep}{10pt} … … 246 244 \lstMakeShortInline@% 247 245 \end{center} 248 249 246 Love it or hate it, C is extremely popular, highly used, and one of the few systems languages. 250 247 In many cases, \CC is often used solely as a better C. 251 Nevertheless, C, which was first standardized almost 30 \textcolor{blue}{CHANGE ``40'' TO ``30''}years ago~\cite{ANSI89:C}, lacks many features that make programming in more modern languages safer and more productive.248 Nevertheless, C, which was first standardized almost 30 years ago~\cite{ANSI89:C}, lacks many features that make programming in more modern languages safer and more productive. 252 249 253 250 \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 source and runtime compatibility in the familiar C programming model. … … 281 278 ultimately, a compiler is necessary for advanced features and optimal performance. 282 279 % 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. 283 Two key translator components are expression analysis, determining expression validity and what operations are required for its implementation, and code generation, dealing with multiple forms of overloading, polymorphism, and multiple return values by converting them into C code for a C compiler that supports none of these features.280 Two key translator components are expression analysis, determining expression validity and what operations are required for its implementation, and code generation, dealing with multiple forms of overloading, polymorphism, and multiple return values by converting them into the C code for a C compiler that supports none of these features. 284 281 Details of these components are available in chapters 2 and 3 in the work of Bilson~\cite{Bilson03} and form the base for the current \CFA translator. 285 282 % @plg2[8]% cd cfa-cc/src; cloc libcfa … … 345 342 Section~\ref{sec:libraries} includes a number of examples of how this overloading simplifies \CFA programming relative to C. 346 343 Code generation for these overloaded functions and variables is implemented by the usual approach of mangling the identifier names to include a representation of their type, while \CFA decides which overload to apply based on the same ``usual arithmetic conversions'' used in C to disambiguate operator overloads. 347 \textcolor{blue}{REMOVE ``We have the following as an example''} 344 348 345 \newpage 349 \textcolor{blue}{UPDATE FOLLOWING PROGRAM EXAMPLE WITH ADJUSTED COMMENTS TO FIT PAGE WIDTH.}350 346 \begin{cfa} 351 347 int max = 2147483647; $\C[4in]{// (1)}$ … … 362 358 In some cases, hundreds of names can be reduced to tens, resulting in a significant cognitive reduction. 363 359 In the above, the name @max@ has a consistent meaning, and a programmer only needs to remember the single concept: maximum. 364 To prevent significant ambiguities, \CFA uses the return type in selecting overloads, \eg in the assignment to @m@, the compiler use @m@'s type to unambiguously select the most appropriate call to function @max@ (as does Ada).360 To prevent significant ambiguities, \CFA uses the return type in selecting overloads, \eg in the assignment to @m@, the compiler uses @m@'s type to unambiguously select the most appropriate call to function @max@ (as does Ada). 365 361 As is shown later, there are a number of situations where \CFA takes advantage of available type information to disambiguate, where other programming languages generate ambiguities. 366 362 … … 380 376 \label{sec:poly-fns} 381 377 382 The signature feature of \CFA is parametric-polymorphic functions~\cite{forceone:impl,Cormack90,Duggan96} with functions generalized using a @forall@ clause (giving the language its name). \textcolor{blue}{REMOVE ``as follows''}378 The signature feature of \CFA is parametric-polymorphic functions~\cite{forceone:impl,Cormack90,Duggan96} with functions generalized using a @forall@ clause (giving the language its name). 383 379 \begin{cfa} 384 380 `forall( otype T )` T identity( T val ) { return val; } … … 395 391 396 392 Since bare polymorphic types provide a restricted set of available operations, \CFA provides a \newterm{type assertion}~\cite[pp.~37-44]{Alphard} mechanism to provide further type information, where type assertions may be variable or function declarations that depend on a polymorphic type variable. 397 For example, the function @twice@ can be defined using the \CFA syntax for operator overloading. \textcolor{blue}{REMOVE ``as follows''}393 For example, the function @twice@ can be defined using the \CFA syntax for operator overloading. 398 394 \begin{cfa} 399 395 forall( otype T `| { T ?+?(T, T); }` ) T twice( T x ) { return x `+` x; } $\C{// ? denotes operands}$ … … 409 405 Crucial to the design of a new programming language are the libraries to access thousands of external software features. 410 406 Like \CC, \CFA inherits a massive compatible library base, where other programming languages must rewrite or provide fragile interlanguage communication with C. 411 A simple example is leveraging the existing type-unsafe (@void *@) C @bsearch@ to binary search a sorted float array. \textcolor{blue}{REMOVE ``as follows''}407 A simple example is leveraging the existing type-unsafe (@void *@) C @bsearch@ to binary search a sorted float array. 412 408 \begin{cfa} 413 409 void * bsearch( const void * key, const void * base, size_t nmemb, size_t size, … … 605 601 To enable interoperation among equivalent instantiations of a generic type, the translator saves the set of instantiations currently in scope and reuses the generated structure declarations where appropriate. 606 602 A function declaration that accepts or returns a concrete generic type produces a declaration for the instantiated structure in the same scope, which all callers may reuse. 607 For example, the concrete instantiation for @pair( const char *, int )@ is \textcolor{blue}{REMOVE ``as follows.''}603 For example, the concrete instantiation for @pair( const char *, int )@ is 608 604 \begin{cfa} 609 605 struct _pair_conc0 { … … 634 630 If a dynamic generic type is declared to be passed or returned by value from a polymorphic function, the translator can safely assume that the generic type is complete (\ie has a known layout) at any call site, and the offset array is passed from the caller; 635 631 if the generic type is concrete at the call site, the elements of this offset array can even be statically generated using the C @offsetof@ macro. 636 As an example, the body of the second @value@ function is implemented as \textcolor{blue}{REMOVE ``follows.''}632 As an example, the body of the second @value@ function is implemented as 637 633 \begin{cfa} 638 634 _assign_T( _retval, p + _offsetof_pair[1] ); $\C{// return *p.second}$ … … 640 636 \newpage 641 637 \noindent 642 \textcolor{blue}{NO PARAGRAPH INDENT}Here, @_assign_T@ is passed in as an implicit parameter from @otype T@, and takes two @T *@ (@void *@ in the generated code), a destination and a source, and @_retval@ is the pointer to a caller-allocated buffer for the return value, the usual \CFA method to handle dynamically sized return types.638 Here, @_assign_T@ is passed in as an implicit parameter from @otype T@, and takes two @T *@ (@void *@ in the generated code), a destination and a source, and @_retval@ is the pointer to a caller-allocated buffer for the return value, the usual \CFA method to handle dynamically sized return types. 643 639 @_offsetof_pair@ is the offset array passed into @value@; 644 this array is generated at the call site as \textcolor{blue}{REMOVE ``follows.''}640 this array is generated at the call site as 645 641 \begin{cfa} 646 642 size_t _offsetof_pair[] = { offsetof( _pair_conc0, first ), offsetof( _pair_conc0, second ) } … … 677 673 678 674 Another useful pattern enabled by reused dtype-static type instantiations is zero-cost \newterm{tag structures}. 679 Sometimes, information is only used for type checking and can be omitted at runtime. \textcolor{blue}{REMOVE ``As an example, we have the following''}675 Sometimes, information is only used for type checking and can be omitted at runtime. 680 676 \begin{cquote} 681 677 \lstDeleteShortInline@% … … 724 720 Both approaches are awkward. 725 721 % FIX 726 Alternatively, a programming language can directly support returning multiple values, \eg \CFA provides the following. \textcolor{blue}{REPLACE ``in \CFA, we have the following'' WITH ``\CFA provides the following''}722 Alternatively, a programming language can directly support returning multiple values, \eg \CFA provides the following. 727 723 \begin{cfa} 728 724 [ int, int ] div( int num, int den ); $\C{// return two integers}$ … … 745 741 As such, \CFA allows assigning multiple values from a function into multiple variables, using a square-bracketed list of lvalue expressions (as above), called a \newterm{tuple}. 746 742 747 However, functions also use \newterm{composition} (nested calls), with the direct consequence that MRVFs must also support composition to be orthogonal with single-returning-value functions (SRVFs), \eg, \CFA provides the following. \textcolor{blue}{REPLACE ``As an example, we have the following'' WITH ``\CFA provides the following''}743 However, functions also use \newterm{composition} (nested calls), with the direct consequence that MRVFs must also support composition to be orthogonal with single-returning-value functions (SRVFs), \eg, \CFA provides the following. 748 744 \begin{cfa} 749 745 printf( "%d %d\n", div( 13, 5 ) ); $\C{// return values seperated into arguments}$ … … 781 777 printf( "%d %d\n", qr ); 782 778 \end{cfa} 783 \CFA also supports \newterm{tuple indexing} to access single components of a tuple expression. \textcolor{blue}{REMOVE ``as follows''}779 \CFA also supports \newterm{tuple indexing} to access single components of a tuple expression. 784 780 \begin{cfa} 785 781 [int, int] * p = &qr; $\C{// tuple pointer}$ … … 809 805 In the call to @f@, @x@ is implicitly flattened so the components of @x@ are passed as two arguments. 810 806 In the call to @g@, the values @y@ and @10@ are structured into a single argument of type @[int, int]@ to match the parameter type of @g@. 811 Finally, in the call to @h@, @x@ is flattened to yield an argument list of length 3, of which the first component of @x@ is passed as the first parameter of @h@, and the second component \textcolor{blue}{CHANGE ``components'' TO ``component''}of @x@ and @y@ are structured into the second argument of type @[int, int]@.812 The flexible structure of tuples permits a simple and expressive function call syntax to work seamlessly with both SRVFs and MRVFs \textcolor{blue}{REMOVE ``and''}with any number of arguments of arbitrarily complex structure.807 Finally, in the call to @h@, @x@ is flattened to yield an argument list of length 3, of which the first component of @x@ is passed as the first parameter of @h@, and the second component of @x@ and @y@ are structured into the second argument of type @[int, int]@. 808 The flexible structure of tuples permits a simple and expressive function call syntax to work seamlessly with both SRVFs and MRVFs with any number of arguments of arbitrarily complex structure. 813 809 814 810 815 811 \subsection{Tuple assignment} 816 812 813 \enlargethispage{-10pt} 817 814 An assignment where the left side is a tuple type is called \newterm{tuple assignment}. 818 815 There are two kinds of tuple assignment depending on whether the right side of the assignment operator has a tuple type or a nontuple type, called \newterm{multiple} and \newterm{mass assignment}, respectively. … … 828 825 Both kinds of tuple assignment have parallel semantics, so that each value on the left and right sides is evaluated before any assignments occur. 829 826 As a result, it is possible to swap the values in two variables without explicitly creating any temporary variables or calling a function, \eg, @[x, y] = [y, x]@. 830 This semantics means mass assignment differs from C cascading 831 \newpage 832 assignment (\eg @a = b = c@) in that conversions are applied in each individual assignment, which prevents data loss from the chain of conversions that can happen during a cascading assignment. 827 This semantics means mass assignment differs from C cascading assignment (\eg @a = b = c@) in that conversions are applied in each individual assignment, which prevents data loss from the chain of conversions that can happen during a cascading assignment. 833 828 For example, @[y, x] = 3.14@ performs the assignments @y = 3.14@ and @x = 3.14@, yielding @y == 3.14@ and @x == 3@, whereas C cascading assignment @y = x = 3.14@ performs the assignments @x = 3.14@ and @y = x@, yielding @3@ in @y@ and @x@. 834 829 Finally, tuple assignment is an expression where the result type is the type of the left-hand side of the assignment, just like all other assignment expressions in C. … … 857 852 [int, int, int] y = x.[2, 0, 2]; $\C{// duplicate: [y.0, y.1, y.2] = [x.2, x.0.x.2]}$ 858 853 \end{cfa} 859 It is also possible for a member access to contain other member accesses. \textcolor{blue}{REMOVE ``, as follows.''}854 It is also possible for a member access to contain other member accesses. 860 855 \begin{cfa} 861 856 struct A { double i; int j; }; … … 969 964 Since nothing is known about a parameter pack by default, assertion parameters are key to doing anything meaningful. 970 965 Unlike variadic templates, @ttype@ polymorphic functions can be separately compiled. 971 For example, the following is a \textcolor{blue}{CHANGE ``As an example, we have the following'' TO ``For example, the following is a''}generalized @sum@ function.966 For example, the following is a generalized @sum@ function. 972 967 \begin{cfa} 973 968 int sum$\(_0\)$() { return 0; } … … 1003 998 Unlike C variadic functions, it is unnecessary to hard code the number and expected types. 1004 999 Furthermore, this code is extendable for any user-defined type with a @?+?@ operator. 1005 Summing \textcolor{blue}{REMOVE ``up''}arbitrary heterogeneous lists is possible with similar code by adding the appropriate type variables and addition operators.1000 Summing arbitrary heterogeneous lists is possible with similar code by adding the appropriate type variables and addition operators. 1006 1001 1007 1002 It is also possible to write a type-safe variadic print function to replace @printf@: … … 1039 1034 Tuples are implemented in the \CFA translator via a transformation into \newterm{generic types}. 1040 1035 For each $N$, the first time an $N$-tuple is seen in a scope, a generic type with $N$ type parameters is generated. 1041 For example, the following \textcolor{blue}{CHANGE ``, as follows:'' TO ``For example, the following''}1036 For example, the following 1042 1037 \begin{cfa} 1043 1038 [int, int] f() { … … 1519 1514 \end{cfa} 1520 1515 1521 \textcolor{blue}{PARAGRAPH INDENT}Finally, \CFA provides a Java-like @finally@ clause after the catch clauses.1516 Finally, \CFA provides a Java-like @finally@ clause after the catch clauses. 1522 1517 \begin{cfa} 1523 1518 try { … … 1655 1650 1656 1651 C declaration syntax is notoriously confusing and error prone. 1657 For example, many C programmers are confused by a declaration as simple as the following. \textcolor{blue}{CHANGE ``simple a declaration as in'' TO ``declaration as simple as''}1652 For example, many C programmers are confused by a declaration as simple as the following. 1658 1653 \begin{cquote} 1659 1654 \lstDeleteShortInline@% … … 1709 1704 % Specifically, the character @*@ is used to indicate a pointer, square brackets @[@\,@]@ are used to represent an array or function return value, and parentheses @()@ are used to indicate a function parameter. 1710 1705 However, unlike C, \CFA type declaration tokens are distributed across all variables in the declaration list. 1711 For instance, variables @x@ and @y@ of type pointer to integer are defined in \CFA as \textcolor{blue}{REMOVE ``follows.''}1706 For instance, variables @x@ and @y@ of type pointer to integer are defined in \CFA as 1712 1707 \begin{cquote} 1713 1708 \lstDeleteShortInline@% … … 1959 1954 Since \CFA in not object oriented, adopting dynamic scoping does not make sense; 1960 1955 instead, \CFA adopts \CC static nesting, using the member-selection operator ``@.@'' for type qualification, as does Java, rather than the \CC type-selection operator ``@::@'' (see Figure~\ref{f:TypeNestingQualification}). 1956 In the C left example, types @C@, @U@ and @T@ are implicitly hoisted outside of type @S@ into the containing block scope. 1957 In the \CFA right example, the types are not hoisted and accessible. 1961 1958 1962 1959 \begin{figure} … … 2028 2025 \vspace*{-8pt} 2029 2026 \end{figure} 2030 2031 In the C left example, types @C@, @U@ and @T@ are implicitly hoisted outside of type @S@ into the containing block scope.2032 In the \CFA right example, the types are not hoisted and accessible.2033 2027 2034 2028 … … 2066 2060 For details of the code-generation placement of implicit constructor and destructor calls among complex executable statements, see section~2.2 in the work of Schlintz~\cite{Schluntz17}. 2067 2061 2068 \CFA also provides syntax for \newterm{initialization} and \newterm{copy}. \textcolor{blue}{REMOVE ``, as follows''}2062 \CFA also provides syntax for \newterm{initialization} and \newterm{copy}. 2069 2063 \begin{cfa} 2070 2064 void ?{}( VLA & vla, int size, char fill = '\0' ) { $\C{// initialization}$ … … 2131 2125 2132 2126 A simple example is allowing the underscore, as in Ada, to separate prefixes, digits, and suffixes in all \CFA constants, \eg @0x`_`1.ffff`_`ffff`_`p`_`128`_`l@, where the underscore is also the standard separator in C identifiers. 2133 \CC uses a single quote as a separator, but it is restricted among digits, precluding its use in the literal prefix or suffix, \eg @0x1.ffff@@`'@@ffffp128l@, and causes problems with most \textcolor{blue}{Q2 CHANGE ``IDEs'' TO ``integrated development environments (IDEs)''}, which must be extended to deal with this alternate use of the single quote.2127 \CC uses a single quote as a separator, but it is restricted among digits, precluding its use in the literal prefix or suffix, \eg @0x1.ffff@@`'@@ffffp128l@, and causes problems with most integrated development environments (IDEs), which must be extended to deal with this alternate use of the single quote. 2134 2128 2135 2129 … … 2203 2197 y = "12345678901234567890123456789"|`mp| + "12345678901234567890123456789"|`mp|; 2204 2198 \end{cfa} 2205 Because \CFA uses a standard function, all types and literals are applicable, as well as overloading and conversions, where @?`@ \textcolor{blue}{USE CHARACTER \lstinline@`@ NOT \textsf{'}} denotes a postfix-function name and @`@ \textcolor{blue}{USE CHARACTER \lstinline@`@ NOT `}denotes a postfix-function call.2199 Because \CFA uses a standard function, all types and literals are applicable, as well as overloading and conversions, where @?`@ denotes a postfix-function name and @`@ denotes a postfix-function call. 2206 2200 }% 2207 2201 \begin{cquote} … … 2345 2339 \lstMakeShortInline@% 2346 2340 \end{cquote} 2347 The result is a significant reduction in names to access typed constants. \textcolor{blue}{REMOVE ``, as follows.''}2341 The result is a significant reduction in names to access typed constants. 2348 2342 \begin{cquote} 2349 2343 \lstDeleteShortInline@% … … 2390 2384 \lstMakeShortInline@% 2391 2385 \end{cquote} 2392 The result is a significant reduction in names to access math functions. \textcolor{blue}{REMOVE ``, as follows.''}2386 The result is a significant reduction in names to access math functions. 2393 2387 \begin{cquote} 2394 2388 \lstDeleteShortInline@% … … 2437 2431 \lstMakeShortInline@% 2438 2432 \end{cquote} 2439 The result is a significant reduction in names to access the utility functions. \textcolor{blue}{REMOVE ``, as follows.''}2433 The result is a significant reduction in names to access the utility functions. 2440 2434 \begin{cquote} 2441 2435 \lstDeleteShortInline@% … … 2458 2452 In addition, there are polymorphic functions, like @min@ and @max@, that work on any type with operator @?<?@ or @?>?@. 2459 2453 2460 The following shows one example where \CFA \ textcolor{blue}{ADD SPACE} \emph{extends} an existing standard C interface to reduce complexity and provide safety.2454 The following shows one example where \CFA \emph{extends} an existing standard C interface to reduce complexity and provide safety. 2461 2455 C/\Celeven provide a number of complex and overlapping storage-management operations to support the following capabilities. 2462 2456 \begin{list}{}{\itemsep=0pt\parsep=0pt\labelwidth=0pt\leftmargin\parindent\itemindent-\leftmargin\let\makelabel\descriptionlabel} … … 2649 2643 \label{s:MultiPrecisionIntegers} 2650 2644 2651 \CFA has an interface to the \textcolor{blue}{Q3 CHANGE ``GMP multiprecision'' TO ``GNU multiple precision (GMP)''}signed integers~\cite{GMP}, similar to the \CC interface provided by GMP.2645 \CFA has an interface to the GNU multiple precision (GMP) signed integers~\cite{GMP}, similar to the \CC interface provided by GMP. 2652 2646 The \CFA interface wraps GMP functions into operator functions to make programming with multiprecision integers identical to using fixed-sized integers. 2653 2647 The \CFA type name for multiprecision signed integers is @Int@ and the header file is @gmp@. … … 2742 2736 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. 2743 2737 The graph plots the median of five consecutive runs of each program, with an initial warm-up run omitted. 2744 All code is compiled at \texttt{-O2} by gcc or g++ 6.4.0, with all \CC code compiled as \CCfourteen. \textcolor{blue}{CHANGE ``\CC{}fourteen'' TO ``\CCfourteen''}2745 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 \textcolor{blue}{REMOVE ``of''}maximum clock frequency.2738 All code is compiled at \texttt{-O2} by gcc or g++ 6.4.0, with all \CC code compiled as \CCfourteen. 2739 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. 2746 2740 2747 2741 \begin{figure} … … 2770 2764 \end{table} 2771 2765 2766 \enlargethispage{-10pt} 2772 2767 The C and \CCV variants are generally the slowest with the largest memory footprint, due to their less-efficient memory layout and the pointer indirection necessary to implement generic types; 2773 2768 this inefficiency is exacerbated by the second level of generic types in the pair benchmarks. … … 2860 2855 Tuples are a generalization of @std::pair@, in that they allow for arbitrary length, fixed-size aggregation of heterogeneous values. 2861 2856 Operations include @std::get<N>@ to extract values, @std::tie@ to create a tuple of references used for assignment, and lexicographic comparisons. 2862 \CCseventeen \textcolor{blue}{CHANGE ``\CC{}seventeen TO ``\CCseventeen''}proposes \emph{structured bindings}~\cite{Sutter15} to eliminate predeclaring variables and the use of @std::tie@ for binding the results.2857 \CCseventeen proposes \emph{structured bindings}~\cite{Sutter15} to eliminate predeclaring variables and the use of @std::tie@ for binding the results. 2863 2858 This extension requires the use of @auto@ to infer the types of the new variables; hence, complicated expressions with a nonobvious type must be documented with some other mechanism. 2864 2859 Furthermore, structured bindings are not a full replacement for @std::tie@, as it always declares new variables. -
tests/coroutine/fibonacci.c
r550e819 r39c4dac 6 6 // 7 7 // fibonacci.c -- 3-state finite-state machine 8 9 8 // 10 9 // Author : Thierry Delisle 11 10 // Created On : Thu Jun 8 07:29:37 2017 12 11 // Last Modified By : Peter A. Buhr 13 // Last Modified On : Thu Aug 16 08:18:16201814 // Update Count : 2 012 // Last Modified On : Sat Aug 18 11:21:58 2018 13 // Update Count : 24 15 14 // 16 15 … … 39 38 int main() { 40 39 Fibonacci f1, f2; 41 for ( int i = 1; i <= 10; i += 1 ) {40 for ( 10 ) { // print N Fibonacci values 42 41 sout | next( f1 ) | next( f2 ) | endl; 43 42 } // for -
tests/coroutine/pingpong.c
r550e819 r39c4dac 10 10 // Created On : Wed Sep 20 11:55:23 2017 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Wed Sep 20 13:41:39 201713 // Update Count : 2 612 // Last Modified On : Sat Aug 18 11:31:11 2018 13 // Update Count : 28 14 14 // 15 15 … … 39 39 } 40 40 void main( PingPong & pingpong ) { // ping's starter ::main, pong's starter ping 41 for ( unsigned int i = 0; i < pingpong.N; i += 1 ) {41 for ( pingpong.N ) { // N ping-pongs 42 42 sout | pingpong.name | endl; 43 43 cycle( *pingpong.part ); -
tests/coroutine/prodcons.c
r550e819 r39c4dac 10 10 // Created On : Mon Sep 18 12:23:39 2017 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Tue Jan 2 12:17:01201813 // Update Count : 4712 // Last Modified On : Sat Aug 18 12:55:10 2018 13 // Update Count : 51 14 14 // 15 15 16 16 #include <fstream.hfa> 17 17 #include <coroutine.hfa> 18 #include <stdlib.hfa> 18 #include <stdlib.hfa> // random 19 19 #include <unistd.h> // getpid 20 20 … … 29 29 void main( Prod & prod ) with( prod ) { // starter ::main 30 30 // 1st resume starts here 31 for ( i nt i = 0; i < N; i += 1 ) {31 for ( i; N ) { // N pairs of values 32 32 int p1 = random( 100 ); 33 33 int p2 = random( 100 ); -
tests/gmp.c
r550e819 r39c4dac 10 10 // Created On : Tue Apr 19 08:55:51 2016 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Thu Sep 28 18:33:51 201713 // Update Count : 55 512 // Last Modified On : Sat Aug 18 12:43:13 2018 13 // Update Count : 556 14 14 // 15 15 … … 89 89 fn = 1; fn2 = fn1; fn1 = fn; // 2nd case 90 90 sout | 1 | fn | endl; 91 for ( unsigned int i = 2; i <= 200; i += 1) {91 for ( i; 2u ~= 200 ) { 92 92 fn = fn1 + fn2; fn2 = fn1; fn1 = fn; // general case 93 93 sout | i | fn | endl; … … 99 99 Int fact = 1; // 1st case 100 100 sout | (int)0 | fact | endl; 101 for ( unsigned int i = 1; i <= 40; i += 1) {101 for ( i; 1u ~= 40u ) { 102 102 fact *= i; // general case 103 103 sout | i | fact | endl;
Note: See TracChangeset
for help on using the changeset viewer.