Index: doc/user/user.tex =================================================================== --- doc/user/user.tex (revision 6016c874a17e2a5bf68cc3be0670a2fa39751491) +++ doc/user/user.tex (revision 6065b3aad7ca045ec48fc6103d1c55f0b5fb74b0) @@ -11,6 +11,6 @@ %% Created On : Wed Apr 6 14:53:29 2016 %% Last Modified By : Peter A. Buhr -%% Last Modified On : Tue May 30 11:45:46 2017 -%% Update Count : 2098 +%% Last Modified On : Thu Jun 1 22:46:09 2017 +%% Update Count : 2126 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @@ -5242,77 +5242,86 @@ \begin{description} \item[fill] -after allocation the storage is or is not filled with a specified character. +after allocation the storage is filled with a specified character. \item[resize] an existing allocation is decreased or increased in size. In either case, new storage may or may not be allocated and, if there is a new allocation, as much data from the existing allocation is copied. -For an increase in storage size, new storage after the copied data may or may not be filled. +For an increase in storage size, new storage after the copied data may be filled. \item[alignment] an allocation starts on a specified memory boundary, e.g., an address multiple of 64 or 128 for cache-line purposes. \item[array] the allocation size is scaled to the specified number of array elements. -An array may or not be filled, resized, or aligned. +An array may be filled, resized, or aligned. \end{description} - -The following table show the allocation routines supporting different combinations of storage-management capabilities: +The table shows allocation routines supporting different combinations of storage-management capabilities: \begin{center} -\begin{tabular}{@{}r|l|l|l|l@{}} - & fill & resize & alignment & array \\ +\begin{tabular}{@{}lr|l|l|l|l@{}} + & & \multicolumn{1}{c|}{fill} & resize & alignment & array \\ \hline -©malloc© & no/yes & no/yes & no & no \\ -©amalloc© & no/copy data/yes & no/yes & no & yes \\ -©calloc© & yes (0 only) & no & no & yes \\ -©realloc© & no/copy data & yes & no & no \\ -©memalign© & no/yes & no & yes & no \\ -©amemalign© & no/yes & no & yes & yes \\ -©align_alloc© & no & no & yes & no \\ -©posix_memalign© & no & no & yes & no \\ +C & ©malloc© & no & no & no & no \\ + & ©calloc© & yes (0 only) & no & no & yes \\ + & ©realloc© & no/copy & yes & no & no \\ + & ©memalign© & no & no & yes & no \\ + & ©posix_memalign© & no & no & yes & no \\ +C11 & ©aligned_alloc© & no & no & yes & no \\ +\CFA & ©alloc© & no/copy/yes & no/yes & no & yes \\ + & ©align_alloc© & no/yes & no & yes & yes \\ \end{tabular} \end{center} -% When ©amalloc© resizes and fills, the space after the copied data from the source is set to the fill character. It is impossible to resize with alignment because the underlying ©realloc© allocates storage if more space is needed, and it does not honour alignment from the original allocation. \leavevmode \begin{cfa}[aboveskip=0pt,belowskip=0pt] -// allocation, non-array types -forall( dtype T | sized(T) ) T * malloc( void );§\indexc{malloc}§ -forall( dtype T | sized(T) ) T * malloc( char fill ); - -// allocation, array types -forall( dtype T | sized(T) ) T * calloc( size_t dim );§\indexc{cmalloc}§ -forall( dtype T | sized(T) ) T * amalloc( size_t dim );§\indexc{amalloc}§ // alternate name for calloc -forall( dtype T | sized(T) ) T * amalloc( size_t dim, char fill ); - -// resize, non-array types -forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size );§\indexc{realloc}§ -forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, char fill ); -forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size ); // alternate name for realloc -forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size, char fill ); - -// resize, array types -forall( dtype T | sized(T) ) T * amalloc( T * ptr, size_t dim ); -forall( dtype T | sized(T) ) T * amalloc( T * ptr, size_t dim, char fill ); - -// alignment, non-array types -forall( dtype T | sized(T) ) T * memalign( size_t alignment );§\indexc{memalign}§ -forall( dtype T | sized(T) ) T * memalign( size_t alignment, char fill ); -forall( dtype T | sized(T) ) T * aligned_alloc( size_t alignment );§\indexc{aligned_alloc}§ -forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t alignment );§\indexc{posix_memalign}§ - -// alignment, array types -forall( dtype T | sized(T) ) T * amemalign( size_t alignment, size_t dim );§\indexc{amemalign}§ -forall( dtype T | sized(T) ) T * amemalign( size_t alignment, size_t dim, char fill ); - -// data, non-array types +// C unsafe allocation +extern "C" { void * mallac( size_t size ); }§\indexc{memset}§ +extern "C" { void * calloc( size_t dim, size_t size ); }§\indexc{calloc}§ +extern "C" { void * realloc( void * ptr, size_t size ); }§\indexc{realloc}§ +extern "C" { void * memalign( size_t align, size_t size ); }§\indexc{memalign}§ +extern "C" { int posix_memalign( void ** ptr, size_t align, size_t size ); }§\indexc{posix_memalign}§ + +// §\CFA§ safe equivalents, i.e., implicit size specification +forall( dtype T | sized(T) ) T * malloc( void ); +forall( dtype T | sized(T) ) T * calloc( size_t dim ); +forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size ); +forall( dtype T | sized(T) ) T * memalign( size_t align ); +forall( dtype T | sized(T) ) T * aligned_alloc( size_t align ); +forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t align ); + +// §\CFA§ safe general allocation, fill, resize, array +forall( dtype T | sized(T) ) T * alloc( void );§\indexc{alloc}§ +forall( dtype T | sized(T) ) T * alloc( char fill ); +forall( dtype T | sized(T) ) T * alloc( size_t dim ); +forall( dtype T | sized(T) ) T * alloc( size_t dim, char fill ); +forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim ); +forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill ); + +// §\CFA§ safe general allocation, align, fill, array +forall( dtype T | sized(T) ) T * align_alloc( size_t align ); +forall( dtype T | sized(T) ) T * align_alloc( size_t align, char fill ); +forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim ); +forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim, char fill ); + +// C unsafe initialization/copy +extern "C" { void * memset( void * dest, int c, size_t size ); } +extern "C" { void * memcpy( void * dest, const void * src, size_t size ); } + +// §\CFA§ safe initialization/copy forall( dtype T | sized(T) ) T * memset( T * dest, char c );§\indexc{memset}§ forall( dtype T | sized(T) ) T * memcpy( T * dest, const T * src );§\indexc{memcpy}§ -// data, array types -forall( dtype T | sized(T) ) T * amemset( T * dest, size_t dim, char c );§\indexc{amemset}§ -forall( dtype T | sized(T) ) T * amemcpy( T * dest, const T * src, size_t dim );§\indexc{amemcpy}§ - -// allocation/deallocation and constructor/destructor -forall( dtype T, ttype Params | sized(T) | { void ?{}(T *, Params); } ) T * new( Params p );§\indexc{new}§ +// §\CFA§ safe initialization/copy array +forall( dtype T | sized(T) ) T * memset( T dest[], size_t dim, char c ); +forall( dtype T | sized(T) ) T * memcpy( T dest[], const T src[], size_t dim ); + +// §\CFA§ allocation/deallocation and constructor/destructor +forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * new( Params p );§\indexc{new}§ forall( dtype T | { void ^?{}( T * ); } ) void delete( T * ptr );§\indexc{delete}§ -forall( dtype T, ttype Params | { void ^?{}( T * ); void delete(Params); } ) void delete( T * ptr, Params rest ); +forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } ) + void delete( T * ptr, Params rest ); + +// §\CFA§ allocation/deallocation and constructor/destructor, array +forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * anew( size_t dim, Params p );§\indexc{anew}§ +forall( dtype T | sized(T) | { void ^?{}( T * ); } ) void adelete( size_t dim, T arr[] );§\indexc{adelete}§ +forall( dtype T | sized(T) | { void ^?{}( T * ); }, ttype Params | { void adelete( Params ); } ) + void adelete( size_t dim, T arr[], Params rest ); \end{cfa} Index: src/libcfa/stdlib =================================================================== --- src/libcfa/stdlib (revision 6016c874a17e2a5bf68cc3be0670a2fa39751491) +++ src/libcfa/stdlib (revision 6065b3aad7ca045ec48fc6103d1c55f0b5fb74b0) @@ -10,6 +10,6 @@ // Created On : Thu Jan 28 17:12:35 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue May 30 09:07:35 2017 -// Update Count : 164 +// Last Modified On : Thu Jun 1 22:46:43 2017 +// Update Count : 216 // @@ -28,6 +28,4 @@ //--------------------------------------- -extern "C" { void * memset( void * dest, int c, size_t size ); } // use default C routine for void * - // allocation, non-array types static inline forall( dtype T | sized(T) ) T * malloc( void ) { @@ -35,83 +33,83 @@ return (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc } // malloc -static inline forall( dtype T | sized(T) ) T * malloc( char fill ) { + +extern "C" { void * calloc( size_t dim, size_t size ); } // default C routine +static inline forall( dtype T | sized(T) ) T * calloc( size_t dim ) { //printf( "X2\n" ); + return (T *)(void *)calloc( dim, sizeof(T) ); // C cmalloc +} + +extern "C" { void * realloc( void * ptr, size_t size ); } // default C routine for void * +static inline forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size ) { + //printf( "X3\n" ); + return (T *)(void *)realloc( (void *)ptr, size ); +} + +extern "C" { void * memalign( size_t align, size_t size ); } // use default C routine for void * +static inline forall( dtype T | sized(T) ) T * memalign( size_t align ) { + //printf( "X4\n" ); + return (T *)memalign( align, sizeof(T) ); +} // memalign + +static inline forall( dtype T | sized(T) ) T * aligned_alloc( size_t align ) { + //printf( "X5\n" ); + return (T *)memalign( align, sizeof(T) ); +} // aligned_alloc + +extern "C" { int posix_memalign( void ** ptr, size_t align, size_t size ); } // use default C routine for void * +static inline forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t align ) { + //printf( "X6\n" ); + return posix_memalign( (void **)ptr, align, sizeof(T) ); +} // posix_memalign + + +extern "C" { void * memset( void * dest, int c, size_t size ); } // use default C routine for void * + +static inline forall( dtype T | sized(T) ) T * alloc( void ) { + //printf( "X7\n" ); + return (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc +} // alloc +static inline forall( dtype T | sized(T) ) T * alloc( char fill ) { + //printf( "X8\n" ); T * ptr = (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc return memset( ptr, (int)fill, sizeof(T) ); // initial with fill value -} // malloc - -// allocation, array types -extern "C" { void * calloc( size_t dim, size_t size ); } // use default C routine for void * -static inline forall( dtype T | sized(T) ) T * calloc( size_t dim ) { - //printf( "X3\n" ); - return (T *)(void *)calloc( dim, sizeof(T) ); // C cmalloc -} -static inline forall( dtype T | sized(T) ) T * amalloc( size_t dim ) { // alternative name - //printf( "X4\n" ); +} // alloc + +static inline forall( dtype T | sized(T) ) T * alloc( size_t dim ) { + //printf( "X9\n" ); return (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc -} // amalloc -static inline forall( dtype T | sized(T) ) T * amalloc( size_t dim, char fill ) { // alternative name - //printf( "X5\n" ); +} // alloc +static inline forall( dtype T | sized(T) ) T * alloc( size_t dim, char fill ) { + //printf( "X10\n" ); T * ptr = (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc return memset( ptr, (int)fill, dim * sizeof(T) ); -} // amalloc - -// resize, non-array types -extern "C" { void * realloc( void * ptr, size_t size ); } // use default C routine for void * -static inline forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size ) { - //printf( "X5.5\n" ); - return (T *)(void *)realloc( (void *)ptr, size ); -} -forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, char fill ); -static inline forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size ) { // alternative name - //printf( "X7\n" ); - return realloc( ptr, size ); -} // malloc -static inline forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size, char fill ) { // alternative name - //printf( "X8\n" ); - return realloc( ptr, size, fill ); -} // malloc - -// resize, array types -static inline forall( dtype T | sized(T) ) T * amalloc( T * ptr, size_t dim ) { - //printf( "X9\n" ); - return malloc( ptr, dim * (size_t)sizeof(T) ); -} // amalloc -static inline forall( dtype T | sized(T) ) T * amalloc( T * ptr, size_t dim, char fill ) { - //printf( "X10\n" ); - return malloc( ptr, dim * (size_t)sizeof(T), fill ); -} // amalloc - -// alignment, non-array types -extern "C" { void * memalign( size_t alignment, size_t size ); } // use default C routine for void * -static inline forall( dtype T | sized(T) ) T * memalign( size_t alignment ) { +} // alloc + +static inline forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim ) { //printf( "X11\n" ); - return (T *)memalign( alignment, sizeof(T) ); -} // memalign -static inline forall( dtype T | sized(T) ) T * memalign( size_t alignment, char fill ) { - //printf( "X12\n" ); - T * ptr = (T *)memalign( alignment, sizeof(T) ); + return (void *)realloc( (void *)ptr, dim * (size_t)sizeof(T) ); // C realloc +} // alloc +forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill ); + +static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align ) { + //printf( "X13\n" ); + return (T *)memalign( align, sizeof(T) ); +} // align_alloc +static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, char fill ) { + //printf( "X14\n" ); + T * ptr = (T *)memalign( align, sizeof(T) ); return memset( ptr, (int)fill, sizeof(T) ); -} // memalign -static inline forall( dtype T | sized(T) ) T * aligned_alloc( size_t alignment ) { - //printf( "X13\n" ); - return (T *)memalign( alignment, sizeof(T) ); -} // aligned_alloc -extern "C" { int posix_memalign( void ** ptr, size_t alignment, size_t size ); } // use default C routine for void * -static inline forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t alignment ) { - //printf( "X14\n" ); - return posix_memalign( (void **)ptr, alignment, sizeof(T) ); -} // posix_memalign - -// alignment, array types -static inline forall( dtype T | sized(T) ) T * amemalign( size_t alignment, size_t dim ) { +} // align_alloc + +static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim ) { //printf( "X15\n" ); - return (T *)memalign( alignment, dim * sizeof(T) ); -} // amemalign -static inline forall( dtype T | sized(T) ) T * amemalign( size_t alignment, size_t dim, char fill ) { + return (T *)memalign( align, dim * sizeof(T) ); +} // align_alloc +static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim, char fill ) { //printf( "X16\n" ); - T * ptr = (T *)memalign( alignment, dim * sizeof(T) ); + T * ptr = (T *)memalign( align, dim * sizeof(T) ); return memset( ptr, (int)fill, dim * sizeof(T) ); -} // amemalign +} // align_alloc + // data, non-array types @@ -127,17 +125,22 @@ // data, array types -static inline forall( dtype T | sized(T) ) T * amemset( T * dest, size_t dim, char c ) { +static inline forall( dtype T | sized(T) ) T * memset( T dest[], size_t dim, char c ) { //printf( "X19\n" ); return memset( dest, c, dim * sizeof(T) ); -} // amemset -static inline forall( dtype T | sized(T) ) T * amemcpy( T * dest, const T * src, size_t dim ) { +} // memset +static inline forall( dtype T | sized(T) ) T * memcpy( T dest[], const T src[], size_t dim ) { //printf( "X20\n" ); - return memcpy( dest, src, dim * sizeof(T) ); -} // amemcpy - -// allocation/deallocation and constructor/destructor -forall( dtype T, ttype Params | sized(T) | { void ?{}(T *, Params); } ) T * new( Params p ); + return (void *)memcpy( dest, src, dim * sizeof(T) ); // C memcpy +} // memcpy + +// allocation/deallocation and constructor/destructor, non-array types +forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * new( Params p ); forall( dtype T | { void ^?{}( T * ); } ) void delete( T * ptr ); forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } ) void delete( T * ptr, Params rest ); + +// allocation/deallocation and constructor/destructor, array types +forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * anew( size_t dim, Params p ); +forall( dtype T | sized(T) | { void ^?{}( T * ); } ) void adelete( size_t dim, T arr[] ); +forall( dtype T | sized(T) | { void ^?{}( T * ); }, ttype Params | { void adelete( Params ); } ) void adelete( size_t dim, T arr[], Params rest ); //--------------------------------------- Index: src/libcfa/stdlib.c =================================================================== --- src/libcfa/stdlib.c (revision 6016c874a17e2a5bf68cc3be0670a2fa39751491) +++ src/libcfa/stdlib.c (revision 6065b3aad7ca045ec48fc6103d1c55f0b5fb74b0) @@ -10,6 +10,6 @@ // Created On : Thu Jan 28 17:10:29 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue May 30 09:07:56 2017 -// Update Count : 237 +// Last Modified On : Thu Jun 1 21:52:57 2017 +// Update Count : 280 // @@ -28,8 +28,7 @@ // resize, non-array types -forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, char fill ) { // alternative realloc with fill value - //printf( "X6\n" ); +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, size ); // C realloc + 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 ? @@ -37,15 +36,15 @@ } // return (T *)nptr; -} // realloc - -// allocation/deallocation and constructor/destructor -forall( dtype T, ttype Params | sized(T) | { void ?{}( T *, Params ); } ) +} // alloc + +// allocation/deallocation and constructor/destructor, non-array types +forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * new( Params p ) { - return ((T *)malloc()){ p }; + return (malloc()){ p }; // run constructor } // new forall( dtype T | { void ^?{}( T * ); } ) void delete( T * ptr ) { - if ( ptr ) { + if ( ptr ) { // ignore null ^ptr{}; // run destructor free( ptr ); @@ -55,5 +54,5 @@ forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } ) void delete( T * ptr, Params rest ) { - if ( ptr ) { + if ( ptr ) { // ignore null ^ptr{}; // run destructor free( ptr ); @@ -61,4 +60,36 @@ delete( rest ); } // delete + + +// allocation/deallocation and constructor/destructor, array types +forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) +T * anew( size_t dim, Params p ) { + T *arr = alloc( dim ); + for ( unsigned int i = 0; i < dim; i += 1 ) { + (&arr[i]){ p }; // run constructor + } // for + return arr; +} // anew + +forall( dtype T | sized(T) | { void ^?{}( T * ); } ) +void adelete( size_t dim, T arr[] ) { + if ( arr ) { // ignore null + for ( int i = dim - 1; i >= 0; i -= 1 ) { // reverse allocation order, must be unsigned + ^(&arr[i]){}; // run destructor + } // for + free( arr ); + } // if +} // adelete + +forall( dtype T | sized(T) | { void ^?{}( T * ); }, ttype Params | { void adelete( Params ); } ) +void adelete( size_t dim, T arr[], Params rest ) { + if ( arr ) { // ignore null + for ( int i = dim - 1; i >= 0; i -= 1 ) { // reverse allocation order, must be unsigned + ^(&arr[i]){}; // run destructor + } // for + free( arr ); + } // if + adelete( rest ); +} // adelete //--------------------------------------- Index: src/tests/.expect/alloc.txt =================================================================== --- src/tests/.expect/alloc.txt (revision 6016c874a17e2a5bf68cc3be0670a2fa39751491) +++ src/tests/.expect/alloc.txt (revision 6065b3aad7ca045ec48fc6103d1c55f0b5fb74b0) @@ -1,56 +1,63 @@ -C malloc deadbeef -CFA malloc 0 -CFA malloc, fill 01010101 +C malloc 0xdeadbeef +CFA malloc 0xdeadbeef +CFA alloc 0xdeadbeef +CFA alloc, fill 01010101 -C calloc +C array calloc, fill 0 0 0 0 0 0 0 0 0 0 0 -CFA calloc +CFA array calloc, fill 0 0 0 0 0 0 0 0 0 0 0 -CFA array malloc -0 0 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef -CFA array malloc -1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 +CFA array alloc, no fill +0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef +CFA array alloc, fill 0x1 +0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 -C realloc -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef -CFA realloc -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 0 0 0 0 0 0 0 0 0 0 -CFA realloc -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef -CFA resize malloc -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef -CFA resize malloc, fill -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 -CFA resize malloc, fill -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef +C realloc 40 +0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef +CFA realloc 88 +0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 -CFA resize array malloc -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 0 0 0 0 0 0 0 0 0 0 -CFA resize array malloc -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef -CFA resize array malloc, fill -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 -CFA resize array malloc, fill -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef +CFA resize alloc 40 +0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef +CFA resize array alloc 88 +0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 +CFA resize array alloc 40 +0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef +CFA resize array alloc 40, fill +0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 +CFA resize array alloc 88, fill +0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 +CFA resize array alloc 40, fill +0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 -CFA aligned_alloc 42 42.5 +C memalign 42 42.5 CFA memalign 42 42.5 CFA posix_memalign 42 42.5 -CFA memalign fill 16843009 7.7486e-304 +CFA posix_memalign 42 42.5 +CFA aligned_alloc 42 42.5 +CFA align_alloc 42 42.5 +CFA align_alloc fill 0x1010101 0x1.1010101010101p-1007 -CFA memalign array -0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, -CFA memalign array -1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, +CFA array align_alloc +42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, +CFA array align_alloc, fill +0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, -CFA memset ffffffff -nan -CFA memcpy ffffffff -nan +CFA memset 0x1010101 0x1.1010101010101p-1007 +CFA memcpy 0x1010101 0x1.1010101010101p-1007 CFA array memset -ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, +0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, CFA memcpy -deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, +0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, + +CFA new initialize +42 42.5 42 42.5 +CFA array new initialize +42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, +42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, + pointer arithmetic 0 -CFA deep malloc deadbeef +CFA deep malloc 0xdeadbeef SHOULD FAIL Index: src/tests/alloc.c =================================================================== --- src/tests/alloc.c (revision 6016c874a17e2a5bf68cc3be0670a2fa39751491) +++ src/tests/alloc.c (revision 6065b3aad7ca045ec48fc6103d1c55f0b5fb74b0) @@ -10,6 +10,6 @@ // Created On : Wed Feb 3 07:56:22 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon May 29 11:33:15 2017 -// Update Count : 228 +// Last Modified On : Thu Jun 1 21:33:49 2017 +// Update Count : 315 // @@ -18,4 +18,5 @@ #include // malloc_usable_size #include // uintptr_t +#include // posix_memalign } // extern #include @@ -28,6 +29,6 @@ int main( void ) { size_t dim = 10; - struct S { int x; double y; } * s; int * p; + char fill = '\1'; // allocation, non-array types @@ -35,13 +36,19 @@ p = (void *)malloc( sizeof(*p) ); // C malloc, type unsafe *p = 0xdeadbeef; - printf( "C malloc %x\n", *p ); + printf( "C malloc %#x\n", *p ); free( p ); p = malloc(); // CFA malloc, type safe - printf( "CFA malloc %d\n", *p ); - free( p ); - - p = malloc( '\1' ); // CFA malloc, fill - printf( "CFA malloc, fill %08x\n", *p ); + *p = 0xdeadbeef; + printf( "CFA malloc %#x\n", *p ); + free( p ); + + p = alloc(); // CFA alloc, type safe + *p = 0xdeadbeef; + printf( "CFA alloc %#x\n", *p ); + free( p ); + + p = alloc( fill ); // CFA alloc, fill + printf( "CFA alloc, fill %08x\n", *p ); @@ -50,24 +57,25 @@ p = calloc( dim, sizeof( *p ) ); // C array calloc, type unsafe - printf( "C calloc\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } + printf( "C array calloc, fill 0\n" ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } printf( "\n" ); free( p ); p = calloc( dim ); // CFA array calloc, type safe - printf( "CFA calloc\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } - printf( "\n" ); - free( p ); - - p = amalloc( dim ); // CFA array malloc, type safe - printf( "CFA array malloc\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } - printf( "\n" ); - free( p ); - - p = amalloc( 2 * dim, '\1' ); // CFA array malloc, fill - printf( "CFA array malloc\n" ); - for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } + printf( "CFA array calloc, fill 0\n" ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } + printf( "\n" ); + free( p ); + + p = alloc( dim ); // CFA array alloc, type safe + for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; } + printf( "CFA array alloc, no fill\n" ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } + printf( "\n" ); + free( p ); + + p = alloc( 2 * dim, fill ); // CFA array alloc, fill + printf( "CFA array alloc, fill %#x\n", fill ); + for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); } printf( "\n" ); // do not free @@ -77,32 +85,14 @@ printf( "\n" ); - p = (void *)realloc( p, dim * sizeof(*p) ); // CFA realloc - printf( "C realloc\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } + p = (void *)realloc( p, dim * sizeof(*p) ); // C realloc + for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; } + printf( "C realloc %ld\n", malloc_usable_size( p ) ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } printf( "\n" ); p = realloc( p, 2 * dim * sizeof(*p) ); // CFA realloc - printf( "CFA realloc\n" ); - for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } - printf( "\n" ); - - p = realloc( p, dim * sizeof(*p), '\1' ); // CFA realloc - printf( "CFA realloc\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } - printf( "\n" ); - - p = malloc( p, dim * sizeof(*p) ); // CFA malloc - printf( "CFA resize malloc\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } - printf( "\n" ); - - p = malloc( p, 2 * dim * sizeof(*p), '\1' ); // CFA malloc, fill - printf( "CFA resize malloc, fill\n" ); - for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } - printf( "\n" ); - - p = malloc( p, dim * sizeof(*p), '\1' ); // CFA malloc, fill - printf( "CFA resize malloc, fill\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } + for ( int i = dim; i < 2 * dim; i += 1 ) { p[i] = 0x1010101; } + printf( "CFA realloc %ld\n", malloc_usable_size( p ) ); + for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); } printf( "\n" ); // do not free @@ -112,43 +102,62 @@ printf( "\n" ); - p = amalloc( p, 2 * dim ); // CFA array malloc - printf( "CFA resize array malloc\n" ); - for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } - printf( "\n" ); - - p = amalloc( p, dim ); // CFA array malloc - printf( "CFA resize array malloc\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } - printf( "\n" ); - - p = amalloc( p, 2 * dim, '\1' ); // CFA array malloc, fill - printf( "CFA resize array malloc, fill\n" ); - for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } - printf( "\n" ); - - p = amalloc( p, dim, '\1' ); // CFA array malloc, fill - printf( "CFA resize array malloc, fill\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } + p = alloc( p, dim ); // CFA resize array alloc + for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; } + printf( "CFA resize alloc %ld\n", malloc_usable_size( p ) ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } + printf( "\n" ); + + p = alloc( p, 2 * dim ); // CFA resize array alloc + for ( int i = dim; i < 2 * dim; i += 1 ) { p[i] = 0x1010101; } + printf( "CFA resize array alloc %ld\n", malloc_usable_size( p ) ); + for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); } + printf( "\n" ); + + p = alloc( p, dim ); // CFA array alloc + printf( "CFA resize array alloc %ld\n", malloc_usable_size( p ) ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } + printf( "\n" ); + free( p ); - printf( "\n" ); + p = 0; + + p = alloc( p, dim, fill ); // CFA array alloc, fill + printf( "CFA resize array alloc %ld, fill\n", malloc_usable_size( p ) ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } + printf( "\n" ); + + p = alloc( p, 2 * dim, fill ); // CFA array alloc, fill + printf( "CFA resize array alloc %ld, fill\n", malloc_usable_size( p ) ); + for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); } + printf( "\n" ); + + p = alloc( p, dim, fill ); // CFA array alloc, fill + printf( "CFA resize array alloc %ld, fill\n", malloc_usable_size( p ) ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] );; } + printf( "\n" ); + free( p ); + struct Struct { int x; double y; }; - Struct st, st1, sta[dim], sta1[dim], * stp; - + Struct st, st1, sta[dim], sta1[dim], * stp, * stp1; // alignment, non-array types printf( "\n" ); - enum { Alignment = 128 }; - stp = aligned_alloc( Alignment ); // CFA aligned_alloc + + stp = (memalign( Alignment, sizeof( *stp ) ) ){ 42, 42.5 }; // C memalign + assert( (uintptr_t)stp % Alignment == 0 ); + printf( "C memalign %d %g\n", stp->x, stp->y ); + free( stp ); + + stp = (memalign( Alignment )){ 42, 42.5 }; // CFA memalign + assert( (uintptr_t)stp % Alignment == 0 ); + printf( "CFA memalign %d %g\n", stp->x, stp->y ); + free( stp ); + + posix_memalign( (void **)&stp, Alignment, sizeof( *stp ) ); // C posix_memalign *stp = (Struct){ 42, 42.5 }; assert( (uintptr_t)stp % Alignment == 0 ); - printf( "CFA aligned_alloc %d %g\n", stp->x, stp->y ); - free( stp ); - - stp = memalign( Alignment ); // CFA memalign - *stp = (Struct){ 42, 42.5 }; - assert( (uintptr_t)stp % Alignment == 0 ); - printf( "CFA memalign %d %g\n", stp->x, stp->y ); + printf( "CFA posix_memalign %d %g\n", stp->x, stp->y ); free( stp ); @@ -159,7 +168,17 @@ free( stp ); - stp = memalign( Alignment, '\1' ); // CFA memalign, fill - assert( (uintptr_t)stp % Alignment == 0 ); - printf( "CFA memalign fill %d %g\n", stp->x, stp->y ); + stp = (aligned_alloc( Alignment )){ 42, 42.5 }; // CFA aligned_alloc + assert( (uintptr_t)stp % Alignment == 0 ); + printf( "CFA aligned_alloc %d %g\n", stp->x, stp->y ); + free( stp ); + + stp = (align_alloc( Alignment )){ 42, 42.5 }; // CFA align_alloc + assert( (uintptr_t)stp % Alignment == 0 ); + printf( "CFA align_alloc %d %g\n", stp->x, stp->y ); + free( stp ); + + stp = align_alloc( Alignment, fill ); // CFA memalign, fill + assert( (uintptr_t)stp % Alignment == 0 ); + printf( "CFA align_alloc fill %#x %a\n", stp->x, stp->y ); free( stp ); @@ -168,15 +187,16 @@ printf( "\n" ); - stp = amemalign( Alignment, 2 * dim ); // CFA array memalign - assert( (uintptr_t)stp % Alignment == 0 ); - printf( "CFA memalign array\n" ); - for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x %g, ", stp[i].x, stp[i].y ); stp[i].x = 0Xdeadbeef, stp[i].y = -17.2; } - printf( "\n" ); - free( stp ); - - stp = amemalign( Alignment, dim, '\1' ); // CFA array memalign, fill - assert( (uintptr_t)stp % Alignment == 0 ); - printf( "CFA memalign array\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x %g, ", stp[i].x, stp[i].y ); stp[i].x = 0Xdeadbeef, stp[i].y = -17.2; } + stp = align_alloc( Alignment, dim ); // CFA array memalign + assert( (uintptr_t)stp % Alignment == 0 ); + for ( int i = 0; i < dim; i += 1 ) { stp[i] = (Struct){ 42, 42.5 }; } + printf( "CFA array align_alloc\n" ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%d %g, ", stp[i].x, stp[i].y ); } + printf( "\n" ); + free( stp ); + + stp = align_alloc( Alignment, dim, fill ); // CFA array memalign, fill + assert( (uintptr_t)stp % Alignment == 0 ); + printf( "CFA array align_alloc, fill\n" ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", stp[i].x, stp[i].y ); } printf( "\n" ); free( stp ); @@ -186,8 +206,8 @@ printf( "\n" ); - stp = memset( &st, '\xff' ); // CFA memset, type safe - printf( "CFA memset %x %g\n", st.x, st.y ); - stp = memcpy( &st1, &st ); // CFA memcpy, type safe - printf( "CFA memcpy %x %g\n", st1.x, st1.y ); + memset( &st, fill ); // CFA memset, type safe + printf( "CFA memset %#x %a\n", st.x, st.y ); + memcpy( &st1, &st ); // CFA memcpy, type safe + printf( "CFA memcpy %#x %a\n", st1.x, st1.y ); @@ -195,12 +215,34 @@ printf( "\n" ); - stp = amemset( sta, dim, '\xff' ); // CFA array memset, type safe + memset( sta, dim, fill ); // CFA array memset, type safe printf( "CFA array memset\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x %g, ", sta[i].x, sta[i].y ); sta[i].x = 0Xdeadbeef, sta[i].y = -17.2; } - printf( "\n" ); - - stp = amemcpy( sta1, sta, dim ); // CFA array memcpy, type safe + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", sta[i].x, sta[i].y ); } + printf( "\n" ); + + memcpy( sta1, sta, dim ); // CFA array memcpy, type safe printf( "CFA memcpy\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x %g, ", sta1[i].x, sta1[i].y ); sta1[i].x = 0Xdeadbeef, sta1[i].y = -17.2; } + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", sta1[i].x, sta1[i].y ); } + printf( "\n" ); + + + // new, non-array types + printf( "\n" ); + + stp = new( 42, 42.5 ); + stp1 = new( 42, 42.5 ); + printf( "CFA new initialize\n%d %g %d %g\n", stp->x, stp->y, stp1->x, stp1->y ); + delete( stp, stp1 ); + + // new, array types + stp = anew( dim, 42, 42.5 ); + printf( "CFA array new initialize\n" ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%d %g, ", stp[i].x, stp[i].y ); } + printf( "\n" ); + stp1 = anew( dim, 42, 42.5 ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%d %g, ", stp1[i].x, stp1[i].y ); } + printf( "\n" ); + adelete( dim, stp, dim, stp1 ); + + // extras printf( "\n" ); @@ -211,10 +253,10 @@ p = foo( bar( baz( malloc(), 0 ), 0 ), 0 ); *p = 0xdeadbeef; - printf( "CFA deep malloc %x\n", *p ); + printf( "CFA deep malloc %#x\n", *p ); free( p ); stp = malloc(); printf( "\nSHOULD FAIL\n" ); - p = malloc( stp, dim * sizeof(*stp) ); + p = alloc( stp, dim * sizeof(*stp) ); p = memset( stp, 10 ); p = memcpy( &st1, &st );