void MemoryPool_Extend( MemoryPool *memPool )
{
int i = 0;
char **newPool;
assert( memPool );
memPool->numMemChunks++;
memPool->chunks = (MemChunk*)Memory_Realloc( memPool->chunks, sizeof(MemChunk)*memPool->numMemChunks );
assert( memPool->chunks );
memPool->chunks[memPool->numMemChunks-1].memory = (char*)Memory_Alloc_Bytes_Unnamed( memPool->elementSize * memPool->delta, "int" );
memset( memPool->chunks[memPool->numMemChunks-1].memory, 0, memPool->elementSize * memPool->delta );
memPool->chunks[memPool->numMemChunks-1].numFree = memPool->delta;
memPool->chunks[memPool->numMemChunks-1].maxFree = memPool->delta;
newPool = (char**)Memory_Alloc_Bytes_Unnamed( sizeof(char*) * (memPool->numElements+memPool->delta), "char*" );
assert( newPool );
memcpy( newPool+memPool->delta, memPool->pool, sizeof(char*)*memPool->numElements );
for( i=0; i<memPool->delta; i++ ){
newPool[i] = &(memPool->chunks[memPool->numMemChunks-1].memory[i*memPool->elementSize]);
}
Memory_Free( memPool->pool );
memPool->pool = newPool;
memPool->numElements+=memPool->delta;
memPool->numElementsFree=memPool->delta;
if( memPool->callbackFunc ){
memPool->callbackFunc( memPool->callbackFuncArg );
}
}
void LinkedListSuite_DataCopyFunction( void **nodeData, void *newData, SizeT dataSize)
{
*nodeData = Memory_Alloc_Bytes_Unnamed(dataSize, "char");
memset(*nodeData, 0, dataSize);
memcpy(*nodeData, newData, dataSize);
}
Stg_Class* _Stg_Class_New( SizeT _sizeOfSelf,
Type type,
Stg_Class_DeleteFunction* _delete,
Stg_Class_PrintFunction* _print,
Stg_Class_CopyFunction* _copy )
{
Stg_Class* self;
/* Allocate memory */
assert( _sizeOfSelf >= sizeof(Stg_Class) );
self = (Stg_Class*)Memory_Alloc_Bytes_Unnamed( _sizeOfSelf, type );
memset( self, 0, _sizeOfSelf );
self->_sizeOfSelf = _sizeOfSelf;
self->_deleteSelf = True;
/* Init count to for this pointer to one. */
Memory_CountInc( self );
/* General info */
self->type = type;
/* Virtual functions */
self->_delete = _delete;
self->_print = _print;
self->_copy = _copy;
/* Stg_Class info */
_Stg_Class_Init( self );
return self;
}
Stg_TimeMonitor* Stg_TimeMonitor_New( char* tag, Bool criteria, Bool print, MPI_Comm communicator ) {
Stg_TimeMonitor* tm;
tm = Memory_Alloc_Unnamed( Stg_TimeMonitor );
tm->tag = (char*)Memory_Alloc_Bytes_Unnamed( strlen( tag ) + 1, Stg_TimeMonitor_TagType );
strcpy( tm->tag, tag );
tm->criteria = criteria;
tm->print = print;
tm->communicator = communicator;
return tm;
}
Stg_MemMonitor* Stg_MemMonitor_New( char* tag, Bool criteria, Bool print, int comm ) {
Stg_MemMonitor* tm;
tm = Memory_Alloc_Unnamed( Stg_MemMonitor );
tm->tag = Memory_Alloc_Bytes_Unnamed( strlen( tag ) + 1, Stg_MemMonitor_TagType );
strcpy( tm->tag, tag );
tm->criteria = criteria;
tm->print = print;
tm->comm = comm;
return tm;
}
void _MemoryPool_Init( MemoryPool* self ){
int i = 0;
/* General info */
assert( self );
_Stg_Class_Init ((Stg_Class*) self);
assert( self->numMemChunks == 1 );
self->chunks = (MemChunk*)Memory_Alloc_Bytes_Unnamed( sizeof(MemChunk)*self->numMemChunks, "char*" );
self->chunks[self->numMemChunks-1].memory = (char*)Memory_Alloc_Bytes_Unnamed( self->elementSize * self->numElements, "char" );
memset( self->chunks[self->numMemChunks-1].memory, 0, self->elementSize * self->numElements );
self->chunks[self->numMemChunks-1].numFree = self->numElements;
self->chunks[self->numMemChunks-1].maxFree = self->numElements;
self->pool = (char**)Memory_Alloc_Bytes_Unnamed( sizeof( char* ) * self->numElements, "char*" );
memset( self->pool, 0, sizeof(char*) * self->numElements );
for( i=0; i<self->numElements; i++ ){
self->pool[i] = &(self->chunks[self->numMemChunks-1].memory[i*self->elementSize]);
}
}
void* _ForceVector_Copy( void* forceVector, void* dest, Bool deep, Name nameExt, PtrMap* ptrMap ) {
ForceVector* self = (ForceVector*)forceVector;
ForceVector* newForceVector;
PtrMap* map = ptrMap;
Bool ownMap = False;
if( !map ) {
map = PtrMap_New( 10 );
ownMap = True;
}
newForceVector = _SolutionVector_Copy( self, dest, deep, nameExt, map );
/* TODO: copy vector? */
newForceVector->entryPoint_Register = self->entryPoint_Register;
newForceVector->localSize = self->localSize;
if( deep ) {
newForceVector->assembleForceVector = (FeEntryPoint*)Stg_Class_Copy( self->assembleForceVector, NULL, deep, nameExt, map );
if( self->_assembleForceVectorEPName ) {
if( nameExt ) {
unsigned nameLen = strlen( self->_assembleForceVectorEPName );
newForceVector->_assembleForceVectorEPName = Memory_Alloc_Bytes_Unnamed( nameLen + strlen( nameExt ) + 1, "FV->vecEPName" );
memcpy( newForceVector->_assembleForceVectorEPName, self->_assembleForceVectorEPName, nameLen );
strcpy( newForceVector->_assembleForceVectorEPName + nameLen, nameExt );
}
else {
newForceVector->_assembleForceVectorEPName = StG_Strdup( self->_assembleForceVectorEPName );
}
}
else {
newForceVector->_assembleForceVectorEPName = NULL;
}
}
else {
newForceVector->debug = self->debug;
newForceVector->_assembleForceVectorEPName = self->_assembleForceVectorEPName;
newForceVector->assembleForceVector = self->assembleForceVector;
}
if( ownMap ) {
Stg_Class_Delete( map );
}
return (void*)newForceVector;
}
VoxelDataHandler_Geomodeller* _VoxelDataHandler_Geomodeller_New( VOXELDATAHANDLER_GEOMODELLER_DEFARGS )
{
VoxelDataHandler_Geomodeller* self;
/* Allocate memory */
assert( _sizeOfSelf >= sizeof( VoxelDataHandler_Geomodeller ) );
self = (VoxelDataHandler_Geomodeller*)_VoxelDataHandler_Abstract_New( VOXELDATAHANDLER_ABSTRACT_PASSARGS );
self->dataType = Variable_DataType_Char;
self->dataBufferSize = sizeof(signed char);
self->dataBuffer = Memory_Alloc_Bytes_Unnamed( self->dataBufferSize , "voxel data handler type" );
self->dataStride = -1;
self->dataPos = 1;
return self;
}
void* _Stg_Class_Copy( void* _class, void* dest, Bool deep, Name nameExt, struct PtrMap* ptrMap ) {
Stg_Class* self = (Stg_Class*)_class;
Stg_Class* newClass;
if( !dest ) {
newClass = (Stg_Class*)Memory_Alloc_Bytes_Unnamed( self->_sizeOfSelf, self->type );
}
else {
newClass = (Stg_Class*)dest;
}
PtrMap_Append( ptrMap, self, newClass );
newClass->_sizeOfSelf = self->_sizeOfSelf;
newClass->_deleteSelf = self->_deleteSelf;
newClass->type = self->type;
newClass->_delete = self->_delete;
newClass->_print = self->_print;
newClass->_copy = self->_copy;
newClass->nRefs = self->nRefs;
return (void*)newClass;
}
static void copyFunc( void** newData, void* data, SizeT size ) {
*newData = Memory_Alloc_Bytes_Unnamed( size, "char" );
assert( *newData );
*(int*)(*newData) = *(int*)data;
}
void MemoryPool_Shrink( MemoryPool *memPool )
{
int i = 0;
Bool deleteFlag = (Bool)0;
int chunkIdx = 0;
char **newPool = (char**)0;
int eCounter = 0;
assert( memPool );
if( memPool->numElementsFree < memPool->delta ){
return;
}
for( i=0; i<memPool->numMemChunks; i++ )
{
if( memPool->chunks[i].numFree == memPool->chunks[i].maxFree ){
deleteFlag = True;
chunkIdx = i;
break;
}
}
if( deleteFlag ){
int numObjs = 0;
numObjs = memPool->chunks[chunkIdx].maxFree*memPool->elementSize;
newPool = (char**)Memory_Alloc_Bytes_Unnamed( sizeof(char*) * (memPool->numElements-memPool->chunks[chunkIdx].maxFree), "char*" );
eCounter = 0;
for( i=0; i<memPool->numElements; i++ ){
if( (memPool->pool[i] >= memPool->chunks[chunkIdx].memory) &&
(memPool->pool[i] < (memPool->chunks[chunkIdx].memory+numObjs)) ){
}
else{
newPool[eCounter++] = memPool->pool[i];
}
}
Memory_Free( memPool->pool );
memPool->pool = newPool;
memPool->numElements-=memPool->chunks[chunkIdx].maxFree;
memPool->numElementsFree-=memPool->chunks[chunkIdx].maxFree;
Memory_Free( memPool->chunks[chunkIdx].memory );
memPool->chunks[chunkIdx].memory = (char*)NULL;
if( chunkIdx == (memPool->numMemChunks-1) ){
memPool->numMemChunks--;
if( memPool->numMemChunks>0 ){
memPool->chunks = (MemChunk*)Memory_Realloc( memPool->chunks, sizeof(MemChunk)*memPool->numMemChunks );
assert( memPool->chunks );
}
}
else{
memcpy( &(memPool->chunks[chunkIdx]), &(memPool->chunks[chunkIdx+1]), sizeof(MemChunk)*(memPool->numMemChunks - (chunkIdx+1)) );
memPool->numMemChunks--;
memPool->chunks = (MemChunk*)Memory_Realloc( memPool->chunks, sizeof(MemChunk)*memPool->numMemChunks );
assert( memPool->chunks );
}
}
if( memPool->callbackFunc ){
memPool->callbackFunc( memPool->callbackFuncArg );
}
}
