[bd85400] | 1 | // |
---|
| 2 | // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo |
---|
| 3 | // |
---|
| 4 | // The contents of this file are covered under the licence agreement in the |
---|
| 5 | // file "LICENCE" distributed with Cforall. |
---|
| 6 | // |
---|
[bb82c03] | 7 | // stdlib -- |
---|
[bd85400] | 8 | // |
---|
| 9 | // Author : Peter A. Buhr |
---|
| 10 | // Created On : Thu Jan 28 17:12:35 2016 |
---|
[b89c7c2] | 11 | // Last Modified By : Peter A. Buhr |
---|
[d4264e8] | 12 | // Last Modified On : Fri Apr 19 09:47:55 2024 |
---|
| 13 | // Update Count : 826 |
---|
[bd85400] | 14 | // |
---|
| 15 | |
---|
[53a6c2a] | 16 | #pragma once |
---|
[17e5e2b] | 17 | |
---|
[94429f8] | 18 | #include "bits/defs.hfa" // OPTIONAL_THREAD |
---|
| 19 | #include "bits/align.hfa" // libAlign |
---|
[12b5e94a] | 20 | #include "bits/random.hfa" // prng |
---|
[b5e725a] | 21 | #include <Exception.hfa> |
---|
| 22 | #include <heap.hfa> |
---|
[2026bb6] | 23 | |
---|
[d46ed6e] | 24 | #include <stdlib.h> // *alloc, strto*, ato* |
---|
[76acb60] | 25 | #include <errno.h> |
---|
[2210cfc] | 26 | |
---|
[ca7949b] | 27 | // Reduce includes by explicitly defining these routines. |
---|
[3ce0d440] | 28 | extern "C" { |
---|
[4e7c0fc0] | 29 | void * memalign( size_t alignment, size_t size ); // malloc.h |
---|
| 30 | void * pvalloc( size_t size ); // malloc.h |
---|
[b9c04946] | 31 | void * memset( void * dest, int fill, size_t size ); // string.h |
---|
[57fc7d8] | 32 | void * memcpy( void * dest, const void * src, size_t size ); // string.h |
---|
[3ce0d440] | 33 | } // extern "C" |
---|
[e672372] | 34 | |
---|
[bd85400] | 35 | //--------------------------------------- |
---|
| 36 | |
---|
[45161b4d] | 37 | #ifndef EXIT_FAILURE |
---|
| 38 | #define EXIT_FAILURE 1 // failing exit status |
---|
| 39 | #define EXIT_SUCCESS 0 // successful exit status |
---|
| 40 | #endif // ! EXIT_FAILURE |
---|
| 41 | |
---|
| 42 | //--------------------------------------- |
---|
| 43 | |
---|
[c354108] | 44 | #include "common.hfa" |
---|
| 45 | |
---|
| 46 | //--------------------------------------- |
---|
| 47 | |
---|
[fd54fef] | 48 | static inline forall( T & | sized(T) ) { |
---|
[d4264e8] | 49 | // CFA safe equivalents, i.e., implicit size specification, eliminate return-type cast |
---|
[3ce0d440] | 50 | |
---|
[74b19fb] | 51 | T * malloc( void ) { |
---|
[aa0a1ad] | 52 | if ( _Alignof(T) <= libAlign() ) return (T *)malloc( sizeof(T) ); // C allocation |
---|
[68f0c4e] | 53 | else return (T *)memalign( _Alignof(T), sizeof(T) ); |
---|
[74b19fb] | 54 | } // malloc |
---|
| 55 | |
---|
[856fe3e] | 56 | T * aalloc( size_t dim ) { |
---|
[aa0a1ad] | 57 | if ( _Alignof(T) <= libAlign() ) return (T *)aalloc( dim, sizeof(T) ); // C allocation |
---|
| 58 | else return (T *)amemalign( _Alignof(T), dim, sizeof(T) ); |
---|
[856fe3e] | 59 | } // aalloc |
---|
| 60 | |
---|
[74b19fb] | 61 | T * calloc( size_t dim ) { |
---|
[aa0a1ad] | 62 | if ( _Alignof(T) <= libAlign() ) return (T *)calloc( dim, sizeof(T) ); // C allocation |
---|
| 63 | else return (T *)cmemalign( _Alignof(T), dim, sizeof(T) ); |
---|
[74b19fb] | 64 | } // calloc |
---|
| 65 | |
---|
[d4264e8] | 66 | T * resize( T * ptr, size_t size ) { |
---|
| 67 | if ( _Alignof(T) <= libAlign() ) return (T *)resize( (void *)ptr, size ); // C resize |
---|
[aa0a1ad] | 68 | else return (T *)resize( (void *)ptr, _Alignof(T), size ); // CFA resize |
---|
[856fe3e] | 69 | } // resize |
---|
| 70 | |
---|
[d4264e8] | 71 | T * resize( T * ptr, size_t alignment, size_t size ) { |
---|
| 72 | return (T *)resize( (void *)ptr, alignment, size ); // CFA resize |
---|
| 73 | } // resize |
---|
| 74 | |
---|
[710d0c8c] | 75 | T * realloc( T * ptr, size_t size ) { // CFA realloc |
---|
[aa0a1ad] | 76 | if ( _Alignof(T) <= libAlign() ) return (T *)realloc( (void *)ptr, size ); // C realloc |
---|
| 77 | else return (T *)realloc( (void *)ptr, _Alignof(T), size ); // CFA realloc |
---|
[74b19fb] | 78 | } // realloc |
---|
| 79 | |
---|
[d4264e8] | 80 | T * realloc( T * ptr, size_t alignment, size_t size ) { |
---|
| 81 | return (T *)realloc( (void *)ptr, alignment, size ); // CFA realloc |
---|
| 82 | } // realloc |
---|
| 83 | |
---|
[710d0c8c] | 84 | T * reallocarray( T * ptr, size_t dim ) { // CFA reallocarray |
---|
| 85 | if ( _Alignof(T) <= libAlign() ) return (T *)reallocarray( (void *)ptr, dim, sizeof(T) ); // C reallocarray |
---|
| 86 | else return (T *)reallocarray( (void *)ptr, _Alignof(T), dim ); // CFA reallocarray |
---|
| 87 | } // realloc |
---|
| 88 | |
---|
[d4264e8] | 89 | T * reallocarray( T * ptr, size_t alignment, size_t dim ) { |
---|
| 90 | return (T *)reallocarray( (void *)ptr, alignment, dim ); // CFA reallocarray |
---|
| 91 | } // realloc |
---|
| 92 | |
---|
[74b19fb] | 93 | T * memalign( size_t align ) { |
---|
[cafb687] | 94 | return (T *)memalign( align, sizeof(T) ); // C memalign |
---|
[74b19fb] | 95 | } // memalign |
---|
| 96 | |
---|
[856fe3e] | 97 | T * amemalign( size_t align, size_t dim ) { |
---|
| 98 | return (T *)amemalign( align, dim, sizeof(T) ); // CFA amemalign |
---|
| 99 | } // amemalign |
---|
| 100 | |
---|
[d4264e8] | 101 | T * cmemalign( size_t align, size_t dim ) { |
---|
[d74369b] | 102 | return (T *)cmemalign( align, dim, sizeof(T) ); // CFA cmemalign |
---|
| 103 | } // cmemalign |
---|
| 104 | |
---|
[74b19fb] | 105 | T * aligned_alloc( size_t align ) { |
---|
[cafb687] | 106 | return (T *)aligned_alloc( align, sizeof(T) ); // C aligned_alloc |
---|
[74b19fb] | 107 | } // aligned_alloc |
---|
| 108 | |
---|
| 109 | int posix_memalign( T ** ptr, size_t align ) { |
---|
| 110 | return posix_memalign( (void **)ptr, align, sizeof(T) ); // C posix_memalign |
---|
| 111 | } // posix_memalign |
---|
[ada0246d] | 112 | |
---|
| 113 | T * valloc( void ) { |
---|
| 114 | return (T *)valloc( sizeof(T) ); // C valloc |
---|
| 115 | } // valloc |
---|
| 116 | |
---|
| 117 | T * pvalloc( void ) { |
---|
| 118 | return (T *)pvalloc( sizeof(T) ); // C pvalloc |
---|
| 119 | } // pvalloc |
---|
[55acc3a] | 120 | } // distribution |
---|
| 121 | |
---|
[ceb7db8] | 122 | /* |
---|
| 123 | FIX ME : fix alloc interface after Ticker Number 214 is resolved, define and add union to S_fill. Then, modify postfix-fill functions to support T * with nmemb, char, and T object of any size. Finally, change alloc_internal. |
---|
| 124 | Or, just follow the instructions below for that. |
---|
| 125 | |
---|
| 126 | 1. Replace the current forall-block that contains defintions of S_fill and S_realloc with following: |
---|
[fd54fef] | 127 | forall( T & | sized(T) ) { |
---|
[b6a71bc] | 128 | union U_fill { char c; T * a; T t; }; |
---|
| 129 | struct S_fill { char tag; U_fill(T) fill; }; |
---|
| 130 | struct S_realloc { inline T *; }; |
---|
[ceb7db8] | 131 | } |
---|
| 132 | |
---|
| 133 | 2. Replace all current postfix-fill functions with following for updated S_fill: |
---|
[b6a71bc] | 134 | S_fill(T) ?`fill( char a ) { S_fill(T) ret = {'c'}; ret.fill.c = a; return ret; } |
---|
| 135 | S_fill(T) ?`fill( T a ) { S_fill(T) ret = {'t'}; memcpy(&ret.fill.t, &a, sizeof(T)); return ret; } |
---|
| 136 | S_fill(T) ?`fill( T a[], size_t nmemb ) { S_fill(T) ret = {'a', nmemb}; ret.fill.a = a; return ret; } |
---|
[ceb7db8] | 137 | |
---|
[6c5d92f] | 138 | 3. Replace the alloc_internal$ function which is outside ttype forall-block with following function: |
---|
| 139 | T * alloc_internal$( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill) { |
---|
[ceb7db8] | 140 | T * ptr = NULL; |
---|
| 141 | size_t size = sizeof(T); |
---|
| 142 | size_t copy_end = 0; |
---|
| 143 | |
---|
| 144 | if(Resize) { |
---|
| 145 | ptr = (T*) (void *) resize( (int *)Resize, Align, Dim * size ); |
---|
| 146 | } else if (Realloc) { |
---|
| 147 | if (Fill.tag != '0') copy_end = min(malloc_size( Realloc ), Dim * size); |
---|
| 148 | ptr = (T*) (void *) realloc( (int *)Realloc, Align, Dim * size ); |
---|
| 149 | } else { |
---|
| 150 | ptr = (T*) (void *) memalign( Align, Dim * size ); |
---|
| 151 | } |
---|
| 152 | |
---|
| 153 | if(Fill.tag == 'c') { |
---|
| 154 | memset( (char *)ptr + copy_end, (int)Fill.fill.c, Dim * size - copy_end ); |
---|
| 155 | } else if(Fill.tag == 't') { |
---|
| 156 | for ( int i = copy_end; i <= Dim * size - size ; i += size ) { |
---|
| 157 | memcpy( (char *)ptr + i, &Fill.fill.t, size ); |
---|
| 158 | } |
---|
| 159 | } else if(Fill.tag == 'a') { |
---|
| 160 | memcpy( (char *)ptr + copy_end, Fill.fill.a, min(Dim * size - copy_end, size * Fill.nmemb) ); |
---|
| 161 | } |
---|
| 162 | |
---|
| 163 | return ptr; |
---|
[6c5d92f] | 164 | } // alloc_internal$ |
---|
[ceb7db8] | 165 | */ |
---|
| 166 | |
---|
[b6a71bc] | 167 | typedef struct S_align { inline size_t; } T_align; |
---|
| 168 | typedef struct S_resize { inline void *; } T_resize; |
---|
[ceb7db8] | 169 | |
---|
[fd54fef] | 170 | forall( T & ) { |
---|
[b6a71bc] | 171 | struct S_fill { char tag; char c; size_t size; T * at; char t[50]; }; |
---|
| 172 | struct S_realloc { inline T *; }; |
---|
[ceb7db8] | 173 | } |
---|
| 174 | |
---|
[b6a71bc] | 175 | static inline T_align ?`align( size_t a ) { return (T_align){a}; } |
---|
| 176 | static inline T_resize ?`resize( void * a ) { return (T_resize){a}; } |
---|
[74b19fb] | 177 | |
---|
[fd54fef] | 178 | static inline forall( T & | sized(T) ) { |
---|
[d4264e8] | 179 | S_fill(T) ?`fill( T t ) { |
---|
[ceb7db8] | 180 | S_fill(T) ret = { 't' }; |
---|
| 181 | size_t size = sizeof(T); |
---|
[3d3d75e] | 182 | if ( size > sizeof(ret.t) ) { |
---|
| 183 | abort( "ERROR: const object of size greater than 50 bytes given for dynamic memory fill\n" ); |
---|
| 184 | } // if |
---|
[ceb7db8] | 185 | memcpy( &ret.t, &t, size ); |
---|
| 186 | return ret; |
---|
| 187 | } |
---|
[d4264e8] | 188 | S_fill(T) ?`fill( zero_t ) = void; // FIX ME: remove this once ticket 214 is resolved |
---|
| 189 | S_fill(T) ?`fill( T * a ) { return (S_fill(T)){ 'T', '0', 0, a }; } // FIX ME: remove this once ticket 214 is resolved |
---|
| 190 | S_fill(T) ?`fill( char c ) { return (S_fill(T)){ 'c', c }; } |
---|
| 191 | S_fill(T) ?`fill( T a[], size_t nmemb ) { return (S_fill(T)){ 'a', '0', nmemb * sizeof(T), a }; } |
---|
[ceb7db8] | 192 | |
---|
[b6a71bc] | 193 | S_realloc(T) ?`realloc ( T * a ) { return (S_realloc(T)){a}; } |
---|
[ceb7db8] | 194 | |
---|
[6c5d92f] | 195 | T * alloc_internal$( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill ) { |
---|
[ceb7db8] | 196 | T * ptr = NULL; |
---|
| 197 | size_t size = sizeof(T); |
---|
| 198 | size_t copy_end = 0; |
---|
[f67b983] | 199 | |
---|
| 200 | if ( Resize ) { |
---|
[b6a71bc] | 201 | ptr = (T*)(void *)resize( (void *)Resize, Align, Dim * size ); |
---|
[f67b983] | 202 | } else if ( Realloc ) { |
---|
[3d3d75e] | 203 | if ( Fill.tag != '0' ) copy_end = min(malloc_size( Realloc ), Dim * size ); |
---|
[b6a71bc] | 204 | ptr = (T *)(void *)realloc( (void *)Realloc, Align, Dim * size ); |
---|
[cfbc703d] | 205 | } else { |
---|
[b6a71bc] | 206 | ptr = (T *)(void *) memalign( Align, Dim * size ); |
---|
[ceb7db8] | 207 | } |
---|
| 208 | |
---|
[3d3d75e] | 209 | if ( Fill.tag == 'c' ) { |
---|
[ceb7db8] | 210 | memset( (char *)ptr + copy_end, (int)Fill.c, Dim * size - copy_end ); |
---|
[3d3d75e] | 211 | } else if ( Fill.tag == 't' ) { |
---|
[f6a4917] | 212 | for ( i; copy_end ~ Dim * size ~ size ) { |
---|
[3d3d75e] | 213 | #pragma GCC diagnostic push |
---|
| 214 | #pragma GCC diagnostic ignored "-Wmaybe-uninitialized" |
---|
[d1b70d4] | 215 | assert( size <= sizeof(Fill.t) ); |
---|
| 216 | memcpy( (char *)ptr + i, &Fill.t, size ); |
---|
[3d3d75e] | 217 | #pragma GCC diagnostic pop |
---|
[ceb7db8] | 218 | } |
---|
[3d3d75e] | 219 | } else if ( Fill.tag == 'a' ) { |
---|
[ceb7db8] | 220 | memcpy( (char *)ptr + copy_end, Fill.at, min(Dim * size - copy_end, Fill.size) ); |
---|
[3d3d75e] | 221 | } else if ( Fill.tag == 'T' ) { |
---|
| 222 | memcpy( (char *)ptr + copy_end, Fill.at, Dim * size ); |
---|
[ceb7db8] | 223 | } |
---|
| 224 | |
---|
| 225 | return ptr; |
---|
[6c5d92f] | 226 | } // alloc_internal$ |
---|
[ceb7db8] | 227 | |
---|
[d4264e8] | 228 | forall( List ... | { T * alloc_internal$( void *, T *, size_t, size_t, S_fill(T), List ); } ) { |
---|
| 229 | T * alloc_internal$( void *, T *, size_t Align, size_t Dim, S_fill(T) Fill, T_resize Resize, List rest ) { |
---|
[6c5d92f] | 230 | return alloc_internal$( Resize, (T*)0p, Align, Dim, Fill, rest); |
---|
[ceb7db8] | 231 | } |
---|
| 232 | |
---|
[d4264e8] | 233 | T * alloc_internal$( void *, T *, size_t Align, size_t Dim, S_fill(T) Fill, S_realloc(T) Realloc, List rest ) { |
---|
[6c5d92f] | 234 | return alloc_internal$( (void*)0p, Realloc, Align, Dim, Fill, rest); |
---|
[ceb7db8] | 235 | } |
---|
| 236 | |
---|
[d4264e8] | 237 | T * alloc_internal$( void * Resize, T * Realloc, size_t, size_t Dim, S_fill(T) Fill, T_align Align, List rest ) { |
---|
[6c5d92f] | 238 | return alloc_internal$( Resize, Realloc, Align, Dim, Fill, rest); |
---|
[ceb7db8] | 239 | } |
---|
| 240 | |
---|
[d4264e8] | 241 | T * alloc_internal$( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T), S_fill(T) Fill, List rest ) { |
---|
[58e97d9] | 242 | return alloc_internal$( Resize, Realloc, Align, Dim, Fill, rest ); |
---|
[ceb7db8] | 243 | } |
---|
| 244 | |
---|
[d4264e8] | 245 | T * alloc( List all ) { |
---|
[58e97d9] | 246 | return alloc_internal$( (void*)0p, (T*)0p, (_Alignof(T) > libAlign() ? _Alignof(T) : libAlign()), (size_t)1, (S_fill(T)){'0'}, all ); |
---|
[ceb7db8] | 247 | } |
---|
| 248 | |
---|
[d4264e8] | 249 | T * alloc( size_t dim, List all ) { |
---|
[58e97d9] | 250 | return alloc_internal$( (void*)0p, (T*)0p, (_Alignof(T) > libAlign() ? _Alignof(T) : libAlign()), dim, (S_fill(T)){'0'}, all ); |
---|
[ceb7db8] | 251 | } |
---|
[d4264e8] | 252 | } // distribution List |
---|
[ceb7db8] | 253 | } // distribution T |
---|
[3ce0d440] | 254 | |
---|
[fd54fef] | 255 | static inline forall( T & | sized(T) ) { |
---|
[4803a901] | 256 | // CFA safe initialization/copy, i.e., implicit size specification, non-array types |
---|
[b9c04946] | 257 | T * memset( T * dest, char fill ) { |
---|
| 258 | return (T *)memset( dest, fill, sizeof(T) ); |
---|
[3ce0d440] | 259 | } // memset |
---|
| 260 | |
---|
| 261 | T * memcpy( T * dest, const T * src ) { |
---|
| 262 | return (T *)memcpy( dest, src, sizeof(T) ); |
---|
| 263 | } // memcpy |
---|
| 264 | |
---|
[4803a901] | 265 | // CFA safe initialization/copy, i.e., implicit size specification, array types |
---|
[b9c04946] | 266 | T * amemset( T dest[], char fill, size_t dim ) { |
---|
| 267 | return (T *)(void *)memset( dest, fill, dim * sizeof(T) ); // C memset |
---|
| 268 | } // amemset |
---|
[3ce0d440] | 269 | |
---|
[b9c04946] | 270 | T * amemcpy( T dest[], const T src[], size_t dim ) { |
---|
[3ce0d440] | 271 | return (T *)(void *)memcpy( dest, src, dim * sizeof(T) ); // C memcpy |
---|
[b9c04946] | 272 | } // amemcpy |
---|
[3ce0d440] | 273 | } // distribution |
---|
[f3fc631f] | 274 | |
---|
[4803a901] | 275 | // CFA deallocation for multiple objects |
---|
[d4264e8] | 276 | static inline forall( T & ) |
---|
[4803a901] | 277 | void free( T * ptr ) { |
---|
| 278 | free( (void *)ptr ); // C free |
---|
| 279 | } // free |
---|
[d4264e8] | 280 | static inline forall( T &, List ... | { void free( List ); } ) |
---|
| 281 | void free( T * ptr, List rest ) { |
---|
[4803a901] | 282 | free( ptr ); |
---|
[94429f8] | 283 | free( rest ); |
---|
| 284 | } // free |
---|
| 285 | |
---|
[4803a901] | 286 | // CFA allocation/deallocation and constructor/destructor, non-array types |
---|
[d4264e8] | 287 | static inline forall( T & | sized(T), Parms ... | { void ?{}( T &, Parms ); } ) |
---|
| 288 | T * new( Parms p ) { |
---|
[09ee131] | 289 | return &(*(T *)malloc()){ p }; // run constructor |
---|
[94429f8] | 290 | } // new |
---|
| 291 | |
---|
[fd54fef] | 292 | static inline forall( T & | { void ^?{}( T & ); } ) |
---|
[94429f8] | 293 | void delete( T * ptr ) { |
---|
[0f7a0ea] | 294 | // special case for 0-sized object => always call destructor |
---|
| 295 | if ( ptr || sizeof(ptr) == 0 ) { // ignore null but not 0-sized objects |
---|
[94429f8] | 296 | ^(*ptr){}; // run destructor |
---|
| 297 | } // if |
---|
[4803a901] | 298 | free( ptr ); // always call free |
---|
[94429f8] | 299 | } // delete |
---|
[d4264e8] | 300 | static inline forall( T &, List ... | { void ^?{}( T & ); void delete( List ); } ) |
---|
| 301 | void delete( T * ptr, List rest ) { |
---|
[94429f8] | 302 | delete( ptr ); |
---|
| 303 | delete( rest ); |
---|
| 304 | } // delete |
---|
[627f585] | 305 | |
---|
[4803a901] | 306 | // CFA allocation/deallocation and constructor/destructor, array types |
---|
[d4264e8] | 307 | forall( T & | sized(T), Parms ... | { void ?{}( T &, Parms ); } ) T * anew( size_t dim, Parms p ); |
---|
[fd54fef] | 308 | forall( T & | sized(T) | { void ^?{}( T & ); } ) void adelete( T arr[] ); |
---|
[d4264e8] | 309 | forall( T & | sized(T) | { void ^?{}( T & ); }, List ... | { void adelete( List ); } ) void adelete( T arr[], List rest ); |
---|
| 310 | |
---|
[54af365] | 311 | //--------------------------------------- |
---|
| 312 | |
---|
[8f650f0] | 313 | // Check if all string characters are a specific kind, e.g., checkif( s, isblank ) |
---|
| 314 | bool checkif( const char s[], int (* kind)( int ) ); |
---|
| 315 | bool checkif( const char s[], int (* kind)( int, locale_t ), locale_t locale ); |
---|
[6065b3aa] | 316 | |
---|
[bd85400] | 317 | //--------------------------------------- |
---|
| 318 | |
---|
[57fc7d8] | 319 | static inline { |
---|
[76acb60] | 320 | int strto( const char sptr[], char * eptr[], int base ) { return (int)strtol( sptr, eptr, base ); } |
---|
| 321 | unsigned int strto( const char sptr[], char * eptr[], int base ) { return (unsigned int)strtoul( sptr, eptr, base ); } |
---|
| 322 | long int strto( const char sptr[], char * eptr[], int base ) { return strtol( sptr, eptr, base ); } |
---|
| 323 | unsigned long int strto( const char sptr[], char * eptr[], int base ) { return strtoul( sptr, eptr, base ); } |
---|
| 324 | long long int strto( const char sptr[], char * eptr[], int base ) { return strtoll( sptr, eptr, base ); } |
---|
| 325 | unsigned long long int strto( const char sptr[], char * eptr[], int base ) { return strtoull( sptr, eptr, base ); } |
---|
| 326 | |
---|
| 327 | float strto( const char sptr[], char * eptr[] ) { return strtof( sptr, eptr ); } |
---|
| 328 | double strto( const char sptr[], char * eptr[] ) { return strtod( sptr, eptr ); } |
---|
| 329 | long double strto( const char sptr[], char * eptr[] ) { return strtold( sptr, eptr ); } |
---|
[57fc7d8] | 330 | } // distribution |
---|
[e672372] | 331 | |
---|
[76acb60] | 332 | float _Complex strto( const char sptr[], char * eptr[] ); |
---|
| 333 | double _Complex strto( const char sptr[], char * eptr[] ); |
---|
| 334 | long double _Complex strto( const char sptr[], char * eptr[] ); |
---|
| 335 | |
---|
[b5e725a] | 336 | ExceptionDecl( out_of_range ); |
---|
| 337 | ExceptionDecl( invalid_argument ); |
---|
[76acb60] | 338 | |
---|
| 339 | forall( T | { T strto( const char sptr[], char * eptr[], int ); } ) |
---|
[54af365] | 340 | T convert( const char sptr[] ); // integrals |
---|
| 341 | forall( T | { T strto( const char sptr[], char * eptr[] ); } ) |
---|
| 342 | T convert( const char sptr[] ); // floating-point (no base) |
---|
[bd85400] | 343 | |
---|
[57fc7d8] | 344 | static inline { |
---|
[e3fea42] | 345 | int ato( const char sptr[] ) { return (int)strtol( sptr, 0p, 10 ); } |
---|
| 346 | unsigned int ato( const char sptr[] ) { return (unsigned int)strtoul( sptr, 0p, 10 ); } |
---|
| 347 | long int ato( const char sptr[] ) { return strtol( sptr, 0p, 10 ); } |
---|
| 348 | unsigned long int ato( const char sptr[] ) { return strtoul( sptr, 0p, 10 ); } |
---|
| 349 | long long int ato( const char sptr[] ) { return strtoll( sptr, 0p, 10 ); } |
---|
| 350 | unsigned long long int ato( const char sptr[] ) { return strtoull( sptr, 0p, 10 ); } |
---|
| 351 | |
---|
| 352 | float ato( const char sptr[] ) { return strtof( sptr, 0p ); } |
---|
| 353 | double ato( const char sptr[] ) { return strtod( sptr, 0p ); } |
---|
| 354 | long double ato( const char sptr[] ) { return strtold( sptr, 0p ); } |
---|
| 355 | |
---|
| 356 | float _Complex ato( const char sptr[] ) { return strto( sptr, 0p ); } |
---|
| 357 | double _Complex ato( const char sptr[] ) { return strto( sptr, 0p ); } |
---|
| 358 | long double _Complex ato( const char sptr[] ) { return strto( sptr, 0p ); } |
---|
[57fc7d8] | 359 | } // distribution |
---|
[e672372] | 360 | |
---|
[bd85400] | 361 | //--------------------------------------- |
---|
| 362 | |
---|
[fd54fef] | 363 | forall( E | { int ?<?( E, E ); } ) { |
---|
[3ce0d440] | 364 | E * bsearch( E key, const E * vals, size_t dim ); |
---|
| 365 | size_t bsearch( E key, const E * vals, size_t dim ); |
---|
| 366 | E * bsearchl( E key, const E * vals, size_t dim ); |
---|
| 367 | size_t bsearchl( E key, const E * vals, size_t dim ); |
---|
| 368 | E * bsearchu( E key, const E * vals, size_t dim ); |
---|
| 369 | size_t bsearchu( E key, const E * vals, size_t dim ); |
---|
| 370 | } // distribution |
---|
[9c47a47] | 371 | |
---|
[fd54fef] | 372 | forall( K, E | { int ?<?( K, K ); K getKey( const E & ); } ) { |
---|
[3ce0d440] | 373 | E * bsearch( K key, const E * vals, size_t dim ); |
---|
| 374 | size_t bsearch( K key, const E * vals, size_t dim ); |
---|
| 375 | E * bsearchl( K key, const E * vals, size_t dim ); |
---|
| 376 | size_t bsearchl( K key, const E * vals, size_t dim ); |
---|
| 377 | E * bsearchu( K key, const E * vals, size_t dim ); |
---|
| 378 | size_t bsearchu( K key, const E * vals, size_t dim ); |
---|
| 379 | } // distribution |
---|
[bd85400] | 380 | |
---|
[fd54fef] | 381 | forall( E | { int ?<?( E, E ); } ) { |
---|
[b9c04946] | 382 | void qsort( E * vals, size_t dim ); |
---|
| 383 | } // distribution |
---|
| 384 | |
---|
[bd85400] | 385 | //--------------------------------------- |
---|
| 386 | |
---|
[bbe1a87] | 387 | extern "C" { // override C version |
---|
| 388 | void srandom( unsigned int seed ); |
---|
[4e7c0fc0] | 389 | long int random( void ); // GENERATES POSITIVE AND NEGATIVE VALUES |
---|
| 390 | // For positive values, use unsigned int, e.g., unsigned int r = random() % 100U; |
---|
[bbe1a87] | 391 | } // extern "C" |
---|
| 392 | |
---|
| 393 | static inline { |
---|
[aa8e24c3] | 394 | long int random( long int l, long int u ) { if ( u < l ) [u, l] = [l, u]; return lrand48() % (u - l + 1) + l; } // [l,u] |
---|
| 395 | long int random( long int u ) { return random( 0, u - 1 ); } // [0,u) |
---|
[bbe1a87] | 396 | unsigned long int random( void ) { return lrand48(); } |
---|
| 397 | unsigned long int random( unsigned long int u ) { return lrand48() % u; } // [0,u) |
---|
[aa8e24c3] | 398 | unsigned long int random( unsigned long int l, unsigned long int u ) { if ( u < l ) [u, l] = [l, u]; return lrand48() % (u - l + 1) + l; } // [l,u] |
---|
[bbe1a87] | 399 | |
---|
| 400 | char random( void ) { return (unsigned long int)random(); } |
---|
[24d6572] | 401 | char random( char u ) { return (unsigned long int)random( (unsigned long int)u ); } // [0,u) |
---|
[bbe1a87] | 402 | char random( char l, char u ) { return random( (unsigned long int)l, (unsigned long int)u ); } // [l,u) |
---|
| 403 | int random( void ) { return (long int)random(); } |
---|
[24d6572] | 404 | int random( int u ) { return (long int)random( (long int)u ); } // [0,u] |
---|
[bbe1a87] | 405 | int random( int l, int u ) { return random( (long int)l, (long int)u ); } // [l,u) |
---|
| 406 | unsigned int random( void ) { return (unsigned long int)random(); } |
---|
[24d6572] | 407 | unsigned int random( unsigned int u ) { return (unsigned long int)random( (unsigned long int)u ); } // [0,u] |
---|
[bbe1a87] | 408 | unsigned int random( unsigned int l, unsigned int u ) { return random( (unsigned long int)l, (unsigned long int)u ); } // [l,u) |
---|
| 409 | } // distribution |
---|
| 410 | |
---|
| 411 | float random( void ); // [0.0, 1.0) |
---|
| 412 | double random( void ); // [0.0, 1.0) |
---|
| 413 | float _Complex random( void ); // [0.0, 1.0)+[0.0, 1.0)i |
---|
| 414 | double _Complex random( void ); // [0.0, 1.0)+[0.0, 1.0)i |
---|
| 415 | long double _Complex random( void ); // [0.0, 1.0)+[0.0, 1.0)i |
---|
[bd85400] | 416 | |
---|
| 417 | //--------------------------------------- |
---|
| 418 | |
---|
[1959528] | 419 | // Sequential Pseudo Random-Number Generator : generate repeatable sequence of values that appear random. |
---|
| 420 | // |
---|
| 421 | // Declaration : |
---|
| 422 | // PRNG sprng = { 1009 } - set starting seed versus random seed |
---|
[a892e61] | 423 | // |
---|
[1959528] | 424 | // Interface : |
---|
| 425 | // set_seed( sprng, 1009 ) - set starting seed for ALL kernel threads versus random seed |
---|
| 426 | // get_seed( sprng ) - read seed |
---|
| 427 | // prng( sprng ) - generate random value in range [0,UINT_MAX] |
---|
| 428 | // prng( sprng, u ) - generate random value in range [0,u) |
---|
| 429 | // prng( sprng, l, u ) - generate random value in range [l,u] |
---|
| 430 | // calls( sprng ) - number of generated random value so far |
---|
| 431 | // |
---|
| 432 | // Examples : generate random number between 5-21 |
---|
| 433 | // prng( sprng ) % 17 + 5; values 0-16 + 5 = 5-21 |
---|
| 434 | // prng( sprng, 16 + 1 ) + 5; |
---|
| 435 | // prng( sprng, 5, 21 ); |
---|
| 436 | // calls( sprng ); |
---|
| 437 | |
---|
[8a97248] | 438 | forall( PRNG &, R ) |
---|
| 439 | trait basic_prng { |
---|
[20cf96d] | 440 | void set_seed( PRNG & prng, R seed ); // set seed |
---|
| 441 | R get_seed( PRNG & prng ); // get seed |
---|
[d2ad151] | 442 | R prng( PRNG & prng ); |
---|
| 443 | void ?{}( PRNG & prng ); // random seed |
---|
[20cf96d] | 444 | void ?{}( PRNG & prng, R seed ); // fixed seed |
---|
[d2ad151] | 445 | }; // basic_prng |
---|
| 446 | |
---|
[20cf96d] | 447 | static inline forall( PRNG &, R | basic_prng( PRNG, R ) | { R ?%?( R, R ); } ) { |
---|
[d2ad151] | 448 | R prng( PRNG & prng, R u ) { return prng( prng ) % u; } // [0,u) |
---|
| 449 | } |
---|
[20cf96d] | 450 | static inline forall( PRNG &, R | basic_prng( PRNG, R ) | { R ?+?( R, R ); R ?-?( R, R ); R ?%?( R, R ); void ?{}( R &, one_t ); } ) { |
---|
[d2ad151] | 451 | R prng( PRNG & prng, R l, R u ) { return prng( prng, u - l + (R){1} ) + l; } // [l,u] |
---|
| 452 | } |
---|
| 453 | |
---|
| 454 | struct PRNG32 { |
---|
[aa8e24c3] | 455 | uint32_t callcnt; // call count |
---|
| 456 | uint32_t seed; // current seed |
---|
[dd46fd3] | 457 | PRNG_STATE_32_T state; // random state |
---|
[3770b87] | 458 | }; // PRNG32 |
---|
[d2ad151] | 459 | |
---|
| 460 | static inline { |
---|
[261e107] | 461 | void set_seed( PRNG32 & prng, uint32_t seed_ ) with( prng ) { seed = seed_; PRNG_SET_SEED_32( state, seed ); } |
---|
| 462 | uint32_t get_seed( PRNG32 & prng ) __attribute__(( warn_unused_result )) with( prng ) { return seed; } |
---|
[5f31bf0] | 463 | void ?{}( PRNG32 & prng, uint32_t seed ) with( prng ) { callcnt = 0; set_seed( prng, seed ); } // fixed seed |
---|
| 464 | void ?{}( PRNG32 & prng ) with( prng ) { ?{}( prng, rdtscl() ); } // random seed |
---|
[dd46fd3] | 465 | uint32_t prng( PRNG32 & prng ) __attribute__(( warn_unused_result )) with( prng ) { callcnt += 1; return PRNG_NAME_32( state ); } // [0,UINT_MAX] |
---|
[ac8b016] | 466 | uint32_t prng( PRNG32 & prng, uint32_t u ) __attribute__(( warn_unused_result )) { return prng( prng ) % u; } // [0,u) |
---|
| 467 | uint32_t prng( PRNG32 & prng, uint32_t l, uint32_t u ) __attribute__(( warn_unused_result )) { return prng( prng, u - l + 1 ) + l; } // [l,u] |
---|
[d2ad151] | 468 | uint32_t calls( PRNG32 & prng ) __attribute__(( warn_unused_result )) with( prng ) { return callcnt; } |
---|
[3770b87] | 469 | void copy( PRNG32 & dst, PRNG32 & src ) { dst = src; } // checkpoint PRNG state, use autogen assignment |
---|
[d2ad151] | 470 | } // distribution |
---|
[3770b87] | 471 | void ?{}( PRNG32 &, PRNG32 & ) = void; // no copy, remove autogen copy constructor |
---|
| 472 | PRNG32 & ?=?( PRNG32 &, const PRNG32 ) = void; // no assignment, remove autogen assignment |
---|
[d2ad151] | 473 | |
---|
| 474 | struct PRNG64 { |
---|
| 475 | uint64_t callcnt; // call count |
---|
| 476 | uint64_t seed; // current seed |
---|
[dd46fd3] | 477 | PRNG_STATE_64_T state; // random state |
---|
[3770b87] | 478 | }; // PRNG64 |
---|
[aa8e24c3] | 479 | |
---|
| 480 | static inline { |
---|
[261e107] | 481 | void set_seed( PRNG64 & prng, uint64_t seed_ ) with( prng ) { seed = seed_; PRNG_SET_SEED_64( state, seed ); } |
---|
| 482 | uint64_t get_seed( PRNG64 & prng ) __attribute__(( warn_unused_result )) with( prng ) { return seed; } |
---|
[5f31bf0] | 483 | void ?{}( PRNG64 & prng, uint64_t seed ) with( prng ) { callcnt = 0; set_seed( prng, seed ); } // fixed seed |
---|
| 484 | void ?{}( PRNG64 & prng ) with( prng ) { ?{}( prng, rdtscl() ); } // random seed |
---|
[dd46fd3] | 485 | uint64_t prng( PRNG64 & prng ) __attribute__(( warn_unused_result )) with( prng ) { callcnt += 1; return PRNG_NAME_64( state ); } // [0,UINT_MAX] |
---|
[ac8b016] | 486 | uint64_t prng( PRNG64 & prng, uint64_t u ) __attribute__(( warn_unused_result )) { return prng( prng ) % u; } // [0,u) |
---|
| 487 | uint64_t prng( PRNG64 & prng, uint64_t l, uint64_t u ) __attribute__(( warn_unused_result )) { return prng( prng, u - l + 1 ) + l; } // [l,u] |
---|
[d2ad151] | 488 | uint64_t calls( PRNG64 & prng ) __attribute__(( warn_unused_result )) with( prng ) { return callcnt; } |
---|
[3770b87] | 489 | void copy( PRNG64 & dst, PRNG64 & src ) { dst = src; } // checkpoint PRNG state, use autogen assignment |
---|
[aa8e24c3] | 490 | } // distribution |
---|
[3770b87] | 491 | void ?{}( PRNG64 &, PRNG64 & ) = void; // no copy, remove autogen copy constructor |
---|
| 492 | PRNG64 & ?=?( PRNG64 &, const PRNG64 ) = void; // no assignment, remove autogen assignment |
---|
[aa8e24c3] | 493 | |
---|
[b5e725a] | 494 | // Set default random-generator size. |
---|
| 495 | #if defined( __x86_64__ ) || defined( __aarch64__ ) // 64-bit architecture |
---|
| 496 | #define PRNG PRNG64 |
---|
| 497 | #else // 32-bit architecture |
---|
| 498 | #define PRNG PRNG32 |
---|
| 499 | #endif // __x86_64__ |
---|
| 500 | |
---|
[1959528] | 501 | // Concurrent Pseudo Random-Number Generator : generate repeatable sequence of values that appear random. |
---|
| 502 | // |
---|
| 503 | // Interface : |
---|
| 504 | // set_seed( 1009 ) - fixed seed for all kernel threads versus random seed |
---|
| 505 | // get_seed() - read seed |
---|
| 506 | // prng() - generate random value in range [0,UINT_MAX] |
---|
| 507 | // prng( u ) - generate random value in range [0,u) |
---|
| 508 | // prng( l, u ) - generate random value in range [l,u] |
---|
| 509 | // |
---|
| 510 | // Examples : generate random number between 5-21 |
---|
| 511 | // prng() % 17 + 5; values 0-16 + 5 = 5-21 |
---|
| 512 | // prng( 16 + 1 ) + 5; |
---|
| 513 | // prng( 5, 21 ); |
---|
| 514 | |
---|
[d2ad151] | 515 | // Harmonize with concurrency/thread.hfa. |
---|
[d8bdf13] | 516 | void set_seed( size_t seed_ ) OPTIONAL_THREAD; // set global seed |
---|
| 517 | size_t get_seed() __attribute__(( warn_unused_result )); // get global seed |
---|
[20cf96d] | 518 | size_t prng( void ) __attribute__(( warn_unused_result )) OPTIONAL_THREAD; // [0,UINT_MAX] |
---|
[aa8e24c3] | 519 | static inline { |
---|
[20cf96d] | 520 | size_t prng( size_t u ) __attribute__(( warn_unused_result )) { return prng() % u; } // [0,u) |
---|
| 521 | size_t prng( size_t l, size_t u ) __attribute__(( warn_unused_result )) { return prng( u - l + 1 ) + l; } // [l,u] |
---|
[aa8e24c3] | 522 | } // distribution |
---|
| 523 | |
---|
| 524 | //--------------------------------------- |
---|
| 525 | |
---|
[94429f8] | 526 | extern bool threading_enabled( void ) OPTIONAL_THREAD; |
---|
[2026bb6] | 527 | |
---|
[bd85400] | 528 | // Local Variables: // |
---|
| 529 | // mode: c // |
---|
| 530 | // tab-width: 4 // |
---|
| 531 | // End: // |
---|