Changes in / [83b52f1:6130304]


Ignore:
Files:
1 deleted
20 edited

Legend:

Unmodified
Added
Removed

  • libcfa/src/heap.cfa

    r83b52f1 r6130304  
    1010// Created On       : Tue Dec 19 21:58:35 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jul 23 14:13:13 2019
    13 // Update Count     : 549
     12// Last Modified On : Thu May  9 16:29:12 2019
     13// Update Count     : 516
    1414//
    1515
    … …  
    3131
    3232
     33enum {
     34        __CFA_DEFAULT_MMAP_START__ = (512 * 1024 + 1),
     35        __CFA_DEFAULT_HEAP_EXPANSION__ = (1 * 1024 * 1024),
     36};
     37
     38size_t default_mmap_start() __attribute__(( weak )) {
     39        return __CFA_DEFAULT_MMAP_START__;
     40} // default_mmap_start
     41
     42size_t default_heap_expansion() __attribute__(( weak )) {
     43        return __CFA_DEFAULT_HEAP_EXPANSION__;
     44} // default_heap_expansion
     45
     46
     47// supported mallopt options
     48#ifndef M_MMAP_THRESHOLD
     49#define M_MMAP_THRESHOLD (-1)
     50#endif // M_TOP_PAD
     51#ifndef M_TOP_PAD
     52#define M_TOP_PAD (-2)
     53#endif // M_TOP_PAD
     54
     55#define FASTLOOKUP
     56#define __STATISTICS__
     57
     58#define SPINLOCK 0
     59#define LOCKFREE 1
     60#define BUCKETLOCK SPINLOCK
     61#if BUCKETLOCK == LOCKFREE
     62#include <uStackLF.h>
     63#endif // LOCKFREE
     64
     65// #comment TD : This defined is significantly different from the __ALIGN__ define from locks.hfa
     66#define ALIGN 16
     67
     68// enum { NoBucketSizes = 93,                                                           // number of buckets sizes
     69// #ifdef FASTLOOKUP
     70//         LookupSizes = 65536,                                                         // number of fast lookup sizes
     71// #endif // FASTLOOKUP
     72// };
     73#define NoBucketSizes 93                                                                // number of buckets sizes
     74#ifdef FASTLOOKUP
     75#define LookupSizes 65536                                                               // number of fast lookup sizes
     76#endif // FASTLOOKUP
     77
     78
    3379static bool traceHeap = false;
    3480
    … …  
    86132//      return temp;
    87133// } // traceHeapTermOff
    88 
    89 
    90 enum {
    91         __CFA_DEFAULT_MMAP_START__ = (512 * 1024 + 1),
    92         __CFA_DEFAULT_HEAP_EXPANSION__ = (1 * 1024 * 1024),
    93 };
    94 
    95 size_t default_mmap_start() __attribute__(( weak )) {
    96         return __CFA_DEFAULT_MMAP_START__;
    97 } // default_mmap_start
    98 
    99 size_t default_heap_expansion() __attribute__(( weak )) {
    100         return __CFA_DEFAULT_HEAP_EXPANSION__;
    101 } // default_heap_expansion
    102134
    103135
    … …  
    128160#endif // __CFA_DEBUG__
    129161
    130 // statically allocated variables => zero filled.
    131 static size_t pageSize;                                                                 // architecture pagesize
    132 static size_t heapExpand;                                                               // sbrk advance
    133 static size_t mmapStart;                                                                // cross over point for mmap
    134 static unsigned int maxBucketsUsed;                                             // maximum number of buckets in use
    135 
    136 
    137 // #comment TD : This defined is significantly different from the __ALIGN__ define from locks.hfa
    138 #define ALIGN 16
    139 
    140 #define SPINLOCK 0
    141 #define LOCKFREE 1
    142 #define BUCKETLOCK SPINLOCK
    143 #if BUCKETLOCK == LOCKFREE
    144 #include <uStackLF.h>
    145 #endif // LOCKFREE
    146 
    147 // Recursive definitions: HeapManager needs size of bucket array and bucket area needs sizeof HeapManager storage.
    148 // Break recusion by hardcoding number of buckets and statically checking number is correct after bucket array defined.
    149 enum { NoBucketSizes = 93 };                                                    // number of buckets sizes
    150162
    151163struct HeapManager {
    … …  
    222234}; // HeapManager
    223235
     236
    224237static inline size_t getKey( const HeapManager.FreeHeader & freeheader ) { return freeheader.blockSize; }
    225238
    226 
    227 #define FASTLOOKUP
    228 #define __STATISTICS__
     239// statically allocated variables => zero filled.
     240static size_t pageSize;                                                                 // architecture pagesize
     241static size_t heapExpand;                                                               // sbrk advance
     242static size_t mmapStart;                                                                // cross over point for mmap
     243static unsigned int maxBucketsUsed;                                             // maximum number of buckets in use
    229244
    230245// Powers of 2 are common allocation sizes, so make powers of 2 generate the minimum required size.
    231 static const unsigned int bucketSizes[] @= {                    // different bucket sizes
     246static const unsigned int bucketSizes[NoBucketSizes] @= { // different bucket sizes
    232247        16, 32, 48, 64,
    233248        64 + sizeof(HeapManager.Storage), 96, 112, 128, 128 + sizeof(HeapManager.Storage), 160, 192, 224,
    … …  
    244259        4_194_304 + sizeof(HeapManager.Storage)
    245260};
    246 
    247 static_assert( NoBucketSizes == sizeof(bucketSizes) / sizeof(bucketSizes[0]), "size of bucket array wrong" );
    248 
    249261#ifdef FASTLOOKUP
    250 static_assert( 16 == sizeof(HeapManager.Storage), "size of HeapManager Storage wrong" ); // FIX ME
    251 enum { LookupSizes = 65_536 + 16 };                                             // number of fast lookup sizes
    252262static unsigned char lookup[LookupSizes];                               // O(1) lookup for small sizes
    253263#endif // FASTLOOKUP
    … …  
    522532
    523533
    524 size_t Bsearchl( unsigned int key, const unsigned int * vals, size_t dim ) {
    525         size_t l = 0, m, h = dim;
    526         while ( l < h ) {
    527                 m = (l + h) / 2;
    528                 if ( (unsigned int &)(vals[m]) < key ) {                // cast away const
    529                         l = m + 1;
    530                 } else {
    531                         h = m;
    532                 } // if
    533         } // while
    534         return l;
    535 } // Bsearchl
    536 
    537 
    538534static inline void * doMalloc( size_t size ) with ( heapManager ) {
    539535        HeapManager.Storage * block;                                            // pointer to new block of storage
    … …  
    544540        size_t tsize = size + sizeof(HeapManager.Storage);
    545541        if ( likely( tsize < mmapStart ) ) {                            // small size => sbrk
    546                 size_t posn;
    547                 #ifdef FASTLOOKUP
    548                 if ( tsize < LookupSizes ) posn = lookup[tsize];
    549                 else
    550                 #endif // FASTLOOKUP
    551                         posn = Bsearchl( (unsigned int)tsize, bucketSizes, (size_t)maxBucketsUsed );
    552                 HeapManager.FreeHeader * freeElem = &freeLists[posn];
    553                 // #ifdef FASTLOOKUP
    554                 // if ( tsize < LookupSizes )
    555                 //      freeElem = &freeLists[lookup[tsize]];
    556                 // else
    557                 // #endif // FASTLOOKUP
    558                 //      freeElem = bsearchl( tsize, freeLists, (size_t)maxBucketsUsed ); // binary search
    559                 // HeapManager.FreeHeader * freeElem =
    560                 //      #ifdef FASTLOOKUP
    561                 //      tsize < LookupSizes ? &freeLists[lookup[tsize]] :
    562                 //      #endif // FASTLOOKUP
    563                 //      bsearchl( tsize, freeLists, (size_t)maxBucketsUsed ); // binary search
     542                HeapManager.FreeHeader * freeElem =
     543                        #ifdef FASTLOOKUP
     544                        tsize < LookupSizes ? &freeLists[lookup[tsize]] :
     545                        #endif // FASTLOOKUP
     546                        bsearchl( tsize, freeLists, (size_t)maxBucketsUsed ); // binary search
    564547                assert( freeElem <= &freeLists[maxBucketsUsed] ); // subscripting error ?
    565548                assert( tsize <= freeElem->blockSize );                 // search failure ?
    … …  
    764747
    765748
    766 // supported mallopt options
    767 #ifndef M_MMAP_THRESHOLD
    768 #define M_MMAP_THRESHOLD (-1)
    769 #endif // M_TOP_PAD
    770 #ifndef M_TOP_PAD
    771 #define M_TOP_PAD (-2)
    772 #endif // M_TOP_PAD
    773 
    774 
    775749extern "C" {
    776750        // The malloc() function allocates size bytes and returns a pointer to the allocated memory. The memory is not
    … …  
    869843                void * area;
    870844                if ( unlikely( alignment != 0 ) ) {                             // previous request memalign?
    871                         area = memalign( alignment, size );                     // create new aligned area
     845                        area = memalign( alignment, size );                     // create new area
    872846                } else {
    873847                        area = mallocNoStats( size );                           // create new area

  • libcfa/src/stdlib.hfa

    r83b52f1 r6130304  
    1010// Created On       : Thu Jan 28 17:12:35 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jul 23 14:14:59 2019
    13 // Update Count     : 373
     12// Last Modified On : Wed Apr 24 17:35:43 2019
     13// Update Count     : 352
    1414//
    1515
    … …  
    1717
    1818#include "bits/defs.hfa"
    19 #include "bits/align.hfa"
    2019
    2120#include <stdlib.h>                                                                             // *alloc, strto*, ato*
    22 
    2321extern "C" {
    2422        void * memalign( size_t align, size_t size );           // malloc.h
    … …  
    4139
    4240        T * malloc( void ) {
    43                 if ( _Alignof(T) <= libAlign() ) return (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
    44                 else return (T *)memalign( _Alignof(T), sizeof(T) );
     41                return (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
    4542        } // malloc
    4643
    4744        T * calloc( size_t dim ) {
    48                 if ( _Alignof(T) <= libAlign() )return (T *)(void *)calloc( dim, sizeof(T) ); // C calloc
    49                 else return (T *)cmemalign( _Alignof(T), dim, sizeof(T) );
     45                return (T *)(void *)calloc( dim, sizeof(T) );   // C calloc
    5046        } // calloc
    5147
    5248        T * realloc( T * ptr, size_t size ) {
    53                 if ( unlikely( ptr == 0 ) ) return malloc();
    5449                return (T *)(void *)realloc( (void *)ptr, size );
    5550        } // realloc
    … …  
    7166
    7267        T * alloc( void ) {
    73                 return malloc();
     68                return (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
    7469        } // alloc
    7570
    7671        T * alloc( char fill ) {
    77                 T * ptr;
    78                 if ( _Alignof(T) <= libAlign() ) ptr = (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
    79                 else ptr = (T *)memalign( _Alignof(T), sizeof(T) );
     72                T * ptr = (T *)(void *)malloc( (size_t)sizeof(T) );     // C malloc
    8073                return (T *)memset( ptr, (int)fill, sizeof(T) ); // initialize with fill value
    8174        } // alloc
    8275
    8376        T * alloc( size_t dim ) {
    84                 if ( _Alignof(T) <= libAlign() ) return (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc
    85                 else return (T *)memalign( _Alignof(T), dim * sizeof(T) );
     77                return (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc
    8678        } // alloc
    8779
    8880        T * alloc( size_t dim, char fill ) {
    89                 return (T *)memset( (T *)alloc( dim ), (int)fill, dim * sizeof(T) ); // initialize with fill value
     81                T * ptr = (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C calloc
     82                return (T *)memset( ptr, (int)fill, dim * sizeof(T) ); // initialize with fill value
    9083        } // alloc
    9184
    9285        T * alloc( T ptr[], size_t dim ) {
    93                 return realloc( ptr, dim * sizeof(T) );
    94         } // alloc
    95 } // distribution
     86                return (T *)(void *)realloc( (void *)ptr, dim * (size_t)sizeof(T) ); // C realloc
     87        } // alloc
     88} // distribution
     89
     90
     91forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill );
    9692
    9793
    … …  
    111107
    112108        T * align_alloc( size_t align, size_t dim, char fill ) {
     109                T * ptr;
    113110                if ( fill == '\0' ) {
    114                         return (T *)cmemalign( align, dim, sizeof(T) );
     111                        ptr = (T *)cmemalign( align, dim, sizeof(T) );
    115112                } else {
    116                         return (T *)memset( (T *)memalign( align, dim * sizeof(T) ), (int)fill, dim * sizeof(T) );
     113                        ptr = (T *)memalign( align, dim * sizeof(T) );
     114                        return (T *)memset( ptr, (int)fill, dim * sizeof(T) );
    117115                } // if
    118         } // align_alloc
    119 } // distribution
    120 
    121 forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill );
     116                return ptr;
     117        } // align_alloc
     118} // distribution
    122119
    123120

  • src/InitTweak/InitTweak.cc

    r83b52f1 r6130304  
    99// Author           : Rob Schluntz
    1010// Created On       : Fri May 13 11:26:36 2016
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Fri Jun 19 14:34:00 2019
    13 // Update Count     : 6
     11// Last Modified By : Aaron B. Moss
     12// Last Modified On : Mon Jun 10 13:30:00 2019
     13// Update Count     : 5
    1414//
    1515
    … …  
    633633                        return nullptr;
    634634                }
    635 
    636                 DeclarationWithType * getFunctionCore( const Expression * expr ) {
    637                         if ( const auto * appExpr = dynamic_cast< const ApplicationExpr * >( expr ) ) {
    638                                 return getCalledFunction( appExpr->function );
    639                         } else if ( const auto * untyped = dynamic_cast< const UntypedExpr * >( expr ) ) {
    640                                 return getCalledFunction( untyped->function );
    641                         }
    642                         assertf( false, "getFunction with unknown expression: %s", toString( expr ).c_str() );
    643                 }
    644635        }
    645636
    646637        DeclarationWithType * getFunction( Expression * expr ) {
    647                 return getFunctionCore( expr );
    648         }
    649 
    650         const DeclarationWithType * getFunction( const Expression * expr ) {
    651                 return getFunctionCore( expr );
     638                if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr ) ) {
     639                        return getCalledFunction( appExpr->get_function() );
     640                } else if ( UntypedExpr * untyped = dynamic_cast< UntypedExpr * > ( expr ) ) {
     641                        return getCalledFunction( untyped->get_function() );
     642                }
     643                assertf( false, "getFunction received unknown expression: %s", toString( expr ).c_str() );
    652644        }
    653645

  • src/InitTweak/InitTweak.h

    r83b52f1 r6130304  
    99// Author           : Rob Schluntz
    1010// Created On       : Fri May 13 11:26:36 2016
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Fri Jul 19 14:18:00 2019
    13 // Update Count     : 6
     11// Last Modified By : Aaron B. Moss
     12// Last Modified On : Mon Jun 10 13:30:00 2019
     13// Update Count     : 5
    1414//
    1515
    … …  
    6161        /// returns the declaration of the function called by the expr (must be ApplicationExpr or UntypedExpr)
    6262        DeclarationWithType * getFunction( Expression * expr );
    63         const DeclarationWithType * getFunction( const Expression * expr );
    6463        const ast::DeclWithType * getFunction( const ast::Expr * expr );
    6564

  • src/ResolvExpr/Alternative.h

    r83b52f1 r6130304  
    2929        /// One assertion to resolve
    3030        struct AssertionItem {
    31                 const DeclarationWithType* decl;
     31                DeclarationWithType* decl;
    3232                AssertionSetValue info;
    33 
     33               
    3434                AssertionItem() = default;
    35                 AssertionItem( const DeclarationWithType* decl, const AssertionSetValue& info )
     35                AssertionItem( DeclarationWithType* decl, const AssertionSetValue& info )
    3636                : decl(decl), info(info) {}
    3737                AssertionItem( const AssertionSet::value_type& e ) : decl(e.first), info(e.second) {}

  • src/ResolvExpr/FindOpenVars.cc

    r83b52f1 r6130304  
    99// Author           : Richard C. Bilson
    1010// Created On       : Sun May 17 09:42:48 2015
    11 // Last Modified By : Andrew
    12 // Last Modified On : Fri Jul 12 14:18:00 2019
    13 // Update Count     : 4
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sun May 17 09:45:25 2015
     13// Update Count     : 3
    1414//
    1515
    … …  
    2929                FindOpenVars_old( OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen );
    3030
    31                 void previsit( const PointerType * pointerType );
    32                 void previsit( const ArrayType * arrayType );
    33                 void previsit( const FunctionType * functionType );
    34                 void previsit( const TupleType * tupleType );
     31                void previsit( PointerType * pointerType );
     32                void previsit( ArrayType * arrayType );
     33                void previsit( FunctionType * functionType );
     34                void previsit( TupleType * tupleType );
    3535
    36                 void common_action( const Type *type );
     36                void common_action( Type *type );
    3737
    3838                OpenVarSet &openVars, &closedVars;
    … …  
    4141        };
    4242
    43         void findOpenVars( const Type *type, OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen ) {
     43        void findOpenVars( Type *type, OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen ) {
    4444                PassVisitor<FindOpenVars_old> finder( openVars, closedVars, needAssertions, haveAssertions, firstIsOpen );
    4545                type->accept( finder );
    … …  
    5050        }
    5151
    52         void FindOpenVars_old::common_action( const Type * type ) {
     52        void FindOpenVars_old::common_action( Type *type ) {
    5353                if ( nextIsOpen ) {
    54                         for ( Type::ForallList::const_iterator i = type->forall.begin(); i != type->forall.end(); ++i ) {
     54                        for ( Type::ForallList::const_iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
    5555                                openVars[ (*i)->get_name() ] = TypeDecl::Data{ (*i) };
    5656                                for ( std::list< DeclarationWithType* >::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) {
    … …  
    6161                        }
    6262                } else {
    63                         for ( Type::ForallList::const_iterator i = type->forall.begin(); i != type->forall.end(); ++i ) {
     63                        for ( Type::ForallList::const_iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
    6464                                closedVars[ (*i)->get_name() ] = TypeDecl::Data{ (*i) };
    6565                                for ( std::list< DeclarationWithType* >::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) {
    … …  
    7878        }
    7979
    80         void FindOpenVars_old::previsit(const PointerType * pointerType) {
     80        void FindOpenVars_old::previsit(PointerType *pointerType) {
    8181                common_action( pointerType );
    8282        }
    8383
    84         void FindOpenVars_old::previsit(const ArrayType * arrayType) {
     84        void FindOpenVars_old::previsit(ArrayType *arrayType) {
    8585                common_action( arrayType );
    8686        }
    8787
    88         void FindOpenVars_old::previsit(const FunctionType * functionType) {
     88        void FindOpenVars_old::previsit(FunctionType *functionType) {
    8989                common_action( functionType );
    9090                nextIsOpen = ! nextIsOpen;
    … …  
    9292        }
    9393
    94         void FindOpenVars_old::previsit(const TupleType * tupleType) {
     94        void FindOpenVars_old::previsit(TupleType *tupleType) {
    9595                common_action( tupleType );
    9696        }
    … …  
    104104                        bool nextIsOpen;
    105105
    106                         FindOpenVars_new(
    107                                 ast::OpenVarSet & o, ast::OpenVarSet & c, ast::AssertionSet & n,
     106                        FindOpenVars_new( 
     107                                ast::OpenVarSet & o, ast::OpenVarSet & c, ast::AssertionSet & n, 
    108108                                ast::AssertionSet & h, FirstMode firstIsOpen )
    109109                        : open( o ), closed( c ), need( n ), have( h ), nextIsOpen( firstIsOpen ) {}
    … …  
    135135        }
    136136
    137         void findOpenVars(
    138                         const ast::Type * type, ast::OpenVarSet & open, ast::OpenVarSet & closed,
     137        void findOpenVars( 
     138                        const ast::Type * type, ast::OpenVarSet & open, ast::OpenVarSet & closed, 
    139139                        ast::AssertionSet & need, ast::AssertionSet & have, FirstMode firstIsOpen ) {
    140140                ast::Pass< FindOpenVars_new > finder{ open, closed, need, have, firstIsOpen };

  • src/ResolvExpr/FindOpenVars.h

    r83b52f1 r6130304  
    2626namespace ResolvExpr {
    2727        // Updates open and closed variables and their associated assertions
    28         void findOpenVars( const Type *type, OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen );
     28        void findOpenVars( Type *type, OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen );
    2929
    3030        enum FirstMode { FirstClosed, FirstOpen };

  • src/ResolvExpr/Occurs.cc

    r83b52f1 r6130304  
    2424        struct Occurs : public WithVisitorRef<Occurs> {
    2525                Occurs( std::string varName, const TypeEnvironment &env );
    26                 void previsit( const TypeInstType * typeInst );
     26                void previsit( TypeInstType * typeInst );
    2727
    2828                bool result;
    … …  
    3131        };
    3232
    33         bool occurs( const Type *type, const std::string & varName, const TypeEnvironment &env ) {
     33        bool occurs( Type *type, std::string varName, const TypeEnvironment &env ) {
    3434                PassVisitor<Occurs> occur( varName, env );
    3535                type->accept( occur );
    … …  
    4545        }
    4646
    47         void Occurs::previsit( const TypeInstType * typeInst ) {
     47        void Occurs::previsit( TypeInstType * typeInst ) {
    4848                ///   std::cerr << "searching for vars: ";
    4949///   std::copy( eqvVars.begin(), eqvVars.end(), std::ostream_iterator< std::string >( std::cerr, " " ) );

  • src/ResolvExpr/ResolveAssertions.cc

    r83b52f1 r6130304  
    7373                CandidateList matches;
    7474
    75                 DeferItem( const DeclarationWithType* decl, const AssertionSetValue& info, CandidateList&& matches )
     75                DeferItem( DeclarationWithType* decl, const AssertionSetValue& info, CandidateList&& matches )
    7676                : decl(decl), info(info), matches(std::move(matches)) {}
    7777

  • src/ResolvExpr/TypeEnvironment.cc

    r83b52f1 r6130304  
    99// Author           : Richard C. Bilson
    1010// Created On       : Sun May 17 12:19:47 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Fri Jun 18 14:27:00 2019
    13 // Update Count     : 5
     11// Last Modified By : Aaron B. Moss
     12// Last Modified On : Mon Jun 18 11:58:00 2018
     13// Update Count     : 4
    1414//
    1515
    … …  
    315315        }
    316316
    317         bool isFtype( const Type * type ) {
    318                 if ( dynamic_cast< const FunctionType * >( type ) ) {
     317        bool isFtype( Type *type ) {
     318                if ( dynamic_cast< FunctionType* >( type ) ) {
    319319                        return true;
    320                 } else if ( const TypeInstType *typeInst = dynamic_cast< const TypeInstType * >( type ) ) {
     320                } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( type ) ) {
    321321                        return typeInst->get_isFtype();
    322322                } // if
    … …  
    324324        }
    325325
    326         bool tyVarCompatible( const TypeDecl::Data & data, const Type * type ) {
     326        bool tyVarCompatible( const TypeDecl::Data & data, Type *type ) {
    327327                switch ( data.kind ) {
    328328                  case TypeDecl::Dtype:
    … …  
    336336                  case TypeDecl::Ttype:
    337337                        // ttype unifies with any tuple type
    338                         return dynamic_cast< const TupleType * >( type ) || Tuples::isTtype( type );
     338                        return dynamic_cast< TupleType * >( type ) || Tuples::isTtype( type );
    339339                  default:
    340340                        assertf(false, "Unhandled tyvar kind: %d", data.kind);
    … …  
    343343        }
    344344
    345         bool TypeEnvironment::bindVar( const TypeInstType *typeInst, Type *bindTo, const TypeDecl::Data & data, AssertionSet &need, AssertionSet &have, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer ) {
     345        bool TypeEnvironment::bindVar( TypeInstType *typeInst, Type *bindTo, const TypeDecl::Data & data, AssertionSet &need, AssertionSet &have, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer ) {
    346346
    347347                // remove references from other, so that type variables can only bind to value types
    … …  
    361361                                // attempt to unify equivalence class type (which has qualifiers stripped, so they must be restored) with the type to bind to
    362362                                std::unique_ptr< Type > newType( curClass->type->clone() );
    363                                 newType->tq = typeInst->tq;
     363                                newType->get_qualifiers() = typeInst->get_qualifiers();
    364364                                if ( unifyInexact( newType.get(), bindTo, *this, need, have, openVars, widen & WidenMode( curClass->allowWidening, true ), indexer, common ) ) {
    365365                                        if ( common ) {
    … …  
    386386        }
    387387
    388         bool TypeEnvironment::bindVarToVar( const TypeInstType * var1, const TypeInstType * var2,
    389                         TypeDecl::Data && data, AssertionSet &need, AssertionSet &have,
     388        bool TypeEnvironment::bindVarToVar( TypeInstType *var1, TypeInstType *var2,
     389                        TypeDecl::Data && data, AssertionSet &need, AssertionSet &have, 
    390390                        const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer ) {
    391391

  • src/ResolvExpr/TypeEnvironment.h

    r83b52f1 r6130304  
    99// Author           : Richard C. Bilson
    1010// Created On       : Sun May 17 12:24:58 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Fri Jul 19 17:00:10 2019
    13 // Update Count     : 10
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Tue Apr 30 23:04:10 2019
     13// Update Count     : 9
    1414//
    1515
    … …  
    4040        // declarations.
    4141        //
    42         // I've seen a TU go from 54 minutes to 1 minute 34 seconds with the addition of this
     42        // I've seen a TU go from 54 minutes to 1 minute 34 seconds with the addition of this 
    4343        // comparator.
    4444        //
    … …  
    4646        // memory layout can alter compilation time in unpredictable ways. For example, the placement
    4747        // of a line directive can reorder type pointers with respect to each other so that assertions
    48         // are seen in different orders, causing a potentially different number of unification calls
    49         // when resolving assertions. I've seen a TU go from 36 seconds to 27 seconds by reordering
    50         // line directives alone, so it would be nice to fix this comparison so that assertions compare
    51         // more consistently. I've tried to modify this to compare on mangle name instead of type as
    52         // the second comparator, but this causes some assertions to never be recorded. More
     48        // are seen in different orders, causing a potentially different number of unification calls 
     49        // when resolving assertions. I've seen a TU go from 36 seconds to 27 seconds by reordering 
     50        // line directives alone, so it would be nice to fix this comparison so that assertions compare 
     51        // more consistently. I've tried to modify this to compare on mangle name instead of type as 
     52        // the second comparator, but this causes some assertions to never be recorded. More 
    5353        // investigation is needed.
    5454        struct AssertCompare {
    55                 bool operator()( const DeclarationWithType * d1, const DeclarationWithType * d2 ) const {
     55                bool operator()( DeclarationWithType * d1, DeclarationWithType * d2 ) const {
    5656                        int cmp = d1->get_name().compare( d2->get_name() );
    5757                        return cmp < 0 ||
    … …  
    6565                AssertionSetValue() : isUsed(false), resnSlot(0) {}
    6666        };
    67         typedef std::map< const DeclarationWithType *, AssertionSetValue, AssertCompare > AssertionSet;
     67        typedef std::map< DeclarationWithType *, AssertionSetValue, AssertCompare > AssertionSet;
    6868        typedef std::unordered_map< std::string, TypeDecl::Data > OpenVarSet;
    6969
    … …  
    7878        struct EqvClass {
    7979                std::set< std::string > vars;
    80                 Type * type;
     80                Type *type;
    8181                bool allowWidening;
    8282                TypeDecl::Data data;
    … …  
    111111                bool isEmpty() const { return env.empty(); }
    112112                void print( std::ostream &os, Indenter indent = {} ) const;
    113 
     113               
    114114                /// Simply concatenate the second environment onto this one; no safety checks performed
    115115                void simpleCombine( const TypeEnvironment &second );
    … …  
    126126                /// Returns false if fails, but does NOT roll back partial changes.
    127127                bool combine( const TypeEnvironment& second, OpenVarSet& openVars, const SymTab::Indexer& indexer );
    128 
     128               
    129129                void extractOpenVars( OpenVarSet &openVars ) const;
    130130                TypeEnvironment *clone() const { return new TypeEnvironment( *this ); }
    … …  
    134134                void addActual( const TypeEnvironment& actualEnv, OpenVarSet& openVars );
    135135
    136                 /// Binds the type class represented by `typeInst` to the type `bindTo`; will add
     136                /// Binds the type class represented by `typeInst` to the type `bindTo`; will add 
    137137                /// the class if needed. Returns false on failure.
    138                 bool bindVar( const TypeInstType * typeInst, Type * bindTo, const TypeDecl::Data & data, AssertionSet &need, AssertionSet &have, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer );
    139 
    140                 /// Binds the type classes represented by `var1` and `var2` together; will add
     138                bool bindVar( TypeInstType *typeInst, Type *bindTo, const TypeDecl::Data & data, AssertionSet &need, AssertionSet &have, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer );
     139               
     140                /// Binds the type classes represented by `var1` and `var2` together; will add 
    141141                /// one or both classes if needed. Returns false on failure.
    142                 bool bindVarToVar( const TypeInstType * var1, const TypeInstType * var2, TypeDecl::Data && data, AssertionSet &need, AssertionSet &have, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer );
     142                bool bindVarToVar( TypeInstType *var1, TypeInstType *var2, TypeDecl::Data && data, AssertionSet &need, AssertionSet &have, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer );
    143143
    144144                /// Disallows widening for all bindings in the environment
    … …  
    151151          private:
    152152                ClassList env;
    153 
     153               
    154154                ClassList::iterator internal_lookup( const std::string &var );
    155155        };

  • src/ResolvExpr/typeops.h

    r83b52f1 r6130304  
    149149
    150150        // in Occurs.cc
    151         bool occurs( const Type * type, const std::string & varName, const TypeEnvironment & env );
     151        bool occurs( Type * type, std::string varName, const TypeEnvironment & env );
    152152        // new AST version in TypeEnvironment.cpp (only place it was used in old AST)
    153153
    … …  
    200200
    201201        // in TypeEnvironment.cc
    202         bool isFtype( const Type * type );
     202        bool isFtype( Type * type );
    203203} // namespace ResolvExpr
    204204

  • src/SynTree/Type.cc

    r83b52f1 r6130304  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Fri Jul 12 15:48:00 2019
    13 // Update Count     : 44
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Thu Jan 31 21:54:16 2019
     13// Update Count     : 43
    1414//
    1515#include "Type.h"
    … …  
    141141}
    142142
    143 const Type * Type::stripReferences() const {
    144         const Type * type;
    145         const ReferenceType * ref;
    146         for ( type = this; (ref = dynamic_cast<const ReferenceType *>( type )); type = ref->base );
    147         return type;
    148 }
    149 
    150143int Type::referenceDepth() const { return 0; }
    151144

  • src/SynTree/Type.h

    r83b52f1 r6130304  
    172172        /// return type without outer references
    173173        Type * stripReferences();
    174         const Type * stripReferences() const;
    175174
    176175        /// return the number of references occuring consecutively on the outermost layer of this type (i.e. do not count references nested within other types)
    … …  
    257256        BasicType( const Type::Qualifiers & tq, Kind bt, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    258257
    259         Kind get_kind() const { return kind; }
     258        Kind get_kind() { return kind; }
    260259        void set_kind( Kind newValue ) { kind = newValue; }
    261260

  • src/Tuples/TupleExpansion.cc

    r83b52f1 r6130304  
    99// Author           : Rodolfo G. Esteves
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Fri Jul 19 14:39:00 2019
    13 // Update Count     : 22
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Wed Feb 13 18:14:12 2019
     13// Update Count     : 21
    1414//
    1515
    … …  
    350350        }
    351351
    352         const TypeInstType * isTtype( const Type * type ) {
    353                 if ( const TypeInstType * inst = dynamic_cast< const TypeInstType * >( type ) ) {
    354                         if ( inst->baseType && inst->baseType->kind == TypeDecl::Ttype ) {
    355                                 return inst;
    356                         }
    357                 }
    358                 return nullptr;
    359         }
    360 
    361352        const ast::TypeInstType * isTtype( const ast::Type * type ) {
    362353                if ( const ast::TypeInstType * inst = dynamic_cast< const ast::TypeInstType * >( type ) ) {
    … …  
    373364                        ImpurityDetector( bool ignoreUnique ) : ignoreUnique( ignoreUnique ) {}
    374365
    375                         void previsit( const ApplicationExpr * appExpr ) {
     366                        void previsit( ApplicationExpr * appExpr ) {
    376367                                visit_children = false;
    377                                 if ( const DeclarationWithType * function = InitTweak::getFunction( appExpr ) ) {
    378                                         if ( function->linkage == LinkageSpec::Intrinsic ) {
    379                                                 if ( function->name == "*?" || function->name == "?[?]" ) {
     368                                if ( DeclarationWithType * function = InitTweak::getFunction( appExpr ) ) {
     369                                        if ( function->get_linkage() == LinkageSpec::Intrinsic ) {
     370                                                if ( function->get_name() == "*?" || function->get_name() == "?[?]" ) {
    380371                                                        // intrinsic dereference, subscript are pure, but need to recursively look for impurity
    381372                                                        visit_children = true;
    … …  
    386377                                maybeImpure = true;
    387378                        }
    388                         void previsit( const UntypedExpr * ) { maybeImpure = true; visit_children = false; }
    389                         void previsit( const UniqueExpr * ) {
     379                        void previsit( UntypedExpr * ) { maybeImpure = true; visit_children = false; }
     380                        void previsit( UniqueExpr * ) {
    390381                                if ( ignoreUnique ) {
    391382                                        // bottom out at unique expression.
    … …  
    402393        } // namespace
    403394
    404         bool maybeImpure( const Expression * expr ) {
     395        bool maybeImpure( Expression * expr ) {
    405396                PassVisitor<ImpurityDetector> detector( false );
    406397                expr->accept( detector );
    … …  
    408399        }
    409400
    410         bool maybeImpureIgnoreUnique( const Expression * expr ) {
     401        bool maybeImpureIgnoreUnique( Expression * expr ) {
    411402                PassVisitor<ImpurityDetector> detector( true );
    412403                expr->accept( detector );

  • src/Tuples/Tuples.h

    r83b52f1 r6130304  
    5252        /// returns a TypeInstType if `type` is a ttype, nullptr otherwise
    5353        TypeInstType * isTtype( Type * type );
    54         const TypeInstType * isTtype( const Type * type );
    5554        const ast::TypeInstType * isTtype( const ast::Type * type );
    5655
    5756        /// returns true if the expression may contain side-effects.
    58         bool maybeImpure( const Expression * expr );
     57        bool maybeImpure( Expression * expr );
    5958        bool maybeImpure( const ast::Expr * expr );
    6059
    6160        /// Returns true if the expression may contain side-effect,
    6261        /// ignoring the presence of unique expressions.
    63         bool maybeImpureIgnoreUnique( const Expression * expr );
     62        bool maybeImpureIgnoreUnique( Expression * expr );
    6463        bool maybeImpureIgnoreUnique( const ast::Expr * expr );
    6564} // namespace Tuples

  • tests/.expect/copyfile.txt

    r83b52f1 r6130304  
    1010// Created On       : Tue Jul 16 16:47:22 2019
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jul 17 18:04:44 2019
    13 // Update Count     : 26
     12// Last Modified On : Tue Jul 16 16:48:16 2019
     13// Update Count     : 1
    1414//
    1515
    1616#include <fstream.hfa>
    17 #include <stdlib.hfa>                                                                   // new/delete
    1817
    1918int main( int argc, char * argv[] ) {
    20         ifstream * in  = &stdin;                                                        // default files
    21         ofstream * out = &stdout;
    22         try {
    23                 choose ( argc ) {
    24                   case 2, 3:
    25                           in = new( (const char *)argv[1] );            // open input file first as output creates file
    26                           if ( argc == 3 ) out = new( (const char *)argv[2] ); // only open output if input opens as output created if nonexistent
    27                   case 1: ;                                     // use default files
    28                   default:
    29                           exit | "Usage [ input-file (default stdin) [ output-file (default stdout) ] ]";
    30                 } // choose
     19    ifstream & in  = stdin;                             // default files
     20    ofstream & out = stdout;
     21    try {
     22        choose ( argc ) {
     23          case 2, 3:
     24            open( in, argv[1] );                        // open input file first as output creates file
     25            if ( argc == 3 ) open( out, argv[2] );      // only open output if input opens as output created if nonexistent
     26          case 1: ;                                     // use default files
     27          default:
     28            exit | "Usage [ input-file (default stdin) [ output-file (default stdout) ] ]";
     29        } // choose
    3130
    32                 char ch;
    33                 *out | nlOff;                                                                   // turn off auto newline
    34                 *in  | nlOn;                                                                    // turn on reading newline
     31        char ch;
     32        out | nlOff;                                    // turn off auto newline
     33        in  | nlOn;                                     // turn on reading newline
    3534
    36                 for () {                                                                                // read all characters
    37                         *in | ch;
    38                   if ( eof( *in ) ) break;                                              // eof ?
    39                         *out | ch;
    40                 } // for
    41         } finally {
    42                 if ( in  != &stdin  ) delete( in );                             // close file, do not delete stdin!
    43                 if ( out != &stdout ) delete( out );                    // close file, do not delete stdout!
    44         } // try
     35        for () {                                        // read all characters
     36            in | ch;
     37          if ( eof( in ) ) break;                       // eof ?
     38            out | ch;
     39        } // for
     40    } finally {
     41        close( in );                                    // stdin, stdout are never closed
     42        close( out );
     43    } // try
    4544} // main
    4645

  • tests/.in/copyfile.txt

    r83b52f1 r6130304  
    1010// Created On       : Tue Jul 16 16:47:22 2019
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jul 17 18:04:44 2019
    13 // Update Count     : 26
     12// Last Modified On : Tue Jul 16 16:48:16 2019
     13// Update Count     : 1
    1414//
    1515
    1616#include <fstream.hfa>
    17 #include <stdlib.hfa>                                                                   // new/delete
    1817
    1918int main( int argc, char * argv[] ) {
    20         ifstream * in  = &stdin;                                                        // default files
    21         ofstream * out = &stdout;
    22         try {
    23                 choose ( argc ) {
    24                   case 2, 3:
    25                           in = new( (const char *)argv[1] );            // open input file first as output creates file
    26                           if ( argc == 3 ) out = new( (const char *)argv[2] ); // only open output if input opens as output created if nonexistent
    27                   case 1: ;                                     // use default files
    28                   default:
    29                           exit | "Usage [ input-file (default stdin) [ output-file (default stdout) ] ]";
    30                 } // choose
     19    ifstream & in  = stdin;                             // default files
     20    ofstream & out = stdout;
     21    try {
     22        choose ( argc ) {
     23          case 2, 3:
     24            open( in, argv[1] );                        // open input file first as output creates file
     25            if ( argc == 3 ) open( out, argv[2] );      // only open output if input opens as output created if nonexistent
     26          case 1: ;                                     // use default files
     27          default:
     28            exit | "Usage [ input-file (default stdin) [ output-file (default stdout) ] ]";
     29        } // choose
    3130
    32                 char ch;
    33                 *out | nlOff;                                                                   // turn off auto newline
    34                 *in  | nlOn;                                                                    // turn on reading newline
     31        char ch;
     32        out | nlOff;                                    // turn off auto newline
     33        in  | nlOn;                                     // turn on reading newline
    3534
    36                 for () {                                                                                // read all characters
    37                         *in | ch;
    38                   if ( eof( *in ) ) break;                                              // eof ?
    39                         *out | ch;
    40                 } // for
    41         } finally {
    42                 if ( in  != &stdin  ) delete( in );                             // close file, do not delete stdin!
    43                 if ( out != &stdout ) delete( out );                    // close file, do not delete stdout!
    44         } // try
     35        for () {                                        // read all characters
     36            in | ch;
     37          if ( eof( in ) ) break;                       // eof ?
     38            out | ch;
     39        } // for
     40    } finally {
     41        close( in );                                    // stdin, stdout are never closed
     42        close( out );
     43    } // try
    4544} // main
    4645

  • tests/copyfile.cfa

    r83b52f1 r6130304  
    1010// Created On       : Tue Jul 16 16:47:22 2019
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jul 17 18:04:44 2019
    13 // Update Count     : 26
     12// Last Modified On : Tue Jul 16 16:48:16 2019
     13// Update Count     : 1
    1414//
    1515
    1616#include <fstream.hfa>
    17 #include <stdlib.hfa>                                                                   // new/delete
    1817
    1918int main( int argc, char * argv[] ) {
    20         ifstream * in  = &stdin;                                                        // default files
    21         ofstream * out = &stdout;
    22         try {
    23                 choose ( argc ) {
    24                   case 2, 3:
    25                           in = new( (const char *)argv[1] );            // open input file first as output creates file
    26                           if ( argc == 3 ) out = new( (const char *)argv[2] ); // only open output if input opens as output created if nonexistent
    27                   case 1: ;                                     // use default files
    28                   default:
    29                           exit | "Usage [ input-file (default stdin) [ output-file (default stdout) ] ]";
    30                 } // choose
     19    ifstream & in  = stdin;                             // default files
     20    ofstream & out = stdout;
     21    try {
     22        choose ( argc ) {
     23          case 2, 3:
     24            open( in, argv[1] );                        // open input file first as output creates file
     25            if ( argc == 3 ) open( out, argv[2] );      // only open output if input opens as output created if nonexistent
     26          case 1: ;                                     // use default files
     27          default:
     28            exit | "Usage [ input-file (default stdin) [ output-file (default stdout) ] ]";
     29        } // choose
    3130
    32                 char ch;
    33                 *out | nlOff;                                                                   // turn off auto newline
    34                 *in  | nlOn;                                                                    // turn on reading newline
     31        char ch;
     32        out | nlOff;                                    // turn off auto newline
     33        in  | nlOn;                                     // turn on reading newline
    3534
    36                 for () {                                                                                // read all characters
    37                         *in | ch;
    38                   if ( eof( *in ) ) break;                                              // eof ?
    39                         *out | ch;
    40                 } // for
    41         } finally {
    42                 if ( in  != &stdin  ) delete( in );                             // close file, do not delete stdin!
    43                 if ( out != &stdout ) delete( out );                    // close file, do not delete stdout!
    44         } // try
     35        for () {                                        // read all characters
     36            in | ch;
     37          if ( eof( in ) ) break;                       // eof ?
     38            out | ch;
     39        } // for
     40    } finally {
     41        close( in );                                    // stdin, stdout are never closed
     42        close( out );
     43    } // try
    4544} // main
    4645

  • tests/heap.cfa

    r83b52f1 r6130304  
    1010// Created On       : Tue Nov  6 17:54:56 2018
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Jul 19 08:22:34 2019
    13 // Update Count     : 19
     12// Last Modified On : Tue Dec 11 21:52:40 2018
     13// Update Count     : 18
    1414//
    1515
    … …  
    2929#define __U_DEFAULT_MMAP_START__ (512 * 1024 + 1)
    3030size_t default_mmap_start() __attribute__(( weak )) {
    31         return __U_DEFAULT_MMAP_START__;
     31    return __U_DEFAULT_MMAP_START__;
    3232} // default_mmap_start
    3333
    … …  
    3636
    3737void main( Worker & ) {
    38         enum { NoOfAllocs = 5000, NoOfMmaps = 10 };
    39         char * locns[NoOfAllocs];
    40         int i;
    41 
    42         // check alloc/free
    43 
    44         for ( j; 40 ) {
     38    enum { NoOfAllocs = 5000, NoOfMmaps = 10 };
     39    char * locns[NoOfAllocs];
     40    int i;
     41
     42    // check alloc/free
     43
     44    for ( j; 40 ) {
    4545                for ( i; NoOfAllocs ) {
    4646                        locns[i] = alloc( i );
    … …  
    6767                        free( locns[i] );
    6868                } // for
    69         } // for
    70 
    71         // check malloc/free (sbrk)
    72 
    73         for ( i; NoOfAllocs ) {
     69    } // for
     70
     71    // check malloc/free (sbrk)
     72
     73    for ( i; NoOfAllocs ) {
    7474                size_t s = (i + 1) * 20;
    7575                char * area = (char *)malloc( s );
    … …  
    7878                area[malloc_usable_size( area ) - 1] = '\345';  // fill ultimate byte
    7979                free( area );
    80         } // for
    81 
    82         for ( i; NoOfAllocs ) {
     80    } // for
     81
     82    for ( i; NoOfAllocs ) {
    8383                size_t s = i + 1;                                                               // +1 to make initialization simpler
    8484                locns[i] = (char *)malloc( s );
    … …  
    8686                locns[i][0] = '\345'; locns[i][s - 1] = '\345'; // fill first/last
    8787                locns[i][malloc_usable_size( locns[i] ) - 1] = '\345'; // fill ultimate byte
    88         } // for
    89         for ( i; NoOfAllocs ) {
     88    } // for
     89    for ( i; NoOfAllocs ) {
    9090                size_t s = i + 1;
    9191                if ( locns[i][0] != '\345' || locns[i][s - 1] != '\345' ||
    9292                         locns[i][malloc_usable_size( locns[i] ) - 1] != '\345' ) abort( "malloc/free corrupt storage" );
    9393                free( locns[i] );
    94         } // for
    95 
    96         // check malloc/free (mmap)
    97 
    98         for ( i; NoOfMmaps ) {
     94    } // for
     95
     96    // check malloc/free (mmap)
     97
     98    for ( i; NoOfMmaps ) {
    9999                size_t s = i + default_mmap_start();                    // cross over point
    100100                char * area = (char *)malloc( s );
    … …  
    103103                area[malloc_usable_size( area ) - 1] = '\345';  // fill ultimate byte
    104104                free( area );
    105         } // for
    106 
    107         for ( i; NoOfMmaps ) {
     105    } // for
     106
     107    for ( i; NoOfMmaps ) {
    108108                size_t s = i + default_mmap_start();                    // cross over point
    109109                locns[i] = (char *)malloc( s );
    … …  
    111111                locns[i][0] = '\345'; locns[i][s - 1] = '\345'; // fill first/last
    112112                locns[i][malloc_usable_size( locns[i] ) - 1] = '\345'; // fill ultimate byte
    113         } // for
    114         for ( i; NoOfMmaps ) {
     113    } // for
     114    for ( i; NoOfMmaps ) {
    115115                size_t s = i + default_mmap_start();                    // cross over point
    116116                if ( locns[i][0] != '\345' || locns[i][s - 1] != '\345' ||
    117117                         locns[i][malloc_usable_size( locns[i] ) - 1] != '\345' ) abort( "malloc/free corrupt storage" );
    118118                free( locns[i] );
    119         } // for
    120 
    121         // check calloc/free (sbrk)
    122 
    123         for ( i; NoOfAllocs ) {
     119    } // for
     120
     121    // check calloc/free (sbrk)
     122
     123    for ( i; NoOfAllocs ) {
    124124                size_t s = (i + 1) * 20;
    125125                char * area = (char *)calloc( 5, s );
    … …  
    131131                area[malloc_usable_size( area ) - 1] = '\345';  // fill ultimate byte
    132132                free( area );
    133         } // for
    134 
    135         for ( i; NoOfAllocs ) {
     133    } // for
     134
     135    for ( i; NoOfAllocs ) {
    136136                size_t s = i + 1;
    137137                locns[i] = (char *)calloc( 5, s );
    … …  
    142142                locns[i][0] = '\345'; locns[i][s - 1] = '\345'; // fill first/last
    143143                locns[i][malloc_usable_size( locns[i] ) - 1] = '\345'; // fill ultimate byte
    144         } // for
    145         for ( i; NoOfAllocs ) {
     144    } // for
     145    for ( i; NoOfAllocs ) {
    146146                size_t s = i + 1;
    147147                if ( locns[i][0] != '\345' || locns[i][s - 1] != '\345' ||
    148148                         locns[i][malloc_usable_size( locns[i] ) - 1] != '\345' ) abort( "calloc/free corrupt storage3" );
    149149                free( locns[i] );
    150         } // for
    151 
    152         // check calloc/free (mmap)
    153 
    154         for ( i; NoOfMmaps ) {
     150    } // for
     151
     152    // check calloc/free (mmap)
     153
     154    for ( i; NoOfMmaps ) {
    155155                size_t s = i + default_mmap_start();                    // cross over point
    156156                char * area = (char *)calloc( 1, s );
    … …  
    162162                area[malloc_usable_size( area ) - 1] = '\345';  // fill ultimate byte
    163163                free( area );
    164         } // for
    165 
    166         for ( i; NoOfMmaps ) {
     164    } // for
     165
     166    for ( i; NoOfMmaps ) {
    167167                size_t s = i + default_mmap_start();                    // cross over point
    168168                locns[i] = (char *)calloc( 1, s );
    … …  
    173173                locns[i][0] = '\345'; locns[i][s - 1] = '\345'; // fill first/last
    174174                locns[i][malloc_usable_size( locns[i] ) - 1] = '\345'; // fill ultimate byte
    175         } // for
    176         for ( i; NoOfMmaps ) {
     175    } // for
     176    for ( i; NoOfMmaps ) {
    177177                size_t s = i + default_mmap_start();                    // cross over point
    178178                if ( locns[i][0] != '\345' || locns[i][s - 1] != '\345' ||
    179179                         locns[i][malloc_usable_size( locns[i] ) - 1] != '\345' ) abort( "calloc/free corrupt storage6" );
    180180                free( locns[i] );
    181         } // for
    182 
    183         // check memalign/free (sbrk)
    184 
    185         enum { limit = 64 * 1024 };                                                     // check alignments up to here
     181    } // for
     182
     183    // check memalign/free (sbrk)
     184
     185    enum { limit = 64 * 1024 };                                                 // check alignments up to here
    186186
    187187        for ( a; libAlign() ~= limit ~ a ) {                            // generate powers of 2
    … …  
    198198                        free( area );
    199199                } // for
    200         } // for
    201 
    202         // check memalign/free (mmap)
     200    } // for
     201
     202    // check memalign/free (mmap)
    203203
    204204        for ( a; libAlign() ~= limit ~ a ) {                            // generate powers of 2
    … …  
    216216                        free( area );
    217217                } // for
    218         } // for
    219 
    220         // check calloc/realloc/free (sbrk)
    221 
    222         for ( i; 1 ~ 10_000 ~ 12 ) {
     218    } // for
     219
     220    // check calloc/realloc/free (sbrk)
     221
     222    for ( i; 1 ~ 10_000 ~ 12 ) {
    223223                // initial N byte allocation
    224224                char * area = (char *)calloc( 5, i );
    … …  
    237237                } // for
    238238                free( area );
    239         } // for
    240 
    241         // check calloc/realloc/free (mmap)
    242 
    243         for ( i; 1 ~ 10_000 ~ 12 ) {
     239    } // for
     240
     241    // check calloc/realloc/free (mmap)
     242
     243    for ( i; 1 ~ 10_000 ~ 12 ) {
    244244                // initial N byte allocation
    245245                size_t s = i + default_mmap_start();                    // cross over point
    … …  
    259259                } // for
    260260                free( area );
    261         } // for
    262 
    263         // check memalign/realloc/free
    264 
    265         size_t amount = 2;
     261    } // for
     262
     263    // check memalign/realloc/free
     264
     265    size_t amount = 2;
    266266        for ( a; libAlign() ~= limit ~ a ) {                            // generate powers of 2
    267267                // initial N byte allocation
    … …  
    286286                } // for
    287287                free( area );
    288         } // for
    289 
    290         // check cmemalign/free
     288    } // for
     289
     290    // check cmemalign/free
    291291
    292292        for ( a; libAlign() ~= limit ~ a ) {                            // generate powers of 2
    … …  
    305305                        free( area );
    306306                } // for
    307         } // for
    308 
    309         // check cmemalign/realloc/free
    310 
    311         amount = 2;
     307    } // for
     308
     309    // check cmemalign/realloc/free
     310
     311    amount = 2;
    312312        for ( a; libAlign() ~= limit ~ a ) {                            // generate powers of 2
    313313                // initial N byte allocation
    … …  
    338338                } // for
    339339                free( area );
    340         } // for
     340    } // for
    341341        //sout | "worker" | thisTask() | "successful completion";
    342342} // Worker main
    343343
    344344int main() {
    345         const unsigned int NoOfWorkers = 4;
    346         {
     345    const unsigned int NoOfWorkers = 4;
     346    {
    347347                processor processors[NoOfWorkers - 1] __attribute__(( unused )); // more than one processor
    348348                Worker workers[NoOfWorkers] __attribute__(( unused ));
    349         }
     349    }
    350350        // checkFreeOn();
    351         // malloc_stats();
     351    // malloc_stats();
    352352}
    353353
Note: See TracChangeset for help on using the changeset viewer.