Changeset ca7949b


Ignore:
Timestamp:
Mar 6, 2020, 1:46:00 PM (19 months ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
arm-eh, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr
Children:
6b4a1bf
Parents:
63aea5a
Message:

update comments

Location:
libcfa/src
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • libcfa/src/heap.cfa

    r63aea5a rca7949b  
    1010// Created On       : Tue Dec 19 21:58:35 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Feb  4 10:04:51 2020
    13 // Update Count     : 648
     12// Last Modified On : Fri Mar  6 10:14:52 2020
     13// Update Count     : 650
    1414//
    1515
     
    819819
    820820extern "C" {
    821         // The malloc() function allocates size bytes and returns a pointer to the allocated memory. The memory is not
    822         // initialized. If size is 0, then malloc() returns either 0p, or a unique pointer value that can later be
    823         // successfully passed to free().
     821        // Allocates size bytes and returns a pointer to the allocated memory. The memory is not initialized. If size is 0,
     822        // then malloc() returns either 0p, or a unique pointer value that can later be successfully passed to free().
    824823        void * malloc( size_t size ) {
    825824                #ifdef __STATISTICS__
     
    831830        } // malloc
    832831
    833         // The calloc() function allocates memory for an array of nmemb elements of size bytes each and returns a pointer to
    834         // the allocated memory. The memory is set to zero. If nmemb or size is 0, then calloc() returns either 0p, or a
    835         // unique pointer value that can later be successfully passed to free().
     832        // Allocate memory for an array of nmemb elements of size bytes each and returns a pointer to the allocated
     833        // memory. The memory is set to zero. If nmemb or size is 0, then calloc() returns either 0p, or a unique pointer
     834        // value that can later be successfully passed to free().
    836835        void * calloc( size_t noOfElems, size_t elemSize ) {
    837836                #ifdef __STATISTICS__
     
    843842        } // calloc
    844843
    845         // The realloc() function changes the size of the memory block pointed to by ptr to size bytes. The contents will be
    846         // unchanged in the range from the start of the region up to the minimum of the old and new sizes. If the new size
    847         // is larger than the old size, the added memory will not be initialized.  If ptr is 0p, then the call is
    848         // equivalent to malloc(size), for all values of size; if size is equal to zero, and ptr is not 0p, then the call
    849         // is equivalent to free(ptr). Unless ptr is 0p, it must have been returned by an earlier call to malloc(),
    850         // calloc() or realloc(). If the area pointed to was moved, a free(ptr) is done.
     844        // Change the size of the memory block pointed to by ptr to size bytes. The contents shall be unchanged in the range
     845        // from the start of the region up to the minimum of the old and new sizes. If the new size is larger than the old
     846        // size, the added memory shall not be initialized.  If ptr is 0p, then the call is equivalent to malloc(size), for
     847        // all values of size; if size is equal to zero, and ptr is not 0p, then the call is equivalent to free(ptr). Unless
     848        // ptr is 0p, it must have been returned by an earlier call to malloc(), calloc() or realloc(). If the area pointed
     849        // to was moved, a free(ptr) is done.
    851850        void * realloc( void * oaddr, size_t size ) {
    852851                #ifdef __STATISTICS__
     
    903902        } // realloc
    904903
    905         // The obsolete function memalign() allocates size bytes and returns a pointer to the allocated memory. The memory
    906         // address will be a multiple of alignment, which must be a power of two.
     904        // Allocates size bytes and returns a pointer to the allocated memory. The memory address shall be a multiple of
     905        // alignment, which must be a power of two. (obsolete)
    907906        void * memalign( size_t alignment, size_t size ) {
    908907                #ifdef __STATISTICS__
     
    915914
    916915
    917         // The cmemalign() function is the same as calloc() with memory alignment.
     916        // Same as calloc() with memory alignment.
    918917        void * cmemalign( size_t alignment, size_t noOfElems, size_t elemSize ) {
    919918                #ifdef __STATISTICS__
     
    925924        } // cmemalign
    926925
    927         // The function aligned_alloc() is the same as memalign(), except for the added restriction that size should be a
    928         // multiple of alignment.
     926        // Same as memalign(), but ISO/IEC 2011 C11 Section 7.22.2 states: the value of size shall be an integral multiple
     927    // of alignment. This requirement is universally ignored.
    929928        void * aligned_alloc( size_t alignment, size_t size ) {
    930929                return memalign( alignment, size );
     
    932931
    933932
    934         // The function posix_memalign() allocates size bytes and places the address of the allocated memory in *memptr. The
    935         // address of the allocated memory will be a multiple of alignment, which must be a power of two and a multiple of
    936         // sizeof(void *). If size is 0, then posix_memalign() returns either 0p, or a unique pointer value that can later
    937         // be successfully passed to free(3).
     933        // Allocates size bytes and places the address of the allocated memory in *memptr. The address of the allocated
     934        // memory shall be a multiple of alignment, which must be a power of two and a multiple of sizeof(void *). If size
     935        // is 0, then posix_memalign() returns either 0p, or a unique pointer value that can later be successfully passed to
     936        // free(3).
    938937        int posix_memalign( void ** memptr, size_t alignment, size_t size ) {
    939938          if ( alignment < sizeof(void *) || ! libPow2( alignment ) ) return EINVAL; // check alignment
     
    943942        } // posix_memalign
    944943
    945         // The obsolete function valloc() allocates size bytes and returns a pointer to the allocated memory. The memory
    946         // address will be a multiple of the page size.  It is equivalent to memalign(sysconf(_SC_PAGESIZE),size).
     944        // Allocates size bytes and returns a pointer to the allocated memory. The memory address shall be a multiple of the
     945        // page size.  It is equivalent to memalign(sysconf(_SC_PAGESIZE),size).
    947946        void * valloc( size_t size ) {
    948947                return memalign( pageSize, size );
     
    950949
    951950
    952         // The free() function frees the memory space pointed to by ptr, which must have been returned by a previous call to
    953         // malloc(), calloc() or realloc().  Otherwise, or if free(ptr) has already been called before, undefined behavior
    954         // occurs. If ptr is 0p, no operation is performed.
     951        // Same as valloc but rounds size to multiple of page size.
     952        void * pvalloc( size_t size ) {
     953                return memalign( pageSize, libCeiling( size, pageSize ) );
     954        } // pvalloc
     955
     956
     957        // Frees the memory space pointed to by ptr, which must have been returned by a previous call to malloc(), calloc()
     958        // or realloc().  Otherwise, or if free(ptr) has already been called before, undefined behavior occurs. If ptr is
     959        // 0p, no operation is performed.
    955960        void free( void * addr ) {
    956961                #ifdef __STATISTICS__
     
    973978
    974979
    975         // The malloc_alignment() function returns the alignment of the allocation.
     980        // Returns the alignment of the allocation.
    976981        size_t malloc_alignment( void * addr ) {
    977982          if ( unlikely( addr == 0p ) ) return libAlign();      // minimum alignment
     
    985990
    986991
    987         // The malloc_zero_fill() function returns true if the allocation is zero filled, i.e., initially allocated by calloc().
     992        // Returns true if the allocation is zero filled, i.e., initially allocated by calloc().
    988993        bool malloc_zero_fill( void * addr ) {
    989994          if ( unlikely( addr == 0p ) ) return false;           // null allocation is not zero fill
     
    9961001
    9971002
    998         // The malloc_usable_size() function returns the number of usable bytes in the block pointed to by ptr, a pointer to
    999         // a block of memory allocated by malloc(3) or a related function.
     1003        // Returns the number of usable bytes in the block pointed to by ptr, a pointer to a block of memory allocated by
     1004        // malloc or a related function.
    10001005        size_t malloc_usable_size( void * addr ) {
    10011006          if ( unlikely( addr == 0p ) ) return 0;                       // null allocation has 0 size
     
    10091014
    10101015
    1011         // The malloc_stats() function prints (on default standard error) statistics about memory allocated by malloc(3) and
    1012         // related functions.
     1016        // Prints (on default standard error) statistics about memory allocated by malloc and related functions.
    10131017        void malloc_stats( void ) {
    10141018                #ifdef __STATISTICS__
     
    10181022        } // malloc_stats
    10191023
    1020         // The malloc_stats_fd() function changes the file descripter where malloc_stats() writes the statistics.
     1024        // Changes the file descripter where malloc_stats() writes statistics.
    10211025        int malloc_stats_fd( int fd __attribute__(( unused )) ) {
    10221026                #ifdef __STATISTICS__
     
    10301034
    10311035
    1032         // The mallopt() function adjusts parameters that control the behavior of the memory-allocation functions (see
    1033         // malloc(3)). The param argument specifies the parameter to be modified, and value specifies the new value for that
    1034         // parameter.
     1036        // Adjusts parameters that control the behavior of the memory-allocation functions (see malloc). The param argument
     1037        // specifies the parameter to be modified, and value specifies the new value for that parameter.
    10351038        int mallopt( int option, int value ) {
    10361039                choose( option ) {
     
    10431046        } // mallopt
    10441047
    1045         // The malloc_trim() function attempts to release free memory at the top of the heap (by calling sbrk(2) with a
    1046         // suitable argument).
     1048        // Attempt to release free memory at the top of the heap (by calling sbrk with a suitable argument).
    10471049        int malloc_trim( size_t ) {
    10481050                return 0;                                                                               // => impossible to release memory
     
    10501052
    10511053
    1052         // The malloc_info() function exports an XML string that describes the current state of the memory-allocation
    1053         // implementation in the caller.  The string is printed on the file stream stream.  The exported string includes
    1054         // information about all arenas (see malloc(3)).
     1054        // Exports an XML string that describes the current state of the memory-allocation implementation in the caller.
     1055        // The string is printed on the file stream stream.  The exported string includes information about all arenas (see
     1056        // malloc).
    10551057        int malloc_info( int options, FILE * stream ) {
    10561058                if ( options != 0 ) { errno = EINVAL; return -1; }
     
    10591061
    10601062
    1061         // The malloc_get_state() function records the current state of all malloc(3) internal bookkeeping variables (but
    1062         // not the actual contents of the heap or the state of malloc_hook(3) functions pointers).  The state is recorded in
    1063         // a system-dependent opaque data structure dynamically allocated via malloc(3), and a pointer to that data
    1064         // structure is returned as the function result.  (It is the caller's responsibility to free(3) this memory.)
     1063        // Records the current state of all malloc internal bookkeeping variables (but not the actual contents of the heap
     1064        // or the state of malloc_hook functions pointers).  The state is recorded in a system-dependent opaque data
     1065        // structure dynamically allocated via malloc, and a pointer to that data structure is returned as the function
     1066        // result.  (The caller must free this memory.)
    10651067        void * malloc_get_state( void ) {
    10661068                return 0p;                                                                              // unsupported
     
    10681070
    10691071
    1070         // The malloc_set_state() function restores the state of all malloc(3) internal bookkeeping variables to the values
    1071         // recorded in the opaque data structure pointed to by state.
     1072        // Restores the state of all malloc internal bookkeeping variables to the values recorded in the opaque data
     1073        // structure pointed to by state.
    10721074        int malloc_set_state( void * ptr ) {
    10731075                return 0;                                                                               // unsupported
  • libcfa/src/stdlib.hfa

    r63aea5a rca7949b  
    1010// Created On       : Thu Jan 28 17:12:35 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Feb  4 08:27:01 2020
    13 // Update Count     : 401
     12// Last Modified On : Thu Mar  5 11:29:06 2020
     13// Update Count     : 407
    1414//
    1515
     
    2121#include <stdlib.h>                                                                             // *alloc, strto*, ato*
    2222
     23// Reduce includes by explicitly defining these routines.
    2324extern "C" {
    2425        void * memalign( size_t align, size_t size );           // malloc.h
     26    void * cmemalign( size_t alignment, size_t noOfElems, size_t elemSize ); // CFA heap
    2527        void * memset( void * dest, int fill, size_t size ); // string.h
    2628        void * memcpy( void * dest, const void * src, size_t size ); // string.h
    27     void * cmemalign( size_t alignment, size_t noOfElems, size_t elemSize ); // CFA heap
    2829} // extern "C"
    2930
     
    4041
    4142static inline forall( dtype T | sized(T) ) {
    42         // C dynamic allocation
     43        // Cforall safe equivalents, i.e., implicit size specification
    4344
    4445        T * malloc( void ) {
     
    7273        } // posix_memalign
    7374
    74         // Cforall dynamic allocation
     75        // Cforall safe general allocation, fill, resize, array
    7576
    7677        T * alloc( void ) {
     
    159160
    160161static inline forall( dtype T | sized(T) ) {
    161         // data, non-array types
     162        // Cforall safe initialization/copy, i.e., implicit size specification, non-array types
    162163        T * memset( T * dest, char fill ) {
    163164                return (T *)memset( dest, fill, sizeof(T) );
     
    170171
    171172static inline forall( dtype T | sized(T) ) {
    172         // data, array types
     173        // Cforall safe initialization/copy, i.e., implicit size specification, array types
    173174        T * amemset( T dest[], char fill, size_t dim ) {
    174175                return (T *)(void *)memset( dest, fill, dim * sizeof(T) ); // C memset
     
    180181} // distribution
    181182
    182 // allocation/deallocation and constructor/destructor, non-array types
     183// Cforall allocation/deallocation and constructor/destructor, non-array types
    183184forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * new( Params p );
    184185forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void delete( T * ptr );
    185186forall( dtype T, ttype Params | sized(T) | { void ^?{}( T & ); void delete( Params ); } ) void delete( T * ptr, Params rest );
    186187
    187 // allocation/deallocation and constructor/destructor, array types
     188// Cforall allocation/deallocation and constructor/destructor, array types
    188189forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * anew( size_t dim, Params p );
    189190forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void adelete( size_t dim, T arr[] );
Note: See TracChangeset for help on using the changeset viewer.