ocrGuid_t mainEdt(u32 paramc, u64* paramv, u32 depc, ocrEdtDep_t depv[]) { // Current thread is '0' and goes on with user code. ocrGuid_t e0; ocrEventCreate(&e0, OCR_EVENT_ONCE_T, EVT_PROP_TAKES_ARG); // Creates the EDTa ocrGuid_t edtGuid; ocrGuid_t taskForEdtTemplateGuid; ocrEdtTemplateCreate(&taskForEdtTemplateGuid, taskForEdt, 0 /*paramc*/, 2/*depc*/); ocrEdtCreate(&edtGuid, taskForEdtTemplateGuid, EDT_PARAM_DEF, /*paramv=*/NULL, EDT_PARAM_DEF, /*depv=*/NULL, /*properties=*/0, NULL_HINT, /*outEvent=*/NULL); // Register a dependence between an event and an edt ocrAddDependence(e0, edtGuid, 0, DB_MODE_CONST); ocrAddDependence(e0, edtGuid, 1, DB_MODE_CONST); int *k; ocrGuid_t dbGuid; ocrDbCreate(&dbGuid,(void **) &k, sizeof(int), /*flags=*/DB_PROP_NONE, /*location=*/NULL_HINT, NO_ALLOC); *k = 42; // Satisfy event's chain head ocrEventSatisfy(e0, dbGuid); return NULL_GUID; }
ocrGuid_t mainEdt(u32 paramc, u64* paramv, u32 depc, ocrEdtDep_t depv[]) { // Creates a data block int *k; ocrGuid_t dbGuid; ocrDbCreate(&dbGuid,(void **) &k, sizeof(int), /*flags=*/0, /*location=*/NULL_GUID, NO_ALLOC); *k = 42; ocrGuid_t eventGuid; ocrEventCreate(&eventGuid, OCR_EVENT_STICKY_T, true); // Creates the EDT ocrGuid_t edtGuid; ocrGuid_t taskForEdtTemplateGuid; ocrEdtTemplateCreate(&taskForEdtTemplateGuid, taskForEdt, 0 /*paramc*/, 1 /*depc*/); ocrEdtCreate(&edtGuid, taskForEdtTemplateGuid, EDT_PARAM_DEF, /*paramv=*/NULL, EDT_PARAM_DEF, /*depv=*/NULL, /*properties=*/0, NULL_GUID, /*outEvent=*/NULL); ocrAddDependence(eventGuid, edtGuid, 0, DB_MODE_RO); // Register a dependence between a db and an event // (equivalent to directly satisfying the DB) ocrAddDependence(dbGuid, eventGuid, 0, DB_MODE_RO); // No need to satisfy as addDependence is equivalent to a satisfy // when the source is a datablock return NULL_GUID; }
ocrGuid_t realMainEdt(u32 paramc, u64 *paramv, u32 depc, ocrEdtDep_t depv[]){ /* paramv[0]: number of workers for GSi to create depv 0: userSharedBlock 1: GSsharedBlock realMain launches the GS initialization */ u64 i, mynode; ocrGuid_t once; userSharedBlock_t * uSB = depv[0].ptr; GSsharedBlock_t * SB = depv[1].ptr; SB->numnodes = N; //setting the number of "ranks" REQUIRED ocrEdtTemplateCreate(&(uSB->cgTemplate), cgTask, 3, 4); SB->userBlock = depv[0].guid; //passed through GSiEDT to computeInitEdt ocrGuid_t gsBlock, GSi, sticky, dummy; ocrEdtTemplateCreate(&(SB->GSiTemplate), GSiEdt, 3, 2); //needed both to launch GSiEDT and inside for cloning REQUIRED ocrDbCreate(&(gsBlock), (void**) &dummy, sizeof(gsBlock_t), 0, NULL_GUID, NO_ALLOC); //needed for GSiEDT REQUIRED //create and luanch GSiEdt u64 GSparamvout[3] = {0, NULL_GUID, NULL_GUID}; //REQUIRED ocrEdtCreate(&GSi, SB->GSiTemplate, EDT_PARAM_DEF, GSparamvout, EDT_PARAM_DEF, NULL_GUID, EDT_PROP_NONE, NULL_GUID, NULL_GUID); //REQUIRED ocrDbRelease(depv[1].guid); ocrAddDependence(depv[1].guid, GSi, 0, DB_MODE_RW); //REQUIRED ocrAddDependence(gsBlock, GSi, 1, DB_MODE_RW); //REQUIRED return NULL_GUID; }
ocrGuid_t mainEdt(u32 paramc, u64* paramv, u32 depc, ocrEdtDep_t depv[]) { ocrGuid_t tplGuid; ocrEdtTemplateCreate(&tplGuid, otherEdt, 0 /*paramc*/, 2 /*depc*/); ocrGuid_t edtGuid; ocrGuid_t ndepv[2]; ndepv[0] = UNINITIALIZED_GUID; ndepv[1] = UNINITIALIZED_GUID; ocrEdtCreate(&edtGuid, tplGuid, 0, NULL, 2, ndepv, EDT_PROP_NONE, NULL_HINT, NULL); ocrEdtTemplateDestroy(tplGuid); ocrGuid_t db1Guid; u64 * db1Ptr; ocrDbCreate(&db1Guid, (void**) &db1Ptr, sizeof(u64), DB_PROP_NONE, NULL_HINT, NO_ALLOC); db1Ptr[0] = 1; ocrDbRelease(db1Guid); ocrGuid_t db2Guid; u64 * db2Ptr; ocrDbCreate(&db2Guid, (void**) &db2Ptr, sizeof(u64), DB_PROP_NONE, NULL_HINT, NO_ALLOC); db2Ptr[0] = 2; ocrDbRelease(db2Guid); ocrAddDependence(db1Guid, edtGuid, 0, DB_MODE_RO); ocrAddDependence(db2Guid, edtGuid, 1, DB_MODE_RO); return NULL_GUID; }
ocrGuid_t mainEdt(){ /* mainEdt is executed first Creates the datablocks creates realmain as a FINISH EDT creates wrap up to depend on realmain launches realmain (wrapup waits until realmain is done) */ u64 i; u64 *dummy; ocrGuid_t realMain, GSsharedBlock, userSharedBlock, realMainTemplate, output, wrapup, wrapupTemplate; PRINTF("Preconditioned driver\n"); PRINTF("Number of timesteps is %d \n", T); PRINTF("Number of workers is %d \n", N); PRINTF("Rows per worker %d \n", M); ocrEdtTemplateCreate(&wrapupTemplate, wrapupEdt, 0, 1); ocrEdtTemplateCreate(&realMainTemplate, realMainEdt, 0, 2); ocrEdtCreate(&realMain, realMainTemplate, EDT_PARAM_DEF, NULL, EDT_PARAM_DEF, NULL, EDT_PROP_FINISH, NULL_GUID, &output); ocrDbCreate(&GSsharedBlock, (void **) &dummy, sizeof(GSsharedBlock_t), 0, NULL_GUID, NO_ALLOC); ocrDbCreate(&userSharedBlock, (void **) &dummy, sizeof(userSharedBlock_t), 0, NULL_GUID, NO_ALLOC); ocrEdtCreate(&wrapup, wrapupTemplate, EDT_PARAM_DEF, NULL, EDT_PARAM_DEF, NULL, EDT_PROP_FINISH, NULL_GUID, NULL_GUID); ocrAddDependence(output, wrapup, 0, DB_MODE_RW); ocrAddDependence(userSharedBlock, realMain, 0, DB_MODE_RW); ocrAddDependence(GSsharedBlock, realMain, 1, DB_MODE_RW); return NULL_GUID; }
ocrGuid_t fftStartEdt(u32 paramc, u64* paramv, u32 depc, ocrEdtDep_t depv[]) { int i; ocrGuid_t startGuid = paramv[0]; ocrGuid_t endGuid = paramv[1]; ocrGuid_t endSlaveGuid = paramv[2]; float *data = (float*)depv[0].ptr; ocrGuid_t dataGuid = depv[0].guid; u64 N = paramv[3]; u64 step = paramv[4]; u64 offset = paramv[5]; u64 x_in_offset = paramv[6]; bool verbose = paramv[7]; u64 serialBlockSize = paramv[8]; float *x_in = (float*)data; float *X_real = (float*)(data+offset + N*step); float *X_imag = (float*)(data+offset + 2*N*step); if(verbose) { PRINTF("Step %d offset: %d N*step: %d\n", step, offset, N*step); } if(N <= serialBlockSize) { ditfft2(X_real, X_imag, x_in+x_in_offset, N, step); } else { // DFT even side u64 childParamv[9] = { startGuid, endGuid, endSlaveGuid, N/2, 2 * step, 0 + offset, x_in_offset, verbose, serialBlockSize }; u64 childParamv2[9] = { startGuid, endGuid, endSlaveGuid, N/2, 2 * step, N/2 + offset, x_in_offset + step, verbose, serialBlockSize }; if(verbose) { PRINTF("Creating children of size %d\n",N/2); } ocrGuid_t edtGuid, edtGuid2, endEdtGuid, finishEventGuid, finishEventGuid2; ocrEdtCreate(&edtGuid, startGuid, EDT_PARAM_DEF, childParamv, EDT_PARAM_DEF, NULL_GUID, EDT_PROP_FINISH, NULL_GUID, &finishEventGuid); ocrEdtCreate(&edtGuid2, startGuid, EDT_PARAM_DEF, childParamv2, EDT_PARAM_DEF, NULL_GUID, EDT_PROP_FINISH, NULL_GUID, &finishEventGuid2); if(verbose) { PRINTF("finishEventGuid after create: %lu\n",finishEventGuid); } ocrGuid_t endDependencies[3] = { dataGuid, finishEventGuid, finishEventGuid2 }; // Do calculations after having divided and conquered ocrEdtCreate(&endEdtGuid, endGuid, EDT_PARAM_DEF, paramv, EDT_PARAM_DEF, endDependencies, EDT_PROP_FINISH, NULL_GUID, NULL); ocrAddDependence(dataGuid, edtGuid, 0, DB_MODE_ITW); ocrAddDependence(dataGuid, edtGuid2, 0, DB_MODE_ITW); } if(verbose) { PRINTF("Task with size %d completed\n",N); } return NULL_GUID; }
void test () { // Current thread is '0' and goes on with user code. ocrGuid_t eventGuid; ocrEventCreate(&eventGuid, OCR_EVENT_STICKY_T, true); // Creates the EDT ocrGuid_t edtGuid; ocrGuid_t taskForEdtTemplateGuid; ocrEdtTemplateCreate(&taskForEdtTemplateGuid, taskForEdt, 0 /*paramc*/, 1 /*depc*/); ocrEdtCreate(&edtGuid, taskForEdtTemplateGuid, EDT_PARAM_DEF, /*paramv=*/NULL, EDT_PARAM_DEF, /*depv=*/NULL, 0, NULL_GUID, NULL); // Register a dependence between an event and an edt ocrAddDependence(eventGuid, edtGuid, 0, DB_MODE_RO); int *k; ocrGuid_t db_guid; ocrDbCreate(&db_guid,(void **) &k, sizeof(int), /*flags=*/FLAGS, /*location=*/NULL_GUID, NO_ALLOC); *k = 42; ocrEventSatisfy(eventGuid, db_guid); }
// Create an event at the current affinity and writes // the GUID into the domainSetup data-structure. void domainSetup(ocrGuid_t userSetupDoneEvt, domainSetup_t * dsetup) { // This is for the domain kernel to callback and stop the timer ocrGuid_t stopTimerEvt; ocrEventCreate(&stopTimerEvt, OCR_EVENT_ONCE_T, true); // Create an EDT at a remote affinity to: // - Create a remote latch event and initialize it // - Hook that event to the local event declared above // - write back the guid of the remote latch event into the setup DB // - userSetupDoneEvt: to be satisfied when setup is done // - stopTimerEvt: to be satisfied when domain kernel is done dsetup->userSetupDoneEvt = userSetupDoneEvt; dsetup->stopTimerEvt = stopTimerEvt; u64 affinityCount; ocrAffinityCount(AFFINITY_PD, &affinityCount); ocrGuid_t remoteAffGuid; ocrAffinityGetAt(AFFINITY_PD, affinityCount-1, &remoteAffGuid); ocrHint_t edtHint; ocrHintInit(&edtHint, OCR_HINT_EDT_T); ocrSetHintValue(&edtHint, OCR_HINT_EDT_AFFINITY, ocrAffinityToHintValue(remoteAffGuid)); ocrGuid_t edtTemplGuid; ocrEdtTemplateCreate(&edtTemplGuid, remoteSetupUserEdt, 0, 1); ocrGuid_t edtGuid; ocrEdtCreate(&edtGuid, edtTemplGuid, 0, NULL, 1, NULL, EDT_PROP_NONE, &edtHint, NULL); // EW addresses the race that the current caller owns the DB and we're // trying to start the remote setup EDT concurrently. Since we do not have // the caller event we can't setup a proper dependence and rely on EW instead. ocrAddDependence(dsetup->self, edtGuid, 0, DB_MODE_EW); ocrEdtTemplateDestroy(edtTemplGuid); }
int main(int argc, const char * argv[]) { ocrConfig_t ocrConfig; ocrParseArgs(argc, argv, &ocrConfig); ocrInit(&ocrConfig); ocrGuid_t terminateEdtGuid; ocrGuid_t terminateEdtTemplateGuid; ocrEdtTemplateCreate(&terminateEdtTemplateGuid, terminateEdt, 0 /*paramc*/, 1 /*depc*/); ocrEdtCreate(&terminateEdtGuid, terminateEdtTemplateGuid, EDT_PARAM_DEF, /*paramv=*/NULL, EDT_PARAM_DEF, /*depv=*/NULL, /*properties=*/0, NULL_GUID, /*outEvent=*/NULL); ocrGuid_t outputEventGuid; ocrGuid_t rootEdtGuid; ocrGuid_t rootEdtTemplateGuid; ocrEdtTemplateCreate(&rootEdtTemplateGuid, rootEdt, 0 /*paramc*/, 0 /*depc*/); ocrEdtCreate(&rootEdtGuid, rootEdtTemplateGuid, EDT_PARAM_DEF, /*paramv=*/NULL, EDT_PARAM_DEF, /*depv=*/NULL, /*properties=*/EDT_PROP_FINISH, NULL_GUID, /*outEvent=*/&outputEventGuid); // When output-event will be satisfied, the whole task sub-tree // spawned by rootEdt will be done, and shutdownEdt is called. ocrAddDependence(outputEventGuid, terminateEdtGuid, 0, DB_MODE_RO); ocrFinalize(); return 0; }
int main (int argc, char ** argv) { ocrEdt_t fctPtrArray [1]; fctPtrArray[0] = &task_for_edt; ocrInit(&argc, argv, 1, fctPtrArray); // Current thread is '0' and goes on with user code. ocrGuid_t event_guid; ocrEventCreate(&event_guid, OCR_EVENT_STICKY_T, true); // Creates the EDT ocrGuid_t edt_guid; ocrEdtCreate(&edt_guid, task_for_edt, /*paramc=*/0, /*params=*/ NULL, /*paramv=*/NULL, /*properties=*/0, /*depc=*/1, /*depv=*/NULL); // Register a dependence between an event and an edt ocrAddDependence(event_guid, edt_guid, 0); // Schedule the EDT (will run when dependences satisfied) ocrEdtSchedule(edt_guid); int *k; ocrGuid_t db_guid; ocrDbCreate(&db_guid, (void **) &k, sizeof(int), /*flags=*/FLAGS, /*location=*/NULL, NO_ALLOC); *k = 42; ocrEventSatisfy(event_guid, db_guid); ocrCleanup(); return 0; }
inline static void cblas_dsyrk_task_prescriber ( ocrGuid_t edtTemp, u32 k, u32 j, u32 i, u32 tileSize, ocrGuid_t*** lkji_event_guids) { ocrGuid_t cblas_dsyrk_task_guid; u64 func_args[5]; func_args[0] = k; func_args[1] = j; func_args[2] = i; func_args[3] = tileSize; func_args[4] = (u64)(lkji_event_guids[j][j][k+1]); ocrGuid_t affinity = NULL_GUID; ocrEdtCreate(&cblas_dsyrk_task_guid, edtTemp, 5, func_args, 2, NULL, PROPERTIES, affinity, NULL); ocrAddDependence(lkji_event_guids[j][j][k], cblas_dsyrk_task_guid, 0, DB_MODE_RW); ocrAddDependence(lkji_event_guids[j][k][k+1], cblas_dsyrk_task_guid, 1, DB_MODE_RW); }
ocrGuid_t mainEdt ( u32 paramc, u64* paramv, u32 depc, ocrEdtDep_t depv[]) { u64 size = -1; u64 offset = -1; u32 i = 0; u64 argc; void *programArg = depv[0].ptr; argc = getArgc(programArg); if ( argc != 4 ) { PRINTF("Usage: ./basicIO offset size fileName \n"); ocrShutdown(); return 1; } offset = atoi(getArgv(programArg, 1)); size = atoi(getArgv(programArg, 2)); u64 nparamv[2]; nparamv[0] = offset; nparamv[1] = size; FILE *in; in = fopen(getArgv(programArg, 3), "r"); if( !in ) { PRINTF("Cannot find file: %s\n", getArgv(programArg, 3)); ocrShutdown(); return NULL_GUID; } ocrGuid_t dataGuid; // Data can be passed as parameter also , there was no // necessary need of creating data block in this example. // Its has been created for demo purpose //Create datablock to hold a block of 'size' elements u64 *inputarr; ocrDbCreate(&dataGuid, (void**)&inputarr, sizeof(u64)*size,0,NULL_GUID, NO_ALLOC); #ifndef TG_ARCH while(fscanf(in,"%llu\n",&inputarr[i++])!=EOF); #else fread(inputarr, sizeof(u64),size , in); #endif fclose(in); ocrGuid_t addEdtTemplateGuid; ocrEdtTemplateCreate(&addEdtTemplateGuid, add_edt, 2 /*paramc*/, 1 /*depc*/); ocrGuid_t add_edt_guid; // Create the EDT not specifying the dependence vector at creation ocrEdtCreate(&add_edt_guid, addEdtTemplateGuid, EDT_PARAM_DEF, nparamv,1,NULL ,EDT_PROP_FINISH , NULL_GUID, NULL); ocrGuid_t triggerEventGuid; ocrEventCreate(&triggerEventGuid, OCR_EVENT_STICKY_T, true); ocrAddDependence(triggerEventGuid, add_edt_guid, 0, DB_MODE_EW); ocrEventSatisfy(triggerEventGuid, dataGuid); return NULL_GUID; }
ocrGuid_t mainEdt(u32 paramc, u64* paramv, u32 depc, ocrEdtDep_t depv[]) { ocrGuid_t e0; ocrEventCreate(&e0, OCR_EVENT_STICKY_T, false); ocrGuid_t terminateEdtGuid; ocrGuid_t terminateEdtTemplateGuid; ocrEdtTemplateCreate(&terminateEdtTemplateGuid, terminateEdt, 0 /*paramc*/, EDT_PARAM_UNK /*depc*/); ocrEdtCreate(&terminateEdtGuid, terminateEdtTemplateGuid, EDT_PARAM_DEF, NULL, 1, NULL_GUID, /*properties=*/EDT_PROP_FINISH, NULL_GUID, /*outEvent=*/ NULL); ocrAddDependence(e0, terminateEdtGuid, 0, DB_MODE_RO); ocrEventSatisfy(e0, NULL_GUID); return NULL_GUID; }
// The kernel to invoke void domainKernel(ocrGuid_t userKernelDoneEvt, domainSetup_t * setupDbPtr, timestamp_t * timer) { // Setup: DB to use to satisfy the domain kernel's done event ocrGuid_t curAffGuid; ocrAffinityGetCurrent(&curAffGuid); ocrHint_t dbHint; ocrHintInit(&dbHint, OCR_HINT_DB_T); ocrSetHintValue(&dbHint, OCR_HINT_DB_AFFINITY, ocrAffinityToHintValue(curAffGuid)); //TODO why is this not created by the caller as for domainSetup ? ocrGuid_t kernelDbGuid; domainKernel_t * kernelDbPtr; ocrDbCreate(&kernelDbGuid, (void**) &kernelDbPtr, sizeof(domainKernel_t), 0, &dbHint, NO_ALLOC); kernelDbPtr->self = kernelDbGuid; // Kernel's core // Create callback EDT to depend on stop timer event triggered by remote ocrHint_t edtHint; ocrHintInit(&edtHint, OCR_HINT_EDT_T); ocrSetHintValue(&edtHint, OCR_HINT_EDT_AFFINITY, ocrAffinityToHintValue(curAffGuid)); ocrGuid_t stopTpl; ocrEdtTemplateCreate(&stopTpl, stopTimerEdt, 0, 2); ocrGuid_t stopEdt; ocrGuid_t stopEdtDone; ocrEdtCreate(&stopEdt, stopTpl, 0, NULL, 2, NULL, EDT_PROP_NONE, &edtHint, &stopEdtDone); // Stop timer will satisfy the user kernel done event ocrAddDependence(stopEdtDone, userKernelDoneEvt, 0, DB_MODE_NULL); ocrAddDependence(setupDbPtr->stopTimerEvt, stopEdt, 0, DB_MODE_NULL); ocrAddDependence(kernelDbPtr->self, stopEdt, 1, DB_MODE_EW); // Start timer ocrGuid_t remoteEvt = setupDbPtr->remoteLatchEvent; get_time(&kernelDbPtr->startTimer); u64 i; for(i=0; i<NB_SATISFY; i++) { ocrEventSatisfySlot(remoteEvt, NULL_GUID, OCR_EVENT_LATCH_DECR_SLOT); } // Note: Timer stops when the remote latch event got all the satisfy ocrDbRelease(kernelDbGuid); }
inline static void lapacke_dpotrf_task_prescriber (ocrGuid_t edtTemp, u32 k, u32 tileSize, ocrGuid_t*** lkji_event_guids) { ocrGuid_t seq_cholesky_task_guid; u64 func_args[3]; func_args[0] = k; func_args[1] = tileSize; func_args[2] = (u64)(lkji_event_guids[k][k][k+1]); ocrGuid_t affinity = NULL_GUID; ocrEdtCreate(&seq_cholesky_task_guid, edtTemp, 3, func_args, 1, NULL, PROPERTIES, affinity, NULL); ocrAddDependence(lkji_event_guids[k][k][k], seq_cholesky_task_guid, 0, DB_MODE_RW); }
ocrGuid_t computeInitEdt(u32 paramc, u64 *paramv, u32 depc, ocrEdtDep_t depv[]){ /* param[0] = mynode depv 0: userSharedBlock 1: GSsharedblock 2: My GSdatablock Stub connection to cgTask but could create other datablocks as needed (one cgBlock in this case) computeInit is launched by the initialization phase of the GS library */ u64 mynode = paramv[0]; userSharedBlock_t * uSB = depv[0].ptr; //create and launch cgTask ocrGuid_t cgEdt, cgBlock, dummy; u64 paramvout[3] = {mynode, 0, 0}; ocrDbCreate(&(cgBlock), (void**) &dummy, sizeof(cgBlock_t), 0, NULL_GUID, NO_ALLOC); ocrEdtCreate(&cgEdt, uSB->cgTemplate, EDT_PARAM_DEF, paramvout, EDT_PARAM_DEF, NULL, EDT_PROP_NONE, NULL_GUID, NULL_GUID); ocrAddDependence(depv[0].guid, cgEdt, 0, DB_MODE_RW); ocrAddDependence(depv[1].guid, cgEdt, 1, DB_MODE_RW); ocrAddDependence(depv[2].guid, cgEdt, 2, DB_MODE_RW); ocrAddDependence(cgBlock, cgEdt, 3, DB_MODE_RW); return NULL_GUID; }
void SPMD_Add_haloarray(int len, int slot, int *halo, SPMD_t info) { info_t **thread; int size = 4, i; thread = &info.thread[slot]; ocrGuid_t tmpDataGuid; u64 *tmp; ocrDbCreate(&tmpDataGuid, (void**) &tmp, sizeof(double)*len, DB_PROP_NONE, NULL_GUID, NO_ALLOC); ocrAddDependence(tmpDataGuid, thread[0]->edt_next_compute, 0, DB_MODE_RW); int num_neighbor = 2; for (i = 0; i < num_neighbor; ++i) ocrDbCreate(&tmpDataGuid, (void**) &tmp, sizeof(double), DB_PROP_NONE, NULL_GUID, NO_ALLOC); }
ocrGuid_t mainEdt(u32 paramc, u64* paramv, u32 depc, ocrEdtDep_t depv[]) { PRINTF("Starting mainEdt\n"); ocrGuid_t edt1_template, edt2_template, edt3_template; ocrGuid_t edt1, edt2, edt3, outputEvent1, outputEvent2; //Create templates for the EDTs ocrEdtTemplateCreate(&edt1_template, fun1, 0, 1); ocrEdtTemplateCreate(&edt2_template, fun2, 0, 1); ocrEdtTemplateCreate(&edt3_template, shutdownEdt, 0, 2); //Create the EDTs ocrEdtCreate(&edt1, edt1_template, EDT_PARAM_DEF, NULL, EDT_PARAM_DEF, NULL, EDT_PROP_NONE, NULL_HINT, &outputEvent1); ocrEdtCreate(&edt2, edt2_template, EDT_PARAM_DEF, NULL, EDT_PARAM_DEF, NULL, EDT_PROP_NONE, NULL_HINT, &outputEvent2); ocrEdtCreate(&edt3, edt3_template, EDT_PARAM_DEF, NULL, 2, NULL, EDT_PROP_NONE, NULL_HINT, NULL); //Setup dependences for the shutdown EDT ocrAddDependence(outputEvent1, edt3, 0, DB_MODE_CONST); ocrAddDependence(outputEvent2, edt3, 1, DB_MODE_CONST); //Start execution of the parallel EDTs ocrAddDependence(NULL_GUID, edt1, 0, DB_DEFAULT_MODE); ocrAddDependence(NULL_GUID, edt2, 0, DB_DEFAULT_MODE); return NULL_GUID; }
ocrGuid_t mainEdt(u32 paramc, u64* paramv, u32 depc, ocrEdtDep_t depv[]) { // Current thread is '0' and goes on with user code. ocrGuid_t latchGuid; ocrEventCreate(&latchGuid, OCR_EVENT_LATCH_T, false); // Creates the EDT ocrGuid_t edtGuid; ocrGuid_t taskForEdtTemplateGuid; ocrEdtTemplateCreate(&taskForEdtTemplateGuid, taskForEdt, 0 /*paramc*/, 1 /*depc*/); ocrEdtCreate(&edtGuid, taskForEdtTemplateGuid, EDT_PARAM_DEF, /*paramv=*/NULL, EDT_PARAM_DEF, /*depv=*/NULL, /*properties=*/0, NULL_GUID, /*outEvent=*/NULL); // Register a dependence between an event and an edt ocrAddDependence(latchGuid, edtGuid, 0, DB_MODE_RO); // decr first and then incr (reaching zero from negative) ocrEventSatisfySlot(latchGuid, NULL_GUID, OCR_EVENT_LATCH_DECR_SLOT); ocrEventSatisfySlot(latchGuid, NULL_GUID, OCR_EVENT_LATCH_INCR_SLOT); return NULL_GUID; }
ocrGuid_t remoteSetupUserEdt(u32 paramc, u64* paramv, u32 depc, ocrEdtDep_t depv[]) { ocrGuid_t dsetupGuid = depv[0].guid; domainSetup_t * dsetup = (domainSetup_t *) depv[0].ptr; // Create 'remote' (local to here) latch event ocrGuid_t evtGuid; ocrEventParams_t params; params.EVENT_LATCH.counter = NB_SATISFY; ocrEventCreateParams(&evtGuid, OCR_EVENT_LATCH_T, false, ¶ms); dsetup->remoteLatchEvent = evtGuid; // Setup callback for when the latch event fires ocrAddDependence(evtGuid, dsetup->stopTimerEvt, 0, DB_MODE_NULL); ocrGuid_t userSetupDoneEvt = dsetup->userSetupDoneEvt; ocrDbRelease(dsetupGuid); // Global setup is done ocrEventSatisfy(userSetupDoneEvt, NULL_GUID); return NULL_GUID; }
inline static void wrap_up_task_prescriber ( ocrGuid_t edtTemp, u32 numTiles, u32 tileSize, u32 outSelLevel, ocrGuid_t*** lkji_event_guids ) { u32 i,j,k; ocrGuid_t wrap_up_task_guid; u64 func_args[3]; func_args[0]=(u32)numTiles; func_args[1]=(u32)tileSize; func_args[2]=(u32)outSelLevel; ocrGuid_t affinity = NULL_GUID; ocrEdtCreate(&wrap_up_task_guid, edtTemp, 3, func_args, (numTiles+1)*numTiles/2, NULL, PROPERTIES, affinity, NULL); u32 index = 0; for ( i = 0; i < numTiles; ++i ) { k = 1; for ( j = 0; j <= i; ++j ) { ocrAddDependence(lkji_event_guids[i][j][k], wrap_up_task_guid, index++, DB_MODE_RW); ++k; } } }
int main (int argc, char ** argv) { ocrEdt_t fctPtrArray [1]; fctPtrArray[0] = &task_for_edt; ocrInit(&argc, argv, 1, fctPtrArray); // Current thread is '0' and goes on with user code. ocrGuid_t event_guid; ocrEventCreate(&event_guid, OCR_EVENT_STICKY_T, true); // Creates the EDT u32 paramc = 1; u64 params[1]; params[0] = sizeof(int); int * paramv = (int *) malloc(sizeof(int)); paramv[0] = 32; ocrGuid_t edt_guid; ocrEdtCreate(&edt_guid, task_for_edt, paramc, params, (void**) ¶mv, 0, 1, NULL); // Register a dependence between an event and an edt ocrAddDependence(event_guid, edt_guid, 0); int *k; ocrGuid_t db_guid; ocrDbCreate(&db_guid,(void **) &k, sizeof(int), /*flags=*/FLAGS, /*location=*/NULL, NO_ALLOC); *k = 42; ocrEventSatisfy(event_guid, db_guid); ocrEdtSchedule(edt_guid); ocrCleanup(); return 0; }
ocrGuid_t mainEdt(u32 paramc, u64* paramv, u32 depc, ocrEdtDep_t depv[]) { u64 affinityCount; ocrAffinityCount(AFFINITY_PD, &affinityCount); ASSERT(affinityCount >= 1); ocrGuid_t affinities[affinityCount]; ocrAffinityGet(AFFINITY_PD, &affinityCount, affinities); ocrGuid_t edtAffinity = affinities[affinityCount-1]; // Create a DB void * dbPtr; ocrGuid_t dbGuid; u64 nbElem = NB_ELEM_DB; ocrDbCreate(&dbGuid, &dbPtr, sizeof(TYPE_ELEM_DB) * NB_ELEM_DB, 0, NULL_HINT, NO_ALLOC); int v = 1; int i = 0; int * data = (int *) dbPtr; while (i < nbElem) { data[i] = v++; i++; } ocrDbRelease(dbGuid); PRINTF("mainEdt: local DB guid is "GUIDF", dbPtr=%p\n",GUIDA(dbGuid), dbPtr); // create local edt that depends on the remote edt, the db is automatically cloned ocrGuid_t edtTemplateGuid; ocrEdtTemplateCreate(&edtTemplateGuid, consumerEdt, 0, 1); ocrHint_t edtHint; ocrHintInit( &edtHint, OCR_HINT_EDT_T ); ocrSetHintValue( & edtHint, OCR_HINT_EDT_AFFINITY, ocrAffinityToHintValue( edtAffinity) ); ocrGuid_t edtGuid; ocrEdtCreate(&edtGuid, edtTemplateGuid, 0, NULL, 1, NULL, EDT_PROP_NONE, &edtHint, NULL); ocrAddDependence(dbGuid, edtGuid, 0, DB_MODE_RW); return NULL_GUID; }
ocrGuid_t mainEdt(u32 paramc, u64* paramv, u32 depc, ocrEdtDep_t depv[]) { u64 arraySize = 100; //Create argument vector to hold array size u64 nparamv[1]; nparamv[0] = arraySize; u64 * dataArray; ocrGuid_t dataGuid; //Create datablock to hold a block of 'array size' u64 elements ocrDbCreate(&dataGuid, (void **) &dataArray, sizeof(u64)*arraySize, /*flags=*/0, /*loc=*/NULL_GUID, NO_ALLOC); ocrGuid_t stepAEdtTemplateGuid; ocrEdtTemplateCreate(&stepAEdtTemplateGuid, stepA_edt, 1 /*paramc*/, 1 /*depc*/); // Create the EDT not specifying the dependence vector at creation ocrGuid_t stepAEdtGuid; ocrEdtCreate(&stepAEdtGuid, stepAEdtTemplateGuid, EDT_PARAM_DEF, nparamv, 1, NULL, /*prop=*/EDT_PROP_NONE, NULL_GUID, NULL); ocrGuid_t triggerEventGuid; //TODO Setup event used to trigger stepA ocrEventCreate(&triggerEventGuid, OCR_EVENT_STICKY_T, EVT_PROP_TAKES_ARG); //END-TODO //TODO Setup dependence between event and stepA's EDTs slot 0 ocrAddDependence(triggerEventGuid, stepAEdtGuid, 0, DB_MODE_EW); //END-TODO //TODO Satisfy the event with the datablock ocrEventSatisfy(triggerEventGuid, dataGuid); //END-TODO return NULL_GUID; }
int main (int argc, char ** argv) { ocrEdt_t fctPtrArray[2] = {summer, autumn}; ocrInit(&argc, argv, 2, fctPtrArray); /* No machine description */ if(argc != 3) { printf("Usage %s <num1> <num2>\n", argv[0]); return -1; } /* Create 2 data-blocks */ ocrGuid_t dbs[2]; int *data[2]; int i; for(i = 0; i < 2; ++i) { ocrDbCreate(&dbs[i], (void**)&data[i], sizeof(int), /*flags=*/0, /*location=*/NULL, NO_ALLOC); *(data[i]) = atoi(argv[i+1]); printf("Created a data-block with value %d (GUID: 0x%lx)\n", i, (u64)dbs[i]); } ocrGuid_t summerEdt, autumnEdt; ocrGuid_t autumnEvt, summerEvt[3]; ocrGuid_t summerEvtDbGuid; ocrGuid_t *summerEvtDb; /* Create final EDT (autumn) */ ocrEdtCreate(&autumnEdt, autumn, /*paramc=*/0, /*params=*/NULL, /*paramv=*/NULL, /*properties=*/0, /*depc=*/1, /*depv=*/NULL); /* Create event */ ocrEventCreate(&autumnEvt, OCR_EVENT_STICKY_T, true); /* Create summer */ ocrEdtCreate(&summerEdt, summer, /*paramc=*/0, /*params=*/NULL, /*paramv=*/NULL, /*properties=*/0, /*depc=*/3, /*depv=*/NULL); /* Create events for summer */ for(i = 0; i < 3; ++i) { ocrEventCreate(&summerEvt[i], OCR_EVENT_STICKY_T, true); } /* Create data-block containing event */ ocrDbCreate(&summerEvtDbGuid, (void**)&summerEvtDb, sizeof(ocrGuid_t), /*flags=*/0, /*location=*/NULL, NO_ALLOC); *summerEvtDb = autumnEvt; /* Link up dependencees */ for(i = 0; i < 3; ++i) { ocrAddDependence(summerEvt[i], summerEdt, i); } ocrAddDependence(autumnEvt, autumnEdt, 0); /* "Schedule" EDTs (order does not matter) */ ocrEdtSchedule(autumnEdt); ocrEdtSchedule(summerEdt); printf("Done all scheduling, now going to satisfy\n"); /* Satisfy dependences passing data */ ocrEventSatisfy(summerEvt[0], dbs[0]); ocrEventSatisfy(summerEvt[1], dbs[1]); ocrEventSatisfy(summerEvt[2], summerEvtDbGuid); /* Finalize */ ocrCleanup(); return 0; }
int main ( int argc, char* argv[] ) { OCR_INIT(&argc, argv, smith_waterman_task ); int i, j; int tile_width = (int) atoi (argv[3]); int tile_height = (int) atoi (argv[4]); int n_tiles_width; int n_tiles_height; if ( argc < 5 ) { fprintf(stderr, "Usage: %s fileName1 fileName2 tileWidth tileHeight\n", argv[0]); exit(1); } signed char* string_1; signed char* string_2; char* file_name_1 = argv[1]; char* file_name_2 = argv[2]; FILE* file_1 = fopen(file_name_1, "r"); if (!file_1) { fprintf(stderr, "could not open file %s\n",file_name_1); exit(1); } size_t n_char_in_file_1 = 0; string_1 = read_file(file_1, &n_char_in_file_1); fprintf(stdout, "Size of input string 1 is %zu\n", n_char_in_file_1 ); FILE* file_2 = fopen(file_name_2, "r"); if (!file_2) { fprintf(stderr, "could not open file %s\n",file_name_2); exit(1); } size_t n_char_in_file_2 = 0; string_2 = read_file(file_2, &n_char_in_file_2); fprintf(stdout, "Size of input string 2 is %zu\n", n_char_in_file_2 ); fprintf(stdout, "Tile width is %d\n", tile_width); fprintf(stdout, "Tile height is %d\n", tile_height); n_tiles_width = n_char_in_file_1/tile_width; n_tiles_height = n_char_in_file_2/tile_height; fprintf(stdout, "Imported %d x %d tiles.\n", n_tiles_width, n_tiles_height); fprintf(stdout, "Allocating tile matrix\n"); /* Allocate a 2D matrix of 'Tile's where every Tile has 3 events that represents the readiness * of the bottom row, right column and bottom right element of that tile */ Tile_t** tile_matrix = (Tile_t **) malloc(sizeof(Tile_t*)*(n_tiles_height+1)); for ( i = 0; i < n_tiles_height+1; ++i ) { tile_matrix[i] = (Tile_t *) malloc(sizeof(Tile_t)*(n_tiles_width+1)); for ( j = 0; j < n_tiles_width+1; ++j ) { /* Create readiness events for every tile */ ocrEventCreate(&(tile_matrix[i][j].bottom_row_event_guid ), OCR_EVENT_STICKY_T, true); ocrEventCreate(&(tile_matrix[i][j].right_column_event_guid ), OCR_EVENT_STICKY_T, true); ocrEventCreate(&(tile_matrix[i][j].bottom_right_event_guid ), OCR_EVENT_STICKY_T, true); } } fprintf(stdout, "Allocated tile matrix\n"); initialize_border_values(tile_matrix, n_tiles_width, n_tiles_height, tile_width, tile_height); struct timeval a; struct timeval b; gettimeofday(&a, 0); for ( i = 1; i < n_tiles_height+1; ++i ) { for ( j = 1; j < n_tiles_width+1; ++j ) { /* Box function parameters and put them on the heap for lifetime */ intptr_t **p_paramv = (intptr_t **)malloc(sizeof(intptr_t*)); intptr_t *paramv = (intptr_t *)malloc(9*sizeof(intptr_t)); paramv[0]=(intptr_t) i; paramv[1]=(intptr_t) j; paramv[2]=(intptr_t) tile_width; paramv[3]=(intptr_t) tile_height; paramv[4]=(intptr_t) tile_matrix; paramv[5]=(intptr_t) string_1; paramv[6]=(intptr_t) string_2; paramv[7]=(intptr_t) n_tiles_height; paramv[8]=(intptr_t) n_tiles_width; *p_paramv = paramv; /* Create an event-driven tasks of smith_waterman tasks */ ocrGuid_t task_guid; ocrEdtCreate(&task_guid, smith_waterman_task, 9, NULL, (void **) p_paramv, PROPERTIES, 3, NULL); /* add dependency to the EDT from the west tile's right column ready event */ ocrAddDependence(tile_matrix[i][j-1].right_column_event_guid, task_guid, 0); /* add dependency to the EDT from the north tile's bottom row ready event */ ocrAddDependence(tile_matrix[i-1][j].bottom_row_event_guid, task_guid, 1); /* add dependency to the EDT from the northwest tile's bottom right ready event */ ocrAddDependence(tile_matrix[i-1][j-1].bottom_right_event_guid, task_guid, 2); /* schedule task*/ ocrEdtSchedule(task_guid); } } ocrCleanup(); gettimeofday(&b, 0); printf("The computation took %f seconds\r\n",((b.tv_sec - a.tv_sec)*1000000+(b.tv_usec - a.tv_usec))*1.0/1000000); return 0; }
extern "C" ocrGuid_t mainEdt(u32 paramc, u64* paramv, u32 depc, ocrEdtDep_t depv[]) { u64 argc = getArgc(depv[0].ptr); int i; char *argv[argc]; for(i=0;i<argc;i++) { argv[i] = getArgv(depv[0].ptr,i); } u64 N; u64 iterations; bool verify; bool verbose; bool printResults; u64 serialBlockSize = SERIAL_BLOCK_SIZE_DEFAULT; if(!parseOptions(argc,argv,&N,&verify,&iterations,&verbose,&printResults,&serialBlockSize)) { printHelp(argv,true); ocrShutdown(); return NULL_GUID; } if(verbose) { for(i=0;i<argc;i++) { PRINTF("argv[%d]: %s\n",i,argv[i]); } } if(iterations > 1 && verbose) { PRINTF("Running %d iterations\n",iterations); } ocrGuid_t startTempGuid,endTempGuid,printTempGuid,endSlaveTempGuid,iterationTempGuid; ocrEdtTemplateCreate(&iterationTempGuid, &fftIterationEdt, 7, 4); ocrEdtTemplateCreate(&startTempGuid, &fftStartEdt, 9, 3); ocrEdtTemplateCreate(&endTempGuid, &fftEndEdt, 9, 5); ocrEdtTemplateCreate(&endSlaveTempGuid, &fftEndSlaveEdt, 5, 3); ocrEdtTemplateCreate(&printTempGuid, &finalPrintEdt, 3, 5); float *x_in; // Output for the FFT float *X_real; float *X_imag; ocrGuid_t dataInGuid,dataRealGuid,dataImagGuid,timeDataGuid; // TODO: OCR cannot handle large datablocks DBCREATE(&dataInGuid, (void **) &x_in, sizeof(float) * N, 0, NULL_GUID, NO_ALLOC); DBCREATE(&dataRealGuid, (void **) &X_real, sizeof(float) * N, 0, NULL_GUID, NO_ALLOC); DBCREATE(&dataImagGuid, (void **) &X_imag, sizeof(float) * N, 0, NULL_GUID, NO_ALLOC); if(verbose) { PRINTF("3 Datablocks of size %lu (N=%lu) created\n",sizeof(float)*N,N); } for(i=0;i<N;i++) { x_in[i] = 0; X_real[i] = 0; X_imag[i] = 0; } x_in[1] = 1; //x_in[3] = -1; //x_in[5] = 1; //x_in[7] = -1; // Create an EDT out of the EDT template ocrGuid_t edtGuid, edtPrevGuid, printEdtGuid, edtEventGuid, edtPrevEventGuid; //ocrEdtCreate(&edtGuid, startTempGuid, EDT_PARAM_DEF, edtParamv, EDT_PARAM_DEF, NULL_GUID, EDT_PROP_FINISH, NULL_GUID, &edtEventGuid); std::stack<ocrGuid_t> edtStack; std::stack<ocrGuid_t> eventStack; edtEventGuid = NULL_GUID; edtPrevEventGuid = NULL_GUID; for(i=1;i<=iterations;i++) { u64 edtParamv[7] = { startTempGuid, endTempGuid, endSlaveTempGuid, N, verbose, serialBlockSize, i }; ocrEdtCreate(&edtGuid, iterationTempGuid, EDT_PARAM_DEF, edtParamv, EDT_PARAM_DEF, NULL_GUID, EDT_PROP_FINISH, NULL_GUID, &edtEventGuid); edtStack.push(edtGuid); eventStack.push(edtEventGuid); } edtEventGuid = eventStack.top(); if(verify) { edtEventGuid = setUpVerify(dataInGuid, dataRealGuid, dataImagGuid, N, edtEventGuid); } double *startTime; DBCREATE(&timeDataGuid, (void **) &startTime, sizeof(double), 0, NULL_GUID, NO_ALLOC); *startTime = mysecond(); u64 edtParamv[3] = { N, verbose, printResults }; // Create finish EDT, with dependence on last EDT ocrGuid_t finishDependencies[5] = { edtEventGuid, dataInGuid, dataRealGuid, dataImagGuid, timeDataGuid }; ocrEdtCreate(&printEdtGuid, printTempGuid, EDT_PARAM_DEF, edtParamv, EDT_PARAM_DEF, finishDependencies, EDT_PROP_NONE, NULL_GUID, NULL); eventStack.pop(); while(!edtStack.empty()) { edtGuid = edtStack.top(); if(!eventStack.empty()) { edtEventGuid = eventStack.top(); } else { edtEventGuid = NULL_GUID; } ocrAddDependence(dataInGuid, edtGuid, 0, DB_MODE_RO); ocrAddDependence(dataRealGuid, edtGuid, 1, DB_MODE_ITW); ocrAddDependence(dataImagGuid, edtGuid, 2, DB_MODE_ITW); ocrAddDependence(edtEventGuid, edtGuid, 3, DB_MODE_RO); edtStack.pop(); eventStack.pop(); } return NULL_GUID; }
extern "C" ocrGuid_t mainEdt(u32 paramc, u64* paramv, u32 depc, ocrEdtDep_t depv[]) { u64 argc = getArgc(depv[0].ptr); int i; char *argv[argc]; for(i=0;i<argc;i++) { argv[i] = getArgv(depv[0].ptr,i); } u64 N; u64 iterations; bool verify; bool verbose; bool printResults; u64 serialBlockSize = SERIAL_BLOCK_SIZE_DEFAULT; if(!parseOptions(argc,argv,&N,&verify,&iterations,&verbose,&printResults,&serialBlockSize)) { printHelp(argv,true); ocrShutdown(); return NULL_GUID; } if(verbose) { for(i=0;i<argc;i++) { PRINTF("argv[%d]: %s\n",i,argv[i]); } PRINTF("Running %d iterations\n",iterations); } ocrGuid_t iterationTempGuid,startTempGuid,endTempGuid,printTempGuid,endSlaveTempGuid; ocrEdtTemplateCreate(&iterationTempGuid, &fftIterationEdt, 6, 2); ocrEdtTemplateCreate(&startTempGuid, &fftStartEdt, 9, 1); ocrEdtTemplateCreate(&endTempGuid, &fftEndEdt, 9, 3); ocrEdtTemplateCreate(&endSlaveTempGuid, &fftEndSlaveEdt, 5, 1); ocrEdtTemplateCreate(&printTempGuid, &finalPrintEdt, 3, 2); // x_in, X_real, and X_imag in a contiguous block float *x; ocrGuid_t dataGuid; // TODO: OCR cannot handle large datablocks DBCREATE(&dataGuid, (void **) &x, sizeof(float) * N * 3, 0, NULL_GUID, NO_ALLOC); if(verbose) { PRINTF("Datablock of size %lu (N=%lu) created\n",sizeof(float)*N*3,N); } for(i=0;i<N;i++) { x[i] = 0; } x[1] = 1; //x[3] = -3; //x[4] = 8; //x[5] = 9; //x[6] = 1; std::stack<ocrGuid_t> edtStack; std::stack<ocrGuid_t> eventStack; u64 edtParamv[6] = { startTempGuid, endTempGuid, endSlaveTempGuid, N, verbose, serialBlockSize }; ocrGuid_t edtGuid, printEdtGuid, edtEventGuid; for(i=1;i<=iterations;i++) { ocrEdtCreate(&edtGuid, iterationTempGuid, EDT_PARAM_DEF, edtParamv, EDT_PARAM_DEF, NULL_GUID, EDT_PROP_FINISH, NULL_GUID, &edtEventGuid); edtStack.push(edtGuid); eventStack.push(edtEventGuid); } edtEventGuid = eventStack.top(); if(verify) { edtEventGuid = setUpVerify(dataGuid, NULL_GUID, NULL_GUID, N, edtEventGuid); } u64 printParamv[3] = { N, verbose, printResults }; ocrGuid_t finishDependencies[2] = { edtEventGuid, dataGuid }; ocrEdtCreate(&printEdtGuid, printTempGuid, EDT_PARAM_DEF, printParamv, EDT_PARAM_DEF, finishDependencies, EDT_PROP_NONE, NULL_GUID, NULL); eventStack.pop(); while(!edtStack.empty()) { edtGuid = edtStack.top(); if(!eventStack.empty()) { edtEventGuid = eventStack.top(); } else { edtEventGuid = NULL_GUID; } ocrAddDependence(dataGuid, edtGuid, 0, DB_MODE_ITW); ocrAddDependence(edtEventGuid, edtGuid, 1, DB_MODE_RO); edtStack.pop(); eventStack.pop(); } return NULL_GUID; }
ocrGuid_t cgTask(u32 paramc, u64 *paramv, u32 depc, ocrEdtDep_t depv[]){ /* params 0: mynode 1: timestep 2: phase depv 0: userblock 1: GSsharedBlock 2: my GSblock 3: cgBlock (matrix and vectors) */ u64 mynode = paramv[0]; u64 timestep = paramv[1]; u64 phase = paramv[2]; userSharedBlock_t * uSB = depv[0].ptr; GSsharedBlock_t * SB = depv[1].ptr; gsBlock_t * mydata = depv[2].ptr; cgBlock_t * cgdata = depv[3].ptr; ocrGuid_t cgEdt, gsEdt; double sum, pap, rtz, alpha, beta; u64 i; switch (phase) { case 0: //Initial call only //Initialize matrix and vectors sum = M*mynode+1; for(i=0;i<M;i++){ cgdata->a[i] = sum; cgdata->b[i] = sum; cgdata->r[i] = sum; cgdata->p[i] = sum++; cgdata->x[i] = 0.0; cgdata->pc[i] = sum; //already incremented } //Prepare for the first summation of rtz sum = 0; for(i=0;i<M;i++) sum += cgdata->r[i]*cgdata->r[i]; mydata->data = sum; //local sum //Create clone paramv[2] = 1; ocrEdtCreate(&cgEdt, uSB->cgTemplate, EDT_PARAM_DEF, paramv, EDT_PARAM_DEF, NULL, EDT_PROP_NONE, NULL_GUID, NULL_GUID); ocrDbRelease(depv[0].guid); ocrAddDependence(depv[0].guid, cgEdt, 0, DB_MODE_RW); ocrAddDependence(SB->rootEvent, cgEdt, 1, DB_MODE_RW); ocrDbRelease(depv[2].guid); ocrAddDependence(depv[2].guid, cgEdt, 2, DB_MODE_RW); ocrDbRelease(depv[3].guid); ocrAddDependence(depv[3].guid, cgEdt, 3, DB_MODE_RW); //launch global sum ocrEdtCreate(&gsEdt, SB->GSxTemplate, EDT_PARAM_DEF, &mynode, EDT_PARAM_DEF, NULL, EDT_PROP_NONE, NULL_GUID, NULL_GUID); ocrDbRelease(depv[1].guid); ocrAddDependence(depv[1].guid, gsEdt, 0, DB_MODE_RW); ocrAddDependence(depv[2].guid, gsEdt, 1, DB_MODE_RW); for(i=0;i<ARITY;i++) ocrAddDependence(NULL_GUID, gsEdt, i+2, DB_MODE_RW); return NULL_GUID; case 1: //consume rtr if(mynode==0) PRINTF("time %d rtr %f \n", timestep, SB->sum); if(timestep==0) SB->rtr0 = SB->sum; else if(SB->sum/SB->rtr0 < 1e-13 || timestep == T) { for(i=0;i<M;i++) PRINTF("CG%d T%d %d value %f \n", mynode, timestep, i, cgdata->x[i]); if(mynode == 0 && M==300 && N==20 && T==100) { if(fabs(cgdata->x[0] - .999794) < 1e-5) PRINTF("PASS\n"); else PRINTF("FAIL difference %f is too large\n", cgdata->x[0] - .999794); } return NULL_GUID; } //preconditioning for(i=0;i<M;i++) cgdata->z[i] = cgdata->r[i]/cgdata->pc[i]; //compute local rtz sum = 0; for(i=0;i<M;i++) sum += cgdata->z[i]*cgdata->r[i]; mydata->data = sum; //Create clone paramv[2] = 2; ocrEdtCreate(&cgEdt, uSB->cgTemplate, EDT_PARAM_DEF, paramv, EDT_PARAM_DEF, NULL, EDT_PROP_NONE, NULL_GUID, NULL_GUID); ocrDbRelease(depv[0].guid); ocrAddDependence(depv[0].guid, cgEdt, 0, DB_MODE_RW); ocrAddDependence(SB->rootEvent, cgEdt, 1, DB_MODE_RW); ocrDbRelease(depv[2].guid); ocrAddDependence(depv[2].guid, cgEdt, 2, DB_MODE_RW); ocrDbRelease(depv[3].guid); ocrAddDependence(depv[3].guid, cgEdt, 3, DB_MODE_RW); //launch global sum ocrEdtCreate(&gsEdt, SB->GSxTemplate, EDT_PARAM_DEF, &mynode, EDT_PARAM_DEF, NULL, EDT_PROP_NONE, NULL_GUID, NULL_GUID); ocrDbRelease(depv[1].guid); ocrAddDependence(depv[1].guid, gsEdt, 0, DB_MODE_RW); ocrAddDependence(depv[2].guid, gsEdt, 1, DB_MODE_RW); for(i=0;i<ARITY;i++) ocrAddDependence(NULL_GUID, gsEdt, i+2, DB_MODE_RW); return NULL_GUID; case 2: //consume rtz if(mynode == 0) SB->rtz = SB->sum; //compute beta if(timestep == 0) beta = 0; else beta = SB->sum/SB->rtzold; //update p for(i=0;i<M;i++) cgdata->p[i] = cgdata->z[i] + beta*cgdata->p[i]; //compute Ap for(i=0;i<M;i++) cgdata->ap[i] = cgdata->a[i]*cgdata->p[i]; //compute pAp sum = 0; for(i=0;i<M;i++) sum += cgdata->p[i]*cgdata->ap[i]; mydata->data = sum; //Create clone paramv[2]=3; ocrEdtCreate(&cgEdt, uSB->cgTemplate, EDT_PARAM_DEF, paramv, EDT_PARAM_DEF, NULL, EDT_PROP_NONE, NULL_GUID, NULL_GUID); ocrDbRelease(depv[0].guid); ocrAddDependence(depv[0].guid, cgEdt, 0, DB_MODE_RW); ocrAddDependence(SB->rootEvent, cgEdt, 1, DB_MODE_RW); ocrDbRelease(depv[2].guid); ocrAddDependence(depv[2].guid, cgEdt, 2, DB_MODE_RW); ocrDbRelease(depv[3].guid); ocrAddDependence(depv[3].guid, cgEdt, 3, DB_MODE_RW); //launch global sum ocrEdtCreate(&gsEdt, SB->GSxTemplate, EDT_PARAM_DEF, &mynode, EDT_PARAM_DEF, NULL, EDT_PROP_NONE, NULL_GUID, NULL_GUID); ocrDbRelease(depv[1].guid); ocrAddDependence(depv[1].guid, gsEdt, 0, DB_MODE_RW); ocrAddDependence(depv[2].guid, gsEdt, 1, DB_MODE_RW); for(i=0;i<ARITY;i++) ocrAddDependence(NULL_GUID, gsEdt, i+2, DB_MODE_RW); return NULL_GUID; case 3: //consume pAp pap = SB->sum; alpha = SB->rtz/pap; if(mynode == 0) SB->rtzold = SB->rtz; //Here so don't need shim //update x and r for(i=0;i<M;i++) { cgdata->x[i] += alpha*cgdata->p[i]; cgdata->r[i] -= alpha*cgdata->ap[i]; } //Prepare for the summation of rtr sum = 0; for(i=0;i<M;i++) sum += cgdata->r[i]*cgdata->r[i]; mydata->data = sum; //local sum //create clone paramv[2]=1; paramv[1]++; ocrEdtCreate(&cgEdt, uSB->cgTemplate, EDT_PARAM_DEF, paramv, EDT_PARAM_DEF, NULL, EDT_PROP_NONE, NULL_GUID, NULL_GUID); ocrDbRelease(depv[0].guid); ocrAddDependence(depv[0].guid, cgEdt, 0, DB_MODE_RW); ocrAddDependence(SB->rootEvent, cgEdt, 1, DB_MODE_RW); ocrDbRelease(depv[2].guid); ocrAddDependence(depv[2].guid, cgEdt, 2, DB_MODE_RW); ocrDbRelease(depv[3].guid); ocrAddDependence(depv[3].guid, cgEdt, 3, DB_MODE_RW); //launch global sum for pAp ocrEdtCreate(&gsEdt, SB->GSxTemplate, EDT_PARAM_DEF, &mynode, EDT_PARAM_DEF, NULL, EDT_PROP_NONE, NULL_GUID, NULL_GUID); ocrDbRelease(depv[1].guid); ocrAddDependence(depv[1].guid, gsEdt, 0, DB_MODE_RW); ocrAddDependence(depv[2].guid, gsEdt, 1, DB_MODE_RW); for(i=0;i<ARITY;i++) ocrAddDependence(NULL_GUID, gsEdt, i+2, DB_MODE_RW); return NULL_GUID; } }
ocrGuid_t fibEdt(u32 paramc, u64* paramv, u32 depc, ocrEdtDep_t depv[]) { void* ptr; ocrGuid_t inDep; ocrGuid_t fib0, fib1, comp; ocrGuid_t fibDone[2]; ocrGuid_t fibArg[2]; inDep = (ocrGuid_t)paramv[0]; int my_ID = paramv[1]; u32 n = *(u32*)(depv[0].ptr); PRINTF("r%d Starting fibEdt(%u)\n", my_ID, n); if (n < 2) { PRINTF("r%d In fibEdt(%d) -- done (sat %lx)\n", my_ID, n, inDep); ocrEventSatisfy(inDep, depv[0].guid); return NULL_GUID; } PRINTF("r%d In fibEdt(%d) -- spawning children\n", my_ID, n); /* create the completion EDT and pass it the in/out argument as a dependency */ /* create the EDT with the done_event as the argument */ { u64 paramv[] = {(u64)inDep, my_ID}; ocrGuid_t templateGuid; ocrEdtTemplateCreate(&templateGuid, complete, 2, 3); ocrEdtCreate(&comp, templateGuid, 2, paramv, 3, NULL, EDT_PROP_NONE, NULL_GUID, NULL); ocrEdtTemplateDestroy(templateGuid); } PRINTF("r%d In fibEdt(%u) -- spawned complete EDT GUID 0x%llx\n", my_ID, n, (u64)comp); ocrAddDependence(depv[0].guid, comp, 2, DB_DEFAULT_MODE); /* create the events that the completion EDT will "wait" on */ ocrEventCreate(&fibDone[0], OCR_EVENT_ONCE_T, EVT_PROP_TAKES_ARG); ocrEventCreate(&fibDone[1], OCR_EVENT_ONCE_T, EVT_PROP_TAKES_ARG); ocrAddDependence(fibDone[0], comp, 0, DB_DEFAULT_MODE); ocrAddDependence(fibDone[1], comp, 1, DB_DEFAULT_MODE); /* allocate the argument to pass to fib(n-1) */ ocrDbCreate(&fibArg[0], (void**)&ptr, sizeof(u32), DB_PROP_NONE, NULL_GUID, NO_ALLOC); PRINTF("r%d In fibEdt(%u) -- created arg DB GUID 0x%llx\n", my_ID, n, fibArg[0]); *((u32*)ptr) = n-1; /* sched the EDT, passing the fibDone event as it's argument */ { u64 paramv[] = {(u64)fibDone[0], my_ID}; ocrGuid_t depv = fibArg[0]; ocrGuid_t templateGuid; ocrEdtTemplateCreate(&templateGuid, fibEdt, 2, 1); ocrEdtCreate(&fib0, templateGuid, 2, paramv, 1, &depv, EDT_PROP_NONE, NULL_GUID, NULL); ocrEdtTemplateDestroy(templateGuid); } PRINTF("r%d In fibEdt(%u) -- spawned first sub-part EDT GUID 0x%llx\n", my_ID, n, fib0); /* then do the exact same thing for n-2 */ ocrDbCreate(&fibArg[1], (void**)&ptr, sizeof(u32), DB_PROP_NONE, NULL_GUID, NO_ALLOC); PRINTF("r%d In fibEdt(%u) -- created arg DB GUID 0x%llx\n", my_ID, n, fibArg[1]); *((u32*)ptr) = n-2; { u64 paramv[] = {(u64)fibDone[1], my_ID}; ocrGuid_t depv = fibArg[1]; ocrGuid_t templateGuid; ocrEdtTemplateCreate(&templateGuid, fibEdt, 2, 1); ocrEdtCreate(&fib1, templateGuid, 2, paramv, 1, &depv, EDT_PROP_NONE, NULL_GUID, NULL); ocrEdtTemplateDestroy(templateGuid); } PRINTF("r%d In fibEdt(%u) -- spawned first sub-part EDT GUID 0x%llx\n", my_ID, n, fib1); PRINTF("r%d Returning from fibEdt(%u)\n", my_ID, n); return NULL_GUID; }