Changeset f849c8e


Ignore:
Timestamp:
Oct 28, 2016, 1:11:12 PM (5 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
4b1afb6
Parents:
837f999 (diff), 0ebac75 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of plg2:software/cfa/cfa-cc

Conflicts:

src/Makefile.am
src/Makefile.in

Files:
30 edited

Legend:

Unmodified
Added
Removed
  • Makefile.in

    r837f999 rf849c8e  
    132132CFA_PREFIX = @CFA_PREFIX@
    133133CFLAGS = @CFLAGS@
     134CONFIG_STATUS_DEPENDENCIES = @CONFIG_STATUS_DEPENDENCIES@
    134135CPP = @CPP@
    135136CPPFLAGS = @CPPFLAGS@
  • config.h.in

    r837f999 rf849c8e  
    1919#undef CFA_PREFIX
    2020
     21/* Major.Minor */
     22#undef CFA_VERSION
     23
     24/* Build version number. */
     25#undef CFA_VERSION_BUILD
     26
     27/* Major.Minor.Patch.Build */
     28#undef CFA_VERSION_FULL
     29
     30/* Major.Minor.Patch */
     31#undef CFA_VERSION_LONG
     32
    2133/* Major version number. */
    2234#undef CFA_VERSION_MAJOR
     
    2739/* Patch version number. */
    2840#undef CFA_VERSION_PATCH
     41
     42/* Major */
     43#undef CFA_VERSION_SHORT
    2944
    3045/* Define to one of `_getb67', `GETB67', `getb67' for Cray-2 and Cray-YMP
  • configure

    r837f999 rf849c8e  
    646646CFA_BACKEND_CC
    647647BACKEND_CC
     648CONFIG_STATUS_DEPENDENCIES
    648649MAINT
    649650MAINTAINER_MODE_FALSE
     
    29642965                        # may require auto* software to be installed
    29652966
    2966 
    2967 $as_echo "#define CFA_VERSION_MAJOR \"1\"" >>confdefs.h
    2968 
    2969 
    2970 $as_echo "#define CFA_VERSION_MINOR \"0\"" >>confdefs.h
    2971 
    2972 
    2973 $as_echo "#define CFA_VERSION_PATCH \"0\"" >>confdefs.h
     2967ver_major=`cat version | sed -r 's/([0-9]+)\.([0-9]+)\.([0-9]+)\.([0-9]+)/\1/'`
     2968ver_minor=`cat version | sed -r 's/([0-9]+)\.([0-9]+)\.([0-9]+)\.([0-9]+)/\2/'`
     2969ver_patch=`cat version | sed -r 's/([0-9]+)\.([0-9]+)\.([0-9]+)\.([0-9]+)/\3/'`
     2970ver_build=`cat version | sed -r 's/([0-9]+)\.([0-9]+)\.([0-9]+)\.([0-9]+)/\4/'`
     2971ver_short="\"${ver_major}\""
     2972ver__long="\"${ver_major}.${ver_minor}\""
     2973ver__norm="\"${ver_major}.${ver_minor}.${ver_patch}\""
     2974ver__full="\"${ver_major}.${ver_minor}.${ver_patch}.${ver_build}\""
     2975
     2976CONFIG_STATUS_DEPENDENCIES='$(top_srcdir)/version'
     2977
     2978
     2979cat >>confdefs.h <<_ACEOF
     2980#define CFA_VERSION_MAJOR ${ver_major}
     2981_ACEOF
     2982
     2983
     2984cat >>confdefs.h <<_ACEOF
     2985#define CFA_VERSION_MINOR ${ver_minor}
     2986_ACEOF
     2987
     2988
     2989cat >>confdefs.h <<_ACEOF
     2990#define CFA_VERSION_PATCH ${ver_patch}
     2991_ACEOF
     2992
     2993
     2994cat >>confdefs.h <<_ACEOF
     2995#define CFA_VERSION_BUILD ${ver_build}
     2996_ACEOF
     2997
     2998
     2999cat >>confdefs.h <<_ACEOF
     3000#define CFA_VERSION_SHORT ${ver_short}
     3001_ACEOF
     3002
     3003
     3004cat >>confdefs.h <<_ACEOF
     3005#define CFA_VERSION ${ver__long}
     3006_ACEOF
     3007
     3008
     3009cat >>confdefs.h <<_ACEOF
     3010#define CFA_VERSION_LONG ${ver__norm}
     3011_ACEOF
     3012
     3013
     3014cat >>confdefs.h <<_ACEOF
     3015#define CFA_VERSION_FULL ${ver__full}
     3016_ACEOF
    29743017
    29753018
  • configure.ac

    r837f999 rf849c8e  
    1818AM_MAINTAINER_MODE(enable)                      # may require auto* software to be installed
    1919
    20 AC_DEFINE(CFA_VERSION_MAJOR, "1", [Major version number.])
    21 AC_DEFINE(CFA_VERSION_MINOR, "0", [Minor version number.])
    22 AC_DEFINE(CFA_VERSION_PATCH, "0", [Patch version number.])
     20ver_major=`cat version | sed -r 's/([[0-9]]+)\.([[0-9]]+)\.([[0-9]]+)\.([[0-9]]+)/\1/'`
     21ver_minor=`cat version | sed -r 's/([[0-9]]+)\.([[0-9]]+)\.([[0-9]]+)\.([[0-9]]+)/\2/'`
     22ver_patch=`cat version | sed -r 's/([[0-9]]+)\.([[0-9]]+)\.([[0-9]]+)\.([[0-9]]+)/\3/'`
     23ver_build=`cat version | sed -r 's/([[0-9]]+)\.([[0-9]]+)\.([[0-9]]+)\.([[0-9]]+)/\4/'`
     24ver_short="\"${ver_major}\""
     25ver__long="\"${ver_major}.${ver_minor}\""
     26ver__norm="\"${ver_major}.${ver_minor}.${ver_patch}\""
     27ver__full="\"${ver_major}.${ver_minor}.${ver_patch}.${ver_build}\""
     28
     29AC_SUBST([CONFIG_STATUS_DEPENDENCIES], ['$(top_srcdir)/version'])
     30AC_DEFINE_UNQUOTED(CFA_VERSION_MAJOR, ${ver_major}, [Major version number.])
     31AC_DEFINE_UNQUOTED(CFA_VERSION_MINOR, ${ver_minor}, [Minor version number.])
     32AC_DEFINE_UNQUOTED(CFA_VERSION_PATCH, ${ver_patch}, [Patch version number.])
     33AC_DEFINE_UNQUOTED(CFA_VERSION_BUILD, ${ver_build}, [Build version number.])
     34AC_DEFINE_UNQUOTED(CFA_VERSION_SHORT, ${ver_short}, [Major])
     35AC_DEFINE_UNQUOTED(CFA_VERSION, ${ver__long}, [Major.Minor])
     36AC_DEFINE_UNQUOTED(CFA_VERSION_LONG, ${ver__norm}, [Major.Minor.Patch])
     37AC_DEFINE_UNQUOTED(CFA_VERSION_FULL, ${ver__full}, [Major.Minor.Patch.Build])
    2338
    2439# Installation paths
  • doc/proposals/concurrency/concurrency.tex

    r837f999 rf849c8e  
    9090
    9191\maketitle
     92
     93% ### #     # ####### ######  #######
     94%  #  ##    #    #    #     # #     #
     95%  #  # #   #    #    #     # #     #
     96%  #  #  #  #    #    ######  #     #
     97%  #  #   # #    #    #   #   #     #
     98%  #  #    ##    #    #    #  #     #
     99% ### #     #    #    #     # #######
     100
    92101\section{Introduction}
    93102This proposal provides a minimal core concurrency API that is both simple, efficient and can be reused to build higher-level features. The simplest possible core is a thread and a lock but this low-level approach is hard to master. An easier approach for users is to support higher-level construct as the basis of the concurrency in \CFA.
     
    96105There are actually two problems that need to be solved in the design of the concurrency for a language. Which concurrency tools are available to the users and which parallelism tools are available. While these two concepts are often seen together, they are in fact distinct concepts that require different sorts of tools\cite{Buhr05a}. Concurrency tools need to handle mutual exclusion and synchronization while parallelism tools are more about performance, cost and resource utilization.
    97106
     107%  #####  ####### #     #  #####  #     # ######  ######  ####### #     #  #####  #     #
     108% #     # #     # ##    # #     # #     # #     # #     # #       ##    # #     #  #   #
     109% #       #     # # #   # #       #     # #     # #     # #       # #   # #         # #
     110% #       #     # #  #  # #       #     # ######  ######  #####   #  #  # #          #
     111% #       #     # #   # # #       #     # #   #   #   #   #       #   # # #          #
     112% #     # #     # #    ## #     # #     # #    #  #    #  #       #    ## #     #    #
     113%  #####  ####### #     #  #####   #####  #     # #     # ####### #     #  #####     #
     114
    98115\section{Concurrency}
    99 Several tool can be used to solve concurrency challenges. Since these challenges always appear with the use of mutable shared state, some languages and libraries simply disallow mutable shared-state (Erlang\cite{Erlang}, Haskell\cite{Haskell}, Akka (Scala)\cite{Akka}). In these paradigms, interaction among concurrent objects rely on message passing or other paradigms that often closely relate to networking concepts. However, in imperative or OO languages, these approaches entail a clear distinction between concurrent and non-concurrent paradigms (i.e. message passing versus routine call). Which in turns mean that programmers need to learn two sets of designs patterns in order to be effective. Approaches based on shared memory are more closely related to non-concurrent paradigms since they often rely on non-concurrent constructs like routine calls and objects. At a lower level these can be implemented as locks and atomic operations. However, for productivity reasons it is desireable to have a higher-level construct to be the core concurrency paradigm\cite{HPP:Study}. This project proposes Monitors\cite{Hoare74} as the core concurrency construct.
     116% Several tool can be used to solve concurrency challenges. Since these challenges always appear with the use of mutable shared state, some languages and libraries simply disallow mutable shared-state (Erlang\cite{Erlang}, Haskell\cite{Haskell}, Akka (Scala)\cite{Akka}). In these paradigms, interaction among concurrent objects rely on message passing or other paradigms that often closely relate to networking concepts. However, in imperative or OO languages, these approaches entail a clear distinction between concurrent and non-concurrent paradigms (i.e. message passing versus routine call). Which in turns mean that programmers need to learn two sets of designs patterns in order to be effective. Approaches based on shared memory are more closely related to non-concurrent paradigms since they often rely on non-concurrent constructs like routine calls and objects. At a lower level these can be implemented as locks and atomic operations. However, for productivity reasons it is desireable to have a higher-level construct to be the core concurrency paradigm\cite{HPP:Study}. This project proposes Monitors\cite{Hoare74} as the core concurrency construct.
     117% \\
     118
     119Several tool can be used to solve concurrency challenges. Since these challenges always appear with the use of mutable shared state, some languages and libraries simply disallow mutable shared-state (Erlang\cite{Erlang}, Haskell\cite{Haskell}, Akka (Scala)\cite{Akka}). In these paradigms, interaction among concurrent objects rely on message passing\cite{Thoth,Harmony,V-Kernel} or other paradigms that often closely relate to networking concepts. However, in imperative or OO languages, these approaches entail a clear distinction between concurrent and non-concurrent paradigms (i.e. message passing versus routine call). Which in turns mean that programmers need to learn two sets of designs patterns in order to be effective. Approaches based on shared memory are more closely related to non-concurrent paradigms since they often rely on non-concurrent constructs like routine calls and objects. At a lower level these can be implemented as locks and atomic operations. Many such mechanisms have been proposed, including semaphores~\cite{Dijkstra68b} and path expressions~\cite{Campbell74}. However, for productivity reasons it is desireable to have a higher-level construct to be the core concurrency paradigm\cite{HPP:Study}. One of the most natural, elegant, and efficient mechanisms for synchronization and communication, especially for shared memory systems, is the \emph{monitor}.
     120
     121Monitors were first proposed by Brinch Hansen~\cite{Hansen73} and later described and extended by C.A.R.~Hoare~\cite{Hoare74}.
     122Many programming languages---e.g., Concurrent Pascal~\cite{ConcurrentPascal}, Mesa~\cite{Mesa}, Modula~\cite{Modula-2}, Turing~\cite{Turing:old}, Modula-3~\cite{Modula-3}, NeWS~\cite{NeWS}, Emerald~\cite{Emerald}, \uC~\cite{Buhr92a} and Java~\cite{Java}---provide monitors as explicit language constructs. In addition, operating-system kernels and device drivers have a monitor-like structure, although they often use lower-level primitives such as semaphores or locks to simulate monitors. For these reasons, this project proposes Monitors as the core concurrency construct.
    100123\\
    101124
    102125Finally, an approach that is worth mentionning because it is gaining in popularity is transactionnal memory\cite{Dice10}. However, the performance and feature set is currently too restrictive to be possible to add such a paradigm to a language like C or \CC\cit, which is why it was rejected as the core paradigm for concurrency in \CFA.
     126
     127% #     # ####### #     # ### ####### ####### ######   #####
     128% ##   ## #     # ##    #  #     #    #     # #     # #     #
     129% # # # # #     # # #   #  #     #    #     # #     # #
     130% #  #  # #     # #  #  #  #     #    #     # ######   #####
     131% #     # #     # #   # #  #     #    #     # #   #         #
     132% #     # #     # #    ##  #     #    #     # #    #  #     #
     133% #     # ####### #     # ###    #    ####### #     #  #####
    103134
    104135\subsection{Monitors}
     
    113144        }
    114145\end{lstlisting}
     146
     147%  #####     #    #       #
     148% #     #   # #   #       #
     149% #        #   #  #       #
     150% #       #     # #       #
     151% #       ####### #       #
     152% #     # #     # #       #
     153%  #####  #     # ####### #######
    115154
    116155\subsubsection{Call semantics} \label{call}
     
    148187The problem is to indentify which object(s) should be acquired. Furthermore we also need to acquire each objects only once. In case of simple routines like \code{f1} and \code{f2} it is easy to identify an exhaustive list of objects to acquire on entering. Adding indirections (\code{f3}) still allows the compiler and programmer to indentify which object will be acquired. However, adding in arrays (\code{f4}) makes it much harder. Array lengths aren't necessarily known in C and even then making sure we only acquire objects once becomes also none trivial. This can be extended to absurd limits like \code{f5} which uses a custom graph of monitors. To keep everyone as sane as possible\cite{Chicken}, this projects imposes the requirement that a routine may only acquire one monitor per parameter and it must be the type of the parameter (ignoring potential qualifiers and indirections).
    149188
     189% ######     #    #######    #
     190% #     #   # #      #      # #
     191% #     #  #   #     #     #   #
     192% #     # #     #    #    #     #
     193% #     # #######    #    #######
     194% #     # #     #    #    #     #
     195% ######  #     #    #    #     #
     196
    150197\subsubsection{Data semantics} \label{data}
    151198Once the call semantics are established, the next step is to establish data semantics. Indeed, until now a monitor is used simply as a generic handle but in most cases monitors contian shared data. This data should be intrinsic to the monitor declaration to prevent any accidental use of data without its appripriate protection. For example here is a more fleshed-out version of the counter showed in \ref{call}:
     
    219266Recursive mutex routine calls are allowed in \CFA but if not done carefully it can lead to nested monitor call problems\cite{Lister77}. These problems which are a specific  implementation of the lock acquiring order problem. In the example above, the user uses implicit ordering in the case of function \code{bar} but explicit ordering in the case of \code{baz}. This subtle mistake can mean that calling these two functions concurrently will lead to deadlocks, depending on the implicit ordering matching the explicit ordering. As shown on several occasion\cit, there isn't really any solutions to this problem, users simply need to be carefull when acquiring multiple monitors at the same time.
    220267
     268% ######  ####### #######    #    ### #        #####
     269% #     # #          #      # #    #  #       #     #
     270% #     # #          #     #   #   #  #       #
     271% #     # #####      #    #     #  #  #        #####
     272% #     # #          #    #######  #  #             #
     273% #     # #          #    #     #  #  #       #     #
     274% ######  #######    #    #     # ### #######  #####
     275%
     276%             ######  ####### #       #     # #     # ####### ######  #     #
     277%             #     # #     # #        #   #  ##   ## #     # #     # #     #
     278%             #     # #     # #         # #   # # # # #     # #     # #     #
     279%  #####    ######  #     # #          #    #  #  # #     # ######  #######
     280%             #       #     # #          #    #     # #     # #   #   #     #
     281%             #       #     # #          #    #     # #     # #    #  #     #
     282%             #       ####### #######    #    #     # ####### #     # #     #
     283
    221284\subsubsection{Implementation Details: Interaction with polymorphism}
    222285At first glance, interaction between monitors and \CFA's concept of polymorphism seem complexe to support. However, it can be reasoned that entry-point locking can solve most of the issues that could be present with polymorphism.
    223286
    224287First of all, interaction between \code{otype} polymorphism and monitors is impossible since monitors do not support copying. Therefore the main question is how to support \code{dtype} polymorphism. We must remember that monitors' main purpose is to ensure mutual exclusion when accessing shared data. This implies that mutual exclusion is only required for routines that do in fact access shared data. However, since \code{dtype} polymorphism always handle incomplete types (by definition) no \code{dtype} polymorphic routine can access shared data since the data would require knowledge about the type. Therefore the only concern when combining \code{dtype} polymorphism and monitors is to protect access to routines. With callsite-locking, this would require significant amount of work since any \code{dtype} routine could have to obtain some lock before calling a routine. However, with entry-point-locking calling a monitor routine becomes exactly the same as calling it from anywhere else.
     288
     289% ### #     # #######         #####   #####  #     # ####### ######
     290%  #  ##    #    #           #     # #     # #     # #       #     #
     291%  #  # #   #    #           #       #       #     # #       #     #
     292%  #  #  #  #    #            #####  #       ####### #####   #     #
     293%  #  #   # #    #    ###          # #       #     # #       #     #
     294%  #  #    ##    #    ###    #     # #     # #     # #       #     #
     295% ### #     #    #    ###     #####   #####  #     # ####### ######
    225296
    226297\subsection{Internal scheduling} \label{insched}
     
    467538\\
    468539
     540% ####### #     # #######         #####   #####  #     # ####### ######
     541% #        #   #     #           #     # #     # #     # #       #     #
     542% #         # #      #           #       #       #     # #       #     #
     543% #####      #       #            #####  #       ####### #####   #     #
     544% #         # #      #    ###          # #       #     # #       #     #
     545% #        #   #     #    ###    #     # #     # #     # #       #     #
     546% ####### #     #    #    ###     #####   #####  #     # ####### ######
     547
    469548\subsection{External scheduling} \label{extsched}
    470549As one might expect, the alternative to Internal scheduling is to use External scheduling instead. This method is somewhat more robust to deadlocks since one of the threads keeps a relatively tight control on scheduling. Indeed, as the following examples will demonstrate, external scheduling allows users to wait for events from other threads without the concern of unrelated events occuring. External scheduling can generally be done either in terms of control flow (ex: \uC) or in terms of data (ex: Go). Of course, both of these paradigms have their own strenghts and weaknesses but for this project control flow semantics where chosen to stay consistent with the rest of the languages semantics. Two challenges specific to \CFA arise when trying to add external scheduling with loose object definitions and multi-monitor routines. The following example shows what a simple use \code{accept} versus \code{wait}/\code{signal} and its advantages.
     
    496575In the case of internal scheduling, the call to \code{wait} only guarantees that \code{g} was the last routine to access the monitor. This intails that the routine \code{f} may have acquired mutual exclusion several times while routine \code{h} was waiting. On the other hand, external scheduling guarantees that while routine \code{h} was waiting, no routine other than \code{g} could acquire the monitor.
    497576\\
     577
     578% #       ####### #######  #####  #######    ####### ######        #  #####
     579% #       #     # #     # #     # #          #     # #     #       # #     #
     580% #       #     # #     # #       #          #     # #     #       # #
     581% #       #     # #     #  #####  #####      #     # ######        #  #####
     582% #       #     # #     #       # #          #     # #     # #     #       #
     583% #       #     # #     # #     # #          #     # #     # #     # #     #
     584% ####### ####### #######  #####  #######    ####### ######   #####   #####
    498585
    499586\subsubsection{Loose object definitions}
     
    587674An other aspect to consider is what happens if multiple overloads of the same routine are used. For the time being it is assumed that multiple overloads of the same routine should be scheduled regardless of the overload used. However, this could easily be extended in the future.
    588675
     676% #     # #     # #       ####### ###    #     # ####### #     #
     677% ##   ## #     # #          #     #     ##   ## #     # ##    #
     678% # # # # #     # #          #     #     # # # # #     # # #   #
     679% #  #  # #     # #          #     #     #  #  # #     # #  #  #
     680% #     # #     # #          #     #     #     # #     # #   # #
     681% #     # #     # #          #     #     #     # #     # #    ##
     682% #     #  #####  #######    #    ###    #     # ####### #     #
     683
    589684\subsubsection{Multi-monitor scheduling}
    590685
     
    629724Note that the set of monitors passed to the \code{accept} statement must be entirely contained in the set of monitor already acquired in the routine. \code{accept} used in any other context is Undefined Behaviour.
    630725
     726% ######  ####### #######    #    ### #        #####
     727% #     # #          #      # #    #  #       #     #
     728% #     # #          #     #   #   #  #       #
     729% #     # #####      #    #     #  #  #        #####
     730% #     # #          #    #######  #  #             #
     731% #     # #          #    #     #  #  #       #     #
     732% ######  #######    #    #     # ### #######  #####
     733%
     734%                #####  #     # ####### #     # #######  #####
     735%             #     # #     # #       #     # #       #     #
     736%             #     # #     # #       #     # #       #
     737%    #####    #     # #     # #####   #     # #####    #####
     738%             #   # # #     # #       #     # #             #
     739%             #    #  #     # #       #     # #       #     #
     740%                #### #  #####  #######  #####  #######  #####
     741
     742
    631743\subsubsection{Implementation Details: External scheduling queues}
    632744To support multi-monitor external scheduling means that some kind of entry-queues must be used that is aware of both monitors. However, acceptable routines must be aware of the entry queues which means they must be stored inside at least one of the monitors that will be acquired. This in turn adds the requirement a systematic algorithm of disambiguating which queue is relavant regardless of user ordering. The proposed algorithm is to fall back on monitors lock ordering and specify that the monitor that is acquired first is the lock with the relevant entry queue. This assumes that the lock acquiring order is static for the lifetime of all concerned objects but that is a reasonnable constraint. This algorithm choice has two consequences, the entry queue of the highest priority monitor is no longer a true FIFO queue and the queue of the lowest priority monitor is both required and probably unused. The queue can no longer be a FIFO queue because instead of simply containing the waiting threads in order arrival, they also contain the second mutex. Therefore, another thread with the same highest priority monitor but a different lowest priority monitor may arrive first but enter the critical section after a thread with the correct pairing. Secondly, since it may not be known at compile time which monitor will be the lowest priority monitor, every monitor needs to have the correct queues even though it is probable that half the multi-monitor queues will go unused for the entire duration of the program.
     
    636748
    637749\newpage
     750% ######     #    ######     #    #       #       ####### #       ###  #####  #     #
     751% #     #   # #   #     #   # #   #       #       #       #        #  #     # ##   ##
     752% #     #  #   #  #     #  #   #  #       #       #       #        #  #       # # # #
     753% ######  #     # ######  #     # #       #       #####   #        #   #####  #  #  #
     754% #       ####### #   #   ####### #       #       #       #        #        # #     #
     755% #       #     # #    #  #     # #       #       #       #        #  #     # #     #
     756% #       #     # #     # #     # ####### ####### ####### ####### ###  #####  #     #
    638757\section{Parallelism}
    639758Historically, computer performance was about processor speeds and instructions count. However, with heat dissipation being an ever growing challenge, parallelism has become the new source of greatest performance \cite{Sutter05, Sutter05b}. In this decade, it is not longer reasonnable to create high-performance application without caring about parallelism. Indeed, parallelism is an important aspect of performance and more specifically throughput and hardware utilization. The lowest level approach of parallelism is to use \glspl{kthread}. However since these have significant costs and limitations \glspl{kthread} are now mostly used as an implementation tool rather than a user oriented one. There are several alternatives to solve these issues which all have strengths and weaknesses.
     
    654773\subsection{Paradigm performance}
    655774While the choice between the three paradigms listed above may have significant performance implication, it is difficult to pin the performance implications of chosing a model at the language level. Indeed, in many situations one of these paradigms will show better performance but it all strongly depends on the usage. Having mostly indepent units of work to execute almost guarantess that the \gls{job} based system will have the best performance. However, add interactions between jobs and the processor utilisation might suffer. User-level threads may allow maximum ressource utilisation but context switches will be more expansive and it is also harder for users to get perfect tunning. As with every example, fibers sit somewhat in the middle of the spectrum. Furthermore, if the units of uninterrupted work are large enough the paradigm choice will be largely amorticised by the actual work done.
     775
     776%  #####  #######    #          ####### ######  ######
     777% #     # #         # #            #    #     # #     #
     778% #       #        #   #           #    #     # #     #
     779% #       #####   #     # #####    #    ######  ######
     780% #       #       #######          #    #     # #     #
     781% #     # #       #     #          #    #     # #     #
     782%  #####  #       #     #          #    ######  ######
    656783
    657784\section{\CFA 's Thread Building Blocks}
     
    672799
    673800As shown in section \ref{cfaparadigms} these different blocks being available in \CFA it is trivial to reproduce any of these paradigm.
     801
     802% ####### #     # ######  #######    #    ######   #####
     803%    #    #     # #     # #         # #   #     # #     #
     804%    #    #     # #     # #        #   #  #     # #
     805%    #    ####### ######  #####   #     # #     #  #####
     806%    #    #     # #   #   #       ####### #     #       #
     807%    #    #     # #    #  #       #     # #     # #     #
     808%    #    #     # #     # ####### #     # ######   #####
    674809
    675810\subsection{Thread Interface}
     
    843978% \textbf{\large{Work in progress...}} Do wee need something beyond specifying the number of kernel threads?
    844979
     980%    #    #       #
     981%   # #   #       #
     982%  #   #  #       #
     983% #     # #       #
     984% ####### #       #
     985% #     # #       #
     986% #     # ####### #######
    845987\section{Putting it all together}
    846988
     989
     990
     991
     992
     993
     994
     995
     996
     997
     998% ####### #     # ####### #     # ######  #######
     999% #       #     #    #    #     # #     # #
     1000% #       #     #    #    #     # #     # #
     1001% #####   #     #    #    #     # ######  #####
     1002% #       #     #    #    #     # #   #   #
     1003% #       #     #    #    #     # #    #  #
     1004% #        #####     #     #####  #     # ######
    8471005\section{Future work}
    8481006Concurrency and parallelism is still a very active field that strongly benefits from hardware advances. As such certain features that aren't necessarily mature enough in their current state could become relevant in the lifetime of \CFA.
    8491007\subsection{Transactions}
    8501008
     1009% ####### #     # ######
     1010% #       ##    # #     #
     1011% #       # #   # #     #
     1012% #####   #  #  # #     #
     1013% #       #   # # #     #
     1014% #       #    ## #     #
     1015% ####### #     # ######
    8511016\section*{Acknowledgements}
    8521017
     
    8571022\clearpage
    8581023\bibliographystyle{plain}
    859 \bibliography{pl,local}
     1024\bibliography{cw92,distSharedMem,lfp92,mlw92,parallel,parallelIO,partheory,pl,pldi92,ps,realtime,techreportsPAB,visual,local}
    8601025
    8611026
  • doc/proposals/concurrency/version

    r837f999 rf849c8e  
    1 0.4.95
     10.4.99
  • src/ControlStruct/LabelFixer.h

    r837f999 rf849c8e  
    2626namespace ControlStruct {
    2727        /// normalizes label definitions and generates multi-level exit labels
    28         class LabelFixer : public Visitor {
     28        class LabelFixer final : public Visitor {
    2929                typedef Visitor Parent;
    3030          public:
     
    3333                std::map < Label, Statement * > *resolveJumps() throw ( SemanticError );
    3434
     35                using Visitor::visit;
     36
    3537                // Declarations
    36                 virtual void visit( FunctionDecl *functionDecl );
     38                virtual void visit( FunctionDecl *functionDecl ) override;
    3739
    3840                // Statements
    3941                void visit( Statement *stmt );
    4042
    41                 virtual void visit( CompoundStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
    42                 virtual void visit( NullStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
    43                 virtual void visit( ExprStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
    44                 virtual void visit( IfStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
    45                 virtual void visit( WhileStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
    46                 virtual void visit( ForStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
    47                 virtual void visit( SwitchStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
    48                 virtual void visit( CaseStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
    49                 virtual void visit( ReturnStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
    50                 virtual void visit( TryStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
    51                 virtual void visit( CatchStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
    52                 virtual void visit( DeclStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
    53                 virtual void visit( BranchStmt *branchStmt );
    54                 virtual void visit( UntypedExpr *untyped );
     43                virtual void visit( CompoundStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
     44                virtual void visit( NullStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
     45                virtual void visit( ExprStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
     46                virtual void visit( IfStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
     47                virtual void visit( WhileStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
     48                virtual void visit( ForStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
     49                virtual void visit( SwitchStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
     50                virtual void visit( CaseStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
     51                virtual void visit( ReturnStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
     52                virtual void visit( TryStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
     53                virtual void visit( CatchStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
     54                virtual void visit( DeclStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
     55                virtual void visit( BranchStmt *branchStmt ) override;
     56                virtual void visit( UntypedExpr *untyped ) override;
    5557
    5658                Label setLabelsDef( std::list< Label > &, Statement *definition );
  • src/ControlStruct/LabelTypeChecker.cc

    r837f999 rf849c8e  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // LabelTypeChecker.cc -- 
     7// LabelTypeChecker.cc --
    88//
    99// Author           : Rodolfo G. Esteves
     
    2828                assert( untypedExpr != 0 );
    2929                NameExpr *fname;
    30                 if ( ((fname = dynamic_cast<NameExpr *>(untypedExpr->get_function())) != 0) 
     30                if ( ((fname = dynamic_cast<NameExpr *>(untypedExpr->get_function())) != 0)
    3131                         && fname->get_name() == std::string("&&") )
    3232                        std::cerr << "Taking the label of an address." << std::endl;
     
    5858
    5959                NameExpr *name;
    60                 if ( ((name = dynamic_cast<NameExpr *>(target)) == 0) )
     60                if ( (name = dynamic_cast<NameExpr *>(target)) == 0 )
    6161                        return; // Not a name expression
    62        
     62
    6363                std::list< DeclarationWithType * > interps;
    6464                index.lookupId(name->get_name(), interps);
  • src/GenPoly/Box.cc

    r837f999 rf849c8e  
    6464
    6565                /// Adds layout-generation functions to polymorphic types
    66                 class LayoutFunctionBuilder : public DeclMutator {
     66                class LayoutFunctionBuilder final : public DeclMutator {
    6767                        unsigned int functionNesting;  // current level of nested functions
    6868                public:
    6969                        LayoutFunctionBuilder() : functionNesting( 0 ) {}
    7070
    71                         virtual DeclarationWithType *mutate( FunctionDecl *functionDecl );
    72                         virtual Declaration *mutate( StructDecl *structDecl );
    73                         virtual Declaration *mutate( UnionDecl *unionDecl );
     71                        using DeclMutator::mutate;
     72                        virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
     73                        virtual Declaration *mutate( StructDecl *structDecl ) override;
     74                        virtual Declaration *mutate( UnionDecl *unionDecl ) override;
    7475                };
    7576
    7677                /// Replaces polymorphic return types with out-parameters, replaces calls to polymorphic functions with adapter calls as needed, and adds appropriate type variables to the function call
    77                 class Pass1 : public PolyMutator {
     78                class Pass1 final : public PolyMutator {
    7879                  public:
    7980                        Pass1();
    80                         virtual Expression *mutate( ApplicationExpr *appExpr );
    81                         virtual Expression *mutate( AddressExpr *addrExpr );
    82                         virtual Expression *mutate( UntypedExpr *expr );
    83                         virtual DeclarationWithType* mutate( FunctionDecl *functionDecl );
    84                         virtual TypeDecl *mutate( TypeDecl *typeDecl );
    85                         virtual Expression *mutate( CommaExpr *commaExpr );
    86                         virtual Expression *mutate( ConditionalExpr *condExpr );
    87                         virtual Statement * mutate( ReturnStmt *returnStmt );
    88                         virtual Type *mutate( PointerType *pointerType );
    89                         virtual Type * mutate( FunctionType *functionType );
    90 
    91                         virtual void doBeginScope();
    92                         virtual void doEndScope();
     81
     82                        using PolyMutator::mutate;
     83                        virtual Expression *mutate( ApplicationExpr *appExpr ) override;
     84                        virtual Expression *mutate( AddressExpr *addrExpr ) override;
     85                        virtual Expression *mutate( UntypedExpr *expr ) override;
     86                        virtual DeclarationWithType* mutate( FunctionDecl *functionDecl ) override;
     87                        virtual TypeDecl *mutate( TypeDecl *typeDecl ) override;
     88                        virtual Expression *mutate( CommaExpr *commaExpr ) override;
     89                        virtual Expression *mutate( ConditionalExpr *condExpr ) override;
     90                        virtual Statement * mutate( ReturnStmt *returnStmt ) override;
     91                        virtual Type *mutate( PointerType *pointerType ) override;
     92                        virtual Type * mutate( FunctionType *functionType ) override;
     93
     94                        virtual void doBeginScope() override;
     95                        virtual void doEndScope() override;
    9396                  private:
    9497                        /// Pass the extra type parameters from polymorphic generic arguments or return types into a function application
     
    135138                /// * Moves polymorphic returns in function types to pointer-type parameters
    136139                /// * adds type size and assertion parameters to parameter lists
    137                 class Pass2 : public PolyMutator {
     140                class Pass2 final : public PolyMutator {
    138141                  public:
    139142                        template< typename DeclClass >
    140143                        DeclClass *handleDecl( DeclClass *decl, Type *type );
    141                         virtual DeclarationWithType *mutate( FunctionDecl *functionDecl );
    142                         virtual ObjectDecl *mutate( ObjectDecl *objectDecl );
    143                         virtual TypeDecl *mutate( TypeDecl *typeDecl );
    144                         virtual TypedefDecl *mutate( TypedefDecl *typedefDecl );
    145                         virtual Type *mutate( PointerType *pointerType );
    146                         virtual Type *mutate( FunctionType *funcType );
     144
     145                        using PolyMutator::mutate;
     146                        virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
     147                        virtual ObjectDecl *mutate( ObjectDecl *objectDecl ) override;
     148                        virtual TypeDecl *mutate( TypeDecl *typeDecl ) override;
     149                        virtual TypedefDecl *mutate( TypedefDecl *typedefDecl ) override;
     150                        virtual Type *mutate( PointerType *pointerType ) override;
     151                        virtual Type *mutate( FunctionType *funcType ) override;
    147152
    148153                  private:
     
    156161                /// * Calculates polymorphic offsetof expressions from offset array
    157162                /// * Inserts dynamic calculation of polymorphic type layouts where needed
    158                 class PolyGenericCalculator : public PolyMutator {
     163                class PolyGenericCalculator final : public PolyMutator {
    159164                public:
    160165                        typedef PolyMutator Parent;
     
    163168                        template< typename DeclClass >
    164169                        DeclClass *handleDecl( DeclClass *decl, Type *type );
    165                         virtual DeclarationWithType *mutate( FunctionDecl *functionDecl );
    166                         virtual ObjectDecl *mutate( ObjectDecl *objectDecl );
    167                         virtual TypedefDecl *mutate( TypedefDecl *objectDecl );
    168                         virtual TypeDecl *mutate( TypeDecl *objectDecl );
    169                         virtual Statement *mutate( DeclStmt *declStmt );
    170                         virtual Type *mutate( PointerType *pointerType );
    171                         virtual Type *mutate( FunctionType *funcType );
    172                         virtual Expression *mutate( MemberExpr *memberExpr );
    173                         virtual Expression *mutate( SizeofExpr *sizeofExpr );
    174                         virtual Expression *mutate( AlignofExpr *alignofExpr );
    175                         virtual Expression *mutate( OffsetofExpr *offsetofExpr );
    176                         virtual Expression *mutate( OffsetPackExpr *offsetPackExpr );
    177 
    178                         virtual void doBeginScope();
    179                         virtual void doEndScope();
     170                        virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
     171                        virtual ObjectDecl *mutate( ObjectDecl *objectDecl ) override;
     172                        virtual TypedefDecl *mutate( TypedefDecl *objectDecl ) override;
     173                        virtual TypeDecl *mutate( TypeDecl *objectDecl ) override;
     174                        virtual Statement *mutate( DeclStmt *declStmt ) override;
     175                        virtual Type *mutate( PointerType *pointerType ) override;
     176                        virtual Type *mutate( FunctionType *funcType ) override;
     177                        virtual Expression *mutate( MemberExpr *memberExpr ) override;
     178                        virtual Expression *mutate( SizeofExpr *sizeofExpr ) override;
     179                        virtual Expression *mutate( AlignofExpr *alignofExpr ) override;
     180                        virtual Expression *mutate( OffsetofExpr *offsetofExpr ) override;
     181                        virtual Expression *mutate( OffsetPackExpr *offsetPackExpr ) override;
     182
     183                        virtual void doBeginScope() override;
     184                        virtual void doEndScope() override;
    180185
    181186                private:
     
    197202
    198203                /// Replaces initialization of polymorphic values with alloca, declaration of dtype/ftype with appropriate void expression, and sizeof expressions of polymorphic types with the proper variable
    199                 class Pass3 : public PolyMutator {
     204                class Pass3 final : public PolyMutator {
    200205                  public:
    201206                        template< typename DeclClass >
    202207                        DeclClass *handleDecl( DeclClass *decl, Type *type );
    203                         virtual DeclarationWithType *mutate( FunctionDecl *functionDecl );
    204                         virtual ObjectDecl *mutate( ObjectDecl *objectDecl );
    205                         virtual TypedefDecl *mutate( TypedefDecl *objectDecl );
    206                         virtual TypeDecl *mutate( TypeDecl *objectDecl );
    207                         virtual Type *mutate( PointerType *pointerType );
    208                         virtual Type *mutate( FunctionType *funcType );
     208
     209                        using PolyMutator::mutate;
     210                        virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
     211                        virtual ObjectDecl *mutate( ObjectDecl *objectDecl ) override;
     212                        virtual TypedefDecl *mutate( TypedefDecl *objectDecl ) override;
     213                        virtual TypeDecl *mutate( TypeDecl *objectDecl ) override;
     214                        virtual Type *mutate( PointerType *pointerType ) override;
     215                        virtual Type *mutate( FunctionType *funcType ) override;
    209216                  private:
    210217                };
  • src/GenPoly/InstantiateGeneric.cc

    r837f999 rf849c8e  
    147147
    148148        /// Mutator pass that replaces concrete instantiations of generic types with actual struct declarations, scoped appropriately
    149         class GenericInstantiator : public DeclMutator {
     149        class GenericInstantiator final : public DeclMutator {
    150150                /// Map of (generic type, parameter list) pairs to concrete type instantiations
    151151                InstantiationMap< AggregateDecl, AggregateDecl > instantiations;
     
    158158                GenericInstantiator() : DeclMutator(), instantiations(), dtypeStatics(), typeNamer("_conc_") {}
    159159
    160                 virtual Type* mutate( StructInstType *inst );
    161                 virtual Type* mutate( UnionInstType *inst );
    162 
    163                 virtual void doBeginScope();
    164                 virtual void doEndScope();
     160                using DeclMutator::mutate;
     161                virtual Type* mutate( StructInstType *inst ) override;
     162                virtual Type* mutate( UnionInstType *inst ) override;
     163
     164                virtual void doBeginScope() override;
     165                virtual void doEndScope() override;
    165166        private:
    166167                /// Wrap instantiation lookup for structs
  • src/GenPoly/Specialize.cc

    r837f999 rf849c8e  
    3636        const std::list<Label> noLabels;
    3737
    38         class Specialize : public PolyMutator {
     38        class Specialize final : public PolyMutator {
    3939          public:
    4040                Specialize( std::string paramPrefix = "_p" );
    4141
    42                 virtual Expression * mutate( ApplicationExpr *applicationExpr );
    43                 virtual Expression * mutate( AddressExpr *castExpr );
    44                 virtual Expression * mutate( CastExpr *castExpr );
     42                using PolyMutator::mutate;
     43                virtual Expression * mutate( ApplicationExpr *applicationExpr ) override;
     44                virtual Expression * mutate( AddressExpr *castExpr ) override;
     45                virtual Expression * mutate( CastExpr *castExpr ) override;
    4546                // virtual Expression * mutate( LogicalExpr *logicalExpr );
    4647                // virtual Expression * mutate( ConditionalExpr *conditionalExpr );
  • src/InitTweak/FixInit.cc

    r837f999 rf849c8e  
    5050                const std::list<Expression*> noDesignators;
    5151
    52                 class InsertImplicitCalls : public GenPoly::PolyMutator {
     52                class InsertImplicitCalls final : public GenPoly::PolyMutator {
    5353                public:
    5454                        /// wrap function application expressions as ImplicitCopyCtorExpr nodes so that it is easy to identify which
     
    5656                        static void insert( std::list< Declaration * > & translationUnit );
    5757
    58                         virtual Expression * mutate( ApplicationExpr * appExpr );
    59                 };
    60 
    61                 class ResolveCopyCtors : public SymTab::Indexer {
     58                        using GenPoly::PolyMutator::mutate;
     59                        virtual Expression * mutate( ApplicationExpr * appExpr ) override;
     60                };
     61
     62                class ResolveCopyCtors final : public SymTab::Indexer {
    6263                public:
    6364                        /// generate temporary ObjectDecls for each argument and return value of each ImplicitCopyCtorExpr,
     
    6667                        static void resolveImplicitCalls( std::list< Declaration * > & translationUnit );
    6768
    68                         virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr );
     69                        using SymTab::Indexer::visit;
     70                        virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr ) override;
    6971
    7072                        /// create and resolve ctor/dtor expression: fname(var, [cpArg])
     
    8284                        using Parent::visit;
    8385                        typedef std::set< ObjectDecl * > ObjectSet;
    84                         virtual void visit( CompoundStmt *compoundStmt );
    85                         virtual void visit( DeclStmt *stmt );
     86                        virtual void visit( CompoundStmt *compoundStmt ) override;
     87                        virtual void visit( DeclStmt *stmt ) override;
    8688                  protected:
    8789                        ObjectSet curVars;
     
    103105                }
    104106
    105                 class LabelFinder : public ObjDeclCollector {
     107                class LabelFinder final : public ObjDeclCollector {
    106108                  public:
    107109                        typedef ObjDeclCollector Parent;
     
    117119                        // subclasses are added, there is only one place that the code has to be updated, rather than ensure that
    118120                        // every specialized class knows about every new kind of statement that might be added.
    119                         virtual void visit( CompoundStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
    120                         virtual void visit( ExprStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
    121                         virtual void visit( AsmStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
    122                         virtual void visit( IfStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
    123                         virtual void visit( WhileStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
    124                         virtual void visit( ForStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
    125                         virtual void visit( SwitchStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
    126                         virtual void visit( CaseStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
    127                         virtual void visit( BranchStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
    128                         virtual void visit( ReturnStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
    129                         virtual void visit( TryStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
    130                         virtual void visit( CatchStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
    131                         virtual void visit( FinallyStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
    132                         virtual void visit( NullStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
    133                         virtual void visit( DeclStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
    134                         virtual void visit( ImplicitCtorDtorStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
    135                 };
    136 
    137                 class InsertDtors : public ObjDeclCollector {
     121                        using Parent::visit;
     122                        virtual void visit( CompoundStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
     123                        virtual void visit( ExprStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
     124                        virtual void visit( AsmStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
     125                        virtual void visit( IfStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
     126                        virtual void visit( WhileStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
     127                        virtual void visit( ForStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
     128                        virtual void visit( SwitchStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
     129                        virtual void visit( CaseStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
     130                        virtual void visit( BranchStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
     131                        virtual void visit( ReturnStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
     132                        virtual void visit( TryStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
     133                        virtual void visit( CatchStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
     134                        virtual void visit( FinallyStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
     135                        virtual void visit( NullStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
     136                        virtual void visit( DeclStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
     137                        virtual void visit( ImplicitCtorDtorStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
     138                };
     139
     140                class InsertDtors final : public ObjDeclCollector {
    138141                public:
    139142                        /// insert destructor calls at the appropriate places.  must happen before CtorInit nodes are removed
     
    147150                        InsertDtors( LabelFinder & finder ) : labelVars( finder.vars ) {}
    148151
    149                         virtual void visit( ObjectDecl * objDecl );
    150 
    151                         virtual void visit( CompoundStmt * compoundStmt );
    152                         virtual void visit( ReturnStmt * returnStmt );
    153                         virtual void visit( BranchStmt * stmt );
     152                        using Parent::visit;
     153
     154                        virtual void visit( ObjectDecl * objDecl ) override;
     155
     156                        virtual void visit( CompoundStmt * compoundStmt ) override;
     157                        virtual void visit( ReturnStmt * returnStmt ) override;
     158                        virtual void visit( BranchStmt * stmt ) override;
    154159                private:
    155160                        void handleGoto( BranchStmt * stmt );
     
    159164                };
    160165
    161                 class FixInit : public GenPoly::PolyMutator {
     166                class FixInit final : public GenPoly::PolyMutator {
    162167                  public:
    163168                        /// expand each object declaration to use its constructor after it is declared.
    164169                        static void fixInitializers( std::list< Declaration * > &translationUnit );
    165170
    166                         virtual DeclarationWithType * mutate( ObjectDecl *objDecl );
     171                        using GenPoly::PolyMutator::mutate;
     172                        virtual DeclarationWithType * mutate( ObjectDecl *objDecl ) override;
    167173
    168174                        std::list< Declaration * > staticDtorDecls;
    169175                };
    170176
    171                 class FixCopyCtors : public GenPoly::PolyMutator {
     177                class FixCopyCtors final : public GenPoly::PolyMutator {
    172178                  public:
    173179                        /// expand ImplicitCopyCtorExpr nodes into the temporary declarations, copy constructors, call expression,
     
    175181                        static void fixCopyCtors( std::list< Declaration * > &translationUnit );
    176182
    177                         virtual Expression * mutate( ImplicitCopyCtorExpr * impCpCtorExpr );
    178                 };
    179 
    180                 class GenStructMemberCalls : public SymTab::Indexer {
     183                        using GenPoly::PolyMutator::mutate;
     184                        virtual Expression * mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) override;
     185                };
     186
     187                class GenStructMemberCalls final : public SymTab::Indexer {
    181188                  public:
    182189                        typedef Indexer Parent;
     
    186193                        static void generate( std::list< Declaration * > & translationUnit );
    187194
    188                         virtual void visit( FunctionDecl * funcDecl );
    189 
    190                         virtual void visit( MemberExpr * memberExpr );
    191                         virtual void visit( ApplicationExpr * appExpr );
     195                        using Parent::visit;
     196
     197                        virtual void visit( FunctionDecl * funcDecl ) override;
     198
     199                        virtual void visit( MemberExpr * memberExpr ) override;
     200                        virtual void visit( ApplicationExpr * appExpr ) override;
    192201
    193202                        SemanticError errors;
     
    207216                // resolve UntypedExprs that are found within newly
    208217                // generated constructor/destructor calls
    209                 class MutatingResolver : public Mutator {
     218                class MutatingResolver final : public Mutator {
    210219                  public:
    211220                        MutatingResolver( SymTab::Indexer & indexer ) : indexer( indexer ) {}
    212221
    213                         virtual DeclarationWithType* mutate( ObjectDecl *objectDecl );
    214 
    215                         virtual Expression* mutate( UntypedExpr *untypedExpr );
    216                         private:
     222                        using Mutator::mutate;
     223                        virtual DeclarationWithType* mutate( ObjectDecl *objectDecl ) override;
     224                        virtual Expression* mutate( UntypedExpr *untypedExpr ) override;
     225
     226                  private:
    217227                        SymTab::Indexer & indexer;
    218228                };
    219229
    220                 class FixCtorExprs : public GenPoly::DeclMutator {
     230                class FixCtorExprs final : public GenPoly::DeclMutator {
    221231                  public:
    222232                        /// expands ConstructorExpr nodes into comma expressions, using a temporary for the first argument
    223233                        static void fix( std::list< Declaration * > & translationUnit );
    224234
    225                         virtual Expression * mutate( ConstructorExpr * ctorExpr );
     235                        using GenPoly::DeclMutator::mutate;
     236                        virtual Expression * mutate( ConstructorExpr * ctorExpr ) override;
    226237                };
    227238        } // namespace
  • src/InitTweak/GenInit.cc

    r837f999 rf849c8e  
    3636        }
    3737
    38         class ReturnFixer : public GenPoly::PolyMutator {
     38        class ReturnFixer final : public GenPoly::PolyMutator {
    3939          public:
    4040                /// consistently allocates a temporary variable for the return value
     
    4545                ReturnFixer();
    4646
    47                 virtual DeclarationWithType * mutate( FunctionDecl *functionDecl );
    48 
    49                 virtual Statement * mutate( ReturnStmt * returnStmt );
     47                using GenPoly::PolyMutator::mutate;
     48                virtual DeclarationWithType * mutate( FunctionDecl *functionDecl ) override;
     49                virtual Statement * mutate( ReturnStmt * returnStmt ) override;
    5050
    5151          protected:
     
    5555        };
    5656
    57         class CtorDtor : public GenPoly::PolyMutator {
     57        class CtorDtor final : public GenPoly::PolyMutator {
    5858          public:
    5959                typedef GenPoly::PolyMutator Parent;
     
    6565                static void generateCtorDtor( std::list< Declaration * > &translationUnit );
    6666
    67                 virtual DeclarationWithType * mutate( ObjectDecl * );
    68                 virtual DeclarationWithType * mutate( FunctionDecl *functionDecl );
     67                virtual DeclarationWithType * mutate( ObjectDecl * ) override;
     68                virtual DeclarationWithType * mutate( FunctionDecl *functionDecl ) override;
    6969                // should not traverse into any of these declarations to find objects
    7070                // that need to be constructed or destructed
    71                 virtual Declaration* mutate( StructDecl *aggregateDecl );
    72                 virtual Declaration* mutate( UnionDecl *aggregateDecl ) { return aggregateDecl; }
    73                 virtual Declaration* mutate( EnumDecl *aggregateDecl ) { return aggregateDecl; }
    74                 virtual Declaration* mutate( TraitDecl *aggregateDecl ) { return aggregateDecl; }
    75                 virtual TypeDecl* mutate( TypeDecl *typeDecl ) { return typeDecl; }
    76                 virtual Declaration* mutate( TypedefDecl *typeDecl ) { return typeDecl; }
    77 
    78                 virtual Type * mutate( FunctionType *funcType ) { return funcType; }
    79 
    80                 virtual CompoundStmt * mutate( CompoundStmt * compoundStmt );
     71                virtual Declaration* mutate( StructDecl *aggregateDecl ) override;
     72                virtual Declaration* mutate( UnionDecl *aggregateDecl ) override { return aggregateDecl; }
     73                virtual Declaration* mutate( EnumDecl *aggregateDecl ) override { return aggregateDecl; }
     74                virtual Declaration* mutate( TraitDecl *aggregateDecl ) override { return aggregateDecl; }
     75                virtual TypeDecl* mutate( TypeDecl *typeDecl ) override { return typeDecl; }
     76                virtual Declaration* mutate( TypedefDecl *typeDecl ) override { return typeDecl; }
     77
     78                virtual Type * mutate( FunctionType *funcType ) override { return funcType; }
     79
     80                virtual CompoundStmt * mutate( CompoundStmt * compoundStmt ) override;
    8181
    8282          private:
     
    9191        };
    9292
    93         class HoistArrayDimension : public GenPoly::DeclMutator {
     93        class HoistArrayDimension final : public GenPoly::DeclMutator {
    9494          public:
    9595                typedef GenPoly::DeclMutator Parent;
     
    101101
    102102          private:
    103                 virtual DeclarationWithType * mutate( ObjectDecl * objectDecl );
    104                 virtual DeclarationWithType * mutate( FunctionDecl *functionDecl );
     103                using Parent::mutate;
     104
     105                virtual DeclarationWithType * mutate( ObjectDecl * objectDecl ) override;
     106                virtual DeclarationWithType * mutate( FunctionDecl *functionDecl ) override;
    105107                // should not traverse into any of these declarations to find objects
    106108                // that need to be constructed or destructed
    107                 virtual Declaration* mutate( StructDecl *aggregateDecl ) { return aggregateDecl; }
    108                 virtual Declaration* mutate( UnionDecl *aggregateDecl ) { return aggregateDecl; }
    109                 virtual Declaration* mutate( EnumDecl *aggregateDecl ) { return aggregateDecl; }
    110                 virtual Declaration* mutate( TraitDecl *aggregateDecl ) { return aggregateDecl; }
    111                 virtual TypeDecl* mutate( TypeDecl *typeDecl ) { return typeDecl; }
    112                 virtual Declaration* mutate( TypedefDecl *typeDecl ) { return typeDecl; }
    113 
    114                 virtual Type* mutate( FunctionType *funcType ) { return funcType; }
     109                virtual Declaration* mutate( StructDecl *aggregateDecl ) override { return aggregateDecl; }
     110                virtual Declaration* mutate( UnionDecl *aggregateDecl ) override { return aggregateDecl; }
     111                virtual Declaration* mutate( EnumDecl *aggregateDecl ) override { return aggregateDecl; }
     112                virtual Declaration* mutate( TraitDecl *aggregateDecl ) override { return aggregateDecl; }
     113                virtual TypeDecl* mutate( TypeDecl *typeDecl ) override { return typeDecl; }
     114                virtual Declaration* mutate( TypedefDecl *typeDecl ) override { return typeDecl; }
     115
     116                virtual Type* mutate( FunctionType *funcType ) override { return funcType; }
    115117
    116118                void hoist( Type * type );
  • src/InitTweak/InitTweak.h

    r837f999 rf849c8e  
    100100
    101101                class ExpanderImpl;
     102                typedef std::list< Expression * > IndexList;
    102103        private:
    103104                std::shared_ptr< ExpanderImpl > expander;
     
    105106
    106107                // invariant: list of size 2N (elements come in pairs [index, dimension])
    107                 typedef std::list< Expression * > IndexList;
    108108                IndexList indices;
    109109        };
  • src/Makefile.am

    r837f999 rf849c8e  
    66## file "LICENCE" distributed with Cforall.
    77##
    8 ## Makefile.am -- 
     8## Makefile.am --
    99##
    1010## Author           : Peter A. Buhr
    1111## Created On       : Sun May 31 08:51:46 2015
    1212## Last Modified By : Peter A. Buhr
    13 ## Last Modified On : Thu Oct 27 11:56:26 2016
    14 ## Update Count     : 74
     13## Last Modified On : Thu Oct 27 20:41:25 2016
     14## Update Count     : 75
    1515###############################################################################
    1616
     
    4141driver_cfa_cpp_SOURCES = ${SRC}
    4242driver_cfa_cpp_LDADD = ${LEXLIB} -ldl                   # yywrap
    43 driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -Xlinker -export-dynamic -I${abs_top_srcdir}/src/include
     43driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -I${abs_top_srcdir}/src/include -DYY_NO_INPUT
     44driver_cfa_cpp_LDFLAGS = -Xlinker -export-dynamic
    4445
    4546MAINTAINERCLEANFILES += ${libdir}/${notdir ${cfa_cpplib_PROGRAMS}}
  • src/Makefile.in

    r837f999 rf849c8e  
    197197driver_cfa_cpp_DEPENDENCIES = $(am__DEPENDENCIES_1)
    198198driver_cfa_cpp_LINK = $(CXXLD) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) \
    199         $(AM_LDFLAGS) $(LDFLAGS) -o $@
     199        $(driver_cfa_cpp_LDFLAGS) $(LDFLAGS) -o $@
    200200DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)
    201201depcomp = $(SHELL) $(top_srcdir)/automake/depcomp
     
    417417driver_cfa_cpp_SOURCES = ${SRC}
    418418driver_cfa_cpp_LDADD = ${LEXLIB} -ldl                   # yywrap
    419 driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -Xlinker -export-dynamic -I${abs_top_srcdir}/src/include
     419driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -I${abs_top_srcdir}/src/include -DYY_NO_INPUT
     420driver_cfa_cpp_LDFLAGS = -Xlinker -export-dynamic
    420421all: $(BUILT_SOURCES)
    421422        $(MAKE) $(AM_MAKEFLAGS) all-am
  • src/Parser/ParseNode.h

    r837f999 rf849c8e  
    109109        ExpressionNode * set_extension( bool exten ) { extension = exten; return this; }
    110110
    111         void print( std::ostream &os, int indent = 0 ) const {}
     111        virtual void print( std::ostream &os, int indent = 0 ) const override {}
    112112        void printOneLine( std::ostream &os, int indent = 0 ) const {}
    113113
     
    187187//##############################################################################
    188188
    189 class TypeData;
     189struct TypeData;
    190190
    191191class DeclarationNode : public ParseNode {
     
    271271        }
    272272
    273         void print( std::ostream &os, int indent = 0 ) const;
    274         void printList( std::ostream &os, int indent = 0 ) const;
     273        virtual void print( std::ostream &os, int indent = 0 ) const override;
     274        virtual void printList( std::ostream &os, int indent = 0 ) const override;
    275275
    276276        Declaration * build() const;
     
    345345        virtual StatementNode * append_last_case( StatementNode * );
    346346
    347         virtual void print( std::ostream &os, int indent = 0 ) {}
    348         virtual void printList( std::ostream &os, int indent = 0 ) {}
     347        virtual void print( std::ostream &os, int indent = 0 ) const override {}
     348        virtual void printList( std::ostream &os, int indent = 0 ) const override {}
    349349  private:
    350350        std::unique_ptr<Statement> stmt;
  • src/ResolvExpr/AlternativePrinter.h

    r837f999 rf849c8e  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // AlternativePrinter.h -- 
     7// AlternativePrinter.h --
    88//
    99// Author           : Richard C. Bilson
     
    2323
    2424namespace ResolvExpr {
    25         class AlternativePrinter : public SymTab::Indexer {
     25        class AlternativePrinter final : public SymTab::Indexer {
    2626          public:
    2727                AlternativePrinter( std::ostream &os );
    28                 virtual void visit( ExprStmt *exprStmt );
     28
     29                using SymTab::Indexer::visit;
     30                virtual void visit( ExprStmt *exprStmt ) override;
    2931          private:
    3032                std::ostream &os;
  • src/ResolvExpr/Resolver.cc

    r837f999 rf849c8e  
    3232
    3333namespace ResolvExpr {
    34         class Resolver : public SymTab::Indexer {
     34        class Resolver final : public SymTab::Indexer {
    3535          public:
    36                 Resolver() : SymTab::Indexer( false ), switchType( 0 ) {}
    37 
    38                 virtual void visit( FunctionDecl *functionDecl );
    39                 virtual void visit( ObjectDecl *functionDecl );
    40                 virtual void visit( TypeDecl *typeDecl );
    41                 virtual void visit( EnumDecl * enumDecl );
    42 
    43                 virtual void visit( ArrayType * at );
    44                 virtual void visit( PointerType * at );
    45 
    46                 virtual void visit( ExprStmt *exprStmt );
    47                 virtual void visit( AsmExpr *asmExpr );
    48                 virtual void visit( AsmStmt *asmStmt );
    49                 virtual void visit( IfStmt *ifStmt );
    50                 virtual void visit( WhileStmt *whileStmt );
    51                 virtual void visit( ForStmt *forStmt );
    52                 virtual void visit( SwitchStmt *switchStmt );
    53                 virtual void visit( CaseStmt *caseStmt );
    54                 virtual void visit( BranchStmt *branchStmt );
    55                 virtual void visit( ReturnStmt *returnStmt );
    56 
    57                 virtual void visit( SingleInit *singleInit );
    58                 virtual void visit( ListInit *listInit );
    59                 virtual void visit( ConstructorInit *ctorInit );
     36                Resolver() : SymTab::Indexer( false ) {}
     37
     38                using SymTab::Indexer::visit;
     39                virtual void visit( FunctionDecl *functionDecl ) override;
     40                virtual void visit( ObjectDecl *functionDecl ) override;
     41                virtual void visit( TypeDecl *typeDecl ) override;
     42                virtual void visit( EnumDecl * enumDecl ) override;
     43
     44                virtual void visit( ArrayType * at ) override;
     45                virtual void visit( PointerType * at ) override;
     46
     47                virtual void visit( ExprStmt *exprStmt ) override;
     48                virtual void visit( AsmExpr *asmExpr ) override;
     49                virtual void visit( AsmStmt *asmStmt ) override;
     50                virtual void visit( IfStmt *ifStmt ) override;
     51                virtual void visit( WhileStmt *whileStmt ) override;
     52                virtual void visit( ForStmt *forStmt ) override;
     53                virtual void visit( SwitchStmt *switchStmt ) override;
     54                virtual void visit( CaseStmt *caseStmt ) override;
     55                virtual void visit( BranchStmt *branchStmt ) override;
     56                virtual void visit( ReturnStmt *returnStmt ) override;
     57
     58                virtual void visit( SingleInit *singleInit ) override;
     59                virtual void visit( ListInit *listInit ) override;
     60                virtual void visit( ConstructorInit *ctorInit ) override;
    6061          private:
    6162        typedef std::list< Initializer * >::iterator InitIterator;
     
    6970                std::list< Type * > functionReturn;
    7071                Type *initContext;
    71                 Type *switchType;
    7272                bool inEnumDecl = false;
    7373        };
  • src/ResolvExpr/TypeMap.h

    r837f999 rf849c8e  
    3838                typedef typename std::map< std::string, Value* > ValueMap;
    3939                typedef typename ValueMap::iterator ValueMapIterator;
    40                
     40
    4141                Value *voidValue;                                     ///< Value for void type
    4242                Value *basicValue[BasicType::NUMBER_OF_BASIC_TYPES];  ///< Values for basic types
     
    5454                        /// One scope of map rollbacks
    5555                        typedef std::vector< std::pair< ValueMapIterator, Value* > > MapScope;
    56                        
     56
    5757                        PointerScope pointers;  ///< Value pointers to roll back to their previous state
    5858                        MapScope mapNodes;      ///< Value map iterators to roll back to their previous state
     
    6868
    6969                std::vector< Rollback > scopes;  ///< Scope rollback information
    70                
     70
    7171                struct Lookup : public Visitor {
    7272                        Lookup( TypeMap<Value> &typeMap ) : typeMap( typeMap ), found( 0 ), toInsert( 0 ) {}
     
    8787                                return found;
    8888                        }
    89                        
     89
    9090                        void findAndReplace( Value *&loc ) {
    9191                                found = loc;
     
    109109                                }
    110110                        }
    111                        
     111
    112112                        virtual void visit( VoidType *voidType ) {
    113113                                findAndReplace( typeMap.voidValue );
    114114                        }
    115                        
     115
    116116                        virtual void visit( BasicType *basicType ) {
    117117                                findAndReplace( typeMap.basicValue[basicType->get_kind()] );
    118118                        }
    119                        
     119
    120120                        virtual void visit( PointerType *pointerType ) {
    121121                                // NOTE This is one of the places where the apporoximation of the resolver is (deliberately) poor;
     
    129129                                }
    130130                        }
    131                        
     131
    132132                        virtual void visit( ArrayType *arrayType ) {
    133133                                if ( dynamic_cast< FunctionType* >( arrayType->get_base() ) ) {
     
    137137                                }
    138138                        }
    139                        
     139
    140140                        virtual void visit( FunctionType *functionType ) {
    141141                                findAndReplace( typeMap.functionPointerValue );
    142142                        }
    143                        
     143
    144144                        virtual void visit( StructInstType *structType ) {
    145145                                findAndReplace( typeMap.structValue, structType->get_name() );
    146146                        }
    147                        
     147
    148148                        virtual void visit( UnionInstType *unionType ) {
    149149                                findAndReplace( typeMap.unionValue, unionType->get_name() );
    150150                        }
    151                        
     151
    152152                        virtual void visit( EnumInstType *enumType ) {
    153153                                findAndReplace( typeMap.enumValue, enumType->get_name() );
     
    157157                        Value *found;             ///< Value found (NULL if none yet)
    158158                        Value *toInsert;          ///< Value to insert (NULL if a lookup)
    159                 };  // class Lookup
    160                 friend class Lookup;
    161                
     159                };  // struct Lookup
     160                friend struct Lookup;
     161
    162162        public:
    163163                /// Starts a new scope
     
    180180                        scopes.pop_back();
    181181                }
    182                
     182
    183183                TypeMap() : voidValue( 0 ), pointerValue( 0 ), voidPointerValue( 0 ), functionPointerValue( 0 ), structValue(), unionValue(), enumValue(), scopes() {
    184184                        beginScope();
     
    199199                        return searcher.find( key );
    200200                }
    201                
     201
    202202        }; // class TypeMap
    203203
  • src/ResolvExpr/Unify.cc

    r837f999 rf849c8e  
    7373                const OpenVarSet &openVars;
    7474                WidenMode widenMode;
    75                 Type *commonType;
    7675                const SymTab::Indexer &indexer;
    7776        };
  • src/SymTab/Validate.cc

    r837f999 rf849c8e  
    9494
    9595        /// Associates forward declarations of aggregates with their definitions
    96         class Pass2 : public Indexer {
     96        class Pass2 final : public Indexer {
    9797                typedef Indexer Parent;
    9898          public:
    9999                Pass2( bool doDebug, const Indexer *indexer );
    100100          private:
    101                 virtual void visit( StructInstType *structInst );
    102                 virtual void visit( UnionInstType *unionInst );
    103                 virtual void visit( TraitInstType *contextInst );
    104                 virtual void visit( StructDecl *structDecl );
    105                 virtual void visit( UnionDecl *unionDecl );
    106                 virtual void visit( TypeInstType *typeInst );
     101                using Indexer::visit;
     102                void visit( StructInstType *structInst ) final;
     103                void visit( UnionInstType *unionInst ) final;
     104                void visit( TraitInstType *contextInst ) final;
     105                void visit( StructDecl *structDecl ) final;
     106                void visit( UnionDecl *unionDecl ) final;
     107                void visit( TypeInstType *typeInst ) final;
    107108
    108109                const Indexer *indexer;
     
    182183        };
    183184
    184         class CompoundLiteral : public GenPoly::DeclMutator {
     185        class CompoundLiteral final : public GenPoly::DeclMutator {
    185186                DeclarationNode::StorageClass storageclass = DeclarationNode::NoStorageClass;
    186187
    187                 virtual DeclarationWithType * mutate( ObjectDecl *objectDecl );
    188                 virtual Expression *mutate( CompoundLiteralExpr *compLitExpr );
     188                using GenPoly::DeclMutator::mutate;
     189                DeclarationWithType * mutate( ObjectDecl *objectDecl ) final;
     190                Expression *mutate( CompoundLiteralExpr *compLitExpr ) final;
    189191        };
    190192
     
    652654        void EliminateTypedef::addImplicitTypedef( AggDecl * aggDecl ) {
    653655                if ( typedefNames.count( aggDecl->get_name() ) == 0 ) {
    654                         Type *type;
     656                        Type *type = nullptr;
    655657                        if ( StructDecl * newDeclStructDecl = dynamic_cast< StructDecl * >( aggDecl ) ) {
    656658                                type = new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() );
  • src/Tuples/TupleAssignment.cc

    r837f999 rf849c8e  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // TupleAssignment.cc -- 
     7// TupleAssignment.cc --
    88//
    99// Author           : Rodolfo G. Esteves
     
    2929
    3030namespace Tuples {
    31         TupleAssignSpotter::TupleAssignSpotter( ResolvExpr::AlternativeFinder *f = 0 )
     31        TupleAssignSpotter::TupleAssignSpotter( ResolvExpr::AlternativeFinder *f )
    3232                : currentFinder(f), matcher(0), hasMatched( false ) {}
    3333
  • src/Tuples/TupleAssignment.h

    r837f999 rf849c8e  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // TupleAssignment.h -- 
     7// TupleAssignment.h --
    88//
    99// Author           : Rodolfo G. Esteves
     
    2929          public:
    3030                // dispatcher for Tuple (multiple and mass) assignment operations
    31                 TupleAssignSpotter( ResolvExpr::AlternativeFinder * );
     31                TupleAssignSpotter( ResolvExpr::AlternativeFinder * = 0 );
    3232                ~TupleAssignSpotter() { delete matcher; matcher = 0; }
    3333
     
    9797                ResolvExpr::AlternativeFinder *currentFinder;
    9898                //std::list<Expression *> rhs, lhs;
    99                 Expression *rhs, *lhs;
     99                // Expression *rhs, *lhs;
    100100                Matcher *matcher;
    101101                bool hasMatched;
  • src/driver/Makefile.am

    r837f999 rf849c8e  
    66## file "LICENCE" distributed with Cforall.
    77##
    8 ## Makefile.am -- 
     8## Makefile.am --
    99##
    1010## Author           : Peter A. Buhr
     
    2626cc1_SOURCES = cc1.cc
    2727
     28cfa.cc : ${abs_top_srcdir}/version
     29        @true
     30
    2831MAINTAINERCLEANFILES = @CFA_PREFIX@/bin/${bin_PROGRAMS} @CFA_PREFIX@/lib/${cc1lib_PROGRAMS}
  • src/driver/Makefile.in

    r837f999 rf849c8e  
    100100CFA_PREFIX = @CFA_PREFIX@
    101101CFLAGS = @CFLAGS@
     102CONFIG_STATUS_DEPENDENCIES = @CONFIG_STATUS_DEPENDENCIES@
    102103CPP = @CPP@
    103104CPPFLAGS = @CPPFLAGS@
     
    542543
    543544
     545cfa.cc : ${abs_top_srcdir}/version
     546        @true
     547
    544548# Tell versions [3.59,3.63) of GNU make to not export all variables.
    545549# Otherwise a system limit (for SysV at least) may be exceeded.
  • src/driver/cfa.cc

    r837f999 rf849c8e  
    2525using std::endl;
    2626using std::string;
     27using std::to_string;
    2728
    2829
     
    5051
    5152int main( int argc, char *argv[] ) {
    52         string Version( VERSION );                                                      // current version number from CONFIG
    53         string Major( CFA_VERSION_MAJOR ), Minor( CFA_VERSION_MINOR ), Patch( CFA_VERSION_MINOR );
     53        string Version( CFA_VERSION_LONG );                                                     // current version number from CONFIG
     54        string Major( to_string( CFA_VERSION_MAJOR ) ), Minor( to_string( CFA_VERSION_MINOR ) ), Patch( to_string( CFA_VERSION_PATCH ) );
    5455
    5556        string installincdir( CFA_INCDIR );                                     // fixed location of include files
  • src/examples/Makefile.in

    r837f999 rf849c8e  
    111111# applies to both programs
    112112CFLAGS = -g -Wall -Wno-unused-function # TEMPORARY: does not build with -O2
     113CONFIG_STATUS_DEPENDENCIES = @CONFIG_STATUS_DEPENDENCIES@
    113114CPP = @CPP@
    114115CPPFLAGS = @CPPFLAGS@
  • src/libcfa/Makefile.in

    r837f999 rf849c8e  
    137137CFA_PREFIX = @CFA_PREFIX@
    138138CFLAGS = -quiet -no-include-stdhdr -g -Wall -Wno-unused-function @CFA_FLAGS@ -B${abs_top_srcdir}/src/driver -XCFA -t # TEMPORARY: does not build with -O2
     139CONFIG_STATUS_DEPENDENCIES = @CONFIG_STATUS_DEPENDENCIES@
    139140CPP = @CPP@
    140141CPPFLAGS = @CPPFLAGS@
  • src/tests/Makefile.in

    r837f999 rf849c8e  
    121121# applies to both programs
    122122CFLAGS = -g -Wall -Wno-unused-function @CFA_FLAGS@ # TEMPORARY: does not build with -O2
     123CONFIG_STATUS_DEPENDENCIES = @CONFIG_STATUS_DEPENDENCIES@
    123124CPP = @CPP@
    124125CPPFLAGS = @CPPFLAGS@
Note: See TracChangeset for help on using the changeset viewer.