Index: Jenkinsfile =================================================================== --- Jenkinsfile (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ Jenkinsfile (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,418 @@ +#!groovy + +//=========================================================================================================== +// Main loop of the compilation +//=========================================================================================================== + +node('master') { + // Globals + BuildDir = pwd tmp: true + SrcDir = pwd tmp: false + Settings = null + StageName = '' + + // Local variables + def err = null + def log_needed = false + + currentBuild.result = "SUCCESS" + + try { + //Wrap build to add timestamp to command line + wrap([$class: 'TimestamperBuildWrapper']) { + + notify_server(0) + + Settings = prepare_build() + + node(Settings.Architecture.node) { + BuildDir = pwd tmp: true + SrcDir = pwd tmp: false + + clean() + + checkout() + + notify_server(0) + + build() + + test() + + benchmark() + + build_doc() + + publish() + } + + // Update the build directories when exiting the node + BuildDir = pwd tmp: true + SrcDir = pwd tmp: false + + notify_server(45) + } + } + + //If an exception is caught we need to change the status and remember to + //attach the build log to the email + catch (Exception caughtError) { + //rethrow error later + err = caughtError + + echo err.toString() + + //An error has occured, the build log is relevent + log_needed = true + + //Store the result of the build log + currentBuild.result = "${StageName} FAILURE".trim() + } + + finally { + //Send email with final results if this is not a full build + if( Settings && !Settings.Silent ) { + email(log_needed, Settings.IsSandbox) + } + + echo 'Build Completed' + + /* Must re-throw exception to propagate error */ + if (err) { + throw err + } + } +} +//=========================================================================================================== +// Main compilation routines +//=========================================================================================================== +def clean() { + build_stage('Cleanup') { + // clean the build by wipping the build directory + dir(BuildDir) { + deleteDir() + } + } +} + +//Compilation script is done here but environnement set-up and error handling is done in main loop +def checkout() { + build_stage('Checkout') { + //checkout the source code and clean the repo + final scmVars = checkout scm + Settings.GitNewRef = scmVars.GIT_COMMIT + Settings.GitOldRef = scmVars.GIT_PREVIOUS_COMMIT + + echo GitLogMessage() + } +} + +def build() { + build_stage('Build') { + // Build outside of the src tree to ease cleaning + dir (BuildDir) { + //Configure the conpilation (Output is not relevant) + //Use the current directory as the installation target so nothing escapes the sandbox + //Also specify the compiler by hand + targets="" + if( Settings.RunAllTests ) { + targets="--with-target-hosts='host:debug,host:nodebug'" + } else { + targets="--with-target-hosts='host:debug'" + } + + sh "${SrcDir}/configure CXX=${Settings.Compiler.CXX} CC=${Settings.Compiler.CC} ${Settings.Architecture.flags} ${targets} --quiet" + + //Compile the project + sh 'make -j 8 --no-print-directory' + } + } +} + +def test() { + build_stage('Test') { + + dir (BuildDir) { + //Run the tests from the tests directory + if ( Settings.RunAllTests ) { + sh 'make --no-print-directory -C tests timeouts="--timeout=600" all-tests debug=yes' + sh 'make --no-print-directory -C tests timeouts="--timeout=600" all-tests debug=no ' + } + else { + sh 'make --no-print-directory -C tests' + } + } + } +} + +def benchmark() { + build_stage('Benchmark') { + + if( !Settings.RunBenchmark ) return + + dir (BuildDir) { + //Append bench results + sh "${SrcDir}/benchmark/jenkins.sh ${Settings.GitNewRef} ${Settings.Architecture} ${BuildDir}/bench.json" + } + } +} + +def build_doc() { + build_stage('Documentation') { + + if( !Settings.BuildDocumentation ) return + + dir ('doc/user') { + make_doc() + } + + dir ('doc/refrat') { + make_doc() + } + } +} + +def publish() { + build_stage('Publish') { + + if( !Settings.Publish ) return + + //Then publish the results + sh 'curl --silent --show-error -H \'Content-Type: application/json\' --data @${BuildDir}/bench.json https://cforall.uwaterloo.ca:8082/jenkins/publish > /dev/null || true' + } +} + +//=========================================================================================================== +//Routine responsible of sending the email notification once the build is completed +//=========================================================================================================== +def GitLogMessage() { + if (!Settings || !Settings.GitOldRef || !Settings.GitNewRef) return "\nERROR retrieveing git information!\n" + + sh "${SrcDir}/tools/PrettyGitLogs.sh ${SrcDir} ${BuildDir} ${Settings.GitOldRef} ${Settings.GitNewRef}" + + def gitUpdate = readFile("${BuildDir}/GIT_UPDATE") + def gitLog = readFile("${BuildDir}/GIT_LOG") + def gitDiff = readFile("${BuildDir}/GIT_DIFF") + + return """ +The branch ${env.BRANCH_NAME} has been updated. +${gitUpdate} + +Check console output at ${env.BUILD_URL} to view the results. + +- Status -------------------------------------------------------------- + +BUILD# ${env.BUILD_NUMBER} - ${currentBuild.result} + +- Log ----------------------------------------------------------------- +${gitLog} +----------------------------------------------------------------------- +Summary of changes: +${gitDiff} +""" +} + +//Standard build email notification +def email(boolean log, boolean bIsSandbox) { + //Since tokenizer doesn't work, figure stuff out from the environnement variables and command line + //Configurations for email format + echo 'Notifying users of result' + + def project_name = (env.JOB_NAME =~ /(.+)\/.+/)[0][1].toLowerCase() + def email_subject = "[${project_name} git][BUILD# ${env.BUILD_NUMBER} - ${currentBuild.result}] - branch ${env.BRANCH_NAME}" + def email_body = """This is an automated email from the Jenkins build machine. It was +generated because of a git hooks/post-receive script following +a ref change which was pushed to the Cforall repository. +""" + GitLogMessage() + + def email_to = "cforall@lists.uwaterloo.ca" + + if( Settings && !Settings.IsSandbox ) { + //send email notification + emailext body: email_body, subject: email_subject, to: email_to, attachLog: log + } else { + echo "Would send email to: ${email_to}" + echo "With title: ${email_subject}" + echo "Content: \n${email_body}" + } +} + +//=========================================================================================================== +// Helper classes/variables/routines +//=========================================================================================================== +//Description of a compiler (Must be serializable since pipelines are persistent) +class CC_Desc implements Serializable { + public String name + public String CXX + public String CC + + CC_Desc(String name, String CXX, String CC) { + this.name = name + this.CXX = CXX + this.CC = CC + } +} + +//Description of an architecture (Must be serializable since pipelines are persistent) +class Arch_Desc implements Serializable { + public String name + public String flags + public String node + + Arch_Desc(String name, String flags, String node) { + this.name = name + this.flags = flags + this.node = node + } +} + +class BuildSettings implements Serializable { + public final CC_Desc Compiler + public final Arch_Desc Architecture + public final Boolean RunAllTests + public final Boolean RunBenchmark + public final Boolean BuildDocumentation + public final Boolean Publish + public final Boolean Silent + public final Boolean IsSandbox + public final String DescLong + public final String DescShort + + public String GitNewRef + public String GitOldRef + + BuildSettings(java.util.Collections$UnmodifiableMap param, String branch) { + switch( param.Compiler ) { + case 'gcc-6': + this.Compiler = new CC_Desc('gcc-6', 'g++-6', 'gcc-6') + break + case 'gcc-5': + this.Compiler = new CC_Desc('gcc-5', 'g++-5', 'gcc-5') + break + case 'gcc-4.9': + this.Compiler = new CC_Desc('gcc-4.9', 'g++-4.9', 'gcc-4.9') + break + case 'clang': + this.Compiler = new CC_Desc('clang', 'clang++', 'gcc-6') + break + default : + error "Unhandled compiler : ${cc}" + } + + switch( param.Architecture ) { + case 'x64': + this.Architecture = new Arch_Desc('x64', '--host=x86_64', 'x64') + break + case 'x86': + this.Architecture = new Arch_Desc('x86', '--host=i386', 'x86') + break + default : + error "Unhandled architecture : ${arch}" + } + + this.RunAllTests = param.RunAllTests + this.RunBenchmark = param.RunBenchmark + this.BuildDocumentation = param.BuildDocumentation + this.Publish = param.Publish + this.Silent = param.Silent + this.IsSandbox = (branch == "jenkins-sandbox") + + def full = param.RunAllTests ? " (Full)" : "" + this.DescShort = "${ this.Compiler.name }:${ this.Architecture.name }${full}" + + this.DescLong = """Compiler : ${ this.Compiler.name } (${ this.Compiler.CXX }/${ this.Compiler.CC }) +Architecture : ${ this.Architecture.name } +Arc Flags : ${ this.Architecture.flags } +Run All Tests : ${ this.RunAllTests.toString() } +Run Benchmark : ${ this.RunBenchmark.toString() } +Build Documentation : ${ this.BuildDocumentation.toString() } +Publish : ${ this.Publish.toString() } +Silent : ${ this.Silent.toString() } +""" + + this.GitNewRef = '' + this.GitOldRef = '' + } +} + +def prepare_build() { + // prepare the properties + properties ([ \ + [$class: 'ParametersDefinitionProperty', \ + parameterDefinitions: [ \ + [$class: 'ChoiceParameterDefinition', \ + description: 'Which compiler to use', \ + name: 'Compiler', \ + choices: 'gcc-6\ngcc-5\ngcc-4.9\nclang', \ + defaultValue: 'gcc-6', \ + ], \ + [$class: 'ChoiceParameterDefinition', \ + description: 'The target architecture', \ + name: 'Architecture', \ + choices: 'x64\nx86', \ + defaultValue: 'x64', \ + ], \ + [$class: 'BooleanParameterDefinition', \ + description: 'If false, only the quick test suite is ran', \ + name: 'RunAllTests', \ + defaultValue: false, \ + ], \ + [$class: 'BooleanParameterDefinition', \ + description: 'If true, jenkins also runs benchmarks', \ + name: 'RunBenchmark', \ + defaultValue: false, \ + ], \ + [$class: 'BooleanParameterDefinition', \ + description: 'If true, jenkins also builds documentation', \ + name: 'BuildDocumentation', \ + defaultValue: true, \ + ], \ + [$class: 'BooleanParameterDefinition', \ + description: 'If true, jenkins also publishes results', \ + name: 'Publish', \ + defaultValue: false, \ + ], \ + [$class: 'BooleanParameterDefinition', \ + description: 'If true, jenkins will not send emails', \ + name: 'Silent', \ + defaultValue: false, \ + ], \ + ], + ]]) + + // It's unfortunate but it looks like we need to checkout the entire repo just to get the pretty git printer + checkout scm + + final settings = new BuildSettings(params, env.BRANCH_NAME) + + currentBuild.description = settings.DescShort + echo settings.DescLong + + return settings +} + +def build_stage(String name, Closure block ) { + StageName = name + echo " -------- ${StageName} -------- " + stage(name, block) +} + +def notify_server(int wait) { + sh """curl --silent --show-error --data "wait=${wait}" -X POST https://cforall.uwaterloo.ca:8082/jenkins/notify > /dev/null || true""" + return +} + +def make_doc() { + def err = null + try { + sh 'make clean > /dev/null' + sh 'make > /dev/null 2>&1' + } + catch (Exception caughtError) { + err = caughtError //rethrow error later + sh 'cat build/*.log' + } + finally { + if (err) throw err // Must re-throw exception to propagate error + } +} Index: benchmark/Makefile.am =================================================================== --- benchmark/Makefile.am (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ benchmark/Makefile.am (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -21,7 +21,7 @@ include $(top_srcdir)/src/cfa.make -AM_CFLAGS = -O2 -Wall -I$(srcdir) -lrt -pthread -AM_CFAFLAGS = -quiet -in-tree -nodebug -AM_UPPFLAGS = -quiet -nodebug -multi +AM_CFLAGS = -O2 -Wall -Wextra -Werror -I$(srcdir) -lrt -pthread +AM_CFAFLAGS = -quiet -nodebug -in-tree +AM_UPPFLAGS = -quiet -nodebug -multi -std=c++14 BENCH_V_CC = $(__bench_v_CC_$(__quiet)) @@ -139,4 +139,7 @@ $(BENCH_V_CC)$(COMPILE) -DBENCH_N=500000000 $(srcdir)/fetch_add.c +tls-fetch_add$(EXEEXT): + $(BENCH_V_CC)$(COMPILE) -DBENCH_N=500000000 $(srcdir)/tls-fetch_add.c + ## ========================================================================================================= CTXSWITCH_DEPEND = \ @@ -144,4 +147,5 @@ function.run \ fetch_add.run \ + tls-fetch_add.run \ ctxswitch-pthread.run \ ctxswitch-cfa_coroutine.run \ Index: benchmark/Makefile.in =================================================================== --- benchmark/Makefile.in (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ benchmark/Makefile.in (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -371,7 +371,7 @@ # applies to both programs -AM_CFLAGS = -O2 -Wall -I$(srcdir) -lrt -pthread -AM_CFAFLAGS = -quiet -in-tree -nodebug -AM_UPPFLAGS = -quiet -nodebug -multi +AM_CFLAGS = -O2 -Wall -Wextra -Werror -I$(srcdir) -lrt -pthread +AM_CFAFLAGS = -quiet -nodebug -in-tree +AM_UPPFLAGS = -quiet -nodebug -multi -std=c++14 BENCH_V_CC = $(__bench_v_CC_$(__quiet)) BENCH_V_CFA = $(__bench_v_CFA_$(__quiet)) @@ -402,9 +402,9 @@ dummy_SOURCES = dummyC.c dummyCXX.cpp CTXSWITCH_DEPEND = loop.run function.run fetch_add.run \ - ctxswitch-pthread.run ctxswitch-cfa_coroutine.run \ - ctxswitch-cfa_thread.run ctxswitch-cfa_thread2.run \ - ctxswitch-upp_coroutine.run ctxswitch-upp_thread.run \ - ctxswitch-goroutine.run ctxswitch-java_thread.run \ - $(am__append_1) + tls-fetch_add.run ctxswitch-pthread.run \ + ctxswitch-cfa_coroutine.run ctxswitch-cfa_thread.run \ + ctxswitch-cfa_thread2.run ctxswitch-upp_coroutine.run \ + ctxswitch-upp_thread.run ctxswitch-goroutine.run \ + ctxswitch-java_thread.run $(am__append_1) testdir = $(top_srcdir)/tests all: all-am @@ -799,4 +799,7 @@ $(BENCH_V_CC)$(COMPILE) -DBENCH_N=500000000 $(srcdir)/fetch_add.c +tls-fetch_add$(EXEEXT): + $(BENCH_V_CC)$(COMPILE) -DBENCH_N=500000000 $(srcdir)/tls-fetch_add.c + @WITH_LIBFIBRE_TRUE@ctxswitch-kos_fibre$(EXEEXT): @WITH_LIBFIBRE_TRUE@ $(BENCH_V_CXX)$(CXXCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/kos_fibre.cpp -I$(LIBFIBRE_DIR) -lfibre Index: benchmark/tls-fetch_add.c =================================================================== --- benchmark/tls-fetch_add.c (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ benchmark/tls-fetch_add.c (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,27 @@ +#include +#include + +#include "bench.h" + +#define thread_local _Thread_local + +volatile thread_local bool value; + +void __attribute__((noinline)) do_call() { + __atomic_store_n( &value, true, __ATOMIC_RELAXED ); + __atomic_signal_fence(__ATOMIC_ACQUIRE); + asm volatile (""); + __atomic_store_n( &value, false, __ATOMIC_RELAXED ); + __atomic_signal_fence(__ATOMIC_RELEASE); +} + +int main(int argc, char* argv[]) { + BENCH( + for (size_t i = 0; i < n; i++) { + do_call(); + }, + result + ) + + printf("%llu\n", result); +} Index: configure =================================================================== --- configure (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ configure (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -16738,5 +16738,5 @@ #============================================================================== -ac_config_files="$ac_config_files Makefile driver/Makefile src/Makefile benchmark/Makefile tests/Makefile tests/preempt_longrun/Makefile tools/Makefile tools/prettyprinter/Makefile" +ac_config_files="$ac_config_files Makefile driver/Makefile src/Makefile benchmark/Makefile tests/Makefile longrun_tests/Makefile tools/Makefile tools/prettyprinter/Makefile" @@ -17876,5 +17876,5 @@ "benchmark/Makefile") CONFIG_FILES="$CONFIG_FILES benchmark/Makefile" ;; "tests/Makefile") CONFIG_FILES="$CONFIG_FILES tests/Makefile" ;; - "tests/preempt_longrun/Makefile") CONFIG_FILES="$CONFIG_FILES tests/preempt_longrun/Makefile" ;; + "longrun_tests/Makefile") CONFIG_FILES="$CONFIG_FILES longrun_tests/Makefile" ;; "tools/Makefile") CONFIG_FILES="$CONFIG_FILES tools/Makefile" ;; "tools/prettyprinter/Makefile") CONFIG_FILES="$CONFIG_FILES tools/prettyprinter/Makefile" ;; Index: configure.ac =================================================================== --- configure.ac (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ configure.ac (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -211,5 +211,5 @@ benchmark/Makefile tests/Makefile - tests/preempt_longrun/Makefile + longrun_tests/Makefile tools/Makefile tools/prettyprinter/Makefile Index: doc/bibliography/pl.bib =================================================================== --- doc/bibliography/pl.bib (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ doc/bibliography/pl.bib (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -1163,16 +1163,16 @@ title = {Checked C: Making C Safe by Extension}, booktitle = {2018 IEEE Cybersecurity Development (SecDev)}, - year = {2018}, - month = {September}, - pages = {53-60}, - publisher = {IEEE}, - url = {https://www.microsoft.com/en-us/research/publication/checkedc-making-c-safe-by-extension/}, + year = {2018}, + month = {September}, + pages = {53-60}, + publisher = {IEEE}, + url = {https://www.microsoft.com/en-us/research/publication/checkedc-making-c-safe-by-extension/}, } @misc{Clang, - keywords = {clang}, - contributer = {a3moss@uwaterloo.ca}, - title = {Clang: a {C} language family frontend for {LLVM}}, - howpublished = {\href{https://clang.llvm.org/}{https://\-clang.llvm.org/}} + keywords = {clang}, + contributer = {a3moss@uwaterloo.ca}, + title = {Clang: a {C} language family frontend for {LLVM}}, + howpublished= {\href{https://clang.llvm.org/}{https://\-clang.llvm.org/}} } @@ -2347,4 +2347,20 @@ } +@article{Ritchie93, + keywords = {C, history}, + contributer = {pabuhr@plg}, + author = {Ritchie, Dennis M.}, + title = {The Development of the {C} Language}, + journal = sigplan, + volume = 28, + number = 3, + month = mar, + year = 1993, + pages = {201--208}, + url = {http://doi.acm.org/10.1145/155360.155580}, + publisher = {ACM}, + address = {New York, NY, USA}, +} + @article{design, keywords = {Smalltalk, designing classes}, @@ -2354,5 +2370,7 @@ journal = joop, year = 1988, - volume = 1, number = 2, pages = {22-35}, + volume = 1, + number = 2, + pages = {22-35}, comment = { Abstract classes represent standard protocols. ``It is better to @@ -3789,4 +3807,16 @@ optaddress = {Waterloo, Ontario, Canada, N2L 3G1}, note = {\href{https://uwspace.uwaterloo.ca/handle/10012/13935}{https://\-uwspace.uwaterloo.ca/\-handle/\-10012/\-13935}}, +} + +@article{Swift05, + contributer = {pabuhr@plg}, + author = {Michael M. Swift and Brian N. Bershad and Henry M. Levy}, + title = {Improving the Reliability of Commodity Operating Systems}, + journal = tocs, + volume = 23, + number = 1, + month = feb, + year = 2005, + pages = {77-110}, } Index: doc/papers/concurrency/Paper.tex =================================================================== --- doc/papers/concurrency/Paper.tex (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ doc/papers/concurrency/Paper.tex (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -215,5 +215,8 @@ {} \lstnewenvironment{Go}[1][] -{\lstset{#1}} +{\lstset{language=go,moredelim=**[is][\protect\color{red}]{`}{`},#1}\lstset{#1}} +{} +\lstnewenvironment{python}[1][] +{\lstset{language=python,moredelim=**[is][\protect\color{red}]{`}{`},#1}\lstset{#1}} {} @@ -228,5 +231,5 @@ } -\title{\texorpdfstring{Advanced Control-flow in \protect\CFA}{Advanced Control-flow in Cforall}} +\title{\texorpdfstring{Advanced Control-flow and Concurrency in \protect\CFA}{Advanced Control-flow in Cforall}} \author[1]{Thierry Delisle} @@ -242,9 +245,9 @@ \abstract[Summary]{ \CFA is a modern, polymorphic, non-object-oriented, backwards-compatible extension of the C programming language. -This paper discusses the advanced control-flow features in \CFA, which include concurrency and parallelism, and its supporting runtime system. -These features are created from scratch as ISO C's concurrency is low-level and unimplemented, so C programmers continue to rely on the C pthreads library. -\CFA provides high-level control-flow mechanisms, like coroutines and user-level threads, and monitors for mutual exclusion and synchronization. -A unique contribution of this work is allowing multiple monitors to be safely acquired \emph{simultaneously} (deadlock free), while integrating this capability with all monitor synchronization mechanisms. -All features respect the expectations of C programmers, while being fully integrate with the \CFA polymorphic type-system and other language features. +This paper discusses some advanced control-flow and concurrency/parallelism features in \CFA, along with the supporting runtime. +These features are created from scratch because they do not exist in ISO C, or are low-level and/or unimplemented, so C programmers continue to rely on library features, like C pthreads. +\CFA introduces language-level control-flow mechanisms, like coroutines, user-level threading, and monitors for mutual exclusion and synchronization. +A unique contribution of this work is allowing multiple monitors to be safely acquired \emph{simultaneously} (deadlock free), while integrating this capability with monitor synchronization mechanisms. +These features also integrate with the \CFA polymorphic type-system and exception handling, while respecting the expectations and style of C programmers. Experimental results show comparable performance of the new features with similar mechanisms in other concurrent programming-languages. }% @@ -261,15 +264,16 @@ \section{Introduction} -This paper discusses the design of advanced, high-level control-flow extensions (especially concurrency and parallelism) in \CFA and its runtime. +This paper discusses the design of language-level control-flow and concurrency/parallelism extensions in \CFA and its runtime. \CFA is a modern, polymorphic, non-object-oriented\footnote{ \CFA has features often associated with object-oriented programming languages, such as constructors, destructors, virtuals and simple inheritance. However, functions \emph{cannot} be nested in structures, so there is no lexical binding between a structure and set of functions (member/method) implemented by an implicit \lstinline@this@ (receiver) parameter.}, backwards-compatible extension of the C programming language~\cite{Moss18}. -Within the \CFA framework, new control-flow features were created from scratch. -ISO \Celeven defines only a subset of the \CFA extensions, and with respect to concurrency~\cite[\S~7.26]{C11}, the features are largely wrappers for a subset of the pthreads library~\cite{Butenhof97,Pthreads}. -Furthermore, \Celeven and pthreads concurrency is basic, based on thread fork/join in a function and a few locks, which is low-level and error prone; -no high-level language concurrency features exist. -Interestingly, almost a decade after publication of the \Celeven standard, neither gcc-8, clang-8 nor msvc-19 (most recent versions) support the \Celeven include @threads.h@, indicating little interest in the C concurrency approach. -Finally, while the \Celeven standard does not state a concurrent threading-model, the historical association with pthreads suggests the threading model is kernel-level threading (1:1)~\cite{ThreadModel}. +Within the \CFA framework, new control-flow features are created from scratch. +ISO \Celeven defines only a subset of the \CFA extensions, where the overlapping features are concurrency~\cite[\S~7.26]{C11}. +However, \Celeven concurrency is largely wrappers for a subset of the pthreads library~\cite{Butenhof97,Pthreads}. +Furthermore, \Celeven and pthreads concurrency is simple, based on thread fork/join in a function and a few locks, which is low-level and error prone; +no high-level language concurrency features are defined. +Interestingly, almost a decade after publication of the \Celeven standard, neither gcc-8, clang-8 nor msvc-19 (most recent versions) support the \Celeven include @threads.h@, indicating little interest in the C11 concurrency approach. +Finally, while the \Celeven standard does not state a concurrent threading-model, the historical association with pthreads suggests implementations would adopt kernel-level threading (1:1)~\cite{ThreadModel}. In contrast, there has been a renewed interest during the past decade in user-level (M:N, green) threading in old and new programming languages. @@ -284,13 +288,13 @@ A further effort over the past decade is the development of language memory-models to deal with the conflict between certain language features and compiler/hardware optimizations. -This issue can be rephrased as some features are pervasive (language and runtime) and cannot be safely added via a library to prevent invalidation by sequential optimizations~\cite{Buhr95a,Boehm05}. +This issue can be rephrased as: some language features are pervasive (language and runtime) and cannot be safely added via a library to prevent invalidation by sequential optimizations~\cite{Buhr95a,Boehm05}. The consequence is that a language must be cognizant of these features and provide sufficient tools to program around any safety issues. For example, C created the @volatile@ qualifier to provide correct execution for @setjmp@/@logjmp@ (concurrency came later). -The simplest solution is to provide a handful of complex qualifiers and functions (e.g., @volatile@ and atomics) allowing programmers to write consistent/race-free programs, often in the sequentially-consistent memory-model~\cite{Boehm12}. +The common solution is to provide a handful of complex qualifiers and functions (e.g., @volatile@ and atomics) allowing programmers to write consistent/race-free programs, often in the sequentially-consistent memory-model~\cite{Boehm12}. While having a sufficient memory-model allows sound libraries to be constructed, writing these libraries can quickly become awkward and error prone, and using these low-level libraries has the same issues. Essentially, using low-level explicit locks is the concurrent equivalent of assembler programming. -Just as most assembler programming is replaced with programming in a high-level language, explicit locks can be replaced with high-level concurrency constructs in a programming language. -The goal is to get the compiler to check for correct usage and follow any complex coding conventions implicitly. +Just as most assembler programming is replaced with high-level programming, explicit locks can be replaced with high-level concurrency in a programming language. +Then the goal is for the compiler to check for correct usage and follow any complex coding conventions implicitly. The drawback is that language constructs may preclude certain specialized techniques, therefore introducing inefficiency or inhibiting concurrency. For most concurrent programs, these drawbacks are insignificant in comparison to the speed of composition, and subsequent reliability and maintainability of the high-level concurrent program. @@ -299,5 +303,5 @@ As stated, this observation applies to non-concurrent forms of complex control-flow, like exception handling and coroutines. -Adapting the programming language allows matching the control-flow model with the programming-language style, versus adapting to one general (sound) library/paradigm. +Adapting the programming language to these features also allows matching the control-flow model with the programming-language style, versus adopting one general (sound) library/paradigm. For example, it is possible to provide exceptions, coroutines, monitors, and tasks as specialized types in an object-oriented language, integrating these constructs to allow leveraging the type-system (static type-checking) and all other object-oriented capabilities~\cite{uC++}. It is also possible to leverage call/return for blocking communication via new control structures, versus switching to alternative communication paradigms, like channels or message passing. @@ -307,8 +311,17 @@ however, the reverse is seldom true, i.e., given implicit concurrency, e.g., actors, it is virtually impossible to create explicit concurrency, e.g., blocking thread objects.} Finally, with extended language features and user-level threading it is possible to discretely fold locking and non-blocking I/O multiplexing into the language's I/O libraries, so threading implicitly dovetails with the I/O subsystem. - -\CFA embraces language extensions and user-level threading to provide advanced control-flow and concurrency. -We attempt to show the \CFA extensions and runtime are demonstrably better than those proposed for \CC and other concurrent, imperative programming languages. -The contributions of this work are: +\CFA embraces language extensions and user-level threading to provide advanced control-flow (exception handling\footnote{ +\CFA exception handling will be presented in a separate paper. +The key feature that dovetails with this paper is non-local exceptions allowing exceptions to be raised across stacks, with synchronous exceptions raised among coroutines and asynchronous exceptions raised among threads, similar to that in \uC~\cite[\S~5]{uC++} +} and coroutines) and concurrency. + +Most augmented traditional (Fortran 18~\cite{Fortran18}, Cobol 14~\cite{Cobol14}, Ada 12~\cite{Ada12}, Java 11~\cite{Java11}) and new languages (Go~\cite{Go}, Rust~\cite{Rust}, and D~\cite{D}), except \CC, diverge from C with different syntax and semantics, only interoperate indirectly with C, and are not systems languages, for those with managed memory. +As a result, there is a significant learning curve to move to these languages, and C legacy-code must be rewritten. +While \CC, like \CFA, takes an evolutionary approach to extend C, \CC's constantly growing complex and interdependent features-set (e.g., objects, inheritance, templates, etc.) mean idiomatic \CC code is difficult to use from C, and C programmers must expend significant effort learning \CC. +Hence, rewriting and retraining costs for these languages, even \CC, are prohibitive for companies with a large C software-base. +\CFA with its orthogonal feature-set, its high-performance runtime, and direct access to all existing C libraries circumvents these problems. + +We present comparative examples so the reader can judge if the \CFA control-flow extensions are equivalent or better than those in or proposed for \Celeven, \CC and other concurrent, imperative programming languages, and perform experiments to show the \CFA runtime is competitive with other similar mechanisms. +The detailed contributions of this work are: \begin{itemize} \item @@ -615,7 +628,7 @@ -\section{Coroutines: A Stepping Stone}\label{coroutine} - -Advanced controlWhile the focus of this discussion is concurrency and parallelism, it is important to address coroutines, which are a significant building block of a concurrency system (but not concurrent among themselves). +\section{Coroutines: Stepping Stone} +\label{coroutine} + Coroutines are generalized routines allowing execution to be temporarily suspended and later resumed. Hence, unlike a normal routine, a coroutine may not terminate when it returns to its caller, allowing it to be restarted with the values and execution location present at the point of suspension. @@ -641,20 +654,43 @@ \centering \newbox\myboxA +% \begin{lrbox}{\myboxA} +% \begin{cfa}[aboveskip=0pt,belowskip=0pt] +% `int fn1, fn2, state = 1;` // single global variables +% int fib() { +% int fn; +% `switch ( state )` { // explicit execution state +% case 1: fn = 0; fn1 = fn; state = 2; break; +% case 2: fn = 1; fn2 = fn1; fn1 = fn; state = 3; break; +% case 3: fn = fn1 + fn2; fn2 = fn1; fn1 = fn; break; +% } +% return fn; +% } +% int main() { +% +% for ( int i = 0; i < 10; i += 1 ) { +% printf( "%d\n", fib() ); +% } +% } +% \end{cfa} +% \end{lrbox} \begin{lrbox}{\myboxA} \begin{cfa}[aboveskip=0pt,belowskip=0pt] -`int f1, f2, state = 1;` // single global variables -int fib() { - int fn; - `switch ( state )` { // explicit execution state - case 1: fn = 0; f1 = fn; state = 2; break; - case 2: fn = 1; f2 = f1; f1 = fn; state = 3; break; - case 3: fn = f1 + f2; f2 = f1; f1 = fn; break; - } - return fn; -} +#define FIB_INIT { 0, 1 } +typedef struct { int fn1, fn; } Fib; +int fib( Fib * f ) { + + int ret = f->fn1; + f->fn1 = f->fn; + f->fn = ret + f->fn; + return ret; +} + + + int main() { - + Fib f1 = FIB_INIT, f2 = FIB_INIT; for ( int i = 0; i < 10; i += 1 ) { - printf( "%d\n", fib() ); + printf( "%d %d\n", + fib( &f1 ), fib( &f2 ) ); } } @@ -665,84 +701,106 @@ \begin{lrbox}{\myboxB} \begin{cfa}[aboveskip=0pt,belowskip=0pt] -#define FIB_INIT `{ 0, 1 }` -typedef struct { int f2, f1; } Fib; -int fib( Fib * f ) { - - int ret = f->f2; - int fn = f->f1 + f->f2; - f->f2 = f->f1; f->f1 = fn; - - return ret; -} -int main() { - Fib f1 = FIB_INIT, f2 = FIB_INIT; - for ( int i = 0; i < 10; i += 1 ) { - printf( "%d %d\n", fib( &f1 ), fib( &f2 ) ); +`coroutine` Fib { int fn1; }; +void main( Fib & fib ) with( fib ) { + int fn; + [fn1, fn] = [0, 1]; + for () { + `suspend();` + [fn1, fn] = [fn, fn1 + fn]; } } -\end{cfa} -\end{lrbox} - -\subfloat[3 States: global variables]{\label{f:GlobalVariables}\usebox\myboxA} -\qquad -\subfloat[1 State: external variables]{\label{f:ExternalState}\usebox\myboxB} -\caption{C Fibonacci Implementations} -\label{f:C-fibonacci} - -\bigskip - -\newbox\myboxA -\begin{lrbox}{\myboxA} -\begin{cfa}[aboveskip=0pt,belowskip=0pt] -`coroutine` Fib { int fn; }; -void main( Fib & fib ) with( fib ) { - int f1, f2; - fn = 0; f1 = fn; `suspend()`; - fn = 1; f2 = f1; f1 = fn; `suspend()`; - for ( ;; ) { - fn = f1 + f2; f2 = f1; f1 = fn; `suspend()`; - } -} -int next( Fib & fib ) with( fib ) { - `resume( fib );` - return fn; +int ?()( Fib & fib ) with( fib ) { + `resume( fib );` return fn1; } int main() { Fib f1, f2; - for ( int i = 1; i <= 10; i += 1 ) { - sout | next( f1 ) | next( f2 ); - } -} + for ( 10 ) { + sout | f1() | f2(); +} + + \end{cfa} \end{lrbox} -\newbox\myboxB -\begin{lrbox}{\myboxB} -\begin{cfa}[aboveskip=0pt,belowskip=0pt] -`coroutine` Fib { int ret; }; -void main( Fib & f ) with( fib ) { - int fn, f1 = 1, f2 = 0; - for ( ;; ) { - ret = f2; - - fn = f1 + f2; f2 = f1; f1 = fn; `suspend();` - } -} -int next( Fib & fib ) with( fib ) { - `resume( fib );` - return ret; -} - - - - - - -\end{cfa} + +\newbox\myboxC +\begin{lrbox}{\myboxC} +\begin{python}[aboveskip=0pt,belowskip=0pt] + +def Fib(): + + fn1, fn = 0, 1 + while True: + `yield fn1` + fn1, fn = fn, fn1 + fn + + +// next prewritten + + +f1 = Fib() +f2 = Fib() +for i in range( 10 ): + print( next( f1 ), next( f2 ) ) + + + +\end{python} \end{lrbox} -\subfloat[3 States, internal variables]{\label{f:Coroutine3States}\usebox\myboxA} -\qquad\qquad -\subfloat[1 State, internal variables]{\label{f:Coroutine1State}\usebox\myboxB} -\caption{\CFA Coroutine Fibonacci Implementations} -\label{f:cfa-fibonacci} + +\subfloat[C]{\label{f:GlobalVariables}\usebox\myboxA} +\hspace{3pt} +\vrule +\hspace{3pt} +\subfloat[\CFA]{\label{f:ExternalState}\usebox\myboxB} +\hspace{3pt} +\vrule +\hspace{3pt} +\subfloat[Python]{\label{f:ExternalState}\usebox\myboxC} +\caption{Fibonacci Generator} +\label{f:C-fibonacci} + +% \bigskip +% +% \newbox\myboxA +% \begin{lrbox}{\myboxA} +% \begin{cfa}[aboveskip=0pt,belowskip=0pt] +% `coroutine` Fib { int fn; }; +% void main( Fib & fib ) with( fib ) { +% fn = 0; int fn1 = fn; `suspend()`; +% fn = 1; int fn2 = fn1; fn1 = fn; `suspend()`; +% for () { +% fn = fn1 + fn2; fn2 = fn1; fn1 = fn; `suspend()`; } +% } +% int next( Fib & fib ) with( fib ) { `resume( fib );` return fn; } +% int main() { +% Fib f1, f2; +% for ( 10 ) +% sout | next( f1 ) | next( f2 ); +% } +% \end{cfa} +% \end{lrbox} +% \newbox\myboxB +% \begin{lrbox}{\myboxB} +% \begin{python}[aboveskip=0pt,belowskip=0pt] +% +% def Fibonacci(): +% fn = 0; fn1 = fn; `yield fn` # suspend +% fn = 1; fn2 = fn1; fn1 = fn; `yield fn` +% while True: +% fn = fn1 + fn2; fn2 = fn1; fn1 = fn; `yield fn` +% +% +% f1 = Fibonacci() +% f2 = Fibonacci() +% for i in range( 10 ): +% print( `next( f1 )`, `next( f2 )` ) # resume +% +% \end{python} +% \end{lrbox} +% \subfloat[\CFA]{\label{f:Coroutine3States}\usebox\myboxA} +% \qquad +% \subfloat[Python]{\label{f:Coroutine1State}\usebox\myboxB} +% \caption{Fibonacci input coroutine, 3 states, internal variables} +% \label{f:cfa-fibonacci} \end{figure} @@ -784,34 +842,27 @@ \begin{lrbox}{\myboxA} \begin{cfa}[aboveskip=0pt,belowskip=0pt] -`coroutine` Format { - char ch; // used for communication - int g, b; // global because used in destructor +`coroutine` Fmt { + char ch; // communication variables + int g, b; // needed in destructor }; -void main( Format & fmt ) with( fmt ) { - for ( ;; ) { - for ( g = 0; g < 5; g += 1 ) { // group - for ( b = 0; b < 4; b += 1 ) { // block +void main( Fmt & fmt ) with( fmt ) { + for () { + for ( g = 0; g < 5; g += 1 ) { // groups + for ( b = 0; b < 4; b += 1 ) { // blocks `suspend();` - sout | ch; // separator - } - sout | " "; // separator - } - sout | nl; - } -} -void ?{}( Format & fmt ) { `resume( fmt );` } -void ^?{}( Format & fmt ) with( fmt ) { - if ( g != 0 || b != 0 ) sout | nl; -} -void format( Format & fmt ) { - `resume( fmt );` -} + sout | ch; } // print character + sout | " "; } // block separator + sout | nl; } // group separator +} +void ?{}( Fmt & fmt ) { `resume( fmt );` } // prime +void ^?{}( Fmt & fmt ) with( fmt ) { // destructor + if ( g != 0 || b != 0 ) // special case + sout | nl; } +void send( Fmt & fmt, char c ) { fmt.ch = c; `resume( fmt )`; } int main() { - Format fmt; - eof: for ( ;; ) { - sin | fmt.ch; - if ( eof( sin ) ) break eof; - format( fmt ); - } + Fmt fmt; + sout | nlOff; // turn off auto newline + for ( 41 ) + send( fmt, 'a' ); } \end{cfa} @@ -820,42 +871,35 @@ \newbox\myboxB \begin{lrbox}{\myboxB} -\begin{cfa}[aboveskip=0pt,belowskip=0pt] -struct Format { - char ch; - int g, b; -}; -void format( struct Format * fmt ) { - if ( fmt->ch != -1 ) { // not EOF ? - printf( "%c", fmt->ch ); - fmt->b += 1; - if ( fmt->b == 4 ) { // block - printf( " " ); // separator - fmt->b = 0; - fmt->g += 1; - } - if ( fmt->g == 5 ) { // group - printf( "\n" ); // separator - fmt->g = 0; - } - } else { - if ( fmt->g != 0 || fmt->b != 0 ) printf( "\n" ); - } -} -int main() { - struct Format fmt = { 0, 0, 0 }; - for ( ;; ) { - scanf( "%c", &fmt.ch ); - if ( feof( stdin ) ) break; - format( &fmt ); - } - fmt.ch = -1; - format( &fmt ); -} -\end{cfa} +\begin{python}[aboveskip=0pt,belowskip=0pt] + + + +def Fmt(): + try: + while True: + for g in range( 5 ): + for b in range( 4 ): + + print( `(yield)`, end='' ) + print( ' ', end='' ) + print() + + + except GeneratorExit: + if g != 0 | b != 0: + print() + + +fmt = Fmt() +`next( fmt )` # prime +for i in range( 41 ): + `fmt.send( 'a' );` # send to yield + +\end{python} \end{lrbox} -\subfloat[\CFA Coroutine]{\label{f:CFAFmt}\usebox\myboxA} +\subfloat[\CFA]{\label{f:CFAFmt}\usebox\myboxA} \qquad -\subfloat[C Linearized]{\label{f:CFmt}\usebox\myboxB} -\caption{Formatting text into lines of 5 blocks of 4 characters.} +\subfloat[Python]{\label{f:CFmt}\usebox\myboxB} +\caption{Output formatting text} \label{f:fmt-line} \end{figure} @@ -878,5 +922,5 @@ void main( Prod & prod ) with( prod ) { // 1st resume starts here - for ( int i = 0; i < N; i += 1 ) { + for ( i; N ) { int p1 = random( 100 ), p2 = random( 100 ); sout | p1 | " " | p2; @@ -894,5 +938,5 @@ } void start( Prod & prod, int N, Cons &c ) { - &prod.c = &c; + &prod.c = &c; // reassignable reference prod.[N, receipt] = [N, 0]; `resume( prod );` @@ -909,8 +953,8 @@ Prod & p; int p1, p2, status; - _Bool done; + bool done; }; void ?{}( Cons & cons, Prod & p ) { - &cons.p = &p; + &cons.p = &p; // reassignable reference cons.[status, done ] = [0, false]; } @@ -969,4 +1013,59 @@ The program main restarts after the resume in @start@. @start@ returns and the program main terminates. + +One \emph{killer} application for a coroutine is device drivers, which at one time caused 70\%-85\% of failures in Windows/Linux~\cite{Swift05}. +Many device drivers are a finite state-machine parsing a protocol, e.g.: +\begin{tabbing} +\ldots STX \= \ldots message \ldots \= ESC \= ETX \= \ldots message \ldots \= ETX \= 2-byte crc \= \ldots \kill +\ldots STX \> \ldots message \ldots \> ESC \> ETX \> \ldots message \ldots \> ETX \> 2-byte crc \> \ldots +\end{tabbing} +where a network message begins with the control character STX and ends with an ETX, followed by a 2-byte cyclic-redundancy check. +Control characters may appear in a message if preceded by an ESC. +Because FSMs can be complex and occur frequently in important domains, direct support of the coroutine is crucial in a systems programminglanguage. + +\begin{figure} +\begin{cfa} +enum Status { CONT, MSG, ESTX, ELNTH, ECRC }; +`coroutine` Driver { + Status status; + char * msg, byte; +}; +void ?{}( Driver & d, char * m ) { d.msg = m; } $\C[3.0in]{// constructor}$ +Status next( Driver & d, char b ) with( d ) { $\C{// 'with' opens scope}$ + byte = b; `resume( d );` return status; +} +void main( Driver & d ) with( d ) { + enum { STX = '\002', ESC = '\033', ETX = '\003', MaxMsg = 64 }; + unsigned short int crc; $\C{// error checking}$ + msg: for () { $\C{// parse message}$ + status = CONT; + unsigned int lnth = 0, sum = 0; + while ( byte != STX ) `suspend();` + emsg: for () { + `suspend();` $\C{// process byte}$ + choose ( byte ) { $\C{// switch with default break}$ + case STX: + status = ESTX; `suspend();` continue msg; + case ETX: + break emsg; + case ESC: + suspend(); + } // choose + if ( lnth >= MaxMsg ) { $\C{// buffer full ?}$ + status = ELNTH; `suspend();` continue msg; } + msg[lnth++] = byte; + sum += byte; + } // for + msg[lnth] = '\0'; $\C{// terminate string}\CRT$ + `suspend();` + crc = (unsigned char)byte << 8; // prevent sign extension for signed char + `suspend();` + status = (crc | (unsigned char)byte) == sum ? MSG : ECRC; + `suspend();` + } // for +} +\end{cfa} +\caption{Device driver for simple communication protocol} +\end{figure} Index: doc/papers/concurrency/examples/C++Cor-ts.cpp =================================================================== --- doc/papers/concurrency/examples/C++Cor-ts.cpp (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ doc/papers/concurrency/examples/C++Cor-ts.cpp (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,42 @@ + + +auto result = co_await expression; + +// | | +// | | +// \ / +// \ / +// \/ + +auto&& __a = expression; +if (!__a.await_ready()) { + __a.await_suspend(coroutine-handle) + // ...suspend/resume point... +} +auto result = __a.await_resume(); + +//================================================== + +co_yield i; + +// | | +// | | +// \ / +// \ / +// \/ + +co_await __promise.yield_value(i); + +//================================================== + +... coroutine() { + __coroutine_context* __context = new __coroutine_context{}; + __return = __context->_promise.get_return_object(); + co_await __context->_promise.initial_suspend(); + + ... + +__final_suspend_label: + co_await __context->promise.final_suspend(); + delete __context; +} Index: doc/papers/concurrency/examples/Fib.c =================================================================== --- doc/papers/concurrency/examples/Fib.c (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ doc/papers/concurrency/examples/Fib.c (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,23 @@ +#include + +#define FIB_INIT { 0, 1 } +typedef struct { int fn1, fn; } Fib; +int fib( Fib * f ) { + + int ret = f->fn1; + f->fn1 = f->fn; + f->fn = ret + f->fn; + + return ret; +} +int main() { + Fib f1 = FIB_INIT, f2 = FIB_INIT; + for ( int i = 0; i < 10; i += 1 ) { + printf( "%d %d\n", fib( &f1 ), fib( &f2 ) ); + } +} + +// Local Variables: // +// tab-width: 4 // +// compile-command: "gcc Fib.c" // +// End: // Index: doc/papers/concurrency/examples/Fib.cfa =================================================================== --- doc/papers/concurrency/examples/Fib.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ doc/papers/concurrency/examples/Fib.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,72 @@ +#include +#include + +int fn1, fn2, state = 1; +int fib_gvar() { + int fn; + choose ( state ) { + case 1: fn = 0; fn1 = fn; state = 2; + case 2: fn = 1; fn2 = fn1; fn1 = fn; state = 3; + case 3: fn = fn1 + fn2; fn2 = fn1; fn1 = fn; + } + return fn; +} + +#define FIB_INIT { 0, 1 } +typedef struct { int fn1, fn2; } Fib; +int fib_state( Fib & f ) with( f ) { + int ret = fn2; + int fn = fn1 + fn2; + fn2 = fn1; fn1 = fn; + return ret; +} + +coroutine Fib1 { int fn; }; // used for communication +void main( Fib1 & fib ) with( fib ) { // called on first resume + fn = 0; int fn1 = fn; suspend(); + fn = 1; int fn2 = fn1; fn1 = fn; suspend(); + for () { + fn = fn1 + fn2; fn2 = fn1; fn1 = fn; suspend(); + } +} +int next( Fib1 & fib ) with( fib ) { resume( fib ); return fn; } + +coroutine Fib2 { int ret; }; // used for communication +void main( Fib2 & fib ) with( fib ) { // called on first resume + int fn, fn1 = 1, fn2 = 0; // precompute first two states + for () { + ret = fn2; + fn = fn1 + fn2; fn2 = fn1; fn1 = fn; // general case + suspend(); // restart last resume + } +} +int next( Fib2 & fib ) with( fib ) { + resume( fib ); // restart last suspend + return ret; +} + +int main() { + for ( 10 ) + sout | fib_gvar(); + sout | nl; + + Fib f1 = FIB_INIT, f2 = FIB_INIT; + for ( 10 ) + sout | fib_state( f1 ) | fib_state( f2 ); + sout | nl; + + Fib1 f1, f2; + for ( 10 ) + sout | next( f1 ) | next( f2 ); + sout | nl; + + Fib2 f1, f2; + for ( 10 ) + sout | next( (Fib2 &)f1 ) | next( (Fib2 &)f2 ); +} + +// Local Variables: // +// tab-width: 4 // +// fill-column: 120 // +// compile-command: "cfa Fib.cfa" // +// End: // Index: doc/papers/concurrency/examples/Fib.cpp =================================================================== --- doc/papers/concurrency/examples/Fib.cpp (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ doc/papers/concurrency/examples/Fib.cpp (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,120 @@ +#include +#include +#include +#include + +#include + +template +struct cor_range { + struct promise_type { + T _value; + + cor_range get_return_object() { + return cor_range(std::experimental::coroutine_handle::from_promise(*this)); + } + + auto initial_suspend() { return std::experimental::suspend_always(); } + auto final_suspend() { return std::experimental::suspend_always(); } + + void return_value(T value) { + _value = value; + } + + auto yield_value(T value) { + _value = value; + return std::experimental::suspend_always(); + } + + void unhandled_exception() {} + }; + + std::experimental::coroutine_handle _coroutine = nullptr; + + explicit cor_range(std::experimental::coroutine_handle coroutine) + : _coroutine(coroutine) + {} + + ~cor_range() { + if(_coroutine) { _coroutine.destroy(); } + } + + cor_range() = default; + cor_range(cor_range const &) = delete; + cor_range& operator=(cor_range const &) = delete; + + cor_range(cor_range&& other) { + std::swap(_coroutine, other._coroutine); + } + + cor_range& operator=(cor_range&& other) { + if(&other != this) { + _coroutine = other._coroutine; + other._coroutine = nullptr; + } + return *this; + } + + T next() { + _coroutine.resume(); + return _coroutine.promise()._value; + } + + struct iterator : std::iterator { + std::experimental::coroutine_handle _coroutine = nullptr; + + iterator() = default; + explicit iterator(std::experimental::coroutine_handle coroutine) + : _coroutine(coroutine) + {} + + iterator& operator++() { + _coroutine.resume(); + return *this; + } + + T const & operator*() const { + return _coroutine.promise()._value; + } + }; + + iterator begin() { + if(_coroutine) { + _coroutine.resume(); + if(_coroutine.done()) { return end(); } + } + + return iterator{ _coroutine }; + } + + iterator end() { return iterator{}; } +}; + +cor_range fib() { + int fn; + fn = 0; int fn1 = fn; co_yield fn; + fn = 1; int fn2 = fn1; fn1 = fn; co_yield fn; + for(;;) { + fn = fn1 + fn2; fn2 = fn1; fn1 = fn; co_yield fn; + } +} + +int main() { + { + auto f1 = fib(); + auto f2 = fib(); + for(int i = 0; i < 10; i++) { + std::cout << f1.next() << " " << f2.next() << std::endl; + } + } + + { + auto f1 = fib(); + std::vector fibs; + std::copy_n(f1.begin(), 10, std::back_inserter(fibs)); + + for(auto i : fibs) { + std::cout << i << std::endl; + } + } +} Index: doc/papers/concurrency/examples/Fib.py =================================================================== --- doc/papers/concurrency/examples/Fib.py (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ doc/papers/concurrency/examples/Fib.py (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,17 @@ +def Fib(): + fn = 0; fn1 = fn; yield fn # suspend + fn = 1; fn2 = fn1; fn1 = fn; yield fn + while True: + fn = fn1 + fn2; fn2 = fn1; fn1 = fn; yield fn + + + +f1 = Fib() +f2 = Fib() +for i in range( 10 ): + print( next( f1 ), next( f2 ) ) # resume + +# Local Variables: # +# tab-width: 4 # +# compile-command: "python3.5 Fib.py" # +# End: # Index: doc/papers/concurrency/examples/Fib.sim =================================================================== --- doc/papers/concurrency/examples/Fib.sim (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ doc/papers/concurrency/examples/Fib.sim (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,47 @@ +BEGIN + CLASS Fibonacci; + HIDDEN fn, main; ! private members; + BEGIN + INTEGER fn; ! communication; + + PROCEDURE main; ! mimic uC++ coroutine main; + BEGIN + INTEGER fn1, fn2; + + fn := 0; fn1 := fn; + Detach; ! suspend(); + fn := 1; fn2 := fn1; fn1 := fn; + Detach; ! suspend(); + WHILE TRUE DO BEGIN + fn := fn1 + fn2; fn2 := fn1; fn1 := fn; + Detach; ! suspend(); + END; + END; + + INTEGER PROCEDURE next; + BEGIN + Call( THIS Fibonacci ); ! resume(); + next := fn; + END; + ! Fibonacci constructor code; + Detach; ! return to declaration; + main; ! call main as last line of constructor; + END Fibonacci; + ! program main equivalent; + REF(Fibonacci) f1, f2; ! objects are references; + INTEGER i; + + f1 :- NEW Fibonacci; + f2 :- NEW Fibonacci; + FOR i := 1 STEP 1 UNTIL 10 DO BEGIN + OutInt( f1.next, 3 ); + OutText( " " ); + OutInt( f2.next, 3 ); + OutImage; + END +END; + +! Local Variables: ; +! tab-width: 4 ; +! compile-command: "cim Fib.sim" ; +! End: ; Index: doc/papers/concurrency/examples/Fib2.cfa =================================================================== --- doc/papers/concurrency/examples/Fib2.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ doc/papers/concurrency/examples/Fib2.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,45 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2018 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// fibonacci_1.cfa -- 1-state finite-state machine: precomputed first two states returning f(n - 1) +// +// Author : Peter A. Buhr +// Created On : Thu Apr 26 23:20:08 2018 +// Last Modified By : Peter A. Buhr +// Last Modified On : Fri Mar 22 17:26:41 2019 +// Update Count : 28 +// + +#include +#include + +coroutine Fibonacci { int fn1; }; // used for communication + +void main( Fibonacci & fib ) with( fib ) { // called on first resume + int fn; + [fn1, fn] = [0, 1]; // precompute first two states + for () { + suspend(); // restart last resume + [fn1, fn] = [fn, fn1 + fn]; // general case + } // for +} + +int ?()( Fibonacci & fib ) with( fib ) { // function call operator + resume( fib ); // restart last suspend + return fn1; +} + +int main() { + Fibonacci f1, f2; + for ( 10 ) { // print N Fibonacci values + sout | f1() | f2(); + } // for +} + +// Local Variables: // +// tab-width: 4 // +// compile-command: "cfa fibonacci_1.cfa" // +// End: // Index: doc/papers/concurrency/examples/Fib2.cpp =================================================================== --- doc/papers/concurrency/examples/Fib2.cpp (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ doc/papers/concurrency/examples/Fib2.cpp (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,121 @@ +#include +#include +#include +#include + +#include + +template +struct cor_range { + struct promise_type { + T _value; + + cor_range get_return_object() { + return cor_range(std::experimental::coroutine_handle::from_promise(*this)); + } + + auto initial_suspend() { return std::experimental::suspend_always(); } + auto final_suspend() { return std::experimental::suspend_always(); } + + void return_value(T value) { + _value = value; + } + + auto yield_value(T value) { + _value = value; + return std::experimental::suspend_always(); + } + + void unhandled_exception() {} + }; + + std::experimental::coroutine_handle _coroutine = nullptr; + + explicit cor_range(std::experimental::coroutine_handle coroutine) + : _coroutine(coroutine) + {} + + ~cor_range() { + if(_coroutine) { _coroutine.destroy(); } + } + + cor_range() = default; + cor_range(cor_range const &) = delete; + cor_range& operator=(cor_range const &) = delete; + + cor_range(cor_range&& other) { + std::swap(_coroutine, other._coroutine); + } + + cor_range& operator=(cor_range&& other) { + if(&other != this) { + _coroutine = other._coroutine; + other._coroutine = nullptr; + } + return *this; + } + + T next() { + _coroutine.resume(); + return _coroutine.promise()._value; + } + + struct iterator : std::iterator { + std::experimental::coroutine_handle _coroutine = nullptr; + + iterator() = default; + explicit iterator(std::experimental::coroutine_handle coroutine) + : _coroutine(coroutine) + {} + + iterator& operator++() { + _coroutine.resume(); + return *this; + } + + T const & operator*() const { + return _coroutine.promise()._value; + } + }; + + iterator begin() { + if(_coroutine) { + _coroutine.resume(); + if(_coroutine.done()) { return end(); } + } + + return iterator{ _coroutine }; + } + + iterator end() { return iterator{}; } +}; + +cor_range fib() { + int fn1 = 0, fn = 1; + for(;;) { + co_yield fn1; + int temp = fn1; + fn1 = fn; + fn = temp + fn; + } +} + +int main() { + { + auto f1 = fib(); + auto f2 = fib(); + for(int i = 0; i < 10; i++) { + std::cout << f1.next() << " " << f2.next() << std::endl; + } + } + + { + auto f1 = fib(); + std::vector fibs; + std::copy_n(f1.begin(), 10, std::back_inserter(fibs)); + + for(auto i : fibs) { + std::cout << i << std::endl; + } + } +} Index: doc/papers/concurrency/examples/Fib2.py =================================================================== --- doc/papers/concurrency/examples/Fib2.py (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ doc/papers/concurrency/examples/Fib2.py (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,15 @@ +def Fib(): + fn1, fn = 0, 1 + while True: + yield fn1 + fn1, fn = fn, fn1 + fn + +f1 = Fib() +f2 = Fib() +for i in range( 10 ): + print( next( f1 ), next( f2 ) ) # resume + +# Local Variables: # +# tab-width: 4 # +# compile-command: "python3.5 Fib2.py" # +# End: # Index: doc/papers/concurrency/examples/FibRefactor.py =================================================================== --- doc/papers/concurrency/examples/FibRefactor.py (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ doc/papers/concurrency/examples/FibRefactor.py (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,25 @@ +def Fib(): + def Refactor(): + nonlocal fn, fn1 + fn = 0; fn1 = fn + yield fn # suspend + + def Refactor2(): + nonlocal fn, fn1, fn2 + fn = 1; fn2 = fn1; fn1 = fn + yield fn # suspend + + yield from Refactor() + yield from Refactor2() + while True: + fn = fn1 + fn2; fn2 = fn1; fn1 = fn; yield fn + +f1 = Fib() +f2 = Fib() +for i in range( 10 ): + print( next( f1 ), next( f2 ) ) # resume + +# Local Variables: # +# tab-width: 4 # +# compile-command: "python3.5 FibRefactor.py" # +# End: # Index: doc/papers/concurrency/examples/Fmt.sim =================================================================== --- doc/papers/concurrency/examples/Fmt.sim (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ doc/papers/concurrency/examples/Fmt.sim (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,46 @@ +BEGIN + CLASS FmtLines; + HIDDEN ch, main; ! private members; + BEGIN + CHARACTER ch; ! communication; + + PROCEDURE main; ! mimic uC++ coroutine main; + BEGIN + INTEGER g, b; + + WHILE TRUE DO BEGIN ! for as many characters; + FOR g := 1 STEP 1 UNTIL 5 DO BEGIN ! groups of 5; + FOR b := 1 STEP 1 UNTIL 4 DO BEGIN ! blocks of 4; + OutChar( ch ); + Detach; ! suspend(); + END; + OutText( " " ); + END; + OutImage; ! start newline; + END; + END; + + PROCEDURE prt( chp ); + CHARACTER chp; + BEGIN + ch := chp; ! communication; + Call( THIS FmtLines ); ! resume(); + END; + ! FmtLines constructor code; + Detach; ! return to declaration; + main; ! call main as last line of constructor; + END FmtLines; + ! program main equivalent; + REF(FmtLines) fmt; ! objects are references; + INTEGER i; + + fmt :- NEW FmtLines; + FOR i := Rank( ' ' ) STEP 1 UNTIL Rank( 'z' ) DO BEGIN + fmt.prt( Char( i ) ); + END +END; + +! Local Variables: ; +! tab-width: 4 ; +! compile-command: "cim Fmt.sim" ; +! End: ; Index: doc/papers/concurrency/examples/Format.cc =================================================================== --- doc/papers/concurrency/examples/Format.cc (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ doc/papers/concurrency/examples/Format.cc (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,34 @@ +_Coroutine Format { + char ch; // used for communication + int g, b; // global because used in destructor + void main() { + for ( ;; ) { // for as many characters + for ( g = 0; g < 5; g += 1 ) { // groups of 5 blocks + for ( b = 0; b < 4; b += 1 ) { // blocks of 4 characters +// for ( ;; ) { // for newline characters + suspend(); +// if ( ch != '\n' ) break; // ignore newline +// } +// cout << ch; // print character + } +// cout << " "; // print block separator + } +// cout << endl; // print group separator + } + } + public: + Format() { resume(); } // start coroutine +// ~Format() { if ( g != 0 | | b != 0 ) cout << endl; } + void prt( char ch ) { Format::ch = ch; resume(); } +}; + +int main() { + Format fmt; + for ( long int i = 0; i < 1000000000; i += 1 ) + fmt.prt( 'a' ); +} + +// Local Variables: // +// tab-width: 4 // +// compile-command: "u++-work -O2 -nodebubg Format.cc" // +// End: // Index: doc/papers/concurrency/examples/Format.cfa =================================================================== --- doc/papers/concurrency/examples/Format.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ doc/papers/concurrency/examples/Format.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,84 @@ +#if 1 +#include +#include + +coroutine Fmt { + char ch; // communication variables + int g, b; // needed in destructor +}; +void main( Fmt & fmt ) with( fmt ) { + for () { // for as many characters + for ( g = 0; g < 5; g += 1 ) { // groups of 5 blocks + for ( b = 0; b < 4; b += 1 ) { // blocks of 4 characters +// do { + suspend(); +// } while ( ch == '\n' || ch == '\t' ); + sout | ch; // print character + } + sout | " "; // block separator + } + sout | nl; // group separator + } +} +void ?{}( Fmt & fmt ) { resume( fmt ); } // prime (start) coroutine +void ^?{}( Fmt & fmt ) with( fmt ) { // destructor + if ( g != 0 || b != 0 ) // special case + sout | nl; } +void send( Fmt & fmt, char c ) { fmt.ch = c; resume( fmt ); } +int main() { + Fmt fmt; + sout | nlOff; // turn off auto newline + for ( 41 ) + send( fmt, 'a' ); + // sout | nlOff; // turn off auto newline + // eof: for () { // read until end of file + // sin | fmt.ch; // read one character + // if ( eof( sin ) ) break eof; // eof ? + // format( fmt ); // push character for formatting + // } +} +#else + +#include + +struct Format { + char ch; // used for communication + int g, b; // global because used in destructor +}; + +void format( struct Format * fmt ) { + if ( fmt->ch != -1 ) { // not EOF ? +// if ( fmt->ch == '\n' || fmt->ch == '\t' ) return; +// printf( "%c %d %d", fmt->ch, fmt->g, fmt->b ); // character + printf( "%c", fmt->ch ); // character + fmt->b += 1; + if ( fmt->b == 4 ) { // block ? + printf( " " ); // separator + fmt->b = 0; + fmt->g += 1; + } + if ( fmt->g == 5 ) { // group ? + printf( "\n" ); // separator + fmt->g = 0; + } + } else { + if ( fmt->g != 0 || fmt->b != 0 ) printf( "\n" ); + } +} +int main() { + struct Format fmt = { 0, 0, 0 }; + for ( ;; ) { + scanf( "%c", &fmt.ch ); + if ( feof( stdin ) ) break; + format( &fmt ); + } + fmt.ch = -1; + format( &fmt ); +} +#endif + +// Local Variables: // +// tab-width: 4 // +// fill-column: 120 // +// compile-command: "cfa Format.cfa" // +// End: // Index: doc/papers/concurrency/examples/Format.cpp =================================================================== --- doc/papers/concurrency/examples/Format.cpp (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ doc/papers/concurrency/examples/Format.cpp (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,96 @@ +#include +#include + +struct fmt_cor { + struct promise_type { + char _value; + + fmt_cor get_return_object() { + return fmt_cor(std::experimental::coroutine_handle::from_promise(*this)); + } + + auto initial_suspend() { return std::experimental::suspend_never(); } + auto final_suspend() { return std::experimental::suspend_always(); } + + void return_void() {} + void unhandled_exception() {} + }; + + struct get { + promise_type * _promise = nullptr; + + bool await_ready() noexcept { + return false; + } + + void await_suspend(std::experimental::coroutine_handle _coroutine) noexcept { + _promise = &_coroutine.promise(); + } + char await_resume() noexcept { + assert(_promise); + return _promise->_value; + } + }; + + std::experimental::coroutine_handle _coroutine = nullptr; + + explicit fmt_cor(std::experimental::coroutine_handle coroutine) + : _coroutine(coroutine) + {} + + ~fmt_cor() { + if(_coroutine) { + _coroutine.destroy(); + + } + } + + fmt_cor() = default; + fmt_cor(fmt_cor const &) = delete; + fmt_cor& operator=(fmt_cor const &) = delete; + + fmt_cor(fmt_cor&& other) { + std::swap(_coroutine, other._coroutine); + } + + fmt_cor& operator=(fmt_cor&& other) { + if(&other != this) { + _coroutine = other._coroutine; + other._coroutine = nullptr; + } + return *this; + } + + void send(char a) { + _coroutine.promise()._value = a; + _coroutine.resume(); + } +}; + +fmt_cor Fmt() { + struct locals { + int g, b; + + ~locals() { + if (g != 0 | b != 0) { + std::cout << "\n"; + } + } + } l; + for(;;) { + for(l.g = 0; l.g < 5; l.g++) { + for(l.b = 0; l.b < 4; l.b++) { + std::cout << co_await fmt_cor::get(); + } + std::cout << " "; + } + std::cout << std::endl; + } +} + +int main() { + auto fmt = Fmt(); + for(int i = 0; i < 41; i++) { + fmt.send('a'); + } +} Index: doc/papers/concurrency/examples/Format.py =================================================================== --- doc/papers/concurrency/examples/Format.py (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ doc/papers/concurrency/examples/Format.py (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,21 @@ +def Format(): + try: + while True: + for g in range( 5 ): # groups of 5 blocks + for b in range( 4 ): # blocks of 4 characters + print( (yield), end='' ) # receive from send + print( ' ', end='' ) # block separator + print() # group separator + except GeneratorExit: # destructor + if g != 0 | b != 0: # special case + print() + +fmt = Format() +next( fmt ) # prime generator +for i in range( 41 ): + fmt.send( 'a' ); # send to yield + +# Local Variables: # +# tab-width: 4 # +# compile-command: "python3.5 Format.py" # +# End: # Index: doc/papers/concurrency/examples/Pingpong.cc =================================================================== --- doc/papers/concurrency/examples/Pingpong.cc (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ doc/papers/concurrency/examples/Pingpong.cc (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,31 @@ +#include +using namespace std; + +_Coroutine PingPong { + const char * name; + const unsigned int N; + PingPong * part; + void main() { // ping’s starter ::main, pong’s starter ping + for ( unsigned int i = 0; i < N; i += 1 ) { + cout << name << endl; + part->cycle(); + } + } + public: + PingPong( const char * name, unsigned int N, PingPong & part ) + : name( name ), N( N ), part( & part ) {} + PingPong( const char * name, unsigned int N ) : name( name ), N( N ) {} + void partner( PingPong & part ) { PingPong::part = ∂ } + void cycle() { resume(); } +}; +int main() { + enum { N = 10 }; + PingPong ping( "ping", N ), pong( "pong", N, ping ); + ping.partner( pong ); + ping.cycle(); +} + +// Local Variables: // +// tab-width: 4 // +// compile-command: "u++-work -O2 -nodebug Pingpong.cc" // +// End: // Index: doc/papers/concurrency/examples/Pingpong.cfa =================================================================== --- doc/papers/concurrency/examples/Pingpong.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ doc/papers/concurrency/examples/Pingpong.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,38 @@ +#include +#include + +coroutine PingPong { + const char * name; + unsigned int N; + PingPong & part; +}; + +void ?{}( PingPong & this, const char * name, unsigned int N, PingPong & part ) { + this.[name, N] = [name, N]; &this.part = ∂ +} +void ?{}( PingPong & this, const char * name, unsigned int N ) { + this{ name, N, *0p }; // call first constructor +} +void cycle( PingPong & pingpong ) { + resume( pingpong ); +} +void partner( PingPong & this, PingPong & part ) { + &this.part = ∂ + resume( this ); +} +void main( PingPong & pingpong ) with(pingpong) { // ping's starter ::main, pong's starter ping + for ( N ) { // N ping-pongs + sout | name; + cycle( part ); + } // for +} +int main() { + enum { N = 5 }; + PingPong ping = { "ping", N }, pong = { "pong", N, ping }; + partner( ping, pong ); +} + +// Local Variables: // +// tab-width: 4 // +// compile-command: "cfa Pingpong.cfa" // +// End: // Index: doc/papers/concurrency/examples/Pingpong.py =================================================================== --- doc/papers/concurrency/examples/Pingpong.py (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ doc/papers/concurrency/examples/Pingpong.py (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,32 @@ +def PingPong( name, N ): + partner = (yield) # get partner + yield # resume scheduler + for i in range( N ): + print( name ) + yield partner # execute next + print( "end", name ) + +def Scheduler(): + n = (yield) # starting coroutine + while True: + n = next( n ) # schedule coroutine + +pi = PingPong( "ping", 5 ) +po = PingPong( "pong", 5 ) +next( pi ) # prime +pi.send( po ) # send partner +next( po ) # prime +po.send( pi ) # send partner + +s = Scheduler(); +next( s ) # prime +try: + s.send( pi ) # start cycle +except StopIteration: + print( "scheduler stop" ) +print( "stop" ) + +# Local Variables: # +# tab-width: 4 # +# compile-command: "python3.5 Pingpong.py" # +# End: # Index: doc/papers/concurrency/examples/ProdCons.cfa =================================================================== --- doc/papers/concurrency/examples/ProdCons.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ doc/papers/concurrency/examples/ProdCons.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,76 @@ +#include +#include +#include // random +#include // getpid +coroutine Cons; // forward +int delivery( Cons & cons, int p1, int p2 ); +void stop( Cons & cons ); + +coroutine Prod { + Cons & c; + int N, money, receipt; +}; +void main( Prod & prod ) with( prod ) { // starter ::main + // 1st resume starts here + for ( i; N ) { // N pairs of values + int p1 = random( 100 ), p2 = random( 100 ); + sout | p1 | " " | p2; + int status = delivery( c, p1, p2 ); + sout | " $" | money | nl | status; + receipt += 1; + } + stop( c ); + sout | "prod stops"; +} +int payment( Prod & prod, int m ) with(prod) { + money = m; + resume( prod ); // main 1st time, then + return receipt; // prod in delivery +} +void start( Prod & prod, int N, Cons &c ) { + &prod.c = &c; + prod.[N, receipt] = [N, 0]; + resume( prod ); // activate main +} +coroutine Cons { + Prod & p; + int p1, p2, status; + bool done; +}; +void ?{}( Cons & cons, Prod & p ) { + &cons.p = &p; + cons.[status, done ] = [0, false]; +} +void ^?{}( Cons & cons ) {} +void main( Cons & cons ) with( cons ) { // starter prod + // 1st resume starts here + int money = 1, receipt; + for ( ; ! done; ) { + sout | p1 | " " | p2 | nl | " $" | money; + status += 1; + receipt = payment( p, money ); + sout | " #" | receipt; + money += 1; + } + sout | "cons stops"; +} +int delivery( Cons & cons, int p1, int p2 ) { + cons.[p1, p2] = [p1, p2]; + resume( cons ); // main 1st time, then + return cons.status; // cons in payment +} +void stop( Cons & cons ) { + cons.done = true; + resume( cons ); // activate payment +} +int main() { + Prod prod; + Cons cons = { prod }; + srandom( getpid() ); + start( prod, 5, cons ); +} + +// Local Variables: // +// tab-width: 4 // +// compile-command: "cfa ProdCons.cfa" // +// End: // Index: doc/papers/concurrency/examples/ProdCons.cpp =================================================================== --- doc/papers/concurrency/examples/ProdCons.cpp (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ doc/papers/concurrency/examples/ProdCons.cpp (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,244 @@ +#include +#include +#include +#include +#include + +int random(int max) { + return std::rand() % max; +} + +struct Prod; +struct Cons; + +struct resumable { + virtual resumable * resume() = 0; +}; + +struct Prod : public resumable { + struct local { + Cons * c; + int N, money, receipt; + }; + + struct promise_type { + local _l; + resumable * next; + + Prod get_return_object() { + return Prod(std::experimental::coroutine_handle::from_promise(*this)); + } + + auto initial_suspend() { return std::experimental::suspend_never(); } + auto final_suspend() { return std::experimental::suspend_always(); } + + void return_void() {} + void unhandled_exception() {} + }; + + struct data { + promise_type * _promise = nullptr; + bool await_ready() noexcept { return false; } + void await_suspend(std::experimental::coroutine_handle _coroutine) noexcept { + _promise = &_coroutine.promise(); + } + local & await_resume() noexcept { assert(_promise); return _promise->_l; } + }; + + std::experimental::coroutine_handle _coroutine = nullptr; + + explicit Prod(std::experimental::coroutine_handle coroutine) + : _coroutine(coroutine) + {} + + ~Prod() { + if(_coroutine) { _coroutine.destroy(); } + } + + Prod() = default; + Prod(Prod const &) = delete; + Prod& operator=(Prod const &) = delete; + + Prod(Prod&& other) { + std::swap(_coroutine, other._coroutine); + } + + Prod& operator=(Prod&& other) { + if(&other != this) { + _coroutine = other._coroutine; + other._coroutine = nullptr; + } + return *this; + } + + static Prod main(); + + struct payment_return; + + payment_return payment(int money); + + auto start(int N, Cons & c) { + _coroutine.promise()._l.c = &c; + _coroutine.promise()._l.N = N; + _coroutine.promise()._l.receipt = 0; + } + + virtual resumable * resume() override final { + _coroutine.resume(); + return _coroutine.promise().next; + } +}; + +struct Cons : public resumable { + struct local { + Prod * p; + int p1, p2, status; + bool done; + }; + + struct promise_type { + local _l; + resumable * next; + + Cons get_return_object() { + return Cons(std::experimental::coroutine_handle::from_promise(*this)); + } + + auto initial_suspend() { return std::experimental::suspend_never(); } + auto final_suspend() { return std::experimental::suspend_always(); } + + void return_void() {} + void unhandled_exception() {} + }; + + struct data { + Prod * _p; + data(Prod & prod) : _p(&prod) {} + promise_type * _promise = nullptr; + bool await_ready() noexcept { return false; } + void await_suspend(std::experimental::coroutine_handle _coroutine) noexcept { + _promise = &_coroutine.promise(); + } + local & await_resume() noexcept { assert(_promise); _promise->_l.p = _p; return _promise->_l; } + }; + + std::experimental::coroutine_handle _coroutine = nullptr; + + explicit Cons(std::experimental::coroutine_handle coroutine) + : _coroutine(coroutine) + {} + + ~Cons() { + if(_coroutine) { _coroutine.destroy(); } + } + + Cons() = default; + Cons(Cons const &) = delete; + Cons& operator=(Cons const &) = delete; + + Cons(Cons&& other) { + std::swap(_coroutine, other._coroutine); + } + + Cons& operator=(Cons&& other) { + if(&other != this) { + _coroutine = other._coroutine; + other._coroutine = nullptr; + } + return *this; + } + + static Cons main( Prod & prod ); + + auto deliver(int p1, int p2) { + _coroutine.promise()._l.p1 = p1; + _coroutine.promise()._l.p2 = p2; + + struct ret { + int _status; + Cons * c; + bool await_ready() { return false; } + void await_suspend(std::experimental::coroutine_handle _coroutine) { + _coroutine.promise().next = c; + } + int await_resume() { return _status; } + }; + return ret{ _coroutine.promise()._l.status, this }; + } + + auto stop() { + _coroutine.promise()._l.done = true; + struct ret { + Cons * c; + Prod::promise_type * _promise; + bool await_ready() { return false; } + void await_suspend(std::experimental::coroutine_handle _coroutine) { + _promise = &_coroutine.promise(); + _promise->next = c; + } + void await_resume() { + _promise->next = nullptr; + } + }; + return ret{this, nullptr}; + } + + virtual resumable * resume() override final { + _coroutine.resume(); + return _coroutine.promise().next; + } +}; + +struct Prod::payment_return { + int _receipt; + Prod * p; + bool await_ready() { return false; } + void await_suspend(std::experimental::coroutine_handle _coroutine) { + _coroutine.promise().next = p; + } + int await_resume() { return _receipt; } +}; + +Prod::payment_return Prod::payment(int money) { + _coroutine.promise()._l.money = money; + return payment_return{ _coroutine.promise()._l.receipt, this }; +} + +Prod Prod::main() { + auto & p = co_await Prod::data(); + for(int i = 0; i < p.N; i++) { + int p1 = random(100), p2 = random(100); + std::cout << p1 << " " << p2 << std::endl; + int status = co_await p.c->deliver(p1, p2); + std::cout << " $" << p.money << std::endl << status << std::endl; + p.receipt += 1; + } + co_await p.c->stop(); + std::cout << "prod stops" << std::endl; +} + +Cons Cons::main( Prod & prod ) { + auto & c = co_await Cons::data( prod ); + int money = 1, receipt; + for(;!c.done ;) { + std::cout << c.p1 << " " << c.p2 << std::endl; + std::cout << " $ " << money << std::endl; + c.status += 1; + receipt = co_await c.p->payment( money ); + std::cout << " # " << receipt << std::endl; + money += 1; + } + std::cout << "cons stops" << std::endl; +} + +void dispatch(resumable * r) { + while((r = r->resume())); +} + +int main() { + auto prod = Prod::main(); + auto cons = Cons::main( prod ); + srandom( getpid() ); + prod.start(5, cons); + dispatch(&prod); +} Index: doc/papers/concurrency/examples/ProdCons.py =================================================================== --- doc/papers/concurrency/examples/ProdCons.py (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ doc/papers/concurrency/examples/ProdCons.py (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,40 @@ +def Prod( N ): + cons = (yield) # get cons + yield # resume scheduler + for i in range( N ): + print( "prod" ) + yield cons # execute next + print( "end", "prod" ) + +def Cons( N ): + prod = (yield) # get prod + yield # resume scheduler + for i in range( N ): + print( "cons" ) + yield prod # execute next + print( "end", "cons" ) + +def Scheduler(): + n = (yield) # starting coroutine + while True: + n = next( n ) # schedule coroutine + +prod = Prod( 5 ) +cons = Cons( 5 ) +next( prod ) # prime +prod.send( cons ) # send cons +next( cons ) # prime +cons.send( prod ) # send prod + +s = Scheduler(); +next( s ) # prime +try: + s.send( prod ) # start cycle +except StopIteration: + print( "scheduler stop" ) +print( "stop" ) + +# Local Variables: # +# tab-width: 4 # +# compile-command: "python3.5 ProdCons.py" # +# End: # Index: doc/papers/concurrency/examples/ProdCons.sim =================================================================== --- doc/papers/concurrency/examples/ProdCons.sim (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ doc/papers/concurrency/examples/ProdCons.sim (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,104 @@ +BEGIN + CLASS Consumer( prod ); + REF(Producer) prod; ! constructor parameter; + HIDDEN p1, p2, status, done, Main; + BEGIN + INTEGER p1, p2, status; + BOOLEAN done; + PROCEDURE main; + BEGIN + INTEGER money, receipt; + + money := 1; + WHILE NOT done DO BEGIN + OutText( "cons receives: " ); + OutInt( p1, 3 ); + OutText( ", " ); + OutInt( p2, 3 ); + status := status + 1; + OutText( " and pays $" ); + OutInt( money, 3 ); OutImage; + receipt := prod.payment( money ); + OutText( "cons receipt #" ); + OutInt( receipt, 3 ); OutImage; + money := money + 1; + END; + OutText( "cons stops" ); OutImage; + END; + INTEGER PROCEDURE delivery( p1p, p2p ); + INTEGER p1p, p2p; + BEGIN + p1 := p1p; + p2 := p2p; + Resume( THIS Consumer ); + delivery := status; + END; + PROCEDURE stop; + BEGIN + done := TRUE; + Call( THIS Consumer ); + END; + ! Consumer constructor code; + status := 0; + done := FALSE; + Detach; + main; + END Consumer; + + CLASS Producer; + HIDDEN cons, N, money, receipt, Main; + BEGIN + REF(Consumer) cons; + INTEGER N, money, receipt; + PROCEDURE main; + BEGIN + INTEGER i, p1, p2, status; + + FOR i := 1 STEP 1 UNTIL N DO BEGIN + p1 := RandInt( 1, 100, p1 ); + p2 := RandInt( 1, 100, p2 ); + OutText( "prod delivers: " ); + OutInt( p1, 3 ); OutText( ", " ); + OutInt( p2, 3 ); OutImage; + status := cons.delivery( p1, p2 ); + OutText( "prod status: " ); + OutInt( status, 3 ); OutImage; + END; + cons.stop; + OutText( "prod stops" ); OutImage; + END; + INTEGER PROCEDURE payment( moneyp ); + INTEGER moneyp; + BEGIN + money := moneyp; + OutText( "prod payment of $" ); + OutInt( money, 3 ); OutImage; + Resume( THIS Producer ); + receipt := receipt + 1; + payment := receipt; + END; + PROCEDURE start( Np, consp ); + INTEGER Np; + REF(Consumer) consp; + BEGIN + N := Np; + cons :- consp; + Resume( THIS Producer ); + END; + ! Producer constructor code; + receipt := 0; + Detach; + main; + END Producer; + ! program main equivalent; + REF(Producer) prod; + REF(Consumer) cons; + prod :- NEW Producer; + cons :- NEW Consumer( prod ); + prod.start( 5, cons ); +END; + +! Local Variables: ; +! tab-width: 4 ; +! compile-command: "cim ProdCons.sim" ; +! End: ; Index: doc/papers/concurrency/examples/Refactor.py =================================================================== --- doc/papers/concurrency/examples/Refactor.py (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ doc/papers/concurrency/examples/Refactor.py (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,29 @@ +def Recursion(): + def Refactor(): + N = (yield) + print( N ); + if N == 0: + yield 0 + r = Refactor() + next( r ) + x = r.send( N - 1 ) + print( x ); + yield x + + N = (yield) + print( N ); + r = Refactor() + next( r ) + print( r.send( N - 1 ) ) + +c = Recursion() +next( c ) +try: + c.send( 5 ) +except StopIteration: + print( "stop" ) + +# Local Variables: # +# tab-width: 4 # +# compile-command: "python3.5 Refactor.py" # +# End: # Index: doc/papers/concurrency/examples/counter.cpp =================================================================== --- doc/papers/concurrency/examples/counter.cpp (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ doc/papers/concurrency/examples/counter.cpp (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,62 @@ +#include +#include + +struct counter_cor { + struct promise_type { + counter_cor get_return_object() { + return counter_cor(std::experimental::coroutine_handle::from_promise(*this)); + } + + auto initial_suspend() { return std::experimental::suspend_never(); } + auto final_suspend() { return std::experimental::suspend_never(); } + + void return_void() {} + + void unhandled_exception() {} + }; + + std::experimental::coroutine_handle _coroutine = nullptr; + + explicit counter_cor(std::experimental::coroutine_handle coroutine) + : _coroutine(coroutine) + {} + + ~counter_cor() { + if(_coroutine) { _coroutine.destroy(); } + } + + counter_cor() = default; + counter_cor(counter_cor const &) = delete; + counter_cor& operator=(counter_cor const &) = delete; + + counter_cor(counter_cor&& other) { + std::swap(_coroutine, other._coroutine); + } + + counter_cor& operator=(counter_cor&& other) { + if(&other != this) { + _coroutine = other._coroutine; + other._coroutine = nullptr; + } + return *this; + } + + void resume() { _coroutine.resume(); } +}; + +counter_cor counter() { + std::cout << "Counter: called\n"; + for(unsigned i = 1;; i++) { + co_await std::experimental::suspend_always{}; + std::cout << "Counter: Resumed " << i << " time(s)\n"; + } +} + +int main() { + std::cout << "Main: calling counter\n"; + auto c = counter(); + std::cout << "Main: resumes\n"; + c.resume(); + c.resume(); + std::cout << "Main: done\n"; +} Index: doc/proposals/interned_string.cc =================================================================== --- doc/proposals/interned_string.cc (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ doc/proposals/interned_string.cc (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,8 @@ +// Copyright (c) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in +// the file "LICENCE" distributed with this repository. + +#include "interned_string.h" + +std::unordered_set< std::string > interned_string::canonical; Index: doc/proposals/interned_string.h =================================================================== --- doc/proposals/interned_string.h (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ doc/proposals/interned_string.h (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,57 @@ +#pragma once + +// Copyright (c) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in +// the file "LICENCE" distributed with this repository. + +#include +#include +#include +#include + +/// Keeps canonical copies of a std::string for quicker comparisons +class interned_string { + /// Shared map of canonical string representations + static std::unordered_set< std::string > canonical; + + /// Canonical representation of empty string + static const std::string* empty_string() { + static const std::string* mt = [](){ + return &*canonical.emplace( "" ).first; + }(); + return mt; + } + + /// Canonicalize string + template + static const std::string* intern( S&& s ) { + return &*canonical.emplace( std::forward(s) ).first; + } + + /// Pointer to stored string + const std::string* s; + +public: + interned_string() : s{empty_string()} {} + interned_string(const char* cs) : s{intern(cs)} {} + interned_string(const std::string& ss) : s{intern(ss)} {} + + operator const std::string& () const { return *s; } + + bool operator== (const interned_string& o) const { return s == o.s; } + bool operator!= (const interned_string& o) const { return s != o.s; } + bool operator< (const interned_string& o) const { return *s < *o.s; } +}; + +inline std::ostream& operator<< (std::ostream& out, const interned_string& s) { + return out << (const std::string&)s; +} + +namespace std { + template<> struct hash { + std::size_t operator() (const interned_string& s) const { + return std::hash{}( &(const std::string&)s ); + } + }; +} Index: doc/proposals/specialized_casts.md =================================================================== --- doc/proposals/specialized_casts.md (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ doc/proposals/specialized_casts.md (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,32 @@ +## Specialized Casts ## + +There is some use in Cforall for cast operators with semantics other than the standard C cast. To make these alternate casts look like the familiar C cast, this proposal follows the example of the virtual proposal's virtual cast `(virtual Foo)x` and uses an added (pseudo-)keyword inside the cast parens. + +### C (Conversion) Cast ### +The standard C cast performs _conversions_, transformations between types which may make a new object with a different in-memory representation. Cforall maintains these semantics in a backward-compatible way while accounting for name overloading by choosing the lowest-cost interpretation of the argument expression which is convertable to the target type, breaking ties by conversion cost. + +The C cast must be maintained for backward-compatibility, and developing a second cast operator with identical semantics seems an undesirable multiplication of language features, but `(convert Foo)` or `(to Foo)` would be reasonable options for a keyword. An alternate semantics for a Cforall-specific conversion cast would be to choose the cast interpretation with the lowest sum of conversion cost and interpretation cost, which aligns better with Cforall function call resolution algorithm. + +### Ascription Cast ### +Using casts in Cforall for type _ascription_ ("select the interpretation of this type") works by the conversion-cost tiebreaker behaviour of the cast operator. However, the ascription interpretation of casts is prioritized less than the conversion interpretation of casts, sometimes resulting in some surprising results, as in the following example: + + int f(int); // f1 + int f(double); // f2 + int g(int); // g1 + double g(long); // g2 + + f((double)42); // selects f2 by cast on argument + (double)g(42); // does NOT select g2, argument conversion cost results in g1 + +An ascription cast which reversed the priorities of the C cast would be useful for selecting expressions based on their return type; a reversal of the priorities of the standard C cast would work for this (that is, select the lowest-cost conversion, breaking ties based on argument cost). A plausible stricter semantics would be to select the cheapest interpretation with a zero-cost conversion to the target type, reporting a compiler error otherwise (this semantics would make ascription a solely compile-time phenomenon, rather than relying on possible runtime conversions). A resonable keyword would be `(as Foo)`, which is short, evocative, and echos "ascription"; `(return Foo)` would not introduce new keywords, and speaks to its use in return-type selection, as in the following corrected version of the example above: + + (as double)g(42); // selects g2, as expected (under either presented ascription semantics) + +### Coercion Cast ### +Some of the explict conversions in C are defined to be a _coercions_ (reinterpret the bits of this value as another type). Use of coercions often relies on non-standard implementation details of the provided environment, and as such is discouraged, but is sometimes necessary. Since all explicit pointer casts in C are coercions, any lvalue `x` in C/Cforall can be coerced with the pattern `*(Foo*)&x`, but this is complex and doesn't extend to rvalues. A dedicated coercion cast would solve these issues; `(reinterpret Foo)` (from C++), `(transmute Foo)` (from Rust), or `(coerce Foo)` would be reasonable keywords. + +### Qualifier Cast ### +A more restricted (and thus safer) form of coercion is modifiying the qualifiers of a type; C++ has `const_cast` for this purpose, and a similar feature would be useful for Cforall. With regard to syntax, `(requalify const Foo)`/`(requalify Foo)` to add/strip `const` would echo C++, but given that the vast majority of uses are stripping const-qualfiers, `(non const)` would be shorter, clearer, easily searchable, and not require the programmer to exactly match the argument type. In this syntax, coercion casts could be used to add qualifiers, or another cast type (say `(with const)`) could be introduced to add qualfiers. + +### Virtual Cast ### +_see virtual.txt; semantics equivalent to C++ dynamic cast_ Index: doc/proposals/vtable.md =================================================================== --- doc/proposals/vtable.md (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ doc/proposals/vtable.md (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -11,4 +11,9 @@ should be able to store anything that goes into a trait. +I also include notes on a sample implementation, which primarly exists to show +there is a resonable implementation. The code samples for that are in a slight +psudo-code to help avoid name mangling and keeps some CFA features while they +would actually be writen in C. + Trait Instances --------------- @@ -42,12 +47,120 @@ before. -Internally a trait object is a pair of pointers. One to an underlying object -and the other to the vtable. All calls on an trait are implemented by looking -up the matching function pointer and passing the underlying object and the -remaining arguments to it. - -Trait objects can be moved by moving the pointers. Almost all other operations -require some functions to be implemented on the underlying type. Depending on -what is in the virtual table a trait type could be a dtype or otype. +For traits to be used this way they should meet two requirements. First they +should only have a single polymorphic type and each assertion should use that +type once as a parameter. Extentions may later loosen these requirements. + +If a trait object is used it should generate a series of implicate functions +each of which implements one of the functions required by the trait. So for +combiner there is an implicate: + + void combine(trait combiner & this, int); + +This function is the one actually called at the end + +The main use case for trait objects is that they can be stored. They can be +passed into functions, but using the trait directly is prefred in this case. + + trait drawable(otype T) { + void draw(Surface & to, T & draw); + Rect(int) drawArea(T & draw); + }; + + struct UpdatingSurface { + Surface * surface; + vector(trait drawable) drawables; + }; + + void updateSurface(UpdatingSurface & us) { + for (size_t i = 0 ; i < us.drawables.size ; ++i) { + draw(us.surface, us.drawables[i]); + } + } + +Currently these traits are limited to 1 trait parameter and functions should +have exactly 1 parameter. We cannot abstract away pairs of types and still +pass them into normal functions, which take them seperately. + +The second is required the because we need to get the vtable from somewhere. +If there are 0 trait objects than no vtable is avalible, if we have more than +1 than the vtables give conflicting answers on what underlying function to +call. And even then the underlying type assumes a concrete type. + +This loop can sort of be broken by using the trait object directly in the +signature. This has well defined meaning, but might not be useful. + + trait example(otype T) { + bool test(T & this, trait example & that); + } + +#### Sample Implementation +A simple way to implement trait objects is by a pair of pointers. One to the +underlying object and one to the vtable. + + struct vtable_drawable { + void (*draw)(Surface &, void *); + Rect(int) (*drawArea)(void *); + }; + + struct drawable { + void * object; + vtable_drawable * vtable; + }; + +The functions that run on the trait object would generally be generated using +the following pattern: + + void draw(Surface & surface, drawable & traitObj) { + return traitObj.vtable->draw(surface, traitObj.object); + } + +There may have to be special cases for things like copy construction, that +might require a more sigificant wrapper. On the other hand moving could be +implemented by moving the pointers without any need to refer to the base +object. + +### Extention: Multiple Trait Parameters +Currently, this gives traits two independent uses. They use the same syntax, +except for limits boxable traits have, and yet don't really mix. The most +natural way to do this is to allow trait instances to pick one parameter +that they are generic over, the others they choose types to implement. + +The two ways to do the selection, the first is do it at the trait definition. +Each trait picks out a single parameter which it can box (here the `virtual` +qualifier). When you create an instance of a trait object you provide +arguments like for a generic structure, but skip over the marked parameter. + + trait combiner(virtual otype T, otype Combined) { + void combine(T &, Combined &); + } + + trait combiner(int) int_combiner; + +The second is to do it at the instaniation point. A placeholder (here the +keyword `virtual`) is used to explicately skip over the parameter that will be +abstracted away, with the same rules as above if it was the marked parameter. + + trait combiner(otype T, otype Combined) { + void combine(T &, Combined &); + }; + + trait combiner(virtual, int) int_combiner; + +Using both (first to set the default, second as a local override) would also +work, although might be exessively complicated. + +This is useful in cases where you want to use a generic type, but leave part +of it open and store partially generic result. As a simple example + + trait folder(otype T, otype In, otype Out) { + void fold(T & this, In); + Out fold_result(T & this); + } + +Which allows you to fold values without putting them in a container. If they +are already in a container this is exessive, but if they are generated over +time this gives you a simple interface. This could for instance be used in +a profile, where T changes for each profiling statistic and you can plug in +multiple profilers for any run by adding them to an array. Hierarchy @@ -90,19 +203,130 @@ the pointer to it. +Exception Example: +(Also I'm not sure where I got these casing rules.) + + trait exception(otype T) virtual() { + char const * what(T & this); + } + + trait io_error(otype T) virtual(exception) { + FILE * which_file(T & this); + } + + struct eof_error(otype T) virtual(io_error) { + FILE * file; + } + + char const * what(eof_error &) { + return "Tried to read from an empty file."; + } + + FILE * which_file(eof_error & this) { + return eof_error.file; + } + +Ast Example: + + trait ast_node(otype T) virtual() { + void print(T & this, ostream & out); + void visit(T & this, Visitor & visitor); + CodeLocation const & get_code_location(T & this); + } + + trait expression_node(otype T) virtual(ast_node) { + Type eval_type(T const & this); + } + + struct operator_expression virtual(expression_node) { + enum operator_kind kind; + trait expression_node rands[2]; + } + + trait statement_node(otype T) virtual(ast_node) { + vector(Label) & get_labels(T & this); + } + + struct goto_statement virtual(statement_node) { + vector(Label) labels; + Label target; + } + + trait declaration_node(otype T) virtual(ast_node) { + string name_of(T const & this); + Type type_of(T const & this); + } + + struct using_declaration virtual(declaration_node) { + string new_type; + Type old_type; + } + + struct variable_declaration virtual(declaration_node) { + string name; + Type type; + } + +#### Sample Implementation +The type id may be as little as: + + struct typeid { + struct typeid const * const parent; + }; + +Some linker magic would have to be used to ensure exactly one copy of each +structure for each type exists in memory. There seem to be spectial once +sections that support this and it should be easier than generating unique +ids across compilation units. + +The structure could be extended to contain any additional type information. + +There are two general designs for vtables with type ids. The first is to put +the type id at the top of the vtable, this is the most compact and efficient +solution but only works if we have exactly 1 vtable for each type. The second +is to put a pointer to the type id in each vtable. This has more overhead but +allows multiple vtables. + + struct _vtable { + struct typeid const id; + + // Trait dependent list of vtable members. + }; + + struct _vtable { + struct typeid const * const id; + + // Trait dependent list of vtable members. + }; + +### Virtual Casts +To convert from a pointer to a type higher on the hierarchy to one lower on +the hierarchy a check is used to make sure that the underlying type is also +of that lower type. + +The proposed syntax for this is: + + trait SubType * new_value = (virtual trait SubType *)super_type; + +It will return the same pointer if it does point to the subtype and null if +it does not, doing the check and conversion in one operation. + ### Inline vtables Since the structures here are usually made to be turned into trait objects it might be worth it to have fields on them to store the virtual table -pointer. This would have to be declared on the trait as an assertion, but if -it is the trait object could be a single pointer. - -It is trivial to do if the field with the virtual table pointer is fixed. -Otherwise some trickery with pointing to the field and storing the offset in -the virtual table to recover the main object would have to be used. +pointer. This would have to be declared on the trait as an assertion (example: +`vtable;` or `T.vtable;`), but if it is the trait object could be a single +pointer. + +There are also three options for where the pointer to the vtable. It could be +anywhere, a fixed location for each trait or always at the front. For the per- +trait solution an extention to specify what it is (example `vtable[0];`) which +could also be used to combine it with others. So these options can be combined +to allow access to all three options. ### Virtual Tables as Types -Here we consider encoding plus the implementation of functions on it. Which -is to say in the type hierarchy structures aren't concrete types anymore, -instead they are parent types to vtables, which combine the encoding and -implementation. +Here we consider encoding plus the implementation of functions on it to be a +type. Which is to say in the type hierarchy structures aren't concrete types +anymore, instead they are parent types to vtables, which combine the encoding +and implementation. Resolution Scope @@ -123,6 +347,18 @@ other. -Some syntax would have to be added. All resolutions can be found at compile -time and a single vtable created for each type at compilation time. +Some syntax would have to be added to specify the resolution point. To ensure +a single instance there may have to be two variants, one forward declaration +and one to create the instance. With some compiler magic the forward +declaration maybe enough. + + extern trait combiner(struct summation) vtable; + trait combiner(struct summation) vtable; + +Or (with the same variants): + + vtable combiner(struct summation); + +The extern variant promises that the vtable will exist while the normal one +is where the resolution actually happens. ### Explicit Resolution Points: @@ -141,4 +377,26 @@ vtable. + extern trait combiner(struct summation) vtable sum; + trait combiner(struct summation) vtable sum; + + extern trait combiner(struct summation) vtable sum default; + trait combiner(struct summation) vtable sum default; + +The extern difference is the same before. The name (sum in the samples) is +used at the binding site to say which one is picked. The default keyword can +be used in only some of the declarations. + + trait combiner fee = (summation_instance, sum); + trait combiner foe = summation_instance; + +(I am not really happy about this syntax, but it kind of works.) +The object being bound is required. The name of the vtable is optional if +there is exactly one vtable name marked with default. + +These could also be placed inside functions. In which case both the name and +the default keyword might be optional. If the name is ommited in an assignment +the closest vtable is choosen (returning to the global default rule if no +approprate local vtable is in scope). + ### Site Based Resolution: Every place in code where the binding of a vtable to an object occurs has Index: doc/user/user.tex =================================================================== --- doc/user/user.tex (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ doc/user/user.tex (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -11,6 +11,6 @@ %% Created On : Wed Apr 6 14:53:29 2016 %% Last Modified By : Peter A. Buhr -%% Last Modified On : Tue Dec 11 23:19:26 2018 -%% Update Count : 3400 +%% Last Modified On : Sun Apr 14 11:02:34 2019 +%% Update Count : 3443 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @@ -508,16 +508,22 @@ As for \Index{division}, there are exponentiation operators for integral and floating types, including the builtin \Index{complex} types. -Unsigned integral exponentiation\index{exponentiation!unsigned integral} is performed with repeated multiplication\footnote{The multiplication computation is $O(\log y)$.} (or shifting if the base is 2). -Signed integral exponentiation\index{exponentiation!signed integral} is performed with repeated multiplication (or shifting if the base is 2), but yields a floating result because $x^{-y}=1/x^y$. -Hence, it is important to designate exponent integral-constants as unsigned or signed: ©3 \ 3u© return an integral result, while ©3 \ 3© returns a floating result. -Floating exponentiation\index{exponentiation!floating} is performed using \Index{logarithm}s\index{exponentiation!logarithm}, so the base cannot be negative. -\begin{cfa} -sout | 2 ®\® 8u | 4 ®\® 3u | -4 ®\® 3u | 4 ®\® -3 | -4 ®\® -3 | 4.0 ®\® 2.1 | (1.0f+2.0fi) ®\® (3.0f+2.0fi); -256 64 -64 0.015625 -0.015625 18.3791736799526 0.264715-1.1922i -\end{cfa} +Integral exponentiation\index{exponentiation!unsigned integral} is performed with repeated multiplication\footnote{The multiplication computation is $O(\log y)$.} (or shifting if the exponent is 2). +Overflow from large exponents or negative exponents return zero. +Floating exponentiation\index{exponentiation!floating} is performed using \Index{logarithm}s\index{exponentiation!logarithm}, so the exponent cannot be negative. +\begin{cfa} +sout | 1 ®\® 0 | 1 ®\® 1 | 2 ®\® 8 | -4 ®\® 3 | 5 ®\® 3 | 5 ®\® 32 | 5L ®\® 32 | 5L ®\® 64 | -4 ®\® -3 | -4.0 ®\® -3 | 4.0 ®\® 2.1 + | (1.0f+2.0fi) ®\® (3.0f+2.0fi); +1 1 256 -64 125 ®0® 3273344365508751233 ®0® ®0® -0.015625 18.3791736799526 0.264715-1.1922i +\end{cfa} +Note, ©5 ®\® 32© and ©5L ®\® 64© overflow, and ©-4 ®\® -3© is a fraction but stored in an integer so all three computations generate an integral zero. Parenthesis are necessary for complex constants or the expression is parsed as ©1.0f+®(®2.0fi \ 3.0f®)®+2.0fi©. -The exponentiation operator is available for all the basic types, but for user-defined types, only the integral-computation versions are available. -For returning an integral value, the user type ©T© must define multiplication, ©*©, and one, ©1©; -for returning a floating value, an additional divide of type ©T© into a ©double© returning a ©double© (©double ?/?( double, T )©) is necessary for negative exponents. +The exponentiation operator is available for all the basic types, but for user-defined types, only the integral-computation version is available. +\begin{cfa} +forall( otype OT | { void ?{}( OT & this, one_t ); OT ?*?( OT, OT ); } ) +OT ?®\®?( OT ep, unsigned int y ); +forall( otype OT | { void ?{}( OT & this, one_t ); OT ?*?( OT, OT ); } ) +OT ?®\®?( OT ep, unsigned long int y ); +\end{cfa} +The user type ©T© must define multiplication, one, ©1©, and, ©*©. @@ -549,72 +555,90 @@ \subsection{Loop Control} -The ©for©/©while©/©do-while© loop-control allows empty or simplified ranges. +The ©for©/©while©/©do-while© loop-control allows empty or simplified ranges (see Figure~\ref{f:LoopControlExamples}). +\begin{itemize} +\item An empty conditional implies ©1©. -The up-to range ©~©\index{~@©~©} means exclusive range [M,N); -the up-to range ©~=©\index{~=@©~=©} means inclusive range [M,N]. -The down-to range ©-~©\index{-~@©-~©} means exclusive range [N,M); -the down-to range ©-~=©\index{-~=@©-~=©} means inclusive range [N,M]. +\item +The up-to range ©~©\index{~@©~©} means exclusive range [M,N). +\item +The up-to range ©~=©\index{~=@©~=©} means inclusive range [M,N]. +\item +The down-to range ©-~©\index{-~@©-~©} means exclusive range [N,M). +\item +The down-to range ©-~=©\index{-~=@©-~=©} means inclusive range [N,M]. +\item +©@© means put nothing in this field. +\item ©0© is the implicit start value; +\item ©1© is the implicit increment value. +\item The up-to range uses ©+=© for increment; -the down-to range uses ©-=© for decrement. +\item +The down-to range uses ©-=© for decrement. +\item The loop index is polymorphic in the type of the start value or comparison value when start is implicitly ©0©. +\end{itemize} + +\begin{figure} \begin{cquote} -\begin{tabular}{@{}ll|l@{}} -\multicolumn{2}{c|}{loop control} & \multicolumn{1}{c}{output} \\ +\begin{tabular}{@{}l|l@{}} +\multicolumn{1}{c|}{loop control} & \multicolumn{1}{c}{output} \\ \hline \begin{cfa} -while ®()® { sout | "empty"; break; } -do { sout | "empty"; break; } while ®()®; -for ®()® { sout | "empty"; break; } -for ( ®0® ) { sout | "A"; } -for ( ®1® ) { sout | "A"; } -for ( ®10® ) { sout | "A"; } -for ( ®1 ~= 10 ~ 2® ) { sout | "B"; } -for ( ®10 -~= 1 ~ 2® ) { sout | "C"; } -for ( ®0.5 ~ 5.5® ) { sout | "D"; } -for ( ®5.5 -~ 0.5® ) { sout | "E"; } -for ( ®i; 10® ) { sout | i; } -for ( ®i; 1 ~= 10 ~ 2® ) { sout | i; } -for ( ®i; 10 -~= 1 ~ 2® ) { sout | i; } -for ( ®i; 0.5 ~ 5.5® ) { sout | i; } -for ( ®i; 5.5 -~ 0.5® ) { sout | i; } -for ( ®ui; 2u ~= 10u ~ 2u® ) { sout | ui; } -for ( ®ui; 10u -~= 2u ~ 2u® ) { sout | ui; } +sout | nlOff; +while ®()® { sout | "empty"; break; } sout | nl; +do { sout | "empty"; break; } while ®()®; sout | nl; +for ®()® { sout | "empty"; break; } sout | nl; +for ( ®0® ) { sout | "A"; } sout | "zero" | nl; +for ( ®1® ) { sout | "A"; } sout | nl; +for ( ®10® ) { sout | "A"; } sout | nl; +for ( ®1 ~= 10 ~ 2® ) { sout | "B"; } sout | nl; +for ( ®10 -~= 1 ~ 2® ) { sout | "C"; } sout | nl; +for ( ®0.5 ~ 5.5® ) { sout | "D"; } sout | nl; +for ( ®5.5 -~ 0.5® ) { sout | "E"; } sout | nl; +for ( ®i; 10® ) { sout | i; } sout | nl; +for ( ®i; 1 ~= 10 ~ 2® ) { sout | i; } sout | nl; +for ( ®i; 10 -~= 1 ~ 2® ) { sout | i; } sout | nl; +for ( ®i; 0.5 ~ 5.5® ) { sout | i; } sout | nl; +for ( ®i; 5.5 -~ 0.5® ) { sout | i; } sout | nl; +for ( ®ui; 2u ~= 10u ~ 2u® ) { sout | ui; } sout | nl; +for ( ®ui; 10u -~= 2u ~ 2u® ) { sout | ui; } sout | nl; enum { N = 10 }; -for ( ®N® ) { sout | "N"; } -for ( ®i; N® ) { sout | i; } -for ( ®i; N -~ 0® ) { sout | i; } +for ( ®N® ) { sout | "N"; } sout | nl; +for ( ®i; N® ) { sout | i; } sout | nl; +for ( ®i; N -~ 0® ) { sout | i; } sout | nl; const int start = 3, comp = 10, inc = 2; -for ( ®i; start ~ comp ~ inc + 1® ) { sout | i; } +for ( ®i; start ~ comp ~ inc + 1® ) { sout | i; } sout | nl; +for ( ®i; 1 ~ @® ) { if ( i > 10 ) break; + sout | i; } sout | nl; +for ( ®i; 10 -~ @® ) { if ( i < 0 ) break; + sout | i; } sout | nl; +for ( ®i; 2 ~ @ ~ 2® ) { if ( i > 10 ) break; + sout | i; } sout | nl; +for ( ®i; 2.1 ~ @ ~ @® ) { if ( i > 10.5 ) break; + sout | i; i += 1.7; } sout | nl; +for ( ®i; 10 -~ @ ~ 2® ) { if ( i < 0 ) break; + sout | i; } sout | nl; +for ( ®i; 12.1 ~ @ ~ @® ) { if ( i < 2.5 ) break; + sout | i; i -= 1.7; } sout | nl; +for ( ®i; 5 : j; -5 ~ @® ) { sout | i | j; } sout | nl; +for ( ®i; 5 : j; -5 -~ @® ) { sout | i | j; } sout | nl; +for ( ®i; 5 : j; -5 ~ @ ~ 2® ) { sout | i | j; } sout | nl; +for ( ®i; 5 : j; -5 -~ @ ~ 2® ) { sout | i | j; } sout | nl; +for ( ®j; -5 ~ @ : i; 5® ) { sout | i | j; } sout | nl; +for ( ®j; -5 -~ @ : i; 5® ) { sout | i | j; } sout | nl; +for ( ®j; -5 ~ @ ~ 2 : i; 5® ) { sout | i | j; } sout | nl; +for ( ®j; -5 -~ @ ~ 2 : i; 5® ) { sout | i | j; } sout | nl; +for ( ®j; -5 -~ @ ~ 2 : i; 5 : k; 1.5 ~ @® ) { + sout | i | j | k; } sout | nl; +for ( ®j; -5 -~ @ ~ 2 : k; 1.5 ~ @ : i; 5® ) { + sout | i | j | k; } sout | nl; +for ( ®k; 1.5 ~ @ : j; -5 -~ @ ~ 2 : i; 5® ) { + sout | i | j | k; } sout | nl; \end{cfa} & \begin{cfa} -sout | nl; -sout | nl; -sout | nl; -sout | "zero" | nl; -sout | nl; -sout | nl; -sout | nl; -sout | nl; -sout | nl; -sout | nl; -sout | nl; -sout | nl; -sout | nl; -sout | nl; -sout | nl; -sout | nl; -sout | nl | nl; - -sout | nl; -sout | nl; -sout | nl | nl; - -sout | nl; -\end{cfa} -& -\begin{cfa} + empty empty @@ -640,7 +664,36 @@ 3 6 9 + +1 2 3 4 5 6 7 8 9 10 + +10 9 8 7 6 5 4 3 2 1 0 + +2 4 6 8 10 + +2.1 3.8 5.5 7.2 8.9 + +10 8 6 4 2 0 + +12.1 10.4 8.7 7 5.3 3.6 +0 -5 1 -4 2 -3 3 -2 4 -1 +0 -5 1 -6 2 -7 3 -8 4 -9 +0 -5 1 -3 2 -1 3 1 4 3 +0 -5 1 -7 2 -9 3 -11 4 -13 +0 -5 1 -4 2 -3 3 -2 4 -1 +0 -5 1 -6 2 -7 3 -8 4 -9 +0 -5 1 -3 2 -1 3 1 4 3 +0 -5 1 -7 2 -9 3 -11 4 -13 + +0 -5 1.5 1 -7 2.5 2 -9 3.5 3 -11 4.5 4 -13 5.5 + +0 -5 1.5 1 -7 2.5 2 -9 3.5 3 -11 4.5 4 -13 5.5 + +0 -5 1.5 1 -7 2.5 2 -9 3.5 3 -11 4.5 4 -13 5.5 \end{cfa} \end{tabular} \end{cquote} +\caption{Loop Control Examples} +\label{f:LoopControlExamples} +\end{figure} @@ -1320,5 +1373,8 @@ \end{cfa} Essentially, the return type is wrapped around the routine name in successive layers (like an \Index{onion}). -While attempting to make the two contexts consistent is a laudable goal, it has not worked out in practice. +While attempting to make the two contexts consistent is a laudable goal, it has not worked out in practice, even though Dennis Richie believed otherwise: +\begin{quote} +In spite of its difficulties, I believe that the C's approach to declarations remains plausible, and am comfortable with it; it is a useful unifying principle.~\cite[p.~12]{Ritchie93} +\end{quote} \CFA provides its own type, variable and routine declarations, using a different syntax. Index: libcfa/configure =================================================================== --- libcfa/configure (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ libcfa/configure (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -2977,4 +2977,6 @@ ;; esac + +CONFIG_CFAFLAGS="${CONFIG_CFAFLAGS} ${CFAFLAGS}" Index: libcfa/configure.ac =================================================================== --- libcfa/configure.ac (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ libcfa/configure.ac (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -64,4 +64,6 @@ esac +CONFIG_CFAFLAGS="${CONFIG_CFAFLAGS} ${CFAFLAGS}" + AC_SUBST(CONFIG_CFLAGS) AC_SUBST(CONFIG_CFAFLAGS) Index: libcfa/prelude/builtins.c =================================================================== --- libcfa/prelude/builtins.c (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ libcfa/prelude/builtins.c (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -10,6 +10,6 @@ // Created On : Fri Jul 21 16:21:03 2017 // Last Modified By : Peter A. Buhr -// Last Modified On : Sun Mar 10 10:52:50 2019 -// Update Count : 31 +// Last Modified On : Tue Mar 26 23:10:36 2019 +// Update Count : 95 // @@ -18,4 +18,5 @@ typedef unsigned long long __cfaabi_abi_exception_type_t; +#include // CHAR_BIT #include "../src/virtual.h" #include "../src/exception.h" @@ -26,19 +27,21 @@ // increment/decrement unification -static inline forall( dtype T | { T & ?+=?( T &, one_t ); } ) -T & ++? ( T & x ) { return x += 1; } +static inline { + forall( dtype DT | { DT & ?+=?( DT &, one_t ); } ) + DT & ++?( DT & x ) { return x += 1; } -static inline forall( dtype T | sized(T) | { void ?{}( T &, T ); void ^?{}( T & ); T & ?+=?( T &, one_t ); } ) -T & ?++ ( T & x ) { T tmp = x; x += 1; return tmp; } + forall( dtype DT | sized(DT) | { void ?{}( DT &, DT ); void ^?{}( DT & ); DT & ?+=?( DT &, one_t ); } ) + DT & ?++( DT & x ) { DT tmp = x; x += 1; return tmp; } -static inline forall( dtype T | { T & ?-=?( T &, one_t ); } ) -T & --? ( T & x ) { return x -= 1; } + forall( dtype DT | { DT & ?-=?( DT &, one_t ); } ) + DT & --?( DT & x ) { return x -= 1; } -static inline forall( dtype T | sized(T) | { void ?{}( T &, T ); void ^?{}( T & ); T & ?-=?( T &, one_t ); } ) -T & ?-- ( T & x ) { T tmp = x; x -= 1; return tmp; } + forall( dtype DT | sized(DT) | { void ?{}( DT &, DT ); void ^?{}( DT & ); DT & ?-=?( DT &, one_t ); } ) + DT & ?--( DT & x ) { DT tmp = x; x -= 1; return tmp; } +} // distribution // universal typed pointer constant - -static inline forall( dtype T ) T * intptr( uintptr_t addr ) { return (T *)addr; } +// Compiler issue: there is a problem with anonymous types that do not have a size. +static inline forall( dtype DT | sized(DT) ) DT * intptr( uintptr_t addr ) { return (DT *)addr; } // exponentiation operator implementation @@ -53,65 +56,59 @@ } // extern "C" -static inline float ?\?( float x, float y ) { return powf( x, y ); } -static inline double ?\?( double x, double y ) { return pow( x, y ); } -static inline long double ?\?( long double x, long double y ) { return powl( x, y ); } -static inline float _Complex ?\?( float _Complex x, _Complex float y ) { return cpowf(x, y ); } -static inline double _Complex ?\?( double _Complex x, _Complex double y ) { return cpow( x, y ); } -static inline long double _Complex ?\?( long double _Complex x, _Complex long double y ) { return cpowl( x, y ); } +static inline { + float ?\?( float x, float y ) { return powf( x, y ); } + double ?\?( double x, double y ) { return pow( x, y ); } + long double ?\?( long double x, long double y ) { return powl( x, y ); } + float _Complex ?\?( float _Complex x, _Complex float y ) { return cpowf(x, y ); } + double _Complex ?\?( double _Complex x, _Complex double y ) { return cpow( x, y ); } + long double _Complex ?\?( long double _Complex x, _Complex long double y ) { return cpowl( x, y ); } +} // distribution -static inline long int ?\?( long int ep, unsigned long int y ) { // disallow negative exponent - if ( y == 0 ) return 1; // base case - if ( ep == 2 ) return ep << (y - 1); // special case, positive shifting only - typeof( ep ) op = 1; // accumulate odd product - for ( ; y > 1; y >>= 1 ) { // squaring exponentiation, O(log2 y) - if ( (y & 1) == 1 ) op *= ep; // odd ? - ep *= ep; - } // for - return ep * op; -} // ?\? +#define __CFA_BASE_COMP_1__() if ( ep == 1 ) return 1 +#define __CFA_BASE_COMP_2__() if ( ep == 2 ) return ep << (y - 1) +#define __CFA_EXP_OVERFLOW__() if ( y >= sizeof(y) * CHAR_BIT ) return 0 -static inline forall( otype T | { void ?{}( T & this, one_t ); T ?*?( T, T ); } ) -T ?\?( T ep, unsigned long int y ) { - if ( y == 0 ) return 1; - T op = 1; - for ( ; y > 1; y >>= 1 ) { // squaring exponentiation, O(log2 y) - if ( (y & 1) == 1 ) op = op * ep; // odd ? - ep = ep * ep; - } // for - return ep * op; -} // ?\? +#define __CFA_EXP__() \ + if ( y == 0 ) return 1; /* convention */ \ + __CFA_BASE_COMP_1__(); /* base case */ \ + __CFA_BASE_COMP_2__(); /* special case, positive shifting for integral types */ \ + __CFA_EXP_OVERFLOW__(); /* immediate overflow, negative exponent > 2^size-1 */ \ + typeof(ep) op = 1; /* accumulate odd product */ \ + for ( ; y > 1; y >>= 1 ) { /* squaring exponentiation, O(log2 y) */ \ + if ( (y & 1) == 1 ) op = op * ep; /* odd ? */ \ + ep = ep * ep; \ + } \ + return ep * op -// unsigned computation may be faster and larger -static inline unsigned long int ?\?( unsigned long int ep, unsigned long int y ) { // disallow negative exponent - if ( y == 0 ) return 1; // base case - if ( ep == 2 ) return ep << (y - 1); // special case, positive shifting only - typeof( ep ) op = 1; // accumulate odd product - for ( ; y > 1; y >>= 1 ) { // squaring exponentiation, O(log2 y) - if ( (y & 1) == 1 ) op *= ep; // odd ? - ep *= ep; - } // for - return ep * op; -} // ?\? +static inline { + long int ?\?( int ep, unsigned int y ) { __CFA_EXP__(); } + long int ?\?( long int ep, unsigned long int y ) { __CFA_EXP__(); } + // unsigned computation may be faster and larger + unsigned long int ?\?( unsigned int ep, unsigned int y ) { __CFA_EXP__(); } + unsigned long int ?\?( unsigned long int ep, unsigned long int y ) { __CFA_EXP__(); } +} // distribution -static inline double ?\?( long int x, signed long int y ) { // allow negative exponent - if ( y >= 0 ) return (double)(x \ (unsigned long int)y); - else return 1.0 / x \ (unsigned int)(-y); -} // ?\? +#undef __CFA_BASE_COMP_1__ +#undef __CFA_BASE_COMP_2__ +#undef __CFA_EXP_OVERFLOW__ +#define __CFA_BASE_COMP_1__() +#define __CFA_BASE_COMP_2__() +#define __CFA_EXP_OVERFLOW__() -// FIXME (x \ (unsigned long int)y) relies on X ?\?(T, unsigned long) a function that is neither -// defined, nor passed as an assertion parameter. Without user-defined conversions, cannot specify -// X as a type that casts to double, yet it doesn't make sense to write functions with that type -// signature where X is double. +static inline forall( otype OT | { void ?{}( OT & this, one_t ); OT ?*?( OT, OT ); } ) { + OT ?\?( OT ep, unsigned int y ) { __CFA_EXP__(); } + OT ?\?( OT ep, unsigned long int y ) { __CFA_EXP__(); } +} // distribution -// static inline forall( otype T | { void ?{}( T & this, one_t ); T ?*?( T, T ); double ?/?( double, T ); } ) -// double ?\?( T x, signed long int y ) { -// if ( y >= 0 ) return (double)(x \ (unsigned long int)y); -// else return 1.0 / x \ (unsigned long int)(-y); -// } // ?\? +#undef __CFA_BASE_COMP_1__ +#undef __CFA_BASE_COMP_2__ +#undef __CFA_EXP_OVERFLOW__ -static inline long int ?\=?( long int & x, unsigned long int y ) { x = x \ y; return x; } -static inline unsigned long int ?\=?( unsigned long int & x, unsigned long int y ) { x = x \ y; return x; } -static inline int ?\=?( int & x, unsigned long int y ) { x = x \ y; return x; } -static inline unsigned int ?\=?( unsigned int & x, unsigned long int y ) { x = x \ y; return x; } +static inline { + long int ?\=?( long int & x, unsigned long int y ) { x = x \ y; return x; } + unsigned long int ?\=?( unsigned long int & x, unsigned long int y ) { x = x \ y; return x; } + int ?\=?( int & x, unsigned long int y ) { x = x \ y; return x; } + unsigned int ?\=?( unsigned int & x, unsigned long int y ) { x = x \ y; return x; } +} // distribution // Local Variables: // Index: libcfa/prelude/prelude-gen.cc =================================================================== --- libcfa/prelude/prelude-gen.cc (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ libcfa/prelude/prelude-gen.cc (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -10,6 +10,6 @@ // Created On : Sat Feb 16 08:44:58 2019 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Mar 8 16:00:22 2019 -// Update Count : 26 +// Last Modified On : Tue Apr 2 17:18:24 2019 +// Update Count : 37 // @@ -118,5 +118,6 @@ { "?!=?", false, "signed int", Normal, "" }, { "?=?", true, "", Normal, "" }, // void * LHS, zero_t RHS ??? - { "*?", false, "&", Normal, " | sized(DT)" }, // & ??? +// { "*?", false, "&", Normal, " | sized(DT)" }, // & ??? + { "*?", false, "&", Normal, "" }, // & ??? { "?-?", false, "ptrdiff_t", Normal, " | sized(DT)" }, @@ -208,7 +209,7 @@ cout << "void ?{} (" << type << " &);" << endl; cout << "void ?{} (" << type << " &, " << type << ");" << endl; - cout << type << " ?=? (" << type << " &, " << type << ")"; + cout << type << " ?=? (" << type << " &, " << type << ")"; if ( do_volatile ) { - cout << ", ?=?(volatile " << type << " &, " << type << ")"; + cout << ", ?=?(volatile " << type << " &, " << type << ")"; } cout << ";" << endl; @@ -217,5 +218,7 @@ otype("zero_t"); + cout << endl; otype("one_t"); + cout << endl; otype("_Bool", true); cout << endl; @@ -225,4 +228,5 @@ cout << "void ?{}(" << type.name << " &, " << type.name << ");" << endl; cout << "void ?{}(" << type.name << " &, zero_t);" << endl; + cout << "void ?{}(" << type.name << " &, one_t);" << endl; cout << "void ^?{}(" << type.name << " &);" << endl; cout << endl; Index: libcfa/src/Makefile.am =================================================================== --- libcfa/src/Makefile.am (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ libcfa/src/Makefile.am (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -74,9 +74,9 @@ prelude.o : prelude.cfa extras.cf gcc-builtins.cf builtins.cf @CFACC@ @CFACPP@ - ${AM_V_GEN}@CFACC@ ${AM_CFLAGS} ${CFLAGS} -quiet -in-tree @CONFIG_CFAFLAGS@ -XCFA -l ${<} -c -o ${@} + ${AM_V_GEN}$(CFACOMPILE) -quiet -in-tree -XCFA -l ${<} -c -o ${@} prelude.lo: prelude.cfa extras.cf gcc-builtins.cf builtins.cf @CFACC@ @CFACPP@ ${AM_V_GEN}$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile \ - @CFACC@ ${AM_CFLAGS} ${CFLAGS} -quiet -in-tree @CONFIG_CFAFLAGS@ -XCFA -l ${<} -c -o ${@} + $(CFACOMPILE) -quiet -in-tree -XCFA -l ${<} -c -o ${@} Index: libcfa/src/Makefile.in =================================================================== --- libcfa/src/Makefile.in (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ libcfa/src/Makefile.in (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -926,9 +926,9 @@ prelude.o : prelude.cfa extras.cf gcc-builtins.cf builtins.cf @CFACC@ @CFACPP@ - ${AM_V_GEN}@CFACC@ ${AM_CFLAGS} ${CFLAGS} -quiet -in-tree @CONFIG_CFAFLAGS@ -XCFA -l ${<} -c -o ${@} + ${AM_V_GEN}$(CFACOMPILE) -quiet -in-tree -XCFA -l ${<} -c -o ${@} prelude.lo: prelude.cfa extras.cf gcc-builtins.cf builtins.cf @CFACC@ @CFACPP@ ${AM_V_GEN}$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile \ - @CFACC@ ${AM_CFLAGS} ${CFLAGS} -quiet -in-tree @CONFIG_CFAFLAGS@ -XCFA -l ${<} -c -o ${@} + $(CFACOMPILE) -quiet -in-tree -XCFA -l ${<} -c -o ${@} #---------------------------------------------------------------------------------------------------------------- Index: libcfa/src/concurrency/CtxSwitch-x86_64.S =================================================================== --- libcfa/src/concurrency/CtxSwitch-x86_64.S (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ libcfa/src/concurrency/CtxSwitch-x86_64.S (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -88,4 +88,59 @@ ret +//.text +// .align 2 +//.globl CtxStore +//CtxStore: +// // Save floating & SSE control words on the stack. +// +// subq $8,%rsp +// stmxcsr 0(%rsp) // 4 bytes +// fnstcw 4(%rsp) // 2 bytes +// +// // Save volatile registers on the stack. +// +// pushq %r15 +// pushq %r14 +// pushq %r13 +// pushq %r12 +// pushq %rbx +// +// // Save old context in the "from" area. +// +// movq %rsp,SP_OFFSET(%rdi) +// movq %rbp,FP_OFFSET(%rdi) +// +// // Return to thread +// +// ret +// +//.text +// .align 2 +//.globl CtxRet +//CtxRet: +// // Load new context from the "to" area. +// +// movq SP_OFFSET(%rdi),%rsp +// movq FP_OFFSET(%rdi),%rbp +// +// // Load volatile registers from the stack. +// +// popq %rbx +// popq %r12 +// popq %r13 +// popq %r14 +// popq %r15 +// +// // Load floating & SSE control words from the stack. +// +// fldcw 4(%rsp) +// ldmxcsr 0(%rsp) +// addq $8,%rsp +// +// // Return to thread. +// +// ret + + .text .align 2 Index: libcfa/src/concurrency/coroutine.cfa =================================================================== --- libcfa/src/concurrency/coroutine.cfa (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ libcfa/src/concurrency/coroutine.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -35,5 +35,5 @@ extern "C" { - void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage) __attribute__ ((__noreturn__)); + void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct coroutine_desc *) __attribute__ ((__noreturn__)); static void _CtxCoroutine_UnwindCleanup(_Unwind_Reason_Code, struct _Unwind_Exception *) __attribute__ ((__noreturn__)); static void _CtxCoroutine_UnwindCleanup(_Unwind_Reason_Code, struct _Unwind_Exception *) { @@ -84,5 +84,5 @@ void ^?{}(coroutine_desc& this) { if(this.state != Halted && this.state != Start) { - coroutine_desc * src = TL_GET( this_coroutine ); + coroutine_desc * src = TL_GET( this_thread )->curr_cor; coroutine_desc * dst = &this; @@ -115,5 +115,6 @@ // Wrapper for co void CoroutineCtxSwitch(coroutine_desc* src, coroutine_desc* dst) { - // Safety note : This could cause some false positives due to preemption + // Safety note : Preemption must be disabled since there is a race condition + // kernelTLS.this_thread->curr_cor and $rsp/$rbp must agree at all times verify( TL_GET( preemption_state.enabled ) || TL_GET( this_processor )->do_terminate ); disable_interrupts(); @@ -123,5 +124,5 @@ // set new coroutine that task is executing - kernelTLS.this_coroutine = dst; + TL_GET( this_thread )->curr_cor = dst; // context switch to specified coroutine @@ -134,9 +135,9 @@ enable_interrupts( __cfaabi_dbg_ctx ); - // Safety note : This could cause some false positives due to preemption verify( TL_GET( preemption_state.enabled ) || TL_GET( this_processor )->do_terminate ); + if( unlikely(src->cancellation != NULL) ) { - _CtxCoroutine_Unwind(src->cancellation); + _CtxCoroutine_Unwind(src->cancellation, src); } } //ctxSwitchDirect @@ -197,6 +198,5 @@ } - void __leave_coroutine() { - coroutine_desc * src = TL_GET( this_coroutine ); // optimization + void __leave_coroutine( coroutine_desc * src ) { coroutine_desc * starter = src->cancellation != 0 ? src->last : src->starter; Index: libcfa/src/concurrency/coroutine.hfa =================================================================== --- libcfa/src/concurrency/coroutine.hfa (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ libcfa/src/concurrency/coroutine.hfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -46,5 +46,5 @@ //----------------------------------------------------------------------------- // Public coroutine API -static inline void suspend(); +static inline void suspend(void); forall(dtype T | is_coroutine(T)) @@ -71,5 +71,5 @@ // Suspend implementation inlined for performance -static inline void suspend() { +static inline void suspend(void) { // optimization : read TLS once and reuse it // Safety note: this is preemption safe since if @@ -77,5 +77,5 @@ // will also migrate which means this value will // stay in syn with the TLS - coroutine_desc * src = TL_GET( this_coroutine ); + coroutine_desc * src = TL_GET( this_thread )->curr_cor; assertf( src->last != 0, @@ -99,5 +99,5 @@ // will also migrate which means this value will // stay in syn with the TLS - coroutine_desc * src = TL_GET( this_coroutine ); + coroutine_desc * src = TL_GET( this_thread )->curr_cor; coroutine_desc * dst = get_coroutine(cor); @@ -129,5 +129,5 @@ // will also migrate which means this value will // stay in syn with the TLS - coroutine_desc * src = TL_GET( this_coroutine ); + coroutine_desc * src = TL_GET( this_thread )->curr_cor; // not resuming self ? @@ -146,4 +146,70 @@ } + + +// static inline bool suspend_checkpoint(void) { +// // optimization : read TLS once and reuse it +// // Safety note: this is preemption safe since if +// // preemption occurs after this line, the pointer +// // will also migrate which means this value will +// // stay in syn with the TLS +// // set state of current coroutine to inactive +// this->state = Checkpoint; + +// // context switch to specified coroutine +// assert( src->stack.context ); + +// CtxStore(src->stack.context); + +// bool ret = this->state == Checkpoint; + +// // set state of new coroutine to active +// src->state = Active; + +// enable_interrupts( __cfaabi_dbg_ctx ); +// // Safety note : This could cause some false positives due to preemption +// verify( TL_GET( preemption_state.enabled ) || TL_GET( this_processor )->do_terminate ); + +// if( unlikely(src->cancellation != NULL) ) { +// _CtxCoroutine_Unwind(src->cancellation); +// } + +// return ret; +// } + +// static inline void suspend_return(void) { +// // optimization : read TLS once and reuse it +// // Safety note: this is preemption safe since if +// // preemption occurs after this line, the pointer +// // will also migrate which means this value will +// // stay in syn with the TLS +// coroutine_desc * src = TL_GET( this_thread )->curr_cor; + +// assertf( src->last != 0, +// "Attempt to suspend coroutine \"%.256s\" (%p) that has never been resumed.\n" +// "Possible cause is a suspend executed in a member called by a coroutine user rather than by the coroutine main.", +// src->name, src ); +// assertf( src->last->state != Halted, +// "Attempt by coroutine \"%.256s\" (%p) to suspend back to terminated coroutine \"%.256s\" (%p).\n" +// "Possible cause is terminated coroutine's main routine has already returned.", +// src->name, src, src->last->name, src->last ); + +// // Safety note : Preemption must be disabled here since kernelTLS.this_coroutine must always be up to date +// verify( TL_GET( preemption_state.enabled ) || TL_GET( this_processor )->do_terminate ); +// disable_interrupts(); + +// // set state of current coroutine to inactive +// src->state = src->state == Halted ? Halted : Inactive; + +// // set new coroutine that task is executing +// kernelTLS.this_coroutine = dst; + +// // context switch to specified coroutine +// assert( src->stack.context ); +// CtxRet( src->stack.context ); + +// abort(); +// } + // Local Variables: // // mode: c // Index: libcfa/src/concurrency/invoke.c =================================================================== --- libcfa/src/concurrency/invoke.c (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ libcfa/src/concurrency/invoke.c (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -28,6 +28,6 @@ extern void __suspend_internal(void); -extern void __leave_coroutine(void); -extern void __finish_creation(void); +extern void __leave_coroutine( struct coroutine_desc * ); +extern void __finish_creation( struct coroutine_desc * ); extern void __leave_thread_monitor( struct thread_desc * this ); extern void disable_interrupts(); @@ -52,5 +52,5 @@ //Final suspend, should never return - __leave_coroutine(); + __leave_coroutine( cor ); __cabi_abort( "Resumed dead coroutine" ); } @@ -62,10 +62,10 @@ __attribute((__unused__)) struct _Unwind_Exception * unwind_exception, __attribute((__unused__)) struct _Unwind_Context * context, - __attribute((__unused__)) void * param + void * param ) { if( actions & _UA_END_OF_STACK ) { // We finished unwinding the coroutine, // leave it - __leave_coroutine(); + __leave_coroutine( param ); __cabi_abort( "Resumed dead coroutine" ); } @@ -75,7 +75,7 @@ } -void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage) __attribute__ ((__noreturn__)); -void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage) { - _Unwind_Reason_Code ret = _Unwind_ForcedUnwind( storage, _CtxCoroutine_UnwindStop, NULL ); +void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct coroutine_desc * cor) __attribute__ ((__noreturn__)); +void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct coroutine_desc * cor) { + _Unwind_Reason_Code ret = _Unwind_ForcedUnwind( storage, _CtxCoroutine_UnwindStop, cor ); printf("UNWIND ERROR %d after force unwind\n", ret); abort(); @@ -88,10 +88,12 @@ void *this ) { + // Fetch the thread handle from the user defined thread structure + struct thread_desc* thrd = get_thread( this ); + // First suspend, once the thread arrives here, // the function pointer to main can be invalidated without risk - __finish_creation(); + __finish_creation(&thrd->self_cor); - // Fetch the thread handle from the user defined thread structure - struct thread_desc* thrd = get_thread( this ); + // Restore the last to NULL, we clobbered because of the thunk problem thrd->self_cor.last = NULL; Index: libcfa/src/concurrency/invoke.h =================================================================== --- libcfa/src/concurrency/invoke.h (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ libcfa/src/concurrency/invoke.h (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -50,5 +50,4 @@ extern thread_local struct KernelThreadData { - struct coroutine_desc * volatile this_coroutine; struct thread_desc * volatile this_thread; struct processor * volatile this_processor; @@ -61,8 +60,4 @@ } kernelTLS __attribute__ ((tls_model ( "initial-exec" ))); } - - static inline struct coroutine_desc * volatile active_coroutine() { return TL_GET( this_coroutine ); } - static inline struct thread_desc * volatile active_thread () { return TL_GET( this_thread ); } - static inline struct processor * volatile active_processor() { return TL_GET( this_processor ); } // UNSAFE #endif @@ -170,8 +165,12 @@ struct thread_desc * prev; } node; - }; - - #ifdef __cforall - extern "Cforall" { + }; + + #ifdef __cforall + extern "Cforall" { + static inline struct coroutine_desc * volatile active_coroutine() { return TL_GET( this_thread )->curr_cor; } + static inline struct thread_desc * volatile active_thread () { return TL_GET( this_thread ); } + static inline struct processor * volatile active_processor() { return TL_GET( this_processor ); } // UNSAFE + static inline thread_desc * & get_next( thread_desc & this ) { return this.next; @@ -232,4 +231,6 @@ extern void CtxInvokeStub( void ); void CtxSwitch( void * from, void * to ) asm ("CtxSwitch"); + // void CtxStore ( void * this ) asm ("CtxStore"); + // void CtxRet ( void * dst ) asm ("CtxRet"); #if defined( __i386 ) Index: libcfa/src/concurrency/kernel.cfa =================================================================== --- libcfa/src/concurrency/kernel.cfa (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ libcfa/src/concurrency/kernel.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -60,5 +60,4 @@ NULL, NULL, - NULL, { 1, false, false } }; @@ -263,5 +262,5 @@ static void returnToKernel() { coroutine_desc * proc_cor = get_coroutine(kernelTLS.this_processor->runner); - coroutine_desc * thrd_cor = kernelTLS.this_thread->curr_cor = kernelTLS.this_coroutine; + coroutine_desc * thrd_cor = kernelTLS.this_thread->curr_cor; ThreadCtxSwitch(thrd_cor, proc_cor); } @@ -307,5 +306,4 @@ processor * proc = (processor *) arg; kernelTLS.this_processor = proc; - kernelTLS.this_coroutine = NULL; kernelTLS.this_thread = NULL; kernelTLS.preemption_state.[enabled, disable_count] = [false, 1]; @@ -321,5 +319,4 @@ //Set global state - kernelTLS.this_coroutine = get_coroutine(proc->runner); kernelTLS.this_thread = NULL; @@ -351,5 +348,5 @@ // KERNEL_ONLY void kernel_first_resume(processor * this) { - coroutine_desc * src = kernelTLS.this_coroutine; + coroutine_desc * src = mainThread->curr_cor; coroutine_desc * dst = get_coroutine(this->runner); @@ -366,7 +363,4 @@ // set state of current coroutine to inactive src->state = src->state == Halted ? Halted : Inactive; - - // set new coroutine that task is executing - kernelTLS.this_coroutine = dst; // SKULLDUGGERY normally interrupts are enable before leaving a coroutine ctxswitch. @@ -599,5 +593,4 @@ kernelTLS.this_processor = mainProcessor; kernelTLS.this_thread = mainThread; - kernelTLS.this_coroutine = &mainThread->self_cor; // Enable preemption @@ -720,6 +713,6 @@ __cfaabi_dbg_bits_write( abort_text, len ); - if ( get_coroutine(thrd) != kernelTLS.this_coroutine ) { - len = snprintf( abort_text, abort_text_size, " in coroutine %.256s (%p).\n", kernelTLS.this_coroutine->name, kernelTLS.this_coroutine ); + if ( &thrd->self_cor != thrd->curr_cor ) { + len = snprintf( abort_text, abort_text_size, " in coroutine %.256s (%p).\n", thrd->curr_cor->name, thrd->curr_cor ); __cfaabi_dbg_bits_write( abort_text, len ); } Index: libcfa/src/concurrency/thread.cfa =================================================================== --- libcfa/src/concurrency/thread.cfa (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ libcfa/src/concurrency/thread.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -75,5 +75,5 @@ coroutine_desc* thrd_c = get_coroutine(this); thread_desc * thrd_h = get_thread (this); - thrd_c->last = TL_GET( this_coroutine ); + thrd_c->last = TL_GET( this_thread )->curr_cor; // __cfaabi_dbg_print_safe("Thread start : %p (t %p, c %p)\n", this, thrd_c, thrd_h); @@ -81,5 +81,4 @@ disable_interrupts(); create_stack(&thrd_c->stack, thrd_c->stack.size); - kernelTLS.this_coroutine = thrd_c; CtxStart(&this, CtxInvokeThread); assert( thrd_c->last->stack.context ); @@ -92,6 +91,5 @@ extern "C" { // KERNEL ONLY - void __finish_creation(void) { - coroutine_desc* thrd_c = kernelTLS.this_coroutine; + void __finish_creation(coroutine_desc * thrd_c) { ThreadCtxSwitch( thrd_c, thrd_c->last ); } @@ -120,8 +118,6 @@ // set new coroutine that the processor is executing // and context switch to it - kernelTLS.this_coroutine = dst; assert( src->stack.context ); CtxSwitch( src->stack.context, dst->stack.context ); - kernelTLS.this_coroutine = src; // set state of new coroutine to active Index: libcfa/src/fstream.cfa =================================================================== --- libcfa/src/fstream.cfa (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ libcfa/src/fstream.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -10,6 +10,6 @@ // Created On : Wed May 27 17:56:53 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Dec 24 18:33:38 2018 -// Update Count : 304 +// Last Modified On : Sat Apr 20 12:03:43 2019 +// Update Count : 311 // @@ -23,4 +23,5 @@ #include // creal, cimag #include +#include // errno #define IO_MSG "I/O error: " @@ -32,4 +33,5 @@ os.nlOnOff = nlOnOff; os.prt = prt; + os.sawNL = false; sepSet( os, separator ); sepSetCur( os, sepGet( os ) ); @@ -105,7 +107,5 @@ #ifdef __CFA_DEBUG__ if ( file == 0 ) { - fprintf( stderr, IO_MSG "open output file \"%s\", ", name ); - perror( 0 ); - exit( EXIT_FAILURE ); + abort( IO_MSG "open output file \"%s\", %s", name, strerror( errno ) ); } // if #endif // __CFA_DEBUG__ @@ -121,5 +121,5 @@ if ( fclose( (FILE *)(os.file) ) == EOF ) { - perror( IO_MSG "close output" ); + abort( IO_MSG "close output %s", strerror( errno ) ); } // if } // close @@ -127,11 +127,9 @@ ofstream & write( ofstream & os, const char * data, size_t size ) { if ( fail( os ) ) { - fprintf( stderr, "attempt write I/O on failed stream\n" ); - exit( EXIT_FAILURE ); + abort( "attempt write I/O on failed stream\n" ); } // if if ( fwrite( data, 1, size, (FILE *)(os.file) ) != size ) { - perror( IO_MSG "write" ); - exit( EXIT_FAILURE ); + abort( IO_MSG "write %s", strerror( errno ) ); } // if return os; @@ -144,6 +142,5 @@ if ( len == EOF ) { if ( ferror( (FILE *)(os.file) ) ) { - fprintf( stderr, "invalid write\n" ); - exit( EXIT_FAILURE ); + abort( "invalid write\n" ); } // if } // if @@ -166,4 +163,5 @@ void ?{}( ifstream & is, void * file ) { is.file = file; + is.nlOnOff = false; } @@ -177,4 +175,8 @@ open( is, name, "r" ); } + +void nlOn( ifstream & os ) { os.nlOnOff = true; } +void nlOff( ifstream & os ) { os.nlOnOff = false; } +bool getANL( ifstream & os ) { return os.nlOnOff; } int fail( ifstream & is ) { @@ -187,10 +189,8 @@ void open( ifstream & is, const char * name, const char * mode ) { - FILE *file = fopen( name, mode ); + FILE * file = fopen( name, mode ); #ifdef __CFA_DEBUG__ if ( file == 0 ) { - fprintf( stderr, IO_MSG "open input file \"%s\", ", name ); - perror( 0 ); - exit( EXIT_FAILURE ); + abort( IO_MSG "open input file \"%s\", %s\n", name, strerror( errno ) ); } // if #endif // __CFA_DEBUG__ @@ -206,5 +206,5 @@ if ( fclose( (FILE *)(is.file) ) == EOF ) { - perror( IO_MSG "close input" ); + abort( IO_MSG "close input %s", strerror( errno ) ); } // if } // close @@ -212,11 +212,9 @@ ifstream & read( ifstream & is, char * data, size_t size ) { if ( fail( is ) ) { - fprintf( stderr, "attempt read I/O on failed stream\n" ); - exit( EXIT_FAILURE ); + abort( "attempt read I/O on failed stream\n" ); } // if if ( fread( data, size, 1, (FILE *)(is.file) ) == 0 ) { - perror( IO_MSG "read" ); - exit( EXIT_FAILURE ); + abort( IO_MSG "read %s", strerror( errno ) ); } // if return is; @@ -225,11 +223,9 @@ ifstream &ungetc( ifstream & is, char c ) { if ( fail( is ) ) { - fprintf( stderr, "attempt ungetc I/O on failed stream\n" ); - exit( EXIT_FAILURE ); + abort( "attempt ungetc I/O on failed stream\n" ); } // if if ( ungetc( c, (FILE *)(is.file) ) == EOF ) { - perror( IO_MSG "ungetc" ); - exit( EXIT_FAILURE ); + abort( IO_MSG "ungetc %s", strerror( errno ) ); } // if return is; @@ -243,6 +239,5 @@ if ( len == EOF ) { if ( ferror( (FILE *)(is.file) ) ) { - fprintf( stderr, "invalid read\n" ); - exit( EXIT_FAILURE ); + abort( "invalid read\n" ); } // if } // if Index: libcfa/src/fstream.hfa =================================================================== --- libcfa/src/fstream.hfa (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ libcfa/src/fstream.hfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -10,6 +10,6 @@ // Created On : Wed May 27 17:56:53 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Dec 24 18:33:41 2018 -// Update Count : 149 +// Last Modified On : Sat Apr 20 12:03:58 2019 +// Update Count : 151 // @@ -73,7 +73,11 @@ struct ifstream { void * file; + bool nlOnOff; }; // ifstream // public +void nlOn( ifstream & ); +void nlOff( ifstream & ); +bool getANL( ifstream & ); int fail( ifstream & is ); int eof( ifstream & is ); Index: libcfa/src/gmp.hfa =================================================================== --- libcfa/src/gmp.hfa (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ libcfa/src/gmp.hfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -10,6 +10,6 @@ // Created On : Tue Apr 19 08:43:43 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue Dec 4 23:25:51 2018 -// Update Count : 22 +// Last Modified On : Sat Apr 20 09:01:52 2019 +// Update Count : 24 // @@ -271,5 +271,5 @@ void ?|?( ostype & os, Int mp ) { - (ostype)(os | mp); if ( getANL( os ) ) nl( os ); + (ostype)(os | mp); nl( os ); } // ?|? } // distribution Index: libcfa/src/heap.cfa =================================================================== --- libcfa/src/heap.cfa (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ libcfa/src/heap.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -10,6 +10,6 @@ // Created On : Tue Dec 19 21:58:35 2017 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Sep 6 09:01:30 2018 -// Update Count : 513 +// Last Modified On : Fri Mar 22 13:43:10 2019 +// Update Count : 514 // @@ -1034,4 +1034,4 @@ // Local Variables: // // tab-width: 4 // -// compile-command: "cfa -nodebug -O2 heap.c" // +// compile-command: "cfa -nodebug -O2 heap.cfa" // // End: // Index: libcfa/src/iostream.cfa =================================================================== --- libcfa/src/iostream.cfa (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ libcfa/src/iostream.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -10,6 +10,6 @@ // Created On : Wed May 27 17:56:53 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Mar 4 20:57:24 2019 -// Update Count : 593 +// Last Modified On : Sat Apr 20 14:02:43 2019 +// Update Count : 617 // @@ -396,5 +396,11 @@ istype & ?|?( istype & is, char & c ) { - fmt( is, "%c", &c ); // must pass pointer through varg to fmt + char temp; + for () { + 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 ( eof( is ) ) break; + } // for return is; } // ?|? @@ -498,4 +504,14 @@ return is; } // nl + + istype & nlOn( istype & is ) { + nlOn( is ); // call void returning + return is; + } // nlOn + + istype & nlOff( istype & is ) { + nlOff( is ); // call void returning + return is; + } // nlOff } // distribution Index: libcfa/src/iostream.hfa =================================================================== --- libcfa/src/iostream.hfa (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ libcfa/src/iostream.hfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -10,6 +10,6 @@ // Created On : Wed May 27 17:56:53 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue Feb 26 16:57:22 2019 -// Update Count : 221 +// Last Modified On : Sat Apr 20 12:04:07 2019 +// Update Count : 226 // @@ -149,4 +149,7 @@ trait istream( dtype istype ) { + void nlOn( istype & ); // read newline + void nlOff( istype & ); // scan newline + bool getANL( istype & ); // get scan newline (on/off) int fail( istype & ); int eof( istype & ); @@ -187,4 +190,6 @@ // manipulators + istype & nlOn( istype & ); + istype & nlOff( istype & ); istype & ?|?( istype &, istype & (*)( istype & ) ); istype & nl( istype & is ); Index: libcfa/src/rational.cfa =================================================================== --- libcfa/src/rational.cfa (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ libcfa/src/rational.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -10,6 +10,6 @@ // Created On : Wed Apr 6 17:54:28 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Sun Dec 23 22:56:49 2018 -// Update Count : 170 +// Last Modified On : Thu Mar 28 17:33:03 2019 +// Update Count : 181 // @@ -35,6 +35,5 @@ static RationalImpl simplify( RationalImpl & n, RationalImpl & d ) { if ( d == (RationalImpl){0} ) { - serr | "Invalid rational number construction: denominator cannot be equal to 0."; - exit( EXIT_FAILURE ); + abort( "Invalid rational number construction: denominator cannot be equal to 0.\n" ); } // exit if ( d < (RationalImpl){0} ) { d = -d; n = -n; } // move sign to numerator @@ -54,6 +53,5 @@ void ?{}( Rational(RationalImpl) & r, RationalImpl n, RationalImpl d ) { RationalImpl t = simplify( n, d ); // simplify - r.numerator = n / t; - r.denominator = d / t; + r.[numerator, denominator] = [n / t, d / t]; } // rational @@ -78,6 +76,5 @@ RationalImpl prev = r.numerator; RationalImpl t = gcd( abs( n ), r.denominator ); // simplify - r.numerator = n / t; - r.denominator = r.denominator / t; + r.[numerator, denominator] = [n / t, r.denominator / t]; return prev; } // numerator @@ -86,6 +83,5 @@ RationalImpl prev = r.denominator; RationalImpl t = simplify( r.numerator, d ); // simplify - r.numerator = r.numerator / t; - r.denominator = d / t; + r.[numerator, denominator] = [r.numerator / t, d / t]; return prev; } // denominator @@ -120,20 +116,16 @@ Rational(RationalImpl) +?( Rational(RationalImpl) r ) { - Rational(RationalImpl) t = { r.numerator, r.denominator }; - return t; + return (Rational(RationalImpl)){ r.numerator, r.denominator }; } // +? Rational(RationalImpl) -?( Rational(RationalImpl) r ) { - Rational(RationalImpl) t = { -r.numerator, r.denominator }; - return t; + return (Rational(RationalImpl)){ -r.numerator, r.denominator }; } // -? Rational(RationalImpl) ?+?( Rational(RationalImpl) l, Rational(RationalImpl) r ) { if ( l.denominator == r.denominator ) { // special case - Rational(RationalImpl) t = { l.numerator + r.numerator, l.denominator }; - return t; + return (Rational(RationalImpl)){ l.numerator + r.numerator, l.denominator }; } else { - Rational(RationalImpl) t = { l.numerator * r.denominator + l.denominator * r.numerator, l.denominator * r.denominator }; - return t; + return (Rational(RationalImpl)){ l.numerator * r.denominator + l.denominator * r.numerator, l.denominator * r.denominator }; } // if } // ?+? @@ -141,24 +133,19 @@ Rational(RationalImpl) ?-?( Rational(RationalImpl) l, Rational(RationalImpl) r ) { if ( l.denominator == r.denominator ) { // special case - Rational(RationalImpl) t = { l.numerator - r.numerator, l.denominator }; - return t; + return (Rational(RationalImpl)){ l.numerator - r.numerator, l.denominator }; } else { - Rational(RationalImpl) t = { l.numerator * r.denominator - l.denominator * r.numerator, l.denominator * r.denominator }; - return t; + return (Rational(RationalImpl)){ l.numerator * r.denominator - l.denominator * r.numerator, l.denominator * r.denominator }; } // if } // ?-? Rational(RationalImpl) ?*?( Rational(RationalImpl) l, Rational(RationalImpl) r ) { - Rational(RationalImpl) t = { l.numerator * r.numerator, l.denominator * r.denominator }; - return t; + return (Rational(RationalImpl)){ l.numerator * r.numerator, l.denominator * r.denominator }; } // ?*? Rational(RationalImpl) ?/?( Rational(RationalImpl) l, Rational(RationalImpl) r ) { if ( r.numerator < (RationalImpl){0} ) { - r.numerator = -r.numerator; - r.denominator = -r.denominator; + r.[numerator, denominator] = [-r.numerator, -r.denominator]; } // if - Rational(RationalImpl) t = { l.numerator * r.denominator, l.denominator * r.numerator }; - return t; + return (Rational(RationalImpl)){ l.numerator * r.denominator, l.denominator * r.numerator }; } // ?/? @@ -167,7 +154,6 @@ forall( dtype istype | istream( istype ) | { istype & ?|?( istype &, RationalImpl & ); } ) istype & ?|?( istype & is, Rational(RationalImpl) & r ) { - RationalImpl t; is | r.numerator | r.denominator; - t = simplify( r.numerator, r.denominator ); + RationalImpl t = simplify( r.numerator, r.denominator ); r.numerator /= t; r.denominator /= t; @@ -185,4 +171,13 @@ } // distribution } // distribution + +forall( otype RationalImpl | arithmetic( RationalImpl ) | { RationalImpl ?\?( RationalImpl, unsigned long ); } ) +Rational(RationalImpl) ?\?( Rational(RationalImpl) x, long int y ) { + if ( y < 0 ) { + return (Rational(RationalImpl)){ x.denominator \ -y, x.numerator \ -y }; + } else { + return (Rational(RationalImpl)){ x.numerator \ y, x.denominator \ y }; + } // if +} // conversion Index: libcfa/src/rational.hfa =================================================================== --- libcfa/src/rational.hfa (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ libcfa/src/rational.hfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -12,6 +12,6 @@ // Created On : Wed Apr 6 17:56:25 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue Dec 4 23:07:46 2018 -// Update Count : 106 +// Last Modified On : Tue Mar 26 23:16:10 2019 +// Update Count : 109 // @@ -98,4 +98,7 @@ } // distribution +forall( otype RationalImpl | arithmetic( RationalImpl ) |{RationalImpl ?\?( RationalImpl, unsigned long );} ) +Rational(RationalImpl) ?\?( Rational(RationalImpl) x, long int y ); + // conversion forall( otype RationalImpl | arithmetic( RationalImpl ) | { double convert( RationalImpl ); } ) Index: libcfa/src/stdhdr/stdbool.h =================================================================== --- libcfa/src/stdhdr/stdbool.h (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ libcfa/src/stdhdr/stdbool.h (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -10,10 +10,21 @@ // Created On : Mon Jul 4 23:25:26 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue Jul 5 20:39:51 2016 -// Update Count : 12 +// Last Modified On : Mon Mar 25 08:00:08 2019 +// Update Count : 15 // extern "C" { #include_next // has internal check for multiple expansion + +// allows printing as true/false +#if defined( true ) +#undef true +#define true ((_Bool)1) +#endif // true + +#if defined( false ) +#undef false +#define false ((_Bool)0) +#endif // false } // extern "C" Index: libcfa/src/stdlib.hfa =================================================================== --- libcfa/src/stdlib.hfa (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ libcfa/src/stdlib.hfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -10,6 +10,6 @@ // Created On : Thu Jan 28 17:12:35 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Dec 17 15:37:45 2018 -// Update Count : 346 +// Last Modified On : Wed Apr 24 17:35:43 2019 +// Update Count : 352 // @@ -40,11 +40,4 @@ } // malloc - // T & malloc( void ) { - // int & p = *(T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc - // printf( "& malloc %p\n", &p ); - // return p; - // // return (T &)*(T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc - // } // malloc - T * calloc( size_t dim ) { return (T *)(void *)calloc( dim, sizeof(T) ); // C calloc @@ -76,5 +69,5 @@ T * alloc( char fill ) { T * ptr = (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc - return (T *)memset( ptr, (int)fill, sizeof(T) ); // initial with fill value + return (T *)memset( ptr, (int)fill, sizeof(T) ); // initialize with fill value } // alloc @@ -84,6 +77,6 @@ T * alloc( size_t dim, char fill ) { - T * ptr = (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc - return (T *)memset( ptr, (int)fill, dim * sizeof(T) ); // initial with fill value + T * ptr = (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C calloc + return (T *)memset( ptr, (int)fill, dim * sizeof(T) ); // initialize with fill value } // alloc Index: longrun_tests/Makefile.am =================================================================== --- longrun_tests/Makefile.am (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ longrun_tests/Makefile.am (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,87 @@ +######################## -*- Mode: Makefile-Automake -*- ###################### +## +## Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +## +## The contents of this file are covered under the licence agreement in the +## file "LICENCE" distributed with Cforall. +## +## Makefile.am -- +## +## Author : Thierry Delisle +## Created On : Fri Jun 16 10:57:34 2017 +## Last Modified By : +## Last Modified On : +## Update Count : 0 +############################################################################### + +AUTOMAKE_OPTIONS = foreign # do not require all the GNU file names +ACLOCAL_AMFLAGS = -I automake + +include $(top_srcdir)/src/cfa.make + +repeats=10 +max_time=600 +preempt=10ul\`ms +debug=-debug +type=LONG + +REPEAT = $(abs_top_builddir)/tools/repeat +WATCHDOG = $(abs_top_builddir)/tools/watchdog +TIME = /usr/bin/time -f "%E" + +UPDATED_TYPE = $(shell $(srcdir)/update-type $(type)) + +BUILD_FLAGS = +AM_CFAFLAGS = \ + -g \ + -Wall \ + -Wno-unused-function \ + -quiet \ + -O2 \ + -DPREEMPTION_RATE=$(preempt) \ + -I$(abs_top_srcdir)/tests \ + -I$(srcdir) \ + -DTEST_$(shell cat .type | tr a-z A-Z) \ + -in-tree + +TESTS = block coroutine create disjoint enter enter3 processor stack wait yield + +# .INTERMEDIATE: $(TESTS) + +all-local: $(TESTS:=.run) + +runall : $(TESTS:=.run) + @ echo "All programs terminated normally" + +watchall : $(TESTS:=.watch) + @ echo "All programs terminated normally" + +compileall : $(TESTS) + @ echo "Compiled" + +clean-local: + rm -f $(TESTS) core* out.log .type + +% : %.cfa $(CFACC) $(UPDATED_TYPE) + $(AM_V_CFA)$(CFACOMPILE) $(<) $(debug) -o $(@) + +%.run : % $(REPEAT) + @ time $(REPEAT) -r out.log -i -s $(repeats) timeout $(max_time) ./$(<) + @ rm $(<) + @ echo -e "$(<): SUCCESS\n" + +%.watch : % $(WATCHDOG) + @ time $(WATCHDOG} ./$(<) + @ rm $(<) + @ echo -e "$(<): SUCCESS\n" + +%.time : % $(REPEAT) + @ $(REPEAT) -i -s -- $(repeats) $(TIME) -a -o times.log ./$(<) + @ rm $(<) + @ echo -e "$(<): SUCCESS\n" + +$(REPEAT): $(abs_top_builddir)/tools/Makefile + @+make -C $(abs_top_builddir)/tools/ + +$(WATCHDOG): $(abs_top_builddir)/tools/Makefile + @+make -C $(abs_top_builddir)/tools/ Index: longrun_tests/Makefile.in =================================================================== --- longrun_tests/Makefile.in (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ longrun_tests/Makefile.in (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,1005 @@ +# Makefile.in generated by automake 1.15 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994-2014 Free Software Foundation, Inc. + +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + +######################## -*- Mode: Makefile-Automake -*- ###################### +############################################################################### +VPATH = @srcdir@ +am__is_gnu_make = { \ + if test -z '$(MAKELEVEL)'; then \ + false; \ + elif test -n '$(MAKE_HOST)'; then \ + true; \ + elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ + true; \ + else \ + false; \ + fi; \ +} +am__make_running_with_option = \ + case $${target_option-} in \ + ?) ;; \ + *) echo "am__make_running_with_option: internal error: invalid" \ + "target option '$${target_option-}' specified" >&2; \ + exit 1;; \ + esac; \ + has_opt=no; \ + sane_makeflags=$$MAKEFLAGS; \ + if $(am__is_gnu_make); then \ + sane_makeflags=$$MFLAGS; \ + else \ + case $$MAKEFLAGS in \ + *\\[\ \ ]*) \ + bs=\\; \ + sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ + | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ + esac; \ + fi; \ + skip_next=no; \ + strip_trailopt () \ + { \ + flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ + }; \ + for flg in $$sane_makeflags; do \ + test $$skip_next = yes && { skip_next=no; continue; }; \ + case $$flg in \ + *=*|--*) continue;; \ + -*I) strip_trailopt 'I'; skip_next=yes;; \ + -*I?*) strip_trailopt 'I';; \ + -*O) strip_trailopt 'O'; skip_next=yes;; \ + -*O?*) strip_trailopt 'O';; \ + -*l) strip_trailopt 'l'; skip_next=yes;; \ + -*l?*) strip_trailopt 'l';; \ + -[dEDm]) skip_next=yes;; \ + -[JT]) skip_next=yes;; \ + esac; \ + case $$flg in \ + *$$target_option*) has_opt=yes; break;; \ + esac; \ + done; \ + test $$has_opt = yes +am__make_dryrun = (target_option=n; $(am__make_running_with_option)) +am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +subdir = longrun_tests +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/automake/libtool.m4 \ + $(top_srcdir)/automake/ltoptions.m4 \ + $(top_srcdir)/automake/ltsugar.m4 \ + $(top_srcdir)/automake/ltversion.m4 \ + $(top_srcdir)/automake/lt~obsolete.m4 \ + $(top_srcdir)/automake/cfa.m4 $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON) +mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = $(top_builddir)/config.h +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +AM_V_P = $(am__v_P_@AM_V@) +am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) +am__v_P_0 = false +am__v_P_1 = : +AM_V_GEN = $(am__v_GEN_@AM_V@) +am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) +am__v_GEN_0 = @echo " GEN " $@; +am__v_GEN_1 = +AM_V_at = $(am__v_at_@AM_V@) +am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) +am__v_at_0 = @ +am__v_at_1 = +SOURCES = +DIST_SOURCES = +am__can_run_installinfo = \ + case $$AM_UPDATE_INFO_DIR in \ + n|no|NO) false;; \ + *) (install-info --version) >/dev/null 2>&1;; \ + esac +am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) +am__tty_colors_dummy = \ + mgn= red= grn= lgn= blu= brg= std=; \ + am__color_tests=no +am__tty_colors = { \ + $(am__tty_colors_dummy); \ + if test "X$(AM_COLOR_TESTS)" = Xno; then \ + am__color_tests=no; \ + elif test "X$(AM_COLOR_TESTS)" = Xalways; then \ + am__color_tests=yes; \ + elif test "X$$TERM" != Xdumb && { test -t 1; } 2>/dev/null; then \ + am__color_tests=yes; \ + fi; \ + if test $$am__color_tests = yes; then \ + red=''; \ + grn=''; \ + lgn=''; \ + blu=''; \ + mgn=''; \ + brg=''; \ + std=''; \ + fi; \ +} +am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; +am__vpath_adj = case $$p in \ + $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ + *) f=$$p;; \ + esac; +am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; +am__install_max = 40 +am__nobase_strip_setup = \ + srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` +am__nobase_strip = \ + for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" +am__nobase_list = $(am__nobase_strip_setup); \ + for p in $$list; do echo "$$p $$p"; done | \ + sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ + $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ + if (++n[$$2] == $(am__install_max)) \ + { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ + END { for (dir in files) print dir, files[dir] }' +am__base_list = \ + sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ + sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' +am__uninstall_files_from_dir = { \ + test -z "$$files" \ + || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ + || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ + $(am__cd) "$$dir" && rm -f $$files; }; \ + } +am__recheck_rx = ^[ ]*:recheck:[ ]* +am__global_test_result_rx = ^[ ]*:global-test-result:[ ]* +am__copy_in_global_log_rx = ^[ ]*:copy-in-global-log:[ ]* +# A command that, given a newline-separated list of test names on the +# standard input, print the name of the tests that are to be re-run +# upon "make recheck". +am__list_recheck_tests = $(AWK) '{ \ + recheck = 1; \ + while ((rc = (getline line < ($$0 ".trs"))) != 0) \ + { \ + if (rc < 0) \ + { \ + if ((getline line2 < ($$0 ".log")) < 0) \ + recheck = 0; \ + break; \ + } \ + else if (line ~ /$(am__recheck_rx)[nN][Oo]/) \ + { \ + recheck = 0; \ + break; \ + } \ + else if (line ~ /$(am__recheck_rx)[yY][eE][sS]/) \ + { \ + break; \ + } \ + }; \ + if (recheck) \ + print $$0; \ + close ($$0 ".trs"); \ + close ($$0 ".log"); \ +}' +# A command that, given a newline-separated list of test names on the +# standard input, create the global log from their .trs and .log files. +am__create_global_log = $(AWK) ' \ +function fatal(msg) \ +{ \ + print "fatal: making $@: " msg | "cat >&2"; \ + exit 1; \ +} \ +function rst_section(header) \ +{ \ + print header; \ + len = length(header); \ + for (i = 1; i <= len; i = i + 1) \ + printf "="; \ + printf "\n\n"; \ +} \ +{ \ + copy_in_global_log = 1; \ + global_test_result = "RUN"; \ + while ((rc = (getline line < ($$0 ".trs"))) != 0) \ + { \ + if (rc < 0) \ + fatal("failed to read from " $$0 ".trs"); \ + if (line ~ /$(am__global_test_result_rx)/) \ + { \ + sub("$(am__global_test_result_rx)", "", line); \ + sub("[ ]*$$", "", line); \ + global_test_result = line; \ + } \ + else if (line ~ /$(am__copy_in_global_log_rx)[nN][oO]/) \ + copy_in_global_log = 0; \ + }; \ + if (copy_in_global_log) \ + { \ + rst_section(global_test_result ": " $$0); \ + while ((rc = (getline line < ($$0 ".log"))) != 0) \ + { \ + if (rc < 0) \ + fatal("failed to read from " $$0 ".log"); \ + print line; \ + }; \ + printf "\n"; \ + }; \ + close ($$0 ".trs"); \ + close ($$0 ".log"); \ +}' +# Restructured Text title. +am__rst_title = { sed 's/.*/ & /;h;s/./=/g;p;x;s/ *$$//;p;g' && echo; } +# Solaris 10 'make', and several other traditional 'make' implementations, +# pass "-e" to $(SHELL), and POSIX 2008 even requires this. Work around it +# by disabling -e (using the XSI extension "set +e") if it's set. +am__sh_e_setup = case $$- in *e*) set +e;; esac +# Default flags passed to test drivers. +am__common_driver_flags = \ + --color-tests "$$am__color_tests" \ + --enable-hard-errors "$$am__enable_hard_errors" \ + --expect-failure "$$am__expect_failure" +# To be inserted before the command running the test. Creates the +# directory for the log if needed. Stores in $dir the directory +# containing $f, in $tst the test, in $log the log. Executes the +# developer- defined test setup AM_TESTS_ENVIRONMENT (if any), and +# passes TESTS_ENVIRONMENT. Set up options for the wrapper that +# will run the test scripts (or their associated LOG_COMPILER, if +# thy have one). +am__check_pre = \ +$(am__sh_e_setup); \ +$(am__vpath_adj_setup) $(am__vpath_adj) \ +$(am__tty_colors); \ +srcdir=$(srcdir); export srcdir; \ +case "$@" in \ + */*) am__odir=`echo "./$@" | sed 's|/[^/]*$$||'`;; \ + *) am__odir=.;; \ +esac; \ +test "x$$am__odir" = x"." || test -d "$$am__odir" \ + || $(MKDIR_P) "$$am__odir" || exit $$?; \ +if test -f "./$$f"; then dir=./; \ +elif test -f "$$f"; then dir=; \ +else dir="$(srcdir)/"; fi; \ +tst=$$dir$$f; log='$@'; \ +if test -n '$(DISABLE_HARD_ERRORS)'; then \ + am__enable_hard_errors=no; \ +else \ + am__enable_hard_errors=yes; \ +fi; \ +case " $(XFAIL_TESTS) " in \ + *[\ \ ]$$f[\ \ ]* | *[\ \ ]$$dir$$f[\ \ ]*) \ + am__expect_failure=yes;; \ + *) \ + am__expect_failure=no;; \ +esac; \ +$(AM_TESTS_ENVIRONMENT) $(TESTS_ENVIRONMENT) +# A shell command to get the names of the tests scripts with any registered +# extension removed (i.e., equivalently, the names of the test logs, with +# the '.log' extension removed). The result is saved in the shell variable +# '$bases'. This honors runtime overriding of TESTS and TEST_LOGS. Sadly, +# we cannot use something simpler, involving e.g., "$(TEST_LOGS:.log=)", +# since that might cause problem with VPATH rewrites for suffix-less tests. +# See also 'test-harness-vpath-rewrite.sh' and 'test-trs-basic.sh'. +am__set_TESTS_bases = \ + bases='$(TEST_LOGS)'; \ + bases=`for i in $$bases; do echo $$i; done | sed 's/\.log$$//'`; \ + bases=`echo $$bases` +RECHECK_LOGS = $(TEST_LOGS) +AM_RECURSIVE_TARGETS = check recheck +TEST_SUITE_LOG = test-suite.log +TEST_EXTENSIONS = @EXEEXT@ .test +LOG_DRIVER = $(SHELL) $(top_srcdir)/automake/test-driver +LOG_COMPILE = $(LOG_COMPILER) $(AM_LOG_FLAGS) $(LOG_FLAGS) +am__set_b = \ + case '$@' in \ + */*) \ + case '$*' in \ + */*) b='$*';; \ + *) b=`echo '$@' | sed 's/\.log$$//'`; \ + esac;; \ + *) \ + b='$*';; \ + esac +am__test_logs1 = $(TESTS:=.log) +am__test_logs2 = $(am__test_logs1:@EXEEXT@.log=.log) +TEST_LOGS = $(am__test_logs2:.test.log=.log) +TEST_LOG_DRIVER = $(SHELL) $(top_srcdir)/automake/test-driver +TEST_LOG_COMPILE = $(TEST_LOG_COMPILER) $(AM_TEST_LOG_FLAGS) \ + $(TEST_LOG_FLAGS) +am__DIST_COMMON = $(srcdir)/Makefile.in \ + $(top_srcdir)/automake/test-driver $(top_srcdir)/src/cfa.make +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ +AR = @AR@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +BUILD_IN_TREE_FLAGS = @BUILD_IN_TREE_FLAGS@ +CC = @CC@ +CCAS = @CCAS@ +CCASDEPMODE = @CCASDEPMODE@ +CCASFLAGS = @CCASFLAGS@ +CCDEPMODE = @CCDEPMODE@ +CFACC = @CFACC@ +CFACPP = @CFACPP@ +CFA_BACKEND_CC = @CFA_BACKEND_CC@ +CFA_BINDIR = @CFA_BINDIR@ +CFA_FLAGS = @CFA_FLAGS@ +CFA_INCDIR = @CFA_INCDIR@ +CFA_LIBDIR = @CFA_LIBDIR@ +CFA_NAME = @CFA_NAME@ +CFA_PREFIX = @CFA_PREFIX@ +CFLAGS = @CFLAGS@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CXX = @CXX@ +CXXCPP = @CXXCPP@ +CXXDEPMODE = @CXXDEPMODE@ +CXXFLAGS = @CXXFLAGS@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +DEPDIR = @DEPDIR@ +DLLTOOL = @DLLTOOL@ +DRIVER_DIR = @DRIVER_DIR@ +DSYMUTIL = @DSYMUTIL@ +DUMPBIN = @DUMPBIN@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EXEEXT = @EXEEXT@ +FGREP = @FGREP@ +GREP = @GREP@ +HOST_FLAGS = @HOST_FLAGS@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LD = @LD@ +LDFLAGS = @LDFLAGS@ +LEX = @LEX@ +LEXLIB = @LEXLIB@ +LEX_OUTPUT_ROOT = @LEX_OUTPUT_ROOT@ +LIBCFA_TARGET_DIRS = @LIBCFA_TARGET_DIRS@ +LIBCFA_TARGET_MAKEFILES = @LIBCFA_TARGET_MAKEFILES@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LIBTOOL = @LIBTOOL@ +LIPO = @LIPO@ +LN_S = @LN_S@ +LTLIBOBJS = @LTLIBOBJS@ +LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@ +MAKEINFO = @MAKEINFO@ +MANIFEST_TOOL = @MANIFEST_TOOL@ +MKDIR_P = @MKDIR_P@ +NM = @NM@ +NMEDIT = @NMEDIT@ +OBJDUMP = @OBJDUMP@ +OBJEXT = @OBJEXT@ +OTOOL = @OTOOL@ +OTOOL64 = @OTOOL64@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +RANLIB = @RANLIB@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +TARGET_HOSTS = @TARGET_HOSTS@ +VERSION = @VERSION@ +YACC = @YACC@ +YFLAGS = @YFLAGS@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_ct_AR = @ac_ct_AR@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_CXX = @ac_ct_CXX@ +ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +runstatedir = @runstatedir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +AUTOMAKE_OPTIONS = foreign # do not require all the GNU file names +ACLOCAL_AMFLAGS = -I automake +CFACOMPILE = $(CFACC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CFAFLAGS) $(CFAFLAGS) $(AM_CFLAGS) $(CFLAGS) +LTCFACOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=compile $(CFACC) $(DEFS) \ + $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CFAFLAGS) $(CFAFLAGS) \ + $(AM_CFLAGS) $(CFLAGS) + +AM_V_CFA = $(am__v_CFA_@AM_V@) +am__v_CFA_ = $(am__v_CFA_@AM_DEFAULT_V@) +am__v_CFA_0 = @echo " CFA " $@; +am__v_CFA_1 = +AM_V_JAVAC = $(am__v_JAVAC_@AM_V@) +am__v_JAVAC_ = $(am__v_JAVAC_@AM_DEFAULT_V@) +am__v_JAVAC_0 = @echo " JAVAC " $@; +am__v_JAVAC_1 = +AM_V_GOC = $(am__v_GOC_@AM_V@) +am__v_GOC_ = $(am__v_GOC_@AM_DEFAULT_V@) +am__v_GOC_0 = @echo " GOC " $@; +am__v_GOC_1 = +UPPCC = u++ +UPPCOMPILE = $(UPPCC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_UPPFLAGS) $(UPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_CFLAGS) $(CFLAGS) +AM_V_UPP = $(am__v_UPP_@AM_V@) +am__v_UPP_ = $(am__v_UPP_@AM_DEFAULT_V@) +am__v_UPP_0 = @echo " UPP " $@; +am__v_UPP_1 = +repeats = 10 +max_time = 600 +preempt = 10ul\`ms +debug = -debug +type = LONG +REPEAT = $(abs_top_builddir)/tools/repeat +WATCHDOG = $(abs_top_builddir)/tools/watchdog +TIME = /usr/bin/time -f "%E" +UPDATED_TYPE = $(shell $(srcdir)/update-type $(type)) +BUILD_FLAGS = +AM_CFAFLAGS = \ + -g \ + -Wall \ + -Wno-unused-function \ + -quiet \ + -O2 \ + -DPREEMPTION_RATE=$(preempt) \ + -I$(abs_top_srcdir)/tests \ + -I$(srcdir) \ + -DTEST_$(shell cat .type | tr a-z A-Z) \ + -in-tree + +TESTS = block coroutine create disjoint enter enter3 processor stack wait yield +all: all-am + +.SUFFIXES: +.SUFFIXES: .cfa .lo .log .o .test .test$(EXEEXT) .trs +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(top_srcdir)/src/cfa.make $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign longrun_tests/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --foreign longrun_tests/Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; +$(top_srcdir)/src/cfa.make $(am__empty): + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs +tags TAGS: + +ctags CTAGS: + +cscope cscopelist: + + +# Recover from deleted '.trs' file; this should ensure that +# "rm -f foo.log; make foo.trs" re-run 'foo.test', and re-create +# both 'foo.log' and 'foo.trs'. Break the recipe in two subshells +# to avoid problems with "make -n". +.log.trs: + rm -f $< $@ + $(MAKE) $(AM_MAKEFLAGS) $< + +# Leading 'am--fnord' is there to ensure the list of targets does not +# expand to empty, as could happen e.g. with make check TESTS=''. +am--fnord $(TEST_LOGS) $(TEST_LOGS:.log=.trs): $(am__force_recheck) +am--force-recheck: + @: + +$(TEST_SUITE_LOG): $(TEST_LOGS) + @$(am__set_TESTS_bases); \ + am__f_ok () { test -f "$$1" && test -r "$$1"; }; \ + redo_bases=`for i in $$bases; do \ + am__f_ok $$i.trs && am__f_ok $$i.log || echo $$i; \ + done`; \ + if test -n "$$redo_bases"; then \ + redo_logs=`for i in $$redo_bases; do echo $$i.log; done`; \ + redo_results=`for i in $$redo_bases; do echo $$i.trs; done`; \ + if $(am__make_dryrun); then :; else \ + rm -f $$redo_logs && rm -f $$redo_results || exit 1; \ + fi; \ + fi; \ + if test -n "$$am__remaking_logs"; then \ + echo "fatal: making $(TEST_SUITE_LOG): possible infinite" \ + "recursion detected" >&2; \ + elif test -n "$$redo_logs"; then \ + am__remaking_logs=yes $(MAKE) $(AM_MAKEFLAGS) $$redo_logs; \ + fi; \ + if $(am__make_dryrun); then :; else \ + st=0; \ + errmsg="fatal: making $(TEST_SUITE_LOG): failed to create"; \ + for i in $$redo_bases; do \ + test -f $$i.trs && test -r $$i.trs \ + || { echo "$$errmsg $$i.trs" >&2; st=1; }; \ + test -f $$i.log && test -r $$i.log \ + || { echo "$$errmsg $$i.log" >&2; st=1; }; \ + done; \ + test $$st -eq 0 || exit 1; \ + fi + @$(am__sh_e_setup); $(am__tty_colors); $(am__set_TESTS_bases); \ + ws='[ ]'; \ + results=`for b in $$bases; do echo $$b.trs; done`; \ + test -n "$$results" || results=/dev/null; \ + all=` grep "^$$ws*:test-result:" $$results | wc -l`; \ + pass=` grep "^$$ws*:test-result:$$ws*PASS" $$results | wc -l`; \ + fail=` grep "^$$ws*:test-result:$$ws*FAIL" $$results | wc -l`; \ + skip=` grep "^$$ws*:test-result:$$ws*SKIP" $$results | wc -l`; \ + xfail=`grep "^$$ws*:test-result:$$ws*XFAIL" $$results | wc -l`; \ + xpass=`grep "^$$ws*:test-result:$$ws*XPASS" $$results | wc -l`; \ + error=`grep "^$$ws*:test-result:$$ws*ERROR" $$results | wc -l`; \ + if test `expr $$fail + $$xpass + $$error` -eq 0; then \ + success=true; \ + else \ + success=false; \ + fi; \ + br='==================='; br=$$br$$br$$br$$br; \ + result_count () \ + { \ + if test x"$$1" = x"--maybe-color"; then \ + maybe_colorize=yes; \ + elif test x"$$1" = x"--no-color"; then \ + maybe_colorize=no; \ + else \ + echo "$@: invalid 'result_count' usage" >&2; exit 4; \ + fi; \ + shift; \ + desc=$$1 count=$$2; \ + if test $$maybe_colorize = yes && test $$count -gt 0; then \ + color_start=$$3 color_end=$$std; \ + else \ + color_start= color_end=; \ + fi; \ + echo "$${color_start}# $$desc $$count$${color_end}"; \ + }; \ + create_testsuite_report () \ + { \ + result_count $$1 "TOTAL:" $$all "$$brg"; \ + result_count $$1 "PASS: " $$pass "$$grn"; \ + result_count $$1 "SKIP: " $$skip "$$blu"; \ + result_count $$1 "XFAIL:" $$xfail "$$lgn"; \ + result_count $$1 "FAIL: " $$fail "$$red"; \ + result_count $$1 "XPASS:" $$xpass "$$red"; \ + result_count $$1 "ERROR:" $$error "$$mgn"; \ + }; \ + { \ + echo "$(PACKAGE_STRING): $(subdir)/$(TEST_SUITE_LOG)" | \ + $(am__rst_title); \ + create_testsuite_report --no-color; \ + echo; \ + echo ".. contents:: :depth: 2"; \ + echo; \ + for b in $$bases; do echo $$b; done \ + | $(am__create_global_log); \ + } >$(TEST_SUITE_LOG).tmp || exit 1; \ + mv $(TEST_SUITE_LOG).tmp $(TEST_SUITE_LOG); \ + if $$success; then \ + col="$$grn"; \ + else \ + col="$$red"; \ + test x"$$VERBOSE" = x || cat $(TEST_SUITE_LOG); \ + fi; \ + echo "$${col}$$br$${std}"; \ + echo "$${col}Testsuite summary for $(PACKAGE_STRING)$${std}"; \ + echo "$${col}$$br$${std}"; \ + create_testsuite_report --maybe-color; \ + echo "$$col$$br$$std"; \ + if $$success; then :; else \ + echo "$${col}See $(subdir)/$(TEST_SUITE_LOG)$${std}"; \ + if test -n "$(PACKAGE_BUGREPORT)"; then \ + echo "$${col}Please report to $(PACKAGE_BUGREPORT)$${std}"; \ + fi; \ + echo "$$col$$br$$std"; \ + fi; \ + $$success || exit 1 + +check-TESTS: + @list='$(RECHECK_LOGS)'; test -z "$$list" || rm -f $$list + @list='$(RECHECK_LOGS:.log=.trs)'; test -z "$$list" || rm -f $$list + @test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG) + @set +e; $(am__set_TESTS_bases); \ + log_list=`for i in $$bases; do echo $$i.log; done`; \ + trs_list=`for i in $$bases; do echo $$i.trs; done`; \ + log_list=`echo $$log_list`; trs_list=`echo $$trs_list`; \ + $(MAKE) $(AM_MAKEFLAGS) $(TEST_SUITE_LOG) TEST_LOGS="$$log_list"; \ + exit $$?; +recheck: all + @test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG) + @set +e; $(am__set_TESTS_bases); \ + bases=`for i in $$bases; do echo $$i; done \ + | $(am__list_recheck_tests)` || exit 1; \ + log_list=`for i in $$bases; do echo $$i.log; done`; \ + log_list=`echo $$log_list`; \ + $(MAKE) $(AM_MAKEFLAGS) $(TEST_SUITE_LOG) \ + am__force_recheck=am--force-recheck \ + TEST_LOGS="$$log_list"; \ + exit $$? +block.log: block + @p='block'; \ + b='block'; \ + $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ + --log-file $$b.log --trs-file $$b.trs \ + $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ + "$$tst" $(AM_TESTS_FD_REDIRECT) +coroutine.log: coroutine + @p='coroutine'; \ + b='coroutine'; \ + $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ + --log-file $$b.log --trs-file $$b.trs \ + $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ + "$$tst" $(AM_TESTS_FD_REDIRECT) +create.log: create + @p='create'; \ + b='create'; \ + $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ + --log-file $$b.log --trs-file $$b.trs \ + $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ + "$$tst" $(AM_TESTS_FD_REDIRECT) +disjoint.log: disjoint + @p='disjoint'; \ + b='disjoint'; \ + $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ + --log-file $$b.log --trs-file $$b.trs \ + $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ + "$$tst" $(AM_TESTS_FD_REDIRECT) +enter.log: enter + @p='enter'; \ + b='enter'; \ + $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ + --log-file $$b.log --trs-file $$b.trs \ + $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ + "$$tst" $(AM_TESTS_FD_REDIRECT) +enter3.log: enter3 + @p='enter3'; \ + b='enter3'; \ + $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ + --log-file $$b.log --trs-file $$b.trs \ + $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ + "$$tst" $(AM_TESTS_FD_REDIRECT) +processor.log: processor + @p='processor'; \ + b='processor'; \ + $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ + --log-file $$b.log --trs-file $$b.trs \ + $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ + "$$tst" $(AM_TESTS_FD_REDIRECT) +stack.log: stack + @p='stack'; \ + b='stack'; \ + $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ + --log-file $$b.log --trs-file $$b.trs \ + $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ + "$$tst" $(AM_TESTS_FD_REDIRECT) +wait.log: wait + @p='wait'; \ + b='wait'; \ + $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ + --log-file $$b.log --trs-file $$b.trs \ + $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ + "$$tst" $(AM_TESTS_FD_REDIRECT) +yield.log: yield + @p='yield'; \ + b='yield'; \ + $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ + --log-file $$b.log --trs-file $$b.trs \ + $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ + "$$tst" $(AM_TESTS_FD_REDIRECT) +.test.log: + @p='$<'; \ + $(am__set_b); \ + $(am__check_pre) $(TEST_LOG_DRIVER) --test-name "$$f" \ + --log-file $$b.log --trs-file $$b.trs \ + $(am__common_driver_flags) $(AM_TEST_LOG_DRIVER_FLAGS) $(TEST_LOG_DRIVER_FLAGS) -- $(TEST_LOG_COMPILE) \ + "$$tst" $(AM_TESTS_FD_REDIRECT) +@am__EXEEXT_TRUE@.test$(EXEEXT).log: +@am__EXEEXT_TRUE@ @p='$<'; \ +@am__EXEEXT_TRUE@ $(am__set_b); \ +@am__EXEEXT_TRUE@ $(am__check_pre) $(TEST_LOG_DRIVER) --test-name "$$f" \ +@am__EXEEXT_TRUE@ --log-file $$b.log --trs-file $$b.trs \ +@am__EXEEXT_TRUE@ $(am__common_driver_flags) $(AM_TEST_LOG_DRIVER_FLAGS) $(TEST_LOG_DRIVER_FLAGS) -- $(TEST_LOG_COMPILE) \ +@am__EXEEXT_TRUE@ "$$tst" $(AM_TESTS_FD_REDIRECT) + +distdir: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done +check-am: all-am + $(MAKE) $(AM_MAKEFLAGS) check-TESTS +check: check-am +all-am: Makefile all-local +installdirs: +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + if test -z '$(STRIP)'; then \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + install; \ + else \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ + fi +mostlyclean-generic: + -test -z "$(TEST_LOGS)" || rm -f $(TEST_LOGS) + -test -z "$(TEST_LOGS:.log=.trs)" || rm -f $(TEST_LOGS:.log=.trs) + -test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG) + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-generic clean-libtool clean-local mostlyclean-am + +distclean: distclean-am + -rm -f Makefile +distclean-am: clean-am distclean-generic + +dvi: dvi-am + +dvi-am: + +html: html-am + +html-am: + +info: info-am + +info-am: + +install-data-am: + +install-dvi: install-dvi-am + +install-dvi-am: + +install-exec-am: + +install-html: install-html-am + +install-html-am: + +install-info: install-info-am + +install-info-am: + +install-man: + +install-pdf: install-pdf-am + +install-pdf-am: + +install-ps: install-ps-am + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-generic mostlyclean-libtool + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: + +.MAKE: check-am install-am install-strip + +.PHONY: all all-am all-local check check-TESTS check-am clean \ + clean-generic clean-libtool clean-local cscopelist-am ctags-am \ + distclean distclean-generic distclean-libtool distdir dvi \ + dvi-am html html-am info info-am install install-am \ + install-data install-data-am install-dvi install-dvi-am \ + install-exec install-exec-am install-html install-html-am \ + install-info install-info-am install-man install-pdf \ + install-pdf-am install-ps install-ps-am install-strip \ + installcheck installcheck-am installdirs maintainer-clean \ + maintainer-clean-generic mostlyclean mostlyclean-generic \ + mostlyclean-libtool pdf pdf-am ps ps-am recheck tags-am \ + uninstall uninstall-am + +.PRECIOUS: Makefile + + +.cfa.o: + $(AM_V_CFA)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\ + $(CFACOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ + $(am__mv) $$depbase.Tpo $$depbase.Po + +.cfa.lo: + $(AM_V_CFA)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\ + $(LTCFACOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ + $(am__mv) $$depbase.Tpo $$depbase.Plo + +# .INTERMEDIATE: $(TESTS) + +all-local: $(TESTS:=.run) + +runall : $(TESTS:=.run) + @ echo "All programs terminated normally" + +watchall : $(TESTS:=.watch) + @ echo "All programs terminated normally" + +compileall : $(TESTS) + @ echo "Compiled" + +clean-local: + rm -f $(TESTS) core* out.log .type + +% : %.cfa $(CFACC) $(UPDATED_TYPE) + $(AM_V_CFA)$(CFACOMPILE) $(<) $(debug) -o $(@) + +%.run : % $(REPEAT) + @ time $(REPEAT) -r out.log -i -s $(repeats) timeout $(max_time) ./$(<) + @ rm $(<) + @ echo -e "$(<): SUCCESS\n" + +%.watch : % $(WATCHDOG) + @ time $(WATCHDOG} ./$(<) + @ rm $(<) + @ echo -e "$(<): SUCCESS\n" + +%.time : % $(REPEAT) + @ $(REPEAT) -i -s -- $(repeats) $(TIME) -a -o times.log ./$(<) + @ rm $(<) + @ echo -e "$(<): SUCCESS\n" + +$(REPEAT): $(abs_top_builddir)/tools/Makefile + @+make -C $(abs_top_builddir)/tools/ + +$(WATCHDOG): $(abs_top_builddir)/tools/Makefile + @+make -C $(abs_top_builddir)/tools/ + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: Index: longrun_tests/block.cfa =================================================================== --- longrun_tests/block.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ longrun_tests/block.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,1 @@ +../tests/concurrent/signal/block.cfa Index: longrun_tests/coroutine.cfa =================================================================== --- longrun_tests/coroutine.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ longrun_tests/coroutine.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,1 @@ +../tests/concurrent/coroutineYield.cfa Index: longrun_tests/create.cfa =================================================================== --- longrun_tests/create.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ longrun_tests/create.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,27 @@ +#include +#include +#include + +#include "long_tests.hfa" + +#ifndef PREEMPTION_RATE +#error PREEMPTION_RATE not defined in makefile +#endif + +Duration default_preemption() { + return PREEMPTION_RATE; +} + +static const unsigned long N = 60_000ul; + +thread worker_t {}; + +void main(worker_t & this) {} + +int main(int argc, char* argv[]) { + processor p; + for(int i = 0; TEST(i < N); i++) { + worker_t w[7]; + KICK_WATCHDOG; + } +} Index: longrun_tests/disjoint.cfa =================================================================== --- longrun_tests/disjoint.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ longrun_tests/disjoint.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,1 @@ +../tests/concurrent/signal/disjoint.cfa Index: longrun_tests/enter.cfa =================================================================== --- longrun_tests/enter.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ longrun_tests/enter.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,37 @@ +#include +#include +#include +#include + +#define __kick_rate 75000ul +#include "long_tests.hfa" + +#ifndef PREEMPTION_RATE +#error PREEMPTION_RATE not defined in makefile +#endif + +Duration default_preemption() { + return PREEMPTION_RATE; +} + +static const unsigned long N = 2_100_000ul; + +monitor mon_t {}; +void foo( mon_t & mutex this ) { + KICK_WATCHDOG; +} + +mon_t mon; +thread worker_t {}; +void main( worker_t & this ) { + for( unsigned long i = 0; TEST(i < N); i++ ) { + foo( mon ); + } +} + +int main(int argc, char * argv[] ) { + processor p; + { + worker_t w[7]; + } +} Index: longrun_tests/enter3.cfa =================================================================== --- longrun_tests/enter3.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ longrun_tests/enter3.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,45 @@ +#include +#include +#include +#include + +#define __kick_rate 75000ul +#include "long_tests.hfa" + +#ifndef PREEMPTION_RATE +#error PREEMPTION_RATE not defined in makefile +#endif + +Duration default_preemption() { + return PREEMPTION_RATE; +} + +static const unsigned long N = 500_000ul; + +monitor mon_t {}; + +mon_t mon1, mon2, mon3; + +void foo( mon_t & mutex a, mon_t & mutex b, mon_t & mutex c ) { + KICK_WATCHDOG; +} + +thread worker_t {}; + +void main( worker_t & this ) { + for( unsigned long i = 0; TEST(i < N); i++ ) { + foo( mon1, mon2, mon3 ); + } +} + +extern "C" { +static worker_t * workers; +} + +int main(int argc, char * argv[] ) { + processor p; + { + worker_t w[7]; + workers = w; + } +} Index: longrun_tests/preempt.cfa =================================================================== --- longrun_tests/preempt.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ longrun_tests/preempt.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,1 @@ +../tests/concurrent/preempt.cfa Index: longrun_tests/processor.cfa =================================================================== --- longrun_tests/processor.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ longrun_tests/processor.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,33 @@ +#include +#include +#include + +#include + +#include "long_tests.hfa" + +#ifndef PREEMPTION_RATE +#error PREEMPTION_RATE not defined in makefile +#endif + +Duration default_preemption() { + return PREEMPTION_RATE; +} + +static const unsigned long N = 50_000ul; + +int main(int argc, char* argv[]) { + processor * p[15]; + for ( int pi = 0; pi < 15; pi++ ) { + p[pi] = new(); + } + for ( int i = 0; TEST(i < N); i++) { + int pi = i % 15; + delete( p[pi] ); + p[pi] = new(); + KICK_WATCHDOG; + } + for ( int pi = 0; pi < 15; pi++ ) { + delete( p[pi] ); + } +} Index: longrun_tests/stack.cfa =================================================================== --- longrun_tests/stack.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ longrun_tests/stack.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,46 @@ +#include +#include +#include +#include + +#define __kick_rate 5000000ul +#include "long_tests.hfa" + +#ifndef PREEMPTION_RATE +#error PREEMPTION_RATE not defined in makefile +#endif + +Duration default_preemption() { + return PREEMPTION_RATE; +} + +thread worker_t {}; + +void main(worker_t & this) { + while(TEST(0)) { + volatile long long p = 5_021_609ul; + volatile long long a = 326_417ul; + volatile long long n = 1l; + for (volatile long long i = 0; i < p; i++) { + n *= a; + n %= p; + KICK_WATCHDOG; + } + + if( !TEST(n == a) ) { + abort(); + } + } +} + +extern "C" { +static worker_t * workers; +} + +int main(int argc, char* argv[]) { + processor p; + { + worker_t w[7]; + workers = w; + } +} Index: longrun_tests/update-type =================================================================== --- longrun_tests/update-type (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ longrun_tests/update-type (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,25 @@ +#!/bin/bash + +if [ "$#" -ne 1 ] +then + echo "illegal number of parameters, must be 1 was $#" + exit +fi + +NEW="$(echo $1 | tr a-z A-Z)" +TYPE_FILE=".type" +if [ -f "$TYPE_FILE" ] +then + OLD="$(cat $TYPE_FILE | tr a-z A-Z)" + if [ $OLD == $NEW ] + then + echo > /dev/null + # echo "$TYPE_FILE stayed unchanged" + else + echo "$NEW" > "$TYPE_FILE" + # echo "$TYPE_FILE changed from '$OLD' to '$NEW'" + fi +else + echo "$NEW" > "$TYPE_FILE" +fi +echo "$TYPE_FILE" Index: longrun_tests/wait.cfa =================================================================== --- longrun_tests/wait.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ longrun_tests/wait.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,1 @@ +../tests/concurrent/signal/wait.cfa Index: longrun_tests/yield.cfa =================================================================== --- longrun_tests/yield.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ longrun_tests/yield.cfa (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,41 @@ +#include +#include +#include + +#define __kick_rate 550000ul +#include "long_tests.hfa" + +#ifndef PREEMPTION_RATE +#error PREEMPTION_RATE not defined in makefile +#endif + +Duration default_preemption() { + return PREEMPTION_RATE; +} + +#ifdef TEST_LONG +static const unsigned long N = 9_750_000ul; +#else +static const unsigned long N = 325_000ul; +#endif + +thread worker_t {}; + +void main(worker_t & this) { + for(int i = 0; TEST(i < N); i++) { + yield(); + KICK_WATCHDOG; + } +} + +extern "C" { +static worker_t * workers; +} + +int main(int argc, char* argv[]) { + processor p; + { + worker_t w[7]; + workers = w; + } +} Index: src/Common/PassVisitor.cc =================================================================== --- src/Common/PassVisitor.cc (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ src/Common/PassVisitor.cc (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -17,2 +17,3 @@ PassVisitorStats pass_visitor_stats; +Stats::Counters::SimpleCounter* BaseSyntaxNode::new_nodes = nullptr; Index: src/Common/PersistentMap.h =================================================================== --- src/Common/PersistentMap.h (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) +++ src/Common/PersistentMap.h (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -0,0 +1,292 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// PersistentMap.h -- +// +// Author : Aaron B. Moss +// Created On : Thu Mar 7 15:50:00 2019 +// Last Modified By : Aaron B. Moss +// Last Modified On : Thu Mar 7 15:50:00 2019 +// Update Count : 1 +// + +#pragma once + +#include // for assertf +#include // for size_t +#include // for hash, equal_to +#include // for shared_ptr, enable_shared_from_this, make_shared +#include // for unordered_map +#include // for forward, move + +/// Wraps a hash table in a persistent data structure, using a technique based +/// on the persistent array in Conchon & Filliatre "A Persistent Union-Find +/// Data Structure" + +template, typename Eq = std::equal_to> +class PersistentMap + : public std::enable_shared_from_this> { +public: + /// Type of this class + using Self = PersistentMap; + /// Type of pointer to this class + using Ptr = std::shared_ptr; + + /// Types of version nodes + enum Mode { + BASE, ///< Root node of version tree + REM, ///< Key removal node + INS, ///< Key update node + UPD ///< Key update node + }; + +private: + using Base = std::unordered_map; + + /// Insertion/update node + struct Ins { + Ptr base; ///< Modified map + Key key; ///< Key inserted + Val val; ///< Value stored + + template + Ins(P&& p, K&& k, V&& v) + : base(std::forward

(p)), key(std::forward(k)), val(std::forward(v)) {} + }; + + /// Removal node + struct Rem { + Ptr base; ///< Modified map + Key key; ///< Key removed + + template + Rem(P&& p, K&& k) : base(std::forward

(p)), key(std::forward(k)) {} + }; + + /// Underlying storage + union Data { + char def; + Base base; + Ins ins; + Rem rem; + + Data() : def('\0') {} + ~Data() {} + } data; + + /// Type of node + mutable Mode mode; + + /// get mutable reference as T + template + T& as() { return reinterpret_cast(data); } + + /// get const reference as T + template + const T& as() const { return reinterpret_cast(data); } + + /// get rvalue reference as T + template + T&& take_as() { return std::move(as()); } + + /// initialize as T + template + void init( Args&&... args ) { + new( &as() ) T { std::forward(args)... }; + } + + /// reset as current mode + void reset() { + switch( mode ) { + case BASE: as().~Base(); break; + case REM: as().~Rem(); break; + case INS: case UPD: as().~Ins(); break; + } + } + + /// reset as base + void reset_as_base() { + as().~Base(); + } + +public: + using key_type = typename Base::key_type; + using mapped_type = typename Base::mapped_type; + using value_type = typename Base::value_type; + using size_type = typename Base::size_type; + using difference_type = typename Base::difference_type; + using iterator = typename Base::const_iterator; + + PersistentMap() : data(), mode(BASE) { init(); } + + PersistentMap( Base&& b ) : data(), mode(BASE) { init(std::move(b)); } + + PersistentMap( const Self& o ) = delete; + + Self& operator= ( const Self& o ) = delete; + + ~PersistentMap() { reset(); } + + /// Create a pointer to a new, empty persistent map + static Ptr new_ptr() { return std::make_shared(); } + + /// reroot persistent map at current node + void reroot() const { + // recursive base case + if ( mode == BASE ) return; + + // reroot base + Self* mut_this = const_cast(this); + Ptr base = ( mode == REM ) ? mut_this->as().base : mut_this->as().base; + base->reroot(); + + // remove map from base + Base base_map = base->template take_as(); + base->reset_as_base(); + + // switch base to inverse of self and mutate base map + switch ( mode ) { + case REM: { + Rem& self = mut_this->as(); + auto it = base_map.find( self.key ); + + base->template init( + mut_this->shared_from_this(), std::move(self.key), std::move(it->second) ); + base->mode = INS; + + base_map.erase( it ); + break; + } + case INS: { + Ins& self = mut_this->as(); + + base->template init( mut_this->shared_from_this(), self.key ); + base->mode = REM; + + base_map.emplace( std::move(self.key), std::move(self.val) ); + break; + } + case UPD: { + Ins& self = mut_this->as(); + auto it = base_map.find( self.key ); + + base->template init( + mut_this->shared_from_this(), std::move(self.key), std::move(it->second) ); + base->mode = UPD; + + it->second = std::move(self.val); + break; + } + case BASE: assertf(false, "unreachable"); break; + } + + // set base map into self + mut_this->reset(); + mut_this->init( std::move(base_map) ); + mode = BASE; + } + +private: + /// the base after rerooting at the current node + const Base& rerooted() const { + reroot(); + return as(); + } + +public: + /// true iff the map is empty + bool empty() const { return rerooted().empty(); } + + /// number of entries in map + size_type size() const { return rerooted().size(); } + + /// begin iterator for map; may be invalidated by calls to non-iteration functions + /// or functions on other maps in the same tree + iterator begin() const { return rerooted().begin(); } + + /// end iterator for map; may be invalidated by calls to non-iteration functions + /// or functions on other maps in the same tree + iterator end() const { return rerooted().end(); } + + /// underlying map iterator for value + iterator find(const Key& k) const { return rerooted().find( k ); } + + /// check if value is present + size_type count(const Key& k) const { return rerooted().count( k ); } + + /// get value; undefined behaviour if not present + const Val& get(const Key& k) const { + const Base& self = rerooted(); + auto it = self.find( k ); + return it->second; + } + + /// get value; returns default if not present + template + Val get_or_default(const Key& k, V&& d) const { + const Base& self = rerooted(); + auto it = self.find( k ); + if ( it == self.end() ) return d; + else return it->second; + } + + /// set value, storing new map in output variable + template + Ptr set(K&& k, V&& v) { + reroot(); + + // transfer map to new node + Ptr ret = std::make_shared( take_as() ); + reset_as_base(); + Base& base_map = ret->template as(); + + // check if this is update or insert + auto it = base_map.find( k ); + if ( it == base_map.end() ) { + // set self to REM node and insert into base + init( ret, k ); + mode = REM; + + base_map.emplace_hint( it, std::forward(k), std::forward(v) ); + } else { + // set self to UPD node and modify base + init( ret, std::forward(k), std::move(it->second) ); + mode = UPD; + + it->second = std::forward(v); + } + + return ret; + } + + /// remove value, storing new map in output variable; does nothing if key not in map + Ptr erase(const Key& k) { + reroot(); + + // exit early if key does not exist in map + if ( ! as().count( k ) ) return this->shared_from_this(); + + // transfer map to new node + Ptr ret = std::make_shared( take_as() ); + reset_as_base(); + Base& base_map = ret->template as(); + + // set self to INS node and remove from base + init( ret, k, base_map[k] ); + mode = INS; + + base_map.erase( k ); + + return ret; + } +}; + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/Common/Stats/Counter.h =================================================================== --- src/Common/Stats/Counter.h (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ src/Common/Stats/Counter.h (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -37,4 +37,5 @@ class SimpleCounter { public: + inline void operator++() {} inline void operator++(int) {} inline void operator+=(size_t) {} @@ -84,4 +85,5 @@ virtual void print(std::ostream & os) override { os << count; } + inline void operator++() { if(!enabled) return; count++; } inline void operator++(int) { if(!enabled) return; count++; } inline void operator+=(size_t value) { if(!enabled) return; count += value; } Index: src/ControlStruct/ForExprMutator.cc =================================================================== --- src/ControlStruct/ForExprMutator.cc (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ src/ControlStruct/ForExprMutator.cc (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -9,7 +9,7 @@ // Author : Rodolfo G. Esteves // Created On : Mon May 18 07:44:20 2015 -// Last Modified By : Andrew Beach -// Last Modified On : Fri Aug 18 10:22:00 2017 -// Update Count : 12 +// Last Modified By : Peter A. Buhr +// Last Modified On : Mon Mar 11 22:26:52 2019 +// Update Count : 14 // @@ -21,5 +21,5 @@ namespace ControlStruct { - Statement *hoist( Statement *originalStmt, std::list &init ) { + Statement * hoist( Statement * originalStmt, std::list & init ) { // If no hoisting is needed, skip: if ( 0 == init.size() ) { @@ -29,6 +29,6 @@ // Create compound statement, move initializers outside, // the resut of the original stays as is. - CompoundStmt *block = new CompoundStmt(); - std::list &stmts = block->get_kids(); + CompoundStmt * block = new CompoundStmt(); + std::list & stmts = block->get_kids(); stmts.splice( stmts.end(), init ); @@ -38,12 +38,12 @@ } - Statement *ForExprMutator::postmutate( IfStmt *ifStmt ) { + Statement * ForExprMutator::postmutate( IfStmt * ifStmt ) { return hoist( ifStmt, ifStmt->initialization ); } - Statement *ForExprMutator::postmutate( ForStmt *forStmt ) { + Statement * ForExprMutator::postmutate( ForStmt * forStmt ) { // hoist any initializer declarations to make them C89 (rather than C99) return hoist( forStmt, forStmt->initialization ); } - Statement *ForExprMutator::postmutate( WhileStmt *whileStmt ) { + Statement * ForExprMutator::postmutate( WhileStmt * whileStmt ) { return hoist( whileStmt, whileStmt->initialization ); } Index: src/ControlStruct/LabelFixer.cc =================================================================== --- src/ControlStruct/LabelFixer.cc (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ src/ControlStruct/LabelFixer.cc (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -9,7 +9,7 @@ // Author : Rodolfo G. Esteves // Created On : Mon May 18 07:44:20 2015 -// Last Modified By : Rob Schluntz -// Last Modified On : Tue Jul 28 13:32:43 2015 -// Update Count : 156 +// Last Modified By : Peter A. Buhr +// Last Modified On : Mon Mar 11 22:26:02 2019 +// Update Count : 159 // @@ -32,5 +32,5 @@ } - LabelFixer::LabelFixer( LabelGenerator *gen ) : generator ( gen ) { + LabelFixer::LabelFixer( LabelGenerator * gen ) : generator ( gen ) { if ( generator == 0 ) generator = LabelGenerator::getGenerator(); @@ -49,5 +49,5 @@ // prune to at most one label definition for each statement - void LabelFixer::previsit( Statement *stmt ) { + void LabelFixer::previsit( Statement * stmt ) { std::list< Label > &labels = stmt->get_labels(); @@ -58,5 +58,5 @@ } - void LabelFixer::previsit( BranchStmt *branchStmt ) { + void LabelFixer::previsit( BranchStmt * branchStmt ) { previsit( ( Statement *)branchStmt ); @@ -75,7 +75,7 @@ - // sets the definition of the labelTable entry to be the provided - // statement for every label in the list parameter. Happens for every kind of statement - Label LabelFixer::setLabelsDef( std::list< Label > &llabel, Statement *definition ) { + // sets the definition of the labelTable entry to be the provided statement for every label in the list + // parameter. Happens for every kind of statement + Label LabelFixer::setLabelsDef( std::list< Label > & llabel, Statement * definition ) { assert( definition != 0 ); assert( llabel.size() > 0 ); @@ -100,6 +100,5 @@ } // for - // produce one of the labels attached to this statement to be - // temporarily used as the canonical label + // produce one of the labels attached to this statement to be temporarily used as the canonical label return labelTable[ llabel.front() ]->get_label(); } @@ -117,5 +116,5 @@ // Builds a table that maps a label to its defining statement. - std::map *LabelFixer::resolveJumps() throw ( SemanticErrorException ) { + std::map * LabelFixer::resolveJumps() throw ( SemanticErrorException ) { std::map< Label, Statement * > *ret = new std::map< Label, Statement * >(); for ( std::map< Label, Entry * >::iterator i = labelTable.begin(); i != labelTable.end(); ++i ) { Index: src/ControlStruct/LabelGenerator.cc =================================================================== --- src/ControlStruct/LabelGenerator.cc (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ src/ControlStruct/LabelGenerator.cc (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -9,7 +9,7 @@ // Author : Rodolfo G. Esteves // Created On : Mon May 18 07:44:20 2015 -// Last Modified By : Andrew Beach -// Last Modified On : Thr Aug 14 14:14:00 2015 -// Update Count : 14 +// Last Modified By : Peter A. Buhr +// Last Modified On : Mon Mar 11 22:23:20 2019 +// Update Count : 15 // @@ -24,10 +24,9 @@ namespace ControlStruct { - LabelGenerator *LabelGenerator::labelGenerator = 0; + LabelGenerator * LabelGenerator::labelGenerator = 0; - LabelGenerator *LabelGenerator::getGenerator() { + LabelGenerator * LabelGenerator::getGenerator() { if ( LabelGenerator::labelGenerator == 0 ) LabelGenerator::labelGenerator = new LabelGenerator(); - return labelGenerator; } @@ -38,5 +37,5 @@ if ( stmt && ! stmt->get_labels().empty() ) { os << "_" << stmt->get_labels().front() << "__"; - } + } // if std::string ret = os.str(); Label l( ret ); Index: src/Parser/ParseNode.h =================================================================== --- src/Parser/ParseNode.h (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ src/Parser/ParseNode.h (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:28:16 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Feb 13 17:36:49 2019 -// Update Count : 867 +// Last Modified On : Mon Apr 15 14:22:39 2019 +// Update Count : 874 // @@ -132,12 +132,12 @@ void printOneLine( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const {} - Expression *get_expr() const { return expr.get(); } template bool isExpressionType() const { return nullptr != dynamic_cast(expr.get()); } Expression * build() const { return const_cast(this)->expr.release(); } + + std::unique_ptr expr; // public because of lifetime implications private: bool extension = false; - std::unique_ptr expr; }; // ExpressionNode Index: src/Parser/lex.ll =================================================================== --- src/Parser/lex.ll (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ src/Parser/lex.ll (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -10,6 +10,6 @@ * Created On : Sat Sep 22 08:58:10 2001 * Last Modified By : Peter A. Buhr - * Last Modified On : Sun Mar 10 09:13:09 2019 - * Update Count : 706 + * Last Modified On : Wed Mar 13 14:54:30 2019 + * Update Count : 707 */ @@ -226,4 +226,5 @@ char { KEYWORD_RETURN(CHAR); } choose { KEYWORD_RETURN(CHOOSE); } // CFA +coerce { KEYWORD_RETURN(COERCE); } // CFA _Complex { KEYWORD_RETURN(COMPLEX); } // C99 __complex { KEYWORD_RETURN(COMPLEX); } // GCC Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision 69c37ccfbd57ffcac000650a919c9708faf8c701) +++ src/Parser/parser.yy (revision f343c6b9c8b5f408f8025426215c2bc3b3ba5ede) @@ -10,6 +10,6 @@ // Created On : Sat Sep 1 20:22:55 2001 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Feb 21 08:45:07 2019 -// Update Count : 4232 +// Last Modified On : Mon Apr 15 15:02:56 2019 +// Update Count : 4290 // @@ -185,5 +185,5 @@ ForCtrl * forCtrl( ExpressionNode * type, string * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) { - ConstantExpr * constant = dynamic_cast(type->get_expr()); + ConstantExpr * constant = dynamic_cast(type->expr.get()); if ( constant && (constant->get_constant()->get_value() == "0" || constant->get_constant()->get_value() == "1") ) { type = new ExpressionNode( new CastExpr( maybeMoveBuild< Expression >(type), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) ) ); @@ -198,7 +198,7 @@ ForCtrl * forCtrl( ExpressionNode * type, ExpressionNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) { - if ( NameExpr * identifier = dynamic_cast(index->get_expr()) ) { + if ( NameExpr * identifier = dynamic_cast(index->expr.get()) ) { return forCtrl( type, new string( identifier->name ), start, compop, comp, inc ); - } else if ( CommaExpr * commaExpr = dynamic_cast(index->get_expr()) ) { + } else if ( CommaExpr * commaExpr = dynamic_cast(index->expr.get()) ) { if ( NameExpr * identifier = dynamic_cast(commaExpr->arg1 ) ) { return forCtrl( type, new string( identifier->name ), start, compop, comp, inc ); @@ -265,5 +265,5 @@ %token RESTRICT // C99 %token ATOMIC // C11 -%token FORALL MUTEX VIRTUAL // CFA +%token FORALL MUTEX VIRTUAL COERCE // CFA %token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED %token BOOL COMPLEX IMAGINARY // C99 @@ -334,10 +334,10 @@ %type subrange %type asm_name_opt -%type asm_operands_opt asm_operands_list asm_operand +%type asm_operands_opt asm_operands_list asm_operand %type