Changeset d800676 for libcfa

Timestamp:

Mar 23, 2023, 12:18:39 PM (2 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, ast-experimental, master

Children:

c94b1f0

Parents:

1afd9ccb (diff), 18ea270 (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

Location:

libcfa/src

Files:

• Makefile.am (modified) (2 diffs)
• bits/random.hfa (modified) (18 diffs)
• concurrency/channel.hfa (modified) (1 diff)
• concurrency/mutex_stmt.hfa (modified) (1 diff)
• containers/list.hfa (modified) (1 diff)

libcfa/src/Makefile.am ¶

@@ -48 +48 @@
         math.hfa \
         time_t.hfa \
-    virtual_dtor.hfa \
+        virtual_dtor.hfa \
         bits/algorithm.hfa \
         bits/align.hfa \
@@ -69 +69 @@
         vec/vec2.hfa \
         vec/vec3.hfa \
-        vec/vec4.hfa 
+        vec/vec4.hfa
 
 inst_headers_src = \

libcfa/src/bits/random.hfa ¶

@@ -10 +10 @@
 // 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 +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 +57 @@
 #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 +85 @@
 #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 +104 @@
 #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 +131 @@
 #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 +208 @@
 
 #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 +229 @@
 
 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 +247 @@
 
 #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 +268 @@
 
 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 +286 @@
 
 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 +303 @@
 
 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 +317 @@
 
 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 +323 @@
 // 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 +338 @@
 
 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 +344 @@
 // 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 +366 @@
 
 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 +377 @@
 // 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)

libcfa/src/concurrency/channel.hfa ¶

@@ -28 +28 @@
     exp_backoff_then_block_lock c_lock, p_lock;
     __spinlock_t mutex_lock;
+    char __padding[64]; // avoid false sharing in arrays
 };
 

libcfa/src/concurrency/mutex_stmt.hfa ¶

@@ -27 +27 @@
     // 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]);
-    // }
 }
 

libcfa/src/containers/list.hfa ¶

@@ -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; \