void LUResolveMPI(int n,float resolving[][maxN]) { //First We need to Matrix resolving, for it is common to initailize resolving in One process array=MPI::FLOAT.Create_contiguous(n); array.Commit(); //Then we need to Scatter the content of resolving for(int i=0;i<n;i+=totalProcNum) MPI::COMM_WORLD.Scatter(resolving+i, 1, array, resolving+i+nowProcID, 1, array, 0); //This time we just assume that ProcNum can completely divide the Scale, then we finished //We start the round for(int nowRound=0;nowRound<n;nowRound++) { int master=nowRound%totalProcNum; if(nowProcID==master) for(int i=nowRound+1;i<n;i++) buffer[i]=(resolving[nowRound][i]/=resolving[nowRound][nowRound]); //Then we use broadcast let this part to all MPI::COMM_WORLD.Bcast(buffer+nowRound+1,n-nowRound-1,MPI::INT,master); //Now we can use the buffer Number to be calculate the number for(int row=n-totalProcNum+nowProcID;row>=nowRound+1;row-=totalProcNum) for(int column=nowRound+1;column<n;column++) resolving[row][column]=resolving[row][column]-resolving[row][nowRound]*buffer[column]; } //We finished calculate process //Then we gather the whole matrix for(int i=0;i<n;i+=totalProcNum) MPI::COMM_WORLD.Gather(resolving+i+nowProcID,1,array,resolving+i,1,array,0); //We finish gathering matrix array.Free(); }
void runSimulation() { int outputFrequency = 1; int maxSteps = 200; double factor = pow(MPILayer().size(), 1.0/3.0); Coord<3> baseDim(15, 15, 15); Coord<3> dim(factor * baseDim.x(), factor * baseDim.y(), factor * baseDim.z()); MPI::Aint displacements[] = {0}; MPI::Datatype memberTypes[] = {MPI::CHAR}; int lengths[] = { sizeof(CELL) }; MPI::Datatype objType; objType = MPI::Datatype::Create_struct(1, lengths, displacements, memberTypes); objType.Commit(); NBodyInitializer<CELL> *init = new NBodyInitializer<CELL>(dim, maxSteps); // HiParSimulator::HiParSimulator<CELL, HiParSimulator::RecursiveBisectionPartition<3> > sim( // init, // MPILayer().rank() ? 0 : new TracingBalancer(new NoOpBalancer()), // maxSteps, // 1, // objType); SerialSimulator<CELL> sim(init); if (MPILayer().rank() == 0) { std::cout << "ranks: " << MPILayer().size() << "\n" << "dim: " << dim << "\n" << "serial1\n"; sim.addWriter( new TracingWriter<CELL>(outputFrequency, init->maxSteps())); } long long tStart = Chronometer::timeUSec(); sim.run(); long long tEnd = Chronometer::timeUSec(); double seconds = 1e-6 * (tEnd - tStart); double flops = // time steps * grid size 1.0 * maxSteps * dim.prod() * // interactions per container update 27 * CELL::SIZE * CELL::SIZE * // FLOPs per interaction (3 + 6 + 1 + 6); double gflops = 1e-9 * flops / seconds; std::cout << "GFLOPS: " << gflops << "\n" << "----------------------------------------------------------------------\n"; }
void ParaSolverTerminationStateMpi::receive( ParaComm *comm, int source, int tag ) { DEF_PARA_COMM( commMpi, comm); MPI::Datatype datatype; datatype = createDatatype(); datatype.Commit(); PARA_COMM_CALL( commMpi->receive(&interrupted, 1, datatype, source, tag) ); datatype.Free(); }
void ParaSolverTerminationStateMpi::send( ParaComm *comm, int destination, int tag ) { DEF_PARA_COMM( commMpi, comm); MPI::Datatype datatype; datatype = createDatatype(); datatype.Commit(); PARA_COMM_CALL( commMpi->send(&interrupted, 1, datatype, destination, tag) ); datatype.Free(); }
void ParaCalculationStateMpi::receive( ParaComm *comm, int source, int tag ) { DEF_PARA_COMM( commMpi, comm); MPI::Datatype datatype; datatype = createDatatype(); datatype.Commit(); PARA_COMM_CALL( commMpi->receive(&compTime, 1, datatype, source, tag) ); datatype.Free(); }
void ParaCalculationStateMpi::send( ParaComm *comm, int destination, int tag ) { DEF_PARA_COMM( commMpi, comm); MPI::Datatype datatype; datatype = createDatatype(); datatype.Commit(); PARA_COMM_CALL( commMpi->send(&compTime, 1, datatype, destination, tag) ); datatype.Free(); }
/* * Build and commit a user-defined MPI Struct datatype. * * \param mpiType new MPI datatype (on output). */ void MpiStructBuilder::commit(MPI::Datatype& mpiType) { for (int i = 0; i < nMember_; ++i) { addresses_[i] = addresses_[i] - base_; } mpiType = MPI::Datatype::Create_struct(nMember_, counts_, addresses_, types_); mpiType.Commit(); }
int main(int argc, char* argv[]) { MPI::Init(argc, argv); rank = MPI::COMM_WORLD.Get_rank(); size = MPI::COMM_WORLD.Get_size(); if (size < 2 || size > 32) MPI::COMM_WORLD.Abort(1); int brojVrsta = size - 1, brojKolona; if (0 == rank) { // master pline(); cout << "broj kolona matrice: "; fflush(stdout); cin >> brojKolona; for (int i=1; i<brojVrsta+1; i++) MPI::COMM_WORLD.Send(&brojKolona, 1, MPI::INT, i, 0); if (brojKolona <= 0 || brojKolona > 100) MPI::COMM_WORLD.Abort(1); pline(); cout << "ucitaj elemente matrice " << "[" << brojVrsta << "][" << brojKolona << "]" << endl; MPI::Datatype VRSTA = MPI::DOUBLE.Create_contiguous(brojKolona); VRSTA.Commit(); double matrica[brojVrsta][brojKolona]; for (int i=0; i<brojVrsta; i++) { for (int j=0; j<brojKolona; j++) { fflush(stdout); cin >> matrica[i][j]; } } for (int i=0; i<brojVrsta; i++) { MPI::COMM_WORLD.Send(matrica[i], 1, VRSTA, i+1, 0); } VRSTA.Free(); }
static void Union_Find_Merge_Op(const void* in,void* inout,int len,const MPI::Datatype& datatype) { // unpack union finds UNION_FIND<> union_find_in,union_find_inout; int m=datatype.Get_size();assert(len==1); {int position=0;MPI_UTILITIES::Unpack(union_find_in,ARRAY_VIEW<const char>(m,static_cast<const char*>(in)),position,*union_find_merge_op_comm);} {int position=0;MPI_UTILITIES::Unpack(union_find_inout,ARRAY_VIEW<const char>(m,static_cast<char*>(inout)),position,*union_find_merge_op_comm);} // merge union_find_inout.Merge(union_find_in); // pack output {int position=0;MPI_UTILITIES::Pack(union_find_inout,ARRAY_VIEW<char>(m,static_cast<char*>(inout)),position,*union_find_merge_op_comm);} }
int main(int argc, char **argv) { MPI::Init(argc, argv); QApplication app(argc, argv); LibGeoDecomp::Typemaps::initializeMaps(); MPI::Aint displacements[] = {0}; MPI::Datatype memberTypes[] = {MPI::CHAR}; int lengths[] = {sizeof(CanvasCell)}; MPI::Datatype objType; objType = MPI::Datatype::Create_struct(1, lengths, displacements, memberTypes); objType.Commit(); MPI::Datatype particleType; lengths[0] = sizeof(Particle); particleType = MPI::Datatype::Create_struct(1, lengths, displacements, memberTypes); particleType.Commit(); ParticleWidget *widget = 0; CanvasInitializer *init = getInit1(); HiParSimulator<CanvasCell, RecursiveBisectionPartition<2> > *sim = new HiParSimulator<CanvasCell, RecursiveBisectionPartition<2> >( init, MPILayer().rank() ? 0 : new NoOpBalancer(), 1000, 1, particleType); std::cout << "Simulator created ...\n"; // HiParSimulator<CanvasCell, RecursiveBisectionPartition<2> > sim( // new CanvasInitializer(dim.x(), dim.y()), // MPILayer().rank() ? 0 : new NoOpBalancer(), // 1000, // 1, // particleType); ForceSteerer *steerer = new ForceSteerer(1); sim->addSteerer(steerer); std::cout << "Steerer added ...\n"; Storage * storage = 0; if (MPILayer().rank() == 0) { storage = new Storage; widget = new ParticleWidget(*storage, init->gridDimensions(), Qt::black); widget->resize(1000, 500); widget->show(); std::cout << "Widget created ...\n"; } sim->addWriter(new TracingWriter<CanvasCell>(100, 100000)); sim->addWriter(new ParticleWriter(storage, init->gridDimensions(), 1, particleType)); FakeSimulator fakeSim(sim); // DebugOutput logger; QTimer timer; QTimer timerGL; QObject::connect(&timer, SIGNAL(timeout()), &fakeSim, SLOT(step())); // QObject::connect(&widget, SIGNAL(newFrame()), // &logger, SLOT(newFrame())); // QObject::connect(&widget, SIGNAL(forceRecorded(QPoint, QPoint)), // &logger, SLOT(addForce(QPoint, QPoint))); QObject::connect(storage, SIGNAL(forceRecorded(QVector2D, QVector2D)), steerer, SLOT(addForce(QVector2D, QVector2D))); QObject::connect(&timerGL, SIGNAL(timeout()), widget, SLOT(updateGL())); timer.start(10); timerGL.start(10); app.exec(); delete sim; MPI::Finalize(); }
static vector<int> kmeans(const vector<string> &dnas, int k) { int rank = MPI::COMM_WORLD.Get_rank(); int size = MPI::COMM_WORLD.Get_size(); int dnaLength = dnas[0].length(); //Define the string for dna as MPI type MPI::Datatype dnaType = MPI::CHAR.Create_contiguous(dnaLength + 1); dnaType.Commit(); //Define the class Bases as MPI type MPI::Datatype basesType, oldTypes[1]; MPI::Aint offsets[1]; int blockCounts[1]; oldTypes[0] = MPI::INT; offsets[0] = 0; blockCounts[0] = 4; basesType = MPI::Datatype::Create_struct(1, blockCounts, offsets, oldTypes); basesType.Commit(); vector<pair<int, int> > tasks(devideTasks(size, dnas.size())); int startIndex = tasks[rank].first; int endIndex = tasks[rank].second; vector<string> prevCenters(k, string(dnaLength, 'A')); vector<string> centers(k); if (isMaster(rank)) { centers = select_centers(dnas, k); } vector<int> belonging(dnas.size()); char *buffer = new char[dnaLength + 1]; while (true) { //Send the new centers to all tasks if (isMaster(rank)) { for (int i = 0; i < size; i++) { if (!isMaster(i)) { for (int j = 0; j < k; j++) { MPI::COMM_WORLD.Send(centers[j].c_str(), 1, dnaType, i, DEFAULT_TAG); } } } } //All tasks update their centers if (!isMaster(rank)) { for (int j = 0; j < k; j++) { MPI::COMM_WORLD.Recv(buffer, 1, dnaType, MASTER_RANK, DEFAULT_TAG); centers[j] = buffer; } } MPI::COMM_WORLD.Barrier(); if (equal(centers.begin(), centers.end(), prevCenters.begin())) { break; } prevCenters = centers; vector<vector<Bases> > sumClusters(k, vector<Bases>(dnaLength)); for (int i = startIndex; i < endIndex; i++) { int min_dis = numeric_limits<int>::max(); int belong; for (int j = 0; j < k; ++j) { int dis = cal_dis(dnas[i], centers[j]); if (dis < min_dis) { min_dis = dis; belong = j; } } belonging[i] = belong; for (int j = 0; j < dnaLength; j++) { int idx = get_idx(dnas[i][j]); sumClusters[belong][j].increase(idx); } } if (!isMaster(rank)) { for (int i = 0; i < k; i++) { MPI::COMM_WORLD.Send(&(sumClusters[i][0]), dnaLength, basesType, MASTER_RANK, DEFAULT_TAG); } } if (isMaster(rank)) { vector<vector<Bases> > aggrSumClusters(k, vector<Bases>(dnaLength)); for (int i = 0; i < k; i++) { for (int j = 0; j < dnaLength; j++) { aggrSumClusters[i][j] += sumClusters[i][j]; //cout << "cluster " << i << " dna " << j << " count " << aggrSumClusters[i][j].get_max() << endl; } } for (int i = 0; i < size; i++) { if (isMaster(i)) { continue; } for (int j = 0; j < k; j++) { MPI::COMM_WORLD.Recv(&(sumClusters[j][0]), dnaLength, basesType, i, DEFAULT_TAG); } for (int j = 0; j < k; j++) { for (int n = 0; n < dnaLength; n++) { aggrSumClusters[j][n] += sumClusters[j][n]; } } } for (int i = 0; i < centers.size(); ++i) { string center; for (int j = 0; j < dnas[0].size(); ++j) { center += get_base(aggrSumClusters[i][j].get_max()); } centers[i] = center; } } MPI::COMM_WORLD.Barrier(); } delete[] buffer; if (!isMaster(rank)) { MPI::COMM_WORLD.Send(&belonging[startIndex], endIndex - startIndex, MPI::INT, MASTER_RANK, DEFAULT_TAG); } if (isMaster(rank)) { for (int i = 0; i < size; i++) { if (isMaster(i)) { continue; } int taskStart = tasks[i].first; int taskEnd = tasks[i].second; MPI::COMM_WORLD.Recv(&belonging[taskStart], taskEnd - taskStart, MPI::INT, i, DEFAULT_TAG); } } return belonging; }
void PPS::start(){ //Define parameters struct for mpi //Refer to this as an example http://lists.mcs.anl.gov/pipermail/mpich-discuss/2009-April/004880.html MPI::Datatype MPIPPSTRUCT; int blockcounts[2]; MPI::Aint offsets[2]; MPI::Datatype datatypes[2]; MPI::Aint extent,lb; blockcounts[0] = 9; //Number of ints blockcounts[1] = 13; //number of __fpv datatypes[0] = MPI::INT; datatypes[1] = MPIFPV; offsets[0] = 0; MPI::INT.Get_extent(lb, extent); offsets[1] = blockcounts[0] * extent; MPIPPSTRUCT = MPIPPSTRUCT.Create_struct(2,blockcounts,offsets, datatypes); MPIPPSTRUCT.Commit(); if(PPS::pid == 0){ struct parameters temp; int start,i,countdown = PPS::comm_size-1; bool ready = false; MPI::Status status; //Logs std::ofstream logsfile; logsfile.open("tslogs.txt", std::fstream::out | std::fstream::trunc); while(true){ if(countdown == 0) break; //Check first ready-to-compute process MPI::COMM_WORLD.Recv(&ready, 1, MPI::BOOL, MPI_ANY_SOURCE, 0, status); //Logs logsfile << "Remaining sims: " << PPS::plist.size() << " process countdown: " << countdown << std::endl; //Send a 0 status to all the process to stop if(ready){ if(PPS::plist.size() == 0 ){ start = EXIT_PROCESS; MPI::COMM_WORLD.Send(&start, 1, MPI::INT, status.Get_source(), 0); countdown = countdown - 1; }else{ //Prepare him to receive the params and start the sim (an int that contains the simulation number (-1 = exit)) start = PPS::plist.size() - 1; MPI::COMM_WORLD.Send(&start, 1, MPI::INT, status.Get_source(), 0); temp = PPS::plist.back(); //temp.N = status.Get_source() * 10; //Deploy the parameterer struct MPI::COMM_WORLD.Send(&temp, 1, MPIPPSTRUCT, status.Get_source(), 0); //Pullout the parameter struct from the list plist.pop_back(); } } ready = false; } logsfile.close(); }else{ int status; bool ready = true; struct parameters recvparams; while(true){ status == EXIT_PROCESS; //Send with a point to point that you are free MPI::COMM_WORLD.Send(&ready, 1, MPI::BOOL, 0, 0); //receive status value to exit or to receive a new params struct to start new sim MPI::COMM_WORLD.Recv(&status, 1, MPI::INT, 0, 0); if(status != EXIT_PROCESS){ //wait to receive parameters //std::this_thread::sleep_for(std::chrono::seconds(PPS::pid)); MPI::COMM_WORLD.Recv(&recvparams, 1, MPIPPSTRUCT, 0, 0); //Start sim //std::cout << "//////////////////////////////////////////////////////////////////////////////////"<< std::endl; //std::cout << "SAY HI: "<< PPS::pid << std::endl; //print_params(recvparams); //std::cout << "STARTING REAL SIM"<< std::endl; PottsSim(recvparams,"output/"+ std::to_string(PPS::pid) + "_proc_output.dat", status); //old_code( PPS::pid ); //std::cout << "//////////////////////////////////////////////////////////////////////////////////"<< std::endl; }else{ std::cout << "I'm the process "<< PPS::pid << ", ready to die." << std::endl; break; } } } MPIPPSTRUCT.Free(); }