GLFFTWater::~GLFFTWater() { fftwf_free(m_htilde0); #ifdef _WIN32 __mingw_aligned_free(m_w); __mingw_aligned_free(m_h); __mingw_aligned_free(m_dx); __mingw_aligned_free(m_dz); #endif delete[] m_kz; delete[] m_heightmap; delete[] m_kx; }
/* * * Memory management for arrays. Aligns if using SIMD parallelization.. * * * * Memory allocated by these routines must be free'd by agbnp3_vfree() * * */ void agbnp3_vfree(void *x){ #ifdef __MINGW32__ if(x) __mingw_aligned_free(x); #else if(x) free(x); #endif }
static __inline void free_buffer(void* p) { #ifdef __MINGW32__ __mingw_aligned_free(p); #else _aligned_free(p); #endif }
void visual_mem_free_aligned (void* block) { #ifndef VISUAL_WITH_MINGW return _aligned_free (block); #else return __mingw_aligned_free (block); #endif }
void av_free(void *ptr) { /* XXX: this test should not be needed on most libcs */ if (ptr) #ifndef __GNUC__ _aligned_free(ptr); #else __mingw_aligned_free(ptr); #endif }
void av_free(void *ptr) { #if CONFIG_MEMALIGN_HACK if (ptr) free((char*)ptr - ((char*)ptr)[-1]); #elif HAVE_ALIGNED_MALLOC //_aligned_free(ptr); __mingw_aligned_free(ptr); // MPC-HC patch #else free(ptr); #endif }
void CL_System::aligned_free(void *ptr) { if (ptr) { #if defined _MSC_VER || (defined __MINGW32__ && __MSVCRT_VERSION__ >= 0x0700) _aligned_free(ptr); #elif defined __MINGW32__ __mingw_aligned_free (ptr); #else free(ptr); #endif } }
void freeJSBlock(void* address) { #if defined(OLYMPIA_LINUX)// || defined(OLYMPIA_MAC) munmap(reinterpret_cast<char*>(address), BLOCK_SIZE); #elif defined(OLYMPIA_WINDOWS) #if COMPILER(MINGW) && !COMPILER(MINGW64) __mingw_aligned_free(block); #else _aligned_free(address); #endif #elif defined(OLYMPIA_MAC) vm_deallocate(current_task(), reinterpret_cast<vm_address_t>(address), BLOCK_SIZE); #endif }
_cl_mem::~_cl_mem() { std::deque<FreeOCL::mem_call_back> call_backs; call_backs.swap(this->call_backs); unlock(); for(std::deque<FreeOCL::mem_call_back>::const_iterator i = call_backs.begin() ; i != call_backs.end() ; ++i) i->pfn_notify(this, i->user_data); FreeOCL::global_mutex.lock(); FreeOCL::valid_mems.erase(this); FreeOCL::global_mutex.unlock(); if (ptr && !parent && !(flags & CL_MEM_USE_HOST_PTR) && mem_type != CL_MEM_OBJECT_IMAGE1D_BUFFER) { #ifdef FREEOCL_OS_WINDOWS __mingw_aligned_free(ptr); #else free(ptr); #endif ptr = NULL; } }
void FreeImage_Aligned_Free(void* mem) { __mingw_aligned_free (mem); }
void dealloc(OBJECT_PTR ptr) { unsigned int prev_words_deallocated = words_deallocated; if(!is_valid_object(ptr)) { printf("%d\n", ptr); assert(false); } unsigned int tag = ptr & BIT_MASK; OBJECT_PTR array_size; switch(tag) { case CONS_TAG: words_deallocated += 2; break; case ARRAY_TAG: array_size = *((OBJECT_PTR *)extract_ptr(ptr)); words_deallocated += (array_size + 1); break; case CLOSURE_TAG: words_deallocated += 4; break; case MACRO_TAG: words_deallocated += 4; break; case CONTINUATION_TAG: words_deallocated += 1; break; case INTEGER_TAG: words_deallocated += 1; break; case FLOAT_TAG: words_deallocated += 1; break; /* case FUNCTION2_TAG: */ /* words_allocated += 2; */ /* break; */ /* case MACRO2_TAG: */ /* words_allocated += 2; */ /* break; */ case NATIVE_FN_TAG: words_deallocated += 1; break; default: assert(false); } uintptr_t p = extract_ptr(ptr); int i; for(i=0; i < words_deallocated - prev_words_deallocated; i++) *((OBJECT_PTR *)p+i) = 0xFEEEFEEE; #ifdef WIN32 __mingw_aligned_free((void *)extract_ptr(ptr)); #else free((void *)extract_ptr(ptr)); #endif }
void av_free(void *ptr) { __mingw_aligned_free(ptr); }
int misc_bio_initialize(misc_binaryIO* bio, const char* fileName, int openFlag, int permissionsFlag) { if (bio == NULL) return EFAULT; bio->buffer = NULL; bio->bufferLength = 0; bio->fileDescriptor = open(fileName, openFlag, permissionsFlag); if (bio->fileDescriptor == -1) return errno; errno = 0; #ifdef _WIN32 SYSTEM_INFO si; GetSystemInfo(&si); long pageSize = si.dwPageSize; #elif defined(_SC_PAGE_SIZE) long pageSize = sysconf(_SC_PAGE_SIZE); #elif defined(_SC_PAGESIZE) long pageSize = sysconf(_SC_PAGESIZE) #else long pageSize = 4096; #endif if (pageSize <= 0 || errno != 0) pageSize = 4096; // sure, why not? bio->bufferLength = (size_t) pageSize; // practically needs to hold at least one 64 bit int while (bio->bufferLength < sizeof(uint64_t)) bio->bufferLength <<= 1; size_t alignment = sizeof(uint64_t); if (alignment % sizeof(void*) != 0) alignment *= sizeof(void*); #ifdef HAVE_POSIX_MEMALIGN int errorCode = posix_memalign(&bio->buffer, alignment, bio->bufferLength); if (errorCode != 0) { if (bio->buffer != NULL) free(bio->buffer); #elif defined(__MINGW32__) bio->buffer = __mingw_aligned_malloc(bio->bufferLength, alignment); if (bio->buffer == NULL) { int errorCode = ENOMEM; #else bio->buffer = memalign(alignment, bio->bufferLength); if (bio->buffer == NULL) { int errorCode = ENOMEM; #endif close(bio->fileDescriptor); bio->fileDescriptor = -1; bio->bufferLength = 0; return errorCode; } return 0; } void misc_bio_invalidate(misc_binaryIO* bio) { if (bio == NULL) return; if (bio->fileDescriptor != -1) { close(bio->fileDescriptor); bio->fileDescriptor = -1; } if (bio->buffer != NULL) { #if defined(HAVE_POSIX_MEMALIGN) || !defined(__MINGW32__) free(bio->buffer); #else __mingw_aligned_free(bio->buffer); #endif bio->buffer = NULL; } bio->bufferLength = 0; } int misc_bio_writeChar(misc_binaryIO* bio, char c) { if (bio == NULL) return EFAULT; ssize_t bytesWritten = write(bio->fileDescriptor, &c, sizeof(char)); if (bytesWritten == 0) return EIO; if (bytesWritten < 0) return errno; return 0; } int misc_bio_writeChars(misc_binaryIO* bio, const char* c, size_t length) { if (bio == NULL) return EFAULT; int errorCode = misc_bio_writeSizeType(bio, length); if (errorCode != 0) return errorCode; return misc_bio_writeNChars(bio, c, length); } int misc_bio_writeNChars(misc_binaryIO* bio, const char* c, size_t length) { if (bio == NULL) return EFAULT; size_t totalBytesWritten = 0; while (totalBytesWritten < length) { ssize_t bytesWritten = write(bio->fileDescriptor, c + totalBytesWritten, length - totalBytesWritten); if (bytesWritten == 0) return EIO; if (bytesWritten < 0) return errno; totalBytesWritten += (size_t) bytesWritten; } return 0; } int misc_bio_writeSizeType(misc_binaryIO* bio, size_t s) { uint64_t u = (uint64_t) s; #ifndef WORDS_BIGENDIAN swapEndiannessFor8ByteWord((char*) &u); #endif ssize_t bytesWritten = write(bio->fileDescriptor, &u, sizeof(uint64_t)); if (bytesWritten == 0) return EIO; if (bytesWritten < 0) return errno; return 0; } int misc_bio_writeSizeTypes(misc_binaryIO* bio, const size_t* v, size_t length) { if (bio == NULL) return EFAULT; int errorCode = misc_bio_writeSizeType(bio, length); if (errorCode != 0) return errorCode; return misc_bio_writeNSizeTypes(bio, v, length); } int misc_bio_writeNSizeTypes(misc_binaryIO* bio, const size_t* v, size_t length) { if (bio == NULL) return EFAULT; size_t totalItemsWritten = 0; while (totalItemsWritten < length) { size_t itemsWritten = fillBufferFromSizeTypes(bio, v + totalItemsWritten, length - totalItemsWritten); size_t totalBytesWritten = 0; size_t bytesToWrite = itemsWritten * sizeof(uint64_t); while (totalBytesWritten < bytesToWrite) { ssize_t bytesWritten = write(bio->fileDescriptor, (char*) bio->buffer, bytesToWrite - totalBytesWritten); if (bytesWritten == 0) return EIO; if (bytesWritten < 0) return errno; totalBytesWritten += (size_t) bytesWritten; } totalItemsWritten += itemsWritten; } return 0; } int misc_bio_writeUnsigned32BitInteger(misc_binaryIO* bio, uint32_t u) { #ifndef WORDS_BIGENDIAN swapEndiannessFor4ByteWord((char*) &u); #endif ssize_t bytesWritten = write(bio->fileDescriptor, &u, sizeof(uint32_t)); if (bytesWritten == 0) return EIO; if (bytesWritten < 0) return errno; return 0; }