Index: libcfa/src/Makefile.am =================================================================== --- libcfa/src/Makefile.am (revision 1afd9ccb9da2e410d6a44ba8624d04df80915ada) +++ libcfa/src/Makefile.am (revision 056bee803aecbc2db1ac1b7607c78dcf1a8d13f7) @@ -48,5 +48,5 @@ math.hfa \ time_t.hfa \ - virtual_dtor.hfa \ + virtual_dtor.hfa \ bits/algorithm.hfa \ bits/align.hfa \ @@ -69,5 +69,5 @@ vec/vec2.hfa \ vec/vec3.hfa \ - vec/vec4.hfa + vec/vec4.hfa inst_headers_src = \ Index: libcfa/src/bits/random.hfa =================================================================== --- libcfa/src/bits/random.hfa (revision 1afd9ccb9da2e410d6a44ba8624d04df80915ada) +++ libcfa/src/bits/random.hfa (revision 056bee803aecbc2db1ac1b7607c78dcf1a8d13f7) @@ -10,6 +10,6 @@ // Created On : Fri Jan 14 07:18:11 2022 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Dec 22 20:54:22 2022 -// Update Count : 178 +// Last Modified On : Mon Mar 20 21:45:24 2023 +// Update Count : 186 // @@ -28,26 +28,28 @@ #define XOSHIRO256PP //#define KISS_64 + // #define SPLITMIX_64 // 32-bit generators //#define XORSHIFT_6_21_7 #define XOSHIRO128PP + // #define SPLITMIX_32 #else // 32-bit architecture // 64-bit generators //#define XORSHIFT_13_7_17 #define XOSHIRO256PP + // #define SPLITMIX_64 // 32-bit generators //#define XORSHIFT_6_21_7 #define XOSHIRO128PP + // #define SPLITMIX_32 #endif // __x86_64__ // Define C/CFA PRNG name and random-state. - -// SKULLDUGGERY: typedefs name struct and typedef with the same name to deal with CFA typedef numbering problem. #ifdef XOSHIRO256PP #define PRNG_NAME_64 xoshiro256pp #define PRNG_STATE_64_T GLUE(PRNG_NAME_64,_t) -typedef struct PRNG_STATE_64_T { uint64_t s0, s1, s2, s3; } PRNG_STATE_64_T; +typedef struct { uint64_t s0, s1, s2, s3; } PRNG_STATE_64_T; #endif // XOSHIRO256PP @@ -55,5 +57,5 @@ #define PRNG_NAME_32 xoshiro128pp #define PRNG_STATE_32_T GLUE(PRNG_NAME_32,_t) -typedef struct PRNG_STATE_32_T { uint32_t s0, s1, s2, s3; } PRNG_STATE_32_T; +typedef struct { uint32_t s0, s1, s2, s3; } PRNG_STATE_32_T; #endif // XOSHIRO128PP @@ -83,8 +85,18 @@ #endif // XORSHIFT_12_25_27 +#ifdef SPLITMIX_64 +#define PRNG_NAME_64 splitmix64 +#define PRNG_STATE_64_T uint64_t +#endif // SPLITMIX32 + +#ifdef SPLITMIX_32 +#define PRNG_NAME_32 splitmix32 +#define PRNG_STATE_32_T uint32_t +#endif // SPLITMIX32 + #ifdef KISS_64 #define PRNG_NAME_64 kiss_64 #define PRNG_STATE_64_T GLUE(PRNG_NAME_64,_t) -typedef struct PRNG_STATE_64_T { uint64_t z, w, jsr, jcong; } PRNG_STATE_64_T; +typedef struct { uint64_t z, w, jsr, jcong; } PRNG_STATE_64_T; #endif // KISS_^64 @@ -92,5 +104,5 @@ #define PRNG_NAME_32 xorwow #define PRNG_STATE_32_T GLUE(PRNG_NAME_32,_t) -typedef struct PRNG_STATE_32_T { uint32_t a, b, c, d, counter; } PRNG_STATE_32_T; +typedef struct { uint32_t a, b, c, d, counter; } PRNG_STATE_32_T; #endif // XOSHIRO128PP @@ -119,4 +131,70 @@ #ifdef __cforall // don't include in C code (invoke.h) +// https://rosettacode.org/wiki/Pseudo-random_numbers/Splitmix64 +// +// Splitmix64 is not recommended for demanding random number requirements, but is often used to calculate initial states +// for other more complex pseudo-random number generators (see https://prng.di.unimi.it). +// Also https://rosettacode.org/wiki/Pseudo-random_numbers/Splitmix64. +static inline uint64_t splitmix64( uint64_t & state ) { + state += 0x9e3779b97f4a7c15; + uint64_t z = state; + z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9; + z = (z ^ (z >> 27)) * 0x94d049bb133111eb; + return z ^ (z >> 31); +} // splitmix64 + +static inline void splitmix64_set_seed( uint64_t & state , uint64_t seed ) { + state = seed; + splitmix64( state ); // prime +} // splitmix64_set_seed + +// https://github.com/bryc/code/blob/master/jshash/PRNGs.md#splitmix32 +// +// Splitmix32 is not recommended for demanding random number requirements, but is often used to calculate initial states +// for other more complex pseudo-random number generators (see https://prng.di.unimi.it). + +static inline uint32_t splitmix32( uint32_t & state ) { + state += 0x9e3779b9; + uint64_t z = state; + z = (z ^ (z >> 15)) * 0x85ebca6b; + z = (z ^ (z >> 13)) * 0xc2b2ae35; + return z ^ (z >> 16); +} // splitmix32 + +static inline void splitmix32_set_seed( uint32_t & state, uint64_t seed ) { + state = seed; + splitmix32( state ); // prime +} // splitmix32_set_seed + +#ifdef __SIZEOF_INT128__ +//-------------------------------------------------- +static inline uint64_t lehmer64( __uint128_t & state ) { + __uint128_t ret = state; + state *= 0x_da94_2042_e4dd_58b5; + return ret >> 64; +} // lehmer64 + +static inline void lehmer64_set_seed( __uint128_t & state, uint64_t seed ) { + // The seed needs to be coprime with the 2^64 modulus to get the largest period, so no factors of 2 in the seed. + state = splitmix64( seed ); // prime +} // lehmer64_set_seed + +//-------------------------------------------------- +static inline uint64_t wyhash64( uint64_t & state ) { + uint64_t ret = state; + state += 0x_60be_e2be_e120_fc15; + __uint128_t tmp; + tmp = (__uint128_t) ret * 0x_a3b1_9535_4a39_b70d; + uint64_t m1 = (tmp >> 64) ^ tmp; + tmp = (__uint128_t)m1 * 0x_1b03_7387_12fa_d5c9; + uint64_t m2 = (tmp >> 64) ^ tmp; + return m2; +} // wyhash64 + +static inline void wyhash64_set_seed( uint64_t & state, uint64_t seed ) { + state = splitmix64( seed ); // prime +} // wyhash64_set_seed +#endif // __SIZEOF_INT128__ + // https://prng.di.unimi.it/xoshiro256starstar.c // @@ -130,5 +208,5 @@ #ifndef XOSHIRO256PP -typedef struct xoshiro256pp_t { uint64_t s0, s1, s2, s3; } xoshiro256pp_t; +typedef struct { uint64_t s0, s1, s2, s3; } xoshiro256pp_t; #endif // ! XOSHIRO256PP @@ -151,6 +229,10 @@ static inline void xoshiro256pp_set_seed( xoshiro256pp_t & state, uint64_t seed ) { - state = (xoshiro256pp_t){ seed, seed, seed, seed }; - xoshiro256pp( state ); + // To attain repeatable seeding, compute seeds separately because the order of argument evaluation is undefined. + uint64_t seed1 = splitmix64( seed ); // prime + uint64_t seed2 = splitmix64( seed ); + uint64_t seed3 = splitmix64( seed ); + uint64_t seed4 = splitmix64( seed ); + state = (xoshiro256pp_t){ seed1, seed2, seed3, seed4 }; } // xoshiro256pp_set_seed @@ -165,5 +247,5 @@ #ifndef XOSHIRO128PP -typedef struct xoshiro128pp_t { uint32_t s0, s1, s2, s3; } xoshiro128pp_t; +typedef struct { uint32_t s0, s1, s2, s3; } xoshiro128pp_t; #endif // ! XOSHIRO128PP @@ -186,39 +268,11 @@ static inline void xoshiro128pp_set_seed( xoshiro128pp_t & state, uint32_t seed ) { - state = (xoshiro128pp_t){ seed, seed, seed, seed }; - xoshiro128pp( state ); // prime + // To attain repeatable seeding, compute seeds separately because the order of argument evaluation is undefined. + uint32_t seed1 = splitmix32( seed ); // prime + uint32_t seed2 = splitmix32( seed ); + uint32_t seed3 = splitmix32( seed ); + uint32_t seed4 = splitmix32( seed ); + state = (xoshiro128pp_t){ seed1, seed2, seed3, seed4 }; } // xoshiro128pp_set_seed - -#ifdef __SIZEOF_INT128__ - //-------------------------------------------------- - static inline uint64_t lehmer64( __uint128_t & state ) { - __uint128_t ret = state; - state *= 0x_da94_2042_e4dd_58b5; - return ret >> 64; - } // lehmer64 - - static inline void lehmer64_set_seed( __uint128_t & state, uint64_t seed ) { - // The seed needs to be coprime with the 2^64 modulus to get the largest period, so no factors of 2 in the seed. - state = seed; - lehmer64( state ); // prime - } // lehmer64_set_seed - - //-------------------------------------------------- - static inline uint64_t wyhash64( uint64_t & state ) { - uint64_t ret = state; - state += 0x_60be_e2be_e120_fc15; - __uint128_t tmp; - tmp = (__uint128_t) ret * 0x_a3b1_9535_4a39_b70d; - uint64_t m1 = (tmp >> 64) ^ tmp; - tmp = (__uint128_t)m1 * 0x_1b03_7387_12fa_d5c9; - uint64_t m2 = (tmp >> 64) ^ tmp; - return m2; - } // wyhash64 - - static inline void wyhash64_set_seed( uint64_t & state, uint64_t seed ) { - state = seed; - wyhash64( state ); // prime - } // wyhash64_set_seed -#endif // __SIZEOF_INT128__ //-------------------------------------------------- @@ -232,6 +286,5 @@ static inline void xorshift_13_7_17_set_seed( uint64_t & state, uint64_t seed ) { - state = seed; - xorshift_13_7_17( state ); // prime + state = splitmix64( seed ); // prime } // xorshift_13_7_17_set_seed @@ -250,6 +303,5 @@ static inline void xorshift_6_21_7_set_seed( uint32_t & state, uint32_t seed ) { - state = seed; - xorshift_6_21_7( state ); // prime + state = splitmix32( seed ); // prime } // xorshift_6_21_7_set_seed @@ -265,6 +317,5 @@ static inline void xorshift_12_25_27_set_seed( uint64_t & state, uint64_t seed ) { - state = seed; - xorshift_12_25_27( state ); // prime + state = splitmix64( seed ); // prime } // xorshift_12_25_27_set_seed @@ -272,5 +323,5 @@ // The state must be seeded with a nonzero value. #ifndef KISS_64 -typedef struct kiss_64_t { uint64_t z, w, jsr, jcong; } kiss_64_t; +typedef struct { uint64_t z, w, jsr, jcong; } kiss_64_t; #endif // ! KISS_64 @@ -287,6 +338,5 @@ static inline void kiss_64_set_seed( kiss_64_t & rs, uint64_t seed ) with(rs) { - z = 1; w = 1; jsr = 4; jcong = seed; - kiss_64( rs ); // prime + z = 1; w = 1; jsr = 4; jcong = splitmix64( seed ); // prime } // kiss_64_set_seed @@ -294,5 +344,5 @@ // The state array must be initialized to non-zero in the first four words. #ifndef XORWOW -typedef struct xorwow_t { uint32_t a, b, c, d, counter; } xorwow_t; +typedef struct { uint32_t a, b, c, d, counter; } xorwow_t; #endif // ! XORWOW @@ -316,6 +366,10 @@ static inline void xorwow_set_seed( xorwow_t & rs, uint32_t seed ) { - rs = (xorwow_t){ seed, seed, seed, seed, 0 }; - xorwow( rs ); // prime + // To attain repeatable seeding, compute seeds separately because the order of argument evaluation is undefined. + uint32_t seed1 = splitmix32( seed ); // prime + uint32_t seed2 = splitmix32( seed ); + uint32_t seed3 = splitmix32( seed ); + uint32_t seed4 = splitmix32( seed ); + rs = (xorwow_t){ seed1, seed2, seed3, seed4, 0 }; } // xorwow_set_seed @@ -323,6 +377,6 @@ // Used in __tls_rand_fwd #define M (1_l64u << 48_l64u) -#define A (25214903917_l64u) -#define AI (18446708753438544741_l64u) +#define A (25_214_903_917_l64u) +#define AI (18_446_708_753_438_544_741_l64u) #define C (11_l64u) #define D (16_l64u) Index: libcfa/src/concurrency/channel.hfa =================================================================== --- libcfa/src/concurrency/channel.hfa (revision 1afd9ccb9da2e410d6a44ba8624d04df80915ada) +++ libcfa/src/concurrency/channel.hfa (revision 056bee803aecbc2db1ac1b7607c78dcf1a8d13f7) @@ -28,4 +28,5 @@ exp_backoff_then_block_lock c_lock, p_lock; __spinlock_t mutex_lock; + char __padding[64]; // avoid false sharing in arrays }; Index: libcfa/src/concurrency/mutex_stmt.hfa =================================================================== --- libcfa/src/concurrency/mutex_stmt.hfa (revision 1afd9ccb9da2e410d6a44ba8624d04df80915ada) +++ libcfa/src/concurrency/mutex_stmt.hfa (revision 056bee803aecbc2db1ac1b7607c78dcf1a8d13f7) @@ -27,15 +27,4 @@ // Sort locks based on address __libcfa_small_sort(this.lockarr, count); - - // acquire locks in order - // for ( size_t i = 0; i < count; i++ ) { - // lock(*this.lockarr[i]); - // } -} - -static inline void ^?{}( __mutex_stmt_lock_guard & this ) with(this) { - // for ( size_t i = count; i > 0; i-- ) { - // unlock(*lockarr[i - 1]); - // } } Index: libcfa/src/containers/list.hfa =================================================================== --- libcfa/src/containers/list.hfa (revision 1afd9ccb9da2e410d6a44ba8624d04df80915ada) +++ libcfa/src/containers/list.hfa (revision 056bee803aecbc2db1ac1b7607c78dcf1a8d13f7) @@ -32,8 +32,32 @@ static inline tytagref(void, T) ?`inner ( T & this ) { tytagref( void, T ) ret = {this}; return ret; } -// use this on every case of plan-9 inheritance, to make embedded a closure of plan-9 inheritance -#define P9_EMBEDDED( derived, immedBase ) \ -forall( Tbase &, TdiscardPath & | { tytagref( TdiscardPath, Tbase ) ?`inner( immedBase & ); } ) \ - static inline tytagref(immedBase, Tbase) ?`inner( derived & this ) { \ + +// +// P9_EMBEDDED: Use on every case of plan-9 inheritance, to make "implements embedded" be a closure of plan-9 inheritance. +// +// struct foo { +// int a, b, c; +// inline (bar); +// }; +// P9_EMBEDDED( foo, bar ) +// + +// usual version, for structs that are top-level declarations +#define P9_EMBEDDED( derived, immedBase ) P9_EMBEDDED_DECL_( derived, immedBase, static ) P9_EMBEDDED_BDY_( immedBase ) + +// special version, for structs that are declared in functions +#define P9_EMBEDDED_INFUNC( derived, immedBase ) P9_EMBEDDED_DECL_( derived, immedBase, ) P9_EMBEDDED_BDY_( immedBase ) + +// forward declarations of both the above; generally not needed +// may help you control where the P9_EMBEEDED cruft goes, in case "right after the stuct" isn't where you want it +#define P9_EMBEDDED_FWD( derived, immedBase ) P9_EMBEDDED_DECL_( derived, immedBase, static ) ; +#define P9_EMBEDDED_FWD_INFUNC( derived, immedBase ) auto P9_EMBEDDED_DECL_( derived, immedBase, ) ; + +// private helpers +#define P9_EMBEDDED_DECL_( derived, immedBase, STORAGE ) \ + forall( Tbase &, TdiscardPath & | { tytagref( TdiscardPath, Tbase ) ?`inner( immedBase & ); } ) \ + STORAGE inline tytagref(immedBase, Tbase) ?`inner( derived & this ) + +#define P9_EMBEDDED_BDY_( immedBase ) { \ immedBase & ib = this; \ Tbase & b = ib`inner; \