Changeset b067d9b for tests/alloc.cfa


Ignore:
Timestamp:
Oct 29, 2019, 4:01:24 PM (6 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum
Children:
773db65, 9421f3d8
Parents:
7951100 (diff), 8364209 (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

File:
1 moved

Legend:

Unmodified
Added
Removed

  • tests/alloc.cfa

    r7951100 rb067d9b  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // alloc.c --
     7// alloc.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Wed Feb  3 07:56:22 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Feb 16 15:42:31 2018
    13 // Update Count     : 330
     12// Last Modified On : Sun Oct 20 21:45:21 2019
     13// Update Count     : 391
    1414//
    1515
    … …  
    1818#include <stdint.h>                                                                             // uintptr_t
    1919#include <stdlib.h>                                                                             // posix_memalign
    20 #include <fstream>
    21 #include <stdlib>                                                                               // access C malloc, realloc
     20#include <fstream.hfa>
     21#include <stdlib.hfa>                                                                   // access C malloc, realloc
    2222
    2323int * foo( int * p, int c ) { return p; }
    … …  
    2727int main( void ) {
    2828        size_t dim = 10;
    29         char fill = '\xff';
    30         int * p;
     29        char fill = '\xde';
     30        int * p, * p1;
    3131
    3232        // allocation, non-array types
    33 
    34         // int & r = malloc();
    35         // r = 0xdeadbeef;
    36         // printf( "C   malloc %#x\n", r );
    37         // free( &r );
    3833
    3934        p = (int *)malloc( sizeof(*p) );                                        // C malloc, type unsafe
    … …  
    5247        free( p );
    5348
    54         p = alloc( fill );                                  // CFA alloc, fill
     49        p = alloc_set( fill );                                                          // CFA alloc, fill
     50        printf( "CFA array alloc, fill %#hhx\n", fill );
    5551        printf( "CFA alloc, fill %08x\n", *p );
     52        free( p );
     53
     54        p = alloc_set( 3 );                                                                     // CFA alloc, fill
     55        printf( "CFA alloc, fill %d\n", *p );
     56        free( p );
    5657
    5758
    … …  
    6162        p = (int *)calloc( dim, sizeof( *p ) );                         // C array calloc, type unsafe
    6263        printf( "C   array calloc, fill 0\n" );
    63         for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
     64        for ( i; dim ) { printf( "%#x ", p[i] ); }
    6465        printf( "\n" );
    6566        free( p );
    … …  
    6768        p = calloc( dim );                                  // CFA array calloc, type safe
    6869        printf( "CFA array calloc, fill 0\n" );
    69         for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
     70        for ( i; dim ) { printf( "%#x ", p[i] ); }
    7071        printf( "\n" );
    7172        free( p );
    7273
    7374        p = alloc( dim );                                   // CFA array alloc, type safe
    74         for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; }
     75        for ( i; dim ) { p[i] = 0xdeadbeef; }
    7576        printf( "CFA array alloc, no fill\n" );
    76         for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
    77         printf( "\n" );
    78         free( p );
    79 
    80         p = alloc( 2 * dim, fill );                         // CFA array alloc, fill
     77        for ( i; dim ) { printf( "%#x ", p[i] ); }
     78        printf( "\n" );
     79        free( p );
     80
     81        p = alloc_set( 2 * dim, fill );                                         // CFA array alloc, fill
    8182        printf( "CFA array alloc, fill %#hhx\n", fill );
    82         for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); }
    83         printf( "\n" );
    84         // do not free
     83        for ( i; 2 * dim ) { printf( "%#x ", p[i] ); }
     84        printf( "\n" );
     85        free( p );
     86
     87        p = alloc_set( 2 * dim, 0xdeadbeef );                           // CFA array alloc, fill
     88        printf( "CFA array alloc, fill %#hhx\n", 0xdeadbeef );
     89        for ( i; 2 * dim ) { printf( "%#x ", p[i] ); }
     90        printf( "\n" );
     91        // do not free
     92
     93        p1 = alloc_set( 2 * dim, p );                                           // CFA array alloc, fill
     94        printf( "CFA array alloc, fill from array\n" );
     95        for ( i; 2 * dim ) { printf( "%#x %#x, ", p[i], p1[i] ); }
     96        free( p1 );
     97        printf( "\n" );
    8598
    8699
    … …  
    89102
    90103        p = (int *)realloc( p, dim * sizeof(*p) );                      // C realloc
    91         for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; }
    92         printf( "C   realloc\n" );
    93         for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
    94         printf( "\n" );
     104        printf( "C realloc\n" );
     105        for ( i; dim ) { printf( "%#x ", p[i] ); }
     106        printf( "\n" );
     107        // do not free
    95108
    96109        p = realloc( p, 2 * dim * sizeof(*p) );             // CFA realloc
    97         for ( int i = dim; i < 2 * dim; i += 1 ) { p[i] = 0x1010101; }
     110        for ( i; dim ~ 2 * dim ) { p[i] = 0x1010101; }
    98111        printf( "CFA realloc\n" );
    99         for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); }
     112        for ( i; 2 * dim ) { printf( "%#x ", p[i] ); }
    100113        printf( "\n" );
    101114        // do not free
    … …  
    106119
    107120        p = alloc( p, dim );                                // CFA resize array alloc
    108         for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; }
    109         printf( "CFA resize alloc\n" );
    110         for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
    111         printf( "\n" );
     121        for ( i; dim ) { p[i] = 0xdeadbeef; }
     122        printf( "CFA resize array alloc\n" );
     123        for ( i; dim ) { printf( "%#x ", p[i] ); }
     124        printf( "\n" );
     125        // do not free
    112126
    113127        p = alloc( p, 2 * dim );                            // CFA resize array alloc
    114         for ( int i = dim; i < 2 * dim; i += 1 ) { p[i] = 0x1010101; }
     128        for ( i; dim ~ 2 * dim ) { p[i] = 0x1010101; }
    115129        printf( "CFA resize array alloc\n" );
    116         for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); }
    117         printf( "\n" );
    118 
    119         p = alloc( p, dim );                                // CFA array alloc
     130        for ( i; 2 * dim ) { printf( "%#x ", p[i] ); }
     131        printf( "\n" );
     132        // do not free
     133
     134        p = alloc( p, dim );                                // CFA resize array alloc
    120135        printf( "CFA resize array alloc\n" );
    121         for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
    122         printf( "\n" );
    123 
    124         free( p );
    125         p = 0;
    126 
    127         p = alloc( p, dim, fill );                          // CFA array alloc, fill
     136        for ( i; dim ) { printf( "%#x ", p[i] ); }
     137        printf( "\n" );
     138        // do not free
     139
     140        p = alloc_set( p, 3 * dim, fill );                                      // CFA resize array alloc, fill
    128141        printf( "CFA resize array alloc, fill\n" );
    129         for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
    130         printf( "\n" );
    131 
    132         p = alloc( p, 2 * dim, fill );                      // CFA array alloc, fill
     142        for ( i; 3 * dim ) { printf( "%#x ", p[i] ); }
     143        printf( "\n" );
     144        // do not free
     145
     146        p = alloc_set( p, dim, fill );                                          // CFA resize array alloc, fill
    133147        printf( "CFA resize array alloc, fill\n" );
    134         for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); }
    135         printf( "\n" );
    136 
    137         p = alloc( p, dim, fill );                          // CFA array alloc, fill
     148        for ( i; dim ) { printf( "%#x ", p[i] ); }
     149        printf( "\n" );
     150        // do not free
     151
     152        p = alloc_set( p, 3 * dim, fill );                                      // CFA resize array alloc, fill
    138153        printf( "CFA resize array alloc, fill\n" );
    139         for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] );; }
     154        for ( i; 3 * dim ) { printf( "%#x ", p[i] );; }
    140155        printf( "\n" );
    141156        free( p );
    … …  
    171186        free( stp );
    172187
    173         stp = &(*aligned_alloc( Alignment )){ 42, 42.5 };     // CFA aligned_alloc
    174         assert( (uintptr_t)stp % Alignment == 0 );
    175         printf( "CFA aligned_alloc %d %g\n", stp->x, stp->y );
    176         free( stp );
    177 
    178         stp = &(*align_alloc( Alignment )){ 42, 42.5 };       // CFA align_alloc
    179         assert( (uintptr_t)stp % Alignment == 0 );
    180         printf( "CFA align_alloc %d %g\n", stp->x, stp->y );
    181         free( stp );
    182 
    183         stp = align_alloc( Alignment, fill );               // CFA memalign, fill
    184         assert( (uintptr_t)stp % Alignment == 0 );
    185         printf( "CFA align_alloc fill %#x %a\n", stp->x, stp->y );
     188        stp = &(*alloc_align( Alignment)){ 42, 42.5 };          // CFA alloc_align
     189        assert( (uintptr_t)stp % Alignment == 0 );
     190        printf( "CFA alloc_align %d %g\n", stp->x, stp->y );
     191        free( stp );
     192
     193        stp = &(*alloc_align( Alignment )){ 42, 42.5 };         // CFA alloc_align
     194        assert( (uintptr_t)stp % Alignment == 0 );
     195        printf( "CFA alloc_align %d %g\n", stp->x, stp->y );
     196        free( stp );
     197
     198        stp = alloc_align_set( Alignment, fill );                       // CFA memalign, fill
     199        assert( (uintptr_t)stp % Alignment == 0 );
     200        printf( "CFA alloc_align fill %#x %a\n", stp->x, stp->y );
     201        free( stp );
     202
     203        stp = alloc_align_set( Alignment, (Struct){ 42, 42.5 } ); // CFA memalign, fill
     204        assert( (uintptr_t)stp % Alignment == 0 );
     205        printf( "CFA alloc_align fill %d %g\n", stp->x, stp->y );
     206        // do not free
     207
     208        stp = &(*alloc_align( stp, 4096 )){ 42, 42.5 };         // CFA realign
     209        assert( (uintptr_t)stp % 4096 == 0 );
     210        printf( "CFA alloc_align %d %g\n", stp->x, stp->y );
    186211        free( stp );
    187212
    … …  
    190215        printf( "\n" );
    191216
    192         stp = align_alloc( Alignment, dim );                // CFA array memalign
    193         assert( (uintptr_t)stp % Alignment == 0 );
    194         for ( int i = 0; i < dim; i += 1 ) { stp[i] = (Struct){ 42, 42.5 }; }
    195         printf( "CFA array align_alloc\n" );
    196         for ( int i = 0; i < dim; i += 1 ) { printf( "%d %g, ", stp[i].x, stp[i].y ); }
    197         printf( "\n" );
    198         free( stp );
    199 
    200         stp = align_alloc( Alignment, dim, fill );          // CFA array memalign, fill
    201         assert( (uintptr_t)stp % Alignment == 0 );
    202         printf( "CFA array align_alloc, fill\n" );
    203         for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", stp[i].x, stp[i].y ); }
     217        stp = alloc_align( Alignment, dim );                // CFA array memalign
     218        assert( (uintptr_t)stp % Alignment == 0 );
     219        for ( i; dim ) { stp[i] = (Struct){ 42, 42.5 }; }
     220        printf( "CFA array alloc_align\n" );
     221        for ( i; dim ) { printf( "%d %g, ", stp[i].x, stp[i].y ); }
     222        printf( "\n" );
     223        free( stp );
     224
     225        stp = alloc_align_set( Alignment, dim, fill );          // CFA array memalign, fill
     226        assert( (uintptr_t)stp % Alignment == 0 );
     227        printf( "CFA array alloc_align, fill\n" );
     228        for ( i; dim ) { printf( "%#x %a, ", stp[i].x, stp[i].y ); }
     229        printf( "\n" );
     230        free( stp );
     231
     232        stp = alloc_align_set( Alignment, dim, (Struct){ 42, 42.5 } ); // CFA array memalign, fill
     233        assert( (uintptr_t)stp % Alignment == 0 );
     234        printf( "CFA array alloc_align, fill\n" );
     235        for ( i; dim ) { printf( "%d %g, ", stp[i].x, stp[i].y ); }
     236        printf( "\n" );
     237        // do not free
     238
     239        stp1 = alloc_align_set( Alignment, dim, stp );          // CFA array memalign, fill
     240        assert( (uintptr_t)stp % Alignment == 0 );
     241        printf( "CFA array alloc_align, fill array\n" );
     242        for ( i; dim ) { printf( "%d %g, ", stp1[i].x, stp1[i].y ); }
     243        printf( "\n" );
     244        free( stp1 );
     245
     246        stp = alloc_align( stp, 4096, dim );                            // CFA aligned realloc array
     247        assert( (uintptr_t)stp % 4096 == 0 );
     248        for ( i; dim ) { stp[i] = (Struct){ 42, 42.5 }; }
     249        printf( "CFA realloc array alloc_align\n" );
     250        for ( i; dim ) { printf( "%d %g, ", stp[i].x, stp[i].y ); }
    204251        printf( "\n" );
    205252        free( stp );
    … …  
    218265        printf( "\n" );
    219266
    220         memset( sta, dim, fill );                           // CFA array memset, type safe
     267        amemset( sta, fill, dim );                                                      // CFA array memset, type safe
    221268        printf( "CFA array memset\n" );
    222         for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", sta[i].x, sta[i].y ); }
    223         printf( "\n" );
    224 
    225         memcpy( sta1, sta, dim );                           // CFA array memcpy, type safe
    226         printf( "CFA memcpy\n" );
    227         for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", sta1[i].x, sta1[i].y ); }
     269        for ( i; dim ) { printf( "%#x %a, ", sta[i].x, sta[i].y ); }
     270        printf( "\n" );
     271
     272        amemcpy( sta1, sta, dim );                                                      // CFA array memcpy, type safe
     273        printf( "CFA array memcpy\n" );
     274        for ( i; dim ) { printf( "%#x %a, ", sta1[i].x, sta1[i].y ); }
    228275        printf( "\n" );
    229276
    … …  
    240287        stp = anew( dim, 42, 42.5 );
    241288        printf( "CFA array new initialize\n" );
    242         for ( int i = 0; i < dim; i += 1 ) { printf( "%d %g, ", stp[i].x, stp[i].y ); }
     289        for ( i; dim ) { printf( "%d %g, ", stp[i].x, stp[i].y ); }
    243290        printf( "\n" );
    244291        stp1 = anew( dim, 42, 42.5 );
    245         for ( int i = 0; i < dim; i += 1 ) { printf( "%d %g, ", stp1[i].x, stp1[i].y ); }
     292        for ( i; dim ) { printf( "%d %g, ", stp1[i].x, stp1[i].y ); }
    246293        printf( "\n" );
    247294        adelete( dim, stp, dim, stp1 );
    … …  
    271318// Local Variables: //
    272319// tab-width: 4 //
    273 // compile-command: "cfa alloc.c" //
     320// compile-command: "cfa alloc.cfa" //
    274321// End: //
Note: See TracChangeset for help on using the changeset viewer.