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 }