/** resizes cuts and score arrays to be able to store at least num entries */
static
SCIP_RETCODE sepastoreEnsureCutsMem(
SCIP_SEPASTORE* sepastore, /**< separation storage */
SCIP_SET* set, /**< global SCIP settings */
int num /**< minimal number of slots in array */
)
{
assert(sepastore != NULL);
assert(set != NULL);
if( num > sepastore->cutssize )
{
int newsize;
newsize = SCIPsetCalcMemGrowSize(set, num);
SCIP_ALLOC( BMSreallocMemoryArray(&sepastore->cuts, newsize) );
SCIP_ALLOC( BMSreallocMemoryArray(&sepastore->efficacies, newsize) );
SCIP_ALLOC( BMSreallocMemoryArray(&sepastore->objparallelisms, newsize) );
SCIP_ALLOC( BMSreallocMemoryArray(&sepastore->orthogonalities, newsize) );
SCIP_ALLOC( BMSreallocMemoryArray(&sepastore->scores, newsize) );
sepastore->cutssize = newsize;
}
assert(num <= sepastore->cutssize);
return SCIP_OKAY;
}
/** reallocates the buffer to at least the given size */
SCIP_RETCODE SCIPbufferReallocMem(
SCIP_BUFFER* buffer, /**< memory buffer storage */
SCIP_SET* set, /**< global SCIP settings */
void** ptr, /**< pointer to the allocated memory buffer */
int size /**< minimal required size of the buffer */
)
{
#ifndef SCIP_NOBUFFERMEM
int bufnum;
assert(buffer != NULL);
assert(buffer->firstfree <= buffer->ndata);
assert(ptr != NULL);
assert(size >= 0);
/* if the pointer doesn't exist yet, allocate it */
if( *ptr == NULL )
return SCIPbufferAllocMem(buffer, set, ptr, size);
assert(buffer->firstfree >= 1);
/* Search the pointer in the buffer list
* Usually, buffers are allocated and freed like a stack, such that the currently used pointer is
* most likely at the end of the buffer list.
*/
for( bufnum = buffer->firstfree-1; bufnum >= 0 && buffer->data[bufnum] != *ptr; --bufnum )
{
}
assert(bufnum >= 0);
assert(buffer->data[bufnum] == *ptr);
assert(buffer->used[bufnum]);
assert(buffer->size[bufnum] >= 1);
/* check if the buffer has to be enlarged */
if( size > buffer->size[bufnum] )
{
int newsize;
/* enlarge buffer */
newsize = SCIPsetCalcMemGrowSize(set, size);
SCIP_ALLOC( BMSreallocMemorySize(&buffer->data[bufnum], newsize) );
buffer->size[bufnum] = newsize;
*ptr = buffer->data[bufnum];
}
assert(buffer->size[bufnum] >= size);
assert(*ptr == buffer->data[bufnum]);
SCIPdebugMessage("reallocated buffer %d/%d at %p to size %d (required size: %d) for pointer %p\n",
bufnum, buffer->ndata, buffer->data[bufnum], buffer->size[bufnum], size, (void*)ptr);
#else
SCIP_ALLOC( BMSreallocMemorySize(ptr, size) );
#endif
return SCIP_OKAY;
}
/** resizes vars and score arrays to be able to store at least num entries */
static
SCIP_RETCODE pricestoreEnsureVarsMem(
SCIP_PRICESTORE* pricestore, /**< pricing storage */
SCIP_SET* set, /**< global SCIP settings */
int num /**< minimal number of slots in array */
)
{
assert(pricestore != NULL);
assert(set != NULL);
if( num > pricestore->varssize )
{
int newsize;
newsize = SCIPsetCalcMemGrowSize(set, num);
SCIP_ALLOC( BMSreallocMemoryArray(&pricestore->vars, newsize) );
SCIP_ALLOC( BMSreallocMemoryArray(&pricestore->scores, newsize) );
pricestore->varssize = newsize;
}
assert(num <= pricestore->varssize);
return SCIP_OKAY;
}
/** allocates the next unused buffer */
SCIP_RETCODE SCIPbufferAllocMem(
SCIP_BUFFER* buffer, /**< memory buffer storage */
SCIP_SET* set, /**< global SCIP settings */
void** ptr, /**< pointer to store the allocated memory buffer */
int size /**< minimal required size of the buffer */
)
{
#ifndef SCIP_NOBUFFERMEM
int bufnum;
assert(buffer != NULL);
assert(buffer->firstfree <= buffer->ndata);
assert(ptr != NULL);
assert(size >= 0);
/* allocate minimal 1 byte */
if( size == 0 )
size = 1;
/* check, if we need additional buffers */
if( buffer->firstfree == buffer->ndata )
{
int newsize;
int i;
/* create additional buffers */
newsize = SCIPsetCalcMemGrowSize(set, buffer->firstfree+1);
SCIP_ALLOC( BMSreallocMemoryArray(&buffer->data, newsize) );
SCIP_ALLOC( BMSreallocMemoryArray(&buffer->size, newsize) );
SCIP_ALLOC( BMSreallocMemoryArray(&buffer->used, newsize) );
for( i = buffer->ndata; i < newsize; ++i )
{
buffer->data[i] = NULL;
buffer->size[i] = 0;
buffer->used[i] = FALSE;
}
buffer->ndata = newsize;
}
assert(buffer->firstfree < buffer->ndata);
/* check, if the current buffer is large enough */
bufnum = buffer->firstfree;
assert(!buffer->used[bufnum]);
if( buffer->size[bufnum] < size )
{
int newsize;
/* enlarge buffer */
newsize = SCIPsetCalcMemGrowSize(set, size);
SCIP_ALLOC( BMSreallocMemorySize(&buffer->data[bufnum], newsize) );
buffer->size[bufnum] = newsize;
}
assert(buffer->size[bufnum] >= size);
*ptr = buffer->data[bufnum];
buffer->used[bufnum] = TRUE;
buffer->firstfree++;
SCIPdebugMessage("allocated buffer %d/%d at %p of size %d (required size: %d) for pointer %p\n",
bufnum, buffer->ndata, buffer->data[bufnum], buffer->size[bufnum], size, (void*)ptr);
#else
SCIP_ALLOC( BMSallocMemorySize(ptr, size) );
#endif
return SCIP_OKAY;
}
