void WSLB::AtSync()
{
#if CMK_LBDB_ON
// CkPrintf("[%d] WSLB At Sync step %d!!!!\n",CkMyPe(),mystep);
if (CkMyPe() == 0) {
start_lb_time = CkWallTimer();
CkPrintf("Load balancing step %d starting at %f\n",
step(),start_lb_time);
}
if (neighbor_pes == 0) FindNeighbors();
if (!QueryBalanceNow(step()) || mig_msgs_expected == 0) {
MigrationDone();
return;
}
WSLBStatsMsg* msg = AssembleStats();
thisProxy.ReceiveStats(msg,mig_msgs_expected,neighbor_pes);
// Tell our own node that we are ready
ReceiveStats((WSLBStatsMsg*)0);
#endif
}
Node Dlite::GetMinPredecessor(Node* current, LocalMap &map) {
Node* min;
std::vector<Node *> all_neighbors;
for(auto elem : FindNeighbors(current, map)) {
if(!NODES.count(vertex(elem.point, map.height))) { //if vertex wasn't previously examined
elem.g = std::numeric_limits<double>::infinity();
elem.rhs = std::numeric_limits<double>::infinity();
NODES[vertex(elem.point, map.height)] = elem;
all_neighbors.push_back(&(NODES.find(vertex(elem.point, map.height))->second));
} else {
all_neighbors.push_back(&(NODES.find(vertex(elem.point, map.height))->second));
}
}
Node min_node;
if (!all_neighbors.empty()) {
min = (all_neighbors.front());
min_node = *min;
min_node.rhs = std::numeric_limits<double>::infinity();
min_node.parent = min;
for (auto n: all_neighbors) {
if (min_node.rhs > n->g + GetCost(n->point, current->point, map)) {
min_node.rhs = n->g + GetCost(n->point, current->point, map);
min_node.parent = n;
}
}
} else {
min_node.parent = nullptr;
}
return min_node;
}
void HbmLB::ReceiveStats(double t, int frompe, int fromlevel)
{
#if CMK_LBDB_ON
FindNeighbors();
int atlevel = fromlevel + 1;
CmiAssert(tree->isroot(CkMyPe(), atlevel));
DEBUGF(("[%d] ReceiveStats from PE %d from level: %d\n", CkMyPe(), frompe, fromlevel));
int neighborIdx = NeighborIndex(frompe, atlevel);
CmiAssert(neighborIdx==0 || neighborIdx==1);
LevelData *lData = levelData[atlevel];
lData->statsList[neighborIdx] = t;
int &stats_msg_count = levelData[atlevel]->stats_msg_count;
stats_msg_count ++;
DEBUGF(("[%d] ReceiveStats at level: %d %d/%d\n", CkMyPe(), atlevel, stats_msg_count, levelData[atlevel]->nChildren));
if (stats_msg_count == levelData[atlevel]->nChildren)
{
stats_msg_count = 0;
int parent = levelData[atlevel]->parent;
// load balancing
thisProxy[CkMyPe()].Loadbalancing(atlevel);
}
#endif
}
/* Initialize the StateInfo, neighbors and other parameters*/
void Initialize(struct StateInfo state[], int site[], int neighbors[]){
int i;
int *neigh;
for(i=0; i<L; i++){
site[i] = 1;
neigh = FindNeighbors(i+1);
neighbors[3*i]=neigh[0]-1;
neighbors[3*i+1]=neigh[1]-1;
neighbors[3*i+2]=neigh[2]-1;
}
state[0].E = 3*L/2;
state[0].logg = 0.0;
state[0].H = 0.0;
for(i = 1; i < MaxLength; i++){
state[i].E = -1;
state[i].logg = 0.0;
state[i].H = 0.0;
}
StatesLength = 1;
CurrentState = 3*L/2;
CurrentIndex = 0;
MaxState = CurrentState;
MinState = CurrentState;
MinStateFound = 0;
}
void MeshMender::BuildGroups( Triangle* tri, //the tri of interest
TriangleList& possibleNeighbors, //all tris arround a vertex
NeighborGroupList& neighborGroups, //the neighbor groups to be updated
std::vector< Vertex >& theVerts,
CanSmoothChecker* smoothChecker,
const float& minCreaseAngle)
{
if( (!tri) || (tri->handled) )
return;
Triangle* neighbor1 = NULL;
Triangle* neighbor2 = NULL;
FindNeighbors(tri, possibleNeighbors, &neighbor1, &neighbor2,theVerts);
//see if I can join my first neighbors group
if(neighbor1 && (neighbor1->group != NO_GROUP))
{
if( smoothChecker->CanSmooth(tri,neighbor1, minCreaseAngle) )
{
neighborGroups[neighbor1->group].push_back(tri->myID);
tri->group = neighbor1->group;
}
}
//see if I can join my second neighbors group
if(neighbor2 && (neighbor2->group!= NO_GROUP))
{
if( smoothChecker->CanSmooth(tri,neighbor2, minCreaseAngle) )
{
neighborGroups[neighbor2->group].push_back(tri->myID);
tri->group = neighbor2->group;
}
}
//I either couldn't join, or they weren't in a group, so I think I'll
//just go and start my own group...right here we go.
if(tri->group == NO_GROUP)
{
tri->group = neighborGroups.size();
neighborGroups.push_back( TriangleList() );
neighborGroups.back().push_back(tri->myID);
}
assert((tri->group != NO_GROUP) && "error!: tri should have a group set");
tri->handled = true;
//continue growing our group with each neighbor.
BuildGroups(neighbor1,possibleNeighbors,neighborGroups,theVerts,smoothChecker,minCreaseAngle);
BuildGroups(neighbor2,possibleNeighbors,neighborGroups,theVerts,smoothChecker,minCreaseAngle);
}
std::vector<Node* > Dlite::GetSuccessors(Node* current, LocalMap &map) {
std::vector<Node*> result;
for(auto elem : FindNeighbors(current, map)) {
if(!NODES.count(vertex(elem.point, map.height))) { //if vertex wasn't previously examined
elem.g = std::numeric_limits<double>::infinity();
elem.rhs = std::numeric_limits<double>::infinity();
NODES[vertex(elem.point, map.height)] = elem;
result.push_back(&(NODES.find(vertex(elem.point, map.height))->second));
} else {
result.push_back(&(NODES.find(vertex(elem.point, map.height))->second));
}
}
return result;
}
void HybridBaseLB::ReceiveVectorMigration(LBVectorMigrateMsg *msg)
{
#if CMK_LBDB_ON
FindNeighbors();
int atlevel = msg->level - 1;
DEBUGF(("[%d] ReceiveMigration\n", CkMyPe()));
LevelData *lData = levelData[atlevel];
LDStats *statsData = lData->statsData;
// pick objects for required load migration, first fit
lData->vector_expected = 0;
for (int i=0; i<msg->n_moves; i++) {
VectorMigrateInfo &move = msg->moves[i];
CkVec<LDObjData> objs;
CkVec<LDCommData> comms;
if (move.from_pe == CkMyPe()) {
int toPe = move.to_pe;
double load = move.load;
GetObjsToMigrate(toPe, load, statsData, atlevel, comms, objs);
int count = objs.size();
if (_lb_args.debug()>1)
CkPrintf("[%d] sending %d objects to %d at %f.\n", CkMyPe(), count, toPe, CkWallTimer());
if (objs.size() > 0)
thisProxy[toPe].ObjsMigrated(objs, objs.size(), comms.getVec(), comms.size(), atlevel);
thisProxy[toPe].TotalObjMigrated(count, atlevel);
}
else if (move.to_pe == CkMyPe()) {
// expecting objects
lData->vector_expected ++;
}
}
if (_lb_args.debug()>1)
CkPrintf("[%d] expecting %d vectors. \n", CkMyPe(), lData->vector_expected);
if (lData->vectorReceived()) {
VectorDone(atlevel);
if (lData->migrationDone())
StatsDone(atlevel);
}
delete msg;
#endif
}
void HybridBaseLB::AtSync()
{
#if CMK_LBDB_ON
// CkPrintf("[%d] HybridBaseLB At Sync step %d!!!!\n",CkMyPe(),mystep);
FindNeighbors();
// if num of processor is only 1, nothing should happen
if (!QueryBalanceNow(step()) || CkNumPes() == 1) {
MigrationDone(0);
return;
}
thisProxy[CkMyPe()].ProcessAtSync();
#endif
}
void WSLB::ReceiveMigration(LBMigrateMsg *msg)
{
#if CMK_LBDB_ON
if (neighbor_pes == 0) FindNeighbors();
if (mig_msgs_received == 0) migrates_expected = 0;
mig_msgs[mig_msgs_received] = msg;
mig_msgs_received++;
// CkPrintf("[%d] Received migration msg %d of %d\n",
// CkMyPe(),mig_msgs_received,mig_msgs_expected);
if (mig_msgs_received > mig_msgs_expected) {
CkPrintf("[%d] WSLB Error! Too many migration messages received\n",
CkMyPe());
}
if (mig_msgs_received != mig_msgs_expected) {
return;
}
// CkPrintf("[%d] in ReceiveMigration %d moves\n",CkMyPe(),msg->n_moves);
for(int neigh=0; neigh < mig_msgs_received;neigh++) {
LBMigrateMsg* m = mig_msgs[neigh];
for(int i=0; i < m->n_moves; i++) {
MigrateInfo& move = m->moves[i];
const int me = CkMyPe();
if (move.from_pe != me && move.to_pe == me) {
migrates_expected++;
}
}
delete m;
mig_msgs[neigh]=0;
}
// CkPrintf("[%d] in ReceiveMigration %d expected\n",
// CkMyPe(),migrates_expected);
mig_msgs_received = 0;
if (migrates_expected == 0 || migrates_expected == migrates_completed)
MigrationDone();
#endif
}
void HybridBaseLB::ReceiveStats(CkMarshalledCLBStatsMessage &data, int fromlevel)
{
#if CMK_LBDB_ON
FindNeighbors();
// store the message
CLBStatsMsg *m = data.getMessage();
int atlevel = fromlevel + 1;
CmiAssert(tree->isroot(CkMyPe(), atlevel));
depositLBStatsMessage(m, atlevel);
int &stats_msg_count = levelData[atlevel]->stats_msg_count;
stats_msg_count ++;
DEBUGF(("[%d] ReceiveStats at level: %d %d/%d\n", CkMyPe(), atlevel, stats_msg_count, levelData[atlevel]->nChildren));
if (stats_msg_count == levelData[atlevel]->nChildren)
{
// build LDStats
buildStats(atlevel);
stats_msg_count = 0;
int parent = levelData[atlevel]->parent;
if (parent != -1) {
// combine and shrink message
// build a new message based on our LDStats
CLBStatsMsg* cmsg = buildCombinedLBStatsMessage(atlevel);
// send to parent
CkMarshalledCLBStatsMessage marshmsg(cmsg);
thisProxy[parent].ReceiveStats(marshmsg, atlevel);
}
else {
// root of all processors, calls top-level strategy (refine)
thisProxy[CkMyPe()].Loadbalancing(atlevel);
}
}
#endif
}
void JumpPointSearch::IdentifySuccessors(Node* node) {
if (!node) return;
std::vector<Node*> neighbors = FindNeighbors(node);
int ng = 0;
for (Node* neighbor : neighbors) {
if (!neighbor) continue;
Node* jump_point = Jump(neighbor->x, neighbor->y, node->x, node->y);
if (jump_point) {
if (jump_point->closed) continue;
int dx = jump_point->x - node->x;
int dy = jump_point->y - node->y;
int dist = static_cast<int>(std::sqrt(dx * dx + dy * dy));
ng = node->g + dist;
if (!jump_point->opened || ng < jump_point->g) {
jump_point->parent = node;
jump_point->g = ng;
jump_point->h = m_Heuristic(jump_point, m_Goal);
if (!jump_point->opened) {
jump_point->opened = true;
m_OpenSet.Push(jump_point);
} else {
m_OpenSet.Update();
}
}
}
}
}
void WSLB::ReceiveStats(WSLBStatsMsg *m)
{
#if CMK_LBDB_ON
if (neighbor_pes == 0) FindNeighbors();
if (m == 0) { // This is from our own node
receive_stats_ready = 1;
} else {
const int pe = m->from_pe;
// CkPrintf("Stats msg received, %d %d %d %d %p\n",
// pe,stats_msg_count,m->n_objs,m->serial,m);
int peslot = -1;
for(int i=0; i < mig_msgs_expected; i++) {
if (pe == neighbor_pes[i]) {
peslot = i;
break;
}
}
if (peslot == -1 || statsMsgsList[peslot] != 0) {
CkPrintf("*** Unexpected WSLBStatsMsg in ReceiveStats from PE %d ***\n",
pe);
} else {
statsMsgsList[peslot] = m;
statsDataList[peslot].from_pe = m->from_pe;
statsDataList[peslot].total_walltime = m->total_walltime;
statsDataList[peslot].total_cputime = m->total_cputime;
statsDataList[peslot].idletime = m->idletime;
statsDataList[peslot].bg_walltime = m->bg_walltime;
statsDataList[peslot].bg_cputime = m->bg_cputime;
statsDataList[peslot].proc_speed = m->proc_speed;
statsDataList[peslot].obj_walltime = m->obj_walltime;
statsDataList[peslot].obj_cputime = m->obj_cputime;
statsDataList[peslot].vacate_me = m->vacate_me;
statsDataList[peslot].usage = m->usage;
stats_msg_count++;
}
}
const int clients = mig_msgs_expected;
if (stats_msg_count == clients && receive_stats_ready) {
double strat_start_time = CkWallTimer();
receive_stats_ready = 0;
LBMigrateMsg* migrateMsg = Strategy(statsDataList,clients);
int i;
// Migrate messages from me to elsewhere
for(i=0; i < migrateMsg->n_moves; i++) {
MigrateInfo& move = migrateMsg->moves[i];
const int me = CkMyPe();
if (move.from_pe == me && move.to_pe != me) {
theLbdb->Migrate(move.obj,move.to_pe);
} else if (move.from_pe != me) {
CkPrintf("[%d] error, strategy wants to move from %d to %d\n",
me,move.from_pe,move.to_pe);
}
}
// Now, send migrate messages to neighbors
thisProxy.ReceiveMigration(migrateMsg,mig_msgs_expected,neighbor_pes);
// Zero out data structures for next cycle
for(i=0; i < clients; i++) {
delete statsMsgsList[i];
statsMsgsList[i]=0;
}
stats_msg_count=0;
theLbdb->ClearLoads();
if (CkMyPe() == 0) {
double strat_end_time = CkWallTimer();
CkPrintf("Strat elapsed time %f\n",strat_end_time-strat_start_time);
}
}
#endif
}
/* -------------------------------------------------------------------------
* Function : EncapsulateAndForwardPacket
* Description: Encapsulate a captured raw IP packet and forward it
* Input : intf - the network interface on which to forward the packet
* encapsulationUdpData - The encapsulation header, followed by
* the encapsulated IP packet
* source - the source IP address of the BMF packet, or NULL if
* unknown or not applicable
* forwardedBy - the IP address of the node that forwarded the BMF
* packet, or NULL if unknown or not applicable
* forwardedTo - the IP address of the node to which the BMF packet
* was directed, or NULL if unknown or not applicable
* Output : none
* Return : none
* Data Used : none
* ------------------------------------------------------------------------- */
static void EncapsulateAndForwardPacket(
struct TBmfInterface* intf,
unsigned char* encapsulationUdpData,
union olsr_ip_addr* source,
union olsr_ip_addr* forwardedBy,
union olsr_ip_addr* forwardedTo)
{
/* Retrieve the number of bytes to be forwarded via the encapsulation socket */
u_int16_t udpDataLen = GetEncapsulationUdpDataLength(encapsulationUdpData);
/* The next destination(s) */
struct TBestNeighbors bestNeighborLinks;
struct link_entry* bestNeighbor;
int nPossibleNeighbors = 0;
struct sockaddr_in forwardTo; /* Next destination of encapsulation packet */
int nPacketsToSend;
int sendUnicast; /* 0 = send broadcast; 1 = send unicast */
int i;
/* Find at most 'FanOutLimit' best neigbors to forward the packet to */
FindNeighbors(
&bestNeighborLinks,
&bestNeighbor,
intf,
source,
forwardedBy,
forwardedTo,
&nPossibleNeighbors);
if (nPossibleNeighbors <= 0)
{
OLSR_PRINTF(
8,
"%s: --> not encap-forwarding on \"%s\": there is no neighbor that needs my retransmission\n",
PLUGIN_NAME_SHORT,
intf->ifName);
return;
} /* if */
/* Compose destination of encapsulation packet */
memset(&forwardTo, 0, sizeof(forwardTo));
forwardTo.sin_family = AF_INET;
forwardTo.sin_port = htons(BMF_ENCAP_PORT);
/* Start by filling in the local broadcast address. This may be overwritten later. */
forwardTo.sin_addr = intf->broadAddr.v4;
/* - If the BMF mechanism is BM_UNICAST_PROMISCUOUS, always send just one
* unicast packet (to the best neighbor).
* - But if the BMF mechanism is BM_BROADCAST,
* - send 'nPossibleNeighbors' unicast packets if there are up to
* 'FanOutLimit' possible neighbors,
* - if there are more than 'FanOutLimit' possible neighbors, then
* send a (WLAN-air-expensive, less reliable) broadcast packet. */
if (BmfMechanism == BM_UNICAST_PROMISCUOUS)
{
/* One unicast packet to the best neighbor */
nPacketsToSend = 1;
sendUnicast = 1;
bestNeighborLinks.links[0] = bestNeighbor;
}
else /* BmfMechanism == BM_BROADCAST */
{
if (nPossibleNeighbors <= FanOutLimit)
{
/* 'nPossibleNeighbors' unicast packets */
nPacketsToSend = nPossibleNeighbors;
sendUnicast = 1;
}
else /* nPossibleNeighbors > FanOutLimit */
{
/* One broadcast packet, possibly retransmitted as specified in the
* 'BroadcastRetransmitCount' plugin parameter */
nPacketsToSend = BroadcastRetransmitCount;
sendUnicast = 0;
} /* if */
} /* if */
for (i = 0; i < nPacketsToSend; i++)
{
int nBytesWritten;
int pollret;
struct pollfd guard;
guard.fd = intf->encapsulatingSkfd;
guard.events = POLLOUT;
if (sendUnicast == 1)
{
/* For unicast, overwrite the local broadcast address which was filled in above */
forwardTo.sin_addr = bestNeighborLinks.links[i]->neighbor_iface_addr.v4;
}
/* Daniele Lacamera: poll guard to avoid locking in sendto().
* Wait at most 2 polling periods. Since we're running in the context of the main
* OLSR thread, we should not wait too long. 2 polling periods is considered a
* reasonable time. */
pollret = poll (&guard, 1, 2 * olsr_cnf->pollrate * MSEC_PER_SEC);
if (pollret <= 0)
{
BmfPError("sendto() on \"%s\": not ready to send pkt. pollret=%d\n", intf->ifName, pollret);
/* Apparently the network interface is jammed. Give up and return. */
return;
}
/* Forward the BMF packet via the encapsulation socket */
nBytesWritten = sendto(
intf->encapsulatingSkfd,
encapsulationUdpData,
udpDataLen,
MSG_DONTROUTE,
(struct sockaddr*) &forwardTo,
sizeof(forwardTo));
/* Evaluate and display result */
if (nBytesWritten != udpDataLen)
{
BmfPError("sendto() error forwarding encapsulated pkt on \"%s\"", intf->ifName);
return;
} /* if (nBytesWritten != udpDataLen) */
/* Increase counter */
intf->nBmfPacketsTx++;
OLSR_PRINTF(
8,
"%s: --> forwarded encapsulated packet on \"%s\" to %s\n",
PLUGIN_NAME_SHORT,
intf->ifName,
inet_ntoa(forwardTo.sin_addr));
} /* for */
} /* EncapsulateAndForwardPacket */
static void
generate_system (ModeInfo * mi)
{
pipesstruct *pp = &pipes[MI_SCREEN(mi)];
Bool wire = MI_IS_WIREFRAME(mi);
int newdir;
int OPX, OPY, OPZ;
Bool reset_p = False;
pp->system_index = 0;
pp->system_size = 0;
pinit (mi, 1);
while (1) {
glNewList (get_dlist (mi, pp->system_size++), GL_COMPILE);
mi->polygon_count = 0;
glPushMatrix();
FindNeighbors(mi);
if (wire)
glColor4fv (pp->system_color);
else
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, pp->system_color);
/* If it's the begining of a system, draw a sphere */
if (pp->olddir == dirNone) {
glPushMatrix();
glTranslatef((pp->PX - 16) / 3.0 * 4.0, (pp->PY - 12) / 3.0 * 4.0, (pp->PZ - 16) / 3.0 * 4.0);
mySphere(0.6, wire);
glPopMatrix();
}
/* Check for stop conditions */
if (pp->ndirections == 0 || pp->counter > pp->system_length) {
glPushMatrix();
glTranslatef((pp->PX - 16) / 3.0 * 4.0, (pp->PY - 12) / 3.0 * 4.0, (pp->PZ - 16) / 3.0 * 4.0);
/* Finish the system with another sphere */
mySphere(0.6, wire);
glPopMatrix();
/* If the maximum number of system was drawn, restart (clearing the screen), */
/* else start a new system. */
if (++pp->system_number > pp->number_of_systems) {
reset_p = True;
} else {
pinit(mi, 0);
}
goto NEXT;
}
pp->counter++;
pp->turncounter++;
/* Do will the direction change? if so, determine the new one */
newdir = pp->nowdir;
if (!pp->directions[newdir]) { /* cannot proceed in the current direction */
newdir = SelectNeighbor(mi);
} else {
if (tightturns) {
/* random change (20% chance) */
if ((pp->counter > 1) && (NRAND(100) < 20)) {
newdir = SelectNeighbor(mi);
}
} else {
/* Chance to turn increases after each length of pipe drawn */
if ((pp->counter > 1) && NRAND(50) < NRAND(pp->turncounter + 1)) {
newdir = SelectNeighbor(mi);
pp->turncounter = 0;
}
}
}
/* Has the direction changed? */
if (newdir == pp->nowdir) {
/* If not, draw the cell's center pipe */
glPushMatrix();
glTranslatef((pp->PX - 16) / 3.0 * 4.0, (pp->PY - 12) / 3.0 * 4.0, (pp->PZ - 16) / 3.0 * 4.0);
/* Chance of factory shape here, if enabled. */
if ((pp->counter > 1) && (NRAND(100) < factory)) {
MakeShape(mi, newdir);
} else {
MakeTube(mi, newdir);
}
glPopMatrix();
} else {
/* If so, draw the cell's center elbow/sphere */
int sysT = pp->system_type;
if (sysT == NofSysTypes + 1) {
sysT = ((pp->system_number - 1) % NofSysTypes) + 1;
}
glPushMatrix();
switch (sysT) {
case 1:
glTranslatef((pp->PX - 16) / 3.0 * 4.0, (pp->PY - 12) / 3.0 * 4.0, (pp->PZ - 16) / 3.0 * 4.0);
mySphere(elbowradius, wire);
break;
case 2:
case 3:
switch (pp->nowdir) {
case dirUP:
switch (newdir) {
case dirLEFT:
glTranslatef((pp->PX - 16) / 3.0 * 4.0 - (one_third), (pp->PY - 12) / 3.0 * 4.0 - (one_third), (pp->PZ - 16) / 3.0 * 4.0);
glRotatef(180.0, 1.0, 0.0, 0.0);
break;
case dirRIGHT:
glTranslatef((pp->PX - 16) / 3.0 * 4.0 + (one_third), (pp->PY - 12) / 3.0 * 4.0 - (one_third), (pp->PZ - 16) / 3.0 * 4.0);
glRotatef(180.0, 1.0, 0.0, 0.0);
glRotatef(180.0, 0.0, 1.0, 0.0);
break;
case dirFAR:
glTranslatef((pp->PX - 16) / 3.0 * 4.0, (pp->PY - 12) / 3.0 * 4.0 - (one_third), (pp->PZ - 16) / 3.0 * 4.0 - (one_third));
glRotatef(90.0, 0.0, 1.0, 0.0);
glRotatef(180.0, 0.0, 0.0, 1.0);
break;
case dirNEAR:
glTranslatef((pp->PX - 16) / 3.0 * 4.0, (pp->PY - 12) / 3.0 * 4.0 - (one_third), (pp->PZ - 16) / 3.0 * 4.0 + (one_third));
glRotatef(90.0, 0.0, 1.0, 0.0);
glRotatef(180.0, 1.0, 0.0, 0.0);
break;
}
break;
case dirDOWN:
switch (newdir) {
case dirLEFT:
glTranslatef((pp->PX - 16) / 3.0 * 4.0 - (one_third), (pp->PY - 12) / 3.0 * 4.0 + (one_third), (pp->PZ - 16) / 3.0 * 4.0);
break;
case dirRIGHT:
glTranslatef((pp->PX - 16) / 3.0 * 4.0 + (one_third), (pp->PY - 12) / 3.0 * 4.0 + (one_third), (pp->PZ - 16) / 3.0 * 4.0);
glRotatef(180.0, 0.0, 1.0, 0.0);
break;
case dirFAR:
glTranslatef((pp->PX - 16) / 3.0 * 4.0, (pp->PY - 12) / 3.0 * 4.0 + (one_third), (pp->PZ - 16) / 3.0 * 4.0 - (one_third));
glRotatef(270.0, 0.0, 1.0, 0.0);
break;
case dirNEAR:
glTranslatef((pp->PX - 16) / 3.0 * 4.0, (pp->PY - 12) / 3.0 * 4.0 + (one_third), (pp->PZ - 16) / 3.0 * 4.0 + (one_third));
glRotatef(90.0, 0.0, 1.0, 0.0);
break;
}
break;
case dirLEFT:
switch (newdir) {
case dirUP:
glTranslatef((pp->PX - 16) / 3.0 * 4.0 + (one_third), (pp->PY - 12) / 3.0 * 4.0 + (one_third), (pp->PZ - 16) / 3.0 * 4.0);
glRotatef(180.0, 0.0, 1.0, 0.0);
break;
case dirDOWN:
glTranslatef((pp->PX - 16) / 3.0 * 4.0 + (one_third), (pp->PY - 12) / 3.0 * 4.0 - (one_third), (pp->PZ - 16) / 3.0 * 4.0);
glRotatef(180.0, 1.0, 0.0, 0.0);
glRotatef(180.0, 0.0, 1.0, 0.0);
break;
case dirFAR:
glTranslatef((pp->PX - 16) / 3.0 * 4.0 + (one_third), (pp->PY - 12) / 3.0 * 4.0, (pp->PZ - 16) / 3.0 * 4.0 - (one_third));
glRotatef(270.0, 1.0, 0.0, 0.0);
glRotatef(180.0, 0.0, 1.0, 0.0);
break;
case dirNEAR:
glTranslatef((pp->PX - 16) / 3.0 * 4.0 + (one_third), (pp->PY - 12) / 3.0 * 4.0, (pp->PZ - 16) / 3.0 * 4.0 + (one_third));
glRotatef(270.0, 1.0, 0.0, 0.0);
glRotatef(180.0, 0.0, 0.0, 1.0);
break;
}
break;
case dirRIGHT:
switch (newdir) {
case dirUP:
glTranslatef((pp->PX - 16) / 3.0 * 4.0 - (one_third), (pp->PY - 12) / 3.0 * 4.0 + (one_third), (pp->PZ - 16) / 3.0 * 4.0);
break;
case dirDOWN:
glTranslatef((pp->PX - 16) / 3.0 * 4.0 - (one_third), (pp->PY - 12) / 3.0 * 4.0 - (one_third), (pp->PZ - 16) / 3.0 * 4.0);
glRotatef(180.0, 1.0, 0.0, 0.0);
break;
case dirFAR:
glTranslatef((pp->PX - 16) / 3.0 * 4.0 - (one_third), (pp->PY - 12) / 3.0 * 4.0, (pp->PZ - 16) / 3.0 * 4.0 - (one_third));
glRotatef(270.0, 1.0, 0.0, 0.0);
break;
case dirNEAR:
glTranslatef((pp->PX - 16) / 3.0 * 4.0 - (one_third), (pp->PY - 12) / 3.0 * 4.0, (pp->PZ - 16) / 3.0 * 4.0 + (one_third));
glRotatef(90.0, 1.0, 0.0, 0.0);
break;
}
break;
case dirNEAR:
switch (newdir) {
case dirLEFT:
glTranslatef((pp->PX - 16) / 3.0 * 4.0 - (one_third), (pp->PY - 12) / 3.0 * 4.0, (pp->PZ - 16) / 3.0 * 4.0 - (one_third));
glRotatef(270.0, 1.0, 0.0, 0.0);
break;
case dirRIGHT:
glTranslatef((pp->PX - 16) / 3.0 * 4.0 + (one_third), (pp->PY - 12) / 3.0 * 4.0, (pp->PZ - 16) / 3.0 * 4.0 - (one_third));
glRotatef(270.0, 1.0, 0.0, 0.0);
glRotatef(180.0, 0.0, 1.0, 0.0);
break;
case dirUP:
glTranslatef((pp->PX - 16) / 3.0 * 4.0, (pp->PY - 12) / 3.0 * 4.0 + (one_third), (pp->PZ - 16) / 3.0 * 4.0 - (one_third));
glRotatef(270.0, 0.0, 1.0, 0.0);
break;
case dirDOWN:
glTranslatef((pp->PX - 16) / 3.0 * 4.0, (pp->PY - 12) / 3.0 * 4.0 - (one_third), (pp->PZ - 16) / 3.0 * 4.0 - (one_third));
glRotatef(90.0, 0.0, 1.0, 0.0);
glRotatef(180.0, 0.0, 0.0, 1.0);
break;
}
break;
case dirFAR:
switch (newdir) {
case dirUP:
glTranslatef((pp->PX - 16) / 3.0 * 4.0, (pp->PY - 12) / 3.0 * 4.0 + (one_third), (pp->PZ - 16) / 3.0 * 4.0 + (one_third));
glRotatef(90.0, 0.0, 1.0, 0.0);
break;
case dirDOWN:
glTranslatef((pp->PX - 16) / 3.0 * 4.0, (pp->PY - 12) / 3.0 * 4.0 - (one_third), (pp->PZ - 16) / 3.0 * 4.0 + (one_third));
glRotatef(90.0, 0.0, 1.0, 0.0);
glRotatef(180.0, 1.0, 0.0, 0.0);
break;
case dirLEFT:
glTranslatef((pp->PX - 16) / 3.0 * 4.0 - (one_third), (pp->PY - 12) / 3.0 * 4.0, (pp->PZ - 16) / 3.0 * 4.0 + (one_third));
glRotatef(90.0, 1.0, 0.0, 0.0);
break;
case dirRIGHT:
glTranslatef((pp->PX - 16) / 3.0 * 4.0 + (one_third), (pp->PY - 12) / 3.0 * 4.0, (pp->PZ - 16) / 3.0 * 4.0 + (one_third));
glRotatef(270.0, 1.0, 0.0, 0.0);
glRotatef(180.0, 0.0, 0.0, 1.0);
break;
}
break;
}
myElbow(mi, (sysT == 2));
break;
}
glPopMatrix();
}
OPX = pp->PX;
OPY = pp->PY;
OPZ = pp->PZ;
pp->olddir = pp->nowdir;
pp->nowdir = newdir;
switch (pp->nowdir) {
case dirUP:
pp->PY++;
break;
case dirDOWN:
pp->PY--;
break;
case dirLEFT:
pp->PX--;
break;
case dirRIGHT:
pp->PX++;
break;
case dirNEAR:
pp->PZ++;
break;
case dirFAR:
pp->PZ--;
break;
}
pp->Cells[pp->PX][pp->PY][pp->PZ] = 1;
/* Cells'face pipe */
glTranslatef(((pp->PX + OPX) / 2.0 - 16) / 3.0 * 4.0, ((pp->PY + OPY) / 2.0 - 12) / 3.0 * 4.0, ((pp->PZ + OPZ) / 2.0 - 16) / 3.0 * 4.0);
MakeTube(mi, newdir);
NEXT:
glPopMatrix();
glEndList();
pp->poly_counts [pp->system_size-1] = mi->polygon_count;
if (reset_p)
break;
}
}
static void
pinit(ModeInfo * mi, int zera)
{
pipesstruct *pp = &pipes[MI_SCREEN(mi)];
int X, Y, Z;
if (zera) {
pp->system_number = 1;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
(void) memset(pp->Cells, 0, sizeof (pp->Cells));
for (X = 0; X < HCELLS; X++) {
for (Y = 0; Y < VCELLS; Y++) {
pp->Cells[X][Y][0] = 1;
pp->Cells[X][Y][HCELLS - 1] = 1;
pp->Cells[0][Y][X] = 1;
pp->Cells[HCELLS - 1][Y][X] = 1;
}
}
for (X = 0; X < HCELLS; X++) {
for (Z = 0; Z < HCELLS; Z++) {
pp->Cells[X][0][Z] = 1;
pp->Cells[X][VCELLS - 1][Z] = 1;
}
}
(void) memset(pp->usedcolors, 0, sizeof (pp->usedcolors));
}
pp->counter = 0;
pp->turncounter = 0;
if (!MI_IS_MONO(mi)) {
int collist[DEFINEDCOLORS];
int i, j, lower = 1000;
/* Avoid repeating colors on the same screen unless necessary */
for (i = 0; i < DEFINEDCOLORS; i++) {
if (lower > pp->usedcolors[i])
lower = pp->usedcolors[i];
}
for (i = 0, j = 0; i < DEFINEDCOLORS; i++) {
if (pp->usedcolors[i] == lower) {
collist[j] = i;
j++;
}
}
i = collist[NRAND(j)];
pp->usedcolors[i]++;
switch (i) {
case 0:
pp->system_color = MaterialRed;
break;
case 1:
pp->system_color = MaterialGreen;
break;
case 2:
pp->system_color = MaterialBlue;
break;
case 3:
pp->system_color = MaterialCyan;
break;
case 4:
pp->system_color = MaterialYellow;
break;
case 5:
pp->system_color = MaterialMagenta;
break;
case 6:
pp->system_color = MaterialWhite;
break;
}
} else {
pp->system_color = MaterialGray;
}
do {
pp->PX = NRAND((HCELLS - 1)) + 1;
pp->PY = NRAND((VCELLS - 1)) + 1;
pp->PZ = NRAND((HCELLS - 1)) + 1;
} while (pp->Cells[pp->PX][pp->PY][pp->PZ] ||
(pp->Cells[pp->PX + 1][pp->PY][pp->PZ] && pp->Cells[pp->PX - 1][pp->PY][pp->PZ] &&
pp->Cells[pp->PX][pp->PY + 1][pp->PZ] && pp->Cells[pp->PX][pp->PY - 1][pp->PZ] &&
pp->Cells[pp->PX][pp->PY][pp->PZ + 1] && pp->Cells[pp->PX][pp->PY][pp->PZ - 1]));
pp->Cells[pp->PX][pp->PY][pp->PZ] = 1;
pp->olddir = dirNone;
FindNeighbors(mi);
pp->nowdir = SelectNeighbor(mi);
}
// migrate only object LDStat in group
// leaf nodes actually migrate objects
void HybridBaseLB::ReceiveMigration(LBMigrateMsg *msg)
{
#if CMK_LBDB_ON
#if CMK_MEM_CHECKPOINT
CkResetInLdb();
#endif
FindNeighbors();
int atlevel = msg->level - 1;
DEBUGF(("[%d] ReceiveMigration\n", CkMyPe()));
LevelData *lData = levelData[atlevel];
// only non NULL when level > 0
LDStats *statsData = lData->statsData;
// do LDStats migration
const int me = CkMyPe();
lData->migrates_expected = 0;
for(int i=0; i < msg->n_moves; i++) {
MigrateInfo& move = msg->moves[i];
// incoming
if (move.from_pe != me && move.to_pe == me) {
// I can not be the parent node
DEBUGF(("[%d] expecting LDStats object from %d\n",me,move.from_pe));
// will receive a ObjData message
lData->migrates_expected ++;
}
else if (move.from_pe == me) { // outgoing
if (statsData) { // this is inner node
// send objdata
int obj;
int found = 0;
for (obj = 0; obj<statsData->n_objs; obj++) {
if (move.obj.omID() == statsData->objData[obj].handle.omID() &&
move.obj.objID() == statsData->objData[obj].handle.objID())
{
DEBUGF(("[%d] level: %d sending objData %d to %d. \n", CkMyPe(), atlevel, obj, move.to_pe));
found = 1;
// TODO send comm data
CkVec<LDCommData> comms;
collectCommData(obj, comms, atlevel);
if (move.to_pe != -1) {
// this object migrates to another PE of the parent domain
thisProxy[move.to_pe].ObjMigrated(statsData->objData[obj], comms.getVec(), comms.size(), atlevel);
}
lData->outObjs.push_back(MigrationRecord(move.obj, lData->children[statsData->from_proc[obj]], -1));
statsData->removeObject(obj);
break;
}
}
CmiAssert(found == 1);
}
else { // this is leave node
if (move.to_pe == -1) {
lData->outObjs.push_back(MigrationRecord(move.obj, CkMyPe(), -1));
}
else {
// migrate the object
theLbdb->Migrate(move.obj,move.to_pe);
}
}
} // end if
}
if (lData->migrationDone())
StatsDone(atlevel);
#endif
}