void QPBO<REAL>::Reset()
{
node_last[0] = nodes[0];
node_last[1] = nodes[1];
node_num = 0;
if (nodeptr_block)
{
delete nodeptr_block;
nodeptr_block = NULL;
}
if (changed_list)
{
delete changed_list;
changed_list = NULL;
}
if (fix_node_info_list)
{
delete fix_node_info_list;
fix_node_info_list = NULL;
}
maxflow_iteration = 0;
zero_energy = 0;
stage = 0;
all_edges_submodular = true;
memset(arcs[0], 0, 2*arc_shift);
InitFreeList();
}
QPBO<REAL>::QPBO(int node_num_max, int edge_num_max, void (*err_function)(char *))
: node_num(0),
nodeptr_block(NULL),
changed_list(NULL),
fix_node_info_list(NULL),
stage(0),
all_edges_submodular(true),
error_function(err_function),
zero_energy(0)
{
node_num_max += 4;
if (node_num_max < 16) node_num_max = 16;
if (edge_num_max < 16) edge_num_max = 16;
nodes[0] = (Node*) malloc(2*node_num_max*sizeof(Node));
arcs[0] = (Arc*) malloc(4*edge_num_max*sizeof(Arc));
if (!nodes[0] || !arcs[0]) { if (error_function) (*error_function)("Not enough memory!"); exit(1); }
node_last[0] = nodes[0];
node_max[0] = nodes[1] = node_last[1] = nodes[0] + node_num_max;
node_max[1] = nodes[1] + node_num_max;
node_shift = node_num_max*sizeof(Node);
arc_max[0] = arcs[1] = arcs[0] + 2*edge_num_max;
arc_max[1] = arcs[1] + 2*edge_num_max;
arc_shift = 2*edge_num_max*sizeof(Arc);
maxflow_iteration = 0;
memset(arcs[0], 0, 2*arc_shift);
InitFreeList();
}
void QPBO<REAL>::reallocate_arcs(int arc_num_max_new)
{
int arc_num_max_old = (int)(arc_max[0] - arcs[0]);
int arc_num_max = arc_num_max_new;
if (arc_num_max & 1) arc_num_max ++;
code_assert(arc_num_max > arc_num_max_old);
Arc* arcs_old[2] = { arcs[0], arcs[1] };
arcs[0] = (Arc*) realloc(arcs_old[0], 2*arc_num_max*sizeof(Arc));
if (!arcs[0]) {
if (error_function) (*error_function)("Not enough memory!");
exit(1);
}
arc_shift = arc_num_max*sizeof(Arc);
arc_max[0] = arcs[1] = arcs[0] + arc_num_max;
arc_max[1] = arcs[1] + arc_num_max;
if (stage)
{
memmove(arcs[1], arcs[0]+arc_num_max_old, arc_num_max_old*sizeof(Arc));
memset(arcs[0]+arc_num_max_old, 0, (arc_num_max-arc_num_max_old)*sizeof(Arc));
memset(arcs[1]+arc_num_max_old, 0, (arc_num_max-arc_num_max_old)*sizeof(Arc));
}
else
{
memset(arcs[0]+arc_num_max_old, 0, (2*arc_num_max-arc_num_max_old)*sizeof(Arc));
}
Node* i;
Arc* a;
for (i=nodes[0]; i<node_last[stage]; i++)
{
if (i==node_last[0]) i = nodes[1];
if (i->first)
{
int k = (i->first < arcs_old[1]) ? 0 : 1;
i->first = (Arc*) ((char*)i->first + (((char*) arcs[k]) - ((char*) arcs_old[k])));
}
}
for (a=arcs[0]; a<arc_max[stage]; a++)
{
if (a->sister)
{
if (a->next)
{
int k = (a->next < arcs_old[1]) ? 0 : 1;
a->next = (Arc*) ((char*)a->next + (((char*) arcs[k]) - ((char*) arcs_old[k])));
}
int k = (a->sister < arcs_old[1]) ? 0 : 1;
a->sister = (Arc*) ((char*)a->sister + (((char*) arcs[k]) - ((char*) arcs_old[k])));
}
}
InitFreeList();
}
QPBO<REAL>::QPBO(QPBO<REAL>& q)
: node_num(q.node_num),
nodeptr_block(NULL),
changed_list(NULL),
fix_node_info_list(NULL),
stage(q.stage),
all_edges_submodular(q.all_edges_submodular),
error_function(q.error_function),
zero_energy(q.zero_energy)
{
int node_num_max = q.node_shift/sizeof(Node);
int arc_num_max = (int)(q.arc_max[0] - q.arcs[0]);
Node* i;
Arc* a;
nodes[0] = (Node*) malloc(2*node_num_max*sizeof(Node));
arcs[0] = (Arc*) malloc(2*arc_num_max*sizeof(Arc));
if (!nodes[0] || !arcs[0]) {
if (error_function) (*error_function)("Not enough memory!");
exit(1);
}
node_last[0] = nodes[0] + node_num;
node_max[0] = nodes[1] = nodes[0] + node_num_max;
node_last[1] = nodes[1] + node_num;
node_max[1] = nodes[1] + node_num_max;
node_shift = node_num_max*sizeof(Node);
arc_max[0] = arcs[1] = arcs[0] + arc_num_max;
arc_max[1] = arcs[1] + arc_num_max;
arc_shift = arc_num_max*sizeof(Arc);
maxflow_iteration = 0;
memcpy(nodes[0], q.nodes[0], 2*node_num_max*sizeof(Node));
memcpy(arcs[0], q.arcs[0], 2*arc_num_max*sizeof(Arc));
for (i=nodes[0]; i<node_last[stage]; i++)
{
if (i==node_last[0]) i = nodes[1];
if (i->first) i->first = (Arc*) ((char*)i->first + (((char*) arcs[0]) - ((char*) q.arcs[0])));
}
for (a=arcs[0]; a<arc_max[stage]; a++)
{
if (a == arc_max[0]) a = arcs[1];
if (a->sister)
{
a->head = (Node*) ((char*)a->head + (((char*) nodes[0]) - ((char*) q.nodes[0])));
if (a->next) a->next = (Arc*) ((char*)a->next + (((char*) arcs[0]) - ((char*) q.arcs[0])));
a->sister = (Arc*) ((char*)a->sister + (((char*) arcs[0]) - ((char*) q.arcs[0])));
}
}
InitFreeList();
}
/*
* Initialize shared buffer pool
*
* This is called once during shared-memory initialization (either in the
* postmaster, or in a standalone backend).
*/
void
InitBufferPool(void)
{
char *BufferBlocks;
bool foundBufs,
foundDescs;
int i;
Data_Descriptors = NBuffers;
Free_List_Descriptor = Data_Descriptors;
Lookup_List_Descriptor = Data_Descriptors + 1;
Num_Descriptors = Data_Descriptors + 1;
/*
* It's probably not really necessary to grab the lock --- if there's
* anyone else attached to the shmem at this point, we've got
* problems.
*/
LWLockAcquire(BufMgrLock, LW_EXCLUSIVE);
#ifdef BMTRACE
CurTraceBuf = (long *) ShmemInitStruct("Buffer trace",
(BMT_LIMIT * sizeof(bmtrace)) + sizeof(long),
&foundDescs);
if (!foundDescs)
MemSet(CurTraceBuf, 0, (BMT_LIMIT * sizeof(bmtrace)) + sizeof(long));
TraceBuf = (bmtrace *) & (CurTraceBuf[1]);
#endif
BufferDescriptors = (BufferDesc *)
ShmemInitStruct("Buffer Descriptors",
Num_Descriptors * sizeof(BufferDesc), &foundDescs);
BufferBlocks = (char *)
ShmemInitStruct("Buffer Blocks",
NBuffers * BLCKSZ, &foundBufs);
if (foundDescs || foundBufs)
{
/* both should be present or neither */
Assert(foundDescs && foundBufs);
}
else
{
BufferDesc *buf;
char *block;
buf = BufferDescriptors;
block = BufferBlocks;
/*
* link the buffers into a circular, doubly-linked list to
* initialize free list, and initialize the buffer headers. Still
* don't know anything about replacement strategy in this file.
*/
for (i = 0; i < Data_Descriptors; block += BLCKSZ, buf++, i++)
{
Assert(ShmemIsValid((unsigned long) block));
buf->freeNext = i + 1;
buf->freePrev = i - 1;
CLEAR_BUFFERTAG(&(buf->tag));
buf->buf_id = i;
buf->data = MAKE_OFFSET(block);
buf->flags = (BM_DELETED | BM_FREE | BM_VALID);
buf->refcount = 0;
buf->io_in_progress_lock = LWLockAssign();
buf->cntx_lock = LWLockAssign();
buf->cntxDirty = false;
buf->wait_backend_id = 0;
}
/* close the circular queue */
BufferDescriptors[0].freePrev = Data_Descriptors - 1;
BufferDescriptors[Data_Descriptors - 1].freeNext = 0;
}
/* Init other shared buffer-management stuff */
InitBufTable();
InitFreeList(!foundDescs);
LWLockRelease(BufMgrLock);
}
