_WCRTLINK int _nheapchk( void )
{
struct _heapinfo hi;
int heap_status;
size_t free_size;
_AccessNHeap();
heap_status = checkFreeList( &free_size );
if( heap_status != _HEAPOK ) {
_ReleaseNHeap();
return( heap_status );
}
hi._pentry = NULL;
for(;;) {
heap_status = __NHeapWalk( &hi, __nheapbeg );
if( heap_status != _HEAPOK ) break;
if( hi._useflag == _FREEENTRY ) {
heap_status = checkFree( (frlptr) hi._pentry );
if( heap_status != _HEAPOK ) break;
free_size -= hi._size;
}
}
if( free_size != 0 ) {
heap_status = _HEAPBADNODE;
} else if( heap_status == _HEAPBADPTR ) {
heap_status = _HEAPBADNODE;
} else {
if( heap_status == _HEAPEND ) {
heap_status = _HEAPOK;
}
}
_ReleaseNHeap();
return( heap_status );
}
_WCRTLINK int _fheapchk( void )
{
struct _heapinfo hi;
int heap_status;
unsigned long free_size;
_AccessFHeap();
heap_status = checkFreeList( &free_size );
if( heap_status != _HEAPOK ) {
_ReleaseFHeap();
return( heap_status );
}
hi._pentry = NULL;
while( (heap_status = __HeapWalk( &hi, __fheapbeg, _NULLSEG )) == _HEAPOK ) {
if( hi._useflag == _FREEENTRY ) {
heap_status = checkFree( hi._pentry );
if( heap_status != _HEAPOK )
break;
free_size -= hi._size;
}
}
if( free_size != 0 ) {
heap_status = _HEAPBADNODE;
} else if( heap_status == _HEAPBADPTR ) {
heap_status = _HEAPBADNODE;
} else if( heap_status == _HEAPEND ) {
heap_status = _HEAPOK;
}
_ReleaseFHeap();
return( heap_status );
}
void validateFreeList( heapAllocator* heap ) {
block* b = heap->first;
while ( b ) {
if ( b->free ) {
checkFree( heap, b );
}
b = b->next;
}
}
void checkFreeList(struct check **pList)
/* Free a list of dynamically allocated check's */
{
struct check *el, *next;
for (el = *pList; el != NULL; el = next)
{
next = el->next;
checkFree(&el);
}
*pList = NULL;
}
// Release a block from the heapAllocator
void heap_deallocate( heapAllocator* heap, void* data ) {
if ( data == NULL )
return;
vmutex_lock( &allocator_mutex );
// Check if it's in a bitpool
bitpool* bit_pool = heap_findBitpoolForData( heap, data );
if ( bit_pool ) {
bitpool_free( bit_pool, data );
vmutex_unlock( &allocator_mutex );
return;
}
block* b = (block*)((uint8_t*)data - sizeof( block ));
vAssert( !b->free );
assertBlockInvariants( b );
#ifdef MEM_DEBUG_VERBOSE
printf("Allocator freed address: " xPTRf ".\n", (uintptr_t)b->data );
#endif
b->free = true;
addToFreeList( heap, b );
heap->total_free += b->size;
heap->total_allocated -= b->size;
checkFree( heap, b );
// Try to merge blocks
if ( b->next && b->next->free ) {
checkFree( heap, b->next );
blockMerge( heap, b, b->next );
}
if ( b->prev && b->prev->free ) {
checkFree( heap, b->prev );
blockMerge( heap, b->prev, b );
}
--heap->allocations;
vmutex_unlock( &allocator_mutex );
}
template<> Uint8ClampedArray* CData::getValue<Uint8ClampedArray>()
{
cl_int err_code;
#ifdef PREALLOCATE_IN_JS_HEAP
void* mem;
#endif // PREALLOCATE_IN_JS_HEAP
if (m_theUint8ClampedArray.get()) {
#ifdef PREALLOCATE_IN_JS_HEAP
if (false && !m_isMapped) {
DEBUG_LOG_STATUS("getValue", "memory is " << m_theUint8ClampedArray.get());
void* mem = clEnqueueMapBuffer(m_queue, m_memObj, CL_TRUE, CL_MAP_READ, 0, m_size, 0, 0, 0, &err_code);
if (err_code != CL_SUCCESS) {
DEBUG_LOG_ERROR("getValue", err_code);
return 0;
}
#ifndef DEBUG_OFF
if (mem != m_theUint8ClampedArray->data())
DEBUG_LOG_STATUS("getValue", "EnqueueMap returned wrong pointer");
#endif // DEBUG_OFF
m_isMapped = true;
}
#endif // PREALLOCATE_IN_JS_HEAP
return m_theUint8ClampedArray.get();
} else {
#ifdef INCREMENTAL_MEM_RELEASE
checkFree();
#endif // INCREMENTAL_MEM_RELEASE
if (m_parent->createAlignedTA<Uint8ClampedArray, unsigned char>(m_type, m_length, m_theUint8ClampedArray) != RT_OK)
return 0;
if (!m_theUint8ClampedArray) {
DEBUG_LOG_STATUS("getValue", "Cannot create typed array");
return 0;
}
err_code = enqueueReadBuffer(m_size, m_theUint8ClampedArray->data());
if (err_code != CL_SUCCESS) {
DEBUG_LOG_ERROR("getValue", err_code);
m_theUint8ClampedArray.clear();
return 0;
}
DEBUG_LOG_STATUS("getValue", "materialized typed array");
return m_theUint8ClampedArray.get();
}
}
mama_status
mamaDictionary_destroy (mamaDictionary dictionary)
{
uint32_t i = 0;
if (dictionary == NULL) return MAMA_STATUS_OK;
if (self->mDict)
{
for (i = 0; i <= self->mMaxFid; ++i)
{
if (self->mDict[i] )
{
mamaFieldDescriptor_destroy (self->mDict[i]);
}
}
}
if (self->mSubscription)
{
mamaSubscription_destroy (self->mSubscription);
mamaSubscription_deallocate (self->mSubscription);
}
if (self->mDict)
{
free(self->mDict);
}
checkFree(&self->mFeedName);
checkFree(&self->mFeedHost);
memset (self, 0, sizeof( mamaDictionaryImpl));
free (self);
return MAMA_STATUS_OK;
}
cl_int CData::enqueueReadBuffer(size_t size, void* ptr)
{
#ifdef INCREMENTAL_MEM_RELEASE
cl_int err_code;
int freed;
do {
freed = checkFree();
err_code = clEnqueueReadBuffer(m_queue, m_memObj, CL_TRUE, 0, size, ptr, 0, 0, 0);
} while (((err_code == CL_MEM_OBJECT_ALLOCATION_FAILURE) || (err_code == CL_OUT_OF_HOST_MEMORY)) && freed);
return err_code;
#else // INCREMENTAL_MEM_RELEASE
return clEnqueueReadBuffer(m_queue, m_memObj, CL_TRUE, 0, size, ptr, 0, 0, 0);
#endif // INCREMENTAL_MEM_RELEASE
}
static BOOL COFFLibLoad(PFILE libfile,PMODULE mod,BOOL isDjgpp)
{
UINT i,j;
UINT numsyms;
UINT modpage;
UINT memberSize;
UINT startPoint;
PUCHAR endptr;
PCHAR name;
PUCHAR modbuf;
PUCHAR longnames;
PPSYMBOL symlist;
INT x;
UCHAR buf[60];
startPoint=ftell(libfile);
if(fread(buf,1,8,libfile)!=8)
{
addError("Error reading from file %s",mod->file);
return FALSE;
}
buf[8]=0;
/* complain if file header is wrong */
if(strcmp(buf,"!<arch>\n"))
{
addError("Invalid library file format - bad file header: \"%s\"",buf);
return FALSE;
}
/* read archive member header */
if(fread(buf,1,60,libfile)!=60)
{
addError("Error reading from file %s",mod->file);
return FALSE;
}
if((buf[58]!=0x60) || (buf[59]!='\n'))
{
addError("Invalid library file format for %s - bad member signature",mod->file);
return FALSE;
}
buf[16]=0;
/* check name of first linker member */
if(strcmp(buf,"/ ")) /* 15 spaces */
{
addError("Invalid library file format for %s - bad member name",mod->file);
return FALSE;
}
buf[58]=0;
/* strip trailing spaces from size */
endptr=buf+57;
while((endptr>(buf+48)) && isspace(*endptr))
{
*endptr=0;
endptr--;
}
/* get size */
errno=0;
memberSize=strtoul(buf+48,(PPCHAR)&endptr,10);
if(errno || (*endptr))
{
addError("Invalid library file format - bad member size\n");
return FALSE;
}
if((memberSize<4) && memberSize)
{
addError("Invalid library file format - bad member size\n");
return FALSE;
}
if(!memberSize)
{
numsyms=0;
}
else
{
if(fread(buf,1,4,libfile)!=4)
{
addError("Error reading from file\n");
return FALSE;
}
numsyms=buf[3]+(buf[2]<<8)+(buf[1]<<16)+(buf[0]<<24);
}
modbuf=(PUCHAR)checkMalloc(numsyms*4);
if(numsyms)
{
if(fread(modbuf,1,4*numsyms,libfile)!=4*numsyms)
{
addError("Error reading from file\n");
return FALSE;
}
symlist=(PPSYMBOL)checkMalloc(sizeof(PSYMBOL)*numsyms);
}
for(i=0;i<numsyms;i++)
{
modpage=modbuf[3+i*4]+(modbuf[2+i*4]<<8)+(modbuf[1+i*4]<<16)+(modbuf[i*4]<<24);
name=NULL;
for(j=0;TRUE;j++)
{
if((x=getc(libfile))==EOF)
{
addError("Error reading from file\n");
return FALSE;
}
if(!x) break;
name=(char*)checkRealloc(name,j+2);
name[j]=x;
name[j+1]=0;
}
if(!name)
{
addError("NULL name for symbol %li\n",i);
return FALSE;
}
symlist[i]=createSymbol(name,PUB_LIBSYM,mod,modpage,isDjgpp?DJGPPLibModLoad:MSCOFFLibModLoad);
}
checkFree(modbuf);
if(ftell(libfile)!=(startPoint+68+memberSize))
{
addError("Invalid first linker member: Pos=%08lX, should be %08lX",ftell(libfile),startPoint+68+memberSize);
return FALSE;
}
/* move to an even byte boundary in the file */
if(ftell(libfile)&1)
{
fseek(libfile,1,SEEK_CUR);
}
startPoint=ftell(libfile);
/* read archive member header */
if(fread(buf,1,60,libfile)!=60)
{
addError("Error reading from file\n");
return FALSE;
}
if((buf[58]!=0x60) || (buf[59]!='\n'))
{
addError("Invalid library file format - bad member signature\n");
return FALSE;
}
buf[16]=0;
/* check name of second linker member */
if(!strcmp(buf,"/ ")) /* 15 spaces */
{
/* OK, so we've found it, now skip over */
buf[58]=0;
/* strip trailing spaces from size */
endptr=buf+57;
while((endptr>(buf+48)) && isspace(*endptr))
{
*endptr=0;
endptr--;
}
/* get size */
errno=0;
memberSize=strtoul(buf+48,(PPCHAR)&endptr,10);
if(errno || (*endptr))
{
addError("Invalid library file format - bad member size\n");
return FALSE;
}
if((memberSize<8) && memberSize)
{
addError("Invalid library file format - bad member size\n");
return FALSE;
}
/* move over second linker member */
fseek(libfile,startPoint+60+memberSize,SEEK_SET);
/* move to an even byte boundary in the file */
if(ftell(libfile)&1)
{
fseek(libfile,1,SEEK_CUR);
}
}
else
{
fseek(libfile,startPoint,SEEK_SET);
}
startPoint=ftell(libfile);
longnames=NULL;
/* read archive member header */
if(fread(buf,1,60,libfile)!=60)
{
addError("Error reading from file\n");
return FALSE;
}
if((buf[58]!=0x60) || (buf[59]!='\n'))
{
addError("Invalid library file format - bad 3rd member signature\n");
return FALSE;
}
buf[16]=0;
/* check name of long names linker member */
if(!strcmp(buf,"// ")) /* 14 spaces */
{
buf[58]=0;
/* strip trailing spaces from size */
endptr=buf+57;
while((endptr>(buf+48)) && isspace(*endptr))
{
*endptr=0;
endptr--;
}
/* get size */
errno=0;
memberSize=strtoul(buf+48,(PPCHAR)&endptr,10);
if(errno || (*endptr))
{
addError("Invalid library file format - bad member size\n");
return FALSE;
}
if(memberSize)
{
longnames=(PUCHAR)checkMalloc(memberSize);
if(fread(longnames,1,memberSize,libfile)!=memberSize)
{
addError("Error reading from file\n");
return FALSE;
}
}
}
else
{
/* if no long names member, move back to member header */
fseek(libfile,startPoint,SEEK_SET);
}
mod->formatSpecificData=longnames;
for(i=0;i<numsyms;++i)
{
addGlobalSymbol(symlist[i]);
}
checkFree(symlist);
return TRUE;
}
static void MAMACALLTYPE
dictMsgIterator (const mamaMsg msg,
const mamaMsgField field,
void* closure)
{
mamaDictionaryImpl* impl = (mamaDictionaryImpl*) closure;
const char* fieldName = NULL;
mama_fid_t fid = 0;
mamaFieldType type = 0;
const char* val = NULL;
mamaMsgField_getType(field,&type);
mamaMsgField_getFid(field,&fid);
mamaMsgField_getName(field,&fieldName);
if (MamaFieldFeedName.mFid == fid)
{
if (MAMA_STATUS_OK == mamaMsg_getString (msg, fieldName, fid, &val))
{
checkFree(&impl->mFeedName);
impl->mFeedName = copyString(val);
mama_log ( MAMA_LOG_LEVEL_FINE,
"Dictionary source feed name: %s",
val);
}
}
else if (MamaFieldFeedHost.mFid == fid)
{
if (MAMA_STATUS_OK == mamaMsg_getString (msg, fieldName, fid, &val))
{
checkFree(&impl->mFeedHost);
impl->mFeedHost = copyString(val);
mama_log ( MAMA_LOG_LEVEL_FINE,
"Dictionary source hostname: %s",
val);
}
}
mamaDictionary_createFieldDescriptor (impl,
fid,
fieldName,
type,
NULL);
}
