sObject* vector_new_on_stack(int first_size)
{
sObject* self = (sObject*)stack_get_free_object(T_VECTOR);
SVECTOR(self).mTable = (void**)MALLOC(sizeof(void*) * first_size);
SVECTOR(self).mTableSize = first_size;
SVECTOR(self).mCount = 0;
return self;
}
sObject* vector_new_on_gc(int first_size, BOOL user_object)
{
sObject* self = (sObject*)gc_get_free_object(T_VECTOR, user_object);
SVECTOR(self).mTable = (void**)MALLOC(sizeof(void*) * first_size);
SVECTOR(self).mTableSize = first_size;
SVECTOR(self).mCount = 0;
return self;
}
int vector_index(sObject* self, void* item)
{
int i;
for(i=0; i<SVECTOR(self).mCount; i++) {
if(SVECTOR(self).mTable[i] == item) {
return i;
}
}
return -1;
}
sObject* vector_new_on_malloc_debug(int first_size, const char* fname, int line, const char* func_name)
{
sObject* self = CheckMemLeak_Malloc(sizeof(sObject), fname, line, func_name);
self->mFlags = T_VECTOR;
SVECTOR(self).mTable = (void**)MALLOC(sizeof(void*) * first_size);
SVECTOR(self).mTableSize = first_size;
SVECTOR(self).mCount = 0;
return self;
}
sObject* vector_new_on_malloc(int first_size)
{
sObject* self = (sObject*)MALLOC(sizeof(sObject));
self->mFlags = T_VECTOR;
SVECTOR(self).mTable = (void**)MALLOC(sizeof(void*) * first_size);
SVECTOR(self).mTableSize = first_size;
SVECTOR(self).mCount = 0;
return self;
}
void vector_add(sObject* self, void* item)
{
if(SVECTOR(self).mCount == SVECTOR(self).mTableSize) {
SVECTOR(self).mTableSize = SVECTOR(self).mTableSize * 2;
SVECTOR(self).mTable = (void**)REALLOC(SVECTOR(self).mTable
, sizeof(void*)*SVECTOR(self).mTableSize);
}
SVECTOR(self).mTable[SVECTOR(self).mCount] = item;
SVECTOR(self).mCount++;
}
void* vector_erase(sObject* self, int n)
{
void* item = NULL;
if(n>=0 && n<SVECTOR(self).mCount) {
item = SVECTOR(self).mTable[n];
memmove(SVECTOR(self).mTable + n, SVECTOR(self).mTable + n + 1, sizeof(void*)*(SVECTOR(self).mCount -n-1));
SVECTOR(self).mCount--;
}
return item;
}
static BOOL quick_sort(sObject* self, int left, int right, sort_if fun)
{
int i;
int j;
void* center_item;
if(left < right) {
center_item = SVECTOR(self).mTable[(left+right) / 2];
i = left;
j = right;
do {
while(1) {
int ret = fun(SVECTOR(self).mTable[i], center_item);
if(ret < 0) return FALSE;
if(SVECTOR(self).mTable[i]==center_item || !ret)
{
break;
}
i++;
}
while(1) {
int ret = fun(center_item, SVECTOR(self).mTable[j]);
if(ret < 0) return FALSE;
if(center_item==SVECTOR(self).mTable[j] || !ret)
{
break;
}
j--;
}
if(i <= j) {
void* tmp = SVECTOR(self).mTable[i]; // swap
SVECTOR(self).mTable[i] = SVECTOR(self).mTable[j];
SVECTOR(self).mTable[j] = tmp;
i++;
j--;
}
} while(i <= j);
if(!quick_sort(self, left, j, fun)) {
return FALSE;
}
if(!quick_sort(self, i, right, fun)) {
return FALSE;
}
}
return TRUE;
}
int vector_gc_children_mark(sObject* self)
{
int count = 0;
int i;
for(i=0; i<SVECTOR(self).mCount; i++) {
sObject* item = SVECTOR(self).mTable[i];
if(item && IS_MARKED(item) == 0) {
SET_MARK(item);
count++;
count += object_gc_children_mark(item);
}
}
return count;
}
void vector_exchange(sObject* self, int n, void* item)
{
SVECTOR(self).mTable[n] = item;
}
void vector_delete_on_stack(sObject* self)
{
FREE(SVECTOR(self).mTable);
}
void vector_delete_on_malloc(sObject* self)
{
FREE(SVECTOR(self).mTable);
FREE(self);
}
void vector_mass_insert(sObject* self, int n, void** items, int items_size)
{
if(SVECTOR(self).mCount+items_size >= SVECTOR(self).mTableSize) {
SVECTOR(self).mTableSize = (SVECTOR(self).mTableSize+items_size) * 2;
SVECTOR(self).mTable = (void**)REALLOC(SVECTOR(self).mTable
, sizeof(void*)*SVECTOR(self).mTableSize);
}
memmove(SVECTOR(self).mTable +n +items_size, SVECTOR(self).mTable +n
, sizeof(void*)*(SVECTOR(self).mCount - n));
memmove(SVECTOR(self).mTable + n, items, sizeof(void*)*items_size);
SVECTOR(self).mCount+=items_size;
}
void vector_clear(sObject* self)
{
SVECTOR(self).mCount = 0;
}
void vector_sort(sObject* self, sort_if fun)
{
quick_sort(self, 0, SVECTOR(self).mCount-1, fun);
}
void* vector_pop_back(sObject* self)
{
return vector_erase(self, SVECTOR(self).mCount-1);
}
void vector_insert(sObject* self, int n, void* item)
{
if(SVECTOR(self).mCount == SVECTOR(self).mTableSize) {
SVECTOR(self).mTableSize = SVECTOR(self).mTableSize * 2;
SVECTOR(self).mTable = (void**)REALLOC(SVECTOR(self).mTable
, sizeof(void*)*SVECTOR(self).mTableSize);
}
memmove(SVECTOR(self).mTable +n +1, SVECTOR(self).mTable +n
, sizeof(void*)*(SVECTOR(self).mCount - n));
SVECTOR(self).mTable[n] = item;
SVECTOR(self).mCount++;
}
void NS_DIM_PREFIX SetGhostObjectPriorities (GRID *theGrid)
{
ELEMENT *theElement,*theNeighbor,*SonList[MAX_SONS];
NODE *theNode;
EDGE *theEdge;
VECTOR *theVector;
INT i,prio,*proclist,hghost,vghost;
/* reset USED flag for objects of ghostelements */
for (theElement=PFIRSTELEMENT(theGrid);
theElement!=NULL;
theElement=SUCCE(theElement))
{
SETUSED(theElement,0); SETTHEFLAG(theElement,0);
for (i=0; i<EDGES_OF_ELEM(theElement); i++)
{
theEdge = GetEdge(CORNER(theElement,CORNER_OF_EDGE(theElement,i,0)),
CORNER(theElement,CORNER_OF_EDGE(theElement,i,1)));
ASSERT(theEdge != NULL);
SETUSED(theEdge,0); SETTHEFLAG(theEdge,0);
}
if (VEC_DEF_IN_OBJ_OF_GRID(theGrid,SIDEVEC))
for (i=0; i<SIDES_OF_ELEM(theElement); i++)
{
theVector = SVECTOR(theElement,i);
if (theVector != NULL) {
SETUSED(theVector,0);
SETTHEFLAG(theVector,0);
}
}
}
/* to reset also nodes which are at corners of the boundary */
/* reset of nodes need to be done through the node list */
for (theNode=PFIRSTNODE(theGrid); theNode!=NULL; theNode=SUCCN(theNode))
{
SETUSED(theNode,0); SETTHEFLAG(theNode,0);
SETMODIFIED(theNode,0);
}
/* set FLAG for objects of horizontal and vertical overlap */
for (theElement=PFIRSTELEMENT(theGrid);
theElement!=NULL;
theElement=SUCCE(theElement))
{
if (PARTITION(theElement) == me) continue;
/* check for horizontal ghost */
hghost = 0;
for (i=0; i<SIDES_OF_ELEM(theElement); i++)
{
theNeighbor = NBELEM(theElement,i);
if (theNeighbor == NULL) continue;
if (PARTITION(theNeighbor) == me)
{
hghost = 1;
break;
}
}
/* check for vertical ghost */
vghost = 0;
GetAllSons(theElement,SonList);
for (i=0; SonList[i]!=NULL; i++)
{
if (PARTITION(SonList[i]) == me)
{
vghost = 1;
break;
}
}
/* one or both of vghost and hghost should be true here */
/* except for elements which will be disposed during Xfer */
if (vghost) SETTHEFLAG(theElement,1);
if (hghost) SETUSED(theElement,1);
for (i=0; i<CORNERS_OF_ELEM(theElement); i++)
{
theNode = CORNER(theElement,i);
if (vghost) SETTHEFLAG(theNode,1);
if (hghost) SETUSED(theNode,1);
}
for (i=0; i<EDGES_OF_ELEM(theElement); i++)
{
theEdge = GetEdge(CORNER_OF_EDGE_PTR(theElement,i,0),
CORNER_OF_EDGE_PTR(theElement,i,1));
ASSERT(theEdge != NULL);
if (vghost) SETTHEFLAG(theEdge,1);
if (hghost) SETUSED(theEdge,1);
}
if (VEC_DEF_IN_OBJ_OF_GRID(theGrid,SIDEVEC))
for (i=0; i<SIDES_OF_ELEM(theElement); i++)
{
theVector = SVECTOR(theElement,i);
if (theVector != NULL) {
if (vghost) SETTHEFLAG(theVector,1);
if (hghost) SETUSED(theVector,1);
}
}
}
DEBUG_TIME(0);
/* set USED flag for objects of master elements */
/* reset FLAG for objects of master elements */
for (theElement=PFIRSTELEMENT(theGrid);
theElement!=NULL;
theElement=SUCCE(theElement))
{
if (PARTITION(theElement) != me) continue;
SETUSED(theElement,0); SETTHEFLAG(theElement,0);
for (i=0; i<CORNERS_OF_ELEM(theElement); i++)
{
theNode = CORNER(theElement,i);
SETUSED(theNode,0); SETTHEFLAG(theNode,0);
SETMODIFIED(theNode,1);
}
for (i=0; i<EDGES_OF_ELEM(theElement); i++)
{
theEdge = GetEdge(CORNER_OF_EDGE_PTR(theElement,i,0),
CORNER_OF_EDGE_PTR(theElement,i,1));
ASSERT(theEdge != NULL);
SETUSED(theEdge,0); SETTHEFLAG(theEdge,0);
}
if (VEC_DEF_IN_OBJ_OF_GRID(theGrid,SIDEVEC))
for (i=0; i<SIDES_OF_ELEM(theElement); i++)
{
theVector = SVECTOR(theElement,i);
if (theVector != NULL) {
SETUSED(theVector,0);
SETTHEFLAG(theVector,0);
}
}
}
DEBUG_TIME(0);
/* set object priorities for ghostelements */
for (theElement=PFIRSTELEMENT(theGrid);
theElement!=NULL;
theElement=SUCCE(theElement))
{
if (PARTITION(theElement) == me) continue;
if (USED(theElement) || THEFLAG(theElement))
{
prio = PRIO_CALC(theElement);
PRINTDEBUG(gm,1,("SetGhostObjectPriorities(): e=" EID_FMTX " new prio=%d\n",
EID_PRTX(theElement),prio))
SETEPRIOX(theElement,prio);
if (VEC_DEF_IN_OBJ_OF_GRID(theGrid,ELEMVEC))
{
theVector = EVECTOR(theElement);
if (theVector != NULL)
SETPRIOX(theVector,prio);
}
}
/* set edge priorities */
for (i=0; i<EDGES_OF_ELEM(theElement); i++)
{
theEdge = GetEdge(CORNER(theElement,CORNER_OF_EDGE(theElement,i,0)),
CORNER(theElement,CORNER_OF_EDGE(theElement,i,1)));
ASSERT(theEdge != NULL);
if (USED(theEdge) || THEFLAG(theEdge))
{
PRINTDEBUG(dddif,3,(PFMT " dddif_SetGhostObjectPriorities():"
" downgrade edge=" EDID_FMTX " from=%d to PrioHGhost\n",
me,EDID_PRTX(theEdge),prio));
EDGE_PRIORITY_SET(theGrid,theEdge,PRIO_CALC(theEdge));
}
else
EDGE_PRIORITY_SET(theGrid,theEdge,PrioMaster);
}
#ifdef __THREEDIM__
/* if one(all) of the side nodes is (are) a hghost (vghost) node */
/* then its a hghost (vghost) side vector */
if (VEC_DEF_IN_OBJ_OF_GRID(theGrid,SIDEVEC))
for (i=0; i<SIDES_OF_ELEM(theElement); i++)
{
if (USED(theVector) || THEFLAG(theVector))
SETPRIOX(theVector,PRIO_CALC(theVector));
}
#endif
}
/* to set also nodes which are at corners of the boundary */
/* set them through the node list */
for (theNode=PFIRSTNODE(theGrid); theNode!=NULL; theNode=SUCCN(theNode))
{
/* check if its a master node */
if (USED(theNode) || THEFLAG(theNode))
{
PRINTDEBUG(dddif,3,(PFMT " dddif_SetGhostObjectPriorities():"
" downgrade node=" ID_FMTX " from=%d to PrioHGhost\n",
me,ID_PRTX(theNode),prio));
/* set node priorities of node to ghost */
NODE_PRIORITY_SET(theGrid,theNode,PRIO_CALC(theNode))
}
else if (MODIFIED(theNode) == 0)
