int posix_memalign(void **memptr, size_t alignment, size_t size) { int ret; if( !chpl_mem_inited() ) { *memptr = NULL; ret = chpl_posix_memalign_check_valid(alignment); if( ret ) return ret; *memptr = __libc_memalign(alignment, size); if( ! *memptr ) return ENOMEM; if( DEBUG_REPLACE_MALLOC ) printf("in early posix_memalign %p = system posix_memalign(%#x)\n", *memptr, (int) size); track_system_allocated(*memptr, size, __libc_malloc); return 0; } if( DEBUG_REPLACE_MALLOC ) printf("in posix_memalign\n"); ret = chpl_posix_memalign(memptr, alignment, size); if( DEBUG_REPLACE_MALLOC ) printf("%p = chpl_posix_memalign(%#x, %#x) returned %i\n", *memptr, (int) alignment, (int) size, ret); return ret; }
void chpl_memhook_check_pre(size_t number, size_t size, chpl_mem_descInt_t description, int32_t lineno, c_string filename) { if (!chpl_mem_inited()) chpl_error("memory routine called before the memory layer is initialized", lineno, filename); if (number > 0 && size > SIZE_MAX/number) chpl_error("Attempting to allocate > max(size_t) bytes of memory", lineno, filename); }
void* memalign(size_t alignment, size_t size) { if( !chpl_mem_inited() ) { void* ret = __libc_memalign(alignment, size); if( DEBUG_REPLACE_MALLOC ) printf("in early memalign %p = system memalign(%#x)\n", ret, (int) size); track_system_allocated(ret, size, __libc_malloc); return ret; } if( DEBUG_REPLACE_MALLOC ) printf("in memalign\n"); return chpl_memalign(alignment, size); }
void* pvalloc(size_t size) { if( !chpl_mem_inited() ) { void* ret = __libc_pvalloc(size); if( DEBUG_REPLACE_MALLOC ) printf("in early pvalloc %p = system pvalloc(%#x)\n", ret, (int) size); track_system_allocated(ret, size, __libc_malloc); return ret; } if( DEBUG_REPLACE_MALLOC ) printf("in pvalloc\n"); return chpl_pvalloc(size); }
void free(void* ptr) { if( ! ptr ) return; if( DEBUG_REPLACE_MALLOC ) printf("in free(%p)\n", ptr); // check to see if we're freeing a pointer that was allocated // before the our allocator came up. if( !chpl_mem_inited() || is_system_allocated(ptr, NULL) ) { if( DEBUG_REPLACE_MALLOC ) printf("calling system free\n"); __libc_free(ptr); return; } if( DEBUG_REPLACE_MALLOC ) printf("calling chpl_free\n"); chpl_free(ptr); }
void* realloc(void* ptr, size_t size) { if( !chpl_mem_inited() ) { void* ret = __libc_realloc(ptr, size); if( DEBUG_REPLACE_MALLOC ) printf("in early realloc %p = system realloc(%p,%#x)\n", ret, ptr, (int) size); track_system_allocated(ret, size, __libc_malloc); return ret; } else { void* ret = NULL; size_t allocated_len = 0; size_t copy_size; if( DEBUG_REPLACE_MALLOC ) printf("in realloc(%p,%#x)\n", ptr, (int) size); // check to see if we're realloc'ing a pointer that was allocated // before the our allocator came up. if( is_system_allocated(ptr, &allocated_len) ) { if( DEBUG_REPLACE_MALLOC ) { printf("in realloc, ptr %p was system allocated to size %#x\n", ptr, (int) allocated_len); } // allocate some new memory on the Chapel heap ret = chpl_malloc(size); // copy the minimum of allocated_len and size // to handle realloc expanding or shrinking the allocation copy_size = allocated_len; if( size < copy_size ) copy_size = size; memcpy(ret, ptr, copy_size); // free the old pointer from the system heap. __libc_free(ptr); return ret; } else { return chpl_realloc(ptr, size); } } }
void* calloc(size_t n, size_t size) { void* ret; if( !chpl_mem_inited() ) { ret = __libc_calloc(n, size); if( DEBUG_REPLACE_MALLOC ) printf("in early calloc %p = system calloc(%#x)\n", ret, (int) (n*size)); track_system_allocated(ret, n*size, __libc_malloc); return ret; } if( DEBUG_REPLACE_MALLOC ) printf("in calloc\n"); ret = chpl_calloc(n, size); if( DEBUG_REPLACE_MALLOC ) printf("%p = chpl_calloc(%#x)\n", ret, (int) (n*size)); return ret; }