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;
}
