コード例 #1
0
ファイル: testOcrLib2.c プロジェクト: ChengduoZhao/ocr
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;
}
コード例 #2
0
ファイル: pcg.c プロジェクト: shamouda/ocr-apps
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;
}
コード例 #3
0
ファイル: pcg.c プロジェクト: shamouda/ocr-apps
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;
}
コード例 #4
0
ファイル: testDistAffinity2.c プロジェクト: shamouda/ocr
ocrGuid_t mainEdt(u32 paramc, u64* paramv, u32 depc, ocrEdtDep_t depv[]) {
    u64 affinityCount;
    ocrAffinityCount(AFFINITY_PD, &affinityCount);
    ocrGuid_t dbAffGuid;
    ocrGuid_t * dbAffPtr;
    ocrDbCreate(&dbAffGuid, (void **)&dbAffPtr, sizeof(ocrGuid_t) * affinityCount, DB_PROP_SINGLE_ASSIGNMENT, NULL_HINT, NO_ALLOC);
    ocrAffinityGet(AFFINITY_PD, &affinityCount, dbAffPtr);
    ASSERT(affinityCount >= 1);

    // create local edt that depends on the remote edt, the db is automatically cloned
    ocrGuid_t remoteEdtTemplateGuid;
    ocrEdtTemplateCreate(&remoteEdtTemplateGuid, remoteEdt, 0, 1);

    ocrGuid_t eventsGuid[COUNT_EDT];
    ocrGuid_t dbsGuid[COUNT_EDT];
    u64 i = 0;
    while(i < COUNT_EDT) {
        ocrEventCreate(&eventsGuid[i],OCR_EVENT_ONCE_T, EVT_PROP_NONE);
        ocrGuid_t * dbPtr;
        ocrDbCreate(&dbsGuid[i], (void **)&dbPtr, sizeof(ocrGuid_t)*2, DB_PROP_SINGLE_ASSIGNMENT, NULL_HINT, NO_ALLOC);
        dbPtr[0] = eventsGuid[i];
        dbPtr[1] = dbAffPtr[i%affinityCount];
        ocrDbRelease(dbsGuid[i]);
        i++;
    }
    ocrDbRelease(dbAffGuid);

    // Setup shutdown EDT
    ocrGuid_t shutdownEdtTemplateGuid;
    ocrEdtTemplateCreate(&shutdownEdtTemplateGuid, shutdownEdt, 0, COUNT_EDT);
    ocrHint_t edtHint;
    ocrHintInit( &edtHint, OCR_HINT_EDT_T );

    ocrGuid_t shutdownEdtGuid;
    ocrEdtCreate(&shutdownEdtGuid, shutdownEdtTemplateGuid, 0, NULL, EDT_PARAM_DEF, eventsGuid,
                 EDT_PROP_NONE, NULL_HINT, NULL);

    // Spawn 'COUNT_EDT' EDTs, each satisfying its event
    i = 0;
    while(i < COUNT_EDT) {
        ocrSetHintValue( & edtHint, OCR_HINT_EDT_AFFINITY, ocrAffinityToHintValue( dbAffPtr[i%affinityCount]) );
        // Create EDTs
        ocrGuid_t edtGuid;
        ocrEdtCreate(&edtGuid, remoteEdtTemplateGuid, 0, NULL, EDT_PARAM_DEF, &dbsGuid[i],
            EDT_PROP_NONE, &edtHint, NULL);
        i++;
    }

    return NULL_GUID;
}
コード例 #5
0
ファイル: ex3.c プロジェクト: shamouda/ocr-apps
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
    //END-TODO

    //TODO Setup dependence between event and stepA's EDTs slot 0
    //END-TODO

    //TODO Satisfy the event with the datablock
    //END-TODO

    return NULL_GUID;
}
コード例 #6
0
ファイル: testOcrEventOnce1.c プロジェクト: shamouda/ocr
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;
}
コード例 #7
0
ファイル: edtDepvUninit1.c プロジェクト: shamouda/ocr
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;
}
コード例 #8
0
ファイル: remoteLatchSatisfy.c プロジェクト: shamouda/ocr
// paramv[0]: event to satisfy when kernel is done
// depv[0]: setupEdt completed (may carry a DB)
ocrGuid_t kernelEdt(u32 paramc, u64* paramv, u32 depc, ocrEdtDep_t depv[]) {
    // PRINTF("kernelEdt\n");
    ocrGuid_t kernelEdtDoneEvt;
    kernelEdtDoneEvt.guid = paramv[0];
    ocrGuid_t setupDb = depv[0].guid;
    domainSetup_t * setupDbPtr = depv[0].ptr;

    // The sub kernel done event
    ocrGuid_t subKernelDoneEvt;
    ocrEventCreate(&subKernelDoneEvt, OCR_EVENT_ONCE_T, true);

    // This EDT done event
    ocrGuid_t selfDoneEvt;
    ocrEventCreate(&selfDoneEvt, OCR_EVENT_ONCE_T, true);

    // Combine those in a combine EDT that satisfies kernelEdtDoneEvt
    //TODO same issue of allocating tpl every iteration
    ocrGuid_t curAffGuid;
    ocrAffinityGetCurrent(&curAffGuid);
    ocrGuid_t combEdtTplGuid;
    ocrEdtTemplateCreate(&combEdtTplGuid, combineKernelEdt, 1, 2);
    ocrGuid_t combineEdtGuid;
    combine(&combineEdtGuid, combEdtTplGuid, curAffGuid,
                  selfDoneEvt, subKernelDoneEvt, kernelEdtDoneEvt);
    ocrEdtTemplateDestroy(combEdtTplGuid);

    timestamp_t timer;
    domainKernel(subKernelDoneEvt, setupDbPtr, &timer);

    // Satisfy self event with the timer information
    ocrEventSatisfy(selfDoneEvt, setupDb);
    return NULL_GUID;
}
コード例 #9
0
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);
}
コード例 #10
0
ファイル: remoteLatchSatisfy.c プロジェクト: shamouda/ocr
// 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);
}
コード例 #11
0
ファイル: testDistAffinity3.c プロジェクト: shamouda/ocr
ocrGuid_t mainEdt(u32 paramc, u64* paramv, u32 depc, ocrEdtDep_t depv[]) {
    u64 affinityCount;
    ocrAffinityCount(AFFINITY_PD, &affinityCount);
    ocrGuid_t dbAffGuid;
    ocrGuid_t * dbAffPtr;
    ocrDbCreate(&dbAffGuid, (void **)&dbAffPtr, sizeof(ocrGuid_t) * affinityCount, DB_PROP_SINGLE_ASSIGNMENT, NULL_HINT, NO_ALLOC);
    ocrAffinityGet(AFFINITY_PD, &affinityCount, dbAffPtr);
    ASSERT(affinityCount >= 1);
    ocrGuid_t affinityGuid = dbAffPtr[affinityCount-1];
    ocrDbRelease(dbAffGuid);

    // Finish EDT potentially remote, but spawning all children on the same node
    ocrGuid_t finishEdtTemplateGuid;
    ocrEdtTemplateCreate(&finishEdtTemplateGuid, finishEdt, 0, 0);
    ocrHint_t edtHint;
    ocrHintInit( &edtHint, OCR_HINT_EDT_T );
    ocrSetHintValue( & edtHint, OCR_HINT_EDT_AFFINITY, ocrAffinityToHintValue( affinityGuid) );

    PRINTF("mainEdt: spawning remote finish-EDT\n");
    ocrGuid_t edtGuid;
    ocrEdtCreate(&edtGuid, finishEdtTemplateGuid, 0, NULL, EDT_PARAM_DEF, 0,
        EDT_PROP_NONE, &edtHint, NULL);

    return NULL_GUID;
}
コード例 #12
0
ファイル: testDuplicateDeps0.c プロジェクト: shamouda/ocr
ocrGuid_t mainEdt(u32 paramc, u64* paramv, u32 depc, ocrEdtDep_t depv[]) {
    // 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("[local] 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 readerEdtTemplateGuid;
    ocrEdtTemplateCreate(&readerEdtTemplateGuid, readerEdt, 0, 3);

    ocrGuid_t dbGuids [3] = {dbGuid, dbGuid, dbGuid};
    ocrGuid_t readerEdtGuid;
    ocrEdtCreate(&readerEdtGuid, readerEdtTemplateGuid, 0, NULL, 3, dbGuids,
                 EDT_PROP_NONE, NULL_HINT, NULL);

    return NULL_GUID;
}
コード例 #13
0
ファイル: testOcrAddDeps2.c プロジェクト: ChengduoZhao/ocr
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;
}
コード例 #14
0
ファイル: testOcrEventParam1.c プロジェクト: shamouda/ocr
ocrGuid_t mainEdt(u32 paramc, u64* paramv, u32 depc, ocrEdtDep_t depv[]) {
    // Current thread is '0' and goes on with user code.
    ocrGuid_t ndepv[1];
    ocrGuid_t eventGuid;
    ocrEventCreate(&eventGuid, OCR_EVENT_STICKY_T, true);
    ndepv[0] = eventGuid;

    // Creates the EDT
    u32 nparamc = 1;
    u64 nparamv = 32;

    // 'ndepv' stores dependencies, so no need to call
    // ocrAddDependence later on to register events.
    ocrGuid_t edtGuid;
    ocrGuid_t taskForEdtTemplateGuid;
    ocrEdtTemplateCreate(&taskForEdtTemplateGuid, taskForEdt, nparamc, 1 /*depc*/);
    ocrEdtCreate(&edtGuid, taskForEdtTemplateGuid, EDT_PARAM_DEF, &nparamv, EDT_PARAM_DEF, /*depv=*/ndepv,
                 /*properties=*/0, NULL_HINT, /*outEvent=*/NULL);

    int *k;
    ocrGuid_t dbGuid;
    ocrDbCreate(&dbGuid,(void **) &k,
                sizeof(int), /*flags=*/DB_PROP_NONE,
                /*location=*/NULL_HINT,
                NO_ALLOC);
    *k = 42;

    ocrEventSatisfy(eventGuid, dbGuid);

    return NULL_GUID;
}
コード例 #15
0
ファイル: testLegacy6.c プロジェクト: shamouda/ocr
// This is the "key" EDT that is responsible for spawning all the workers
ocrGuid_t keyEdt ( u32 paramc, u64* paramv, u32 depc, ocrEdtDep_t depv[]) {
    ocrGuid_t templateGuid;
    ocrEdtTemplateCreate(&templateGuid, workerEdt, 0, 0);

    ocrGuid_t edtGuid;
    ocrEdtCreate(&edtGuid, templateGuid, 0, NULL, 0, NULL, EDT_PROP_FINISH, NULL_HINT, NULL);
    return NULL_GUID;
}
コード例 #16
0
ファイル: basicIO.c プロジェクト: shamouda/ocr-apps
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;
}
コード例 #17
0
ocrGuid_t mainEdt(u32 paramc, u64* paramv, u32 depc, ocrEdtDep_t depv[]) {
    ocrGuid_t terminateEdtGuid;
    ocrGuid_t terminateEdtTemplateGuid;
    ocrEdtTemplateCreate(&terminateEdtTemplateGuid, terminateEdt, EDT_PARAM_UNK /*paramc*/, 0 /*depc*/);
    u8 res = ocrEdtCreate(&terminateEdtGuid, terminateEdtTemplateGuid, 1, NULL, 0, NULL,
                 /*properties=*/EDT_PROP_FINISH, NULL_HINT, /*outEvent=*/ NULL);
    ASSERT(!res);
    if(res) {
        ocrAbort(res);
    }
    return NULL_GUID;
}
コード例 #18
0
ファイル: remoteLatchSatisfy.c プロジェクト: shamouda/ocr
void setupFramework(info_t * info, ocrGuid_t self, u32 maxIt, u32 affCount) {
    info->self = self;
    info->i = 0;
    info->max = maxIt;
    ocrEdtTemplateCreate(&(info->edtTemplGuids[ITER_IDX]), iterationEdt, 1, 2);
    ocrEdtTemplateCreate(&(info->edtTemplGuids[SETUP_IDX]), setupEdt, 1, 1);
    ocrEdtTemplateCreate(&(info->edtTemplGuids[KERNEL_IDX]), kernelEdt, 1, 1);
    ocrEdtTemplateCreate(&(info->edtTemplGuids[POST_IDX]), postEdt, 1, 1);
    ocrEdtTemplateCreate(&(info->edtTemplGuids[END_IDX]), endEdt, 1, 1);

    //TODO don't like this very much but I don't see how to specify
    //edt affinities otherwise.
    u32 i = 0;
    while (i < NB_TMPL) {
        info->edtAffinities[i] = 0;
        i++;
    }
    info->edtAffinities[SETUP_IDX] = affCount-1;
    ASSERT(affCount >= 1);
    info->timer = 0;
}
コード例 #19
0
ファイル: edtDepvUnk2.c プロジェクト: ChengduoZhao/ocr
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;
}
コード例 #20
0
ファイル: testDistAffinity3.c プロジェクト: shamouda/ocr
ocrGuid_t finishEdt(u32 paramc, u64* paramv, u32 depc, ocrEdtDep_t depv[]) {
    ocrGuid_t edtTemplateGuid;
    ocrEdtTemplateCreate(&edtTemplateGuid, remoteEdt, 0, 1);

    ocrGuid_t eventsGuid[COUNT_EDT];
    ocrGuid_t dbsGuid[COUNT_EDT];
    u64 i = 0;
    while(i < COUNT_EDT) {
        ocrEventCreate(&eventsGuid[i],OCR_EVENT_ONCE_T, EVT_PROP_NONE);
        ocrGuid_t * dbPtr;
        ocrDbCreate(&dbsGuid[i], (void **)&dbPtr, sizeof(ocrGuid_t), DB_PROP_SINGLE_ASSIGNMENT, NULL_HINT, NO_ALLOC);
        dbPtr[0] = eventsGuid[i];
        ocrDbRelease(dbsGuid[i]);
        i++;
    }

    // Setup shutdown EDT
    ocrGuid_t shutdownEdtTemplateGuid;
    ocrEdtTemplateCreate(&shutdownEdtTemplateGuid, shutdownEdt, 0, COUNT_EDT);

    ocrGuid_t shutdownEdtGuid;
    ocrEdtCreate(&shutdownEdtGuid, shutdownEdtTemplateGuid, 0, NULL, EDT_PARAM_DEF, eventsGuid,
                 EDT_PROP_NONE, NULL_HINT, NULL);
    ocrGuid_t currentAffinity;
    ocrAffinityGetCurrent(&currentAffinity);

    ocrHint_t edtHint;
    ocrHintInit( &edtHint, OCR_HINT_EDT_T );
    ocrSetHintValue( & edtHint, OCR_HINT_EDT_AFFINITY, ocrAffinityToHintValue( currentAffinity) );
    // Spawn 'COUNT_EDT' EDTs, each satisfying its event
    i = 0;
    while(i < COUNT_EDT) {
        // Create EDTs
        ocrGuid_t edtGuid;
        ocrEdtCreate(&edtGuid, edtTemplateGuid, 0, NULL, EDT_PARAM_DEF, &dbsGuid[i],
            EDT_PROP_NONE, &edtHint, NULL);
        i++;
    }
    return NULL_GUID;
}
コード例 #21
0
ファイル: testLegacy1.c プロジェクト: shamouda/ocr
int main(int argc, const char * argv[]) {
    ocrConfig_t ocrConfig;
    ocrGuid_t legacyCtx;
    ocrParseArgs(argc, argv, &ocrConfig);
    ocrLegacyInit(&legacyCtx, &ocrConfig);
    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=*/0, NULL_HINT, /*outEvent=*/NULL);
    // This should wait for the EDT to finish
    ocrLegacyFinalize(legacyCtx, true);
    return 0;
}
コード例 #22
0
ファイル: example1.c プロジェクト: shamouda/ocr
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;
}
コード例 #23
0
ファイル: testDistParamc1.c プロジェクト: shamouda/ocr
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];

    ocrGuid_t edtTemplateGuid;
    ocrEdtTemplateCreate(&edtTemplateGuid, remoteEdt, 2, 0);
    ocrHint_t edtHint;
    ocrHintInit( &edtHint, OCR_HINT_EDT_T );
    ocrSetHintValue( & edtHint, OCR_HINT_EDT_AFFINITY, ocrAffinityToHintValue( edtAffinity) );
    ocrGuid_t edtGuid;
    u64 edtParamv[2] = {333,555};
    ocrEdtCreate(&edtGuid, edtTemplateGuid, EDT_PARAM_DEF, (u64*) &edtParamv, 0, NULL,
        EDT_PROP_NONE, &edtHint, NULL);
    return NULL_GUID;
}
コード例 #24
0
ファイル: testDistDbSA2.c プロジェクト: shamouda/ocr
ocrGuid_t saViolationEdt(u32 paramc, u64* paramv, u32 depc, ocrEdtDep_t depv[]) {
    ocrGuid_t dbGuid = (ocrGuid_t) depv[0].guid;
    PRINTF("[remote] saViolationEdt: executing, depends on remote DB guid "GUIDF" \n", GUIDA(dbGuid));
    TYPE_ELEM_DB v = 1;
    int i = 0;
    TYPE_ELEM_DB * data = (TYPE_ELEM_DB *) depv[0].ptr;
    while (i < NB_ELEM_DB) {
        ASSERT (data[i] == v++);
        i++;
    }
    PRINTF("[remote] saViolationEdt: illegal local writes to DB/SA\n");

    // Being a bad boy and trying to modify the DB/SA content.
    // There's nothing the runtime can do to prevent spoiling
    // this node copy (beside making an extra preventing copy).
    // However the runtime guarantees this won't be written-back
    // to the DB/SA located on its home node
    while (i < NB_ELEM_DB) {
        data[i] *= 2;
        i++;
    }
    ocrDbRelease(dbGuid);

    u64 affinityCount;
    ocrAffinityCount(AFFINITY_PD, &affinityCount);
    ASSERT(affinityCount >= 1);
    ocrGuid_t affinities[affinityCount];
    ocrAffinityGet(AFFINITY_PD, &affinityCount, affinities);
    ocrGuid_t edtAffinity = affinities[0]; //TODO this implies we know current PD is '0'

    ocrGuid_t checkerTemplateGuid;
    ocrEdtTemplateCreate(&checkerTemplateGuid, checkerEdt, 0, 1);
    ocrHint_t edtHint;
    ocrHintInit( &edtHint, OCR_HINT_EDT_T );
    ocrSetHintValue( & edtHint, OCR_HINT_EDT_AFFINITY, ocrAffinityToHintValue( edtAffinity) );

    PRINTF("[remote] saViolationEdt: create checker EDT at DB/SA home node\n");
    ocrGuid_t checkerEdtGuid;
    ocrEdtCreate(&checkerEdtGuid, checkerTemplateGuid, 0, NULL, 1, &dbGuid,
                 EDT_PROP_NONE, &edtHint, NULL);
    return NULL_GUID;
}
コード例 #25
0
ファイル: testOcrDepv1.c プロジェクト: shamouda/ocr
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_HINT,
                NO_ALLOC);
    *k = 42;

    // 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=*/&dbGuid,
                 /*properties=*/0, NULL_HINT, /*outEvent=*/NULL);

    return NULL_GUID;
}
コード例 #26
0
ファイル: testDist0.c プロジェクト: shamouda/ocr
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 local edt that depends on the remote edt, the db is automatically cloned
    ocrGuid_t remoteEdtTemplateGuid;
    ocrEdtTemplateCreate(&remoteEdtTemplateGuid, remoteEdt, 0, 0);
    ocrHint_t edtHint;
    ocrHintInit( &edtHint, OCR_HINT_EDT_T );
    ocrSetHintValue( & edtHint, OCR_HINT_EDT_AFFINITY, ocrAffinityToHintValue( edtAffinity) );

    ocrGuid_t edtGuid;
    ocrEdtCreate(&edtGuid, remoteEdtTemplateGuid, 0, NULL, 0, NULL,
        EDT_PROP_NONE, &edtHint, NULL);

    return NULL_GUID;
}
コード例 #27
0
ファイル: testOcrEventLatch1.c プロジェクト: ChengduoZhao/ocr
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;
}
コード例 #28
0
ファイル: remoteLatchSatisfy.c プロジェクト: shamouda/ocr
// 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);
}
コード例 #29
0
ファイル: testOcrLib2.c プロジェクト: ChengduoZhao/ocr
ocrGuid_t rootEdt(u32 paramc, u64* paramv, u32 depc, ocrEdtDep_t depv[]) {
    // Build a data-block to be shared with sub-edts
    u64 * array;
    ocrGuid_t dbGuid;
    ocrDbCreate(&dbGuid,(void **) &array, sizeof(u64)*N, 0, NULL_GUID, NO_ALLOC);

    ocrGuid_t updaterEdtTemplateGuid;
    ocrEdtTemplateCreate(&updaterEdtTemplateGuid, updaterEdt, 1 /*paramc*/, 1/*depc*/);
    u64 i = 0;
    while (i < N) {
        // Pass down the index to write to and the db guid through params
        // (Could also be done through dependences)
        u32 nparamc = 1;
        u64* nparamv = (u64*) malloc(sizeof(void *)*nparamc);
        nparamv[0] = i;
        // Pass the guid we got fron depv to the updaterEdt through depv
        ocrGuid_t updaterEdtGuid;
        ocrEdtCreate(&updaterEdtGuid, updaterEdtTemplateGuid, EDT_PARAM_DEF, nparamv, EDT_PARAM_DEF, &dbGuid, 0, NULL_GUID, NULL_GUID);
        i++;
    }
    return dbGuid;
}
コード例 #30
0
ファイル: ex3.c プロジェクト: shamouda/ocr-apps
ocrGuid_t stepA_edt(u32 paramc, u64* paramv, u32 depc, ocrEdtDep_t depv[]) {
    u64 * data = depv[0].ptr;
    //TODO retrieve data-block guid from depv
    //END-TODO
    u64 arraySize = paramv[0];

    // Do step A processing: initialize the array
    u64 i = 0;
    while(i < arraySize) {
        data[i] = 0;
        i++;
    }

    // Setup next step
    ocrGuid_t stepBEdtTemplateGuid;
    ocrEdtTemplateCreate(&stepBEdtTemplateGuid, stepB_edt, 1 /*paramc*/, 1 /*depc*/);

    ocrGuid_t stepBEdtGuid;
    ocrEdtCreate(&stepBEdtGuid, stepBEdtTemplateGuid, EDT_PARAM_DEF, paramv,
                 EDT_PARAM_DEF, &dataGuid, /*prop=*/EDT_PROP_NONE, NULL_GUID, NULL);

    return NULL_GUID;
}