Diff [a2e4b0cd8f28d66ff183eebe6d8cf6d6d3858dd9:a51a02de31d78381190b6b5aafa5260020147369] for / – Cforall

doc/theses/mubeen_zulfiqar_MMath/allocator.tex

-              ra2e4b0c
+              ra51a02d
 \end{itemize}
 The new features added to uHeapLmmm (incl. @malloc\_size@ routine)
+The new features added to uHeapLmmm (incl. @malloc_size@ routine)
 \CFA alloc interface with examples.
 \begin{itemize}
 \item
 …
 We added a few more features and routines to the allocator's C interface that can make the allocator more usable to the programmers. THese features will programmer more control on the dynamic memory allocation.
 \subsubsection void * aalloc( size\_t dim, size\_t elemSize )
+\subsubsection void * aalloc( size_t dim, size_t elemSize )
 aalloc is an extension of malloc. It allows programmer to allocate a dynamic array of objects without calculating the total size of array explicitly. The only alternate of this routine in the other allocators is calloc but calloc also fills the dynamic memory with 0 which makes it slower for a programmer who only wants to dynamically allocate an array of objects without filling it with 0.
 \paragraph{Usage}
 aalloc takes two parameters.
 \begin{itemize}
 \item
 …
 It returns address of dynamic object allocatoed on heap that can contain dim number of objects of the size elemSize. On failure, it returns NULL pointer.
 \subsubsection void * resize( void * oaddr, size\_t size )
+\subsubsection void * resize( void * oaddr, size_t size )
 resize is an extension of relloc. It allows programmer to reuse a cuurently allocated dynamic object with a new size requirement. Its alternate in the other allocators is realloc but relloc also copy the data in old object to the new object which makes it slower for the programmer who only wants to reuse an old dynamic object for a new size requirement but does not want to preserve the data in the old object to the new object.
 \paragraph{Usage}
 resize takes two parameters.
 \begin{itemize}
 \item
 …
 It returns an object that is of the size given but it does not preserve the data in the old object. On failure, it returns NULL pointer.
 \subsubsection void * resize( void * oaddr, size\_t nalign, size\_t size )
+\subsubsection void * resize( void * oaddr, size_t nalign, size_t size )
 This resize is an extension of the above resize (FIX ME: cite above resize). In addition to resizing the size of of an old object, it can also realign the old object to a new alignment requirement.
 \paragraph{Usage}
 This resize takes three parameters. It takes an additional parameter of nalign as compared to the above resize (FIX ME: cite above resize).
 \begin{itemize}
 \item
 …
 It returns an object with the size and alignment given in the parameters. On failure, it returns a NULL pointer.
 \subsubsection void * amemalign( size\_t alignment, size\_t dim, size\_t elemSize )
+\subsubsection void * amemalign( size_t alignment, size_t dim, size_t elemSize )
 amemalign is a hybrid of memalign and aalloc. It allows programmer to allocate an aligned dynamic array of objects without calculating the total size of the array explicitly. It frees the programmer from calculating the total size of the array.
 \paragraph{Usage}
 amemalign takes three parameters.
 \begin{itemize}
 \item
 …
 It returns a dynamic array of objects that has the capacity to contain dim number of objects of the size of elemSize. The returned dynamic array is aligned to the given alignment. On failure, it returns NULL pointer.
 \subsubsection void * cmemalign( size\_t alignment, size\_t dim, size\_t elemSize )
+\subsubsection void * cmemalign( size_t alignment, size_t dim, size_t elemSize )
 cmemalign is a hybrid of amemalign and calloc. It allows programmer to allocate an aligned dynamic array of objects that is 0 filled. The current way to do this in other allocators is to allocate an aligned object with memalign and then fill it with 0 explicitly. This routine provides both features of aligning and 0 filling, implicitly.
 \paragraph{Usage}
 cmemalign takes three parameters.
 \begin{itemize}
 \item
 …
 It returns a dynamic array of objects that has the capacity to contain dim number of objects of the size of elemSize. The returned dynamic array is aligned to the given alignment and is 0 filled. On failure, it returns NULL pointer.
+\subsubsection size\_t malloc\_alignment( void * addr )
+malloc\_alignment returns the alignment of a currently allocated dynamic object. It allows the programmer in memory management and personal bookkeeping. It helps the programmer in verofying the alignment of a dynamic object especially in a scenerio similar to prudcer-consumer where a producer allocates a dynamic object and the consumer needs to assure that the dynamic object was allocated with the required alignment.
+\paragraph{Usage}
+malloc\_alignment takes one parameters.
+\subsubsection size_t malloc_alignment( void * addr )
+malloc_alignment returns the alignment of a currently allocated dynamic object. It allows the programmer in memory management and personal bookkeeping. It helps the programmer in verofying the alignment of a dynamic object especially in a scenerio similar to prudcer-consumer where a producer allocates a dynamic object and the consumer needs to assure that the dynamic object was allocated with the required alignment.
+\paragraph{Usage}
+malloc_alignment takes one parameters.
 \begin{itemize}
 \item
 addr: the address of the currently allocated dynamic object.
 \end{itemize}
+malloc\_alignment returns the alignment of the given dynamic object. On failure, it return the value of default alignment of the uHeapLmmm allocator.
+\subsubsection bool malloc\_zero\_fill( void * addr )
+malloc\_zero\_fill returns whether a currently allocated dynamic object was initially zero filled at the time of allocation. It allows the programmer in memory management and personal bookkeeping. It helps the programmer in verifying the zero filled property of a dynamic object especially in a scenerio similar to prudcer-consumer where a producer allocates a dynamic object and the consumer needs to assure that the dynamic object was zero filled at the time of allocation.
+\paragraph{Usage}
+malloc\_zero\_fill takes one parameters.
+malloc_alignment returns the alignment of the given dynamic object. On failure, it return the value of default alignment of the uHeapLmmm allocator.
+\subsubsection bool malloc_zero_fill( void * addr )
+malloc_zero_fill returns whether a currently allocated dynamic object was initially zero filled at the time of allocation. It allows the programmer in memory management and personal bookkeeping. It helps the programmer in verifying the zero filled property of a dynamic object especially in a scenerio similar to prudcer-consumer where a producer allocates a dynamic object and the consumer needs to assure that the dynamic object was zero filled at the time of allocation.
+\paragraph{Usage}
+malloc_zero_fill takes one parameters.
 \begin{itemize}
 \item
 addr: the address of the currently allocated dynamic object.
 \end{itemize}
+malloc\_zero\_fill returns true if the dynamic object was initially zero filled and return false otherwise. On failure, it returns false.
+\subsubsection size\_t malloc\_size( void * addr )
+malloc\_size returns the allocation size of a currently allocated dynamic object. It allows the programmer in memory management and personal bookkeeping. It helps the programmer in verofying the alignment of a dynamic object especially in a scenerio similar to prudcer-consumer where a producer allocates a dynamic object and the consumer needs to assure that the dynamic object was allocated with the required size. Its current alternate in the other allocators is malloc\_usable\_size. But, malloc\_size is different from malloc\_usable\_size as malloc\_usabe\_size returns the total data capacity of dynamic object including the extra space at the end of the dynamic object. On the other hand, malloc\_size returns the size that was given to the allocator at the allocation of the dynamic object. This size is updated when an object is realloced, resized, or passed through a similar allocator routine.
+\paragraph{Usage}
+malloc\_size takes one parameters.
+malloc_zero_fill returns true if the dynamic object was initially zero filled and return false otherwise. On failure, it returns false.
+\subsubsection size_t malloc_size( void * addr )
+malloc_size returns the allocation size of a currently allocated dynamic object. It allows the programmer in memory management and personal bookkeeping. It helps the programmer in verofying the alignment of a dynamic object especially in a scenerio similar to prudcer-consumer where a producer allocates a dynamic object and the consumer needs to assure that the dynamic object was allocated with the required size. Its current alternate in the other allocators is malloc_usable_size. But, malloc_size is different from malloc_usable_size as malloc_usabe_size returns the total data capacity of dynamic object including the extra space at the end of the dynamic object. On the other hand, malloc_size returns the size that was given to the allocator at the allocation of the dynamic object. This size is updated when an object is realloced, resized, or passed through a similar allocator routine.
+\paragraph{Usage}
+malloc_size takes one parameters.
 \begin{itemize}
 \item
 addr: the address of the currently allocated dynamic object.
 \end{itemize}
 malloc\_size returns the allocation size of the given dynamic object. On failure, it return zero.
 \subsubsection void * realloc( void * oaddr, size\_t nalign, size\_t size )
+malloc_size returns the allocation size of the given dynamic object. On failure, it return zero.
+\subsubsection void * realloc( void * oaddr, size_t nalign, size_t size )
 This realloc is an extension of the default realloc (FIX ME: cite default realloc). In addition to reallocating an old object and preserving the data in old object, it can also realign the old object to a new alignment requirement.
 \paragraph{Usage}
 This realloc takes three parameters. It takes an additional parameter of nalign as compared to the default realloc.
 \begin{itemize}
 \item
 …
 It returns a dynamic object of the size of type T. On failure, it return NULL pointer.
 \subsubsection T * aalloc( size\_t dim )
+\subsubsection T * aalloc( size_t dim )
 This aalloc is a simplified polymorphic form of above aalloc (FIX ME: cite aalloc). It takes one parameter as compared to the above aalloc that takes two parameters.
 \paragraph{Usage}
 aalloc takes one parameters.
 \begin{itemize}
 \item
 …
 It returns a dynamic object that has the capacity to contain dim number of objects, each of the size of type T. On failure, it return NULL pointer.
 \subsubsection T * calloc( size\_t dim )
+\subsubsection T * calloc( size_t dim )
 This calloc is a simplified polymorphic form of defualt calloc (FIX ME: cite calloc). It takes one parameter as compared to the default calloc that takes two parameters.
 \paragraph{Usage}
 This calloc takes one parameter.
 \begin{itemize}
 \item
 …
 It returns a dynamic object that has the capacity to contain dim number of objects, each of the size of type T. On failure, it return NULL pointer.
 \subsubsection T * resize( T * ptr, size\_t size )
+\subsubsection T * resize( T * ptr, size_t size )
 This resize is a simplified polymorphic form of above resize (FIX ME: cite resize with alignment). It takes two parameters as compared to the above resize that takes three parameters. It frees the programmer from explicitly mentioning the alignment of the allocation as CFA provides gives allocator the liberty to get the alignment of the returned type.
 \paragraph{Usage}
 This resize takes two parameters.
 \begin{itemize}
 \item
 …
 It returns a dynamic object of the size given in paramters. The returned object is aligned to the alignemtn of type T. On failure, it return NULL pointer.
 \subsubsection T * realloc( T * ptr, size\_t size )
+\subsubsection T * realloc( T * ptr, size_t size )
 This realloc is a simplified polymorphic form of defualt realloc (FIX ME: cite realloc with align). It takes two parameters as compared to the above realloc that takes three parameters. It frees the programmer from explicitly mentioning the alignment of the allocation as CFA provides gives allocator the liberty to get the alignment of the returned type.
 \paragraph{Usage}
 This realloc takes two parameters.
 \begin{itemize}
 \item
 …
 It returns a dynamic object of the size given in paramters that preserves the data in the given object. The returned object is aligned to the alignemtn of type T. On failure, it return NULL pointer.
 \subsubsection T * memalign( size\_t align )
+\subsubsection T * memalign( size_t align )
 This memalign is a simplified polymorphic form of defualt memalign (FIX ME: cite memalign). It takes one parameters as compared to the default memalign that takes two parameters.
 \paragraph{Usage}
 memalign takes one parameters.
 \begin{itemize}
 \item
 …
 It returns a dynamic object of the size of type T that is aligned to given parameter align. On failure, it return NULL pointer.
 \subsubsection T * amemalign( size\_t align, size\_t dim )
+\subsubsection T * amemalign( size_t align, size_t dim )
 This amemalign is a simplified polymorphic form of above amemalign (FIX ME: cite amemalign). It takes two parameter as compared to the above amemalign that takes three parameters.
 \paragraph{Usage}
 amemalign takes two parameters.
 \begin{itemize}
 \item
 …
 It returns a dynamic object that has the capacity to contain dim number of objects, each of the size of type T. The returned object is aligned to the given parameter align. On failure, it return NULL pointer.
 \subsubsection T * cmemalign( size\_t align, size\_t dim  )
+\subsubsection T * cmemalign( size_t align, size_t dim  )
 This cmemalign is a simplified polymorphic form of above cmemalign (FIX ME: cite cmemalign). It takes two parameter as compared to the above cmemalign that takes three parameters.
 \paragraph{Usage}
 cmemalign takes two parameters.
 \begin{itemize}
 \item
 …
 It returns a dynamic object that has the capacity to contain dim number of objects, each of the size of type T. The returned object is aligned to the given parameter align and is zero filled. On failure, it return NULL pointer.
+\subsubsection T * aligned\_alloc( size\_t align )
+This aligned\_alloc is a simplified polymorphic form of defualt aligned\_alloc (FIX ME: cite aligned\_alloc). It takes one parameter as compared to the default aligned\_alloc that takes two parameters.
+\paragraph{Usage}
+This aligned\_alloc takes one parameter.
+\subsubsection T * aligned_alloc( size_t align )
+This aligned_alloc is a simplified polymorphic form of defualt aligned_alloc (FIX ME: cite aligned_alloc). It takes one parameter as compared to the default aligned_alloc that takes two parameters.
+\paragraph{Usage}
+This aligned_alloc takes one parameter.
 \begin{itemize}
 \item
 …
 It returns a dynamic object of the size of type T that is aligned to the given parameter. On failure, it return NULL pointer.
+\subsubsection int posix\_memalign( T ** ptr, size\_t align )
+This posix\_memalign is a simplified polymorphic form of defualt posix\_memalign (FIX ME: cite posix\_memalign). It takes two parameters as compared to the default posix\_memalign that takes three parameters.
+\paragraph{Usage}
+This posix\_memalign takes two parameter.
+\subsubsection int posix_memalign( T ** ptr, size_t align )
+This posix_memalign is a simplified polymorphic form of defualt posix_memalign (FIX ME: cite posix_memalign). It takes two parameters as compared to the default posix_memalign that takes three parameters.
+\paragraph{Usage}
+This posix_memalign takes two parameter.
 \begin{itemize}
 \item
 …
 align: required alignment of the dynamic object.
 \end{itemize}
 It stores address of the dynamic object of the size of type T in given parameter ptr. This object is aligned to the given parameter. On failure, it return NULL pointer.
 …
 It returns a dynamic object of the size that is calcutaed by rouding the size of type T. The returned object is also aligned to the page size. On failure, it return NULL pointer.
 \subsection Alloc Interface
+\subsection{Alloc Interface}
 In addition to improve allocator interface both for CFA and our standalone allocator uHeapLmmm in C. We also added a new alloc interface in CFA that increases usability of dynamic memory allocation.
 This interface helps programmers in three major ways.
 \begin{itemize}
 \item
 …
 This is the only parameter in the alloc routine that has a fixed-position and it is also the only parameter that does not use a backtick function. It has to be passed at the first position to alloc call in-case of an array allocation of objects of type T.
 It represents the required number of members in the array allocation as in CFA's aalloc (FIX ME: cite aalloc).
 This parameter should be of type size\_t.
+This parameter should be of type size_t.
 Example: int a = alloc( 5 )
 …
 \paragraph{Align}
 This parameter is position-free and uses a backtick routine align (`align). The parameter passed with `align should be of type size\_t. If the alignment parameter is not a power of two or is less than the default alignment of the allocator (that can be found out using routine libAlign in CFA) then the passed alignment parameter will be rejected and the default alignment will be used.
+This parameter is position-free and uses a backtick routine align (`align). The parameter passed with `align should be of type size_t. If the alignment parameter is not a power of two or is less than the default alignment of the allocator (that can be found out using routine libAlign in CFA) then the passed alignment parameter will be rejected and the default alignment will be used.
 Example: int b = alloc( 5 , 64`align )
 …
 This parameter is position-free and uses a backtick routine fill (`fill). In case of realloc, only the extra space after copying the data in the old object will be filled with given parameter.
 Three types of parameters can be passed using `fill.
 \begin{itemize}
 \item

doc/theses/mubeen_zulfiqar_MMath/background.tex

-              ra2e4b0c
+              ra51a02d
 ====================
+\section{Background}
+% FIXME: cite wasik
+\cite{wasik.thesis}
+\subsection{Memory Allocation}
+With dynamic allocation being an important feature of C, there are many standalone memory allocators that have been designed for different purposes. For this thesis, we chose 7 of the most popular and widely used memory allocators.
+\paragraph{dlmalloc}
+dlmalloc (FIX ME: cite allocator) is a thread-safe allocator that is single threaded and single heap. dlmalloc maintains free-lists of different sizes to store freed dynamic memory. (FIX ME: cite wasik)
+\paragraph{hoard}
+Hoard (FIX ME: cite allocator) is a thread-safe allocator that is multi-threaded and using a heap layer framework. It has per-thred heaps that have thread-local free-lists, and a gloabl shared heap. (FIX ME: cite wasik)
+\paragraph{jemalloc}
+jemalloc (FIX ME: cite allocator) is a thread-safe allocator that uses multiple arenas. Each thread is assigned an arena. Each arena has chunks that contain contagious memory regions of same size. An arena has multiple chunks that contain regions of multiple sizes.
+\paragraph{ptmalloc}
+ptmalloc (FIX ME: cite allocator) is a modification of dlmalloc. It is a thread-safe multi-threaded memory allocator that uses multiple heaps. ptmalloc heap has similar design to dlmalloc's heap.
+\paragraph{rpmalloc}
+rpmalloc (FIX ME: cite allocator) is a thread-safe allocator that is multi-threaded and uses per-thread heap. Each heap has multiple size-classes and each size-calss contains memory regions of the relevant size.
+\paragraph{tbb malloc}
+tbb malloc (FIX ME: cite allocator) is a thread-safe allocator that is multi-threaded and uses private heap for each thread. Each private-heap has multiple bins of different sizes. Each bin contains free regions of the same size.
+\paragraph{tc malloc}
+tcmalloc (FIX ME: cite allocator) is a thread-safe allocator. It uses per-thread cache to store free objects that prevents contention on shared resources in multi-threaded application. A central free-list is used to refill per-thread cache when it gets empty.
+\subsection{Benchmarks}
+There are multiple benchmarks that are built individually and evaluate different aspects of a memory allocator. But, there is not standard set of benchamrks that can be used to evaluate multiple aspects of memory allocators.
+\paragraph{threadtest}
+(FIX ME: cite benchmark and hoard) Each thread repeatedly allocates and then deallocates 100,000 objects. Runtime of the benchmark evaluates its efficiency.
+\paragraph{shbench}
+(FIX ME: cite benchmark and hoard) Each thread allocates and randomly frees a number of random-sized objects. It is a stress test that also uses runtime to determine efficiency of the allocator.
+\paragraph{larson}
+(FIX ME: cite benchmark and hoard) Larson simulates a server environment. Multiple threads are created where each thread allocator and free a number of objects within a size range. Some objects are passed from threads to the child threads to free. It caluculates memory operations per second as an indicator of memory allocator's performance.
+\cite{Wasik08}

doc/theses/mubeen_zulfiqar_MMath/benchmarks.tex

ra2e4b0c	ra51a02d
149	149	*** FIX ME: Insert a figure of above benchmark with description
150	150
151		\paragraph{Relevant Knobs}
	151	\paragrpah{Relevant Knobs}
152	152	*** FIX ME: Insert Relevant Knobs
153	153

doc/theses/mubeen_zulfiqar_MMath/intro.tex

-              ra2e4b0c
+              ra51a02d
 \begin{itemize}
 \item
 aligned\_alloc
+aligned_alloc
 \item
 malloc\_usable\_size
+malloc_usable_size
 \item
 memalign
 \item
 posix\_memalign
+posix_memalign
 \item
 pvalloc
 …
 With the rise of concurrent applications, memory allocators should be able to fulfill dynamic memory requests from multiple threads in parallel without causing contention on shared resources. There needs to be a set of a standard benchmarks that can be used to evaluate an allocator's performance in different scenerios.
+\section{Background}
+\subsection{Memory Allocation}
+With dynamic allocation being an important feature of C, there are many standalone memory allocators that have been designed for different purposes. For this thesis, we chose 7 of the most popular and widely used memory allocators.
+\paragraph{dlmalloc}
+dlmalloc (FIX ME: cite allocator) is a thread-safe allocator that is single threaded and single heap. dlmalloc maintains free-lists of different sizes to store freed dynamic memory. (FIX ME: cite wasik)
+\paragraph{hoard}
+Hoard (FIX ME: cite allocator) is a thread-safe allocator that is multi-threaded and using a heap layer framework. It has per-thred heaps that have thread-local free-lists, and a gloabl shared heap. (FIX ME: cite wasik)
+\paragraph{jemalloc}
+jemalloc (FIX ME: cite allocator) is a thread-safe allocator that uses multiple arenas. Each thread is assigned an arena. Each arena has chunks that contain contagious memory regions of same size. An arena has multiple chunks that contain regions of multiple sizes.
+\paragraph{ptmalloc}
+ptmalloc (FIX ME: cite allocator) is a modification of dlmalloc. It is a thread-safe multi-threaded memory allocator that uses multiple heaps. ptmalloc heap has similar design to dlmalloc's heap.
+\paragraph{rpmalloc}
+rpmalloc (FIX ME: cite allocator) is a thread-safe allocator that is multi-threaded and uses per-thread heap. Each heap has multiple size-classes and each size-calss contains memory regions of the relevant size.
+\paragraph{tbb malloc}
+tbb malloc (FIX ME: cite allocator) is a thread-safe allocator that is multi-threaded and uses private heap for each thread. Each private-heap has multiple bins of different sizes. Each bin contains free regions of the same size.
+\paragraph{tc malloc}
+tcmalloc (FIX ME: cite allocator) is a thread-safe allocator. It uses per-thread cache to store free objects that prevents contention on shared resources in multi-threaded application. A central free-list is used to refill per-thread cache when it gets empty.
+\subsection{Benchmarks}
+There are multiple benchmarks that are built individually and evaluate different aspects of a memory allocator. But, there is not standard set of benchamrks that can be used to evaluate multiple aspects of memory allocators.
+\paragraph{threadtest}
+(FIX ME: cite benchmark and hoard) Each thread repeatedly allocates and then deallocates 100,000 objects. Runtime of the benchmark evaluates its efficiency.
+\paragraph{shbench}
+(FIX ME: cite benchmark and hoard) Each thread allocates and randomly frees a number of random-sized objects. It is a stress test that also uses runtime to determine efficiency of the allocator.
+\paragraph{larson}
+(FIX ME: cite benchmark and hoard) Larson simulates a server environment. Multiple threads are created where each thread allocator and free a number of objects within a size range. Some objects are passed from threads to the child threads to free. It caluculates memory operations per second as an indicator of memory allocator's performance.
 \section{Research Objectives}

doc/theses/mubeen_zulfiqar_MMath/performance.tex

-              ra2e4b0c
+              ra51a02d
 tc               &             &  \\
 \end{tabularx}
+%(FIX ME: complete table)
+(FIX ME: complete table)
 \section{Experiment Environment}

doc/theses/mubeen_zulfiqar_MMath/uw-ethesis.bib

-              ra2e4b0c
+              ra51a02d
         address =       "Reading, Massachusetts"
+}
-@article{wasik.thesis,
-    author        = "Ayelet Wasik",
-    title         = "Features of A Multi-Threaded Memory Alloator",
-    publisher     = "University of Waterloo",
-    year          = "2008"
+}

doc/theses/mubeen_zulfiqar_MMath/uw-ethesis.tex

-              ra2e4b0c
+              ra51a02d
 \usepackage{graphicx}
 \usepackage{comment} % Removes large sections of the document.
-\usepackage{tabularx}
 % Hyperlinks make it very easy to navigate an electronic document.
 …
 % Tip: Putting each sentence on a new line is a way to simplify later editing.
 %----------------------------------------------------------------------
-\begin{sloppypar}
 \input{intro}
 \input{background}
 …
 \input{performance}
 \input{conclusion}
-\end{sloppypar}
 %----------------------------------------------------------------------

doc/user/user.tex

-              ra2e4b0c
+              ra51a02d
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Sun Oct 10 12:45:00 2021
 %% Update Count     : 5095
+%% Last Modified On : Mon May 31 09:03:34 2021
+%% Update Count     : 5071
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 \CFA provides a fine-grained solution where a \Index{recursive lock} is acquired and released indirectly via a manipulator ©acquire© or instantiating an \Index{RAII} type specific for the kind of stream: ©osacquire©\index{ostream@©ostream©!osacquire@©osacquire©} for output streams and ©isacquire©\index{isacquire@©isacquire©}\index{istream@©istream©!isacquire@©isacquire©} for input streams.
 The common usage is the short form of the mutex statement\index{ostream@©ostream©!mutex@©mutex©} to lock a stream during a single cascaded I/O expression, \eg:
 \begin{cfa}
 $\emph{thread\(_1\)}$ : ®mutex()® sout | "abc " | "def ";
 $\emph{thread\(_2\)}$ : ®mutex()® sout | "uvw " | "xyz ";
+The common usage is manipulator ©acquire©\index{ostream@©ostream©!acquire@©acquire©} to lock a stream during a single cascaded I/O expression, with the manipulator appearing as the first item in a cascade list, \eg:
+\begin{cfa}
+$\emph{thread\(_1\)}$ : sout | ®acquire® | "abc " | "def ";   // manipulator
+$\emph{thread\(_2\)}$ : sout | ®acquire® | "uvw " | "xyz ";
 \end{cfa}
 Now, the order of the thread execution is still non-deterministic, but the output is constrained to two possible lines in either order.
 …
 In summary, the stream lock is acquired by the ©acquire© manipulator and implicitly released at the end of the cascaded I/O expression ensuring all operations in the expression occur atomically.
+To lock a stream across multiple I/O operations, he long form of the mutex statement is used, \eg:
+\begin{cfa}
+®mutex( sout )® {
+To lock a stream across multiple I/O operations, an object of type ©osacquire© or ©isacquire© is declared to implicitly acquire/release the stream lock providing mutual exclusion for the object's duration, \eg:
+\begin{cfa}
+{       // acquire sout for block duration
+        ®osacquire® acq = { sout };                             $\C{// named stream locker}$
         sout | 1;
         ®mutex() sout® | 2 | 3;                         $\C{// unnecessary, but ok because of recursive lock}$
+        sout | ®acquire® | 2 | 3;                               $\C{// unnecessary, but ok to acquire and release again}$
         sout | 4;
 } // implicitly release sout lock
 \end{cfa}
 Note, the unnecessary ©mutex© in the middle of the mutex statement, works because the recursive stream-lock can be acquired/released multiple times by the owner thread.
+}       // implicitly release the lock when "acq" is deallocated
+\end{cfa}
+Note, the unnecessary ©acquire© manipulator works because the recursive stream-lock can be acquired/released multiple times by the owner thread.
 Hence, calls to functions that also acquire a stream lock for their output do not result in \Index{deadlock}.
 The previous values written by threads 1 and 2 can be read in concurrently:
 \begin{cfa}
+®mutex( sin )® {
+{       // acquire sin lock for block duration
+        ®isacquire acq = { sin };®                              $\C{// named stream locker}$
         int x, y, z, w;
         sin | x;
         ®mutex() sin® | y | z;                          $\C{// unnecessary, but ok because of recursive lock}$
+        sin | ®acquire® | y | z;                                $\C{// unnecessary, but ok to acquire and release again}$
         sin | w;
 } // implicitly release sin lock
+}       // implicitly release the lock when "acq" is deallocated
 \end{cfa}
 Again, the order of the reading threads is non-deterministic.
 …
 \Textbf{WARNING:} The general problem of \Index{nested locking} can occur if routines are called in an I/O sequence that block, \eg:
 \begin{cfa}
 ®mutex() sout® | "data:" | rtn( mon );  $\C{// mutex call on monitor}$
+sout | ®acquire® | "data:" | rtn( mon );        $\C{// mutex call on monitor}$
 \end{cfa}
 If the thread executing the I/O expression blocks in the monitor with the ©sout© lock, other threads writing to ©sout© also block until the thread holding the lock is unblocked and releases it.
 …
 \begin{cfa}
 int ®data® = rtn( mon );
 mutex() sout | "data:" | ®data®;
+sout | acquire | "data:" | ®data®;
 \end{cfa}
 …
 \section{String Stream}
+The stream types ©ostrstream© and ©istrstream© provide all the stream formatting capabilities to/from a C string rather than a stream file.
+\VRef[Figure]{f:StringStreamProcessing} shows writing (output) to and reading (input) from a C string.
+The only string stream operations different from a file stream are:
+\begin{itemize}[topsep=4pt,itemsep=2pt,parsep=0pt]
+\item
+constructors to create a stream that writes to a write buffer (©ostrstream©) of ©size©, or reads from a read buffer (©istrstream©) containing a C string terminated with ©'\0'©.
+\begin{cfa}
+void ?{}( ostrstream &, char buf[], size_t size );
+void ?{}( istrstream & is, char buf[] );
+\end{cfa}
+\item
+\Indexc{write} (©ostrstream© only) writes all the buffered characters to the specified stream (©stdout© default).
+\begin{cfa}
+ostrstream & write( ostrstream & os, FILE * stream = stdout );
+\end{cfa}
+There is no ©read© for ©istrstream©.
+\end{itemize}
+All the stream formatting capabilities are available to format text to/from a C string rather than to a stream file.
+\VRef[Figure]{f:StringStreamProcessing} shows writing (output) and reading (input) from a C string.
 \begin{figure}
 \begin{cfa}
 …
         double x = 12345678.9, y = 98765.4321e-11;
         osstr | i | hex(j) | wd(10, k) | sci(x) | unit(eng(y)) | "abc";
         write( osstr ); $\C{// write string to stdout}$
         printf( "%s", buf ); $\C{// same lines of output}$
         sout | i | hex(j) | wd(10, k) | sci(x) | unit(eng(y)) | "abc";
         char buf2[] = "12 14 15 3.5 7e4 abc"; $\C{// input buffer}$
+        osstr | i | hex(j) | wd(10, k) | sci(x) | unit(eng(y)); $\C{// same lines of output}$
+        write( osstr );
+        printf( "%s", buf );
+        sout | i | hex(j) | wd(10, k) | sci(x) | unit(eng(y));
+        char buf2[] = "12 14 15 3.5 7e4"; $\C{// input buffer}$
         ®istrstream isstr = { buf2 };®
+        char s[10];
+        isstr | i | j | k | x | y | s;
+        sout  | i | j | k | x | y | s;
+}
+0x5          7 1.234568e+07 987.654n abc
+0x5          7 1.234568e+07 987.654n abc
+0x5          7 1.234568e+07 987.654n abc
+14 15 3.5 70000. abc
+        isstr | i | j | k | x | y;
+        sout | i | j | k | x | y;
+}
 \end{cfa}
 \caption{String Stream Processing}
 \label{f:StringStreamProcessing}
 \end{figure}
+\VRef[Figure]{f:StringStreamFunctions} shows the string stream operations.
+\begin{itemize}[topsep=4pt,itemsep=2pt,parsep=0pt]
+\item
+\Indexc{write} (©ostrstream© only) writes all the buffered characters to the specified stream (©stdout© default).
+\end{itemize}
+The constructor functions:
+\begin{itemize}[topsep=4pt,itemsep=2pt,parsep=0pt]
+\item
+create a bound stream to a write buffer (©ostrstream©) of ©size© or a read buffer (©istrstream©) containing a C string terminated with ©'\0'©.
+\end{itemize}
+\begin{figure}
+\begin{cfa}
+// *********************************** ostrstream ***********************************
+ostrstream & write( ostrstream & os, FILE * stream = stdout );
+void ?{}( ostrstream &, char buf[], size_t size );
+// *********************************** istrstream ***********************************
+void ?{}( istrstream & is, char buf[] );
+\end{cfa}
+\caption{String Stream Functions}
+\label{f:StringStreamFunctions}
+\end{figure}
 \begin{comment}

libcfa/src/fstream.cfa

-              ra2e4b0c
+              ra51a02d
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Oct 10 11:23:05 2021
 // Update Count     : 512
+// Last Modified On : Tue Sep 21 21:51:38 2021
+// Update Count     : 460
 //
 …
 #define IO_MSG "I/O error: "
+// private
+void ?{}( ofstream & os, void * file ) with( os ) {
+void ?{}( ofstream & os, void * file ) with(os) {
         file$ = file;
         sepDefault$ = true;
 …
         prt$ = false;
         sawNL$ = false;
+        acquired$ = false;
         sepSetCur$( os, sepGet( os ) );
         sepSet( os, " " );
 …
 } // ?{}
+inline bool sepPrt$( ofstream & os ) { setNL$( os, false ); return os.sepOnOff$; }
+inline void sepReset$( ofstream & os ) { os.sepOnOff$ = os.sepDefault$; }
+inline void sepReset$( ofstream & os, bool reset ) { os.sepDefault$ = reset; os.sepOnOff$ = os.sepDefault$; }
+inline const char * sepGetCur$( ofstream & os ) { return os.sepCur$; }
+inline void sepSetCur$( ofstream & os, const char sepCur[] ) { os.sepCur$ = sepCur; }
+inline bool getNL$( ofstream & os ) { return os.sawNL$; }
+inline void setNL$( ofstream & os, bool state ) { os.sawNL$ = state; }
+inline bool getANL$( ofstream & os ) { return os.nlOnOff$; }
+inline bool getPrt$( ofstream & os ) { return os.prt$; }
+inline void setPrt$( ofstream & os, bool state ) { os.prt$ = state; }
+inline void lock( ofstream & os ) with( os ) {  lock( os.lock$ ); }
+inline void unlock( ofstream & os ) { unlock( os.lock$ ); }
+// private
+bool sepPrt$( ofstream & os ) { setNL$( os, false ); return os.sepOnOff$; }
+void sepReset$( ofstream & os ) { os.sepOnOff$ = os.sepDefault$; }
+void sepReset$( ofstream & os, bool reset ) { os.sepDefault$ = reset; os.sepOnOff$ = os.sepDefault$; }
+const char * sepGetCur$( ofstream & os ) { return os.sepCur$; }
+void sepSetCur$( ofstream & os, const char sepCur[] ) { os.sepCur$ = sepCur; }
+bool getNL$( ofstream & os ) { return os.sawNL$; }
+void setNL$( ofstream & os, bool state ) { os.sawNL$ = state; }
+bool getANL$( ofstream & os ) { return os.nlOnOff$; }
+bool getPrt$( ofstream & os ) { return os.prt$; }
+void setPrt$( ofstream & os, bool state ) { os.prt$ = state; }
 // public
 void ?{}( ofstream & os ) { os.file$ = 0p; }
+void ?{}( ofstream & os, const char name[], const char mode[] ) { open( os, name, mode ); }
+void ?{}( ofstream & os, const char name[] ) { open( os, name, "w" ); }
+void ^?{}( ofstream & os ) { close( os ); }
+void ?{}( ofstream & os, const char name[], const char mode[] ) {
+        open( os, name, mode );
+} // ?{}
+void ?{}( ofstream & os, const char name[] ) {
+        open( os, name, "w" );
+} // ?{}
+void ^?{}( ofstream & os ) {
+        close( os );
+} // ^?{}
 void sepOn( ofstream & os ) { os.sepOnOff$ = ! getNL$( os ); }
 …
         if ( &os == &exit ) exit( EXIT_FAILURE );
         if ( &os == &abort ) abort();
+        if ( os.acquired$ ) { os.acquired$ = false; release( os ); }
 } // ends
+bool fail( ofstream & os ) { return os.file$ == 0 || ferror( (FILE *)(os.file$) ); }
+void clear( ofstream & os ) { clearerr( (FILE *)(os.file$) ); }
+int flush( ofstream & os ) { return fflush( (FILE *)(os.file$) ); }
+bool fail( ofstream & os ) {
+        return os.file$ == 0 || ferror( (FILE *)(os.file$) );
+} // fail
+void clear( ofstream & os ) {
+        clearerr( (FILE *)(os.file$) );
+} // clear
+int flush( ofstream & os ) {
+        return fflush( (FILE *)(os.file$) );
+} // flush
 void open( ofstream & os, const char name[], const char mode[] ) {
+        FILE * file;
+    for ( cnt; 10 ) {
+                errno = 0;
+                file = fopen( name, mode );
+          if ( file != 0p || errno != EINTR ) break;            // timer interrupt ?
+          if ( cnt == 9 ) abort( "ofstream open EINTR spinning exceeded" );
+    } // for
+        FILE * file = fopen( name, mode );
         if ( file == 0p ) {
                 throw (Open_Failure){ os };
 …
 } // open
+void open( ofstream & os, const char name[] ) { open( os, name, "w" ); }
+void close( ofstream & os ) with( os ) {
+void open( ofstream & os, const char name[] ) {
+        open( os, name, "w" );
+} // open
+void close( ofstream & os ) with(os) {
   if ( (FILE *)(file$) == 0p ) return;
   if ( (FILE *)(file$) == (FILE *)stdout || (FILE *)(file$) == (FILE *)stderr ) return;
+        int ret;
+    for ( cnt; 10 ) {
+                errno = 0;
+                ret = fclose( (FILE *)(file$) );
+          if ( ret != EOF || errno != EINTR ) break;            // timer interrupt ?
+          if ( cnt == 9 ) abort( "ofstream open EINTR spinning exceeded" );
+    } // for
+        if ( ret == EOF ) {
+        if ( fclose( (FILE *)(file$) ) == EOF ) {
                 throw (Close_Failure){ os };
                 // abort | IO_MSG "close output" | nl | strerror( errno );
         } // if
         file$ = 0p;                                                                                     // safety after close
+        file$ = 0p;
 } // close
 …
         va_list args;
         va_start( args, format );
+        int len;
+    for ( cnt; 10 ) {
+                errno = 0;
+                len = vfprintf( (FILE *)(os.file$), format, args );
+          if ( len != EOF || errno != EINTR ) break;            // timer interrupt ?
+          if ( cnt == 9 ) abort( "ofstream fmt EINTR spinning exceeded" );
+    } // for
+        int len = vfprintf( (FILE *)(os.file$), format, args );
         if ( len == EOF ) {
                 if ( ferror( (FILE *)(os.file$) ) ) {
 …
 } // fmt
-<<<<<<< HEAD
 inline void acquire( ofstream & os ) with(os) {
         lock( lock$ );                                                                          // may increase recursive lock
 …
 void ^?{}( osacquire & acq ) { release( acq.os ); }
-=======
->>>>>>> 15885de998d9500373efda8e609b893c87e6363a
 static ofstream soutFile = { (FILE *)stdout };
 ofstream & sout = soutFile, & stdout = soutFile;
 …
         flush( os );
         return os;
+        // (ofstream &)(os | '\n');
+        // setPrt$( os, false );                                                        // turn off
+        // setNL$( os, true );
+        // flush( os );
+        // return sepOff( os );                                                 // prepare for next line
 } // nl
 …
 // private
 void ?{}( ifstream & is, void * file ) with( is ) {
+void ?{}( ifstream & is, void * file ) with(is) {
         file$ = file;
         nlOnOff$ = false;
+} // ?{}
+bool getANL$( ifstream & os ) { return os.nlOnOff$; }
+inline void lock( ifstream & os ) with( os ) { lock( os.lock$ ); }
+inline void unlock( ifstream & os ) { unlock( os.lock$ ); }
+        acquired$ = false;
+} // ?{}
 // public
 void ?{}( ifstream & is ) { is.file$ = 0p; }
+void ?{}( ifstream & is, const char name[], const char mode[] ) { open( is, name, mode ); }
+void ?{}( ifstream & is, const char name[] ) { open( is, name, "r" ); }
+void ^?{}( ifstream & is ) { close( is ); }
+bool fail( ifstream & is ) { return is.file$ == 0p || ferror( (FILE *)(is.file$) ); }
+void clear( ifstream & is ) { clearerr( (FILE *)(is.file$) ); }
+void ?{}( ifstream & is, const char name[], const char mode[] ) {
+        open( is, name, mode );
+} // ?{}
+void ?{}( ifstream & is, const char name[] ) {
+        open( is, name, "r" );
+} // ?{}
+void ^?{}( ifstream & is ) {
+        close( is );
+} // ^?{}
 void nlOn( ifstream & os ) { os.nlOnOff$ = true; }
 void nlOff( ifstream & os ) { os.nlOnOff$ = false; }
+void ends( ifstream & is ) {}
+bool eof( ifstream & is ) { return feof( (FILE *)(is.file$) ) != 0; }
+bool getANL( ifstream & os ) { return os.nlOnOff$; }
+bool fail( ifstream & is ) {
+        return is.file$ == 0p || ferror( (FILE *)(is.file$) );
+} // fail
+void clear( ifstream & is ) {
+        clearerr( (FILE *)(is.file$) );
+} // clear
+void ends( ifstream & is ) {
+        if ( is.acquired$ ) { is.acquired$ = false; release( is ); }
+} // ends
+bool eof( ifstream & is ) {
+        return feof( (FILE *)(is.file$) );
+} // eof
 void open( ifstream & is, const char name[], const char mode[] ) {
+        FILE * file;
+    for ( cnt; 10 ) {
+                errno = 0;
+                file = fopen( name, mode );
+          if ( file != 0p || errno != EINTR ) break;            // timer interrupt ?
+          if ( cnt == 9 ) abort( "ifstream open EINTR spinning exceeded" );
+    } // for
+        FILE * file = fopen( name, mode );
         if ( file == 0p ) {
                 throw (Open_Failure){ is };
 …
 } // open
+void open( ifstream & is, const char name[] ) { open( is, name, "r" ); }
+void close( ifstream & is ) with( is ) {
+void open( ifstream & is, const char name[] ) {
+        open( is, name, "r" );
+} // open
+void close( ifstream & is ) with(is) {
   if ( (FILE *)(file$) == 0p ) return;
   if ( (FILE *)(file$) == (FILE *)stdin ) return;
+        int ret;
+    for ( cnt; 10 ) {
+                errno = 0;
+                ret = fclose( (FILE *)(file$) );
+          if ( ret != EOF || errno != EINTR ) break;            // timer interrupt ?
+          if ( cnt == 9 ) abort( "ifstream close EINTR spinning exceeded" );
+    } // for
+        if ( ret == EOF ) {
+        if ( fclose( (FILE *)(file$) ) == EOF ) {
                 throw (Close_Failure){ is };
                 // abort | IO_MSG "close input" | nl | strerror( errno );
         } // if
         file$ = 0p;                                                                                     // safety after close
+        file$ = 0p;
 } // close
 …
 int fmt( ifstream & is, const char format[], ... ) {
         va_list args;
         va_start( args, format );
+        int len;
+    for () {                                                                                    // no check for EINTR limit waiting for keyboard input
+                errno = 0;
+                len = vfscanf( (FILE *)(is.file$), format, args );
+          if ( len != EOF || errno != EINTR ) break;            // timer interrupt ?
+    } // for
+        int len = vfscanf( (FILE *)(is.file$), format, args );
         if ( len == EOF ) {
                 if ( ferror( (FILE *)(is.file$) ) ) {
 …
         return len;
 } // fmt
+inline void acquire( ifstream & is ) with(is) {
+        lock( lock$ );                                                                          // may increase recursive lock
+        if ( ! acquired$ ) acquired$ = true;                            // not locked ?
+        else unlock( lock$ );                                                           // unwind recursive lock at start
+} // acquire
+inline void release( ifstream & is ) {
+        unlock( is.lock$ );
+} // release
+void ?{}( isacquire & acq, ifstream & is ) { lock( is.lock$ ); &acq.is = &is; }
+void ^?{}( isacquire & acq ) { release( acq.is ); }
 static ifstream sinFile = { (FILE *)stdin };

libcfa/src/fstream.hfa

-              ra2e4b0c
+              ra51a02d
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Oct 10 09:37:32 2021
 // Update Count     : 243
+// Last Modified On : Wed Jul 28 07:35:50 2021
+// Update Count     : 234
 //
 …
         char tupleSeparator$[ofstream_sepSize];
         multiple_acquisition_lock lock$;
+        bool acquired$;
 }; // ofstream
 …
 void setPrt$( ofstream &, bool );
-void lock( ofstream & );
-void unlock( ofstream & );
 // public
 void sepOn( ofstream & );
 …
 void open( ofstream &, const char name[] );
 void close( ofstream & );
 ofstream & write( ofstream &, const char data[], size_t size );
+void acquire( ofstream & );
+void release( ofstream & );
+void lock( ofstream & );
+void unlock( ofstream & );
+struct osacquire {
+        ofstream & os;
+};
+void ?{}( osacquire & acq, ofstream & );
+void ^?{}( osacquire & acq );
 void ?{}( ofstream & );
 …
         bool nlOnOff$;
         multiple_acquisition_lock lock$;
+        bool acquired$;
 }; // ifstream
 // Satisfies istream
-// private
-bool getANL$( ifstream & );
-void lock( ifstream & );
-void unlock( ifstream & );
 // public
 void nlOn( ifstream & );
 void nlOff( ifstream & );
+bool getANL( ifstream & );
 void ends( ifstream & );
 int fmt( ifstream &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) ));
 …
 void open( ifstream & is, const char name[] );
 void close( ifstream & is );
 ifstream & read( ifstream & is, char data[], size_t size );
 ifstream & ungetc( ifstream & is, char c );
+void acquire( ifstream & is );
+void release( ifstream & is );
+struct isacquire {
+        ifstream & is;
+};
+void ?{}( isacquire & acq, ifstream & is );
+void ^?{}( isacquire & acq );
 void ?{}( ifstream & is );

libcfa/src/iostream.cfa

-              ra2e4b0c
+              ra51a02d
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Oct 10 09:28:17 2021
 // Update Count     : 1345
+// Last Modified On : Sat May 15 09:39:21 2021
+// Update Count     : 1342
 //
 …
                 return os;
         } // nlOff
+} // distribution
+forall( ostype & | ostream( ostype ) ) {
+        ostype & acquire( ostype & os ) {
+                acquire( os );                                                                  // call void returning
+                return os;
+        } // acquire
 } // distribution
 …
                         fmt( is, "%c", &temp );                                         // must pass pointer through varg to fmt
                         // do not overwrite parameter with newline unless appropriate
                         if ( temp != '\n' || getANL$( is ) ) { c = temp; break; }
+                        if ( temp != '\n' || getANL( is ) ) { c = temp; break; }
                         if ( eof( is ) ) break;
                 } // for
 …
                 return is;
         } // nlOff
+} // distribution
+forall( istype & | istream( istype ) ) {
+        istype & acquire( istype & is ) {
+                acquire( is );                                                                  // call void returning
+                return is;
+        } // acquire
 } // distribution

libcfa/src/iostream.hfa

-              ra2e4b0c
+              ra51a02d
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Oct 10 10:02:07 2021
 // Update Count     : 407
+// Last Modified On : Wed Apr 28 20:37:56 2021
+// Update Count     : 401
 //
 …
         void close( ostype & );
         ostype & write( ostype &, const char [], size_t );
+        void acquire( ostype & );                                                       // concurrent access
 }; // ostream
 …
         ostype & nlOn( ostype & );
         ostype & nlOff( ostype & );
+} // distribution
+forall( ostype & | ostream( ostype ) ) {
+        ostype & acquire( ostype & );
 } // distribution
 …
 trait basic_istream( istype & ) {
+        // private
+        bool getANL$( istype & );                                                       // get scan newline (on/off)
+        // public
+        bool getANL( istype & );                                                        // get scan newline (on/off)
         void nlOn( istype & );                                                          // read newline
         void nlOff( istype & );                                                         // scan newline
         void ends( istype & os );                                                       // end of output statement
         int fmt( istype &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) ));
 …
         void close( istype & is );
         istype & read( istype &, char [], size_t );
+        void acquire( istype & );                                                       // concurrent access
 }; // istream
 …
 } // distribution
+forall( istype & | istream( istype ) ) {
+        istype & acquire( istype & );
+} // distribution
 // *********************************** manipulators ***********************************

libcfa/src/strstream.cfa

-              ra2e4b0c
+              ra51a02d
 // Created On       : Thu Apr 22 22:24:35 2021
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Oct 10 16:13:20 2021
 // Update Count     : 101
+// Last Modified On : Tue Apr 27 20:59:53 2021
+// Update Count     : 78
 //
 #include "strstream.hfa"
-#include "fstream.hfa"                                                                  // abort
 #include <stdio.h>                                                                              // vsnprintf
 …
 // private
 inline bool sepPrt$( ostrstream & os ) { setNL$( os, false ); return os.sepOnOff$; }
 inline void sepReset$( ostrstream & os ) { os.sepOnOff$ = os.sepDefault$; }
 inline void sepReset$( ostrstream & os, bool reset ) { os.sepDefault$ = reset; os.sepOnOff$ = os.sepDefault$; }
 inline const char * sepGetCur$( ostrstream & os ) { return os.sepCur$; }
 inline void sepSetCur$( ostrstream & os, const char sepCur[] ) { os.sepCur$ = sepCur; }
 inline bool getNL$( ostrstream & os ) { return os.sawNL$; }
 inline void setNL$( ostrstream & os, bool state ) { os.sawNL$ = state; }
 inline bool getANL$( ostrstream & os ) { return os.nlOnOff$; }
 inline bool getPrt$( ostrstream & os ) { return os.prt$; }
 inline void setPrt$( ostrstream & os, bool state ) { os.prt$ = state; }
+bool sepPrt$( ostrstream & os ) { setNL$( os, false ); return os.sepOnOff$; }
+void sepReset$( ostrstream & os ) { os.sepOnOff$ = os.sepDefault$; }
+void sepReset$( ostrstream & os, bool reset ) { os.sepDefault$ = reset; os.sepOnOff$ = os.sepDefault$; }
+const char * sepGetCur$( ostrstream & os ) { return os.sepCur$; }
+void sepSetCur$( ostrstream & os, const char sepCur[] ) { os.sepCur$ = sepCur; }
+bool getNL$( ostrstream & os ) { return os.sawNL$; }
+void setNL$( ostrstream & os, bool state ) { os.sawNL$ = state; }
+bool getANL$( ostrstream & os ) { return os.nlOnOff$; }
+bool getPrt$( ostrstream & os ) { return os.prt$; }
+void setPrt$( ostrstream & os, bool state ) { os.prt$ = state; }
 // public
 …
 // *********************************** istrstream ***********************************
-// private
-bool getANL$( istrstream & is ) { return is.nlOnOff$; }
 // public
 …
 } // ?{}
+bool getANL( istrstream & is ) { return is.nlOnOff$; }
 void nlOn( istrstream & is ) { is.nlOnOff$ = true; }
 void nlOff( istrstream & is ) { is.nlOnOff$ = false; }
 void ends( istrstream & is ) {}
+bool eof( istrstream & is ) { return false; }
+void ends( istrstream & is ) {
+} // ends
+int fmt( istrstream & is, const char format[], ... ) with(is) {
+        va_list args;
+        va_start( args, format );
+        // THIS DOES NOT WORK BECAUSE VSSCANF RETURNS NUMBER OF VALUES READ VERSUS BUFFER POSITION SCANNED.
+        int len = vsscanf( buf$ + cursor$, format, args );
+        va_end( args );
+        if ( len == EOF ) {
+                abort | IO_MSG "invalid read";
+        } // if
+        // SKULLDUGGERY: This hack skips over characters read by vsscanf by moving to the next whitespace but it does not
+        // handle C reads with wdi manipulators that leave the cursor at a non-whitespace character.
+        for ( ; buf$[cursor$] != ' ' && buf$[cursor$] != '\t' && buf$[cursor$] != '\0'; cursor$ += 1 ) {
+                //printf( "X \'%c\'\n", buf$[cursor$] );
+        } // for
+        if ( buf$[cursor$] != '\0' ) cursor$ += 1;      // advance to whitespace
+        return len;
+} // fmt
+int eof( istrstream & is ) {
+        return 0;
+} // eof
 istrstream &ungetc( istrstream & is, char c ) {
 …
 } // ungetc
+int fmt( istrstream & is, const char format[], ... ) {
+        va_list args;
+        va_start( args, format );
+        // This does not work because vsscanf does not return buffer position.
+        int len = vsscanf( is.buf$ + is.cursor$, format, args );
+        va_end( args );
+        if ( len == EOF ) {
+                int j;
+                printf( "X %d%n\n", len, &j );
+        } // if
+        is.cursor$ += len;
+        return len;
+} // fmt
 // Local Variables: //
 // tab-width: 4 //

libcfa/src/strstream.hfa

-              ra2e4b0c
+              ra51a02d
 // Created On       : Thu Apr 22 22:20:59 2021
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Oct 10 10:14:22 2021
 // Update Count     : 47
+// Last Modified On : Tue Apr 27 20:58:50 2021
+// Update Count     : 41
 //
 …
 // Satisfies basic_istream
-// private
-bool getANL$( istrstream & );
 // public
+bool getANL( istrstream & );
 void nlOn( istrstream & );
 void nlOff( istrstream & );
 void ends( istrstream & );
+int fmt( istrstream &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) ));
+istrstream & ungetc( istrstream & is, char c );
+int eof( istrstream & is );
+int fmt( istrstream &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) ));
+istrstream & ungetc( istrstream &, char );
+bool eof( istrstream & );
+void ?{}( istrstream &, char buf[] );
+void ?{}( istrstream & is, char buf[] );
 // Local Variables: //

src/AST/Pass.hpp

-              ra2e4b0c
+              ra51a02d
         /// When this node is finished being visited, restore the value of a variable
-        /// You may assign to the return value to set the new value in the same statement.
         template< typename T >
         T& GuardValue( T& val ) {
+        void GuardValue( T& val ) {
                 at_cleanup( [ val ]( void * newVal ) {
                         * static_cast< T * >( newVal ) = val;
                 }, static_cast< void * >( & val ) );
-                return val;
+        }
 …
 };
-/// Used to get a pointer to the wrapping TranslationUnit.
-struct WithConstTranslationUnit {
-        const TranslationUnit * translationUnit = nullptr;
-        const TranslationUnit & transUnit() const {
-                assertf( translationUnit, "WithConstTranslationUnit not set-up." );
-                return *translationUnit;
+        }
-};
+}

src/AST/Pass.impl.hpp

-              ra2e4b0c
+              ra51a02d
 template< typename core_t >
 inline void ast::accept_all( ast::TranslationUnit & unit, ast::Pass< core_t > & visitor ) {
+        if ( auto ptr = __pass::translation_unit::get_cptr( visitor.core, 0 ) ) {
+                ValueGuard<const TranslationUnit *> guard( *ptr );
+                *ptr = &unit;
+                return ast::accept_all( unit.decls, visitor );
+        } else {
+                return ast::accept_all( unit.decls, visitor );
+        }
+        return ast::accept_all( unit.decls, visitor );
+}

src/AST/Pass.proto.hpp

-              ra2e4b0c
+              ra51a02d
         } // namespace forall
-        // For passes that need access to the global context. Sreaches `translationUnit`
-        namespace translation_unit {
-                template<typename core_t>
-                static inline auto get_cptr( core_t & core, int )
-                                -> decltype( &core.translationUnit ) {
-                        return &core.translationUnit;
+                }
-                template<typename core_t>
-                static inline const TranslationUnit ** get_cptr( core_t &, long ) {
-                        return nullptr;
+                }
+        }
         template<typename core_t>
         static inline auto get_result( core_t & core, char ) -> decltype( core.result() ) {

src/AST/TranslationUnit.hpp

-              ra2e4b0c
+              ra51a02d
         std::list< ptr< Decl > > decls;
         struct Global {
+        struct Globals {
                 std::map< UniqueId, Decl * > idMap;
                 ptr<Type> sizeType;
+                const Type * sizeType;
                 const FunctionDecl * dereference;
                 const StructDecl * dtorStruct;

src/AST/porting.md

ra2e4b0c	ra51a02d
98	98	* `Initializer` => `ast::Init`
99	99	* `Statement` => `ast::Stmt`
100		* `ReferenceToType` => `ast::BaseInstType`
101	100	* any field names should follow a similar renaming
102	101	* because they don't really belong to `Type` (and for consistency with `Linkage::Spec`):

src/CodeTools/DeclStats.cc

-              ra2e4b0c
+              ra51a02d
                 /// number of counting bins for linkages
                 static const unsigned n_named_specs = 8;
+                /// Mapping function from linkage to bin.
+                static unsigned linkage_index( LinkageSpec::Spec spec ) {
+                        switch ( spec ) {
+                        case LinkageSpec::Intrinsic:  return 0;
+                        case LinkageSpec::C:          return 1;
+                        case LinkageSpec::Cforall:    return 2;
+                        case LinkageSpec::AutoGen:    return 3;
+                        case LinkageSpec::Compiler:   return 4;
+                        case LinkageSpec::BuiltinCFA: return 5;
+                        case LinkageSpec::BuiltinC:   return 6;
+                        default:                      return 7;
+                        }
+                }
+                /// map from total number of specs to bins
+                static const unsigned ind_for_linkage[16];
                 Stats for_linkage[n_named_specs];            ///< Stores separate stats per linkage
 …
                         const std::string& mangleName = decl->get_mangleName().empty() ? decl->name : decl->get_mangleName();
                         if ( seen_names.insert( mangleName ).second ) {
                                 Stats& stats = for_linkage[ linkage_index( decl->linkage ) ];
+                                Stats& stats = for_linkage[ ind_for_linkage[ decl->linkage ] ];
                                 ++stats.n_decls;
 …
         };
+        const unsigned DeclStats::ind_for_linkage[]
+                = { 7, 7, 2, 1,   7, 7, 7, 3,   4, 7, 6, 5,   7, 7, 7, 0 };
         void printDeclStats( std::list< Declaration * > &translationUnit ) {
                 PassVisitor<DeclStats> stats;

src/Common/module.mk

-              ra2e4b0c
+              ra51a02d
       Common/CompilerError.h \
       Common/Debug.h \
-      Common/DeclStats.hpp \
-      Common/DeclStats.cpp \
       Common/ErrorObjects.h \
       Common/Eval.cc \
 …
       Common/PassVisitor.proto.h \
       Common/PersistentMap.h \
-      Common/ResolvProtoDump.hpp \
-      Common/ResolvProtoDump.cpp \
       Common/ScopedMap.h \
       Common/SemanticError.cc \

src/InitTweak/GenInit.cc

-              ra2e4b0c
+              ra51a02d
 // Author           : Rob Schluntz
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Mon Oct 25 13:53:00 2021
 // Update Count     : 186
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Dec 13 23:15:10 2019
+// Update Count     : 184
 //
 #include "GenInit.h"
 …
 #include "AST/Decl.hpp"
 #include "AST/Init.hpp"
-#include "AST/Pass.hpp"
 #include "AST/Node.hpp"
 #include "AST/Stmt.hpp"
 …
+        }
-namespace {
-#       warning Remove the _New suffix after the conversion is complete.
-        struct HoistArrayDimension_NoResolve_New final :
-                        public ast::WithDeclsToAdd<>, public ast::WithShortCircuiting,
-                        public ast::WithGuards, public ast::WithConstTranslationUnit,
-                        public ast::WithVisitorRef<HoistArrayDimension_NoResolve_New> {
-                void previsit( const ast::ObjectDecl * decl );
-                const ast::DeclWithType * postvisit( const ast::ObjectDecl * decl );
-                // Do not look for objects inside there declarations (and type).
-                void previsit( const ast::AggregateDecl * ) { visit_children = false; }
-                void previsit( const ast::NamedTypeDecl * ) { visit_children = false; }
-                void previsit( const ast::FunctionType * ) { visit_children = false; }
-                const ast::Type * hoist( const ast::Type * type );
-                ast::Storage::Classes storageClasses;
-        };
-        void HoistArrayDimension_NoResolve_New::previsit(
-                        const ast::ObjectDecl * decl ) {
-                GuardValue( storageClasses ) = decl->storage;
+        }
-        const ast::DeclWithType * HoistArrayDimension_NoResolve_New::postvisit(
-                        const ast::ObjectDecl * objectDecl ) {
-                return mutate_field( objectDecl, &ast::ObjectDecl::type,
-                                hoist( objectDecl->type ) );
+        }
-        const ast::Type * HoistArrayDimension_NoResolve_New::hoist(
-                        const ast::Type * type ) {
-                static UniqueName dimensionName( "_array_dim" );
-                if ( !isInFunction() || storageClasses.is_static ) {
-                        return type;
+                }
-                if ( auto arrayType = dynamic_cast< const ast::ArrayType * >( type ) ) {
-                        if ( nullptr == arrayType->dimension ) {
-                                return type;
+                        }
-                        if ( !Tuples::maybeImpure( arrayType->dimension ) ) {
-                                return type;
+                        }
-                        ast::ptr<ast::Type> dimType = transUnit().global.sizeType;
-                        assert( dimType );
-                        add_qualifiers( dimType, ast::CV::Qualifiers( ast::CV::Const ) );
-                        ast::ObjectDecl * arrayDimension = new ast::ObjectDecl(
-                                arrayType->dimension->location,
-                                dimensionName.newName(),
-                                dimType,
-                                new ast::SingleInit(
-                                        arrayType->dimension->location,
-                                        arrayType->dimension
+                                )
-                        );
-                        ast::ArrayType * mutType = ast::mutate( arrayType );
-                        mutType->dimension = new ast::VariableExpr(
-                                        arrayDimension->location, arrayDimension );
-                        declsToAddBefore.push_back( arrayDimension );
-                        mutType->base = hoist( mutType->base );
-                        return mutType;
+                }
-                return type;
+        }
-        struct ReturnFixer_New final :
-                        public ast::WithStmtsToAdd<>, ast::WithGuards {
-                void previsit( const ast::FunctionDecl * decl );
-                const ast::ReturnStmt * previsit( const ast::ReturnStmt * stmt );
-        private:
-                const ast::FunctionDecl * funcDecl = nullptr;
-        };
-        void ReturnFixer_New::previsit( const ast::FunctionDecl * decl ) {
-                GuardValue( funcDecl ) = decl;
+        }
-        const ast::ReturnStmt * ReturnFixer_New::previsit(
-                        const ast::ReturnStmt * stmt ) {
-                auto & returns = funcDecl->returns;
-                assert( returns.size() < 2 );
-                // Hands off if the function returns a reference.
-                // Don't allocate a temporary if the address is returned.
-                if ( stmt->expr && 1 == returns.size() ) {
-                        ast::ptr<ast::DeclWithType> retDecl = returns.front();
-                        if ( isConstructable( retDecl->get_type() ) ) {
-                                // Explicitly construct the return value using the return
-                                // expression and the retVal object.
-                                assertf( "" != retDecl->name,
-                                        "Function %s has unnamed return value.\n",
-                                        funcDecl->name.c_str() );
-                                auto retVal = retDecl.strict_as<ast::ObjectDecl>();
-                                if ( auto varExpr = stmt->expr.as<ast::VariableExpr>() ) {
-                                        // Check if the return statement is already set up.
-                                        if ( varExpr->var == retVal ) return stmt;
+                                }
-                                ast::ptr<ast::Stmt> ctorStmt = genCtorDtor(
-                                        retVal->location, "?{}", retVal, stmt->expr );
-                                assertf( ctorStmt,
-                                        "ReturnFixer: genCtorDtor returned nllptr: %s / %s",
-                                        toString( retVal ).c_str(),
-                                        toString( stmt->expr ).c_str() );
-                                        stmtsToAddBefore.push_back( ctorStmt );
-                                // Return the retVal object.
-                                ast::ReturnStmt * mutStmt = ast::mutate( stmt );
-                                mutStmt->expr = new ast::VariableExpr(
-                                        stmt->location, retDecl );
-                                return mutStmt;
+                        }
+                }
-                return stmt;
+        }
-} // namespace
-        void genInit( ast::TranslationUnit & transUnit ) {
-                ast::Pass<HoistArrayDimension_NoResolve_New>::run( transUnit );
-                ast::Pass<ReturnFixer_New>::run( transUnit );
+        }
         void CtorDtor::generateCtorDtor( std::list< Declaration * > & translationUnit ) {
                 PassVisitor<CtorDtor> ctordtor;

src/InitTweak/GenInit.h

-              ra2e4b0c
+              ra51a02d
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Fri Oct 22 16:08:00 2021
 // Update Count     : 6
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat Jul 22 09:31:19 2017
+// Update Count     : 4
 //
 …
         /// Adds return value temporaries and wraps Initializers in ConstructorInit nodes
         void genInit( std::list< Declaration * > & translationUnit );
-        void genInit( ast::TranslationUnit & translationUnit );
         /// Converts return statements into copy constructor calls on the hidden return variable

src/Parser/parser.yy

-              ra2e4b0c
+              ra51a02d
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Oct 15 09:20:17 2021
 // Update Count     : 5163
+// Last Modified On : Sat Sep 11 08:20:44 2021
+// Update Count     : 5040
 //
 …
 // from ANSI90 to ANSI11 C are marked with the comment "C99/C11".
 // This grammar also has two levels of extensions. The first extensions cover most of the GCC C extensions. All of the
+// This grammar also has two levels of extensions. The first extensions cover most of the GCC C extensions All of the
 // syntactic extensions for GCC C are marked with the comment "GCC". The second extensions are for Cforall (CFA), which
 // fixes several of C's outstanding problems and extends C with many modern language concepts. All of the syntactic
 …
         // 2. String encodings are transformed into canonical form (one encoding at start) so the encoding can be found
         //    without searching the string, e.g.: "abc" L"def" L"ghi" => L"abc" "def" "ghi". Multiple encodings must match,
         //    e.g., u"a" U"b" L"c" is disallowed.
+        //    i.e., u"a" U"b" L"c" is disallowed.
         if ( from[0] != '"' ) {                                                         // encoding ?
 …
 %token ATassign                                                                                 // @=
+%type<tok> identifier                                   identifier_at                           identifier_or_type_name         attr_name
+%type<tok> identifier
+%type<tok> identifier_or_type_name  attr_name
 %type<tok> quasi_keyword
 %type<constant> string_literal
 …
 %type<en> conditional_expression                constant_expression                     assignment_expression           assignment_expression_opt
 %type<en> comma_expression                              comma_expression_opt
 %type<en> argument_expression_list_opt  argument_expression_list        argument_expression                     default_initializer_opt
+%type<en> argument_expression_list_opt  argument_expression                     default_initializer_opt
 %type<ifctl> if_control_expression
 %type<fctl> for_control_expression              for_control_expression_list
 …
         IDENTIFIER
         | quasi_keyword
+        ;
-identifier_at:
-        identifier
         | '@'                                                                                           // CFA
                 { Token tok = { new string( DeclarationNode::anonymous.newName() ), yylval.tok.loc }; $$ = tok; }
 …
         // empty
                 { $$ = nullptr; }
+        | argument_expression_list
+        ;
+argument_expression_list:
+        argument_expression
+        | argument_expression
         | argument_expression_list_opt ',' argument_expression
                 { $$ = (ExpressionNode *)($1->set_last( $3 )); }
 …
         | FLOATINGconstant fraction_constants_opt
                 { $$ = new ExpressionNode( build_field_name_fraction_constants( build_field_name_FLOATINGconstant( *$1 ), $2 ) ); }
         | identifier_at fraction_constants_opt                          // CFA, allow anonymous fields
+        | identifier fraction_constants_opt
+                {
                         $$ = new ExpressionNode( build_field_name_fraction_constants( build_varref( $1 ), $2 ) );
 …
         comma_expression_opt ';'
                 { $$ = new StatementNode( build_expr( $1 ) ); }
-        | MUTEX '(' ')' comma_expression ';'
-                { $$ = new StatementNode( build_mutex( nullptr, new StatementNode( build_expr( $4 ) ) ) ); }
-                // { SemanticError( yylloc, "Mutex expression is currently unimplemented." ); $$ = nullptr; }
+        ;
 …
 iteration_statement:
+        WHILE '(' ')' statement                                                         // CFA => while ( 1 )
+        WHILE '(' push if_control_expression ')' statement pop
+                { $$ = new StatementNode( build_while( $4, maybe_build_compound( $6 ) ) ); }
+        | WHILE '(' ')' statement                                                       // CFA => while ( 1 )
                 { $$ = new StatementNode( build_while( new IfCtrl( nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ), maybe_build_compound( $4 ) ) ); }
+        | WHILE '(' if_control_expression ')' statement         %prec THEN
+                { $$ = new StatementNode( build_while( $3, maybe_build_compound( $5 ) ) ); }
+        | WHILE '(' if_control_expression ')' statement ELSE statement // CFA
+                { SemanticError( yylloc, "Loop default block is currently unimplemented." ); $$ = nullptr; }
+        | DO statement WHILE '(' comma_expression ')' ';'
+                { $$ = new StatementNode( build_do_while( $5, maybe_build_compound( $2 ) ) ); }
         | DO statement WHILE '(' ')' ';'                                        // CFA => do while( 1 )
                 { $$ = new StatementNode( build_do_while( new ExpressionNode( build_constantInteger( *new string( "1" ) ) ), maybe_build_compound( $2 ) ) ); }
+        | DO statement WHILE '(' comma_expression ')' ';'       %prec THEN
+                { $$ = new StatementNode( build_do_while( $5, maybe_build_compound( $2 ) ) ); }
+        | DO statement WHILE '(' comma_expression ')' ELSE statement // CFA
+                { SemanticError( yylloc, "Loop default block is currently unimplemented." ); $$ = nullptr; }
+        | FOR '(' push for_control_expression_list ')' statement pop
+                { $$ = new StatementNode( build_for( $4, maybe_build_compound( $6 ) ) ); }
         | FOR '(' ')' statement                                                         // CFA => for ( ;; )
                 { $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), maybe_build_compound( $4 ) ) ); }
-        | FOR '(' for_control_expression_list ')' statement     %prec THEN
-                { $$ = new StatementNode( build_for( $3, maybe_build_compound( $5 ) ) ); }
-        | FOR '(' for_control_expression_list ')' statement ELSE statement // CFA
-                { SemanticError( yylloc, "Loop default block is currently unimplemented." ); $$ = nullptr; }
+        ;
 …
 with_statement:
         WITH '(' tuple_expression_list ')' statement
+                { $$ = new StatementNode( build_with( $3, $5 ) ); }
+                {
+                        $$ = new StatementNode( build_with( $3, $5 ) );
+                }
+        ;
 // If MUTEX becomes a general qualifier, there are shift/reduce conflicts, so change syntax to "with mutex".
 mutex_statement:
         MUTEX '(' argument_expression_list ')' statement
+        MUTEX '(' argument_expression_list_opt ')' statement
                 { $$ = new StatementNode( build_mutex( $3, $5 ) ); }
+        ;
 …
 designation:
         designator_list ':'                                                                     // C99, CFA uses ":" instead of "="
         | identifier_at ':'                                                                     // GCC, field name
+        | identifier ':'                                                                        // GCC, field name
                 { $$ = new ExpressionNode( build_varref( $1 ) ); }
+        ;
 …
 designator:
         '.' identifier_at                                                                       // C99, field name
+        '.' identifier                                                                          // C99, field name
                 { $$ = new ExpressionNode( build_varref( $2 ) ); }
         | '[' push assignment_expression pop ']'                        // C99, single array element
 …
 paren_identifier:
         identifier_at
+        identifier
                 { $$ = DeclarationNode::newName( $1 ); }
         | '(' paren_identifier ')'                                                      // redundant parenthesis

src/main.cc

-              ra2e4b0c
+              ra51a02d
 // Author           : Peter Buhr and Rob Schluntz
 // Created On       : Fri May 15 23:12:02 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Fri Oct 22 16:06:00 2021
 // Update Count     : 653
+// Last Modified By : Henry Xue
+// Last Modified On : Mon Aug 23 15:42:08 2021
+// Update Count     : 650
 //
 …
 #include "Common/CodeLocationTools.hpp"     // for forceFillCodeLocations
 #include "Common/CompilerError.h"           // for CompilerError
-#include "Common/DeclStats.hpp"             // for printDeclStats
-#include "Common/ResolvProtoDump.hpp"       // for dumpAsResolverProto
 #include "Common/Stats.h"
 #include "Common/PassVisitor.h"
 …
                 PASS( "Fix Labels", ControlStruct::fixLabels( translationUnit ) );
                 PASS( "Fix Names", CodeGen::fixNames( translationUnit ) );
+                PASS( "Gen Init", InitTweak::genInit( translationUnit ) );
+                if ( libcfap ) {
+                        // generate the bodies of cfa library functions
+                        LibCfa::makeLibCfa( translationUnit );
+                } // if
+                if ( declstatsp ) {
+                        CodeTools::printDeclStats( translationUnit );
+                        deleteAll( translationUnit );
+                        return EXIT_SUCCESS;
+                } // if
+                if ( bresolvep ) {
+                        dump( translationUnit );
+                        return EXIT_SUCCESS;
+                } // if
                 CodeTools::fillLocations( translationUnit );
+                if ( resolvprotop ) {
+                        CodeTools::dumpAsResolvProto( translationUnit );
+                        return EXIT_SUCCESS;
+                } // if
                 if( useNewAST ) {
 …
                         auto transUnit = convert( move( translationUnit ) );
-                        forceFillCodeLocations( transUnit );
-                        PASS( "Gen Init", InitTweak::genInit( transUnit ) );
                         PASS( "Expand Member Tuples" , Tuples::expandMemberTuples( transUnit ) );
+                        if ( libcfap ) {
+                                // Generate the bodies of cfa library functions.
+                                LibCfa::makeLibCfa( transUnit );
+                        } // if
+                        if ( declstatsp ) {
+                                printDeclStats( transUnit );
+                                return EXIT_SUCCESS;
+                        } // if
+                        if ( bresolvep ) {
+                                dump( move( transUnit ) );
+                                return EXIT_SUCCESS;
+                        } // if
+                        if ( resolvprotop ) {
+                                dumpAsResolverProto( transUnit );
+                                return EXIT_SUCCESS;
+                        } // if
                         PASS( "Resolve", ResolvExpr::resolve( transUnit ) );
                         if ( exprp ) {
 …
                         PASS( "Fix Init", InitTweak::fix(transUnit, buildingLibrary()));
                         translationUnit = convert( move( transUnit ) );
                 } else {
-                        PASS( "Gen Init", InitTweak::genInit( translationUnit ) );
                         PASS( "Expand Member Tuples" , Tuples::expandMemberTuples( translationUnit ) );
-                        if ( libcfap ) {
-                                // Generate the bodies of cfa library functions.
-                                LibCfa::makeLibCfa( translationUnit );
-                        } // if
-                        if ( declstatsp ) {
-                                CodeTools::printDeclStats( translationUnit );
-                                deleteAll( translationUnit );
-                                return EXIT_SUCCESS;
-                        } // if
-                        if ( bresolvep ) {
-                                dump( translationUnit );
-                                return EXIT_SUCCESS;
-                        } // if
-                        CodeTools::fillLocations( translationUnit );
-                        if ( resolvprotop ) {
-                                CodeTools::dumpAsResolvProto( translationUnit );
-                                return EXIT_SUCCESS;
-                        } // if
                         PASS( "Resolve", ResolvExpr::resolve( translationUnit ) );

tests/concurrent/semaphore.cfa

-              ra2e4b0c
+              ra51a02d
 #include <locks.hfa>
 #include <thread.hfa>
-#include <mutex_stmt.hfa>
 enum { num_blockers = 17, num_unblockers = 13 };
 …
                 thrash();
                 P(ben);
                 if(((thread&)this).seqable.next != 0p) mutex(sout) sout | "Link not invalidated";
+                if(((thread&)this).seqable.next != 0p) sout | acquire |"Link not invalidated";
                 thrash();
+        }

tests/concurrent/sleep.cfa

-              ra2e4b0c
+              ra51a02d
 #include <fstream.hfa>
 #include <thread.hfa>
-#include <mutex_stmt.hfa>
 #include <time.hfa>
 …
 int main() {
         mutex( sout ) sout | "start";
+        sout | acquire | "start";
+        {
                 slow_sleeper slow;
 …
                 yield();
+        }
         mutex( sout ) sout | "done";
+        sout | acquire | "done";
+}

tests/io/io-acquire.cfa

-              ra2e4b0c
+              ra51a02d
 // Created On       : Mon Mar  1 18:40:09 2021
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Oct  6 18:04:58 2021
 // Update Count     : 72
+// Last Modified On : Tue Apr 27 11:49:34 2021
+// Update Count     : 18
 //
 #include <fstream.hfa>
 #include <thread.hfa>
-#include <mutex_stmt.hfa>
 thread T {};
 …
         // output from parallel threads should not be scrambled
         for ( 100 ) {                                                                           // expression protection
                 mutex(sout) sout | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+        for ( 100 ) {                                                                           // local protection
+                sout | acquire | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+        }
+        mutex( sout ) {                                                                         // statement protection
+        {                                                                                                       // global protection (RAII)
+                osacquire acq = { sout };
                 for ( 100 ) {
                         sout | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
 …
+        }
         {                                                                                                       // duplicate protection demonstrating recursive lock
+                ofstream & h1( ofstream & os ) {                                // helper
+                        mutex( os ) return os | 1 | 2 | 3 | 4;          // unnecessary mutex
+                }
+                ofstream & h2( ofstream & os ) {                                // helper
+                        mutex( os ) return os | 6 | 7 | 8 | 9;          // unnecessary mutex
+                }
+                mutex( sout ) {                                                                 // unnecessary mutex
+                        for ( 100 ) {
+                                mutex( sout ) {
+                                        sout | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+                                        sout | h1 | 5 | h2;                                     // refactored code
+                                }
+                        }
+                osacquire acq = { sout };
+                for ( 100 ) {
+                        osacquire acq = { sout };
+                        sout | acquire | 1 | 2 | 3 | 4 | 5 | acquire | 6 | 7 | 8 | 9;
+                        sout | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+                }
+        }
 …
         int a, b, c, d, e, f, g, h, i;
         for ( 100 ) {                                                                           // expression protection
                 mutex(sin) sin | a | b | c | d | e | f | g | h | i;
+        for ( 100 ) {                                                                           // local protection
+                sin | acquire | a | b | c | d | e | f | g | h | i;
+        }
+        mutex( sin ) {                                                                          // statement protection
+        {                                                                                                       // global protection (RAII)
+                isacquire acq = { sin };
                 for ( 100 ) {
                         sin  | a | b | c | d | e | f | g | h | i;
 …
+        }
         {                                                                                                       // duplicate protection demonstrating recursive lock
+                ifstream & h1( ifstream & is ) {                                // helper
+                        mutex( is ) return is | a | b | c | d;          // unnecessary mutex
+                }
+                ifstream & h2( ifstream & is ) {                                // helper
+                        mutex( is ) return is | f | g | h | i;          // unnecessary mutex
+                }
+                mutex( sin ) {                                                                  // unnecessary mutex
+                        for ( 5 ) {
+                                mutex( sin ) {
+                                        sin  | a | b | c | d | e | f | g | h | i;
+                                        sin  | h1 | e | h2;                                     // refactored code
+                                }
+                        }
+                isacquire acq = { sin };
+                for ( 100 ) {
+                        isacquire acq = { sin };
+                        sin | acquire | a | b | c | d | e | acquire | f | g | h | i;
+                        sin | a | b | c | d | e | f | g | h | i;
+                }
+        }

tests/linking/io-acquire.cfa

-              ra2e4b0c
+              ra51a02d
 #include <fstream.hfa>
 #include <stdlib.hfa>
-#include <mutex_stmt.hfa>
 int main() {
         int i;
         if(threading_enabled()) {
                 mutex( stdout ) stdout | "YES";
+                stdout | acquire | "YES";
                 stdin | i;
         } else {
                 mutex( stdout ) stdout | "NO";
+                stdout | acquire | "NO";
                 stdin | i;
+        }

tests/pybin/test_run.py

-              ra2e4b0c
+              ra51a02d
         def toString( cls, retcode, duration ):
                 if settings.generating :
                         if   retcode == TestResult.SUCCESS:     key = 'pass'; text = "Done   "
                         elif retcode == TestResult.TIMEOUT:     key = 'time'; text = "TIMEOUT"
                         else :  key = 'fail';   text = "ERROR code %d" % retcode
+                        if   retcode == TestResult.SUCCESS:     text = "Done   "
+                        elif retcode == TestResult.TIMEOUT:     text = "TIMEOUT"
+                        else :                                          text = "ERROR code %d" % retcode
                 else :
                         if   retcode == TestResult.SUCCESS:     key = 'pass'; text = "PASSED "
                         elif retcode == TestResult.TIMEOUT:     key = 'time'; text = "TIMEOUT"
                         else :  key = 'fail';   text = "FAILED with code %d" % retcode
+                        if   retcode == TestResult.SUCCESS:     text = "PASSED "
+                        elif retcode == TestResult.TIMEOUT:     text = "TIMEOUT"
+                        else :                                          text = "FAILED with code %d" % retcode
                 text += "    C%s - R%s" % (fmtDur(duration[0]), fmtDur(duration[1]))
                 return key, text
+                return text

tests/test.py

-              ra2e4b0c
+              ra51a02d
                 # update output based on current action
                 result_key, result_txt = TestResult.toString( retcode, duration )
+                result_txt = TestResult.toString( retcode, duration )
                 #print result with error if needed
 …
                         text = text + '\n' + error
                 return retcode == TestResult.SUCCESS, result_key, text
+                return retcode == TestResult.SUCCESS, text
         except KeyboardInterrupt:
                 return False, 'keybrd', ""
+                return False, ""
         # except Exception as ex:
         #       print("Unexpected error in worker thread running {}: {}".format(t.target(), ex), file=sys.stderr)
 …
         failed = False
-        rescnts = {     'pass': 0, 'fail': 0, 'time': 0, 'keybrd': 0 }
-        other = 0
         # for each test to run
 …
+                )
+                for i, (succ, code, txt) in enumerate(timed(results, timeout = settings.timeout.total), 1) :
+                        if code in rescnts.keys():
+                                rescnts[code] += 1
+                        else:
+                                other += 1
+                for i, (succ, txt) in enumerate(timed(results, timeout = settings.timeout.total), 1) :
                         if not succ :
                                 failed = True
 …
         # clean the workspace
         make('clean', output_file=subprocess.DEVNULL, error=subprocess.DEVNULL)
-        print("{} passes, {} failures, {} timeouts, {} cancelled, {} other".format(rescnts['pass'], rescnts['fail'], rescnts['time'], rescnts['keybrd'], other))
         return failed
 …
                         failed = run_tests(local_tests, options.jobs)
                         if failed:
+                                result = 1
                                 if not settings.continue_:
                                         break

Context Navigation

Changes in / [a2e4b0c:a51a02d]

Legend:

doc/theses/mubeen_zulfiqar_MMath/allocator.tex

doc/theses/mubeen_zulfiqar_MMath/background.tex

doc/theses/mubeen_zulfiqar_MMath/benchmarks.tex

doc/theses/mubeen_zulfiqar_MMath/intro.tex

doc/theses/mubeen_zulfiqar_MMath/performance.tex

doc/theses/mubeen_zulfiqar_MMath/uw-ethesis.bib

doc/theses/mubeen_zulfiqar_MMath/uw-ethesis.tex

doc/user/user.tex

libcfa/src/fstream.cfa

libcfa/src/fstream.hfa

libcfa/src/iostream.cfa

libcfa/src/iostream.hfa

libcfa/src/strstream.cfa

libcfa/src/strstream.hfa

src/AST/Pass.hpp

src/AST/Pass.impl.hpp

src/AST/Pass.proto.hpp

src/AST/TranslationUnit.hpp

src/AST/porting.md

src/CodeTools/DeclStats.cc

src/Common/module.mk

src/InitTweak/GenInit.cc

src/InitTweak/GenInit.h

src/Parser/parser.yy

src/main.cc

tests/concurrent/semaphore.cfa

tests/concurrent/sleep.cfa

tests/io/io-acquire.cfa

tests/linking/io-acquire.cfa

tests/pybin/test_run.py

tests/test.py

Download in other formats: