Changeset ca7949b
- Timestamp:
- Mar 6, 2020, 1:46:00 PM (5 years ago)
- Branches:
- ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum
- Children:
- 6b4a1bf
- Parents:
- 63aea5a
- Location:
- libcfa/src
- Files:
-
- 2 edited
-
heap.cfa (modified) (20 diffs)
-
stdlib.hfa (modified) (7 diffs)
Legend:
- Unmodified
- Added
- Removed
-
libcfa/src/heap.cfa
r63aea5a rca7949b 10 10 // Created On : Tue Dec 19 21:58:35 2017 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Tue Feb 4 10:04:51202013 // Update Count : 6 4812 // Last Modified On : Fri Mar 6 10:14:52 2020 13 // Update Count : 650 14 14 // 15 15 … … 819 819 820 820 extern "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(). 824 823 void * malloc( size_t size ) { 825 824 #ifdef __STATISTICS__ … … 831 830 } // malloc 832 831 833 // The calloc() function allocates memory for an array of nmemb elements of size bytes each and returns a pointer to834 // the allocated memory. The memory is set to zero. If nmemb or size is 0, then calloc() returns either 0p, or a835 // unique pointervalue 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(). 836 835 void * calloc( size_t noOfElems, size_t elemSize ) { 837 836 #ifdef __STATISTICS__ … … 843 842 } // calloc 844 843 845 // The realloc() function changes the size of the memory block pointed to by ptr to size bytes. The contents will be846 // unchanged in the range from the start of the region up to the minimum of the old and new sizes. If the new size847 // is larger than the old size, the added memory will not be initialized. If ptr is 0p, then the call is848 // equivalent to malloc(size), for all values of size; if size is equal to zero, and ptr is not 0p, then the call849 // 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 pointedto 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. 851 850 void * realloc( void * oaddr, size_t size ) { 852 851 #ifdef __STATISTICS__ … … 903 902 } // realloc 904 903 905 // The obsolete function memalign() allocates size bytes and returns a pointer to the allocated memory. The memory906 // a ddress 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) 907 906 void * memalign( size_t alignment, size_t size ) { 908 907 #ifdef __STATISTICS__ … … 915 914 916 915 917 // The cmemalign() function is the same as calloc() with memory alignment.916 // Same as calloc() with memory alignment. 918 917 void * cmemalign( size_t alignment, size_t noOfElems, size_t elemSize ) { 919 918 #ifdef __STATISTICS__ … … 925 924 } // cmemalign 926 925 927 // The function aligned_alloc() is the same as memalign(), except for the added restriction that size should be a928 // 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. 929 928 void * aligned_alloc( size_t alignment, size_t size ) { 930 929 return memalign( alignment, size ); … … 932 931 933 932 934 // The function posix_memalign() allocates size bytes and places the address of the allocated memory in *memptr. The935 // address of the allocated memory will be a multiple of alignment, which must be a power of two and a multiple of936 // sizeof(void *). If size is 0, then posix_memalign() returns either 0p, or a unique pointer value that can later937 // be successfully passed tofree(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). 938 937 int posix_memalign( void ** memptr, size_t alignment, size_t size ) { 939 938 if ( alignment < sizeof(void *) || ! libPow2( alignment ) ) return EINVAL; // check alignment … … 943 942 } // posix_memalign 944 943 945 // The obsolete function valloc() allocates size bytes and returns a pointer to the allocated memory. The memory946 // address will be a multiple of thepage 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). 947 946 void * valloc( size_t size ) { 948 947 return memalign( pageSize, size ); … … 950 949 951 950 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. 955 960 void free( void * addr ) { 956 961 #ifdef __STATISTICS__ … … 973 978 974 979 975 // The malloc_alignment() function returns the alignment of the allocation.980 // Returns the alignment of the allocation. 976 981 size_t malloc_alignment( void * addr ) { 977 982 if ( unlikely( addr == 0p ) ) return libAlign(); // minimum alignment … … 985 990 986 991 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(). 988 993 bool malloc_zero_fill( void * addr ) { 989 994 if ( unlikely( addr == 0p ) ) return false; // null allocation is not zero fill … … 996 1001 997 1002 998 // The malloc_usable_size() function returns the number of usable bytes in the block pointed to by ptr, a pointer to999 // 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. 1000 1005 size_t malloc_usable_size( void * addr ) { 1001 1006 if ( unlikely( addr == 0p ) ) return 0; // null allocation has 0 size … … 1009 1014 1010 1015 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. 1013 1017 void malloc_stats( void ) { 1014 1018 #ifdef __STATISTICS__ … … 1018 1022 } // malloc_stats 1019 1023 1020 // The malloc_stats_fd() function changes the file descripter where malloc_stats() writes thestatistics.1024 // Changes the file descripter where malloc_stats() writes statistics. 1021 1025 int malloc_stats_fd( int fd __attribute__(( unused )) ) { 1022 1026 #ifdef __STATISTICS__ … … 1030 1034 1031 1035 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. 1035 1038 int mallopt( int option, int value ) { 1036 1039 choose( option ) { … … 1043 1046 } // mallopt 1044 1047 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). 1047 1049 int malloc_trim( size_t ) { 1048 1050 return 0; // => impossible to release memory … … 1050 1052 1051 1053 1052 // The malloc_info() function exports an XML string that describes the current state of the memory-allocation1053 // implementation in the caller. The string is printed on the file stream stream. The exported string includes1054 // 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). 1055 1057 int malloc_info( int options, FILE * stream ) { 1056 1058 if ( options != 0 ) { errno = EINVAL; return -1; } … … 1059 1061 1060 1062 1061 // The malloc_get_state() function records the current state of all malloc(3) internal bookkeeping variables (but1062 // not the actual contents of the heap or the state of malloc_hook(3) functions pointers). The state is recorded in1063 // a system-dependent opaque data structure dynamically allocated via malloc(3), and a pointer to that data1064 // 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.) 1065 1067 void * malloc_get_state( void ) { 1066 1068 return 0p; // unsupported … … 1068 1070 1069 1071 1070 // The malloc_set_state() function restores the state of all malloc(3) internal bookkeeping variables to the values1071 // recorded in the opaque datastructure 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. 1072 1074 int malloc_set_state( void * ptr ) { 1073 1075 return 0; // unsupported -
libcfa/src/stdlib.hfa
r63aea5a rca7949b 10 10 // Created On : Thu Jan 28 17:12:35 2016 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : T ue Feb 4 08:27:01202013 // Update Count : 40 112 // Last Modified On : Thu Mar 5 11:29:06 2020 13 // Update Count : 407 14 14 // 15 15 … … 21 21 #include <stdlib.h> // *alloc, strto*, ato* 22 22 23 // Reduce includes by explicitly defining these routines. 23 24 extern "C" { 24 25 void * memalign( size_t align, size_t size ); // malloc.h 26 void * cmemalign( size_t alignment, size_t noOfElems, size_t elemSize ); // CFA heap 25 27 void * memset( void * dest, int fill, size_t size ); // string.h 26 28 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 heap28 29 } // extern "C" 29 30 … … 40 41 41 42 static inline forall( dtype T | sized(T) ) { 42 // C dynamic allocation43 // Cforall safe equivalents, i.e., implicit size specification 43 44 44 45 T * malloc( void ) { … … 72 73 } // posix_memalign 73 74 74 // Cforall dynamic allocation75 // Cforall safe general allocation, fill, resize, array 75 76 76 77 T * alloc( void ) { … … 159 160 160 161 static inline forall( dtype T | sized(T) ) { 161 // data, non-array types162 // Cforall safe initialization/copy, i.e., implicit size specification, non-array types 162 163 T * memset( T * dest, char fill ) { 163 164 return (T *)memset( dest, fill, sizeof(T) ); … … 170 171 171 172 static inline forall( dtype T | sized(T) ) { 172 // data, array types173 // Cforall safe initialization/copy, i.e., implicit size specification, array types 173 174 T * amemset( T dest[], char fill, size_t dim ) { 174 175 return (T *)(void *)memset( dest, fill, dim * sizeof(T) ); // C memset … … 180 181 } // distribution 181 182 182 // allocation/deallocation and constructor/destructor, non-array types183 // Cforall allocation/deallocation and constructor/destructor, non-array types 183 184 forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * new( Params p ); 184 185 forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void delete( T * ptr ); 185 186 forall( dtype T, ttype Params | sized(T) | { void ^?{}( T & ); void delete( Params ); } ) void delete( T * ptr, Params rest ); 186 187 187 // allocation/deallocation and constructor/destructor, array types188 // Cforall allocation/deallocation and constructor/destructor, array types 188 189 forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * anew( size_t dim, Params p ); 189 190 forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void adelete( size_t dim, T arr[] );
Note: See TracChangeset
for help on using the changeset viewer.
