static char* MPI_ReadlineFunctionPointer(char* prompt) { char* result = 0; int stringSize = 0; Assert(Original_ReadlineFunctionPointer); Assert(prompt); if ( worldRank == 0 ) { prompt = adjustedPrompt(prompt); /* Apply localization */ result = Original_ReadlineFunctionPointer(prompt); deleteAdjustedPrompt(prompt); /* Release adjusted prompt */ if ( !result ) { stringSize = PYTHONBROADCAST_EOT; /* i.e. No Data */ MPICHECK( PyMPI_COMM_INPUT, MPI_Bcast(&stringSize,1,MPI_INT,0,PyMPI_COMM_INPUT) ); } else { stringSize = strlen(result); MPICHECK( PyMPI_COMM_INPUT, MPI_Bcast(&stringSize,1,MPI_INT,0,PyMPI_COMM_INPUT) ); MPICHECK( PyMPI_COMM_INPUT, MPI_Bcast(result,stringSize+1,MPI_CHAR,0,PyMPI_COMM_INPUT) ); } } /* ----------------------------------------------- */ /* Slaves will be making calls 1-1 with master */ /* ----------------------------------------------- */ else { int finalized = 0; MPICHECKCOMMLESS( PyMPI_Finalized(&finalized) ); if ( finalized ) return 0; /* Figure out the buffer size */ MPICHECK( PyMPI_COMM_INPUT, MPI_Bcast(&stringSize,1,MPI_INT,0,PyMPI_COMM_INPUT) ); if ( stringSize < 0 ) { result = 0; /* Error of some sort */ } else { result = (char*)malloc(stringSize+1); MPICHECK( PyMPI_COMM_INPUT, MPI_Bcast(result,stringSize+1,MPI_CHAR,0,PyMPI_COMM_INPUT) ); } } return result; pythonError: if ( result ) free(result); return 0; }
int main(int argc, char** argv) { //parparser parser(argc, argv); //long inititalPosition = parser.get("x").asLong(); srand(time(0)); //----------------------------------------------------------------------------- MPICHECK(MPI_Init(&argc, &argv)); //----------------------------------------------------------------------------- int commSize = 0; int rank = 0; MPICHECK(MPI_Comm_size(MPI_COMM_WORLD, &commSize)); MPICHECK(MPI_Comm_rank(MPI_COMM_WORLD, &rank)); const int nextProc = rank == commSize - 1 ? 0 : rank + 1; const int prevProc = rank == 0 ? commSize - 1 : rank - 1; vector<Individ> population(islandSize); for (int i = 0; i < islandSize; ++i) { population[i].init(problemSize); } for (int i = 1; i <= iterationsThreshold; ++i) { select(population); crossoverPopulation(population); mutatePopulation(population); if (i % migrationFreq == 0) { migrate(population, nextProc, prevProc); } cout << getBestFitness(population, rank, commSize) << "\n"; } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- MPICHECK(MPI_Finalize()); return 0; }
START_CPLUSPLUS /**************************************************************************/ /* GLOBAL ************** pyMPI_recv ************************/ /**************************************************************************/ /* Receive a message on a communicator object given source and tag */ /**************************************************************************/ PyObject* pyMPI_recv(PyMPI_Comm* self, int source, int tag) { PyMPI_Message buffer1; char* buffer2 = 0; PyObject* result = 0; PyObject* result_status = 0; MPI_Status status; /* ----------------------------------------------- */ /* MPI better be in ready state */ /* ----------------------------------------------- */ RAISEIFNOMPI(); /* ----------------------------------------------- */ /* Initial message */ /* ----------------------------------------------- */ Assert(self); MPICHECK( self->communicator, MPI_Recv(&buffer1, 1, pyMPI_message_datatype, source,tag, self->communicator,&status) ); /* ----------------------------------------------- */ /* Update the actual source/tag if we used */ /* wildcards */ /* ----------------------------------------------- */ if ( source == MPI_ANY_SOURCE ) source = status.MPI_SOURCE; if ( tag == MPI_ANY_TAG ) tag = status.MPI_TAG; if ( buffer1.header.bytes_in_second_message ) { buffer2 = (char*)malloc(buffer1.header.bytes_in_second_message); Assert(buffer2); MPI_Recv(buffer2, buffer1.header.bytes_in_second_message, MPI_BYTE,source,tag, self->communicator,&status); buffer1.header.free_buffer = 1; /* This malloc'd space needs to be freed */ } PYCHECK(result /*owned*/ = pyMPI_unpack(&buffer1,&buffer2)); PYCHECK(result_status/*owned*/ = pyMPI_resultstatus(/*consumes*/result,status) ); return result_status; pythonError: pyMPI_message_free(&buffer1,&buffer2); return 0; }
float getBestFitness(vector<Individ>& population, int rank, int commSize) { MPI_Status status; float localBest = 0.0; for (int i = 0; i < population.size(); ++i) { if (i == 0 || population[i].fitness < localBest) { localBest = population[i].fitness; } } float globalBest = localBest; if (rank == MASTER) { for (int i = 1; i < commSize; ++i) { float remoteBest; MPICHECK(MPI_Recv(&remoteBest, 1, MPI_FLOAT, i, 0, MPI_COMM_WORLD, &status)); if (remoteBest < globalBest) globalBest = remoteBest; } } else { MPICHECK(MPI_Send(&localBest, 1, MPI_FLOAT, MASTER, 0, MPI_COMM_WORLD)); } return globalBest; }
void migrate(vector<Individ>& population, int next, int prev) { const int indSize = population[0].genotype.size(); const int migrationSize = indSize * migratesIndividsPart; vector<float> buf(indSize, 0.0); MPI_Status status; for (int i = 0; i < migrationSize; ++i) { const int target = rand() % population.size(); MPICHECK(MPI_Sendrecv(&population[target].genotype[0], indSize, MPI_FLOAT, next, 0, &buf[0], indSize, MPI_FLOAT, prev, 0, MPI_COMM_WORLD, &status)); memcpy(&population[target].genotype[0], &buf[0], indSize * sizeof(float)); } }
/************************************************************************* * method: initpympi * This is called right after python has been initialized. MPI has already * been initialized here * ************************************************************************/ void initpympi() { PyObject* mpiName = 0; char versionString[32]; PyObject* lastWish = 0; int version; int subversion; PyObject* pickleModule = 0; PyObject* pickleDict = 0; PyObject* docString = 0; PyObject* pyWorld = 0; PyObject* member = 0; PyMethodDef* methodPtr = 0; char* docExtra = 0; int myRank = 0; int result = MPI_Comm_rank(MPI_COMM_WORLD, &myRank ); /* ----------------------------------------------- */ /* The IBM poe environment is brain dead */ /* ----------------------------------------------- */ #ifdef _AIX Py_InteractiveFlag++; #endif /* ----------------------------------------------- */ /* Cover our butts on assumptions */ /* ----------------------------------------------- */ Assert( sizeof(MPI_Comm) <= sizeof(long) ); /* ----------------------------------------------- */ /* We subvert the input stream to handle broadcast */ /* ----------------------------------------------- */ Original_ReadlineFunctionPointer = PyOS_ReadlineFunctionPointer; if ( !Original_ReadlineFunctionPointer ) { Original_ReadlineFunctionPointer = PyOS_StdioReadline; } PyOS_ReadlineFunctionPointer = MPI_ReadlineFunctionPointer; /* ----------------------------------------------- */ /* Setup the initial mpi module */ /* ----------------------------------------------- */ module = Py_InitModule("mpi",MPI_methods); Assert(module); PyMPI_dictionary = PyModule_GetDict(module); Assert(PyMPI_dictionary); /* ----------------------------------------------- */ /* Set up a docstring for the mpi module itself */ /* ----------------------------------------------- */ docExtra = DocStringFromMethods(MPI_methods,"mpi\n\nBasic mpi calls\n\n"); Assert(docExtra); docString = PyString_FromString(docExtra); free(docExtra); /* ----------------------------------------------- */ /* We start off with errors handled with flag */ /* ----------------------------------------------- */ if ( MPI_Errhandler_set(MPI_COMM_WORLD,MPI_ERRORS_RETURN) != MPI_SUCCESS ) { PYCHECK( PyErr_SetString(PyExc_SystemError,"MPI Failure -- MPI_Errhandler_set()") ); } /* ----------------------------------------------- */ /* See if we conform! */ /* ----------------------------------------------- */ MPICHECKCOMMLESS( MPI_Get_version(&version,&subversion) ); Assert(version == MPI_VERSION && subversion == MPI_SUBVERSION); /* ----------------------------------------------- */ /* We have some cleanup work to do on exit */ /* ----------------------------------------------- */ PYCHECK( lastWish = PyCFunction_New(&lastwishMethods,module) ); Assert(lastWish); sysExitfunc = PySys_GetObject("exitfunc"); PyErr_Clear(); PYCHECK( PySys_SetObject("exitfunc",lastWish) ); /* ----------------------------------------------- */ /* Set common attributes */ /* ----------------------------------------------- */ PYCHECK( PyDict_SetItemString(PyMPI_dictionary,"stdout",Py_None) ); Py_INCREF(Py_None); PYCHECK( PyString_ConcatFromString(&docString,"name: Name of MPI model (MPICH, LAM, mpi)") ); #ifdef MPICH_NAME PYCHECK( mpiName = PyString_FromString("MPICH") ); #else # ifdef LAM_MPI PYCHECK( mpiName = PyString_FromString("LAM") ); # else PYCHECK( mpiName = PyString_FromString("mpi") ); # endif #endif PYCHECK( PyDict_SetItemString(PyMPI_dictionary,"name",mpiName) ); PYCHECK( PyString_ConcatFromString(&docString,"rank: Rank of MPI_COMM_WORLD communicator\n") ); MPICHECK( MPI_COMM_WORLD, MPI_Comm_rank(MPI_COMM_WORLD,&worldRank)); PYCHECK(PyDict_SetItemString(PyMPI_dictionary,"rank", PyInt_FromLong((long)worldRank))); PYCHECK(PyString_ConcatFromString(&docString,"procs: Size of MPI_COMM_WORLD communicator\n")); MPICHECK( MPI_COMM_WORLD, MPI_Comm_size(MPI_COMM_WORLD,&worldProcs)); PYCHECK(PyDict_SetItemString(PyMPI_dictionary,"procs", PyInt_FromLong((long)worldProcs))); PYCHECK(PyString_ConcatFromString(&docString,"tick: Tick size of high-resolution timer\n")); PYCHECK(PyDict_SetItemString(PyMPI_dictionary,"tick", PyFloat_FromDouble(MPI_Wtick()))); PYCHECK(PyString_ConcatFromString(&docString,"version: String showing mpi version\n")); sprintf(versionString,"%d.%d",MPI_VERSION,MPI_SUBVERSION); #if defined(MPICH_NAME) && MPI_VERSION == 1 && MPI_SUBVERSION == 1 && MPI_STATUS_SIZE == 5 strcat(versionString,".2"); /* MPICH 1.1.2 is evil */ #endif PYCHECK(PyDict_SetItemString(PyMPI_dictionary,"version", PyString_FromString(versionString))); PYCHECK(PyString_ConcatFromString(&docString,"COMM_WORLD: MPI_COMM_WORLD communicator\n")); PYCHECK(PyDict_SetItemString(PyMPI_dictionary,"COMM_WORLD", PyMPI_Comm(MPI_COMM_WORLD))); PYCHECK(PyString_ConcatFromString(&docString,"COMM_NULL: MPI_COMM_NULL communicator (non-functional)\n")); PYCHECK(PyDict_SetItemString(PyMPI_dictionary,"COMM_NULL", PyMPI_Comm(MPI_COMM_NULL))); PYCHECK(PyString_ConcatFromString(&docString,"MAX: MPI_MAX\n")); /*PYCHECK(PyDict_SetItemString(PyMPI_dictionary,"MAX", PyInt_FromLong((long)MPI_MAX)));*/ reduceOpLookup[eMaxOp] = MPI_MAX; PYCHECK(PyDict_SetItemString(PyMPI_dictionary,"MAX", PyInt_FromLong((long)eMaxOp))); PYCHECK(PyString_ConcatFromString(&docString,"MIN: MPI_MIN\n")); /*PYCHECK(PyDict_SetItemString(PyMPI_dictionary,"MIN", PyInt_FromLong((long)MPI_MIN)));*/ reduceOpLookup[eMinOp] = MPI_MIN; PYCHECK(PyDict_SetItemString(PyMPI_dictionary,"MIN", PyInt_FromLong((long)eMinOp))); PYCHECK( PyString_ConcatFromString(&docString,"SUM: MPI_SUM\n")); /*PYCHECK(PyDict_SetItemString(PyMPI_dictionary,"SUM", PyInt_FromLong((long)MPI_SUM)));*/ reduceOpLookup[eSumOp] = MPI_SUM; PYCHECK(PyDict_SetItemString(PyMPI_dictionary,"SUM", PyInt_FromLong((long)eSumOp))); PYCHECK( PyString_ConcatFromString(&docString,"PROD: MPI_PROD\n")); /*PYCHECK(PyDict_SetItemString(PyMPI_dictionary,"PROD", PyInt_FromLong((long)MPI_PROD)));*/ reduceOpLookup[eProdOp] = MPI_PROD; PYCHECK(PyDict_SetItemString(PyMPI_dictionary,"PROD", PyInt_FromLong((long)eProdOp))); PYCHECK( PyString_ConcatFromString(&docString,"LAND: MPI_LAND\n")); /*PYCHECK(PyDict_SetItemString(PyMPI_dictionary,"LAND", PyInt_FromLong((long)MPI_LAND)));*/ reduceOpLookup[eLandOp] = MPI_LAND; PYCHECK(PyDict_SetItemString(PyMPI_dictionary,"LAND", PyInt_FromLong((long)eLandOp))); PYCHECK( PyString_ConcatFromString(&docString,"BAND: MPI_BAND\n")); /*PYCHECK(PyDict_SetItemString(PyMPI_dictionary,"BAND", PyInt_FromLong((long)MPI_BAND)));*/ reduceOpLookup[eBandOp] = MPI_BAND; PYCHECK(PyDict_SetItemString(PyMPI_dictionary,"BAND", PyInt_FromLong((long)eBandOp))); PYCHECK( PyString_ConcatFromString(&docString,"LOR: MPI_LOR\n")); /*PYCHECK(PyDict_SetItemString(PyMPI_dictionary,"LOR", PyInt_FromLong((long)MPI_LOR)));*/ reduceOpLookup[eLorOp] = MPI_LOR; PYCHECK(PyDict_SetItemString(PyMPI_dictionary,"LOR", PyInt_FromLong((long)eLorOp))); PYCHECK( PyString_ConcatFromString(&docString,"BOR: MPI_BOR\n")); /* PYCHECK(PyDict_SetItemString(PyMPI_dictionary,"BOR", PyInt_FromLong((long)MPI_BOR)));*/ reduceOpLookup[eBorOp] = MPI_BOR; PYCHECK(PyDict_SetItemString(PyMPI_dictionary,"BOR", PyInt_FromLong((long)eBorOp))); PYCHECK( PyString_ConcatFromString(&docString,"LXOR: MPI_LXOR\n")); /* PYCHECK(PyDict_SetItemString(PyMPI_dictionary,"LXOR", PyInt_FromLong((long)MPI_LXOR)));*/ reduceOpLookup[eLxorOp] = MPI_LXOR; PYCHECK(PyDict_SetItemString(PyMPI_dictionary,"LXOR", PyInt_FromLong((long)eLxorOp))); PYCHECK( PyString_ConcatFromString(&docString,"BXOR: MPI_BXOR\n")); /* PYCHECK(PyDict_SetItemString(PyMPI_dictionary,"BXOR", PyInt_FromLong((long)MPI_BXOR)));*/ reduceOpLookup[eBxorOp] = MPI_BXOR; PYCHECK(PyDict_SetItemString(PyMPI_dictionary,"BXOR", PyInt_FromLong((long)eBxorOp))); PYCHECK( PyString_ConcatFromString(&docString,"MINLOC: MPI_MINLOC\n")); /* PYCHECK(PyDict_SetItemString(PyMPI_dictionary,"MINLOC", PyInt_FromLong((long)MPI_MINLOC)));*/ reduceOpLookup[eMinlocOp] = MPI_MINLOC; PYCHECK(PyDict_SetItemString(PyMPI_dictionary,"MINLOC", PyInt_FromLong((long)eMinlocOp))); PYCHECK( PyString_ConcatFromString(&docString,"MAXLOC: MPI_MAXLOC\n")); /* PYCHECK(PyDict_SetItemString(PyMPI_dictionary,"MAXLOC", PyInt_FromLong((long)MPI_MAXLOC)));*/ reduceOpLookup[eMaxlocOp] = MPI_MAXLOC; PYCHECK(PyDict_SetItemString(PyMPI_dictionary,"MAXLOC", PyInt_FromLong((long)eMaxlocOp))); PYCHECK( PyString_ConcatFromString(&docString,"ANY_SOURCE: MPI_ANY_SOURCE (used for untargeted recv)\n")); PYCHECK(PyDict_SetItemString(PyMPI_dictionary,"ANY_SOURCE", PyInt_FromLong((long)MPI_ANY_SOURCE))); PYCHECK( PyString_ConcatFromString(&docString,"ANY_TAG: MPI_ANY_TAG (used for untargeted recv)\n")); PYCHECK(PyDict_SetItemString(PyMPI_dictionary,"ANY_TAG", PyInt_FromLong((long)MPI_ANY_TAG))); /* ----------------------------------------------- */ /* We set up an internal communicator for PYTHON */ /* messaging and another for Python I/O */ /* ----------------------------------------------- */ MPICHECK( MPI_COMM_WORLD, MPI_Comm_dup(MPI_COMM_WORLD,&PyMPI_COMM_WORLD)); MPICHECK( MPI_COMM_WORLD, MPI_Comm_dup(MPI_COMM_WORLD,&PyMPI_COMM_INPUT)); PYCHECK( PyString_ConcatFromString(&docString,"WORLD: Internal Python communicator\n") ); PYCHECK( pyWorld = PyMPI_Comm(PyMPI_COMM_WORLD) ); PYCHECK( PyDict_SetItemString(PyMPI_dictionary,"WORLD",pyWorld) ); /* ----------------------------------------------- */ /* Fetch member functions to appear as mpi.xxxx */ /* Make pyWorld immortal to avoid dealloc issues */ /* Magic Rating: 10/10 */ /* ----------------------------------------------- */ Py_INCREF(pyWorld); for(methodPtr = PyMPIMethods_Comm; methodPtr->ml_name; ++methodPtr) { PYCHECK( member = PyObject_GetAttrString(pyWorld,methodPtr->ml_name) ); Py_INCREF(member); PYCHECK( PyDict_SetItemString(PyMPI_dictionary,methodPtr->ml_name,member) ); } /* ----------------------------------------------- */ /* Set up the overloaded input */ /* ----------------------------------------------- */ PYCHECK( overloadedInput = PyMPI_File(worldRank != 0,PySys_GetObject("stdin"),PyMPI_COMM_INPUT) ); Py_INCREF(overloadedInput); PyDict_SetItemString(PyMPI_dictionary,"stdin",overloadedInput); PySys_SetObject("stdin",overloadedInput); /* ----------------------------------------------- */ /* Initial model is no output throttle */ /* ----------------------------------------------- */ PYCHECK( PyMPI_UnrestrictedOutput(3) ); /* ----------------------------------------------- */ /* Have to set up some stuff for communicating */ /* arbitrary python objects */ /* ----------------------------------------------- */ /* -- set up PyMPI_pythonPickleType -- */ MPICHECKCOMMLESS( MPI_Type_contiguous(1,MPI_CHAR,&PyMPI_pythonPickleType) ); MPICHECKCOMMLESS( MPI_Type_commit(&PyMPI_pythonPickleType) ); Assert( PyMPI_pythonPickleType != MPI_CHAR ); /* -- set up PyMPI_pythonFuncPickleType -- */ MPICHECKCOMMLESS( MPI_Type_contiguous(1,MPI_CHAR,&PyMPI_pythonFuncPickleType) ); MPICHECKCOMMLESS( MPI_Type_commit(&PyMPI_pythonFuncPickleType) ); Assert( PyMPI_pythonFuncPickleType != MPI_CHAR ); /* -- set up PyMPI_pythonFuncPickleType -- */ pickleModule = PyImport_ImportModule("cPickle"); if ( !pickleModule || PyErr_Occurred() ) { PyErr_Clear(); } else { PYCHECK( pickleDict = PyModule_GetDict(pickleModule) ); PYCHECK( PyMPI_pickleDumperFunction = PyDict_GetItemString(pickleDict,"dumps") ); PYCHECK( PyMPI_pickleLoaderFunction = PyDict_GetItemString(pickleDict,"loads") ); } /* ----------------------------------------------- */ /* Set up the __doc__ string of the communicator */ /* type with more info (based on list) */ /* ----------------------------------------------- */ PyMPIObject_Communicator_Type.tp_doc = DocStringFromMethods(PyMPIMethods_Comm, PyMPIObject_Communicator_Type.tp_doc); /* ----------------------------------------------- */ /* Set up same info in module doc */ /* ----------------------------------------------- */ docExtra = DocStringFromMethods(PyMPIMethods_Comm, "\nAnd these communicator methods map to the Python world communicator (not MPI_COMM_WORLD)\n\n"); Assert(docExtra); PYCHECK( PyString_ConcatFromString(&docString,docExtra) ); free(docExtra); /* ----------------------------------------------- */ /* Stick in the doc string and we're ready to go */ /* ----------------------------------------------- */ PYCHECK( PyDict_SetItemString(PyMPI_dictionary, "__doc__", docString) ); return; pythonError: Assert( PyErr_Occurred() ); return; /* We have set a Python exception, let Python handle it */ }