ocrGuid_t complete(u32 paramc, u64* paramv, u32 depc, ocrEdtDep_t depv[]) { u64 arg = (u64)paramv[0]; int my_ID = paramv[1]; ocrGuid_t inDep; u32 in1, in2; u32 out; inDep = (ocrGuid_t)arg; /* When we run, we got our inputs from fib(n-1) and fib(n-2) */ in1 = *(u32*)depv[0].ptr; in2 = *(u32*)depv[1].ptr; out = *(u32*)depv[2].ptr; PRINTF("r%d Done with %d (%d + %d)\n", my_ID, out, in1, in2); /* we return our answer in the 3rd db passed in as an argument */ *((u32*)(depv[2].ptr)) = in1 + in2; /* The app is done with the answers from fib(n-1) and fib(n-2) */ ocrDbDestroy(depv[0].guid); ocrDbDestroy(depv[1].guid); /* and let our parent's completion know we're done with fib(n) */ ocrEventSatisfy(inDep, depv[2].guid); return NULL_GUID; }
/* Do the addition */ u8 summer(u32 paramc, u64 * params, void* paramv[], u32 depc, ocrEdtDep_t depv[]) { int *result; ocrGuid_t resultGuid; /* Get both numbers */ int *n1 = (int*)depv[0].ptr, *n2 = (int*)depv[1].ptr; /* Get event to satisfy */ ocrGuid_t *evt = (ocrGuid_t*)depv[2].ptr; /* Create data-block to put result */ ocrDbCreate(&resultGuid, (void**)&result, sizeof(int), /*flags=*/0, /*location=*/NULL, NO_ALLOC); *result = *n1 + *n2; /* Say hello */ printf("I am summing %d (GUID: 0x%lx) and %d (GUID: 0x%lx) and passing along %d (GUID: 0x%lx)\n", *n1, (u64)depv[0].guid, *n2, (u64)depv[1].guid, *result, (u64)resultGuid); /* Satisfy whomever is waiting on me */ ocrEventSatisfy(*evt, resultGuid); /* Free inputs */ ocrDbDestroy(depv[0].guid); ocrDbDestroy(depv[1].guid); ocrDbDestroy(depv[2].guid); return 0; }
// Takes two events and satisfy a result event //depv[0] db for domainSetup_t //depv[1] db for domainKernel_t ocrGuid_t combineKernelEdt(u32 paramc, u64* paramv, u32 depc, ocrEdtDep_t depv[]) { // timestamp_t stopTimer; // get_time(&stopTimer); ocrGuid_t kernelEdtDoneEvt; // Result event kernelEdtDoneEvt.guid = paramv[0]; // Impl-specific here, we know to expect two DBs ocrGuid_t setupDb = depv[0].guid; domainSetup_t * setupDbPtr = depv[0].ptr; ocrGuid_t kernelDb = depv[1].guid; domainKernel_t * kernelDbPtr = depv[1].ptr; // kernelDbPtr->stopTimer=stopTimer; ocrGuid_t timeDbGuid; long * timeDbPtr; ocrDbCreate(&timeDbGuid, (void**) &timeDbPtr, sizeof(long), 0, NULL_HINT, NO_ALLOC); domainKernelCombine(setupDbPtr, kernelDbPtr, timeDbPtr); // PRINTF("combineEdt timeDbGuid=0x%lx\n", timeDbGuid); ocrDbRelease(timeDbGuid); ocrDbRelease(kernelDb); ocrDbRelease(setupDb); ocrDbDestroy(kernelDb); ocrDbDestroy(setupDb); ocrEventSatisfy(kernelEdtDoneEvt, timeDbGuid); return NULL_GUID; }
ocrGuid_t shutdownEdt(u32 paramc, u64* paramv, u32 depc, ocrEdtDep_t depv[]) { PRINTF("Hello from shutdownEdt\n"); int* data1 = (int*) depv[0].ptr; int* data2 = (int*) depv[1].ptr; PRINTF("Received data1 = %"PRId32", data2 = %"PRId32"\n", *data1, *data2); ocrDbDestroy(depv[0].guid); ocrDbDestroy(depv[1].guid); ocrShutdown(); return NULL_GUID; }
void destroy_simulation(void* s, void* l) { simulation* sim = (simulation*)s; ocrGuid_t* list = (ocrGuid_t*)l; u32 b; for(b = 0; b < sim->bxs.boxes_num; ++b) ocrDbDestroy(list[b]); ocrDbDestroy(sim->bxs.list); if(sim->pot.eam.f.values != NULL_GUID) { ocrDbDestroy(sim->pot.eam.phi.values); ocrDbDestroy(sim->pot.eam.rho.values); ocrDbDestroy(sim->pot.eam.f.values); } }
u8 init_simulation(command* cmd, simulation* sim, timer* t, ocrGuid_t** list) { sim->step = 0; sim->steps = cmd->steps; sim->period = cmd->period; sim->dt = cmd->dt; sim->e_potential = 0.0; sim->e_kinetic = 0.0; u8 insane = 0; if(cmd->doeam) insane = init_eam(cmd->pot_dir, cmd->pot_name, cmd->pot_type, &sim->pot, sim->dt); else init_lj(&sim->pot, sim->dt); if(insane) return insane; real_t lattice_const = cmd->lat; if(cmd->lat < 0.0) lattice_const = sim->pot.lat; insane = sanity_checks(cmd, sim->pot.cutoff, lattice_const, sim->pot.lattice_type); if(insane) return insane; ocrGuid_t box_tmp; box** box_ptr = init_lattice(sim, cmd, lattice_const, list, &box_tmp); profile_start(redistribute_timer,t); redistribute_atoms(sim, box_ptr, sim->bxs.boxes_num); profile_stop(redistribute_timer,t); ocrDbDestroy(box_tmp); return 0; }
inline static void satisfyInitialTiles(u32 numTiles, u32 tileSize, double** matrix, ocrGuid_t*** lkji_event_guids) { u32 i,j,index; u32 A_i, A_j, T_i, T_j; for( i = 0 ; i < numTiles ; ++i ) { for( j = 0 ; j <= i ; ++j ) { ocrGuid_t db_guid; ocrGuid_t db_affinity = NULL_GUID; void* temp_db; ocrGuid_t tmpdb_guid; ocrDbCreate(&db_guid, &temp_db, sizeof(double)*tileSize*tileSize, FLAGS, db_affinity, NO_ALLOC); double* temp = (double*) temp_db; double** temp2D; ocrDbCreate(&tmpdb_guid, (void *)&temp2D, sizeof(double*)*tileSize, FLAGS, NULL_GUID, NO_ALLOC); for( index = 0; index < tileSize; ++index ) temp2D [index] = &(temp[index*tileSize]); // Split the matrix u32o tiles and write it u32o the item space at time 0. // The tiles are indexed by tile indices (which are tag values). for( A_i = i*tileSize, T_i = 0 ; T_i < tileSize; ++A_i, ++T_i ) { for( A_j = j*tileSize, T_j = 0 ; T_j < tileSize; ++A_j, ++T_j ) { temp2D[ T_i ][ T_j ] = matrix[ A_i ][ A_j ]; } } ocrEventSatisfy(lkji_event_guids[i][j][0], db_guid); ocrDbDestroy(tmpdb_guid); } } }
ocrGuid_t endEdt(u32 paramc, u64* paramv, u32 depc, ocrEdtDep_t depv[]) { ocrGuid_t infoGuid = depv[0].guid; info_t * info = (info_t *) depv[0].ptr; print_throughput("TEST", (info->max * NB_SATISFY), usec_to_sec(info->timer)); ocrDbRelease(infoGuid); ocrDbDestroy(infoGuid); ocrShutdown(); return NULL_GUID; }
ocrGuid_t mainEdt(u32 paramc, u64* paramv, u32 depc, ocrEdtDep_t depv[]) { // Create a DB void * dbPtr; ocrGuid_t dbGuid; ocrDbCreate(&dbGuid, &dbPtr, sizeof(TYPE_ELEM_DB) * NB_ELEM_DB, 0, NULL_HINT, NO_ALLOC); ocrDbDestroy(dbGuid); ocrShutdown(); return NULL_GUID; }
/* Print the result */ u8 autumn(u32 paramc, u64 * params, void* paramv[], u32 depc, ocrEdtDep_t depv[]) { int * result = (int*)depv[0].ptr; printf("Got result: %d (GUID: 0x%lx)\n", *result, (u64)depv[0].guid); /* Destroy the input data-block */ ocrDbDestroy(depv[0].guid); /* Last EDT to execute */ ocrFinish(); return 0; }
// paramv[0]: continuation after iterations // depv[0]: info // depv[1]: done event for the work spawned by the iteration, carries the time DB ocrGuid_t iterationEdt(u32 paramc, u64* paramv, u32 depc, ocrEdtDep_t depv[]) { ocrGuid_t iterationsDoneEvt; iterationsDoneEvt.guid = paramv[0]; ocrGuid_t infoGuid = depv[0].guid; info_t * info = (info_t *) depv[0].ptr; ocrGuid_t timeDbGuid = depv[1].guid; long * timePrevIt = (long *) depv[1].ptr; // PRINTF("iteration %d\n", info->i); if (timePrevIt != NULL) { info->timer += (*timePrevIt); ocrDbRelease(timeDbGuid); ocrDbDestroy(timeDbGuid); } if (info->i < info->max) { //TODO do a pipeline EDT u64 affCount = 0; ocrAffinityCount(AFFINITY_PD, &affCount); ocrGuid_t affinities[affCount]; ocrAffinityGet(AFFINITY_PD, &affCount, affinities); ocrGuid_t stageInit; ocrEventCreate(&stageInit, OCR_EVENT_ONCE_T, false); ocrGuid_t stagePrev = stageInit; u32 i = PIPE_START; while(i < (PIPE_START+PIPE_SZ)) { ocrGuid_t stageEdtDoneEvt; ocrEventCreate(&stageEdtDoneEvt, OCR_EVENT_ONCE_T, false); ocrGuid_t stageEdtGuid; //TODO I wonder if we shouldn't give the whole info to a functor and invoke that chain(&stageEdtGuid, info->edtTemplGuids[i], affinities[info->edtAffinities[i]], stagePrev, stageEdtDoneEvt); stagePrev = stageEdtDoneEvt; i++; } info->i+=1; ocrDbRelease(infoGuid); ocrGuid_t nextItEdtGuid; // 'iterationsDoneEvt' is passed on and on til the last iteration iterate(&nextItEdtGuid, info->edtTemplGuids[ITER_IDX], /*prev*/stagePrev, /*data*/infoGuid, /*next*/iterationsDoneEvt); // Start the pipeline ocrEventSatisfy(stageInit, NULL_GUID); } else { ocrEventSatisfy(iterationsDoneEvt, infoGuid); } return NULL_GUID; }