Changeset acd738aa


Ignore:
Timestamp:
Jun 2, 2017, 11:23:21 AM (7 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc
Children:
6b72040
Parents:
9c1600c (diff), 49c9773 (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

Files:
9 edited

Legend:

Unmodified
Added
Removed
  • doc/user/user.tex

    r9c1600c racd738aa  
    1111%% Created On       : Wed Apr  6 14:53:29 2016
    1212%% Last Modified By : Peter A. Buhr
    13 %% Last Modified On : Tue May 30 11:45:46 2017
    14 %% Update Count     : 2098
     13%% Last Modified On : Thu Jun  1 22:46:09 2017
     14%% Update Count     : 2126
    1515%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1616
     
    52425242\begin{description}
    52435243\item[fill]
    5244 after allocation the storage is or is not filled with a specified character.
     5244after allocation the storage is filled with a specified character.
    52455245\item[resize]
    52465246an existing allocation is decreased or increased in size.
    52475247In 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.
    5248 For an increase in storage size, new storage after the copied data may or may not be filled.
     5248For an increase in storage size, new storage after the copied data may be filled.
    52495249\item[alignment]
    52505250an allocation starts on a specified memory boundary, e.g., an address multiple of 64 or 128 for cache-line purposes.
    52515251\item[array]
    52525252the allocation size is scaled to the specified number of array elements.
    5253 An array may or not be filled, resized, or aligned.
     5253An array may be filled, resized, or aligned.
    52545254\end{description}
    5255 
    5256 The following table show the allocation routines supporting different combinations of storage-management capabilities:
     5255The table shows allocation routines supporting different combinations of storage-management capabilities:
    52575256\begin{center}
    5258 \begin{tabular}{@{}r|l|l|l|l@{}}
    5259                                         & fill                          & resize        & alignment     & array \\
     5257\begin{tabular}{@{}lr|l|l|l|l@{}}
     5258                &                                       & \multicolumn{1}{c|}{fill}     & resize        & alignment     & array \\
    52605259\hline
    5261 ©malloc©                        & no/yes                        & no/yes        & no            & no    \\
    5262 ©amalloc©                       & no/copy data/yes      & no/yes        & no            & yes   \\
    5263 ©calloc©                        & yes (0 only)          & no            & no            & yes   \\
    5264 ©realloc©                       & no/copy data          & yes           & no            & no    \\
    5265 ©memalign©                      & no/yes                        & no            & yes           & no    \\
    5266 ©amemalign©                     & no/yes                        & no            & yes           & yes   \\
    5267 ©align_alloc©           & no                            & no            & yes           & no    \\
    5268 ©posix_memalign©        & no                            & no            & yes           & no    \\
     5260C               & ©malloc©                      & no                    & no            & no            & no    \\
     5261                & ©calloc©                      & yes (0 only)  & no            & no            & yes   \\
     5262                & ©realloc©                     & no/copy               & yes           & no            & no    \\
     5263                & ©memalign©            & no                    & no            & yes           & no    \\
     5264                & ©posix_memalign©      & no                    & no            & yes           & no    \\
     5265C11             & ©aligned_alloc©       & no                    & no            & yes           & no    \\
     5266\CFA    & ©alloc©                       & no/copy/yes   & no/yes        & no            & yes   \\
     5267                & ©align_alloc©         & no/yes                & no            & yes           & yes   \\
    52695268\end{tabular}
    52705269\end{center}
    5271 % When ©amalloc© resizes and fills, the space after the copied data from the source is set to the fill character.
    52725270It 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.
    52735271
    52745272\leavevmode
    52755273\begin{cfa}[aboveskip=0pt,belowskip=0pt]
    5276 // allocation, non-array types
    5277 forall( dtype T | sized(T) ) T * malloc( void );§\indexc{malloc}§
    5278 forall( dtype T | sized(T) ) T * malloc( char fill );
    5279 
    5280 // allocation, array types
    5281 forall( dtype T | sized(T) ) T * calloc( size_t dim );§\indexc{cmalloc}§
    5282 forall( dtype T | sized(T) ) T * amalloc( size_t dim );§\indexc{amalloc}§  // alternate name for calloc
    5283 forall( dtype T | sized(T) ) T * amalloc( size_t dim, char fill );
    5284 
    5285 // resize, non-array types
    5286 forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size );§\indexc{realloc}§
    5287 forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, char fill );
    5288 forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size );  // alternate name for realloc
    5289 forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size, char fill );
    5290 
    5291 // resize, array types
    5292 forall( dtype T | sized(T) ) T * amalloc( T * ptr, size_t dim );
    5293 forall( dtype T | sized(T) ) T * amalloc( T * ptr, size_t dim, char fill );
    5294 
    5295 // alignment, non-array types
    5296 forall( dtype T | sized(T) ) T * memalign( size_t alignment );§\indexc{memalign}§
    5297 forall( dtype T | sized(T) ) T * memalign( size_t alignment, char fill );
    5298 forall( dtype T | sized(T) ) T * aligned_alloc( size_t alignment );§\indexc{aligned_alloc}§
    5299 forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t alignment );§\indexc{posix_memalign}§
    5300 
    5301 // alignment, array types
    5302 forall( dtype T | sized(T) ) T * amemalign( size_t alignment, size_t dim );§\indexc{amemalign}§
    5303 forall( dtype T | sized(T) ) T * amemalign( size_t alignment, size_t dim, char fill );
    5304 
    5305 // data, non-array types
     5274// C unsafe allocation
     5275extern "C" { void * mallac( size_t size ); }§\indexc{memset}§
     5276extern "C" { void * calloc( size_t dim, size_t size ); }§\indexc{calloc}§
     5277extern "C" { void * realloc( void * ptr, size_t size ); }§\indexc{realloc}§
     5278extern "C" { void * memalign( size_t align, size_t size ); }§\indexc{memalign}§
     5279extern "C" { int posix_memalign( void ** ptr, size_t align, size_t size ); }§\indexc{posix_memalign}§
     5280
     5281// §\CFA§ safe equivalents, i.e., implicit size specification
     5282forall( dtype T | sized(T) ) T * malloc( void );
     5283forall( dtype T | sized(T) ) T * calloc( size_t dim );
     5284forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size );
     5285forall( dtype T | sized(T) ) T * memalign( size_t align );
     5286forall( dtype T | sized(T) ) T * aligned_alloc( size_t align );
     5287forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t align );
     5288
     5289// §\CFA§ safe general allocation, fill, resize, array
     5290forall( dtype T | sized(T) ) T * alloc( void );§\indexc{alloc}§
     5291forall( dtype T | sized(T) ) T * alloc( char fill );
     5292forall( dtype T | sized(T) ) T * alloc( size_t dim );
     5293forall( dtype T | sized(T) ) T * alloc( size_t dim, char fill );
     5294forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim );
     5295forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill );
     5296
     5297// §\CFA§ safe general allocation, align, fill, array
     5298forall( dtype T | sized(T) ) T * align_alloc( size_t align );
     5299forall( dtype T | sized(T) ) T * align_alloc( size_t align, char fill );
     5300forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim );
     5301forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim, char fill );
     5302
     5303// C unsafe initialization/copy
     5304extern "C" { void * memset( void * dest, int c, size_t size ); }
     5305extern "C" { void * memcpy( void * dest, const void * src, size_t size ); }
     5306
     5307// §\CFA§ safe initialization/copy
    53065308forall( dtype T | sized(T) ) T * memset( T * dest, char c );§\indexc{memset}§
    53075309forall( dtype T | sized(T) ) T * memcpy( T * dest, const T * src );§\indexc{memcpy}§
    53085310
    5309 // data, array types
    5310 forall( dtype T | sized(T) ) T * amemset( T * dest, size_t dim, char c );§\indexc{amemset}§
    5311 forall( dtype T | sized(T) ) T * amemcpy( T * dest, const T * src, size_t dim );§\indexc{amemcpy}§
    5312 
    5313 // allocation/deallocation and constructor/destructor
    5314 forall( dtype T, ttype Params | sized(T) | { void ?{}(T *, Params); } ) T * new( Params p );§\indexc{new}§
     5311// §\CFA§ safe initialization/copy array
     5312forall( dtype T | sized(T) ) T * memset( T dest[], size_t dim, char c );
     5313forall( dtype T | sized(T) ) T * memcpy( T dest[], const T src[], size_t dim );
     5314
     5315// §\CFA§ allocation/deallocation and constructor/destructor
     5316forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * new( Params p );§\indexc{new}§
    53155317forall( dtype T | { void ^?{}( T * ); } ) void delete( T * ptr );§\indexc{delete}§
    5316 forall( dtype T, ttype Params | { void ^?{}( T * ); void delete(Params); } ) void delete( T * ptr, Params rest );
     5318forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } )
     5319  void delete( T * ptr, Params rest );
     5320
     5321// §\CFA§ allocation/deallocation and constructor/destructor, array
     5322forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * anew( size_t dim, Params p );§\indexc{anew}§
     5323forall( dtype T | sized(T) | { void ^?{}( T * ); } ) void adelete( size_t dim, T arr[] );§\indexc{adelete}§
     5324forall( dtype T | sized(T) | { void ^?{}( T * ); }, ttype Params | { void adelete( Params ); } )
     5325  void adelete( size_t dim, T arr[], Params rest );
    53175326\end{cfa}
    53185327
  • src/Common/PassVisitor.h

    r9c1600c racd738aa  
    2626
    2727        template< typename... Args >
    28         PassVisitor(Args &&... args) 
     28        PassVisitor(Args &&... args)
    2929                : pass( std::forward<Args>( args )... )
    3030        {}
    3131
    3232        virtual ~PassVisitor() = default;
    33 private:
     33
    3434        pass_type pass;
    35 
    36 public:
    3735
    3836        virtual void visit( ObjectDecl *objectDecl ) override final;
  • src/InitTweak/FixInit.cc

    r9c1600c racd738aa  
    192192                };
    193193
    194                 class FixInit final : public GenPoly::PolyMutator {
     194                class FixInit {
    195195                  public:
    196196                        /// expand each object declaration to use its constructor after it is declared.
    197197                        static void fixInitializers( std::list< Declaration * > &translationUnit );
    198198
    199                         typedef GenPoly::PolyMutator Parent;
    200                         using Parent::mutate;
    201                         virtual DeclarationWithType * mutate( ObjectDecl *objDecl ) override;
     199                        DeclarationWithType * postmutate( ObjectDecl *objDecl );
    202200
    203201                        std::list< Declaration * > staticDtorDecls;
     202                        std::list< Statement * > stmtsToAddAfter; // found by PassVisitor
    204203                };
    205204
     
    312311
    313312                void FixInit::fixInitializers( std::list< Declaration * > & translationUnit ) {
    314                         FixInit fixer;
     313                        PassVisitor<FixInit> fixer;
    315314
    316315                        // can't use mutateAll, because need to insert declarations at top-level
     
    320319                                try {
    321320                                        *i = maybeMutate( *i, fixer );
    322                                         translationUnit.splice( i, fixer.staticDtorDecls );
     321                                        translationUnit.splice( i, fixer.pass.staticDtorDecls );
    323322                                } catch( SemanticError &e ) {
    324323                                        e.set_location( (*i)->location );
     
    696695                }
    697696
    698                 DeclarationWithType *FixInit::mutate( ObjectDecl *objDecl ) {
    699                         // first recursively handle pieces of ObjectDecl so that they aren't missed by other visitors when the init
    700                         // is removed from the ObjectDecl
    701                         objDecl = dynamic_cast< ObjectDecl * >( Parent::mutate( objDecl ) );
     697                DeclarationWithType *FixInit::postmutate( ObjectDecl *objDecl ) {
     698                        // since this removes the init field from objDecl, it must occur after children are mutated (i.e. postmutate)
    702699                        if ( ConstructorInit * ctorInit = dynamic_cast< ConstructorInit * >( objDecl->get_init() ) ) {
    703700                                // a decision should have been made by the resolver, so ctor and init are not both non-NULL
  • src/Parser/lex.ll

    r9c1600c racd738aa  
    55 * file "LICENCE" distributed with Cforall.
    66 *
    7  * lex.l --
     7 * lex.ll --
    88 *
    99 * Author           : Peter A. Buhr
    1010 * Created On       : Sat Sep 22 08:58:10 2001
    1111 * Last Modified By : Peter A. Buhr
    12  * Last Modified On : Mon May 22 07:46:30 2017
    13  * Update Count     : 525
     12 * Last Modified On : Tue May 30 22:00:48 2017
     13 * Update Count     : 527
    1414 */
    1515
     
    235235long                    { KEYWORD_RETURN(LONG); }
    236236lvalue                  { KEYWORD_RETURN(LVALUE); }                             // CFA
    237 monitor         { KEYWORD_RETURN(MONITOR); }                    // CFA
     237monitor                 { KEYWORD_RETURN(MONITOR); }                    // CFA
    238238mutex                   { KEYWORD_RETURN(MUTEX); }                              // CFA
    239239_Noreturn               { KEYWORD_RETURN(NORETURN); }                   // C11
  • src/libcfa/stdlib

    r9c1600c racd738aa  
    1010// Created On       : Thu Jan 28 17:12:35 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue May 30 09:07:35 2017
    13 // Update Count     : 164
     12// Last Modified On : Thu Jun  1 22:46:43 2017
     13// Update Count     : 216
    1414//
    1515
     
    2828//---------------------------------------
    2929
    30 extern "C" { void * memset( void * dest, int c, size_t size ); } // use default C routine for void *
    31 
    3230// allocation, non-array types
    3331static inline forall( dtype T | sized(T) ) T * malloc( void ) {
     
    3533        return (T *)(void *)malloc( (size_t)sizeof(T) );        // C malloc
    3634} // malloc
    37 static inline forall( dtype T | sized(T) ) T * malloc( char fill ) {
     35
     36extern "C" { void * calloc( size_t dim, size_t size ); } // default C routine
     37static inline forall( dtype T | sized(T) ) T * calloc( size_t dim ) {
    3838        //printf( "X2\n" );
     39        return (T *)(void *)calloc( dim, sizeof(T) );           // C cmalloc
     40}
     41
     42extern "C" { void * realloc( void * ptr, size_t size ); } // default C routine for void *
     43static inline forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size ) {
     44        //printf( "X3\n" );
     45        return (T *)(void *)realloc( (void *)ptr, size );
     46}
     47
     48extern "C" { void * memalign( size_t align, size_t size ); } // use default C routine for void *
     49static inline forall( dtype T | sized(T) ) T * memalign( size_t align ) {
     50        //printf( "X4\n" );
     51        return (T *)memalign( align, sizeof(T) );
     52} // memalign
     53
     54static inline forall( dtype T | sized(T) ) T * aligned_alloc( size_t align ) {
     55        //printf( "X5\n" );
     56        return (T *)memalign( align, sizeof(T) );
     57} // aligned_alloc
     58
     59extern "C" { int posix_memalign( void ** ptr, size_t align, size_t size ); } // use default C routine for void *
     60static inline forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t align ) {
     61        //printf( "X6\n" );
     62        return posix_memalign( (void **)ptr, align, sizeof(T) );
     63} // posix_memalign
     64
     65
     66extern "C" { void * memset( void * dest, int c, size_t size ); } // use default C routine for void *
     67
     68static inline forall( dtype T | sized(T) ) T * alloc( void ) {
     69        //printf( "X7\n" );
     70        return (T *)(void *)malloc( (size_t)sizeof(T) );        // C malloc
     71} // alloc
     72static inline forall( dtype T | sized(T) ) T * alloc( char fill ) {
     73        //printf( "X8\n" );
    3974        T * ptr = (T *)(void *)malloc( (size_t)sizeof(T) );     // C malloc
    4075    return memset( ptr, (int)fill, sizeof(T) );                 // initial with fill value
    41 } // malloc
    42 
    43 // allocation, array types
    44 extern "C" { void * calloc( size_t dim, size_t size ); } // use default C routine for void *
    45 static inline forall( dtype T | sized(T) ) T * calloc( size_t dim ) {
    46         //printf( "X3\n" );
    47         return (T *)(void *)calloc( dim, sizeof(T) );           // C cmalloc
    48 }
    49 static inline forall( dtype T | sized(T) ) T * amalloc( size_t dim ) { // alternative name
    50         //printf( "X4\n" );
     76} // alloc
     77
     78static inline forall( dtype T | sized(T) ) T * alloc( size_t dim ) {
     79        //printf( "X9\n" );
    5180        return (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc
    52 } // amalloc
    53 static inline forall( dtype T | sized(T) ) T * amalloc( size_t dim, char fill ) { // alternative name
    54         //printf( "X5\n" );
     81} // alloc
     82static inline forall( dtype T | sized(T) ) T * alloc( size_t dim, char fill ) {
     83        //printf( "X10\n" );
    5584        T * ptr = (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc
    5685    return memset( ptr, (int)fill, dim * sizeof(T) );
    57 } // amalloc
    58 
    59 // resize, non-array types
    60 extern "C" { void * realloc( void * ptr, size_t size ); } // use default C routine for void *
    61 static inline forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size ) {
    62         //printf( "X5.5\n" );
    63         return (T *)(void *)realloc( (void *)ptr, size );
    64 }
    65 forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, char fill );
    66 static inline forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size ) { // alternative name
    67         //printf( "X7\n" );
    68         return realloc( ptr, size );
    69 } // malloc
    70 static inline forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size, char fill ) { // alternative name
    71         //printf( "X8\n" );
    72         return realloc( ptr, size, fill );
    73 } // malloc
    74 
    75 // resize, array types
    76 static inline forall( dtype T | sized(T) ) T * amalloc( T * ptr, size_t dim ) {
    77         //printf( "X9\n" );
    78         return malloc( ptr, dim * (size_t)sizeof(T) );
    79 } // amalloc
    80 static inline forall( dtype T | sized(T) ) T * amalloc( T * ptr, size_t dim, char fill ) {
    81         //printf( "X10\n" );
    82         return malloc( ptr, dim * (size_t)sizeof(T), fill );
    83 } // amalloc
    84 
    85 // alignment, non-array types
    86 extern "C" { void * memalign( size_t alignment, size_t size ); } // use default C routine for void *
    87 static inline forall( dtype T | sized(T) ) T * memalign( size_t alignment ) {
     86} // alloc
     87
     88static inline forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim ) {
    8889        //printf( "X11\n" );
    89         return (T *)memalign( alignment, sizeof(T) );
    90 } // memalign
    91 static inline forall( dtype T | sized(T) ) T * memalign( size_t alignment, char fill ) {
    92         //printf( "X12\n" );
    93     T * ptr = (T *)memalign( alignment, sizeof(T) );
     90        return (void *)realloc( (void *)ptr, dim * (size_t)sizeof(T) ); // C realloc
     91} // alloc
     92forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill );
     93
     94static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align ) {
     95        //printf( "X13\n" );
     96        return (T *)memalign( align, sizeof(T) );
     97} // align_alloc
     98static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, char fill ) {
     99        //printf( "X14\n" );
     100    T * ptr = (T *)memalign( align, sizeof(T) );
    94101    return memset( ptr, (int)fill, sizeof(T) );
    95 } // memalign
    96 static inline forall( dtype T | sized(T) ) T * aligned_alloc( size_t alignment ) {
    97         //printf( "X13\n" );
    98         return (T *)memalign( alignment, sizeof(T) );
    99 } // aligned_alloc
    100 extern "C" { int posix_memalign( void ** ptr, size_t alignment, size_t size ); } // use default C routine for void *
    101 static inline forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t alignment ) {
    102         //printf( "X14\n" );
    103         return posix_memalign( (void **)ptr, alignment, sizeof(T) );
    104 } // posix_memalign
    105 
    106 // alignment, array types
    107 static inline forall( dtype T | sized(T) ) T * amemalign( size_t alignment, size_t dim ) {
     102} // align_alloc
     103
     104static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim ) {
    108105        //printf( "X15\n" );
    109         return (T *)memalign( alignment, dim * sizeof(T) );
    110 } // amemalign
    111 static inline forall( dtype T | sized(T) ) T * amemalign( size_t alignment, size_t dim, char fill ) {
     106        return (T *)memalign( align, dim * sizeof(T) );
     107} // align_alloc
     108static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim, char fill ) {
    112109        //printf( "X16\n" );
    113     T * ptr = (T *)memalign( alignment, dim * sizeof(T) );
     110    T * ptr = (T *)memalign( align, dim * sizeof(T) );
    114111    return memset( ptr, (int)fill, dim * sizeof(T) );
    115 } // amemalign
     112} // align_alloc
     113
    116114
    117115// data, non-array types
     
    127125
    128126// data, array types
    129 static inline forall( dtype T | sized(T) ) T * amemset( T * dest, size_t dim, char c ) {
     127static inline forall( dtype T | sized(T) ) T * memset( T dest[], size_t dim, char c ) {
    130128        //printf( "X19\n" );
    131129        return memset( dest, c, dim * sizeof(T) );
    132 } // amemset
    133 static inline forall( dtype T | sized(T) ) T * amemcpy( T * dest, const T * src, size_t dim ) {
     130} // memset
     131static inline forall( dtype T | sized(T) ) T * memcpy( T dest[], const T src[], size_t dim ) {
    134132        //printf( "X20\n" );
    135         return memcpy( dest, src, dim * sizeof(T) );
    136 } // amemcpy
    137 
    138 // allocation/deallocation and constructor/destructor
    139 forall( dtype T, ttype Params | sized(T) | { void ?{}(T *, Params); } ) T * new( Params p );
     133        return (void *)memcpy( dest, src, dim * sizeof(T) ); // C memcpy
     134} // memcpy
     135
     136// allocation/deallocation and constructor/destructor, non-array types
     137forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * new( Params p );
    140138forall( dtype T | { void ^?{}( T * ); } ) void delete( T * ptr );
    141139forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } ) void delete( T * ptr, Params rest );
     140
     141// allocation/deallocation and constructor/destructor, array types
     142forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * anew( size_t dim, Params p );
     143forall( dtype T | sized(T) | { void ^?{}( T * ); } ) void adelete( size_t dim, T arr[] );
     144forall( dtype T | sized(T) | { void ^?{}( T * ); }, ttype Params | { void adelete( Params ); } ) void adelete( size_t dim, T arr[], Params rest );
    142145
    143146//---------------------------------------
  • src/libcfa/stdlib.c

    r9c1600c racd738aa  
    1010// Created On       : Thu Jan 28 17:10:29 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue May 30 09:07:56 2017
    13 // Update Count     : 237
     12// Last Modified On : Thu Jun  1 21:52:57 2017
     13// Update Count     : 280
    1414//
    1515
     
    2828
    2929// resize, non-array types
    30 forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, char fill ) { // alternative realloc with fill value
    31         //printf( "X6\n" );
     30forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill ) {
    3231        size_t olen = malloc_usable_size( ptr );                        // current allocation
    33     char * nptr = (void *)realloc( (void *)ptr, size ); // C realloc
     32    char * nptr = (void *)realloc( (void *)ptr, dim * (size_t)sizeof(T) ); // C realloc
    3433        size_t nlen = malloc_usable_size( nptr );                       // new allocation
    3534        if ( nlen > olen ) {                                                            // larger ?
     
    3736        } //
    3837    return (T *)nptr;
    39 } // realloc
    40 
    41 // allocation/deallocation and constructor/destructor
    42 forall( dtype T, ttype Params | sized(T) | { void ?{}( T *, Params ); } )
     38} // alloc
     39
     40// allocation/deallocation and constructor/destructor, non-array types
     41forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } )
    4342T * new( Params p ) {
    44         return ((T *)malloc()){ p };
     43        return (malloc()){ p };                                                         // run constructor
    4544} // new
    4645
    4746forall( dtype T | { void ^?{}( T * ); } )
    4847void delete( T * ptr ) {
    49         if ( ptr ) {
     48        if ( ptr ) {                                                                            // ignore null
    5049                ^ptr{};                                                                                 // run destructor
    5150                free( ptr );
     
    5554forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } )
    5655void delete( T * ptr, Params rest ) {
    57         if ( ptr ) {
     56        if ( ptr ) {                                                                            // ignore null
    5857                ^ptr{};                                                                                 // run destructor
    5958                free( ptr );
     
    6160        delete( rest );
    6261} // delete
     62
     63
     64// allocation/deallocation and constructor/destructor, array types
     65forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } )
     66T * anew( size_t dim, Params p ) {
     67        T *arr = alloc( dim );
     68        for ( unsigned int i = 0; i < dim; i += 1 ) {
     69                (&arr[i]){ p };                                                                 // run constructor
     70        } // for
     71        return arr;
     72} // anew
     73
     74forall( dtype T | sized(T) | { void ^?{}( T * ); } )
     75void adelete( size_t dim, T arr[] ) {
     76        if ( arr ) {                                                                            // ignore null
     77                for ( int i = dim - 1; i >= 0; i -= 1 ) {               // reverse allocation order, must be unsigned
     78                        ^(&arr[i]){};                                                           // run destructor
     79                } // for
     80                free( arr );
     81        } // if
     82} // adelete
     83
     84forall( dtype T | sized(T) | { void ^?{}( T * ); }, ttype Params | { void adelete( Params ); } )
     85void adelete( size_t dim, T arr[], Params rest ) {
     86        if ( arr ) {                                                                            // ignore null
     87                for ( int i = dim - 1; i >= 0; i -= 1 ) {               // reverse allocation order, must be unsigned
     88                        ^(&arr[i]){};                                                           // run destructor
     89                } // for
     90                free( arr );
     91        } // if
     92        adelete( rest );
     93} // adelete
    6394
    6495//---------------------------------------
  • src/tests/.expect/alloc.txt

    r9c1600c racd738aa  
    1 C   malloc deadbeef
    2 CFA malloc 0
    3 CFA malloc, fill 01010101
     1C   malloc 0xdeadbeef
     2CFA malloc 0xdeadbeef
     3CFA alloc 0xdeadbeef
     4CFA alloc, fill 01010101
    45
    5 C   calloc
     6C   array calloc, fill 0
    670 0 0 0 0 0 0 0 0 0
    7 CFA calloc
     8CFA array calloc, fill 0
    890 0 0 0 0 0 0 0 0 0
    9 CFA array malloc
    10 0 0 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef
    11 CFA array malloc
    12 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101
     10CFA array alloc, no fill
     110xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef
     12CFA array alloc, fill 0x1
     130x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101
    1314
    14 C   realloc
    15 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef
    16 CFA realloc
    17 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 0 0 0 0 0 0 0 0 0 0
    18 CFA realloc
    19 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef
    20 CFA resize malloc
    21 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef
    22 CFA resize malloc, fill
    23 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101
    24 CFA resize malloc, fill
    25 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef
     15C   realloc 40
     160xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef
     17CFA realloc 88
     180xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101
    2619
    27 CFA resize array malloc
    28 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 0 0 0 0 0 0 0 0 0 0
    29 CFA resize array malloc
    30 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef
    31 CFA resize array malloc, fill
    32 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101
    33 CFA resize array malloc, fill
    34 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef
     20CFA resize alloc 40
     210xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef
     22CFA resize array alloc 88
     230xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101
     24CFA resize array alloc 40
     250xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef
     26CFA resize array alloc 40, fill
     270x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101
     28CFA resize array alloc 88, fill
     290x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101
     30CFA resize array alloc 40, fill
     310x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101
    3532
    36 CFA aligned_alloc 42 42.5
     33C   memalign 42 42.5
    3734CFA memalign 42 42.5
    3835CFA posix_memalign 42 42.5
    39 CFA memalign fill 16843009 7.7486e-304
     36CFA posix_memalign 42 42.5
     37CFA aligned_alloc 42 42.5
     38CFA align_alloc 42 42.5
     39CFA align_alloc fill 0x1010101 0x1.1010101010101p-1007
    4040
    41 CFA memalign array
    42 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,
    43 CFA memalign array
    44 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,
     41CFA array align_alloc
     4242 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,
     43CFA array align_alloc, fill
     440x1010101 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,
    4545
    46 CFA memset ffffffff -nan
    47 CFA memcpy ffffffff -nan
     46CFA memset 0x1010101 0x1.1010101010101p-1007
     47CFA memcpy 0x1010101 0x1.1010101010101p-1007
    4848
    4949CFA array memset
    50 ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan,
     500x1010101 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,
    5151CFA memcpy
    52 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,
     520x1010101 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,
     53
     54CFA new initialize
     5542 42.5 42 42.5
     56CFA array new initialize
     5742 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,
     5842 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,
     59
    5360pointer arithmetic 0
    54 CFA deep malloc deadbeef
     61CFA deep malloc 0xdeadbeef
    5562
    5663SHOULD FAIL
  • src/tests/alloc.c

    r9c1600c racd738aa  
    1010// Created On       : Wed Feb  3 07:56:22 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon May 29 11:33:15 2017
    13 // Update Count     : 228
     12// Last Modified On : Thu Jun  1 21:33:49 2017
     13// Update Count     : 315
    1414//
    1515
     
    1818#include <malloc.h>                                                                             // malloc_usable_size
    1919#include <stdint.h>                                                                             // uintptr_t
     20#include <stdlib.h>                                                                             // posix_memalign
    2021} // extern
    2122#include <fstream>
     
    2829int main( void ) {
    2930    size_t dim = 10;
    30     struct S { int x; double y; } * s;
    3131    int * p;
     32        char fill = '\1';
    3233
    3334        // allocation, non-array types
     
    3536    p = (void *)malloc( sizeof(*p) );                                   // C malloc, type unsafe
    3637        *p = 0xdeadbeef;
    37         printf( "C   malloc %x\n", *p );
     38        printf( "C   malloc %#x\n", *p );
    3839    free( p );
    3940
    4041    p = malloc();                                                                               // CFA malloc, type safe
    41         printf( "CFA malloc %d\n", *p );
    42     free( p );
    43 
    44     p = malloc( '\1' );                                                                 // CFA malloc, fill
    45         printf( "CFA malloc, fill %08x\n", *p );
     42        *p = 0xdeadbeef;
     43        printf( "CFA malloc %#x\n", *p );
     44    free( p );
     45
     46    p = alloc();                                                                                // CFA alloc, type safe
     47        *p = 0xdeadbeef;
     48        printf( "CFA alloc %#x\n", *p );
     49    free( p );
     50
     51    p = alloc( fill );                                                                  // CFA alloc, fill
     52        printf( "CFA alloc, fill %08x\n", *p );
    4653
    4754
     
    5057
    5158    p = calloc( dim, sizeof( *p ) );                                    // C array calloc, type unsafe
    52         printf( "C   calloc\n" );
    53         for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
     59        printf( "C   array calloc, fill 0\n" );
     60        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
    5461        printf( "\n" );
    5562    free( p );
    5663
    5764    p = calloc( dim );                                                                  // CFA array calloc, type safe
    58         printf( "CFA calloc\n" );
    59         for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
    60         printf( "\n" );
    61     free( p );
    62 
    63     p = amalloc( dim );                                                                 // CFA array malloc, type safe
    64         printf( "CFA array malloc\n" );
    65         for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
    66         printf( "\n" );
    67     free( p );
    68 
    69     p = amalloc( 2 * dim, '\1' );                                               // CFA array malloc, fill
    70         printf( "CFA array malloc\n" );
    71         for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
     65        printf( "CFA array calloc, fill 0\n" );
     66        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
     67        printf( "\n" );
     68    free( p );
     69
     70    p = alloc( dim );                                                                   // CFA array alloc, type safe
     71        for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; }
     72        printf( "CFA array alloc, no fill\n" );
     73        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
     74        printf( "\n" );
     75    free( p );
     76
     77    p = alloc( 2 * dim, fill );                                                 // CFA array alloc, fill
     78        printf( "CFA array alloc, fill %#x\n", fill );
     79        for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); }
    7280        printf( "\n" );
    7381        // do not free
     
    7785        printf( "\n" );
    7886
    79     p = (void *)realloc( p, dim * sizeof(*p) );                 // CFA realloc
    80         printf( "C   realloc\n" );
    81         for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
     87    p = (void *)realloc( p, dim * sizeof(*p) );                 // C realloc
     88        for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; }
     89        printf( "C   realloc %ld\n", malloc_usable_size( p ) );
     90        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
    8291        printf( "\n" );
    8392
    8493    p = realloc( p, 2 * dim * sizeof(*p) );                             // CFA realloc
    85         printf( "CFA realloc\n" );
    86         for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
    87         printf( "\n" );
    88 
    89     p = realloc( p, dim * sizeof(*p), '\1' );                   // CFA realloc
    90         printf( "CFA realloc\n" );
    91         for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
    92         printf( "\n" );
    93 
    94     p = malloc( p, dim * sizeof(*p) );                                  // CFA malloc
    95         printf( "CFA resize malloc\n" );
    96         for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
    97         printf( "\n" );
    98 
    99     p = malloc( p, 2 * dim * sizeof(*p), '\1' );                // CFA malloc, fill
    100         printf( "CFA resize malloc, fill\n" );
    101         for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
    102         printf( "\n" );
    103 
    104     p = malloc( p, dim * sizeof(*p), '\1' );                    // CFA malloc, fill
    105         printf( "CFA resize malloc, fill\n" );
    106         for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
     94        for ( int i = dim; i < 2 * dim; i += 1 ) { p[i] = 0x1010101; }
     95        printf( "CFA realloc %ld\n", malloc_usable_size( p ) );
     96        for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); }
    10797        printf( "\n" );
    10898        // do not free
     
    112102        printf( "\n" );
    113103
    114     p = amalloc( p, 2 * dim );                                                  // CFA array malloc
    115         printf( "CFA resize array malloc\n" );
    116         for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
    117         printf( "\n" );
    118 
    119     p = amalloc( p, dim );                                                              // CFA array malloc
    120         printf( "CFA resize array malloc\n" );
    121         for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
    122         printf( "\n" );
    123 
    124     p = amalloc( p, 2 * dim, '\1' );                                    // CFA array malloc, fill
    125         printf( "CFA resize array malloc, fill\n" );
    126         for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
    127         printf( "\n" );
    128 
    129     p = amalloc( p, dim, '\1' );                                                // CFA array malloc, fill
    130         printf( "CFA resize array malloc, fill\n" );
    131         for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
     104    p = alloc( p, dim );                                                                // CFA resize array alloc
     105        for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; }
     106        printf( "CFA resize alloc %ld\n", malloc_usable_size( p ) );
     107        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
     108        printf( "\n" );
     109
     110    p = alloc( p, 2 * dim );                                                    // CFA resize array alloc
     111        for ( int i = dim; i < 2 * dim; i += 1 ) { p[i] = 0x1010101; }
     112        printf( "CFA resize array alloc %ld\n", malloc_usable_size( p ) );
     113        for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); }
     114        printf( "\n" );
     115
     116    p = alloc( p, dim );                                                                // CFA array alloc
     117        printf( "CFA resize array alloc %ld\n", malloc_usable_size( p ) );
     118        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
     119        printf( "\n" );
     120
    132121        free( p );
    133         printf( "\n" );
     122        p = 0;
     123
     124    p = alloc( p, dim, fill );                                                  // CFA array alloc, fill
     125        printf( "CFA resize array alloc %ld, fill\n", malloc_usable_size( p ) );
     126        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
     127        printf( "\n" );
     128
     129    p = alloc( p, 2 * dim, fill );                                              // CFA array alloc, fill
     130        printf( "CFA resize array alloc %ld, fill\n", malloc_usable_size( p ) );
     131        for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); }
     132        printf( "\n" );
     133
     134    p = alloc( p, dim, fill );                                                  // CFA array alloc, fill
     135        printf( "CFA resize array alloc %ld, fill\n", malloc_usable_size( p ) );
     136        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] );; }
     137        printf( "\n" );
     138        free( p );
     139
    134140
    135141    struct Struct { int x; double y; };
    136     Struct st, st1, sta[dim], sta1[dim], * stp;
    137 
     142    Struct st, st1, sta[dim], sta1[dim], * stp, * stp1;
    138143
    139144        // alignment, non-array types
    140145        printf( "\n" );
    141 
    142146        enum { Alignment = 128 };
    143     stp = aligned_alloc( Alignment );                                   // CFA aligned_alloc
     147
     148    stp = (memalign( Alignment, sizeof( *stp ) ) ){ 42, 42.5 }; // C memalign
     149        assert( (uintptr_t)stp % Alignment == 0 );
     150        printf( "C   memalign %d %g\n", stp->x, stp->y );
     151    free( stp );
     152
     153    stp = (memalign( Alignment )){ 42, 42.5 };                  // CFA memalign
     154        assert( (uintptr_t)stp % Alignment == 0 );
     155        printf( "CFA memalign %d %g\n", stp->x, stp->y );
     156    free( stp );
     157
     158    posix_memalign( (void **)&stp, Alignment, sizeof( *stp ) ); // C posix_memalign
    144159        *stp = (Struct){ 42, 42.5 };
    145160        assert( (uintptr_t)stp % Alignment == 0 );
    146         printf( "CFA aligned_alloc %d %g\n", stp->x, stp->y );
    147     free( stp );
    148 
    149     stp = memalign( Alignment );                                                // CFA memalign
    150         *stp = (Struct){ 42, 42.5 };
    151         assert( (uintptr_t)stp % Alignment == 0 );
    152         printf( "CFA memalign %d %g\n", stp->x, stp->y );
     161        printf( "CFA posix_memalign %d %g\n", stp->x, stp->y );
    153162    free( stp );
    154163
     
    159168    free( stp );
    160169
    161     stp = memalign( Alignment, '\1' );                                  // CFA memalign, fill
    162         assert( (uintptr_t)stp % Alignment == 0 );
    163         printf( "CFA memalign fill %d %g\n", stp->x, stp->y );
     170    stp = (aligned_alloc( Alignment )){ 42, 42.5 };             // CFA aligned_alloc
     171        assert( (uintptr_t)stp % Alignment == 0 );
     172        printf( "CFA aligned_alloc %d %g\n", stp->x, stp->y );
     173    free( stp );
     174
     175    stp = (align_alloc( Alignment )){ 42, 42.5 };               // CFA align_alloc
     176        assert( (uintptr_t)stp % Alignment == 0 );
     177        printf( "CFA align_alloc %d %g\n", stp->x, stp->y );
     178    free( stp );
     179
     180    stp = align_alloc( Alignment, fill );                               // CFA memalign, fill
     181        assert( (uintptr_t)stp % Alignment == 0 );
     182        printf( "CFA align_alloc fill %#x %a\n", stp->x, stp->y );
    164183    free( stp );
    165184
     
    168187        printf( "\n" );
    169188
    170     stp = amemalign( Alignment, 2 * dim );                              // CFA array memalign
    171         assert( (uintptr_t)stp % Alignment == 0 );
    172         printf( "CFA memalign array\n" );
    173         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; }
    174         printf( "\n" );
    175     free( stp );
    176 
    177     stp = amemalign( Alignment, dim, '\1' );                    // CFA array memalign, fill
    178         assert( (uintptr_t)stp % Alignment == 0 );
    179         printf( "CFA memalign array\n" );
    180         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; }
     189    stp = align_alloc( Alignment, dim );                                // CFA array memalign
     190        assert( (uintptr_t)stp % Alignment == 0 );
     191        for ( int i = 0; i < dim; i += 1 ) { stp[i] = (Struct){ 42, 42.5 }; }
     192        printf( "CFA array align_alloc\n" );
     193        for ( int i = 0; i < dim; i += 1 ) { printf( "%d %g, ", stp[i].x, stp[i].y ); }
     194        printf( "\n" );
     195    free( stp );
     196
     197    stp = align_alloc( Alignment, dim, fill );                  // CFA array memalign, fill
     198        assert( (uintptr_t)stp % Alignment == 0 );
     199        printf( "CFA array align_alloc, fill\n" );
     200        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", stp[i].x, stp[i].y ); }
    181201        printf( "\n" );
    182202    free( stp );
     
    186206        printf( "\n" );
    187207
    188     stp = memset( &st, '\xff' );                                                // CFA memset, type safe
    189         printf( "CFA memset %x %g\n", st.x, st.y );
    190     stp = memcpy( &st1, &st );                                                  // CFA memcpy, type safe
    191         printf( "CFA memcpy %x %g\n", st1.x, st1.y );
     208    memset( &st, fill );                                                                // CFA memset, type safe
     209        printf( "CFA memset %#x %a\n", st.x, st.y );
     210    memcpy( &st1, &st );                                                                // CFA memcpy, type safe
     211        printf( "CFA memcpy %#x %a\n", st1.x, st1.y );
    192212
    193213
     
    195215        printf( "\n" );
    196216
    197     stp = amemset( sta, dim, '\xff' );                                  // CFA array memset, type safe
     217    memset( sta, dim, fill );                                                   // CFA array memset, type safe
    198218        printf( "CFA array memset\n" );
    199         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; }
    200         printf( "\n" );
    201 
    202     stp = amemcpy( sta1, sta, dim );                                    // CFA array memcpy, type safe
     219        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", sta[i].x, sta[i].y ); }
     220        printf( "\n" );
     221
     222    memcpy( sta1, sta, dim );                                                   // CFA array memcpy, type safe
    203223        printf( "CFA memcpy\n" );
    204         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; }
     224        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", sta1[i].x, sta1[i].y ); }
     225        printf( "\n" );
     226
     227
     228        // new, non-array types
     229        printf( "\n" );
     230
     231        stp = new( 42, 42.5 );
     232        stp1 = new( 42, 42.5 );
     233        printf( "CFA new initialize\n%d %g %d %g\n", stp->x, stp->y, stp1->x, stp1->y );
     234        delete( stp, stp1 );
     235
     236        // new, array types
     237        stp = anew( dim, 42, 42.5 );
     238        printf( "CFA array new initialize\n" );
     239        for ( int i = 0; i < dim; i += 1 ) { printf( "%d %g, ", stp[i].x, stp[i].y ); }
     240        printf( "\n" );
     241        stp1 = anew( dim, 42, 42.5 );
     242        for ( int i = 0; i < dim; i += 1 ) { printf( "%d %g, ", stp1[i].x, stp1[i].y ); }
     243        printf( "\n" );
     244        adelete( dim, stp, dim, stp1 );
     245
     246        // extras
    205247        printf( "\n" );
    206248
     
    211253    p = foo( bar( baz( malloc(), 0 ), 0 ), 0 );
    212254        *p = 0xdeadbeef;
    213         printf( "CFA deep malloc %x\n", *p );
     255        printf( "CFA deep malloc %#x\n", *p );
    214256    free( p );
    215257
    216258        stp = malloc();
    217259        printf( "\nSHOULD FAIL\n" );
    218     p = malloc( stp, dim * sizeof(*stp) );
     260    p = alloc( stp, dim * sizeof(*stp) );
    219261    p = memset( stp, 10 );
    220262    p = memcpy( &st1, &st );
  • src/tests/test.py

    r9c1600c racd738aa  
    253253        # for each test to run
    254254        try :
    255                 results = pool.map_async(partial(run_test_worker, generate=generate, dry_run=dry_run, debug=debug), tests, chunksize = 1 ).get(3600)
     255                results = pool.map_async(partial(run_test_worker, generate=generate, dry_run=dry_run, debug=debug), tests, chunksize = 1 ).get(7200)
    256256        except KeyboardInterrupt:
    257257                pool.terminate()
Note: See TracChangeset for help on using the changeset viewer.