Changeset 54eb5ebd for libcfa


Ignore:
Timestamp:
Jul 23, 2020, 1:33:57 PM (22 months ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
arm-eh, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast, new-ast-unique-expr
Children:
e262b5e, f854ee32
Parents:
5751a56 (diff), f19fbbc (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:
3 edited

Legend:

Unmodified
Added
Removed
  • libcfa/src/heap.cfa

    r5751a56 r54eb5ebd  
    1010// Created On       : Tue Dec 19 21:58:35 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Jul 19 17:37:21 2020
    13 // Update Count     : 806
     12// Last Modified On : Mon Jul 20 23:00:32 2020
     13// Update Count     : 808
    1414//
    1515
     
    901901          if ( oalign == 0 && size <= odsize && odsize <= size * 2 ) { // allow 50% wasted storage for smaller size
    902902                        header->kind.real.blockSize &= -2;                      // no alignment and turn off 0 fill
     903                        if ( size != odsize ) header->kind.real.size = size; // reset allocation size
    903904                        return oaddr;
    904905                } // if
     
    929930
    930931                size_t odsize = dataStorage( bsize, oaddr, header ); // data storage available in bucket
    931           if ( size <= odsize && odsize <= size * 2 ) { // allow up to 50% wasted storage in smaller size
    932                         // Do not know size of original allocation => cannot do 0 fill for any additional space because do not know
    933                         // where to start filling, i.e., do not overwrite existing values in space.
     932          if ( size <= odsize && odsize <= size * 2 ) {         // allow up to 50% wasted storage in smaller size
     933                        if ( size != odsize ) header->kind.real.size = size; // reset allocation size
    934934                        return oaddr;
    935935                } // if
     
    12271227                if ( size <= odsize && odsize <= size * 2 ) {   // allow 50% wasted storage for smaller size
    12281228                        header->kind.real.blockSize &= -2;                      // turn off 0 fill
     1229                        if ( size != odsize ) header->kind.real.size = size; // reset allocation size
    12291230                        return oaddr;
    12301231                } // if
  • libcfa/src/heap.hfa

    r5751a56 r54eb5ebd  
    1010// Created On       : Tue May 26 11:23:55 2020
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Jun  1 21:19:00 2020
    13 // Update Count     : 10
     12// Last Modified On : Mon Jul 20 18:52:31 2020
     13// Update Count     : 11
    1414//
    1515
     
    3535        void * resize( void * oaddr, size_t size );
    3636        void * amemalign( size_t align, size_t dim, size_t elemSize );
    37         void * cmemalign( size_t align, size_t noOfElems, size_t elemSize );
     37        void * cmemalign( size_t align, size_t dim, size_t elemSize );
    3838        size_t malloc_alignment( void * addr );
    3939        bool malloc_zero_fill( void * addr );
  • libcfa/src/stdlib.hfa

    r5751a56 r54eb5ebd  
    1010// Created On       : Thu Jan 28 17:12:35 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Jul 20 14:29:21 2020
    13 // Update Count     : 464
     12// Last Modified On : Tue Jul 21 07:58:05 2020
     13// Update Count     : 475
    1414//
    1515
     
    3939//---------------------------------------
    4040
     41// Macro because of returns
     42#define $VAR_ALLOC( allocation, alignment ) \
     43        if ( _Alignof(T) <= libAlign() ) return (T *)(void *)allocation( (size_t)sizeof(T) ); /* C allocation */ \
     44        else return (T *)alignment( _Alignof(T), sizeof(T) )
     45
     46#define $ARRAY_ALLOC( allocation, alignment, dim ) \
     47        if ( _Alignof(T) <= libAlign() ) return (T *)(void *)allocation( dim, (size_t)sizeof(T) ); /* C allocation */ \
     48        else return (T *)alignment( _Alignof(T), dim, sizeof(T) )
     49
     50#define $RE_SPECIALS( ptr, size, allocation, alignment ) \
     51        if ( unlikely( size == 0 ) || unlikely( ptr == 0p ) ) { \
     52                if ( unlikely( size == 0 ) ) free( ptr ); \
     53                $VAR_ALLOC( malloc, memalign ); \
     54        } /* if */
     55
    4156static inline forall( dtype T | sized(T) ) {
    4257        // Cforall safe equivalents, i.e., implicit size specification
    4358
    4459        T * malloc( void ) {
    45                 if ( _Alignof(T) <= libAlign() ) return (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
    46                 else return (T *)memalign( _Alignof(T), sizeof(T) );
     60                $VAR_ALLOC( malloc, memalign );
    4761        } // malloc
    4862
    4963        T * aalloc( size_t dim ) {
    50                 if ( _Alignof(T) <= libAlign() ) return (T *)(void *)aalloc( dim, (size_t)sizeof(T) ); // CFA aalloc
    51                 else return (T *)amemalign( _Alignof(T), dim, sizeof(T) );
     64                $ARRAY_ALLOC( aalloc, amemalign, dim );
    5265        } // aalloc
    5366
    5467        T * calloc( size_t dim ) {
    55                 if ( _Alignof(T) <= libAlign() )return (T *)(void *)calloc( dim, sizeof(T) ); // C calloc
    56                 else return (T *)cmemalign( _Alignof(T), dim, sizeof(T) );
     68                $ARRAY_ALLOC( calloc, cmemalign, dim );
    5769        } // calloc
    5870
    5971        T * resize( T * ptr, size_t size ) {                            // CFA resize, eliminate return-type cast
    60                 if ( unlikely( size == 0 ) || unlikely( ptr == 0p ) ) { // special cases
    61                         if ( unlikely( size == 0 ) ) free( ptr );
    62                         if ( _Alignof(T) <= libAlign() ) return (T *)(void *)malloc( size ); // C malloc
    63                         else return (T *)memalign( _Alignof(T), size ); // C memalign
    64                 } // if
     72                $RE_SPECIALS( ptr, size, malloc, memalign );
    6573                return (T *)(void *)resize( (void *)ptr, size ); // CFA resize
    6674        } // resize
    6775
    6876        T * realloc( T * ptr, size_t size ) {                           // CFA realloc, eliminate return-type cast
    69                 if ( unlikely( size == 0 ) || unlikely( ptr == 0p ) ) { // special cases
    70                         if ( unlikely( size == 0 ) ) free( ptr );
    71                         if ( _Alignof(T) <= libAlign() ) return (T *)(void *)malloc( size ); // C malloc
    72                         else return (T *)memalign( _Alignof(T), size ); // C memalign
    73                 } // if
     77                $RE_SPECIALS( ptr, size, malloc, memalign );
    7478                return (T *)(void *)realloc( (void *)ptr, size ); // C realloc
    7579        } // realloc
     
    159163        T * alloc_set( T ptr[], size_t dim, char fill ) {       // realloc array with fill
    160164                size_t osize = malloc_size( ptr );                              // current allocation
    161                 T * nptr = realloc( ptr, dim * sizeof(T) );             // CFA realloc
    162                 size_t nsize = malloc_size( nptr );                             // new allocation
     165                size_t nsize = dim * sizeof(T);                                 // new allocation
     166                T * nptr = realloc( ptr, nsize );                               // CFA realloc
    163167                if ( nsize > osize ) {                                                  // larger ?
    164168                        memset( (char *)nptr + osize, (int)fill, nsize - osize ); // initialize added storage
     
    168172
    169173        T * alloc_set( T ptr[], size_t dim, T & fill ) {        // realloc array with fill
    170                 size_t odim = malloc_size( ptr ) / sizeof(T);   // current allocation
    171                 T * nptr = realloc( ptr, dim * sizeof(T) );             // CFA realloc
    172                 size_t ndim = malloc_size( nptr ) / sizeof(T);  // new allocation
     174                size_t odim = malloc_size( ptr ) / sizeof(T);   // current dimension
     175                size_t nsize = dim * sizeof(T);                                 // new allocation
     176                size_t ndim = nsize / sizeof(T);                                // new dimension
     177                T * nptr = realloc( ptr, nsize );                               // CFA realloc
    173178                if ( ndim > odim ) {                                                    // larger ?
    174179                        for ( i; odim ~ ndim ) {
     
    226231        T * alloc_align_set( T ptr[], size_t align, size_t dim, char fill ) {
    227232                size_t osize = malloc_size( ptr );                              // current allocation
    228                 T * nptr = realloc( ptr, align, dim * sizeof(T) ); // CFA realloc
    229                 size_t nsize = malloc_size( nptr );                             // new allocation
     233                size_t nsize = dim * sizeof(T);                                 // new allocation
     234                T * nptr = realloc( ptr, align, nsize );                // CFA realloc
    230235                if ( nsize > osize ) {                                                  // larger ?
    231236                        memset( (char *)nptr + osize, (int)fill, nsize - osize ); // initialize added storage
     
    235240
    236241        T * alloc_align_set( T ptr[], size_t align, size_t dim, T & fill ) {
    237                 size_t odim = malloc_size( ptr ) / sizeof(T);   // current allocation
    238                 T * nptr = realloc( ptr, align, dim * sizeof(T) ); // CFA realloc
    239                 size_t ndim = malloc_size( nptr );                              // new allocation
     242                size_t odim = malloc_size( ptr ) / sizeof(T);   // current dimension
     243                size_t nsize = dim * sizeof(T);                                 // new allocation
     244                size_t ndim = nsize / sizeof(T);                                // new dimension
     245                T * nptr = realloc( ptr, align, nsize );                // CFA realloc
    240246                if ( ndim > odim ) {                                                    // larger ?
    241247                        for ( i; odim ~ ndim ) {
Note: See TracChangeset for help on using the changeset viewer.