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