Changeset 24d6572 for tests/PRNG.cfa


Ignore:
Timestamp:
Jun 12, 2023, 2:45:32 PM (2 years ago)
Author:
Fangren Yu <f37yu@…>
Branches:
ast-experimental, master
Children:
62d62db
Parents:
34b4268 (diff), 251ce80 (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' into ast-experimental

File:
1 edited

Legend:

Unmodified
Added
Removed

  • tests/PRNG.cfa

    r34b4268 r24d6572  
    1 //                               -*- Mode: C -*-
    2 //
     1//
    32// Cforall Version 1.0.0 Copyright (C) 2021 University of Waterloo
    4 //
    5 // PRNG.c --
    6 //
     3//
     4// PRNG.c -- high-perforamnce pseudo-random numbers
     5//
     6// The contents of this file are covered under the licence agreement in the
     7// file "LICENCE" distributed with Cforall.
     8//
    79// Author           : Peter A. Buhr
    810// Created On       : Wed Dec 29 09:38:12 2021
    911// Last Modified By : Peter A. Buhr
    10 // Last Modified On : Tue Nov 22 22:51:12 2022
    11 // Update Count     : 381
     12// Last Modified On : Thu May 25 15:39:52 2023
     13// Update Count     : 422
    1214//
    1315
    … …  
    1517#include <stdlib.hfa>                                                                   // PRNG
    1618#include <clock.hfa>
    17 #include <thread.hfa>
    1819#include <limits.hfa>                                                                   // MAX
    1920#include <math.hfa>                                                                             // sqrt
    2021#include <malloc.h>                                                                             // malloc_stats
    2122#include <locale.h>                                                                             // setlocale
     23#include <thread.hfa>
    2224#include <mutex_stmt.hfa>
    2325
    24 #ifdef __x86_64__                                                                               // 64-bit architecture
     26#define xstr(s) str(s)
     27#define str(s) #s
     28
     29#if defined( __x86_64__ ) || defined( __aarch64__ )             // 64-bit architecture
    2530#define PRNG PRNG64
    2631#else                                                                                                   // 32-bit architecture
    2732#define PRNG PRNG32
    2833#endif // __x86_64__
     34
     35//#define TIME
    2936
    3037#ifdef TIME                                                                                             // use -O2 -nodebug
    … …  
    3845#endif // TIME
    3946
    40 void avgstd( unsigned int buckets[] ) {
    41         unsigned int min = MAX, max = 0;
     47static void avgstd( size_t trials, size_t buckets[] ) {
     48        size_t min = MAX, max = 0;
    4249        double sum = 0.0, diff;
    4350        for ( i; BUCKETS ) {
    … …  
    5461        } // for
    5562        double std = sqrt( sum / BUCKETS );
    56         mutex( sout ) sout | "trials"  | TRIALS | "buckets" | BUCKETS
     63        mutex( sout ) sout | "trials"  | trials | "buckets" | BUCKETS
    5764                | "min" | min | "max" | max
    5865                | "avg" | wd(0,1, avg) | "std" | wd(0,1, std) | "rstd" | wd(0,1, (avg == 0 ? 0.0 : std / avg * 100)) | "%";
    … …  
    6067
    6168
    62 unsigned int seed = 1009;
     69size_t seed = 1009;
    6370
    6471thread T1 {};
    6572void main( T1 & ) {
    66         unsigned int * buckets = calloc( BUCKETS );                     // too big for task stack
    67         for ( TRIALS / 100 ) {
     73        size_t * buckets = calloc( BUCKETS );                           // too big for task stack
     74        for ( TRIALS / 50 ) {
    6875                buckets[rand() % BUCKETS] += 1;                                 // concurrent
    6976        } // for
    70         avgstd( buckets );
     77        avgstd( TRIALS / 50, buckets );
    7178        free( buckets );
    7279} // main
    … …  
    7683        PRNG prng;
    7784        if ( seed != 0 ) set_seed( prng, seed );
    78         unsigned int * buckets = calloc( BUCKETS );                     // too big for task stack
     85        size_t * buckets = calloc( BUCKETS );                           // too big for task stack
    7986        for ( TRIALS ) {
    8087                buckets[prng( prng ) % BUCKETS] += 1;                   // concurrent
    8188        } // for
    82         avgstd( buckets );
     89        avgstd( TRIALS, buckets );
    8390        free( buckets );
    8491} // main
    … …  
    8693thread T3 {};
    8794void main( T3 & th ) {
    88         unsigned int * buckets = calloc( BUCKETS );                     // too big for task stack
    89         for ( TRIALS ) {
     95        size_t * buckets = calloc( BUCKETS );                           // too big for task stack
     96        for ( TRIALS / 5 ) {
    9097                buckets[prng() % BUCKETS] += 1;                                 // concurrent
    9198        } // for
    92         avgstd( buckets );
     99        avgstd( TRIALS / 5, buckets );
    93100        free( buckets );
    94101} // main
    … …  
    96103thread T4 {};
    97104void main( T4 & th ) {
    98         unsigned int * buckets = calloc( BUCKETS );                     // too big for task stack
     105        size_t * buckets = calloc( BUCKETS );                           // too big for task stack
    99106        for ( TRIALS ) {
    100                 buckets[prng( th ) % BUCKETS] += 1;     // concurrent
    101         } // for
    102         avgstd( buckets );
     107                buckets[prng( th ) % BUCKETS] += 1;                             // concurrent
     108        } // for
     109        avgstd( TRIALS, buckets );
    103110        free( buckets );
    104111} // main
    … …  
    108115static void dummy( thread$ & th ) __attribute__(( noinline ));
    109116static void dummy( thread$ & th ) {
    110         unsigned int * buckets = (unsigned int *)calloc( BUCKETS, sizeof(unsigned int) ); // too big for task stack
    111         for ( unsigned int i = 0; i < TRIALS; i += 1 ) {
     117        size_t * buckets = (size_t *)calloc( BUCKETS, sizeof(size_t) ); // too big for task stack
     118        for ( size_t i = 0; i < TRIALS; i += 1 ) {
    112119                buckets[prng( th ) % BUCKETS] += 1;                             // sequential
    113120        } // for
    114         avgstd( buckets );
     121        avgstd( TRIALS, buckets );
    115122        free( buckets );
    116123} // dummy
    117124
     125
    118126int main() {
    119         // causes leaked storage message
    120 //      setlocale( LC_NUMERIC, getenv( "LANG" ) );                      // print digit separator
     127        // setlocale( LC_NUMERIC, getenv( "LANG" ) );           // causes leaked storage message
     128
     129        // only works on the current pthread thread
     130        // locale_t loc = newlocale( LC_NUMERIC_MASK, getenv( "LANG" ), (locale_t)0p );
     131        // if ( loc == (locale_t)0p ) abort( "newlocale" );
     132        // uselocale( loc );
    121133
    122134        enum { TASKS = 4 };
    123135        Time start;
     136
    124137#ifdef TIME                                                                                             // too slow for test and generates non-repeatable results
    125138#if 1
    126         unsigned int rseed;
     139        sout | "glib rand" | nl | nl;
     140
     141        size_t rseed;
    127142        if ( seed != 0 ) rseed = seed;
    128143        else rseed = rdtscl();
    … …  
    130145
    131146        sout | sepDisable;
    132         sout | wd(13, "rand()" ) | wd(10, "rand(5)") | wd(13, "rand(0,5)" );
    133         for ( 20 ) {
    134                 sout | wd(13, rand()) | nonl;
    135                 sout | wd(10, rand() % 5) | nonl;
    136                 sout | wd(13, rand() % (5 - 0 + 1) + 0);
     147        sout | nl | wd(26, "rand()" ) | wd(12, "rand(5)") | wd(12, "rand(0,5)" );
     148        for ( 20 ) {
     149                sout | wd(26, rand()) | nonl;
     150                sout | wd(12, rand() % 5) | nonl;
     151                sout | wd(12, rand() % (5 - 0 + 1) + 0);
    137152        } // for
    138153        sout | sepEnable;
    … …  
    142157        STARTTIME;
    143158        {
    144                 unsigned int * buckets = calloc( BUCKETS );             // too big for task stack
    145                 for ( i; TRIALS / 10 ) {
     159                size_t * buckets = calloc( BUCKETS );                   // too big for task stack
     160                for ( i; TRIALS / 5 ) {
    146161                        buckets[rand() % BUCKETS] += 1;                         // sequential
    147162                } // for
    148                 avgstd( buckets );
     163                avgstd( TRIALS / 5, buckets );
    149164                free( buckets );
    150165        }
    151         ENDTIME( " x 10 " );
     166        ENDTIME( " x 5 " );
    152167
    153168        sout | nl | "Concurrent";
    … …  
    159174                } // wait for threads to complete
    160175        }
    161         ENDTIME( " x 100 " );
     176        ENDTIME( " x 50 " );
    162177#endif // 0
    163178#endif // TIME
     179
     180        sout | nl | "CFA " xstr(PRNG_NAME);
     181
    164182#if 1
    165183        PRNG prng;
    … …  
    168186
    169187        sout | sepDisable;
    170         sout | nl | wd(13, "PRNG()" ) | wd(10, "PRNG(5)") | wd(13, "PRNG(0,5)" );
    171         for ( 20 ) {
    172                 sout | wd(13, prng( prng )) | nonl;                             // cascading => side-effect functions called in arbitary order
    173                 sout | wd(10, prng( prng, 5 )) | nonl;
    174                 sout | wd(13, prng( prng, 0, 5 ));
     188        sout | nl | wd(26, "PRNG()" ) | wd(12, "PRNG(5)") | wd(12, "PRNG(0,5)" );
     189        for ( 20 ) {
     190                sout | wd(26, prng( prng )) | nonl;                             // cascading => side-effect functions called in arbitary order
     191                sout | wd(12, prng( prng, 5 )) | nonl;
     192                sout | wd(12, prng( prng, 0, 5 ));
    175193        } // for
    176194        sout | sepEnable;
    … …  
    180198        STARTTIME;
    181199        {
    182                 unsigned int * buckets = calloc( BUCKETS );             // too big for task stack
     200                size_t * buckets = calloc( BUCKETS );                   // too big for task stack
    183201                for ( TRIALS ) {
    184202                        buckets[prng( prng ) % BUCKETS] += 1;           // sequential
    185203                } // for
    186                 avgstd( buckets );
     204                avgstd( TRIALS, buckets );
    187205                free( buckets );
    188206        }
    … …  
    203221
    204222        sout | sepDisable;
    205         sout | nl | wd(13, "prng()" ) | wd(10, "prng(5)") | wd(13, "prng(0,5)" );
    206         for ( 20 ) {
    207                 sout | wd(13, prng()) | nonl;                                   // cascading => side-effect functions called in arbitary order
    208                 sout | wd(10, prng( 5 )) | nonl;
    209                 sout | wd(13, prng( 0, 5 ));
     223        sout | nl | wd(26, "prng()" ) | wd(12, "prng(5)") | wd(12, "prng(0,5)" );
     224        for ( 20 ) {
     225                sout | wd(26, prng()) | nonl;                                   // cascading => side-effect functions called in arbitary order
     226                sout | wd(12, prng( 5 )) | nonl;
     227                sout | wd(12, prng( 0, 5 ));
    210228        } // for
    211229        sout | sepEnable;
    … …  
    215233        STARTTIME;
    216234        {
    217                 unsigned int * buckets = calloc( BUCKETS );             // too big for task stack
    218                 for ( TRIALS ) {
     235                size_t * buckets = calloc( BUCKETS );                   // too big for task stack
     236                for ( TRIALS / 5 ) {
    219237                        buckets[prng() % BUCKETS] += 1;
    220238                } // for
    221                 avgstd( buckets );
     239                avgstd( TRIALS / 5, buckets );
    222240                free( buckets );
    223241        }
    224         ENDTIME();
     242        ENDTIME( " x 5 " );
    225243
    226244        sout | nl | "Concurrent";
    … …  
    232250                } // wait for threads to complete
    233251        }
    234         ENDTIME();
     252        ENDTIME( " x 5 " );
    235253#endif // 0
    236254#if 1
    … …  
    239257
    240258        sout | sepDisable;
    241         sout | nl | wd(13, "prng(t)" ) | wd(10, "prng(t,5)") | wd(13, "prng(t,0,5)" );
    242         for ( 20 ) {
    243                 sout | wd(13, prng( th )) | nonl;                               // cascading => side-effect functions called in arbitary order
    244                 sout | wd(10, prng( th, 5 )) | nonl;
    245                 sout | wd(13, prng( th, 0, 5 ));
     259        sout | nl | wd(26, "prng(t)" ) | wd(12, "prng(t,5)") | wd(12, "prng(t,0,5)" );
     260        for ( 20 ) {
     261                sout | wd(26, prng( th )) | nonl;                               // cascading => side-effect functions called in arbitary order
     262                sout | wd(12, prng( th, 5 )) | nonl;
     263                sout | wd(12, prng( th, 0, 5 ));
    246264        } // for
    247265        sout | sepEnable;
    … …  
    266284#endif // 0
    267285//      malloc_stats();
     286        // freelocale( loc );
    268287} // main
    269288
Note: See TracChangeset for help on using the changeset viewer.