Changeset a2c2363


Ignore:
Timestamp:
Sep 18, 2023, 10:21:29 AM (7 months ago)
Author:
caparsons <caparson@…>
Branches:
master
Children:
e4c3819
Parents:
e3784a50 (diff), 7edf912 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Files:
3 added
25 edited

Legend:

Unmodified
Added
Removed
  • libcfa/src/common.hfa

    re3784a50 ra2c2363  
    6969        T min( T v1, T v2 ) { return v1 < v2 ? v1 : v2; }
    7070
    71         forall( T, Ts... | { T min( T, T ); T min( T, Ts ); } )
    72         T min( T v1, T v2, Ts vs ) { return min( min( v1, v2 ), vs ); }
     71        forall( T, Ts... | { T min( T, T ); T min( T, T, Ts ); } )
     72        T min( T v1, T v2, T v3, Ts vs ) { return min( min( v1, v2 ), v3, vs ); }
    7373
    7474        forall( T | { int ?>?( T, T ); } )
    7575        T max( T v1, T v2 ) { return v1 > v2 ? v1 : v2; }
    7676
    77         forall( T, Ts... | { T max( T, T ); T max( T, Ts ); } )
    78         T max( T v1, T v2, Ts vs ) { return max( max( v1, v2 ), vs ); }
     77        forall( T, Ts... | { T max( T, T ); T max( T, T, Ts ); } )
     78        T max( T v1, T v2, T v3, Ts vs ) { return max( max( v1, v2 ), v3, vs ); }
    7979
    8080        forall( T | { T min( T, T ); T max( T, T ); } )
  • src/GenPoly/GenPoly.cc

    re3784a50 ra2c2363  
    4848                }
    4949
    50                 bool hasPolyParams( const std::vector<ast::ptr<ast::Expr>> & params, const ast::TypeSubstitution * env) {
    51                         for (auto &param : params) {
    52                                 auto paramType = param.strict_as<ast::TypeExpr>();
    53                                 if (isPolyType(paramType->type, env)) return true;
     50                bool hasPolyParams( const std::vector<ast::ptr<ast::Expr>> & params, const ast::TypeSubstitution * env ) {
     51                        for ( auto &param : params ) {
     52                                auto paramType = param.as<ast::TypeExpr>();
     53                                assertf( paramType, "Aggregate parameters should be type expressions" );
     54                                if ( isPolyType( paramType->type, env ) ) return true;
    5455                        }
    5556                        return false;
     
    6263                                assertf(paramType, "Aggregate parameters should be type expressions");
    6364                                if ( isPolyType( paramType->get_type(), tyVars, env ) ) return true;
     65                        }
     66                        return false;
     67                }
     68
     69                bool hasPolyParams( const std::vector<ast::ptr<ast::Expr>> & params, const TypeVarMap & typeVars, const ast::TypeSubstitution * env ) {
     70                        for ( auto & param : params ) {
     71                                auto paramType = param.as<ast::TypeExpr>();
     72                                assertf( paramType, "Aggregate parameters should be type expressions" );
     73                                if ( isPolyType( paramType->type, typeVars, env ) ) return true;
    6474                        }
    6575                        return false;
     
    185195        }
    186196
    187         const ast::Type * isPolyType(const ast::Type * type, const TyVarMap & tyVars, const ast::TypeSubstitution * env) {
    188                 type = replaceTypeInst( type, env );
    189 
    190                 if ( auto typeInst = dynamic_cast< const ast::TypeInstType * >( type ) ) {
    191                         if ( tyVars.contains( typeInst->typeString() ) ) return type;
    192                 } else if ( auto arrayType = dynamic_cast< const ast::ArrayType * >( type ) ) {
    193                         return isPolyType( arrayType->base, env );
    194                 } else if ( auto structType = dynamic_cast< const ast::StructInstType* >( type ) ) {
    195                         if ( hasPolyParams( structType->params, env ) ) return type;
    196                 } else if ( auto unionType = dynamic_cast< const ast::UnionInstType* >( type ) ) {
    197                         if ( hasPolyParams( unionType->params, env ) ) return type;
    198                 }
    199                 return nullptr;
    200         }
    201 
    202197const ast::Type * isPolyType( const ast::Type * type,
    203198                const TypeVarMap & typeVars, const ast::TypeSubstitution * subst ) {
     
    207202                if ( typeVars.contains( *inst ) ) return type;
    208203        } else if ( auto array = dynamic_cast< const ast::ArrayType * >( type ) ) {
    209                 return isPolyType( array->base, subst );
     204                return isPolyType( array->base, typeVars, subst );
    210205        } else if ( auto sue = dynamic_cast< const ast::StructInstType * >( type ) ) {
    211                 if ( hasPolyParams( sue->params, subst ) ) return type;
     206                if ( hasPolyParams( sue->params, typeVars, subst ) ) return type;
    212207        } else if ( auto sue = dynamic_cast< const ast::UnionInstType * >( type ) ) {
    213                 if ( hasPolyParams( sue->params, subst ) ) return type;
     208                if ( hasPolyParams( sue->params, typeVars, subst ) ) return type;
    214209        }
    215210        return nullptr;
  • tests/.expect/minmax.txt

    re3784a50 ra2c2363  
    2020double                  4. 3.1  max 4.
    2121long double             4. 3.1  max 4.
     22
     233 arguments
     242 3 4   min 2   max 4
     254 2 3   min 2   max 4
     263 4 2   min 2   max 4
     274 arguments
     283 2 5 4 min 2   max 5
     295 3 4 2 min 2   max 5
  • tests/concurrency/actors/dynamic.cfa

    re3784a50 ra2c2363  
    99struct derived_actor { inline actor; };
    1010struct derived_msg {
    11     inline message;
    12     int cnt;
     11        inline message;
     12        int cnt;
    1313};
    1414
    1515void ?{}( derived_msg & this, int cnt ) {
    16     ((message &) this){ Delete };
    17     this.cnt = cnt;
     16        set_allocation( this, Delete );
     17        this.cnt = cnt;
    1818}
    1919void ?{}( derived_msg & this ) { ((derived_msg &)this){ 0 }; }
    2020
    2121allocation receive( derived_actor & receiver, derived_msg & msg ) {
    22     if ( msg.cnt >= Times ) {
    23         sout | "Done";
    24         return Delete;
    25     }
    26     derived_msg * d_msg = alloc();
    27     (*d_msg){ msg.cnt + 1 };
    28     derived_actor * d_actor = alloc();
    29     (*d_actor){};
    30     *d_actor | *d_msg;
    31     return Delete;
     22        if ( msg.cnt >= Times ) {
     23                sout | "Done";
     24                return Delete;
     25        }
     26        derived_msg * d_msg = alloc();
     27        (*d_msg){ msg.cnt + 1 };
     28        derived_actor * d_actor = alloc();
     29        (*d_actor){};
     30        *d_actor | *d_msg;
     31        return Delete;
    3232}
    3333
    3434int main( int argc, char * argv[] ) {
    35     switch ( argc ) {
     35        switch ( argc ) {
    3636          case 2:
    3737                if ( strcmp( argv[1], "d" ) != 0 ) {                    // default ?
    38                         Times = atoi( argv[1] );
    39                         if ( Times < 1 ) goto Usage;
     38                        Times = ato( argv[1] );
     39                        if ( Times < 1 ) fallthru default;
    4040                } // if
    4141          case 1:                                                                                       // use defaults
    4242                break;
    4343          default:
    44           Usage:
    45                 sout | "Usage: " | argv[0] | " [ times (> 0) ]";
    46                 exit( EXIT_FAILURE );
     44                exit | "Usage: " | argv[0] | " [ times (> 0) ]";
    4745        } // switch
    4846
    49     printf("starting\n");
     47        sout | "starting";
    5048
    51     executor e{ 0, 1, 1, false };
    52     start_actor_system( e );
     49        executor e{ 0, 1, 1, false };
     50        start_actor_system( e );
    5351
    54     printf("started\n");
     52        sout | "started";
    5553
    56     derived_msg * d_msg = alloc();
    57     (*d_msg){};
    58     derived_actor * d_actor = alloc();
    59     (*d_actor){};
    60     *d_actor | *d_msg;
     54        derived_msg * d_msg = alloc();
     55        (*d_msg){};
     56        derived_actor * d_actor = alloc();
     57        (*d_actor){};
     58        *d_actor | *d_msg;
    6159
    62     printf("stopping\n");
     60        sout | "stopping";
    6361
    64     stop_actor_system();
     62        stop_actor_system();
    6563
    66     printf("stopped\n");
    67 
    68     return 0;
     64        sout | "stopped";
    6965}
  • tests/concurrency/actors/executor.cfa

    re3784a50 ra2c2363  
    1010static int ids = 0;
    1111struct d_actor {
    12     inline actor;
    13     d_actor * gstart;
    14     int id, rounds, recs, sends;
     12        inline actor;
     13        d_actor * gstart;
     14        int id, rounds, recs, sends;
    1515};
    1616void ?{}( d_actor & this ) with(this) {
    17     id = ids++;
    18     gstart = (&this + (id / Set * Set - id)); // remember group-start array-element
    19     rounds = Set * Rounds;      // send at least one message to each group member
    20     recs = 0;
    21     sends = 0;
     17        id = ids++;
     18        gstart = (&this + (id / Set * Set - id)); // remember group-start array-element
     19        rounds = Set * Rounds;  // send at least one message to each group member
     20        recs = 0;
     21        sends = 0;
    2222}
    2323
     
    2525
    2626allocation receive( d_actor & this, d_msg & msg ) with( this ) {
    27     if ( recs == rounds ) return Finished;
    28     if ( recs % Batch == 0 ) {
    29         for ( i; Batch ) {
    30             gstart[sends % Set] | shared_msg;
    31             sends += 1;
    32         }
    33     }
    34     recs += 1;
    35     return Nodelete;
     27        if ( recs == rounds ) return Finished;
     28        if ( recs % Batch == 0 ) {
     29                for ( i; Batch ) {
     30                        gstart[sends % Set] | shared_msg;
     31                        sends += 1;
     32                }
     33        }
     34        recs += 1;
     35        return Nodelete;
    3636}
    3737
    3838int main( int argc, char * argv[] ) {
    39     switch ( argc ) {
     39        switch ( argc ) {
    4040          case 7:
    4141                if ( strcmp( argv[6], "d" ) != 0 ) {                    // default ?
    42                         BufSize = atoi( argv[6] );
    43                         if ( BufSize < 0 ) goto Usage;
     42                        BufSize = ato( argv[6] );
     43                        if ( BufSize < 0 ) fallthru default;
    4444                } // if
    4545          case 6:
    4646                if ( strcmp( argv[5], "d" ) != 0 ) {                    // default ?
    47                         Batch = atoi( argv[5] );
    48                         if ( Batch < 1 ) goto Usage;
     47                        Batch = ato( argv[5] );
     48                        if ( Batch < 1 ) fallthru default;
    4949                } // if
    5050          case 5:
    5151                if ( strcmp( argv[4], "d" ) != 0 ) {                    // default ?
    52                         Processors = atoi( argv[4] );
    53                         if ( Processors < 1 ) goto Usage;
     52                        Processors = ato( argv[4] );
     53                        if ( Processors < 1 ) fallthru default;
    5454                } // if
    5555          case 4:
    5656                if ( strcmp( argv[3], "d" ) != 0 ) {                    // default ?
    57                         Rounds = atoi( argv[3] );
    58                         if ( Rounds < 1 ) goto Usage;
     57                        Rounds = ato( argv[3] );
     58                        if ( Rounds < 1 ) fallthru default;
    5959                } // if
    6060          case 3:
    6161                if ( strcmp( argv[2], "d" ) != 0 ) {                    // default ?
    62                         Set = atoi( argv[2] );
    63                         if ( Set < 1 ) goto Usage;
     62                        Set = ato( argv[2] );
     63                        if ( Set < 1 ) fallthru default;
    6464                } // if
    6565          case 2:
    6666                if ( strcmp( argv[1], "d" ) != 0 ) {                    // default ?
    67                         Actors = atoi( argv[1] );
    68                         if ( Actors < 1 || Actors <= Set || Actors % Set != 0 ) goto Usage;
     67                        Actors = ato( argv[1] );
     68                        if ( Actors < 1 || Actors <= Set || Actors % Set != 0 ) fallthru default;
    6969                } // if
    7070          case 1:                                                                                       // use defaults
    7171                break;
    7272          default:
    73           Usage:
    74                 sout | "Usage: " | argv[0]
    75              | " [ actors (> 0 && > set && actors % set == 0 ) | 'd' (default " | Actors
     73                exit | "Usage: " | argv[0]
     74                         | " [ actors (> 0 && > set && actors % set == 0 ) | 'd' (default " | Actors
    7675                         | ") ] [ set (> 0) | 'd' (default " | Set
    7776                         | ") ] [ rounds (> 0) | 'd' (default " | Rounds
     
    8079                         | ") ] [ buffer size (>= 0) | 'd' (default " | BufSize
    8180                         | ") ]" ;
    82                 exit( EXIT_FAILURE );
    8381        } // switch
    8482
    85     executor e{ Processors, Processors, Processors == 1 ? 1 : Processors * 512, true };
     83        executor e{ Processors, Processors, Processors == 1 ? 1 : Processors * 512, true };
    8684
    87     printf("starting\n");
     85        sout | "starting";
    8886
    89     start_actor_system( e );
     87        start_actor_system( e );
    9088
    91     printf("started\n");
     89        sout | "started";
    9290
    93     d_actor actors[ Actors ];
     91        d_actor actors[ Actors ];
    9492
    9593        for ( i; Actors ) {
     
    9795        } // for
    9896
    99     printf("stopping\n");
     97        sout | "stopping";
    10098
    101     stop_actor_system();
     99        stop_actor_system();
    102100
    103     printf("stopped\n");
    104 
    105     return 0;
     101        sout | "stopped";
    106102}
  • tests/concurrency/actors/inherit.cfa

    re3784a50 ra2c2363  
    1818
    1919allocation handle() {
    20     return Finished;
     20        return Finished;
    2121}
    2222
     
    2727
    2828int main() {
    29     sout | "Start";
    30     {
    31         start_actor_system();
    32         D_msg * dm = alloc();
    33         (*dm){};
    34         D_msg2 * dm2 = alloc();
    35         (*dm2){};
    36         Server2 * s = alloc();
    37         (*s){};
    38         Server2 * s2 = alloc();
    39         (*s2){};
    40         *s | *dm;
    41         *s2 | *dm2;
    42         stop_actor_system();
    43     }
    44     {
    45         start_actor_system();
    46         Server s[2];
    47         D_msg * dm = alloc();
    48         (*dm){};
    49         D_msg2 * dm2 = alloc();
    50         (*dm2){};
    51         s[0] | *dm;
    52         s[1] | *dm2;
    53         stop_actor_system();
    54     }
    55     sout | "Finished";
     29        sout | "Start";
     30        {
     31                start_actor_system();
     32                D_msg * dm = alloc();
     33                (*dm){};
     34                D_msg2 * dm2 = alloc();
     35                (*dm2){};
     36                Server2 * s = alloc();
     37                (*s){};
     38                Server2 * s2 = alloc();
     39                (*s2){};
     40                *s | *dm;
     41                *s2 | *dm2;
     42                stop_actor_system();
     43        }
     44        {
     45                start_actor_system();
     46                Server s[2];
     47                D_msg * dm = alloc();
     48                (*dm){};
     49                D_msg2 * dm2 = alloc();
     50                (*dm2){};
     51                s[0] | *dm;
     52                s[1] | *dm2;
     53                stop_actor_system();
     54        }
     55        sout | "Finished";
    5656}
  • tests/concurrency/actors/inline.cfa

    re3784a50 ra2c2363  
    33
    44struct d_actor {
    5     inline actor;
     5        inline actor;
    66};
    77struct msg_wrapper {
    8     int b;
    9     inline message;
     8        int b;
     9        inline message;
    1010};
    1111void ^?{}( msg_wrapper & this ) { sout | "msg_wrapper dtor"; }
    1212
    1313struct d_msg {
    14     int m;
    15     inline msg_wrapper;
     14        int m;
     15        inline msg_wrapper;
    1616};
    1717void ?{}( d_msg & this, int m, int b ) { this.m = m; this.b = b; set_allocation( this, Delete ); }
     
    1919
    2020allocation receive( d_actor &, d_msg & msg ) {
    21     sout | msg.m;
    22     sout | msg.b;
    23     return Finished;
     21        sout | msg.m;
     22        sout | msg.b;
     23        return Finished;
    2424}
    2525
    2626struct d_msg2 {
    27     int m;
    28     inline msg_wrapper;
     27        int m;
     28        inline msg_wrapper;
    2929};
    3030void ^?{}( d_msg2 & this ) { sout | "d_msg2 dtor";}
    3131
    3232allocation receive( d_actor &, d_msg2 & msg ) {
    33     sout | msg.m;
    34     return Finished;
     33        sout | msg.m;
     34        return Finished;
    3535}
    3636
    3737int main() {
    38     processor p;
    39     {
    40         start_actor_system();                                // sets up executor
    41         d_actor da;
    42         d_msg * dm = alloc();
    43         (*dm){ 42, 2423 };
    44         da | *dm;
    45         stop_actor_system();                                // waits until actors finish
    46     }
    47     {
    48         start_actor_system();                                // sets up executor
    49         d_actor da;
    50         d_msg2 dm{ 29079 };
    51         set_allocation( dm, Nodelete );
    52         msg_wrapper * mw = &dm;
    53         message * mg = &dm;
    54         virtual_dtor * v = &dm;
    55         da | dm;
    56         stop_actor_system();                                // waits until actors finish
    57     }
     38        processor p;
     39        {
     40                start_actor_system();                                                           // sets up executor
     41                d_actor da;
     42                d_msg * dm = alloc();
     43                (*dm){ 42, 2423 };
     44                da | *dm;
     45                stop_actor_system();                                                            // waits until actors finish
     46        }
     47        {
     48                start_actor_system();                                                           // sets up executor
     49                d_actor da;
     50                d_msg2 dm{ 29079 };
     51                set_allocation( dm, Nodelete );
     52                msg_wrapper * mw = &dm;
     53                message * mg = &dm;
     54                virtual_dtor * v = &dm;
     55                da | dm;
     56                stop_actor_system();                                                            // waits until actors finish
     57        }
    5858}
  • tests/concurrency/actors/matrix.cfa

    re3784a50 ra2c2363  
    55#include <stdio.h>
    66
    7 unsigned int xr = 500, xc = 500, yc = 500, Processors = 1; // default values
     7int xr = 500, xc = 500, yc = 500, Processors = 1; // default values, must be signed
    88
    99struct derived_actor { inline actor; };
    1010
    1111struct derived_msg {
    12     inline message;
    13     int * Z;
     12        inline message;
     13        int * Z;
    1414        int * X;
    15     int ** Y;
     15        int ** Y;
    1616};
    1717
    1818void ?{}( derived_msg & this ) {}
    1919void ?{}( derived_msg & this, int * Z, int * X, int ** Y ) {
    20     ((message &) this){ Nodelete };
    21     this.Z = Z;
    22     this.X = X;
    23     this.Y = Y;
     20        set_allocation( this, Nodelete );
     21        this.Z = Z;
     22        this.X = X;
     23        this.Y = Y;
    2424}
    2525
    2626allocation receive( derived_actor & receiver, derived_msg & msg ) {
    27     for ( unsigned int i = 0; i < yc; i += 1 ) { // multiply X_row by Y_col and sum products
    28         msg.Z[i] = 0;
    29         for ( unsigned int j = 0; j < xc; j += 1 ) {
    30             msg.Z[i] += msg.X[j] * msg.Y[j][i];
    31         } // for
    32     } // for
    33     return Finished;
     27        for ( unsigned int i = 0; i < yc; i += 1 ) { // multiply X_row by Y_col and sum products
     28                msg.Z[i] = 0;
     29                for ( unsigned int j = 0; j < xc; j += 1 ) {
     30                        msg.Z[i] += msg.X[j] * msg.Y[j][i];
     31                } // for
     32        } // for
     33        return Finished;
    3434}
    3535
    3636int main( int argc, char * argv[] ) {
    37     switch ( argc ) {
     37        switch ( argc ) {
    3838          case 5:
    3939                if ( strcmp( argv[4], "d" ) != 0 ) {                    // default ?
    40                         Processors = atoi( argv[4] );
    41                         if ( Processors < 1 ) goto Usage;
     40                        Processors = ato( argv[4] );
     41                        if ( Processors < 1 ) fallthru default;
    4242                } // if
    4343          case 4:
    4444                if ( strcmp( argv[3], "d" ) != 0 ) {                    // default ?
    45                         xr = atoi( argv[3] );
    46                         if ( xr < 1 ) goto Usage;
     45                        xr = ato( argv[3] );
     46                        if ( xr < 1 ) fallthru default;
    4747                } // if
    4848          case 3:
    4949                if ( strcmp( argv[2], "d" ) != 0 ) {                    // default ?
    50                         xc = atoi( argv[2] );
    51                         if ( xc < 1 ) goto Usage;
     50                        xc = ato( argv[2] );
     51                        if ( xc < 1 ) fallthru default;
    5252                } // if
    5353          case 2:
    5454                if ( strcmp( argv[1], "d" ) != 0 ) {                    // default ?
    55                         yc = atoi( argv[1] );
    56                         if ( yc < 1 ) goto Usage;
     55                        yc = ato( argv[1] );
     56                        if ( yc < 1 ) fallthru default;
    5757                } // if
    5858          case 1:                                                                                       // use defaults
    5959                break;
    6060          default:
    61           Usage:
    62                 sout | "Usage: " | argv[0]
     61                exit | "Usage: " | argv[0]
    6362                         | " [ yc (> 0) | 'd' (default " | yc
    6463                         | ") ] [ xc (> 0) | 'd' (default " | xc
     
    6665                         | ") ] [ processors (> 0) | 'd' (default " | Processors
    6766                         | ") ]" ;
    68                 exit( EXIT_FAILURE );
    6967        } // switch
    7068
    71     unsigned int r, c;
     69        unsigned int r, c;
    7270        int * Z[xr], * X[xr], * Y[xc];
    7371
     
    8886        } // for
    8987
    90     executor e{ Processors, Processors, Processors == 1 ? 1 : Processors * 16, true };
     88        executor e{ Processors, Processors, Processors == 1 ? 1 : Processors * 16, true };
    9189
    92     printf("starting\n");
     90        sout | "starting";
    9391
    94     start_actor_system( e );
     92        start_actor_system( e );
    9593
    96     printf("started\n");
     94        sout | "started";
    9795
    98     derived_msg messages[xr];
     96        derived_msg messages[xr];
    9997
    100     derived_actor actors[xr];
     98        derived_actor actors[xr];
    10199
    102100        for ( unsigned int r = 0; r < xr; r += 1 ) {
     
    108106        } // for
    109107
    110     printf("stopping\n");
     108        sout | "stopping";
    111109
    112     stop_actor_system();
     110        stop_actor_system();
    113111
    114     printf("stopped\n");
     112        sout | "stopped";
    115113
    116     for ( r = 0; r < xr; r += 1 ) {                                             // deallocate X and Z matrices
     114        for ( r = 0; r < xr; r += 1 ) {                                         // deallocate X and Z matrices
    117115                free( X[r] );
    118         free( Z[r] );
     116                free( Z[r] );
    119117        } // for
    120118        for ( r = 0; r < xc; r += 1 ) {                                         // deallocate Y matrix
    121         free( Y[r] );
     119                free( Y[r] );
    122120        } // for
    123 
    124     return 0;
    125121}
  • tests/concurrency/actors/pingpong.cfa

    re3784a50 ra2c2363  
    1010
    1111struct p_msg {
    12     inline message;
    13     size_t count;
     12        inline message;
     13        size_t count;
    1414};
    15 static inline void ?{}( p_msg & this ) { ((message &)this){}; this.count = 0; }
     15//static inline void ?{}( p_msg & this ) { ((message &)this){}; this.count = 0; }
     16static inline void ?{}( p_msg & this ) { this.count = 0; }
    1617
    1718ping * pi;
     
    2021
    2122allocation receive( ping & receiver, p_msg & msg ) {
    22     msg.count++;
    23     if ( msg.count > times ) return Finished;
     23        msg.count++;
     24        if ( msg.count > times ) return Finished;
    2425
    25     allocation retval = Nodelete;
    26     if ( msg.count == times ) retval = Finished;
    27     *po | msg;
    28     return retval;
     26        allocation retval = Nodelete;
     27        if ( msg.count == times ) retval = Finished;
     28        *po | msg;
     29        return retval;
    2930}
    3031
    3132allocation receive( pong & receiver, p_msg & msg ) {
    32     msg.count++;
    33     if ( msg.count > times ) return Finished;
    34    
    35     allocation retval = Nodelete;
    36     if ( msg.count == times ) retval = Finished;
    37     *pi | msg;
    38     return retval;
     33        msg.count++;
     34        if ( msg.count > times ) return Finished;
     35       
     36        allocation retval = Nodelete;
     37        if ( msg.count == times ) retval = Finished;
     38        *pi | msg;
     39        return retval;
    3940}
    4041
     
    4243
    4344int main( int argc, char * argv[] ) {
    44     printf("start\n");
     45        sout | "start";
    4546
    46     processor p[Processors - 1];
     47        processor p[Processors - 1];
    4748
    48     start_actor_system( Processors ); // test passing number of processors
     49        start_actor_system( Processors ); // test passing number of processors
     50        ping pi_actor;
     51        pong po_actor;
     52        po = &po_actor;
     53        pi = &pi_actor;
     54        p_msg m;
     55        pi_actor | m;
     56        stop_actor_system();
    4957
    50     ping pi_actor;
    51     pong po_actor;
    52     po = &po_actor;
    53     pi = &pi_actor;
    54     p_msg m;
    55     pi_actor | m;
    56     stop_actor_system();
    57 
    58     printf("end\n");
    59     return 0;
     58        sout | "end";
    6059}
  • tests/concurrency/actors/poison.cfa

    re3784a50 ra2c2363  
    1111
    1212int main() {
    13     sout | "Start";
     13        sout | "Start";
    1414
    15     sout | "Finished";
    16     {
    17         start_actor_system();
    18         Server s[10];
    19         for ( i; 10 ) {
    20             s[i] | finished_msg;
    21         }
    22         stop_actor_system();
    23     }
     15        sout | "Finished";
     16        {
     17                start_actor_system();
     18                Server s[10];
     19                for ( i; 10 ) {
     20                        s[i] | finished_msg;
     21                }
     22                stop_actor_system();
     23        }
    2424
    25     sout | "Delete";
    26     {
    27         start_actor_system();
    28         for ( i; 10 ) {
    29             Server * s = alloc();
    30             (*s){};
    31             (*s) | delete_msg;
    32         }
    33         stop_actor_system();
    34     }
     25        sout | "Delete";
     26        {
     27                start_actor_system();
     28                for ( i; 10 ) {
     29                        Server * s = alloc();
     30                        (*s){};
     31                        (*s) | delete_msg;
     32                }
     33                stop_actor_system();
     34        }
    3535
    36     sout | "Destroy";
    37     {
    38         start_actor_system();
    39         Server s[10];
    40         for ( i; 10 )
    41             s[i] | destroy_msg;
    42         stop_actor_system();
    43         for ( i; 10 )
    44             if (s[i].val != 777)
    45                 sout | "Error: dtor not called correctly.";
    46     }
     36        sout | "Destroy";
     37        {
     38                start_actor_system();
     39                Server s[10];
     40                for ( i; 10 )
     41                        s[i] | destroy_msg;
     42                stop_actor_system();
     43                for ( i; 10 )
     44                        if (s[i].val != 777)
     45                                sout | "Error: dtor not called correctly.";
     46        }
    4747
    48     sout | "Done";
    49     return 0;
     48        sout | "Done";
    5049}
  • tests/concurrency/actors/static.cfa

    re3784a50 ra2c2363  
    99struct derived_actor { inline actor; };
    1010struct derived_msg {
    11     inline message;
    12     int cnt;
     11        inline message;
     12        int cnt;
    1313};
    1414
    1515void ?{}( derived_msg & this, int cnt ) {
    16     ((message &) this){ Nodelete };
    17     this.cnt = cnt;
     16        set_allocation( this, Nodelete );
     17        this.cnt = cnt;
    1818}
    1919void ?{}( derived_msg & this ) { ((derived_msg &)this){ 0 }; }
    2020
    2121allocation receive( derived_actor & receiver, derived_msg & msg ) {
    22     if ( msg.cnt >= Times ) {
    23         sout | "Done";
    24         return Finished;
    25     }
    26     msg.cnt++;
    27     receiver | msg;
    28     return Nodelete;
     22        if ( msg.cnt >= Times ) {
     23                sout | "Done";
     24                return Finished;
     25        }
     26        msg.cnt++;
     27        receiver | msg;
     28        return Nodelete;
    2929}
    3030
    3131int main( int argc, char * argv[] ) {
    32     switch ( argc ) {
     32        switch ( argc ) {
    3333          case 2:
    3434                if ( strcmp( argv[1], "d" ) != 0 ) {                    // default ?
    35                         Times = atoi( argv[1] );
    36                         if ( Times < 1 ) goto Usage;
     35                        Times = ato( argv[1] );
     36                        if ( Times < 1 ) fallthru default;
    3737                } // if
    3838          case 1:                                                                                       // use defaults
    3939                break;
    4040          default:
    41           Usage:
    42                 sout | "Usage: " | argv[0] | " [ times (> 0) ]";
    43                 exit( EXIT_FAILURE );
     41                exit | "Usage: " | argv[0] | " [ times (> 0) ]";
    4442        } // switch
    4543
    46     printf("starting\n");
     44        sout | "starting";
    4745
    48     executor e{ 0, 1, 1, false };
    49     start_actor_system( e );
     46        executor e{ 0, 1, 1, false };
     47        start_actor_system( e );
    5048
    51     printf("started\n");
     49        sout | "started";
    5250
    53     derived_msg msg;
     51        derived_msg msg;
    5452
    55     derived_actor actor;
     53        derived_actor actor;
    5654
    57     actor | msg;
     55        actor | msg;
    5856
    59     printf("stopping\n");
     57        sout | "stopping";
    6058
    61     stop_actor_system();
     59        stop_actor_system();
    6260
    63     printf("stopped\n");
    64 
    65     return 0;
     61        sout | "stopped";
    6662}
  • tests/concurrency/actors/types.cfa

    re3784a50 ra2c2363  
    99
    1010struct derived_actor {
    11     inline actor;
    12     int counter;
     11        inline actor;
     12        int counter;
    1313};
    1414static inline void ?{}( derived_actor & this ) { ((actor &)this){}; this.counter = 0; }
    1515
    1616struct d_msg {
    17     inline message;
    18     int num;
     17        inline message;
     18        int num;
    1919};
    2020
    2121// this isn't a valid receive routine since int is not a message type
    2222allocation receive( derived_actor & receiver, int i ) with( receiver ) {
    23     mutex(sout) sout | i;
    24     counter++;
    25     if ( counter == 2 ) return Finished;
    26     return Nodelete;
     23        mutex(sout) sout | i;
     24        counter++;
     25        if ( counter == 2 ) return Finished;
     26        return Nodelete;
    2727}
    2828
    2929allocation receive( derived_actor & receiver, d_msg & msg ) {
    30     return receive( receiver, msg.num );
     30        return receive( receiver, msg.num );
    3131}
    3232
    3333struct derived_actor2 {
    34     struct nested { int i; }; // testing nested before inline
    35     inline actor;
     34        struct nested { int i; }; // testing nested before inline
     35        inline actor;
    3636};
    3737
    3838allocation receive( derived_actor2 & receiver, d_msg & msg ) {
    39     mutex(sout) sout | msg.num;
    40     return Finished;
     39        mutex(sout) sout | msg.num;
     40        return Finished;
    4141}
    4242
     
    4444struct derived_actor4 { inline derived_actor3; };
    4545struct d_msg2 {
    46     inline message;
    47     int num;
     46        inline message;
     47        int num;
    4848};
    4949
    5050allocation receive( derived_actor3 & receiver, d_msg & msg ) {
    51     mutex(sout) sout | msg.num;
    52     if ( msg.num == -1 ) return Nodelete;
    53     return Finished;
     51        mutex(sout) sout | msg.num;
     52        if ( msg.num == -1 ) return Nodelete;
     53        return Finished;
    5454}
    5555
    5656allocation receive( derived_actor3 & receiver, d_msg2 & msg ) {
    57     mutex(sout) sout | msg.num;
    58     return Finished;
     57        mutex(sout) sout | msg.num;
     58        return Finished;
    5959}
    6060
     
    6262
    6363int main( int argc, char * argv[] ) {
    64     printf("start\n");
     64        sout | "start";
    6565
    66     processor p[Processors - 1];
     66        processor p[Processors - 1];
    6767
    68     printf("basic test\n");
    69     start_actor_system( Processors ); // test passing number of processors
    70     derived_actor a;
    71     d_msg b, c;
    72     b.num = 1;
    73     c.num = 2;
    74     a | b | c;
    75     stop_actor_system();
     68        sout | "basic test";
     69        start_actor_system( Processors ); // test passing number of processors
     70        derived_actor a;
     71        d_msg b, c;
     72        b.num = 1;
     73        c.num = 2;
     74        a | b | c;
     75        stop_actor_system();
    7676
    77     printf("same message and different actors test\n");
    78     start_actor_system(); // let system detect # of processors
    79     derived_actor2 d_ac2_0, d_ac2_1;
    80     d_msg d_ac2_msg;
    81     d_ac2_msg.num = 3;
    82     d_ac2_0 | d_ac2_msg;
    83     d_ac2_1 | d_ac2_msg;
    84     stop_actor_system();
     77        sout | "same message and different actors test";
     78        start_actor_system(); // let system detect # of processors
     79        derived_actor2 d_ac2_0, d_ac2_1;
     80        d_msg d_ac2_msg;
     81        d_ac2_msg.num = 3;
     82        d_ac2_0 | d_ac2_msg;
     83        d_ac2_1 | d_ac2_msg;
     84        stop_actor_system();
    8585
    86    
    87     {
    88         printf("same message and different actor types test\n");
    89         executor e{ 0, Processors, Processors == 1 ? 1 : Processors * 4, false };
    90         start_actor_system( e ); // pass an explicit executor
    91         derived_actor2 d_ac2_2;
    92         derived_actor3 d_ac3_0;
    93         d_msg d_ac23_msg;
    94         d_ac23_msg.num = 4;
    95         d_ac3_0 | d_ac23_msg;
    96         d_ac2_2 | d_ac23_msg;
    97         stop_actor_system();
    98     } // RAII to clean up executor
     86       
     87        {
     88                sout | "same message and different actor types test";
     89                executor e{ 0, Processors, Processors == 1 ? 1 : Processors * 4, false };
     90                start_actor_system( e ); // pass an explicit executor
     91                derived_actor2 d_ac2_2;
     92                derived_actor3 d_ac3_0;
     93                d_msg d_ac23_msg;
     94                d_ac23_msg.num = 4;
     95                d_ac3_0 | d_ac23_msg;
     96                d_ac2_2 | d_ac23_msg;
     97                stop_actor_system();
     98        } // RAII to clean up executor
    9999
    100     {
    101         printf("different message types, one actor test\n");
    102         executor e{ 1, Processors, Processors == 1 ? 1 : Processors * 4, true };
    103         start_actor_system( Processors );
    104         derived_actor3 a3;
    105         d_msg b1;
    106         d_msg2 c2;
    107         b1.num = -1;
    108         c2.num = 5;
    109         a3 | b1 | c2;
    110         stop_actor_system();
    111     } // RAII to clean up executor
     100        {
     101                sout | "different message types, one actor test";
     102                executor e{ 1, Processors, Processors == 1 ? 1 : Processors * 4, true };
     103                start_actor_system( Processors );
     104                derived_actor3 a3;
     105                d_msg b1;
     106                d_msg2 c2;
     107                b1.num = -1;
     108                c2.num = 5;
     109                a3 | b1 | c2;
     110                stop_actor_system();
     111        } // RAII to clean up executor
    112112
    113     {
    114         printf("nested inheritance actor test\n");
    115         executor e{ 1, Processors, Processors == 1 ? 1 : Processors * 4, true };
    116         start_actor_system( Processors );
    117         derived_actor4 a4;
    118         d_msg b1;
    119         d_msg2 c2;
    120         b1.num = -1;
    121         c2.num = 5;
    122         a4 | b1 | c2;
    123         stop_actor_system();
    124     } // RAII to clean up executor
     113        {
     114                sout | "nested inheritance actor test";
     115                executor e{ 1, Processors, Processors == 1 ? 1 : Processors * 4, true };
     116                start_actor_system( Processors );
     117                derived_actor4 a4;
     118                d_msg b1;
     119                d_msg2 c2;
     120                b1.num = -1;
     121                c2.num = 5;
     122                a4 | b1 | c2;
     123                stop_actor_system();
     124        } // RAII to clean up executor
    125125
    126     printf("end\n");
    127     return 0;
     126        sout | "end";
    128127}
  • tests/concurrency/channels/barrier.cfa

    re3784a50 ra2c2363  
    88
    99size_t total_operations = 0;
    10 int Processors = 1, Tasks = 5, BarrierSize = 2;
     10ssize_t Processors = 1, Tasks = 5, BarrierSize = 2;             // must be signed
    1111
    1212typedef channel( int ) Channel;
     
    6565          case 3:
    6666                if ( strcmp( argv[2], "d" ) != 0 ) {                    // default ?
    67                         BarrierSize = atoi( argv[2] );
    68             if ( Processors < 1 ) goto Usage;
     67                        BarrierSize = ato( argv[2] );
     68            if ( Processors < 1 ) fallthru default;
    6969                } // if
    7070          case 2:
    7171                if ( strcmp( argv[1], "d" ) != 0 ) {                    // default ?
    72                         Processors = atoi( argv[1] );
    73                         if ( Processors < 1 ) goto Usage;
     72                        Processors = ato( argv[1] );
     73                        if ( Processors < 1 ) fallthru default;
    7474                } // if
    7575          case 1:                                                                                       // use defaults
    7676                break;
    7777          default:
    78           Usage:
    79                 sout | "Usage: " | argv[0]
     78                exit | "Usage: " | argv[0]
    8079             | " [ processors (> 0) | 'd' (default " | Processors
    8180                         | ") ] [ BarrierSize (> 0) | 'd' (default " | BarrierSize
    8281                         | ") ]" ;
    83                 exit( EXIT_FAILURE );
    8482        } // switch
    8583    if ( Tasks < BarrierSize )
  • tests/concurrency/channels/big_elems.cfa

    re3784a50 ra2c2363  
    22#include "parallel_harness.hfa"
    33
    4 size_t Processors = 10, Channels = 10, Producers = 40, Consumers = 40, ChannelSize = 128;
     4ssize_t Processors = 10, Channels = 10, Producers = 40, Consumers = 40, ChannelSize = 128;
    55
    66int main() {
  • tests/concurrency/channels/churn.cfa

    re3784a50 ra2c2363  
    77#include <time.hfa>
    88
    9 size_t Processors = 1, Channels = 4, Producers = 2, Consumers = 2, ChannelSize = 128;
     9ssize_t Processors = 1, Channels = 4, Producers = 2, Consumers = 2, ChannelSize = 128;
    1010
    1111owner_lock o;
     
    9090      case 4:
    9191                if ( strcmp( argv[3], "d" ) != 0 ) {                    // default ?
    92                         if ( atoi( argv[3] ) < 1 ) goto Usage;
    93                         ChannelSize = atoi( argv[3] );
     92                        ChannelSize = ato( argv[3] );
     93                        if ( ChannelSize < 1 ) fallthru default;
    9494                } // if
    9595      case 3:
    9696                if ( strcmp( argv[2], "d" ) != 0 ) {                    // default ?
    97                         if ( atoi( argv[2] ) < 1 ) goto Usage;
    98                         Channels = atoi( argv[2] );
     97                        Channels = ato( argv[2] );
     98                        if ( Channels < 1 ) fallthru default;
    9999                } // if
    100100      case 2:
    101101                if ( strcmp( argv[1], "d" ) != 0 ) {                    // default ?
    102                         if ( atoi( argv[1] ) < 1 ) goto Usage;
    103                         Processors = atoi( argv[1] );
     102                        Processors = ato( argv[1] );
     103                        if ( Processors < 1 ) fallthru default;
    104104                } // if
    105105          case 1:                                                                                       // use defaults
    106106                break;
    107107          default:
    108           Usage:
    109                 sout | "Usage: " | argv[0]
     108                exit | "Usage: " | argv[0]
    110109             | " [ processors > 0 | d ]"
    111110             | " [ producers > 0 | d ]"
    112111             | " [ consumers > 0 | d ]"
    113112             | " [ channels > 0 | d ]";
    114                 exit( EXIT_FAILURE );
    115113    }
    116114    processor p[Processors - 1];
  • tests/concurrency/channels/contend.cfa

    re3784a50 ra2c2363  
    127127          case 3:
    128128                if ( strcmp( argv[2], "d" ) != 0 ) {                    // default ?
    129                         ChannelSize = atoi( argv[2] );
     129                        ChannelSize = ato( argv[2] );
     130                        if ( ChannelSize < 1 ) fallthru default;
    130131                } // if
    131132          case 2:
    132133                if ( strcmp( argv[1], "d" ) != 0 ) {                    // default ?
    133                         Processors = atoi( argv[1] );
    134                         if ( Processors < 1 ) goto Usage;
     134                        Processors = ato( argv[1] );
     135                        if ( Processors < 1 ) fallthru default;
    135136                } // if
    136137          case 1:                                                                                       // use defaults
    137138                break;
    138139          default:
    139           Usage:
    140                 sout | "Usage: " | argv[0]
     140                exit | "Usage: " | argv[0]
    141141             | " [ processors (> 0) | 'd' (default " | Processors
    142142                         | ") ] [ channel size (>= 0) | 'd' (default " | ChannelSize
    143143                         | ") ]" ;
    144                 exit( EXIT_FAILURE );
    145144        } // switch
     145
    146146    test(Processors, Channels, Producers, Consumers, ChannelSize);
    147147}
  • tests/concurrency/channels/daisy_chain.cfa

    re3784a50 ra2c2363  
    88
    99size_t total_operations = 0;
    10 size_t Processors = 1, Tasks = 4;
     10ssize_t Processors = 1, Tasks = 4;                                              // must be signed
    1111
    1212owner_lock o;
     
    3737          case 3:
    3838                if ( strcmp( argv[2], "d" ) != 0 ) {                    // default ?
    39                         Tasks = atoi( argv[2] );
    40             if ( Tasks < 1 ) goto Usage;
     39                        Tasks = ato( argv[2] );
     40            if ( Tasks < 1 ) fallthru default;
    4141                } // if
    4242          case 2:
    4343                if ( strcmp( argv[1], "d" ) != 0 ) {                    // default ?
    44                         Processors = atoi( argv[1] );
    45                         if ( Processors < 1 ) goto Usage;
     44                        Processors = ato( argv[1] );
     45                        if ( Processors < 1 ) fallthru default;
    4646                } // if
    4747          case 1:                                                                                       // use defaults
    4848                break;
    4949          default:
    50           Usage:
    51                 sout | "Usage: " | argv[0]
     50                exit | "Usage: " | argv[0]
    5251             | " [ processors (> 0) | 'd' (default " | Processors
    5352                         | ") ] [ channel size (>= 0) | 'd' (default " | Tasks
    5453                         | ") ]" ;
    55                 exit( EXIT_FAILURE );
    5654        } // switch
    5755    processor proc[Processors - 1];
     
    7169    // sout | total_operations;
    7270    sout | "done";
    73 
    74     return 0;
    7571}
  • tests/concurrency/channels/hot_potato.cfa

    re3784a50 ra2c2363  
    88
    99size_t total_operations = 0;
    10 size_t Processors = 1, Tasks = 4;
     10ssize_t Processors = 1, Tasks = 4;                                              // must be signed
    1111
    1212owner_lock o;
     
    3838}
    3939
    40 
    4140int main( int argc, char * argv[] ) {
    4241    switch ( argc ) {
    4342          case 3:
    4443                if ( strcmp( argv[2], "d" ) != 0 ) {                    // default ?
    45                         Tasks = atoi( argv[2] );
    46             if ( Tasks < 1 ) goto Usage;
     44                        Tasks = ato( argv[2] );
     45            if ( Tasks < 1 ) fallthru default;
    4746                } // if
    4847          case 2:
    4948                if ( strcmp( argv[1], "d" ) != 0 ) {                    // default ?
    50                         Processors = atoi( argv[1] );
    51                         if ( Processors < 1 ) goto Usage;
     49                        Processors = ato( argv[1] );
     50                        if ( Processors < 1 ) fallthru default;
    5251                } // if
    5352          case 1:                                                                                       // use defaults
    5453                break;
    5554          default:
    56           Usage:
    57                 sout | "Usage: " | argv[0]
     55                exit | "Usage: " | argv[0]
    5856             | " [ processors (> 0) | 'd' (default " | Processors
    5957                         | ") ] [ channel size (>= 0) | 'd' (default " | Tasks
    6058                         | ") ]" ;
    61                 exit( EXIT_FAILURE );
    6259        } // switch
     60
    6361    processor proc[Processors - 1];
    6462
  • tests/concurrency/channels/pub_sub.cfa

    re3784a50 ra2c2363  
    8787          case 3:
    8888                if ( strcmp( argv[2], "d" ) != 0 ) {                    // default ?
    89                         Tasks = atoi( argv[2] );
    90             if ( Tasks < 1 ) goto Usage;
     89                        Tasks = ato( argv[2] );
     90            if ( Tasks < 1 ) fallthru default;
    9191                } // if
    9292          case 2:
    9393                if ( strcmp( argv[1], "d" ) != 0 ) {                    // default ?
    94                         Processors = atoi( argv[1] );
    95                         if ( Processors < 1 ) goto Usage;
     94                        Processors = ato( argv[1] );
     95                        if ( Processors < 1 ) fallthru default;
    9696                } // if
    9797          case 1:                                                                                       // use defaults
    9898                break;
    9999          default:
    100           Usage:
    101                 sout | "Usage: " | argv[0]
     100                exit | "Usage: " | argv[0]
    102101             | " [ processors (> 0) | 'd' (default " | Processors
    103102                         | ") ] [ Tasks (> 0) | 'd' (default " | Tasks
    104103                         | ") ]" ;
    105                 exit( EXIT_FAILURE );
    106104        } // switch
    107105    BarrierSize = Tasks;
  • tests/concurrency/examples/matrixSum.cfa

    re3784a50 ra2c2363  
    1010// Created On       : Mon Oct  9 08:29:28 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Feb 20 08:37:53 2019
    13 // Update Count     : 16
     12// Last Modified On : Fri Sep  8 19:05:34 2023
     13// Update Count     : 19
    1414//
    1515
    1616#include <fstream.hfa>
    17 #include <kernel.hfa>
    1817#include <thread.hfa>
    1918
     
    3534
    3635int main() {
    37         /* const */ int rows = 10, cols = 1000;
     36        const int rows = 10, cols = 1000;
    3837        int matrix[rows][cols], subtotals[rows], total = 0;
    3938        processor p;                                                                            // add kernel thread
    4039
    41         for ( r; rows ) {
     40        for ( r; rows ) {                                                                       // initialize
    4241                for ( c; cols ) {
    4342                        matrix[r][c] = 1;
    4443                } // for
    4544        } // for
     45
    4646        Adder * adders[rows];
    4747        for ( r; rows ) {                                                                       // start threads to sum rows
    4848                adders[r] = &(*malloc()){ matrix[r], cols, subtotals[r] };
    49 //              adders[r] = new( matrix[r], cols, &subtotals[r] );
     49                // adders[r] = new( matrix[r], cols, subtotals[r] );
    5050        } // for
     51
    5152        for ( r; rows ) {                                                                       // wait for threads to finish
    5253                delete( adders[r] );
     
    5758
    5859// Local Variables: //
    59 // tab-width: 4 //
    6060// compile-command: "cfa matrixSum.cfa" //
    6161// End: //
  • tests/concurrency/unified_locking/locks.cfa

    re3784a50 ra2c2363  
    11#include <stdio.h>
    2 #include "locks.hfa"
     2#include <locks.hfa>
    33#include <stdlib.hfa>
    44#include <thread.hfa>
  • tests/concurrency/unified_locking/pthread_locks.cfa

    re3784a50 ra2c2363  
    11#include <stdio.h>
    2 #include "locks.hfa"
     2#include <locks.hfa>
    33#include <stdlib.hfa>
    44#include <thread.hfa>
  • tests/concurrency/unified_locking/test_debug.cfa

    re3784a50 ra2c2363  
    1 #include "locks.hfa"
     1#include <locks.hfa>
    22
    33fast_block_lock f;
  • tests/concurrency/unified_locking/thread_test.cfa

    re3784a50 ra2c2363  
    11#include <stdio.h>
    2 #include "locks.hfa"
     2#include <locks.hfa>
    33#include <stdlib.hfa>
    44#include <thread.hfa>
  • tests/minmax.cfa

    re3784a50 ra2c2363  
    4545        sout | "double\t\t\t"                           | 4.0 | 3.1 | "\tmax" | max( 4.0, 3.1 );
    4646        sout | "long double\t\t"                        | 4.0l | 3.1l | "\tmax" | max( 4.0l, 3.1l );
     47
     48        sout | nl;
     49
     50        sout | "3 arguments";
     51        sout | 2 | 3 | 4 | "\tmin" | min(2, 3, 4) | "\tmax" | max(2, 3, 4);
     52        sout | 4 | 2 | 3 | "\tmin" | min(4, 2, 3) | "\tmax" | max(4, 2, 3);
     53        sout | 3 | 4 | 2 | "\tmin" | min(3, 4, 2) | "\tmax" | max(3, 4, 2);
     54
     55        sout | "4 arguments";
     56        sout | 3 | 2 | 5 | 4 | "\tmin" | min(3, 2, 5, 4) | "\tmax" | max(3, 2, 5, 4);
     57        sout | 5 | 3 | 4 | 2 | "\tmin" | min(5, 3, 4, 2) | "\tmax" | max(5, 3, 4, 2);
    4758} // main
    4859
Note: See TracChangeset for help on using the changeset viewer.