Index: doc/theses/jiada_liang_MMath/main.tex =================================================================== --- doc/theses/jiada_liang_MMath/main.tex (revision a97b9ed3c1ef2940db3bc2e85497a8b1a674d78d) +++ doc/theses/jiada_liang_MMath/main.tex (revision a97b9ed3c1ef2940db3bc2e85497a8b1a674d78d) @@ -0,0 +1,270 @@ +%% +%% This is file `sample-manuscript.tex', +%% generated with the docstrip utility. +%% +%% The original source files were: +%% +%% samples.dtx (with options: `manuscript') +%% +%% IMPORTANT NOTICE: +%% +%% For the copyright see the source file. +%% +%% Any modified versions of this file must be renamed +%% with new filenames distinct from sample-manuscript.tex. +%% +%% For distribution of the original source see the terms +%% for copying and modification in the file samples.dtx. +%% +%% This generated file may be distributed as long as the +%% original source files, as listed above, are part of the +%% same distribution. (The sources need not necessarily be +%% in the same archive or directory.) +%% +%% Commands for TeXCount +%TC:macro \cite [option:text,text] +%TC:macro \citep [option:text,text] +%TC:macro \citet [option:text,text] +%TC:envir table 0 1 +%TC:envir table* 0 1 +%TC:envir tabular [ignore] word +%TC:envir displaymath 0 word +%TC:envir math 0 word +%TC:envir comment 0 0 +%% +%% +%% The first command in your LaTeX source must be the \documentclass command. +\documentclass[manuscript,screen,review]{acmart} +\usepackage{xcolor} +\usepackage{listings} +\usepackage[ligature, inference]{semantic} +\usepackage{array} + +\definecolor{mGreen}{rgb}{0,0.6,0} +\definecolor{mGray}{rgb}{0.5,0.5,0.5} +\definecolor{mPurple}{rgb}{0.58,0,0.82} +\definecolor{backgroundColour}{rgb}{0.95,0.95,0.92} + +\lstdefinestyle{CStyle}{ + backgroundcolor=\color{backgroundColour}, + commentstyle=\color{mGreen}, + keywordstyle=\color{magenta}, + numberstyle=\tiny\color{mGray}, + stringstyle=\color{mPurple}, + basicstyle=\footnotesize, + breakatwhitespace=false, + breaklines=true, + captionpos=b, + keepspaces=true, + numbers=left, + numbersep=5pt, + showspaces=false, + showstringspaces=false, + showtabs=false, + tabsize=2, + language=C +} + +%% +%% \BibTeX command to typeset BibTeX logo in the docs +\AtBeginDocument{% + \providecommand\BibTeX{{% + \normalfont B\kern-0.5em{\scshape i\kern-0.25em b}\kern-0.8em\TeX}}} + + + +%% +%% Submission ID. +%% Use this when submitting an article to a sponsored event. You'll +%% receive a unique submission ID from the organizers +%% of the event, and this ID should be used as the parameter to this command. +%%\acmSubmissionID{123-A56-BU3} + +%% +%% For managing citations, it is recommended to use bibliography +%% files in BibTeX format. +%% +%% You can then either use BibTeX with the ACM-Reference-Format style, +%% or BibLaTeX with the acmnumeric or acmauthoryear sytles, that include +%% support for advanced citation of software artefact from the +%% biblatex-software package, also separately available on CTAN. +%% +%% Look at the sample-*-biblatex.tex files for templates showcasing +%% the biblatex styles. +%% + +%% +%% The majority of ACM publications use numbered citations and +%% references. The command \citestyle{authoryear} switches to the +%% "author year" style. +%% +%% If you are preparing content for an event +%% sponsored by ACM SIGGRAPH, you must use the "author year" style of +%% citations and references. +%% Uncommenting +%% the next command will enable that style. +%%\citestyle{acmauthoryear} + +%% +%% end of the preamble, start of the body of the document source. +\begin{document} + +%% +%% The "title" command has an optional parameter, +%% allowing the author to define a "short title" to be used in page headers. +\title{Enumeration in Cforall} + +%% +%% The "author" command and its associated commands are used to define +%% the authors and their affiliations. +%% Of note is the shared affiliation of the first two authors, and the +%% "authornote" and "authornotemark" commands +%% used to denote shared contribution to the research. +\author{Jiada Liang} + + +%% +%% The abstract is a short summary of the work to be presented in the +%% article. +\begin{abstract} + An enumeration, or enum in short, is a type that defines a list of named constant values in C. Cforall extends the enumeration with additional features. +\end{abstract} + +%% +%% The code below is generated by the tool at http://dl.acm.org/ccs.cfm. +%% Please copy and paste the code instead of the example below. +%% + + +%% +%% This command processes the author and affiliation and title +%% information and builds the first part of the formatted document. +\maketitle + +\section{C-Style Enum} +\begin{lstlisting}[style=CStyle] +enum Weekday { Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday }; +\end{lstlisting} +Cforall supports the classic C-Style enumeration (C-enum for short) and its syntax is consistent with C. No internal data structure is generated for C-enum, and C-enum does not provide the Cforall-enum interface methods. + +\section{Cforall Enum} +\subsection{Enumerable Type} +\begin{lstlisting}[style=CStyle] +forall(T) +trait enumerable { + void ?()( T & t, zero_t ); + void ?()( T & t, one_t ); + S& ?+=?( T & t, one_t ); + void ?{}( T &, T ); + T ?{}( T &, T ); +}; +\end{lstlisting} +A type is enumerable in Cforall if it has defined 0, 1, increment operator, copy constructor, and copy assignment operator. + +(Should change the definition of enumerable to something else. Maybe auto-constructible. If a type is not auto-constructible, all enumeration must be explicitly initialized) +\begin{lstlisting}[caption={An example enumerable type}, label{lst:sample_enumerable}, style=CStyle] +struct Type { int i; }; +void ?()( Type & t, zero_t ) { t.i = 0; }; +void ?()( Type & t, one_t ) { t.i = 1; }; +int ?!=?( Type t, zero_t ) { return t.i != 0; }; +S& ?+=?( Type & t, one_t ) { t.i += 1; return t; }; +void ?()( Type & t, Type rhs ) { t.i = rhs.i; }; +Type ?()( Type & t, Type rhs ) { t.i = rhs.i; return t; }; +\end{lstlisting} + +A Cforall-enum is a C-enum parameterized by an enumerable type. For example, $enum(int)$ turns a C-enum into a Cforall-enum. +\begin{lstlisting}[caption={An example Cforall enum}, label{lst:sample_cforall_enum}, style=CStyle] +enum Color(Type) { Red, Green, Blue }; + +> Type Color.values[] = { 0, values[0]++, values[1]++ }; +> enum Color.Label { Red_Label, Green_Label, Blue_Label }; +\end{lstlisting} +Declaring a Cforall-enum, the compiler defines a C-enum names every element in the Cforall-enum, and an array that stores Cforall enumeration values. + +\subsection{Cforall Enumerations Behaviour} +An instance of Cforall-enum (denoted as $$) has a label, the defined enum name. The label can be retrieved by calling the function $label()$ on a $$. The $value()$ function on the other hand returns the value used to initialize the Cforall-enum. + +Cforall-enum supports a qualified expression. The syntax of the qualified expression for Cforall-enum is $$.$$. In the $Color$ example, $Color$ is a $$ and $Red$, $Green$, $Blue$ are $$. + +\begin{lstlisting}[caption={An example Cforall enum}, label{lst:sample_cforall_enum_usage}, style=CStyle] +enum Color red = Color.Red; +> enum Color.Label red = = Color.Label.Red_Label; +Type instance = Color.Red; +> Type instance = Color.values[ Color.Label.Red_Label ]; +\end{lstlisting} + +The expression $Color.Red$ is overloaded to represent both $value(Color.Red)$ and $label(Color.Red)$. The expression returns the $label(Color.Red)$ by default but returns $value()$ whenever the $value()$ is a closer candidate in the context. [more explanation] In \ref{lst:sample_cforall_enum_usage}, when assigned to an enum variable, $Color.Red$ returns the label. This is to reduce the memory to store a Cforall-enum variable. In an assignment expression when the left-hand-side expects a $Type$, the resolution finds $value(Color.Red)$ is a better candidate than $label(Color.Red)$, and returns the value instead. + +\subsection{Enum Type Functions} +\begin{lstlisting}[caption={Enum Type Functions}, label{lst:cforall_enum_functions}, style=CStyle] +enum Color(string) { // assume String has been defined as an enumerable type + R = "Red", G = "Green", B = "Blue" +}; +values( Color ); +> [ String("Red"), String("Green"), String("Blue") ]; +label_strings( Color ); +> [ "R", "G", "B" ]; +enum Color green = Color.G; + +label_string( Color, green ); +> "G" +label( Color, green ); +> 1 +value( Color, green ) ; +> "Green" +value( Color, "G" ); +> "Green" +label( Color, "G" ); +> 1 +value( Color, "DNE" ); +> (null) +value( Color, 1 ); // "1" is the label "G" +> "Green" +\end{lstlisting} +Names of labels are distinct in an enum declaration. Cforall therefore allows indexing an enum value with its string representation of a label. + +\subsection{Range Functions and Iteration (Placeholder)} +\begin{lstlisting}[caption={Range Functions}, label{lst:range_functions}, style=CStyle] +enum Weekday( + Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday +}; +\end{lstlisting} + +\section{Implementation} + +\subsection{Companion Object} +The intuition to create a companion object is that functions that support enumeration features need static information of an enumeration class. For example, values() returns an array of values defined for the enumeration. $label( Color, "G" )$ needs information about enum names defined for the enum class $Color$. Theoretically, enum-type functions can be defined as functions that take $TypeName$ expression as the first parameter. An alternative approach is to define that "companion object". + +\begin{lstlisting}[caption={Enum Type Functions}, label{lst:cforall_enum_functions}, style=CStyle] +struct string; +enum Color( string ) { + R = "Red", G = "Green", B = "Blue" +}; + +forall( T | enumerable(T) ) { + struct Companion { + T* values; + char** labels; + }; +} +>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> +Companion( string ) Color = { + .values = [ "Red", "Green", "Blue" ], + .labels = [ "R", "G", "B" ] +}; +>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> +forall( T | enumerable(T) ) +T* value( Companion, int ); +char* label( Companion, int ); +\end{lstlisting} + +\subsection{TODO - Type trait for Cforall - Enum} +%% +%% If your work has an appendix, this is the place to put it. +\appendix + + +\end{document} +\endinput +%% +%% End of file `sample-manuscript.tex'. Index: libcfa/src/concurrency/channel.hfa =================================================================== --- libcfa/src/concurrency/channel.hfa (revision 946a6e4d6e22aa9ec049796a1ac9b96286d7e852) +++ libcfa/src/concurrency/channel.hfa (revision a97b9ed3c1ef2940db3bc2e85497a8b1a674d78d) @@ -130,4 +130,5 @@ static inline void __cons_handoff( channel(T) & chan, T & elem ) with(chan) { memcpy( cons`first.extra, (void *)&elem, sizeof(T) ); // do waiting consumer work + __atomic_thread_fence( __ATOMIC_SEQ_CST ); wake_one( cons ); } @@ -136,4 +137,5 @@ static inline void __prods_handoff( channel(T) & chan, T & retval ) with(chan) { memcpy( (void *)&retval, prods`first.extra, sizeof(T) ); + __atomic_thread_fence( __ATOMIC_SEQ_CST ); wake_one( prods ); } Index: libcfa/src/concurrency/cofor.cfa =================================================================== --- libcfa/src/concurrency/cofor.cfa (revision 946a6e4d6e22aa9ec049796a1ac9b96286d7e852) +++ libcfa/src/concurrency/cofor.cfa (revision a97b9ed3c1ef2940db3bc2e85497a8b1a674d78d) @@ -4,10 +4,10 @@ // cofor ( uC++ COFOR ) -thread co_runner { +thread cofor_runner { ssize_t low, high; __cofor_body_t loop_body; }; -static void ?{}( co_runner & this, ssize_t low, ssize_t high, __cofor_body_t loop_body ) { +static void ?{}( cofor_runner & this, ssize_t low, ssize_t high, __cofor_body_t loop_body ) { this.low = low; this.high = high; @@ -15,5 +15,5 @@ } -void main( co_runner & this ) with( this ) { +void main( cofor_runner & this ) with( this ) { for ( ssize_t i = low; i < high; i++ ) loop_body(i); @@ -29,5 +29,5 @@ ssize_t i = 0; ssize_t stride_iter = low; - co_runner * runners[ threads ]; + cofor_runner * runners[ threads ]; for ( i; threads ) { runners[i] = alloc(); @@ -45,25 +45,3 @@ } -////////////////////////////////////////////////////////////////////////////////////////// -// parallel (COBEGIN/COEND) -thread para_runner { - parallel_stmt_t body; - void * arg; -}; - -static void ?{}( para_runner & this, parallel_stmt_t body, void * arg ) { - this.body = body; - this.arg = arg; -} - -void main( para_runner & this ) with( this ) { body( arg ); } - -void parallel( parallel_stmt_t * stmts, void ** args, size_t num ) libcfa_public { - para_runner * runners[ num ]; - for ( i; num ) - (*(runners[i] = malloc())){ stmts[i], args[i] }; - for ( i; num ) - delete( runners[i] ); -} - Index: libcfa/src/concurrency/cofor.hfa =================================================================== --- libcfa/src/concurrency/cofor.hfa (revision 946a6e4d6e22aa9ec049796a1ac9b96286d7e852) +++ libcfa/src/concurrency/cofor.hfa (revision a97b9ed3c1ef2940db3bc2e85497a8b1a674d78d) @@ -16,6 +16,29 @@ ////////////////////////////////////////////////////////////////////////////////////////// -// parallel (COBEGIN/COEND) -typedef void (*parallel_stmt_t)( void * ); +// corun -void parallel( parallel_stmt_t * stmts, void ** args, size_t num ); +// +typedef void (*__CFA_corun_lambda_t)( void ); + +// used to run a corun statement in parallel +thread co_runner { + __CFA_corun_lambda_t body; +}; + +// wraps a co_runner to provide RAII deallocation +struct runner_block { + co_runner * runner; +}; +static inline void ?{}( co_runner & this, __CFA_corun_lambda_t body ) { this.body = body; } + +void main( co_runner & this ) with( this ) { body(); } + +static inline void ?{}( runner_block & this ) {} +static inline void ?{}( runner_block & this, __CFA_corun_lambda_t body ) { + (*(this.runner = malloc())){ body }; +} + +static inline void ^?{}( runner_block & this ) { + delete( this.runner ); +} + Index: src/AST/Convert.cpp =================================================================== --- src/AST/Convert.cpp (revision 946a6e4d6e22aa9ec049796a1ac9b96286d7e852) +++ src/AST/Convert.cpp (revision a97b9ed3c1ef2940db3bc2e85497a8b1a674d78d) @@ -269,5 +269,5 @@ node->location, Type::StorageClasses( node->storage.val ), - get().accept1( node->base ), + get().accept1( node->base ), LinkageSpec::Spec( node->linkage.val ) ); @@ -567,5 +567,5 @@ } - const ast::WhenClause * visit( const ast::WhenClause * node ) override final { + const ast::WhenClause * visit( const ast::WhenClause * node ) override final { // There is no old-AST WhenClause, so this should never be called. assert( !node ); @@ -604,6 +604,6 @@ } - const ast::Stmt * visit( const ast::WaitUntilStmt * node ) override final { - // There is no old-AST WaitUntilStmt, so this should never be called. + const ast::Stmt * visit( const ast::WaitUntilStmt * node ) override final { + // There is no old-AST WaitUntilStmt, so this should never be called. assert( !node ); return nullptr; @@ -648,4 +648,10 @@ ); return stmtPostamble( stmt, node ); + } + + const ast::Stmt * visit( const ast::CorunStmt * node ) override final { + // There is no old-AST CorunStmt, so this should never be called. + assert( !node ); + return nullptr; } @@ -853,5 +859,5 @@ // New workd: one public type: node->result, plus node->underlyer only to support roundtrip conversion // preserving underlyer because the correct type for string literals is complicated to construct, - // and distinguishing a string from other literals using the type is hard to do accurately + // and distinguishing a string from other literals using the type is hard to do accurately // Both worlds: the outer, expression-level type can change during resolution // for a string, that's char[k] before-resolve and char * after @@ -859,5 +865,5 @@ // for a string, that's char[k] always // Both worlds: the "rep" field of a constant is the C source file fragment that compiles to the desired value - // for a string, that includes outer quotes, backslashes, et al cases from the Literals test + // for a string, that includes outer quotes, backslashes, et al cases from the Literals test ConstantExpr *rslt = new ConstantExpr(Constant( get().accept1(node->underlyer), @@ -1518,5 +1524,5 @@ return strict_dynamic_cast< ast::Decl * >( node ); } - + ConverterOldToNew() = default; ConverterOldToNew(const ConverterOldToNew &) = delete; @@ -1581,5 +1587,5 @@ ast::Label make_label(const Label* old) { CodeLocation const & location = - ( old->labelled ) ? old->labelled->location : CodeLocation(); + ( old->labelled ) ? old->labelled->location : CodeLocation(); return ast::Label( location, @@ -2240,5 +2246,4 @@ // TypeSubstitution shouldn't exist yet in old. ast::TypeSubstitution * convertTypeSubstitution(const TypeSubstitution * old) { - if (!old) return nullptr; if (old->empty()) return nullptr; @@ -2285,5 +2290,5 @@ ast::Expr * visitBaseExpr_SkipResultType( const Expression * old, ast::Expr * nw) { - nw->env = convertTypeSubstitution(old->env); + nw->env = convertTypeSubstitution(old->env); nw->extension = old->extension; @@ -2856,5 +2861,5 @@ virtual void visit( const EnumInstType * old ) override final { - ast::EnumInstType * ty; + ast::EnumInstType * ty; if ( old->baseEnum ) { ty = new ast::EnumInstType{ Index: src/AST/Fwd.hpp =================================================================== --- src/AST/Fwd.hpp (revision 946a6e4d6e22aa9ec049796a1ac9b96286d7e852) +++ src/AST/Fwd.hpp (revision a97b9ed3c1ef2940db3bc2e85497a8b1a674d78d) @@ -67,4 +67,5 @@ class ImplicitCtorDtorStmt; class MutexStmt; +class CorunStmt; class Expr; Index: src/AST/Node.cpp =================================================================== --- src/AST/Node.cpp (revision 946a6e4d6e22aa9ec049796a1ac9b96286d7e852) +++ src/AST/Node.cpp (revision a97b9ed3c1ef2940db3bc2e85497a8b1a674d78d) @@ -192,4 +192,6 @@ template class ast::ptr_base< ast::MutexStmt, ast::Node::ref_type::weak >; template class ast::ptr_base< ast::MutexStmt, ast::Node::ref_type::strong >; +template class ast::ptr_base< ast::CorunStmt, ast::Node::ref_type::weak >; +template class ast::ptr_base< ast::CorunStmt, ast::Node::ref_type::strong >; template class ast::ptr_base< ast::Expr, ast::Node::ref_type::weak >; template class ast::ptr_base< ast::Expr, ast::Node::ref_type::strong >; Index: src/AST/Pass.hpp =================================================================== --- src/AST/Pass.hpp (revision 946a6e4d6e22aa9ec049796a1ac9b96286d7e852) +++ src/AST/Pass.hpp (revision a97b9ed3c1ef2940db3bc2e85497a8b1a674d78d) @@ -162,8 +162,8 @@ const ast::FinallyClause * visit( const ast::FinallyClause * ) override final; const ast::Stmt * visit( const ast::SuspendStmt * ) override final; - const ast::WhenClause * visit( const ast::WhenClause * ) override final; + const ast::WhenClause * visit( const ast::WhenClause * ) override final; const ast::Stmt * visit( const ast::WaitForStmt * ) override final; const ast::WaitForClause * visit( const ast::WaitForClause * ) override final; - const ast::Stmt * visit( const ast::WaitUntilStmt * ) override final; + const ast::Stmt * visit( const ast::WaitUntilStmt * ) override final; const ast::Decl * visit( const ast::WithStmt * ) override final; const ast::NullStmt * visit( const ast::NullStmt * ) override final; @@ -171,4 +171,5 @@ const ast::Stmt * visit( const ast::ImplicitCtorDtorStmt * ) override final; const ast::Stmt * visit( const ast::MutexStmt * ) override final; + const ast::Stmt * visit( const ast::CorunStmt * ) override final; const ast::Expr * visit( const ast::ApplicationExpr * ) override final; const ast::Expr * visit( const ast::UntypedExpr * ) override final; Index: src/AST/Pass.impl.hpp =================================================================== --- src/AST/Pass.impl.hpp (revision 946a6e4d6e22aa9ec049796a1ac9b96286d7e852) +++ src/AST/Pass.impl.hpp (revision a97b9ed3c1ef2940db3bc2e85497a8b1a674d78d) @@ -1121,4 +1121,17 @@ //-------------------------------------------------------------------------- +// CorunStmt +template< typename core_t > +const ast::Stmt * ast::Pass< core_t >::visit( const ast::CorunStmt * node ) { + VISIT_START( node ); + + if ( __visit_children() ) { + maybe_accept( node, &CorunStmt::stmt ); + } + + VISIT_END( Stmt, node ); +} + +//-------------------------------------------------------------------------- // ApplicationExpr template< typename core_t > Index: src/AST/Print.cpp =================================================================== --- src/AST/Print.cpp (revision 946a6e4d6e22aa9ec049796a1ac9b96286d7e852) +++ src/AST/Print.cpp (revision a97b9ed3c1ef2940db3bc2e85497a8b1a674d78d) @@ -209,5 +209,5 @@ } - void print( const ast::WaitStmt * node ) { + void print( const ast::WaitStmt * node ) { if ( node->timeout_time ) { os << indent-1 << "timeout of:" << endl; @@ -860,5 +860,5 @@ } - virtual const ast::Stmt * visit( const ast::WaitUntilStmt * node ) override final { + virtual const ast::Stmt * visit( const ast::WaitUntilStmt * node ) override final { os << "Waituntil Statement" << endl; indent += 2; @@ -866,5 +866,6 @@ clause->accept( *this ); } - print(node); // calls print( const ast::WaitStmt * node ) + // calls print( const ast::WaitStmt * node ) + print(node); return node; } @@ -913,4 +914,15 @@ printAll( node->mutexObjs ); --indent; + os << indent << "... with Statement: "; + ++indent; + safe_print( node->stmt ); + --indent; + os << endl; + + return node; + } + + virtual const ast::Stmt * visit( const ast::CorunStmt * node ) override final { + os << "Corun Statement" << endl; os << indent << "... with Statement: "; ++indent; Index: src/AST/Stmt.hpp =================================================================== --- src/AST/Stmt.hpp (revision 946a6e4d6e22aa9ec049796a1ac9b96286d7e852) +++ src/AST/Stmt.hpp (revision a97b9ed3c1ef2940db3bc2e85497a8b1a674d78d) @@ -532,4 +532,18 @@ }; +// Corun Statement +class CorunStmt final : public Stmt { + public: + ptr stmt; + + CorunStmt( const CodeLocation & loc, const Stmt * stmt, const std::vector