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;
}
