Changes in libcfa/src/stdlib.hfa [cafb687:d6b03b7]

File:

• libcfa/src/stdlib.hfa (modified) (6 diffs)

libcfa/src/stdlib.hfa

@@ -10 +10 @@
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Oct 20 22:57:33 2019
-// Update Count     : 390
+// Last Modified On : Tue Jul 23 14:14:59 2019
+// Update Count     : 373
 //
 
@@ -25 +25 @@
         void * memset( void * dest, int fill, size_t size ); // string.h
         void * memcpy( void * dest, const void * src, size_t size ); // string.h
-    void * cmemalign( size_t alignment, size_t noOfElems, size_t elemSize ); // CFA heap
+    void * cmemalign( size_t alignment, size_t noOfElems, size_t elemSize ); // CFA
 } // extern "C"
 
@@ -52 +52 @@
         T * realloc( T * ptr, size_t size ) {
                 if ( unlikely( ptr == 0 ) ) return malloc();
-                return (T *)(void *)realloc( (void *)ptr, size ); // C realloc
+                return (T *)(void *)realloc( (void *)ptr, size );
         } // realloc
 
         T * memalign( size_t align ) {
-                return (T *)memalign( align, sizeof(T) );               // C memalign
+                return (T *)memalign( align, sizeof(T) );
         } // memalign
 
         T * aligned_alloc( size_t align ) {
-                return (T *)aligned_alloc( align, sizeof(T) );  // C aligned_alloc
+                return (T *)aligned_alloc( align, sizeof(T) );
         } // aligned_alloc
 
@@ -67 +67 @@
         } // posix_memalign
 
+
         // Cforall dynamic allocation
 
@@ -73 +74 @@
         } // alloc
 
+        T * alloc( char fill ) {
+                T * ptr;
+                if ( _Alignof(T) <= libAlign() ) ptr = (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
+                else ptr = (T *)memalign( _Alignof(T), sizeof(T) );
+                return (T *)memset( ptr, (int)fill, sizeof(T) ); // initialize with fill value
+        } // alloc
+
         T * alloc( size_t dim ) {
-                if ( _Alignof(T) <= libAlign() ) return (T *)(void *)malloc( dim * (size_t)sizeof(T) );
+                if ( _Alignof(T) <= libAlign() ) return (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc
                 else return (T *)memalign( _Alignof(T), dim * sizeof(T) );
         } // alloc
 
-        T * alloc( T ptr[], size_t dim ) {                                      // realloc
+        T * alloc( size_t dim, char fill ) {
+                return (T *)memset( (T *)alloc( dim ), (int)fill, dim * sizeof(T) ); // initialize with fill value
+        } // alloc
+
+        T * alloc( T ptr[], size_t dim ) {
                 return realloc( ptr, dim * sizeof(T) );
         } // alloc
-
-        T * alloc_set( char fill ) {
-                return (T *)memset( (T *)alloc(), (int)fill, sizeof(T) ); // initialize with fill value
-        } // alloc
-
-        T * alloc_set( T fill ) {
-                return (T *)memcpy( (T *)alloc(), &fill, sizeof(T) ); // initialize with fill value
-        } // alloc
-
-        T * alloc_set( size_t dim, char fill ) {
-                return (T *)memset( (T *)alloc( dim ), (int)fill, dim * sizeof(T) ); // initialize with fill value
-        } // alloc
-
-        T * alloc_set( size_t dim, T fill ) {
-                T * r = (T *)alloc( dim );
-                for ( i; dim ) { memcpy( &r[i], &fill, sizeof(T) ); } // initialize with fill value
-                return r;
-        } // alloc
-
-        T * alloc_set( size_t dim, const T fill[] ) {
-                return (T *)memcpy( (T *)alloc( dim ), fill, dim * sizeof(T) ); // initialize with fill value
-        } // alloc
-} // distribution
-
-forall( dtype T | sized(T) ) {
-        T * alloc_set( T ptr[], size_t dim, char fill );        // realloc array with fill
-} // distribution
-
-static inline forall( dtype T | sized(T) ) {
-        T * alloc_align( size_t align ) {
+} // distribution
+
+
+static inline forall( dtype T | sized(T) ) {
+        T * align_alloc( size_t align ) {
                 return (T *)memalign( align, sizeof(T) );
-        } // alloc_align
-
-        T * alloc_align( size_t align, size_t dim ) {
+        } // align_alloc
+
+        T * align_alloc( size_t align, char fill ) {
+                T * ptr = (T *)memalign( align, sizeof(T) );
+                return (T *)memset( ptr, (int)fill, sizeof(T) );
+        } // align_alloc
+
+        T * align_alloc( size_t align, size_t dim ) {
                 return (T *)memalign( align, dim * sizeof(T) );
-        } // alloc_align
-
-        T * alloc_align_set( size_t align, char fill ) {
-                return (T *)memset( (T *)alloc_align( align ), (int)fill, sizeof(T) ); // initialize with fill value
-        } // alloc_align
-
-        T * alloc_align_set( size_t align, T fill ) {
-                return (T *)memcpy( (T *)alloc_align( align ), &fill, sizeof(T) ); // initialize with fill value
-        } // alloc_align
-
-        T * alloc_align_set( size_t align, size_t dim, char fill ) {
-                return (T *)memset( (T *)alloc_align( align, dim ), (int)fill, dim * sizeof(T) ); // initialize with fill value
-        } // alloc_align
-
-        T * alloc_align_set( size_t align, size_t dim, T fill ) {
-                T * r = (T *)alloc_align( align, dim );
-                for ( i; dim ) { memcpy( &r[i], &fill, sizeof(T) ); } // initialize with fill value
-                return r;
-        } // alloc_align
-
-        T * alloc_align_set( size_t align, size_t dim, const T fill[] ) {
-                return (T *)memcpy( (T *)alloc_align( align, dim ), fill, dim * sizeof(T) );
-        } // alloc_align
-} // distribution
-
-forall( dtype T | sized(T) ) {
-        T * alloc_align( T ptr[], size_t align );                       // realign
-        T * alloc_align( T ptr[], size_t align, size_t dim ); // aligned realloc array
-        T * alloc_align_set( T ptr[], size_t align, size_t dim, char fill ); // aligned realloc array with fill
-} // distribution
+        } // align_alloc
+
+        T * align_alloc( size_t align, size_t dim, char fill ) {
+                if ( fill == '\0' ) {
+                        return (T *)cmemalign( align, dim, sizeof(T) );
+                } else {
+                        return (T *)memset( (T *)memalign( align, dim * sizeof(T) ), (int)fill, dim * sizeof(T) );
+                } // if
+        } // align_alloc
+} // distribution
+
+forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill );
+
 
 static inline forall( dtype T | sized(T) ) {
         // data, non-array types
+
         T * memset( T * dest, char fill ) {
                 return (T *)memset( dest, fill, sizeof(T) );
@@ -160 +136 @@
 static inline forall( dtype T | sized(T) ) {
         // data, array types
+
         T * amemset( T dest[], char fill, size_t dim ) {
                 return (T *)(void *)memset( dest, fill, dim * sizeof(T) ); // C memset