Changeset f2e40a9f


Ignore:
Timestamp:
Mar 15, 2017, 9:43:15 PM (5 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
27fed7f1, 738e304
Parents:
bf4ac09 (diff), 9b443c7f (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
git-author:
Peter A. Buhr <pabuhr@…> (03/15/17 21:25:49)
git-committer:
Peter A. Buhr <pabuhr@…> (03/15/17 21:43:15)
Message:

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

Files:
32 edited
4 moved

Legend:

Unmodified
Added
Removed
  • Jenkins/FullBuild

    rbf4ac09 rf2e40a9f  
    2020
    2121                                        parallel (
    22                                                 gcc_6_x64: { trigger_build( 'gcc-6',   'x64' ) },
    23                                                 gcc_6_x86: { trigger_build( 'gcc-6',   'x86' ) },
    24                                                 gcc_5_x64: { trigger_build( 'gcc-5',   'x64' ) },
    25                                                 gcc_5_x86: { trigger_build( 'gcc-5',   'x86' ) },
    26                                                 gcc_4_x64: { trigger_build( 'gcc-4.9', 'x64' ) },
    27                                                 gcc_4_x86: { trigger_build( 'gcc-4.9', 'x86' ) },
    28                                                 clang_x64: { trigger_build( 'clang',   'x64' ) },
    29                                                 clang_x86: { trigger_build( 'clang',   'x86' ) },
     22                                                gcc_6_x64: { trigger_build( 'gcc-6',   'x64', true ) },
     23                                                gcc_6_x86: { trigger_build( 'gcc-6',   'x86', true ) },
     24                                                gcc_5_x64: { trigger_build( 'gcc-5',   'x64', false ) },
     25                                                gcc_5_x86: { trigger_build( 'gcc-5',   'x86', false ) },
     26                                                gcc_4_x64: { trigger_build( 'gcc-4.9', 'x64', false ) },
     27                                                gcc_4_x86: { trigger_build( 'gcc-4.9', 'x86', false ) },
     28                                                clang_x64: { trigger_build( 'clang',   'x64', false ) },
     29                                                clang_x86: { trigger_build( 'clang',   'x86', false ) },
    3030                                        )
    3131
     
    6262//===========================================================================================================
    6363
    64 def trigger_build(String cc, String arch) {
     64def trigger_build(String cc, String arch, Boolean publish) {
    6565        def result = build job: 'Cforall/master',               \
    6666                parameters: [                                           \
     
    8282                        [$class: 'BooleanParameterValue',               \
    8383                          name: 'pPublish',                             \
    84                           value: true],                                         \
     84                          value: publish],                                      \
    8585                        [$class: 'BooleanParameterValue',               \
    8686                          name: 'pSilent',                              \
  • Jenkinsfile

    rbf4ac09 rf2e40a9f  
    131131                                [$class: 'BooleanParameterDefinition',                                                  \
    132132                                        description: 'If true, jenkins also builds documentation',              \
    133                                         name: 'pBuildDocumentation',                                                            \
     133                                        name: 'pBuildDocumentation',                                                    \
    134134                                        defaultValue: true,                                                             \
    135135                                ],                                                                                              \
     
    137137                                        description: 'If true, jenkins also publishes results',                 \
    138138                                        name: 'pPublish',                                                               \
    139                                         defaultValue: true,                                                             \
     139                                        defaultValue: false,                                                            \
    140140                                ],                                                                                              \
    141141                                [$class: 'BooleanParameterDefinition',                                                  \
    142142                                        description: 'If true, jenkins will not send emails',           \
    143                                         name: 'pSilent',                                                \
     143                                        name: 'pSilent',                                                                        \
    144144                                        defaultValue: false,                                                            \
    145145                                ],                                                                                              \
     
    159159        echo """Compiler                : ${compiler.cc_name} (${compiler.cpp_cc}/${compiler.cfa_cc})
    160160Architecture            : ${arch_name}
    161 Arc Flags                       : ${architecture}
     161Arc Flags               : ${architecture}
    162162Run All Tests           : ${ pRunAllTests.toString() }
    163163Run Benchmark           : ${ pRunBenchmark.toString() }
  • doc/proposals/concurrency/thePlan.md

    rbf4ac09 rf2e40a9f  
    77
    88_Phase 2_ : Minimum Viable Product
    9 Monitor type and enter/leave mutex member routines
     9done - Monitor type and enter/leave mutex member routines
    1010Monitors as a language feature (not calling enter/leave by hand)
    1111Internal scheduling
  • doc/proposals/flags.md

    rbf4ac09 rf2e40a9f  
    6969In each of the cases above, `FOO` could be replaced by `(BAR | BAZ)` to do the same operation or test on multiple flags at once.
    7070
     71### Alternative/Additional Features ###
     72
     73#### User-defined enum discriminant iterator ####
     74It may be useful to provide a more general method for changing the enum discriminant assignment function, e.g. the flag enum discriminants could be defined by something like the following:
     75
     76        ```
     77        enum(@ << 1) TCP_Flags {  // each discriminant is left-shifted by 1 from the previous
     78                FIN = 0x1,  // first flag is 1
     79                SYN,
     80                ACK,
     81                ...
     82        }
     83        ```
     84
     85#### Member expression for enums ####
     86As a more ergonomic way to set and unset enum flags, we could define a member expression for flags enums. Since only unions and structs can have member expressions now, this change would be backwards compatible. Basically, given a `FunFlags f`, `f.FOO` would return a proxy object which could be implicitly converted to `bool` (with semantics `f & FOO`, i.e. "check if `FOO` is set on `f`"), as well as having `bool` assigned to it (with semantics `f |= FOO` on true or `f -= FOO` on false, i.e. "set or unset `FOO` on `f` as appropriate"). With this member function, the operations above can be expressed as follows (possibly more ergonomically):
     87
     88        ```
     89        FunFlags f = some_val();
     90        if ( f.FOO ) { sout | "f has FOO set" | endl; }
     91        f.FOO = true;    // set FOO
     92        f.FOO = false;   // unset FOO
     93        f.FOO = ! f.FOO; // toggle FOO
     94        ```
     95
    7196### Related Work ###
    7297C# has the [`[Flags]`][1] enum attribute, but their proposal does not go as far; specifically, the flag discriminants must be manually specified, and they do not automatically implement the bitwise operators on the flags.
  • src/Concurrency/Keywords.cc

    rbf4ac09 rf2e40a9f  
    8888        //Handles mutex routines definitions :
    8989        // void foo( A * mutex a, B * mutex b,  int i ) {                  void foo( A * a, B * b,  int i ) {
    90         //                                                                       monitor_desc * __monitors[] = { a, b };
     90        //                                                                       monitor_desc * __monitors[] = { get_monitor(a), get_monitor(b) };
    9191        //                                                                       monitor_guard_t __guard = { __monitors, 2 };
    9292        //    /*Some code*/                                       =>           /*Some code*/
     
    9898                using Visitor::visit;
    9999                virtual void visit( FunctionDecl *functionDecl ) override final;
     100                virtual void visit(   StructDecl *functionDecl ) override final;
    100101
    101102                std::list<DeclarationWithType*> findMutexArgs( FunctionDecl* );
     
    107108                        acceptAll( translationUnit, impl );
    108109                }
     110
     111          private:
     112                StructDecl* monitor_decl = nullptr;
    109113        };
    110114
     
    133137                if( ! body ) return;
    134138
     139                assert(monitor_decl);
    135140                addStatments( body, mutexArgs );
     141        }
     142
     143        void MutexKeyword::visit(StructDecl* decl) {
     144                if( decl->get_name() == "monitor_desc" ) {
     145                        assert( !monitor_decl );
     146                        monitor_decl = decl;
     147                }
    136148        }
    137149
     
    167179
    168180        void MutexKeyword::addStatments( CompoundStmt * body, const std::list<DeclarationWithType * > & args ) {
     181
     182                ObjectDecl * monitors = new ObjectDecl(
     183                        "__monitors",
     184                        noStorage,
     185                        LinkageSpec::Cforall,
     186                        nullptr,
     187                        new ArrayType(
     188                                noQualifiers,
     189                                new PointerType(
     190                                        noQualifiers,
     191                                        new StructInstType(
     192                                                noQualifiers,
     193                                                monitor_decl
     194                                        )
     195                                ),
     196                                new ConstantExpr( Constant::from_ulong( args.size() ) ),
     197                                false,
     198                                false
     199                        ),
     200                        new ListInit(
     201                                map_range < std::list<Initializer*> > ( args, [](DeclarationWithType * var ){
     202                                        return new SingleInit( new UntypedExpr(
     203                                                new NameExpr( "get_monitor" ),
     204                                                {  new VariableExpr( var ) }
     205                                        ) );
     206                                })
     207                        )
     208                );
     209
    169210                //in reverse order :
    170211                // monitor_guard_t __guard = { __monitors, # };
     
    181222                                new ListInit(
    182223                                        {
    183                                                 new SingleInit( new NameExpr( "__monitors" ) ),
     224                                                new SingleInit( new VariableExpr( monitors ) ),
    184225                                                new SingleInit( new ConstantExpr( Constant::from_ulong( args.size() ) ) )
    185226                                        }
     
    189230
    190231                //monitor_desc * __monitors[] = { a, b };
    191                 body->push_front(
    192                         new DeclStmt( noLabels, new ObjectDecl(
    193                                 "__monitors",
    194                                 noStorage,
    195                                 LinkageSpec::Cforall,
    196                                 nullptr,
    197                                 new ArrayType(
    198                                         noQualifiers,
    199                                         new PointerType(
    200                                                 noQualifiers,
    201                                                 new StructInstType(
    202                                                         noQualifiers,
    203                                                         "monitor_desc"
    204                                                 )
    205                                         ),
    206                                         new ConstantExpr( Constant::from_ulong( args.size() ) ),
    207                                         false,
    208                                         false
    209                                 ),
    210                                 new ListInit(
    211                                         map_range < std::list<Initializer*> > ( args, [](DeclarationWithType * var ){
    212                                                 return new SingleInit( new VariableExpr( var ) );
    213                                         })
    214                                 )
    215                         ))
    216                 );
     232                body->push_front( new DeclStmt( noLabels, monitors) );
    217233        }
    218234};
  • src/GenPoly/Box.cc

    rbf4ac09 rf2e40a9f  
    381381                // calculate struct layout in function body
    382382
    383                 // initialize size and alignment to 0 and 1 (will have at least one member to re-edit size
     383                // initialize size and alignment to 0 and 1 (will have at least one member to re-edit size)
    384384                addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( sizeParam ), new ConstantExpr( Constant( sizeAlignType->clone(), "0" ) ) ) );
    385385                addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( alignParam ), new ConstantExpr( Constant( sizeAlignType->clone(), "1" ) ) ) );
     
    18521852
    18531853                        DeclClass *ret = static_cast< DeclClass *>( Mutator::mutate( decl ) );
    1854                         ScrubTyVars::scrub( decl, scopeTyVars );
     1854                        // ScrubTyVars::scrub( decl, scopeTyVars );
     1855                        ScrubTyVars::scrubAll( decl );
    18551856
    18561857                        scopeTyVars.endScope();
  • src/GenPoly/GenPoly.cc

    rbf4ac09 rf2e40a9f  
    1515
    1616#include "GenPoly.h"
     17#include "assert.h"
    1718
    1819#include "SynTree/Expression.h"
    1920#include "SynTree/Type.h"
     21#include "ResolvExpr/typeops.h"
    2022
    2123#include <iostream>
     24#include <iterator>
     25#include <list>
     26#include <typeindex>
     27#include <typeinfo>
     28#include <vector>
    2229using namespace std;
    2330
     
    3845                        for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
    3946                                TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
    40                                 assert(paramType && "Aggregate parameters should be type expressions");
     47                                assertf(paramType, "Aggregate parameters should be type expressions");
    4148                                if ( isPolyType( paramType->get_type(), tyVars, env ) ) return true;
    4249                        }
     
    4855                        for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
    4956                                TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
    50                                 assert(paramType && "Aggregate parameters should be type expressions");
     57                                assertf(paramType, "Aggregate parameters should be type expressions");
    5158                                if ( isDynType( paramType->get_type(), tyVars, env ) ) return true;
     59                        }
     60                        return false;
     61                }
     62
     63                /// Checks a parameter list for inclusion of polymorphic parameters; will substitute according to env if present
     64                bool includesPolyParams( std::list< Expression* >& params, const TypeSubstitution *env ) {
     65                        for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
     66                                TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
     67                                assertf(paramType, "Aggregate parameters should be type expressions");
     68                                if ( includesPolyType( paramType->get_type(), env ) ) return true;
     69                        }
     70                        return false;
     71                }
     72
     73                /// Checks a parameter list for inclusion of polymorphic parameters from tyVars; will substitute according to env if present
     74                bool includesPolyParams( std::list< Expression* >& params, const TyVarMap &tyVars, const TypeSubstitution *env ) {
     75                        for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
     76                                TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
     77                                assertf(paramType, "Aggregate parameters should be type expressions");
     78                                if ( includesPolyType( paramType->get_type(), tyVars, env ) ) return true;
    5279                        }
    5380                        return false;
     
    187214
    188215                return isPolyType( type, tyVars, env );
     216        }
     217
     218        bool includesPolyType( Type *type, const TypeSubstitution *env ) {
     219                type = replaceTypeInst( type, env );
     220
     221                if ( dynamic_cast< TypeInstType * >( type ) ) {
     222                        return true;
     223                } else if ( PointerType *pointerType = dynamic_cast< PointerType* >( type ) ) {
     224                        if ( includesPolyType( pointerType->get_base(), env ) ) return true;
     225                } else if ( StructInstType *structType = dynamic_cast< StructInstType* >( type ) ) {
     226                        if ( includesPolyParams( structType->get_parameters(), env ) ) return true;
     227                } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( type ) ) {
     228                        if ( includesPolyParams( unionType->get_parameters(), env ) ) return true;
     229                }
     230                return false;
     231        }
     232
     233        bool includesPolyType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env ) {
     234                type = replaceTypeInst( type, env );
     235
     236                if ( TypeInstType *typeInstType = dynamic_cast< TypeInstType * >( type ) ) {
     237                        if ( tyVars.find( typeInstType->get_name() ) != tyVars.end() ) {
     238                                return true;
     239                        }
     240                } else if ( PointerType *pointerType = dynamic_cast< PointerType* >( type ) ) {
     241                        if ( includesPolyType( pointerType->get_base(), tyVars, env ) ) return true;
     242                } else if ( StructInstType *structType = dynamic_cast< StructInstType* >( type ) ) {
     243                        if ( includesPolyParams( structType->get_parameters(), tyVars, env ) ) return true;
     244                } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( type ) ) {
     245                        if ( includesPolyParams( unionType->get_parameters(), tyVars, env ) ) return true;
     246                }
     247                return false;
    189248        }
    190249
     
    237296        }
    238297
     298        namespace {
     299                /// Checks if is a pointer to D
     300                template<typename D, typename B>
     301                bool is( const B* p ) { return type_index{typeid(D)} == type_index{typeid(*p)}; }
     302
     303                /// Converts to a pointer to D without checking for safety
     304                template<typename D, typename B>
     305                inline D* as( B* p ) { return reinterpret_cast<D*>(p); }
     306
     307                /// Flattens a declaration list
     308                template<typename Output>
     309                void flattenList( list< DeclarationWithType* > src, Output out ) {
     310                        for ( DeclarationWithType* decl : src ) {
     311                                ResolvExpr::flatten( decl->get_type(), out );
     312                        }
     313                }
     314
     315                /// Flattens a list of types
     316                template<typename Output>
     317                void flattenList( list< Type* > src, Output out ) {
     318                        for ( Type* ty : src ) {
     319                                ResolvExpr::flatten( ty, out );
     320                        }
     321                }
     322
     323                /// Checks if two lists of parameters are equal up to polymorphic substitution.
     324                bool paramListsPolyCompatible( const list< Expression* >& aparams, const list< Expression* >& bparams ) {
     325                        if ( aparams.size() != bparams.size() ) return false;
     326
     327                        for ( list< Expression* >::const_iterator at = aparams.begin(), bt = bparams.begin();
     328                                        at != aparams.end(); ++at, ++bt ) {
     329                                TypeExpr *aparam = dynamic_cast< TypeExpr* >(*at);
     330                                assertf(aparam, "Aggregate parameters should be type expressions");
     331                                TypeExpr *bparam = dynamic_cast< TypeExpr* >(*bt);
     332                                assertf(bparam, "Aggregate parameters should be type expressions");
     333
     334                                // xxx - might need to let VoidType be a wildcard here too; could have some voids
     335                                // stuffed in for dtype-statics.
     336                                // if ( is<VoidType>( aparam->get_type() ) || is<VoidType>( bparam->get_type() ) ) continue;
     337                                if ( ! typesPolyCompatible( aparam->get_type(), bparam->get_type() ) ) return false;
     338                        }
     339                       
     340                        return true;
     341                }
     342        }
     343
     344        bool typesPolyCompatible( Type *a, Type *b ) {
     345                type_index aid{ typeid(*a) };
     346                // polymorphic types always match
     347                if ( aid == type_index{typeid(TypeInstType)} ) return true;
     348               
     349                type_index bid{ typeid(*b) };
     350                // polymorphic types always match
     351                if ( bid == type_index{typeid(TypeInstType)} ) return true;
     352               
     353                // can't match otherwise if different types
     354                if ( aid != bid ) return false;
     355
     356                // recurse through type structure (conditions borrowed from Unify.cc)
     357                if ( aid == type_index{typeid(BasicType)} ) {
     358                        return as<BasicType>(a)->get_kind() == as<BasicType>(b)->get_kind();
     359                } else if ( aid == type_index{typeid(PointerType)} ) {
     360                        PointerType *ap = as<PointerType>(a), *bp = as<PointerType>(b);
     361
     362                        // void pointers should match any other pointer type
     363                        return is<VoidType>( ap->get_base() ) || is<VoidType>( bp->get_base() )
     364                                || typesPolyCompatible( ap->get_base(), bp->get_base() );
     365                } else if ( aid == type_index{typeid(ArrayType)} ) {
     366                        ArrayType *aa = as<ArrayType>(a), *ba = as<ArrayType>(b);
     367
     368                        if ( aa->get_isVarLen() ) {
     369                                if ( ! ba->get_isVarLen() ) return false;
     370                        } else {
     371                                if ( ba->get_isVarLen() ) return false;
     372
     373                                ConstantExpr *ad = dynamic_cast<ConstantExpr*>( aa->get_dimension() );
     374                                ConstantExpr *bd = dynamic_cast<ConstantExpr*>( ba->get_dimension() );
     375                                if ( ad && bd
     376                                                && ad->get_constant()->get_value() != bd->get_constant()->get_value() )
     377                                        return false;
     378                        }
     379
     380                        return typesPolyCompatible( aa->get_base(), ba->get_base() );
     381                } else if ( aid == type_index{typeid(FunctionType)} ) {
     382                        FunctionType *af = as<FunctionType>(a), *bf = as<FunctionType>(b);
     383
     384                        vector<Type*> aparams, bparams;
     385                        flattenList( af->get_parameters(), back_inserter( aparams ) );
     386                        flattenList( bf->get_parameters(), back_inserter( bparams ) );
     387                        if ( aparams.size() != bparams.size() ) return false;
     388
     389                        vector<Type*> areturns, breturns;
     390                        flattenList( af->get_returnVals(), back_inserter( areturns ) );
     391                        flattenList( bf->get_returnVals(), back_inserter( breturns ) );
     392                        if ( areturns.size() != breturns.size() ) return false;
     393
     394                        for ( unsigned i = 0; i < aparams.size(); ++i ) {
     395                                if ( ! typesPolyCompatible( aparams[i], bparams[i] ) ) return false;
     396                        }
     397                        for ( unsigned i = 0; i < areturns.size(); ++i ) {
     398                                if ( ! typesPolyCompatible( areturns[i], breturns[i] ) ) return false;
     399                        }
     400                        return true;
     401                } else if ( aid == type_index{typeid(StructInstType)} ) {
     402                        StructInstType *aa = as<StructInstType>(a), *ba = as<StructInstType>(b);
     403
     404                        if ( aa->get_name() != ba->get_name() ) return false;
     405                        return paramListsPolyCompatible( aa->get_parameters(), ba->get_parameters() );
     406                } else if ( aid == type_index{typeid(UnionInstType)} ) {
     407                        UnionInstType *aa = as<UnionInstType>(a), *ba = as<UnionInstType>(b);
     408
     409                        if ( aa->get_name() != ba->get_name() ) return false;
     410                        return paramListsPolyCompatible( aa->get_parameters(), ba->get_parameters() );
     411                } else if ( aid == type_index{typeid(EnumInstType)} ) {
     412                        return as<EnumInstType>(a)->get_name() == as<EnumInstType>(b)->get_name();
     413                } else if ( aid == type_index{typeid(TraitInstType)} ) {
     414                        return as<TraitInstType>(a)->get_name() == as<TraitInstType>(b)->get_name();
     415                } else if ( aid == type_index{typeid(TupleType)} ) {
     416                        TupleType *at = as<TupleType>(a), *bt = as<TupleType>(b);
     417
     418                        vector<Type*> atypes, btypes;
     419                        flattenList( at->get_types(), back_inserter( atypes ) );
     420                        flattenList( bt->get_types(), back_inserter( btypes ) );
     421                        if ( atypes.size() != btypes.size() ) return false;
     422
     423                        for ( unsigned i = 0; i < atypes.size(); ++i ) {
     424                                if ( ! typesPolyCompatible( atypes[i], btypes[i] ) ) return false;
     425                        }
     426                        return true;
     427                } else return true; // VoidType, VarArgsType, ZeroType & OneType just need the same type
     428        }
     429
    239430        void addToTyVarMap( TypeDecl * tyVar, TyVarMap &tyVarMap ) {
    240431                tyVarMap[ tyVar->get_name() ] = TypeDecl::Data{ tyVar };
  • src/GenPoly/GenPoly.h

    rbf4ac09 rf2e40a9f  
    6767        Type *hasPolyBase( Type *type, const TyVarMap &tyVars, int *levels = 0, const TypeSubstitution *env = 0 );
    6868
     69        /// true iff this type or some base of this type after dereferencing pointers is either polymorphic or a generic type with at least one
     70        /// polymorphic parameter; will look up substitution in env if provided.
     71        bool includesPolyType( Type *type, const TypeSubstitution *env = 0 );
     72
     73        /// true iff this type or some base of this type after dereferencing pointers is either polymorphic in tyVars, or a generic type with
     74        /// at least one polymorphic parameter in tyVars; will look up substitution in env if provided.
     75        bool includesPolyType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env = 0 );
     76
    6977        /// Returns a pointer to the base FunctionType if ty is the type of a function (or pointer to one), NULL otherwise
    7078        FunctionType *getFunctionType( Type *ty );
     
    7381        /// N will be stored in levels, if provided
    7482        VariableExpr *getBaseVar( Expression *expr, int *levels = 0 );
     83
     84        /// true iff types are structurally identical, where TypeInstType's match any type.
     85        bool typesPolyCompatible( Type *aty, Type *bty );
    7586
    7687        /// Adds the type variable `tyVar` to `tyVarMap`
  • src/GenPoly/InstantiateGeneric.cc

    rbf4ac09 rf2e40a9f  
    1616#include <cassert>
    1717#include <list>
     18#include <unordered_map>
    1819#include <utility>
    1920#include <vector>
    20 #include <unordered_map>
    2121
    2222#include "InstantiateGeneric.h"
     
    2525#include "GenPoly.h"
    2626#include "ScopedSet.h"
     27#include "ScrubTyVars.h"
    2728#include "PolyMutator.h"
    2829
     
    7778                        if ( params.size() != that.params.size() ) return false;
    7879
    79                         SymTab::Indexer dummy;
    8080                        for ( std::list< Type* >::const_iterator it = params.begin(), jt = that.params.begin(); it != params.end(); ++it, ++jt ) {
    81                                 if ( ! ResolvExpr::typesCompatible( *it, *jt, dummy ) ) return false;
     81                                if ( ! typesPolyCompatible( *it, *jt ) ) return false;
    8282                        }
    8383                        return true;
     
    227227                        if ( (*baseParam)->isComplete() ) {
    228228                                // substitute parameter for complete (otype or sized dtype) type
    229                                 int pointerLevels = 0;
    230                                 if ( hasPolyBase( paramType->get_type(), &pointerLevels ) && pointerLevels > 0 ) {
    231                                         // Make a void* with equivalent nesting
    232                                         Type* voidPtr = new VoidType( Type::Qualifiers() );
    233                                         while ( pointerLevels > 0 ) {
    234                                                 // Just about data layout, so qualifiers *shouldn't* matter
    235                                                 voidPtr = new PointerType( Type::Qualifiers(), voidPtr );
    236                                                 --pointerLevels;
    237                                         }
    238                                         out.push_back( new TypeExpr( voidPtr ) );
     229                                if ( isPolyType( paramType->get_type() ) ) {
     230                                        // substitute polymorphic parameter type in to generic type
     231                                        out.push_back( paramType->clone() );
     232                                        gt = genericType::dynamic;
    239233                                } else {
    240                                         // Just clone parameter type
    241                                         out.push_back( paramType->clone() );
     234                                        // normalize possibly dtype-static parameter type
     235                                        out.push_back( new TypeExpr{
     236                                                ScrubTyVars::scrubAll( paramType->get_type()->clone() ) } );
     237                                        gt |= genericType::concrete;
    242238                                }
    243                                 // make the struct concrete or dynamic depending on the parameter
    244                                 gt |= isPolyType( paramType->get_type() ) ? genericType::dynamic : genericType::concrete;
    245239                        } else switch ( (*baseParam)->get_kind() ) {
    246240                                case TypeDecl::Dtype:
     
    372366                                concDecl = new StructDecl( typeNamer.newName( inst->get_name() ) );
    373367                                concDecl->set_body( inst->get_baseStruct()->has_body() );
    374                                 substituteMembers( inst->get_baseStruct()->get_members(), *inst->get_baseParameters(), typeSubs,        concDecl->get_members() );
     368                                substituteMembers( inst->get_baseStruct()->get_members(), *inst->get_baseParameters(), typeSubs, concDecl->get_members() );
    375369                                DeclMutator::addDeclaration( concDecl );
    376370                                insert( inst, typeSubs, concDecl );
  • src/GenPoly/ScrubTyVars.cc

    rbf4ac09 rf2e40a9f  
    2626namespace GenPoly {
    2727        Type * ScrubTyVars::mutate( TypeInstType *typeInst ) {
    28                 TyVarMap::const_iterator tyVar = tyVars.find( typeInst->get_name() );
    29                 if ( tyVar != tyVars.end() ) {
     28                if ( ! tyVars ) {
     29                        if ( typeInst->get_isFtype() ) {
     30                                delete typeInst;
     31                                return new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) );
     32                        } else {
     33                                PointerType *ret = new PointerType( Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) );
     34                                delete typeInst;
     35                                return ret;
     36                        }
     37                }
     38
     39                TyVarMap::const_iterator tyVar = tyVars->find( typeInst->get_name() );
     40                if ( tyVar != tyVars->end() ) {
    3041                        switch ( tyVar->second.kind ) {
    3142                          case TypeDecl::Any:
  • src/GenPoly/ScrubTyVars.h

    rbf4ac09 rf2e40a9f  
    2626namespace GenPoly {
    2727        class ScrubTyVars : public Mutator {
    28           public:
    29                 ScrubTyVars( const TyVarMap &tyVars, bool dynamicOnly = false ): tyVars( tyVars ), dynamicOnly( dynamicOnly ) {}
     28                /// Whether to scrub all type variables from the provided map, dynamic type variables from the provided map, or all type variables
     29                enum ScrubMode { FromMap, DynamicFromMap, All };
    3030
     31                ScrubTyVars() : tyVars(nullptr), mode( All ) {}
     32
     33                ScrubTyVars( const TyVarMap &tyVars, ScrubMode mode = FromMap ): tyVars( &tyVars ), mode( mode ) {}
     34
     35        public:
    3136                /// For all polymorphic types with type variables in `tyVars`, replaces generic types, dtypes, and ftypes with the appropriate void type,
    3237                /// and sizeof/alignof expressions with the proper variable
     
    3843                template< typename SynTreeClass >
    3944                static SynTreeClass *scrubDynamic( SynTreeClass *target, const TyVarMap &tyVars );
     45
     46                /// For all polymorphic types, replaces generic types, dtypes, and ftypes with the appropriate void type,
     47                /// and sizeof/alignof expressions with the proper variable
     48                template< typename SynTreeClass >
     49                static SynTreeClass *scrubAll( SynTreeClass *target );
    4050
    4151                virtual Type* mutate( TypeInstType *typeInst );
     
    4959                /// Returns the type if it should be scrubbed, NULL otherwise.
    5060                Type* shouldScrub( Type *ty ) {
    51                         return dynamicOnly ? isDynType( ty, tyVars ) : isPolyType( ty, tyVars );
    52 //                      if ( ! dynamicOnly ) return isPolyType( ty, tyVars );
    53 //
    54 //                      if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( ty ) ) {
    55 //                              return tyVars.find( typeInst->get_name() ) != tyVars.end() ? ty : 0;
    56 //                      }
    57 //
    58 //                      return isDynType( ty, tyVars );
     61                        switch ( mode ) {
     62                        case FromMap: return isPolyType( ty, *tyVars );
     63                        case DynamicFromMap: return isDynType( ty, *tyVars );
     64                        case All: return isPolyType( ty );
     65                        }
     66                        assert(false); return nullptr; // unreachable
     67                        // return dynamicOnly ? isDynType( ty, tyVars ) : isPolyType( ty, tyVars );
    5968                }
    6069               
     
    6271                Type* mutateAggregateType( Type *ty );
    6372               
    64                 const TyVarMap &tyVars;  ///< Type variables to scrub
    65                 bool dynamicOnly;        ///< only scrub the types with dynamic layout? [false]
     73                const TyVarMap *tyVars;  ///< Type variables to scrub
     74                ScrubMode mode;          ///< which type variables to scrub? [FromMap]
    6675        };
    6776
     
    7483        template< typename SynTreeClass >
    7584        SynTreeClass * ScrubTyVars::scrubDynamic( SynTreeClass *target, const TyVarMap &tyVars ) {
    76                 ScrubTyVars scrubber( tyVars, true );
     85                ScrubTyVars scrubber( tyVars, ScrubTyVars::DynamicFromMap );
     86                return static_cast< SynTreeClass * >( target->acceptMutator( scrubber ) );
     87        }
     88
     89        template< typename SynTreeClass >
     90        SynTreeClass * ScrubTyVars::scrubAll( SynTreeClass *target ) {
     91                ScrubTyVars scrubber;
    7792                return static_cast< SynTreeClass * >( target->acceptMutator( scrubber ) );
    7893        }
  • src/SymTab/Validate.cc

    rbf4ac09 rf2e40a9f  
    1010// Created On       : Sun May 17 21:50:04 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Mar  7 07:51:36 2017
    13 // Update Count     : 349
     12// Last Modified On : Tue Mar 14 23:30:27 2017
     13// Update Count     : 350
    1414//
    1515
     
    323323                        ObjectDecl * obj = dynamic_cast< ObjectDecl * >( *i );
    324324                        assert( obj );
    325                         obj->set_type( new EnumInstType( Type::Qualifiers( true, false, false, false, false, false ), enumDecl->get_name() ) );
     325                        obj->set_type( new EnumInstType( Type::Qualifiers( Type::Const ), enumDecl->get_name() ) );
    326326                } // for
    327327                Parent::visit( enumDecl );
  • src/SynTree/Type.h

    rbf4ac09 rf2e40a9f  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Mar 15 21:23:08 2017
    13 // Update Count     : 84
     12// Last Modified On : Wed Mar 15 21:28:09 2017
     13// Update Count     : 85
    1414//
    1515
     
    2424class Type : public BaseSyntaxNode {
    2525  public:
    26         // struct Qualifiers {
    27         //      Qualifiers(): isConst( false ), isVolatile( false ), isRestrict( false ), isLvalue( false ), isAtomic( false ), isMutex( false ) {}
    28         //      Qualifiers( bool isConst, bool isVolatile, bool isRestrict, bool isLvalue, bool isAtomic, bool isMutex ): isConst( isConst ), isVolatile( isVolatile ), isRestrict( isRestrict ), isLvalue( isLvalue ), isAtomic( isAtomic ), isMutex( isMutex ) {}
    29 
    30         //      Qualifiers &operator&=( const Qualifiers &other );
    31         //      Qualifiers &operator+=( const Qualifiers &other );
    32         //      Qualifiers &operator-=( const Qualifiers &other );
    33         //      Qualifiers operator+( const Type::Qualifiers &other );
    34         //      bool operator==( const Qualifiers &other );
    35         //      bool operator!=( const Qualifiers &other );
    36         //      bool operator<=( const Qualifiers &other );
    37         //      bool operator>=( const Qualifiers &other );
    38         //      bool operator<( const Qualifiers &other );
    39         //      bool operator>( const Qualifiers &other );
    40         //      void print( std::ostream &os, int indent = 0 ) const;
    41 
    42         //      bool isConst;
    43         //      bool isVolatile;
    44         //      bool isRestrict;
    45         //      bool isLvalue;
    46         //      bool isAtomic;
    47         //      bool isMutex;
    48         // };
    49 
    5026        static const char * QualifierNames[];
    5127
     
    10076                        return q;
    10177                }
    102                 void print( std::ostream &os, int indent = 0 ) const {
     78                void print( std::ostream & os, int indent = 0 ) const {
    10379                        if ( (*this).any() ) {                                          // any type qualifiers ?
    10480                                for ( unsigned int i = 0; i < NumTypeQualifier; i += 1 ) {
     
    11187        }; // Qualifiers
    11288
    113         Type( const Qualifiers &tq, const std::list< Attribute * > & attributes );
    114         Type( const Type &other );
     89        Type( const Qualifiers & tq, const std::list< Attribute * > & attributes );
     90        Type( const Type & other );
    11591        virtual ~Type();
    11692
    117         Qualifiers &get_qualifiers() { return tq; }
     93        Qualifiers & get_qualifiers() { return tq; }
    11894        bool get_isConst() { return tq.isConst; }
    11995        bool get_isVolatile() { return tq.isVolatile; }
     
    141117
    142118        virtual Type *clone() const = 0;
    143         virtual void accept( Visitor &v ) = 0;
    144         virtual Type *acceptMutator( Mutator &m ) = 0;
    145         virtual void print( std::ostream &os, int indent = 0 ) const;
     119        virtual void accept( Visitor & v ) = 0;
     120        virtual Type *acceptMutator( Mutator & m ) = 0;
     121        virtual void print( std::ostream & os, int indent = 0 ) const;
    146122  private:
    147123        Qualifiers tq;
     
    154130class VoidType : public Type {
    155131  public:
    156         VoidType( const Type::Qualifiers &tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
     132        VoidType( const Type::Qualifiers & tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    157133
    158134        virtual unsigned size() const { return 0; };
     
    160136
    161137        virtual VoidType *clone() const { return new VoidType( *this ); }
    162         virtual void accept( Visitor &v ) { v.visit( this ); }
    163         virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    164         virtual void print( std::ostream &os, int indent = 0 ) const;
     138        virtual void accept( Visitor & v ) { v.visit( this ); }
     139        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
     140        virtual void print( std::ostream & os, int indent = 0 ) const;
    165141};
    166142
     
    194170        static const char *typeNames[];                                         // string names for basic types, MUST MATCH with Kind
    195171
    196         BasicType( const Type::Qualifiers &tq, Kind bt, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
     172        BasicType( const Type::Qualifiers & tq, Kind bt, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    197173
    198174        Kind get_kind() { return kind; }
     
    200176
    201177        virtual BasicType *clone() const { return new BasicType( *this ); }
    202         virtual void accept( Visitor &v ) { v.visit( this ); }
    203         virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    204         virtual void print( std::ostream &os, int indent = 0 ) const;
     178        virtual void accept( Visitor & v ) { v.visit( this ); }
     179        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
     180        virtual void print( std::ostream & os, int indent = 0 ) const;
    205181
    206182        bool isInteger() const;
     
    211187class PointerType : public Type {
    212188  public:
    213         PointerType( const Type::Qualifiers &tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    214         PointerType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
     189        PointerType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
     190        PointerType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    215191        PointerType( const PointerType& );
    216192        virtual ~PointerType();
     
    226202
    227203        virtual PointerType *clone() const { return new PointerType( *this ); }
    228         virtual void accept( Visitor &v ) { v.visit( this ); }
    229         virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    230         virtual void print( std::ostream &os, int indent = 0 ) const;
     204        virtual void accept( Visitor & v ) { v.visit( this ); }
     205        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
     206        virtual void print( std::ostream & os, int indent = 0 ) const;
    231207  private:
    232208        Type *base;
     
    240216class ArrayType : public Type {
    241217  public:
    242         ArrayType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
     218        ArrayType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    243219        ArrayType( const ArrayType& );
    244220        virtual ~ArrayType();
     
    256232
    257233        virtual ArrayType *clone() const { return new ArrayType( *this ); }
    258         virtual void accept( Visitor &v ) { v.visit( this ); }
    259         virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    260         virtual void print( std::ostream &os, int indent = 0 ) const;
     234        virtual void accept( Visitor & v ) { v.visit( this ); }
     235        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
     236        virtual void print( std::ostream & os, int indent = 0 ) const;
    261237  private:
    262238        Type *base;
     
    268244class FunctionType : public Type {
    269245  public:
    270         FunctionType( const Type::Qualifiers &tq, bool isVarArgs, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
     246        FunctionType( const Type::Qualifiers & tq, bool isVarArgs, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    271247        FunctionType( const FunctionType& );
    272248        virtual ~FunctionType();
     
    279255
    280256        virtual FunctionType *clone() const { return new FunctionType( *this ); }
    281         virtual void accept( Visitor &v ) { v.visit( this ); }
    282         virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    283         virtual void print( std::ostream &os, int indent = 0 ) const;
     257        virtual void accept( Visitor & v ) { v.visit( this ); }
     258        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
     259        virtual void print( std::ostream & os, int indent = 0 ) const;
    284260  private:
    285261        std::list<DeclarationWithType*> returnVals;
     
    295271class ReferenceToType : public Type {
    296272  public:
    297         ReferenceToType( const Type::Qualifiers &tq, const std::string &name, const std::list< Attribute * > & attributes );
    298         ReferenceToType( const ReferenceToType &other );
     273        ReferenceToType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes );
     274        ReferenceToType( const ReferenceToType & other );
    299275        virtual ~ReferenceToType();
    300276
    301         const std::string &get_name() const { return name; }
     277        const std::string & get_name() const { return name; }
    302278        void set_name( std::string newValue ) { name = newValue; }
    303279        std::list< Expression* >& get_parameters() { return parameters; }
     
    306282
    307283        virtual ReferenceToType *clone() const = 0;
    308         virtual void accept( Visitor &v ) = 0;
    309         virtual Type *acceptMutator( Mutator &m ) = 0;
    310         virtual void print( std::ostream &os, int indent = 0 ) const;
     284        virtual void accept( Visitor & v ) = 0;
     285        virtual Type *acceptMutator( Mutator & m ) = 0;
     286        virtual void print( std::ostream & os, int indent = 0 ) const;
    311287  protected:
    312288        virtual std::string typeString() const = 0;
     
    320296        typedef ReferenceToType Parent;
    321297  public:
    322         StructInstType( const Type::Qualifiers &tq, const std::string &name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
    323         StructInstType( const Type::Qualifiers &tq, StructDecl * baseStruct, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
    324         StructInstType( const StructInstType &other ) : Parent( other ), baseStruct( other.baseStruct ) {}
     298        StructInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
     299        StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
     300        StructInstType( const StructInstType & other ) : Parent( other ), baseStruct( other.baseStruct ) {}
    325301
    326302        StructDecl *get_baseStruct() const { return baseStruct; }
     
    334310        /// Looks up the members of this struct named "name" and places them into "foundDecls".
    335311        /// Clones declarations into "foundDecls", caller responsible for freeing
    336         void lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const;
     312        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const;
    337313
    338314        virtual StructInstType *clone() const { return new StructInstType( *this ); }
    339         virtual void accept( Visitor &v ) { v.visit( this ); }
    340         virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    341 
    342         virtual void print( std::ostream &os, int indent = 0 ) const;
     315        virtual void accept( Visitor & v ) { v.visit( this ); }
     316        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
     317
     318        virtual void print( std::ostream & os, int indent = 0 ) const;
    343319  private:
    344320        virtual std::string typeString() const;
     
    352328        typedef ReferenceToType Parent;
    353329  public:
    354         UnionInstType( const Type::Qualifiers &tq, const std::string &name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
    355         UnionInstType( const Type::Qualifiers &tq, UnionDecl * baseUnion, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
    356         UnionInstType( const UnionInstType &other ) : Parent( other ), baseUnion( other.baseUnion ) {}
     330        UnionInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
     331        UnionInstType( const Type::Qualifiers & tq, UnionDecl * baseUnion, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
     332        UnionInstType( const UnionInstType & other ) : Parent( other ), baseUnion( other.baseUnion ) {}
    357333
    358334        UnionDecl *get_baseUnion() const { return baseUnion; }
     
    366342        /// looks up the members of this union named "name" and places them into "foundDecls"
    367343        /// Clones declarations into "foundDecls", caller responsible for freeing
    368         void lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const;
     344        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const;
    369345
    370346        virtual UnionInstType *clone() const { return new UnionInstType( *this ); }
    371         virtual void accept( Visitor &v ) { v.visit( this ); }
    372         virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    373 
    374         virtual void print( std::ostream &os, int indent = 0 ) const;
     347        virtual void accept( Visitor & v ) { v.visit( this ); }
     348        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
     349
     350        virtual void print( std::ostream & os, int indent = 0 ) const;
    375351  private:
    376352        virtual std::string typeString() const;
     
    384360        typedef ReferenceToType Parent;
    385361  public:
    386         EnumInstType( const Type::Qualifiers &tq, const std::string &name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
    387         EnumInstType( const Type::Qualifiers &tq, EnumDecl * baseEnum, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
    388         EnumInstType( const EnumInstType &other ) : Parent( other ), baseEnum( other.baseEnum ) {}
     362        EnumInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
     363        EnumInstType( const Type::Qualifiers & tq, EnumDecl * baseEnum, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
     364        EnumInstType( const EnumInstType & other ) : Parent( other ), baseEnum( other.baseEnum ) {}
    389365
    390366        EnumDecl *get_baseEnum() const { return baseEnum; }
     
    394370
    395371        virtual EnumInstType *clone() const { return new EnumInstType( *this ); }
    396         virtual void accept( Visitor &v ) { v.visit( this ); }
    397         virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     372        virtual void accept( Visitor & v ) { v.visit( this ); }
     373        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
    398374  private:
    399375        virtual std::string typeString() const;
     
    407383        typedef ReferenceToType Parent;
    408384  public:
    409         TraitInstType( const Type::Qualifiers &tq, const std::string &name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
    410         TraitInstType( const TraitInstType &other );
     385        TraitInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
     386        TraitInstType( const TraitInstType & other );
    411387        ~TraitInstType();
    412388
     
    416392
    417393        virtual TraitInstType *clone() const { return new TraitInstType( *this ); }
    418         virtual void accept( Visitor &v ) { v.visit( this ); }
    419         virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     394        virtual void accept( Visitor & v ) { v.visit( this ); }
     395        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
    420396  private:
    421397        virtual std::string typeString() const;
     
    429405        typedef ReferenceToType Parent;
    430406  public:
    431         TypeInstType( const Type::Qualifiers &tq, const std::string &name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
    432         TypeInstType( const Type::Qualifiers &tq, const std::string &name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
    433         TypeInstType( const TypeInstType &other );
     407        TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
     408        TypeInstType( const Type::Qualifiers & tq, const std::string & name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
     409        TypeInstType( const TypeInstType & other );
    434410        ~TypeInstType();
    435411
     
    442418
    443419        virtual TypeInstType *clone() const { return new TypeInstType( *this ); }
    444         virtual void accept( Visitor &v ) { v.visit( this ); }
    445         virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    446         virtual void print( std::ostream &os, int indent = 0 ) const;
     420        virtual void accept( Visitor & v ) { v.visit( this ); }
     421        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
     422        virtual void print( std::ostream & os, int indent = 0 ) const;
    447423  private:
    448424        virtual std::string typeString() const;
     
    455431class TupleType : public Type {
    456432  public:
    457         TupleType( const Type::Qualifiers &tq, const std::list< Type * > & types = std::list< Type * >(), const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
     433        TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types = std::list< Type * >(), const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
    458434        TupleType( const TupleType& );
    459435        virtual ~TupleType();
     
    476452
    477453        virtual TupleType *clone() const { return new TupleType( *this ); }
    478         virtual void accept( Visitor &v ) { v.visit( this ); }
    479         virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    480         virtual void print( std::ostream &os, int indent = 0 ) const;
     454        virtual void accept( Visitor & v ) { v.visit( this ); }
     455        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
     456        virtual void print( std::ostream & os, int indent = 0 ) const;
    481457  private:
    482458        std::list<Type*> types;
     
    485461class TypeofType : public Type {
    486462  public:
    487         TypeofType( const Type::Qualifiers &tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
     463        TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
    488464        TypeofType( const TypeofType& );
    489465        virtual ~TypeofType();
     
    495471
    496472        virtual TypeofType *clone() const { return new TypeofType( *this ); }
    497         virtual void accept( Visitor &v ) { v.visit( this ); }
    498         virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    499         virtual void print( std::ostream &os, int indent = 0 ) const;
     473        virtual void accept( Visitor & v ) { v.visit( this ); }
     474        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
     475        virtual void print( std::ostream & os, int indent = 0 ) const;
    500476  private:
    501477        Expression *expr;
     
    504480class AttrType : public Type {
    505481  public:
    506         AttrType( const Type::Qualifiers &tq, const std::string &name, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    507         AttrType( const Type::Qualifiers &tq, const std::string &name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
     482        AttrType( const Type::Qualifiers & tq, const std::string & name, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
     483        AttrType( const Type::Qualifiers & tq, const std::string & name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
    508484        AttrType( const AttrType& );
    509485        virtual ~AttrType();
    510486
    511         const std::string &get_name() const { return name; }
    512         void set_name( const std::string &newValue ) { name = newValue; }
     487        const std::string & get_name() const { return name; }
     488        void set_name( const std::string & newValue ) { name = newValue; }
    513489        Expression *get_expr() const { return expr; }
    514490        void set_expr( Expression *newValue ) { expr = newValue; }
     
    521497
    522498        virtual AttrType *clone() const { return new AttrType( *this ); }
    523         virtual void accept( Visitor &v ) { v.visit( this ); }
    524         virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    525         virtual void print( std::ostream &os, int indent = 0 ) const;
     499        virtual void accept( Visitor & v ) { v.visit( this ); }
     500        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
     501        virtual void print( std::ostream & os, int indent = 0 ) const;
    526502  private:
    527503        std::string name;
     
    540516
    541517        virtual VarArgsType *clone() const { return new VarArgsType( *this ); }
    542         virtual void accept( Visitor &v ) { v.visit( this ); }
    543         virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    544         virtual void print( std::ostream &os, int indent = 0 ) const;
     518        virtual void accept( Visitor & v ) { v.visit( this ); }
     519        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
     520        virtual void print( std::ostream & os, int indent = 0 ) const;
    545521};
    546522
     
    552528
    553529        virtual ZeroType *clone() const { return new ZeroType( *this ); }
    554         virtual void accept( Visitor &v ) { v.visit( this ); }
    555         virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    556         virtual void print( std::ostream &os, int indent = 0 ) const;
     530        virtual void accept( Visitor & v ) { v.visit( this ); }
     531        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
     532        virtual void print( std::ostream & os, int indent = 0 ) const;
    557533};
    558534
     
    564540
    565541        virtual OneType *clone() const { return new OneType( *this ); }
    566         virtual void accept( Visitor &v ) { v.visit( this ); }
    567         virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    568         virtual void print( std::ostream &os, int indent = 0 ) const;
     542        virtual void accept( Visitor & v ) { v.visit( this ); }
     543        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
     544        virtual void print( std::ostream & os, int indent = 0 ) const;
    569545};
    570546
  • src/benchmark/CorCtxSwitch.c

    rbf4ac09 rf2e40a9f  
    11#include <fstream>
    22#include <stdlib>
    3 #include <threads>
     3#include <thread>
    44
    55#include <unistd.h>                                     // sysconf
     
    2424
    2525struct GreatSuspender {
    26         coroutine c;
     26        coroutine_desc c;
    2727};
    2828
  • src/benchmark/ThrdCtxSwitch.c

    rbf4ac09 rf2e40a9f  
    11#include <fstream>
    22#include <stdlib>
    3 #include <threads>
     3#include <thread>
    44
    55#include <unistd.h>                                     // sysconf
  • src/benchmark/bench.c

    rbf4ac09 rf2e40a9f  
    22#include <fstream>
    33#include <stdlib>
    4 #include <threads>
     4#include <thread>
    55
    66#include <unistd.h>                                     // sysconf
     
    8686//=======================================
    8787
    88 struct CoroutineDummy { coroutine c; };
     88struct CoroutineDummy { coroutine_desc c; };
    8989DECL_COROUTINE(CoroutineDummy);
    9090void main(CoroutineDummy * this) {}
     
    119119struct CoroutineResume {
    120120    int N;
    121     coroutine c;
     121    coroutine_desc c;
    122122};
    123123
     
    150150//=======================================
    151151
    152 struct ThreadDummy { thread t; };
     152struct ThreadDummy { thread_desc t; };
    153153DECL_THREAD(ThreadDummy);
    154154void main(ThreadDummy * this) {}
     
    180180    int N;
    181181    long long result;
    182     thread t;
     182    thread_desc t;
    183183};
    184184
  • src/benchmark/csv-data.c

    rbf4ac09 rf2e40a9f  
    11#include <fstream>
    22#include <stdlib>
    3 #include <threads>
     3#include <thread>
    44
    55extern "C" {
     
    2626
    2727struct GreatSuspender {
    28         coroutine c;
     28        coroutine_desc c;
    2929};
    3030
  • src/examples/multicore.c

    rbf4ac09 rf2e40a9f  
    11#include <kernel>
    2 #include <threads>
     2#include <thread>
    33
    4 struct MyThread { thread t; };
     4struct MyThread { thread_desc t; };
    55
    66DECL_THREAD(MyThread);
  • src/libcfa/Makefile.am

    rbf4ac09 rf2e40a9f  
    4545# not all platforms support concurrency, add option do disable it
    4646if BUILD_CONCURRENCY
    47 headers += containers/vector concurrency/coroutines concurrency/threads concurrency/kernel concurrency/monitor
     47headers += containers/vector concurrency/coroutine concurrency/thread concurrency/kernel concurrency/monitor
    4848endif
    4949
  • src/libcfa/Makefile.in

    rbf4ac09 rf2e40a9f  
    4343
    4444# not all platforms support concurrency, add option do disable it
    45 @BUILD_CONCURRENCY_TRUE@am__append_3 = containers/vector concurrency/coroutines concurrency/threads concurrency/kernel concurrency/monitor
     45@BUILD_CONCURRENCY_TRUE@am__append_3 = containers/vector concurrency/coroutine concurrency/thread concurrency/kernel concurrency/monitor
    4646
    4747# not all platforms support concurrency, add option do disable it
     
    9999am__libcfa_d_a_SOURCES_DIST = libcfa-prelude.c limits.c stdlib.c \
    100100        math.c iostream.c fstream.c iterator.c rational.c assert.c \
    101         containers/vector.c concurrency/coroutines.c \
    102         concurrency/threads.c concurrency/kernel.c \
     101        containers/vector.c concurrency/coroutine.c \
     102        concurrency/thread.c concurrency/kernel.c \
    103103        concurrency/monitor.c concurrency/CtxSwitch-@MACHINE_TYPE@.S \
    104104        concurrency/invoke.c
    105105am__dirstamp = $(am__leading_dot)dirstamp
    106106@BUILD_CONCURRENCY_TRUE@am__objects_1 = containers/libcfa_d_a-vector.$(OBJEXT) \
    107 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-coroutines.$(OBJEXT) \
    108 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-threads.$(OBJEXT) \
     107@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-coroutine.$(OBJEXT) \
     108@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-thread.$(OBJEXT) \
    109109@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-kernel.$(OBJEXT) \
    110110@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-monitor.$(OBJEXT)
     
    124124am__libcfa_a_SOURCES_DIST = libcfa-prelude.c limits.c stdlib.c math.c \
    125125        iostream.c fstream.c iterator.c rational.c assert.c \
    126         containers/vector.c concurrency/coroutines.c \
    127         concurrency/threads.c concurrency/kernel.c \
     126        containers/vector.c concurrency/coroutine.c \
     127        concurrency/thread.c concurrency/kernel.c \
    128128        concurrency/monitor.c concurrency/CtxSwitch-@MACHINE_TYPE@.S \
    129129        concurrency/invoke.c
    130130@BUILD_CONCURRENCY_TRUE@am__objects_5 =  \
    131131@BUILD_CONCURRENCY_TRUE@        containers/libcfa_a-vector.$(OBJEXT) \
    132 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-coroutines.$(OBJEXT) \
    133 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-threads.$(OBJEXT) \
     132@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-coroutine.$(OBJEXT) \
     133@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-thread.$(OBJEXT) \
    134134@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-kernel.$(OBJEXT) \
    135135@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-monitor.$(OBJEXT)
     
    175175am__nobase_cfa_include_HEADERS_DIST = limits stdlib math iostream \
    176176        fstream iterator rational assert containers/vector \
    177         concurrency/coroutines concurrency/threads concurrency/kernel \
     177        concurrency/coroutine concurrency/thread concurrency/kernel \
    178178        concurrency/monitor ${shell echo stdhdr/*} \
    179179        concurrency/invoke.h
     
    397397        @$(MKDIR_P) concurrency/$(DEPDIR)
    398398        @: > concurrency/$(DEPDIR)/$(am__dirstamp)
    399 concurrency/libcfa_d_a-coroutines.$(OBJEXT):  \
     399concurrency/libcfa_d_a-coroutine.$(OBJEXT):  \
    400400        concurrency/$(am__dirstamp) \
    401401        concurrency/$(DEPDIR)/$(am__dirstamp)
    402 concurrency/libcfa_d_a-threads.$(OBJEXT): concurrency/$(am__dirstamp) \
     402concurrency/libcfa_d_a-thread.$(OBJEXT): concurrency/$(am__dirstamp) \
    403403        concurrency/$(DEPDIR)/$(am__dirstamp)
    404404concurrency/libcfa_d_a-kernel.$(OBJEXT): concurrency/$(am__dirstamp) \
     
    417417containers/libcfa_a-vector.$(OBJEXT): containers/$(am__dirstamp) \
    418418        containers/$(DEPDIR)/$(am__dirstamp)
    419 concurrency/libcfa_a-coroutines.$(OBJEXT):  \
    420         concurrency/$(am__dirstamp) \
     419concurrency/libcfa_a-coroutine.$(OBJEXT): concurrency/$(am__dirstamp) \
    421420        concurrency/$(DEPDIR)/$(am__dirstamp)
    422 concurrency/libcfa_a-threads.$(OBJEXT): concurrency/$(am__dirstamp) \
     421concurrency/libcfa_a-thread.$(OBJEXT): concurrency/$(am__dirstamp) \
    423422        concurrency/$(DEPDIR)/$(am__dirstamp)
    424423concurrency/libcfa_a-kernel.$(OBJEXT): concurrency/$(am__dirstamp) \
     
    436435        -rm -f *.$(OBJEXT)
    437436        -rm -f concurrency/CtxSwitch-@MACHINE_TYPE@.$(OBJEXT)
    438         -rm -f concurrency/libcfa_a-coroutines.$(OBJEXT)
     437        -rm -f concurrency/libcfa_a-coroutine.$(OBJEXT)
    439438        -rm -f concurrency/libcfa_a-invoke.$(OBJEXT)
    440439        -rm -f concurrency/libcfa_a-kernel.$(OBJEXT)
    441440        -rm -f concurrency/libcfa_a-monitor.$(OBJEXT)
    442         -rm -f concurrency/libcfa_a-threads.$(OBJEXT)
    443         -rm -f concurrency/libcfa_d_a-coroutines.$(OBJEXT)
     441        -rm -f concurrency/libcfa_a-thread.$(OBJEXT)
     442        -rm -f concurrency/libcfa_d_a-coroutine.$(OBJEXT)
    444443        -rm -f concurrency/libcfa_d_a-invoke.$(OBJEXT)
    445444        -rm -f concurrency/libcfa_d_a-kernel.$(OBJEXT)
    446445        -rm -f concurrency/libcfa_d_a-monitor.$(OBJEXT)
    447         -rm -f concurrency/libcfa_d_a-threads.$(OBJEXT)
     446        -rm -f concurrency/libcfa_d_a-thread.$(OBJEXT)
    448447        -rm -f containers/libcfa_a-vector.$(OBJEXT)
    449448        -rm -f containers/libcfa_d_a-vector.$(OBJEXT)
     
    471470@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-stdlib.Po@am__quote@
    472471@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/CtxSwitch-@MACHINE_TYPE@.Po@am__quote@
    473 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-coroutines.Po@am__quote@
     472@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-coroutine.Po@am__quote@
    474473@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-invoke.Po@am__quote@
    475474@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-kernel.Po@am__quote@
    476475@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-monitor.Po@am__quote@
    477 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-threads.Po@am__quote@
    478 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-coroutines.Po@am__quote@
     476@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-thread.Po@am__quote@
     477@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-coroutine.Po@am__quote@
    479478@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-invoke.Po@am__quote@
    480479@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-kernel.Po@am__quote@
    481480@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-monitor.Po@am__quote@
    482 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-threads.Po@am__quote@
     481@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-thread.Po@am__quote@
    483482@AMDEP_TRUE@@am__include@ @am__quote@containers/$(DEPDIR)/libcfa_a-vector.Po@am__quote@
    484483@AMDEP_TRUE@@am__include@ @am__quote@containers/$(DEPDIR)/libcfa_d_a-vector.Po@am__quote@
     
    649648@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o containers/libcfa_d_a-vector.obj `if test -f 'containers/vector.c'; then $(CYGPATH_W) 'containers/vector.c'; else $(CYGPATH_W) '$(srcdir)/containers/vector.c'; fi`
    650649
    651 concurrency/libcfa_d_a-coroutines.o: concurrency/coroutines.c
    652 @am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_d_a-coroutines.o -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-coroutines.Tpo -c -o concurrency/libcfa_d_a-coroutines.o `test -f 'concurrency/coroutines.c' || echo '$(srcdir)/'`concurrency/coroutines.c
    653 @am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-coroutines.Tpo concurrency/$(DEPDIR)/libcfa_d_a-coroutines.Po
    654 @AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/coroutines.c' object='concurrency/libcfa_d_a-coroutines.o' libtool=no @AMDEPBACKSLASH@
    655 @AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    656 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_d_a-coroutines.o `test -f 'concurrency/coroutines.c' || echo '$(srcdir)/'`concurrency/coroutines.c
    657 
    658 concurrency/libcfa_d_a-coroutines.obj: concurrency/coroutines.c
    659 @am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_d_a-coroutines.obj -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-coroutines.Tpo -c -o concurrency/libcfa_d_a-coroutines.obj `if test -f 'concurrency/coroutines.c'; then $(CYGPATH_W) 'concurrency/coroutines.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/coroutines.c'; fi`
    660 @am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-coroutines.Tpo concurrency/$(DEPDIR)/libcfa_d_a-coroutines.Po
    661 @AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/coroutines.c' object='concurrency/libcfa_d_a-coroutines.obj' libtool=no @AMDEPBACKSLASH@
    662 @AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    663 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_d_a-coroutines.obj `if test -f 'concurrency/coroutines.c'; then $(CYGPATH_W) 'concurrency/coroutines.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/coroutines.c'; fi`
    664 
    665 concurrency/libcfa_d_a-threads.o: concurrency/threads.c
    666 @am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_d_a-threads.o -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-threads.Tpo -c -o concurrency/libcfa_d_a-threads.o `test -f 'concurrency/threads.c' || echo '$(srcdir)/'`concurrency/threads.c
    667 @am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-threads.Tpo concurrency/$(DEPDIR)/libcfa_d_a-threads.Po
    668 @AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/threads.c' object='concurrency/libcfa_d_a-threads.o' libtool=no @AMDEPBACKSLASH@
    669 @AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    670 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_d_a-threads.o `test -f 'concurrency/threads.c' || echo '$(srcdir)/'`concurrency/threads.c
    671 
    672 concurrency/libcfa_d_a-threads.obj: concurrency/threads.c
    673 @am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_d_a-threads.obj -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-threads.Tpo -c -o concurrency/libcfa_d_a-threads.obj `if test -f 'concurrency/threads.c'; then $(CYGPATH_W) 'concurrency/threads.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/threads.c'; fi`
    674 @am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-threads.Tpo concurrency/$(DEPDIR)/libcfa_d_a-threads.Po
    675 @AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/threads.c' object='concurrency/libcfa_d_a-threads.obj' libtool=no @AMDEPBACKSLASH@
    676 @AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    677 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_d_a-threads.obj `if test -f 'concurrency/threads.c'; then $(CYGPATH_W) 'concurrency/threads.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/threads.c'; fi`
     650concurrency/libcfa_d_a-coroutine.o: concurrency/coroutine.c
     651@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_d_a-coroutine.o -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-coroutine.Tpo -c -o concurrency/libcfa_d_a-coroutine.o `test -f 'concurrency/coroutine.c' || echo '$(srcdir)/'`concurrency/coroutine.c
     652@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-coroutine.Tpo concurrency/$(DEPDIR)/libcfa_d_a-coroutine.Po
     653@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/coroutine.c' object='concurrency/libcfa_d_a-coroutine.o' libtool=no @AMDEPBACKSLASH@
     654@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     655@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_d_a-coroutine.o `test -f 'concurrency/coroutine.c' || echo '$(srcdir)/'`concurrency/coroutine.c
     656
     657concurrency/libcfa_d_a-coroutine.obj: concurrency/coroutine.c
     658@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_d_a-coroutine.obj -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-coroutine.Tpo -c -o concurrency/libcfa_d_a-coroutine.obj `if test -f 'concurrency/coroutine.c'; then $(CYGPATH_W) 'concurrency/coroutine.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/coroutine.c'; fi`
     659@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-coroutine.Tpo concurrency/$(DEPDIR)/libcfa_d_a-coroutine.Po
     660@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/coroutine.c' object='concurrency/libcfa_d_a-coroutine.obj' libtool=no @AMDEPBACKSLASH@
     661@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     662@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_d_a-coroutine.obj `if test -f 'concurrency/coroutine.c'; then $(CYGPATH_W) 'concurrency/coroutine.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/coroutine.c'; fi`
     663
     664concurrency/libcfa_d_a-thread.o: concurrency/thread.c
     665@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_d_a-thread.o -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-thread.Tpo -c -o concurrency/libcfa_d_a-thread.o `test -f 'concurrency/thread.c' || echo '$(srcdir)/'`concurrency/thread.c
     666@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-thread.Tpo concurrency/$(DEPDIR)/libcfa_d_a-thread.Po
     667@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/thread.c' object='concurrency/libcfa_d_a-thread.o' libtool=no @AMDEPBACKSLASH@
     668@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     669@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_d_a-thread.o `test -f 'concurrency/thread.c' || echo '$(srcdir)/'`concurrency/thread.c
     670
     671concurrency/libcfa_d_a-thread.obj: concurrency/thread.c
     672@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_d_a-thread.obj -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-thread.Tpo -c -o concurrency/libcfa_d_a-thread.obj `if test -f 'concurrency/thread.c'; then $(CYGPATH_W) 'concurrency/thread.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/thread.c'; fi`
     673@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-thread.Tpo concurrency/$(DEPDIR)/libcfa_d_a-thread.Po
     674@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/thread.c' object='concurrency/libcfa_d_a-thread.obj' libtool=no @AMDEPBACKSLASH@
     675@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     676@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_d_a-thread.obj `if test -f 'concurrency/thread.c'; then $(CYGPATH_W) 'concurrency/thread.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/thread.c'; fi`
    678677
    679678concurrency/libcfa_d_a-kernel.o: concurrency/kernel.c
     
    845844@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o containers/libcfa_a-vector.obj `if test -f 'containers/vector.c'; then $(CYGPATH_W) 'containers/vector.c'; else $(CYGPATH_W) '$(srcdir)/containers/vector.c'; fi`
    846845
    847 concurrency/libcfa_a-coroutines.o: concurrency/coroutines.c
    848 @am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_a-coroutines.o -MD -MP -MF concurrency/$(DEPDIR)/libcfa_a-coroutines.Tpo -c -o concurrency/libcfa_a-coroutines.o `test -f 'concurrency/coroutines.c' || echo '$(srcdir)/'`concurrency/coroutines.c
    849 @am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-coroutines.Tpo concurrency/$(DEPDIR)/libcfa_a-coroutines.Po
    850 @AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/coroutines.c' object='concurrency/libcfa_a-coroutines.o' libtool=no @AMDEPBACKSLASH@
    851 @AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    852 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_a-coroutines.o `test -f 'concurrency/coroutines.c' || echo '$(srcdir)/'`concurrency/coroutines.c
    853 
    854 concurrency/libcfa_a-coroutines.obj: concurrency/coroutines.c
    855 @am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_a-coroutines.obj -MD -MP -MF concurrency/$(DEPDIR)/libcfa_a-coroutines.Tpo -c -o concurrency/libcfa_a-coroutines.obj `if test -f 'concurrency/coroutines.c'; then $(CYGPATH_W) 'concurrency/coroutines.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/coroutines.c'; fi`
    856 @am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-coroutines.Tpo concurrency/$(DEPDIR)/libcfa_a-coroutines.Po
    857 @AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/coroutines.c' object='concurrency/libcfa_a-coroutines.obj' libtool=no @AMDEPBACKSLASH@
    858 @AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    859 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_a-coroutines.obj `if test -f 'concurrency/coroutines.c'; then $(CYGPATH_W) 'concurrency/coroutines.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/coroutines.c'; fi`
    860 
    861 concurrency/libcfa_a-threads.o: concurrency/threads.c
    862 @am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_a-threads.o -MD -MP -MF concurrency/$(DEPDIR)/libcfa_a-threads.Tpo -c -o concurrency/libcfa_a-threads.o `test -f 'concurrency/threads.c' || echo '$(srcdir)/'`concurrency/threads.c
    863 @am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-threads.Tpo concurrency/$(DEPDIR)/libcfa_a-threads.Po
    864 @AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/threads.c' object='concurrency/libcfa_a-threads.o' libtool=no @AMDEPBACKSLASH@
    865 @AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    866 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_a-threads.o `test -f 'concurrency/threads.c' || echo '$(srcdir)/'`concurrency/threads.c
    867 
    868 concurrency/libcfa_a-threads.obj: concurrency/threads.c
    869 @am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_a-threads.obj -MD -MP -MF concurrency/$(DEPDIR)/libcfa_a-threads.Tpo -c -o concurrency/libcfa_a-threads.obj `if test -f 'concurrency/threads.c'; then $(CYGPATH_W) 'concurrency/threads.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/threads.c'; fi`
    870 @am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-threads.Tpo concurrency/$(DEPDIR)/libcfa_a-threads.Po
    871 @AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/threads.c' object='concurrency/libcfa_a-threads.obj' libtool=no @AMDEPBACKSLASH@
    872 @AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    873 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_a-threads.obj `if test -f 'concurrency/threads.c'; then $(CYGPATH_W) 'concurrency/threads.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/threads.c'; fi`
     846concurrency/libcfa_a-coroutine.o: concurrency/coroutine.c
     847@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_a-coroutine.o -MD -MP -MF concurrency/$(DEPDIR)/libcfa_a-coroutine.Tpo -c -o concurrency/libcfa_a-coroutine.o `test -f 'concurrency/coroutine.c' || echo '$(srcdir)/'`concurrency/coroutine.c
     848@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-coroutine.Tpo concurrency/$(DEPDIR)/libcfa_a-coroutine.Po
     849@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/coroutine.c' object='concurrency/libcfa_a-coroutine.o' libtool=no @AMDEPBACKSLASH@
     850@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     851@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_a-coroutine.o `test -f 'concurrency/coroutine.c' || echo '$(srcdir)/'`concurrency/coroutine.c
     852
     853concurrency/libcfa_a-coroutine.obj: concurrency/coroutine.c
     854@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_a-coroutine.obj -MD -MP -MF concurrency/$(DEPDIR)/libcfa_a-coroutine.Tpo -c -o concurrency/libcfa_a-coroutine.obj `if test -f 'concurrency/coroutine.c'; then $(CYGPATH_W) 'concurrency/coroutine.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/coroutine.c'; fi`
     855@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-coroutine.Tpo concurrency/$(DEPDIR)/libcfa_a-coroutine.Po
     856@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/coroutine.c' object='concurrency/libcfa_a-coroutine.obj' libtool=no @AMDEPBACKSLASH@
     857@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     858@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_a-coroutine.obj `if test -f 'concurrency/coroutine.c'; then $(CYGPATH_W) 'concurrency/coroutine.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/coroutine.c'; fi`
     859
     860concurrency/libcfa_a-thread.o: concurrency/thread.c
     861@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_a-thread.o -MD -MP -MF concurrency/$(DEPDIR)/libcfa_a-thread.Tpo -c -o concurrency/libcfa_a-thread.o `test -f 'concurrency/thread.c' || echo '$(srcdir)/'`concurrency/thread.c
     862@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-thread.Tpo concurrency/$(DEPDIR)/libcfa_a-thread.Po
     863@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/thread.c' object='concurrency/libcfa_a-thread.o' libtool=no @AMDEPBACKSLASH@
     864@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     865@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_a-thread.o `test -f 'concurrency/thread.c' || echo '$(srcdir)/'`concurrency/thread.c
     866
     867concurrency/libcfa_a-thread.obj: concurrency/thread.c
     868@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_a-thread.obj -MD -MP -MF concurrency/$(DEPDIR)/libcfa_a-thread.Tpo -c -o concurrency/libcfa_a-thread.obj `if test -f 'concurrency/thread.c'; then $(CYGPATH_W) 'concurrency/thread.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/thread.c'; fi`
     869@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-thread.Tpo concurrency/$(DEPDIR)/libcfa_a-thread.Po
     870@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/thread.c' object='concurrency/libcfa_a-thread.obj' libtool=no @AMDEPBACKSLASH@
     871@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     872@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_a-thread.obj `if test -f 'concurrency/thread.c'; then $(CYGPATH_W) 'concurrency/thread.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/thread.c'; fi`
    874873
    875874concurrency/libcfa_a-kernel.o: concurrency/kernel.c
  • src/libcfa/concurrency/coroutine

    rbf4ac09 rf2e40a9f  
    66// file "LICENCE" distributed with Cforall.
    77//
    8 // coroutines --
     8// coroutine --
    99//
    1010// Author           : Thierry Delisle
     
    2727trait is_coroutine(dtype T) {
    2828      void main(T * this);
    29       coroutine * get_coroutine(T * this);
     29      coroutine_desc * get_coroutine(T * this);
    3030};
    3131
    32 #define DECL_COROUTINE(X) static inline coroutine* get_coroutine(X* this) { return &this->c; } void main(X* this)
     32#define DECL_COROUTINE(X) static inline coroutine_desc* get_coroutine(X* this) { return &this->c; } void main(X* this)
    3333
    3434//-----------------------------------------------------------------------------
    3535// Ctors and dtors
    3636void ?{}(coStack_t * this);
    37 void ?{}(coroutine * this);
    38 void ?{}(coroutine * this, const char * name);
     37void ?{}(coroutine_desc * this);
     38void ?{}(coroutine_desc * this, const char * name);
    3939void ^?{}(coStack_t * this);
    40 void ^?{}(coroutine * this);
     40void ^?{}(coroutine_desc * this);
    4141
    4242//-----------------------------------------------------------------------------
     
    6363
    6464// Get current coroutine
    65 coroutine * this_coroutine(void);
     65coroutine_desc * this_coroutine(void);
    6666
    6767// Private wrappers for context switch and stack creation
    68 extern void CoroutineCtxSwitch(coroutine * src, coroutine * dst);
     68extern void CoroutineCtxSwitch(coroutine_desc * src, coroutine_desc * dst);
    6969extern void create_stack( coStack_t * this, unsigned int storageSize );
    7070
    7171// Suspend implementation inlined for performance
    7272static inline void suspend() {
    73       coroutine * src = this_coroutine();               // optimization
     73      coroutine_desc * src = this_coroutine();          // optimization
    7474
    7575        assertf( src->last != 0,
     
    8888forall(dtype T | is_coroutine(T))
    8989static inline void resume(T * cor) {
    90         coroutine * src = this_coroutine();             // optimization
    91         coroutine * dst = get_coroutine(cor);
     90        coroutine_desc * src = this_coroutine();                // optimization
     91        coroutine_desc * dst = get_coroutine(cor);
    9292
    9393      if( unlikely(!dst->stack.base) ) {
     
    111111}
    112112
    113 static inline void resume(coroutine * dst) {
    114         coroutine * src = this_coroutine();             // optimization
     113static inline void resume(coroutine_desc * dst) {
     114        coroutine_desc * src = this_coroutine();                // optimization
    115115
    116116      // not resuming self ?
  • src/libcfa/concurrency/coroutine.c

    rbf4ac09 rf2e40a9f  
    66// file "LICENCE" distributed with Cforall.
    77//
    8 // coroutines.c --
     8// coroutine.c --
    99//
    1010// Author           : Thierry Delisle
     
    1515//
    1616
    17 #include "coroutines"
     17#include "coroutine"
    1818
    1919extern "C" {
     
    3232#include "invoke.h"
    3333
    34 extern processor * get_this_processor();
     34extern thread_local processor * this_processor;
    3535
    3636//-----------------------------------------------------------------------------
     
    6060}
    6161
    62 void ?{}(coroutine* this) {
     62void ?{}(coroutine_desc* this) {
    6363        this{ "Anonymous Coroutine" };
    6464}
    6565
    66 void ?{}(coroutine* this, const char * name) {
     66void ?{}(coroutine_desc* this, const char * name) {
    6767        this->name = name;
    6868        this->errno_ = 0;
     
    7272}
    7373
    74 void ?{}(coroutine* this, size_t size) {
     74void ?{}(coroutine_desc* this, size_t size) {
    7575        this{};
    7676        (&this->stack){size};
     
    8888}
    8989
    90 void ^?{}(coroutine* this) {}
     90void ^?{}(coroutine_desc* this) {}
    9191
    9292// Part of the Public API
     
    9494forall(dtype T | is_coroutine(T))
    9595void prime(T* cor) {
    96         coroutine* this = get_coroutine(cor);
     96        coroutine_desc* this = get_coroutine(cor);
    9797        assert(this->state == Start);
    9898
     
    102102
    103103// Wrapper for co
    104 void CoroutineCtxSwitch(coroutine* src, coroutine* dst) {
     104void CoroutineCtxSwitch(coroutine_desc* src, coroutine_desc* dst) {
    105105        // THREAD_GETMEM( This )->disableInterrupts();
    106106
     
    109109
    110110        // set new coroutine that task is executing
    111         get_this_processor()->current_coroutine = dst;                 
     111        this_processor->current_coroutine = dst;
    112112
    113113        // context switch to specified coroutine
  • src/libcfa/concurrency/invoke.c

    rbf4ac09 rf2e40a9f  
    2929
    3030extern void __suspend_internal(void);
    31 extern void __thread_signal_termination(struct thread*);
     31extern void __thread_signal_termination(struct thread_desc*);
    3232
    3333void CtxInvokeCoroutine(
    3434      void (*main)(void *),
    35       struct coroutine *(*get_coroutine)(void *),
     35      struct coroutine_desc *(*get_coroutine)(void *),
    3636      void *this
    3737) {
    3838      // LIB_DEBUG_PRINTF("Invoke Coroutine : Received %p (main %p, get_c %p)\n", this, main, get_coroutine);
    3939
    40       struct coroutine* cor = get_coroutine( this );
     40      struct coroutine_desc* cor = get_coroutine( this );
    4141
    4242      if(cor->state == Primed) {
     
    5757void CtxInvokeThread(
    5858      void (*main)(void *),
    59       struct thread *(*get_thread)(void *),
     59      struct thread_desc *(*get_thread)(void *),
    6060      void *this
    6161) {
    6262      __suspend_internal();
    6363
    64       struct thread* thrd = get_thread( this );
    65       struct coroutine* cor = &thrd->c;
     64      struct thread_desc* thrd = get_thread( this );
     65      struct coroutine_desc* cor = &thrd->c;
    6666      cor->state = Active;
    6767
     
    7979void CtxStart(
    8080      void (*main)(void *),
    81       struct coroutine *(*get_coroutine)(void *),
     81      struct coroutine_desc *(*get_coroutine)(void *),
    8282      void *this,
    8383      void (*invoke)(void *)
  • src/libcfa/concurrency/invoke.h

    rbf4ac09 rf2e40a9f  
    3535
    3636      struct simple_thread_list {
    37             struct thread * head;
    38             struct thread ** tail;
     37            struct thread_desc * head;
     38            struct thread_desc ** tail;
    3939      };
    4040
     
    4848      extern "Cforall" {
    4949            void ?{}( struct simple_thread_list * );
    50             void append( struct simple_thread_list *, struct thread * );
    51             struct thread * pop_head( struct simple_thread_list * );
     50            void append( struct simple_thread_list *, struct thread_desc * );
     51            struct thread_desc * pop_head( struct simple_thread_list * );
    5252
    5353            void ?{}(spinlock * this);
     
    7171      enum coroutine_state { Halted, Start, Inactive, Active, Primed };
    7272
    73       struct coroutine {
     73      struct coroutine_desc {
    7474            struct coStack_t stack;
    7575            const char *name;                         // textual name for coroutine/task, initialized by uC++ generated code
    7676            int errno_;                               // copy of global UNIX variable errno
    7777            enum coroutine_state state;       // current execution status for coroutine
    78             struct coroutine *starter;        // first coroutine to resume this one
    79             struct coroutine *last;                   // last coroutine to resume this one
     78            struct coroutine_desc *starter;           // first coroutine to resume this one
     79            struct coroutine_desc *last;                      // last coroutine to resume this one
    8080      };
    8181
    82       struct thread {
    83             struct coroutine c;                 // coroutine body used to store context
     82      struct thread_desc {
     83            struct coroutine_desc c;                 // coroutine body used to store context
    8484            struct signal_once terminated;      // indicate if execuation state is not halted
    85             struct thread * next;               // instrusive link field for threads
     85            struct thread_desc * next;               // instrusive link field for threads
    8686      };
    8787
  • src/libcfa/concurrency/kernel

    rbf4ac09 rf2e40a9f  
    66// file "LICENCE" distributed with Cforall.
    77//
    8 // threads --
     8// kernel --
    99//
    1010// Author           : Thierry Delisle
     
    4949struct FinishAction {
    5050        FinishOpCode action_code;
    51         thread * thrd;
     51        thread_desc * thrd;
    5252        spinlock * lock;
    5353};
     
    6262        struct processorCtx_t * runner;
    6363        cluster * cltr;
    64         coroutine * current_coroutine;
    65         thread * current_thread;
     64        coroutine_desc * current_coroutine;
     65        thread_desc * current_thread;
    6666        pthread_t kernel_thread;
    6767       
  • src/libcfa/concurrency/kernel.c

    rbf4ac09 rf2e40a9f  
    4343KERNEL_STORAGE(cluster, systemCluster);
    4444KERNEL_STORAGE(processor, systemProcessor);
    45 KERNEL_STORAGE(thread, mainThread);
     45KERNEL_STORAGE(thread_desc, mainThread);
    4646KERNEL_STORAGE(machine_context_t, mainThread_context);
    4747
    4848cluster * systemCluster;
    4949processor * systemProcessor;
    50 thread * mainThread;
     50thread_desc * mainThread;
    5151
    5252//-----------------------------------------------------------------------------
     
    5555thread_local processor * this_processor;
    5656
    57 processor * get_this_processor() {
    58         return this_processor;
    59 }
    60 
    61 coroutine * this_coroutine(void) {
     57coroutine_desc * this_coroutine(void) {
    6258        return this_processor->current_coroutine;
    6359}
    6460
    65 thread * this_thread(void) {
     61thread_desc * this_thread(void) {
    6662        return this_processor->current_thread;
    6763}
     
    10399}
    104100
    105 void ?{}( coroutine * this, current_stack_info_t * info) {
     101void ?{}( coroutine_desc * this, current_stack_info_t * info) {
    106102        (&this->stack){ info };
    107103        this->name = "Main Thread";
     
    110106}
    111107
    112 void ?{}( thread * this, current_stack_info_t * info) {
     108void ?{}( thread_desc * this, current_stack_info_t * info) {
    113109        (&this->c){ info };
    114110}
     
    179175        LIB_DEBUG_PRINTF("Kernel : core %p starting\n", this);
    180176
    181         thread * readyThread = NULL;
     177        thread_desc * readyThread = NULL;
    182178        for( unsigned int spin_count = 0; ! this->is_terminated; spin_count++ )
    183179        {
     
    206202// runThread runs a thread by context switching
    207203// from the processor coroutine to the target thread
    208 void runThread(processor * this, thread * dst) {
    209         coroutine * proc_cor = get_coroutine(this->runner);
    210         coroutine * thrd_cor = get_coroutine(dst);
     204void runThread(processor * this, thread_desc * dst) {
     205        coroutine_desc * proc_cor = get_coroutine(this->runner);
     206        coroutine_desc * thrd_cor = get_coroutine(dst);
    211207       
    212208        //Reset the terminating actions here
     
    297293//-----------------------------------------------------------------------------
    298294// Scheduler routines
    299 void ScheduleThread( thread * thrd ) {
     295void ScheduleThread( thread_desc * thrd ) {
    300296        assertf( thrd->next == NULL, "Expected null got %p", thrd->next );
    301297       
     
    305301}
    306302
    307 thread * nextThread(cluster * this) {
     303thread_desc * nextThread(cluster * this) {
    308304        lock( &this->lock );
    309         thread * head = pop_head( &this->ready_queue );
     305        thread_desc * head = pop_head( &this->ready_queue );
    310306        unlock( &this->lock );
    311307        return head;
     
    317313
    318314void ScheduleInternal( spinlock * lock ) {
    319         get_this_processor()->finish.action_code = Release;
    320         get_this_processor()->finish.lock = lock;
     315        this_processor->finish.action_code = Release;
     316        this_processor->finish.lock = lock;
    321317        suspend();
    322318}
    323319
    324 void ScheduleInternal( thread * thrd ) {
    325         get_this_processor()->finish.action_code = Schedule;
    326         get_this_processor()->finish.thrd = thrd;
     320void ScheduleInternal( thread_desc * thrd ) {
     321        this_processor->finish.action_code = Schedule;
     322        this_processor->finish.thrd = thrd;
    327323        suspend();
    328324}
    329325
    330 void ScheduleInternal( spinlock * lock, thread * thrd ) {
    331         get_this_processor()->finish.action_code = Release_Schedule;
    332         get_this_processor()->finish.lock = lock;
    333         get_this_processor()->finish.thrd = thrd;
     326void ScheduleInternal( spinlock * lock, thread_desc * thrd ) {
     327        this_processor->finish.action_code = Release_Schedule;
     328        this_processor->finish.lock = lock;
     329        this_processor->finish.thrd = thrd;
    334330        suspend();
    335331}
     
    343339        // SKULLDUGGERY: the mainThread steals the process main thread
    344340        // which will then be scheduled by the systemProcessor normally
    345         mainThread = (thread *)&mainThread_storage;
     341        mainThread = (thread_desc *)&mainThread_storage;
    346342        current_stack_info_t info;
    347343        mainThread{ &info };
     
    440436                this->condition = true;
    441437
    442                 thread * it;
     438                thread_desc * it;
    443439                while( it = pop_head( &this->blocked) ) {
    444440                        ScheduleThread( it );
     
    455451}
    456452
    457 void append( simple_thread_list * this, thread * t ) {
     453void append( simple_thread_list * this, thread_desc * t ) {
    458454        assert(this->tail != NULL);
    459455        *this->tail = t;
     
    461457}
    462458
    463 thread * pop_head( simple_thread_list * this ) {
    464         thread * head = this->head;
     459thread_desc * pop_head( simple_thread_list * this ) {
     460        thread_desc * head = this->head;
    465461        if( head ) {
    466462                this->head = head->next;
  • src/libcfa/concurrency/kernel_private.h

    rbf4ac09 rf2e40a9f  
    66// file "LICENCE" distributed with Cforall.
    77//
    8 // threads --
     8// kernel_private.h --
    99//
    1010// Author           : Thierry Delisle
     
    1919
    2020#include "kernel"
    21 #include "threads"
     21#include "thread"
    2222
    2323//-----------------------------------------------------------------------------
    2424// Scheduler
    25 void ScheduleThread( thread * );
    26 thread * nextThread(cluster * this);
     25void ScheduleThread( thread_desc * );
     26thread_desc * nextThread(cluster * this);
    2727
    2828void ScheduleInternal();
    2929void ScheduleInternal(spinlock * lock);
    30 void ScheduleInternal(thread * thrd);
    31 void ScheduleInternal(spinlock * lock, thread * thrd);
     30void ScheduleInternal(thread_desc * thrd);
     31void ScheduleInternal(spinlock * lock, thread_desc * thrd);
    3232
    3333//-----------------------------------------------------------------------------
     
    3535struct processorCtx_t {
    3636        processor * proc;
    37         coroutine c;
     37        coroutine_desc c;
    3838};
    3939
     
    4242void main(processorCtx_t *);
    4343void start(processor * this);
    44 void runThread(processor * this, thread * dst);
     44void runThread(processor * this, thread_desc * dst);
    4545void finishRunning(processor * this);
    4646void spin(processor * this, unsigned int * spin_count);
     
    5353}
    5454
    55 extern void ThreadCtxSwitch(coroutine * src, coroutine * dst);
     55extern void ThreadCtxSwitch(coroutine_desc * src, coroutine_desc * dst);
    5656
    5757#endif //KERNEL_PRIVATE_H
  • src/libcfa/concurrency/monitor

    rbf4ac09 rf2e40a9f  
    2222#include "stdlib"
    2323
    24 struct __monitor_t {
     24struct monitor_desc {
    2525        spinlock lock;
    26         thread * owner;
     26        thread_desc * owner;
    2727        simple_thread_list entry_queue;
    2828        unsigned int recursion;
    2929};
    3030
    31 static inline void ?{}(__monitor_t * this) {
     31static inline void ?{}(monitor_desc * this) {
    3232        this->owner = 0;
    3333        this->recursion = 0;
     
    3535
    3636//Basic entering routine
    37 void enter(__monitor_t *);
    38 void leave(__monitor_t *);
     37void enter(monitor_desc *);
     38void leave(monitor_desc *);
    3939
    4040//Array entering routine
    41 void enter(__monitor_t **, int count);
    42 void leave(__monitor_t **, int count);
     41void enter(monitor_desc **, int count);
     42void leave(monitor_desc **, int count);
    4343
    4444struct monitor_guard_t {
    45         __monitor_t ** m;
     45        monitor_desc ** m;
    4646        int count;
    4747};
    4848
    49 static inline int ?<?(__monitor_t* lhs, __monitor_t* rhs) {
     49static inline int ?<?(monitor_desc* lhs, monitor_desc* rhs) {
    5050        return ((intptr_t)lhs) < ((intptr_t)rhs);
    5151}
    5252
    53 static inline void ?{}( monitor_guard_t * this, __monitor_t ** m ) {
     53static inline void ?{}( monitor_guard_t * this, monitor_desc ** m ) {
    5454        this->m = m;
    5555        this->count = 1;
     
    5757}
    5858
    59 static inline void ?{}( monitor_guard_t * this, __monitor_t ** m, int count ) {
     59static inline void ?{}( monitor_guard_t * this, monitor_desc ** m, int count ) {
    6060        this->m = m;
    6161        this->count = count;
  • src/libcfa/concurrency/monitor.c

    rbf4ac09 rf2e40a9f  
    66// file "LICENCE" distributed with Cforall.
    77//
    8 // __monitor_t.c --
     8// monitor_desc.c --
    99//
    1010// Author           : Thierry Delisle
     
    1919#include "kernel_private.h"
    2020
    21 void enter(__monitor_t * this) {
     21void enter(monitor_desc * this) {
    2222        lock( &this->lock );
    23         thread * thrd = this_thread();
     23        thread_desc * thrd = this_thread();
    2424
    2525        if( !this->owner ) {
     
    4545}
    4646
    47 void leave(__monitor_t * this) {
     47void leave(monitor_desc * this) {
    4848        lock( &this->lock );
    4949
    50         thread * thrd = this_thread();
     50        thread_desc * thrd = this_thread();
    5151        assert( thrd == this->owner );
    5252
     
    5555
    5656        //If we left the last level of recursion it means we are changing who owns the monitor
    57         thread * new_owner = 0;
     57        thread_desc * new_owner = 0;
    5858        if( this->recursion == 0) {
    5959                //Get the next thread in the list
     
    7272}
    7373
    74 void enter(__monitor_t ** monitors, int count) {
     74void enter(monitor_desc ** monitors, int count) {
    7575        for(int i = 0; i < count; i++) {
    7676                // printf("%d\n", i);
     
    7979}
    8080
    81 void leave(__monitor_t ** monitors, int count) {
     81void leave(monitor_desc ** monitors, int count) {
    8282        for(int i = count - 1; i >= 0; i--) {
    8383                // printf("%d\n", i);
  • src/libcfa/concurrency/thread

    rbf4ac09 rf2e40a9f  
    66// file "LICENCE" distributed with Cforall.
    77//
    8 // threads --
     8// thread --
    99//
    1010// Author           : Thierry Delisle
     
    2121#include "invoke.h"
    2222
    23 #include "coroutines"
     23#include "coroutine"
    2424
    2525//-----------------------------------------------------------------------------
     
    2929trait is_thread(dtype T) {
    3030      void main(T* this);
    31       thread* get_thread(T* this);
     31      thread_desc* get_thread(T* this);
    3232};
    3333
    34 #define DECL_THREAD(X) thread* get_thread(X* this) { return &this->t; } void main(X* this)
     34#define DECL_THREAD(X) thread_desc* get_thread(X* this) { return &this->t; } void main(X* this)
    3535
    3636forall( dtype T | is_thread(T) )
    37 static inline coroutine* get_coroutine(T* this) {
     37static inline coroutine_desc* get_coroutine(T* this) {
    3838        return &get_thread(this)->c;
    3939}
    4040
    41 static inline coroutine* get_coroutine(thread* this) {
     41static inline coroutine_desc* get_coroutine(thread_desc* this) {
    4242        return &this->c;
    4343}
    4444
    45 thread * this_thread(void);
     45thread_desc * this_thread(void);
    4646
    4747//-----------------------------------------------------------------------------
    4848// Ctors and dtors
    49 void ?{}(thread* this);
    50 void ^?{}(thread* this);
     49void ?{}(thread_desc* this);
     50void ^?{}(thread_desc* this);
    5151
    5252//-----------------------------------------------------------------------------
  • src/libcfa/concurrency/thread.c

    rbf4ac09 rf2e40a9f  
    66// file "LICENCE" distributed with Cforall.
    77//
    8 // threads.c --
     8// thread.c --
    99//
    1010// Author           : Thierry Delisle
     
    1515//
    1616
    17 #include "threads"
     17#include "thread"
    1818
    1919#include "kernel_private.h"
     
    2828}
    2929
    30 extern processor * get_this_processor();
     30extern thread_local processor * this_processor;
    3131
    3232//-----------------------------------------------------------------------------
     
    4141// Thread ctors and dtors
    4242
    43 void ?{}(thread* this) {
     43void ?{}(thread_desc* this) {
    4444        (&this->c){};
    4545        this->c.name = "Anonymous Coroutine";
     
    4848}
    4949
    50 void ^?{}(thread* this) {
     50void ^?{}(thread_desc* this) {
    5151        ^(&this->c){};
    5252}
     
    7474forall( dtype T | is_thread(T) )
    7575void start( T* this ) {
    76         coroutine* thrd_c = get_coroutine(this);
    77         thread*  thrd_h = get_thread   (this);
     76        coroutine_desc* thrd_c = get_coroutine(this);
     77        thread_desc*  thrd_h = get_thread   (this);
    7878        thrd_c->last = this_coroutine();
    79         get_this_processor()->current_coroutine = thrd_c;
     79        this_processor->current_coroutine = thrd_c;
    8080
    8181        LIB_DEBUG_PRINTF("Thread start : %p (t %p, c %p)\n", this, thrd_c, thrd_h);
     
    9494
    9595void yield( void ) {
    96         ScheduleInternal( get_this_processor()->current_thread );
     96        ScheduleInternal( this_processor->current_thread );
    9797}
    9898
    99 void ThreadCtxSwitch(coroutine* src, coroutine* dst) {
     99void ThreadCtxSwitch(coroutine_desc* src, coroutine_desc* dst) {
    100100        // set state of current coroutine to inactive
    101101        src->state = Inactive;
     
    107107        // set new coroutine that the processor is executing
    108108        // and context switch to it
    109         get_this_processor()->current_coroutine = dst; 
     109        this_processor->current_coroutine = dst;
    110110        CtxSwitch( src->stack.context, dst->stack.context );
    111         get_this_processor()->current_coroutine = src; 
     111        this_processor->current_coroutine = src;
    112112
    113113        // set state of new coroutine to active
     
    116116}
    117117
    118 // C Helper to signal the termination of a thread
     118// C Helper to signal the termination of a thread_desc
    119119// Used in invoke.c
    120120extern "C" {
    121         void __thread_signal_termination( thread * this ) {
     121        void __thread_signal_termination( thread_desc * this ) {
    122122                this->c.state = Halted;
    123123                LIB_DEBUG_PRINTF("Thread end : %p\n", this);
  • src/tests/coroutine.c

    rbf4ac09 rf2e40a9f  
    11#include <fstream>
    2 #include <coroutines>
     2#include <coroutine>
    33
    44struct Fibonacci {
    55      int fn; // used for communication
    6       coroutine c;
     6      coroutine_desc c;
    77};
    88
     
    1111}
    1212
    13 coroutine* get_coroutine(Fibonacci* this) {
     13coroutine_desc* get_coroutine(Fibonacci* this) {
    1414      return &this->c;
    1515}
     
    4747#ifdef MORE_DEBUG     
    4848      Fibonacci *pf1 = &f1, *pf2 = &f2;
    49       coroutine *cf1 = &f1.c, *cf2 = &f2.c;
     49      coroutine_desc *cf1 = &f1.c, *cf2 = &f2.c;
    5050      covptr_t  *vf1 = vtable(pf1), *vf2 = vtable(pf2);
    51       coroutine *cv1 = get_coroutine(vf1), *cv2 = get_coroutine(vf2);
     51      coroutine_desc *cv1 = get_coroutine(vf1), *cv2 = get_coroutine(vf2);
    5252      Fibonacci *ov1 = (Fibonacci *)get_object(vf1), *ov2 = (Fibonacci *)get_object(vf2);
    5353
  • src/tests/monitor.c

    rbf4ac09 rf2e40a9f  
    22#include <kernel>
    33#include <monitor>
    4 #include <threads>
     4#include <thread>
    55
    66struct global_t {
    77        int value;
    8         __monitor_t m;
     8        monitor_desc m;
    99};
    1010
     
    1616
    1717void increment( /*mutex*/ global_t * this ) {
    18         __monitor_t * mon = &this->m;
     18        monitor_desc * mon = &this->m;
    1919        monitor_guard_t g1 = { &mon };
    2020        {
     
    2727}
    2828
    29 struct MyThread { thread t; };
     29struct MyThread { thread_desc t; };
    3030
    3131DECL_THREAD(MyThread);
  • src/tests/multi-monitor.c

    rbf4ac09 rf2e40a9f  
    22#include <kernel>
    33#include <monitor>
    4 #include <threads>
     4#include <thread>
    55
    66static int global12, global23, global13;
    77
    8 static __monitor_t m1, m2, m3;
     8static monitor_desc m1, m2, m3;
    99
    10 void increment( /*mutex*/ __monitor_t * p1, /*mutex*/ __monitor_t * p2, int * value ) {
    11         __monitor_t * mons[] = { p1, p2 };
     10void increment( /*mutex*/ monitor_desc * p1, /*mutex*/ monitor_desc * p2, int * value ) {
     11        monitor_desc * mons[] = { p1, p2 };
    1212        monitor_guard_t g = { mons, 2 };
    1313        *value += 1;
     
    1515
    1616struct MyThread {
    17         thread t;
     17        thread_desc t;
    1818        int target;
    1919};
  • src/tests/test.py

    rbf4ac09 rf2e40a9f  
    250250parser = argparse.ArgumentParser(description='Script which runs cforall tests')
    251251parser.add_argument('--debug', help='Run all tests in debug or release', type=yes_no, default='no')
    252 parser.add_argument('--concurrent', help='Run concurrent tests', type=yes_no, default='no')
     252parser.add_argument('--concurrent', help='Run concurrent tests', type=yes_no, default='yes')
    253253parser.add_argument('--dry-run', help='Don\'t run the tests, only output the commands', action='store_true')
    254254parser.add_argument('--list', help='List all test available', action='store_true')
  • src/tests/thread.c

    rbf4ac09 rf2e40a9f  
    22#include <kernel>
    33#include <stdlib>
    4 #include <threads>
     4#include <thread>
    55
    6 struct First { thread t; signal_once* lock; };
    7 struct Second { thread t; signal_once* lock; };
     6struct First { thread_desc t; signal_once* lock; };
     7struct Second { thread_desc t; signal_once* lock; };
    88
    99DECL_THREAD(First);
Note: See TracChangeset for help on using the changeset viewer.