Changeset cafb687 for libcfa/src/stdlib.cfa

Timestamp:

Oct 21, 2019, 10:18:15 AM (3 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

arm-eh, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

eb5a115

Parents:

1aa6ecb

Message:

start allocation updates for arrays and alignment

File:

• libcfa/src/stdlib.cfa (modified) (4 diffs)

libcfa/src/stdlib.cfa

@@ -10 +10 @@
 // Created On       : Thu Jan 28 17:10:29 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jun 24 17:34:44 2019
-// Update Count     : 462
+// Last Modified On : Sun Oct 20 18:41:23 2019
+// Update Count     : 473
 //
 
@@ -27 +27 @@
 //---------------------------------------
 
-// resize, non-array types
-forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill ) {
-        size_t olen = malloc_usable_size( ptr );                        // current allocation
-    char * nptr = (void *)realloc( (void *)ptr, dim * (size_t)sizeof(T) ); // C realloc
-        size_t nlen = malloc_usable_size( nptr );                       // new allocation
-        if ( nlen > olen ) {                                                            // larger ?
-                memset( nptr + olen, (int)fill, nlen - olen );  // initialize added storage
-        } //
-    return (T *)nptr;
-} // alloc
+forall( dtype T | sized(T) ) {
+        T * alloc_set( T ptr[], size_t dim, char fill ) {       // realloc array with fill
+                size_t olen = malloc_usable_size( ptr );                // current allocation
+                char * nptr = (char *)realloc( (void *)ptr, dim * sizeof(T) ); // C realloc
+                size_t nlen = malloc_usable_size( nptr );               // new allocation
+                if ( nlen > olen ) {                                                    // larger ?
+                        memset( nptr + olen, (int)fill, nlen - olen ); // initialize added storage
+                } // if
+                return (T *)nptr;
+        } // alloc_set
+
+        T * alloc_align( T ptr[], size_t align ) {                      // aligned realloc array
+                char * nptr;
+                size_t alignment = malloc_alignment( ptr );
+                if ( align != alignment ) {
+                        size_t olen = malloc_usable_size( ptr );        // current allocation
+                        nptr = (char *)memalign( align, olen );
+                        size_t nlen = malloc_usable_size( nptr );       // new allocation
+                        size_t lnth = olen < nlen ? olen : nlen;        // min
+                        memcpy( nptr, ptr, lnth );                                      // initialize storage
+                } else {
+                        nptr = (char *)ptr;
+                } // if
+                return (T *)nptr;
+        } // alloc_align
+
+        T * alloc_align( T ptr[], size_t align, size_t dim ) { // aligned realloc array
+                char * nptr;
+                size_t alignment = malloc_alignment( ptr );
+                if ( align != alignment ) {
+                        size_t olen = malloc_usable_size( ptr );        // current allocation
+                        nptr = (char *)memalign( align, dim * sizeof(T) );
+                        size_t nlen = malloc_usable_size( nptr );       // new allocation
+                        size_t lnth = olen < nlen ? olen : nlen;        // min
+                        memcpy( nptr, ptr, lnth );                                      // initialize storage
+                } else {
+                        nptr = (char *)realloc( (void *)ptr, dim * sizeof(T) ); // C realloc
+                } // if
+                return (T *)nptr;
+        } // alloc_align
+
+        T * alloc_align_set( T ptr[], size_t align, char fill ) { // aligned realloc with fill
+                size_t olen = malloc_usable_size( ptr );                // current allocation
+                char * nptr = alloc_align( ptr, align );
+                size_t nlen = malloc_usable_size( nptr );               // new allocation
+                if ( nlen > olen ) {                                                    // larger ?
+                        memset( nptr + olen, (int)fill, nlen - olen ); // initialize added storage
+                } // if
+                return (T *)nptr;
+        } // alloc_align_set
+} // distribution
 
 // allocation/deallocation and constructor/destructor, non-array types
 forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } )
 T * new( Params p ) {
-        return &(*malloc()){ p };                                                               // run constructor
+        return &(*malloc()){ p };                                                       // run constructor
 } // new
 
@@ -47 +88 @@
 void delete( T * ptr ) {
         if ( ptr ) {                                                                            // ignore null
-                ^(*ptr){};                                                                                      // run destructor
+                ^(*ptr){};                                                                              // run destructor
                 free( ptr );
         } // if
@@ -55 +96 @@
 void delete( T * ptr, Params rest ) {
         if ( ptr ) {                                                                            // ignore null
-                ^(*ptr){};                                                                                      // run destructor
+                ^(*ptr){};                                                                              // run destructor
                 free( ptr );
         } // if