Changeset 28e58fd for src/tests/alloc.c


Ignore:
Timestamp:
Aug 25, 2017, 10:38:34 AM (8 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:
800d275
Parents:
af08051 (diff), 3eab308c (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 edited

Legend:

Unmodified
Added
Removed

  • src/tests/alloc.c

    raf08051 r28e58fd  
    1 // 
     1//
    22// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
    33//
    … …  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // alloc.c -- 
    8 // 
     7// alloc.c --
     8//
    99// Author           : Peter A. Buhr
    1010// Created On       : Wed Feb  3 07:56:22 2016
    … …  
    1212// Last Modified On : Thu Jul 20 16:01:10 2017
    1313// Update Count     : 318
    14 // 
     14//
    1515
    1616#include <assert.h>
    … …  
    1919#include <stdlib.h>                                                                             // posix_memalign
    2020#include <fstream>
    21 #include <stdlib>                                                                               // access C malloc, realloc
     21#include <stdlib>                                                                                       // access C malloc, realloc
    2222
    2323int * foo( int * p, int c ) { return p; }
    … …  
    2626
    2727int main( void ) {
    28     size_t dim = 10;
    29     int * p;
     28        size_t dim = 10;
     29        int * p;
    3030        char fill = '\1';
    3131
    3232        // allocation, non-array types
    3333
    34     p = (void *)malloc( sizeof(*p) );                                   // C malloc, type unsafe
     34        p = (void *)malloc( sizeof(*p) );                   // C malloc, type unsafe
    3535        *p = 0xdeadbeef;
    3636        printf( "C   malloc %#x\n", *p );
    37     free( p );
    38 
    39     p = malloc();                                                                               // CFA malloc, type safe
     37        free( p );
     38
     39        p = malloc();                                       // CFA malloc, type safe
    4040        *p = 0xdeadbeef;
    4141        printf( "CFA malloc %#x\n", *p );
    42     free( p );
    43 
    44     p = alloc();                                                                                // CFA alloc, type safe
     42        free( p );
     43
     44        p = alloc();                                        // CFA alloc, type safe
    4545        *p = 0xdeadbeef;
    4646        printf( "CFA alloc %#x\n", *p );
    47     free( p );
    48 
    49     p = alloc( fill );                                                                  // CFA alloc, fill
     47        free( p );
     48
     49        p = alloc( fill );                                  // CFA alloc, fill
    5050        printf( "CFA alloc, fill %08x\n", *p );
    5151
    … …  
    5454        printf( "\n" );
    5555
    56     p = calloc( dim, sizeof( *p ) );                                    // C array calloc, type unsafe
     56        p = calloc( dim, sizeof( *p ) );                    // C array calloc, type unsafe
    5757        printf( "C   array calloc, fill 0\n" );
    5858        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
    5959        printf( "\n" );
    60     free( p );
    61 
    62     p = calloc( dim );                                                                  // CFA array calloc, type safe
     60        free( p );
     61
     62        p = calloc( dim );                                  // CFA array calloc, type safe
    6363        printf( "CFA array calloc, fill 0\n" );
    6464        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
    6565        printf( "\n" );
    66     free( p );
    67 
    68     p = alloc( dim );                                                                   // CFA array alloc, type safe
     66        free( p );
     67
     68        p = alloc( dim );                                   // CFA array alloc, type safe
    6969        for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; }
    7070        printf( "CFA array alloc, no fill\n" );
    7171        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
    7272        printf( "\n" );
    73     free( p );
    74 
    75     p = alloc( 2 * dim, fill );                                                 // CFA array alloc, fill
     73        free( p );
     74
     75        p = alloc( 2 * dim, fill );                         // CFA array alloc, fill
    7676        printf( "CFA array alloc, fill %#x\n", fill );
    7777        for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); }
    … …  
    8383        printf( "\n" );
    8484
    85     p = (void *)realloc( p, dim * sizeof(*p) );                 // C realloc
     85        p = (void *)realloc( p, dim * sizeof(*p) );         // C realloc
    8686        for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; }
    8787        printf( "C   realloc\n" );
    … …  
    8989        printf( "\n" );
    9090
    91     p = realloc( p, 2 * dim * sizeof(*p) );                             // CFA realloc
     91        p = realloc( p, 2 * dim * sizeof(*p) );             // CFA realloc
    9292        for ( int i = dim; i < 2 * dim; i += 1 ) { p[i] = 0x1010101; }
    9393        printf( "CFA realloc\n" );
    … …  
    100100        printf( "\n" );
    101101
    102     p = alloc( p, dim );                                                                // CFA resize array alloc
     102        p = alloc( p, dim );                                // CFA resize array alloc
    103103        for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; }
    104104        printf( "CFA resize alloc\n" );
    … …  
    106106        printf( "\n" );
    107107
    108     p = alloc( p, 2 * dim );                                                    // CFA resize array alloc
     108        p = alloc( p, 2 * dim );                            // CFA resize array alloc
    109109        for ( int i = dim; i < 2 * dim; i += 1 ) { p[i] = 0x1010101; }
    110110        printf( "CFA resize array alloc\n" );
    … …  
    112112        printf( "\n" );
    113113
    114     p = alloc( p, dim );                                                                // CFA array alloc
     114        p = alloc( p, dim );                                // CFA array alloc
    115115        printf( "CFA resize array alloc\n" );
    116116        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
    … …  
    120120        p = 0;
    121121
    122     p = alloc( p, dim, fill );                                                  // CFA array alloc, fill
     122        p = alloc( p, dim, fill );                          // CFA array alloc, fill
    123123        printf( "CFA resize array alloc, fill\n" );
    124124        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
    125125        printf( "\n" );
    126126
    127     p = alloc( p, 2 * dim, fill );                                              // CFA array alloc, fill
     127        p = alloc( p, 2 * dim, fill );                      // CFA array alloc, fill
    128128        printf( "CFA resize array alloc, fill\n" );
    129129        for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); }
    130130        printf( "\n" );
    131131
    132     p = alloc( p, dim, fill );                                                  // CFA array alloc, fill
     132        p = alloc( p, dim, fill );                          // CFA array alloc, fill
    133133        printf( "CFA resize array alloc, fill\n" );
    134134        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] );; }
    … …  
    137137
    138138
    139     struct Struct { int x; double y; };
    140     Struct st, st1, sta[dim], sta1[dim], * stp, * stp1;
     139        struct Struct { int x; double y; };
     140        Struct st, st1, sta[dim], sta1[dim], * stp, * stp1;
    141141
    142142        // alignment, non-array types
    … …  
    144144        enum { Alignment = 128 };
    145145
    146     stp = (memalign( Alignment, sizeof( *stp ) ) ){ 42, 42.5 }; // C memalign
     146        stp = &(*(Struct*)memalign( Alignment, sizeof( *stp ) ) ){ 42, 42.5 }; // C memalign
    147147        assert( (uintptr_t)stp % Alignment == 0 );
    148148        printf( "C   memalign %d %g\n", stp->x, stp->y );
    149     free( stp );
    150 
    151     stp = (memalign( Alignment )){ 42, 42.5 };                  // CFA memalign
     149        free( stp );
     150
     151        stp = &(*memalign( Alignment )){ 42, 42.5 };          // CFA memalign
    152152        assert( (uintptr_t)stp % Alignment == 0 );
    153153        printf( "CFA memalign %d %g\n", stp->x, stp->y );
    154     free( stp );
    155 
    156     posix_memalign( (void **)&stp, Alignment, sizeof( *stp ) ); // C posix_memalign
     154        free( stp );
     155
     156        posix_memalign( (void **)&stp, Alignment, sizeof( *stp ) ); // C posix_memalign
    157157        *stp = (Struct){ 42, 42.5 };
    158158        assert( (uintptr_t)stp % Alignment == 0 );
    159159        printf( "CFA posix_memalign %d %g\n", stp->x, stp->y );
    160     free( stp );
    161 
    162     posix_memalign( &stp, Alignment );                                  // CFA posix_memalign
     160        free( stp );
     161
     162        posix_memalign( &stp, Alignment );                  // CFA posix_memalign
    163163        *stp = (Struct){ 42, 42.5 };
    164164        assert( (uintptr_t)stp % Alignment == 0 );
    165165        printf( "CFA posix_memalign %d %g\n", stp->x, stp->y );
    166     free( stp );
    167 
    168     stp = (aligned_alloc( Alignment )){ 42, 42.5 };             // CFA aligned_alloc
     166        free( stp );
     167
     168        stp = &(*aligned_alloc( Alignment )){ 42, 42.5 };     // CFA aligned_alloc
    169169        assert( (uintptr_t)stp % Alignment == 0 );
    170170        printf( "CFA aligned_alloc %d %g\n", stp->x, stp->y );
    171     free( stp );
    172 
    173     stp = (align_alloc( Alignment )){ 42, 42.5 };               // CFA align_alloc
     171        free( stp );
     172
     173        stp = &(*align_alloc( Alignment )){ 42, 42.5 };       // CFA align_alloc
    174174        assert( (uintptr_t)stp % Alignment == 0 );
    175175        printf( "CFA align_alloc %d %g\n", stp->x, stp->y );
    176     free( stp );
    177 
    178     stp = align_alloc( Alignment, fill );                               // CFA memalign, fill
     176        free( stp );
     177
     178        stp = align_alloc( Alignment, fill );               // CFA memalign, fill
    179179        assert( (uintptr_t)stp % Alignment == 0 );
    180180        printf( "CFA align_alloc fill %#x %a\n", stp->x, stp->y );
    181     free( stp );
     181        free( stp );
    182182
    183183
    … …  
    185185        printf( "\n" );
    186186
    187     stp = align_alloc( Alignment, dim );                                // CFA array memalign
     187        stp = align_alloc( Alignment, dim );                // CFA array memalign
    188188        assert( (uintptr_t)stp % Alignment == 0 );
    189189        for ( int i = 0; i < dim; i += 1 ) { stp[i] = (Struct){ 42, 42.5 }; }
    … …  
    191191        for ( int i = 0; i < dim; i += 1 ) { printf( "%d %g, ", stp[i].x, stp[i].y ); }
    192192        printf( "\n" );
    193     free( stp );
    194 
    195     stp = align_alloc( Alignment, dim, fill );                  // CFA array memalign, fill
     193        free( stp );
     194
     195        stp = align_alloc( Alignment, dim, fill );          // CFA array memalign, fill
    196196        assert( (uintptr_t)stp % Alignment == 0 );
    197197        printf( "CFA array align_alloc, fill\n" );
    198198        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", stp[i].x, stp[i].y ); }
    199199        printf( "\n" );
    200     free( stp );
     200        free( stp );
    201201
    202202
    … …  
    204204        printf( "\n" );
    205205
    206     memset( &st, fill );                                                                // CFA memset, type safe
     206        memset( &st, fill );                                // CFA memset, type safe
    207207        printf( "CFA memset %#x %a\n", st.x, st.y );
    208     memcpy( &st1, &st );                                                                // CFA memcpy, type safe
     208        memcpy( &st1, &st );                                // CFA memcpy, type safe
    209209        printf( "CFA memcpy %#x %a\n", st1.x, st1.y );
    210210
    … …  
    213213        printf( "\n" );
    214214
    215     memset( sta, dim, fill );                                                   // CFA array memset, type safe
     215        memset( sta, dim, fill );                           // CFA array memset, type safe
    216216        printf( "CFA array memset\n" );
    217217        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", sta[i].x, sta[i].y ); }
    218218        printf( "\n" );
    219219
    220     memcpy( sta1, sta, dim );                                                   // CFA array memcpy, type safe
     220        memcpy( sta1, sta, dim );                           // CFA array memcpy, type safe
    221221        printf( "CFA memcpy\n" );
    222222        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", sta1[i].x, sta1[i].y ); }
    … …  
    245245        printf( "\n" );
    246246
    247     float * fp = malloc() + 1;
    248     printf( "pointer arithmetic %d\n", fp == fp - 1 );
    249     free( fp - 1 );
    250 
    251     p = foo( bar( baz( malloc(), 0 ), 0 ), 0 );
     247        float * fp = malloc() + 1;
     248        printf( "pointer arithmetic %d\n", fp == fp - 1 );
     249        free( fp - 1 );
     250
     251        p = foo( bar( baz( malloc(), 0 ), 0 ), 0 );
    252252        *p = 0xdeadbeef;
    253253        printf( "CFA deep malloc %#x\n", *p );
    254     free( p );
     254        free( p );
    255255
    256256        stp = malloc();
    257257        printf( "\nSHOULD FAIL\n" );
    258     p = alloc( stp, dim * sizeof(*stp) );
    259     p = memset( stp, 10 );
    260     p = memcpy( &st1, &st );
     258        p = alloc( stp, dim * sizeof(*stp) );
     259        p = memset( stp, 10 );
     260        p = memcpy( &st1, &st );
    261261} // main
    262262
Note: See TracChangeset for help on using the changeset viewer.