Changeset 8a2f7f1


Ignore:
Timestamp:
Apr 15, 2023, 4:52:59 PM (13 months ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
ADT, ast-experimental, master
Children:
c831073
Parents:
1b8fc06c
Message:

fix PRNG test to work correctly on ARM

Location:
tests
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • tests/.expect/PRNG.x64.txt

    r1b8fc06c r8a2f7f1  
     1
     2CFA xoshiro256pp
    13
    24                    PRNG()     PRNG(5)   PRNG(0,5)
    … …  
    5658
    5759Sequential
    58 trials 100000000 buckets 100000 min 875 max 1146 avg 1000.0 std 31.6 rstd 3.2%
     60trials 20000000 buckets 100000 min 139 max 265 avg 200.0 std 14.1 rstd 7.0%
    5961
    6062Concurrent
    61 trials 100000000 buckets 100000 min 875 max 1146 avg 1000.0 std 31.6 rstd 3.2%
    62 trials 100000000 buckets 100000 min 875 max 1146 avg 1000.0 std 31.6 rstd 3.2%
    63 trials 100000000 buckets 100000 min 875 max 1146 avg 1000.0 std 31.6 rstd 3.2%
    64 trials 100000000 buckets 100000 min 875 max 1146 avg 1000.0 std 31.6 rstd 3.2%
     63trials 20000000 buckets 100000 min 139 max 265 avg 200.0 std 14.1 rstd 7.0%
     64trials 20000000 buckets 100000 min 139 max 265 avg 200.0 std 14.1 rstd 7.0%
     65trials 20000000 buckets 100000 min 139 max 265 avg 200.0 std 14.1 rstd 7.0%
     66trials 20000000 buckets 100000 min 139 max 265 avg 200.0 std 14.1 rstd 7.0%
    6567
    6668                   prng(t)   prng(t,5) prng(t,0,5)

  • tests/PRNG.cfa

    r1b8fc06c r8a2f7f1  
    88// Created On       : Wed Dec 29 09:38:12 2021
    99// Last Modified By : Peter A. Buhr
    10 // Last Modified On : Wed Dec 21 20:39:59 2022
    11 // Update Count     : 406
     10// Last Modified On : Sat Apr 15 16:44:31 2023
     11// Update Count     : 419
    1212//
    1313
    … …  
    1515#include <stdlib.hfa>                                                                   // PRNG
    1616#include <clock.hfa>
    17 #include <thread.hfa>
    1817#include <limits.hfa>                                                                   // MAX
    1918#include <math.hfa>                                                                             // sqrt
    2019#include <malloc.h>                                                                             // malloc_stats
    2120#include <locale.h>                                                                             // setlocale
     21#include <thread.hfa>
    2222#include <mutex_stmt.hfa>
    2323
    24 #ifdef __x86_64__                                                                               // 64-bit architecture
     24#define xstr(s) str(s)
     25#define str(s) #s
     26
     27#if defined( __x86_64__ ) || defined( __aarch64__ )             // 64-bit architecture
    2528#define PRNG PRNG64
    2629#else                                                                                                   // 32-bit architecture
    2730#define PRNG PRNG32
    2831#endif // __x86_64__
     32
     33//#define TIME
    2934
    3035#ifdef TIME                                                                                             // use -O2 -nodebug
    … …  
    3843#endif // TIME
    3944
    40 void avgstd( unsigned int buckets[] ) {
    41         unsigned int min = MAX, max = 0;
     45static void avgstd( size_t trials, size_t buckets[] ) {
     46        size_t min = MAX, max = 0;
    4247        double sum = 0.0, diff;
    4348        for ( i; BUCKETS ) {
    … …  
    5459        } // for
    5560        double std = sqrt( sum / BUCKETS );
    56         mutex( sout ) sout | "trials"  | TRIALS | "buckets" | BUCKETS
     61        mutex( sout ) sout | "trials"  | trials | "buckets" | BUCKETS
    5762                | "min" | min | "max" | max
    5863                | "avg" | wd(0,1, avg) | "std" | wd(0,1, std) | "rstd" | wd(0,1, (avg == 0 ? 0.0 : std / avg * 100)) | "%";
    … …  
    6469thread T1 {};
    6570void main( T1 & ) {
    66         unsigned int * buckets = calloc( BUCKETS );                     // too big for task stack
    67         for ( TRIALS / 100 ) {
     71        size_t * buckets = calloc( BUCKETS );                           // too big for task stack
     72        for ( TRIALS / 50 ) {
    6873                buckets[rand() % BUCKETS] += 1;                                 // concurrent
    6974        } // for
    70         avgstd( buckets );
     75        avgstd( TRIALS / 50, buckets );
    7176        free( buckets );
    7277} // main
    … …  
    7681        PRNG prng;
    7782        if ( seed != 0 ) set_seed( prng, seed );
    78         unsigned int * buckets = calloc( BUCKETS );                     // too big for task stack
     83        size_t * buckets = calloc( BUCKETS );                           // too big for task stack
    7984        for ( TRIALS ) {
    8085                buckets[prng( prng ) % BUCKETS] += 1;                   // concurrent
    8186        } // for
    82         avgstd( buckets );
     87        avgstd( TRIALS, buckets );
    8388        free( buckets );
    8489} // main
    … …  
    8691thread T3 {};
    8792void main( T3 & th ) {
    88         unsigned int * buckets = calloc( BUCKETS );                     // too big for task stack
    89         for ( TRIALS ) {
     93        size_t * buckets = calloc( BUCKETS );                           // too big for task stack
     94        for ( TRIALS / 5 ) {
    9095                buckets[prng() % BUCKETS] += 1;                                 // concurrent
    9196        } // for
    92         avgstd( buckets );
     97        avgstd( TRIALS / 5, buckets );
    9398        free( buckets );
    9499} // main
    … …  
    96101thread T4 {};
    97102void main( T4 & th ) {
    98         unsigned int * buckets = calloc( BUCKETS );                     // too big for task stack
     103        size_t * buckets = calloc( BUCKETS );                           // too big for task stack
    99104        for ( TRIALS ) {
    100                 buckets[prng( th ) % BUCKETS] += 1;     // concurrent
    101         } // for
    102         avgstd( buckets );
     105                buckets[prng( th ) % BUCKETS] += 1;                             // concurrent
     106        } // for
     107        avgstd( TRIALS, buckets );
    103108        free( buckets );
    104109} // main
    … …  
    108113static void dummy( thread$ & th ) __attribute__(( noinline ));
    109114static 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 ) {
     115        size_t * buckets = (size_t *)calloc( BUCKETS, sizeof(size_t) ); // too big for task stack
     116        for ( size_t i = 0; i < TRIALS; i += 1 ) {
    112117                buckets[prng( th ) % BUCKETS] += 1;                             // sequential
    113118        } // for
    114         avgstd( buckets );
     119        avgstd( TRIALS, buckets );
    115120        free( buckets );
    116121} // dummy
    … …  
    126131        enum { TASKS = 4 };
    127132        Time start;
     133
    128134#ifdef TIME                                                                                             // too slow for test and generates non-repeatable results
    129135#if 1
    130         unsigned int rseed;
     136        sout | "glib rand" | nl | nl;
     137
     138        size_t rseed;
    131139        if ( seed != 0 ) rseed = seed;
    132140        else rseed = rdtscl();
    … …  
    134142
    135143        sout | sepDisable;
    136         sout | wd(26, "rand()" ) | wd(12, "rand(5)") | wd(12, "rand(0,5)" );
     144        sout | nl | wd(26, "rand()" ) | wd(12, "rand(5)") | wd(12, "rand(0,5)" );
    137145        for ( 20 ) {
    138146                sout | wd(26, rand()) | nonl;
    … …  
    146154        STARTTIME;
    147155        {
    148                 unsigned int * buckets = calloc( BUCKETS );             // too big for task stack
    149                 for ( i; TRIALS / 10 ) {
     156                size_t * buckets = calloc( BUCKETS );                   // too big for task stack
     157                for ( i; TRIALS / 5 ) {
    150158                        buckets[rand() % BUCKETS] += 1;                         // sequential
    151159                } // for
    152                 avgstd( buckets );
     160                avgstd( TRIALS / 5, buckets );
    153161                free( buckets );
    154162        }
    155         ENDTIME( " x 10 " );
     163        ENDTIME( " x 5 " );
    156164
    157165        sout | nl | "Concurrent";
    … …  
    163171                } // wait for threads to complete
    164172        }
    165         ENDTIME( " x 100 " );
     173        ENDTIME( " x 50 " );
    166174#endif // 0
    167175#endif // TIME
     176
     177        sout | nl | "CFA " xstr(PRNG_NAME);
     178
    168179#if 1
    169180        PRNG prng;
    … …  
    184195        STARTTIME;
    185196        {
    186                 unsigned int * buckets = calloc( BUCKETS );             // too big for task stack
     197                size_t * buckets = calloc( BUCKETS );                   // too big for task stack
    187198                for ( TRIALS ) {
    188199                        buckets[prng( prng ) % BUCKETS] += 1;           // sequential
    189200                } // for
    190                 avgstd( buckets );
     201                avgstd( TRIALS, buckets );
    191202                free( buckets );
    192203        }
    … …  
    219230        STARTTIME;
    220231        {
    221                 unsigned int * buckets = calloc( BUCKETS );             // too big for task stack
    222                 for ( TRIALS ) {
     232                size_t * buckets = calloc( BUCKETS );                   // too big for task stack
     233                for ( TRIALS / 5 ) {
    223234                        buckets[prng() % BUCKETS] += 1;
    224235                } // for
    225                 avgstd( buckets );
     236                avgstd( TRIALS / 5, buckets );
    226237                free( buckets );
    227238        }
    228         ENDTIME();
     239        ENDTIME( " x 5 " );
    229240
    230241        sout | nl | "Concurrent";
    … …  
    236247                } // wait for threads to complete
    237248        }
    238         ENDTIME();
     249        ENDTIME( " x 5 " );
    239250#endif // 0
    240251#if 1
Note: See TracChangeset for help on using the changeset viewer.