# HG changeset patch # User Sean Halle # Date 1380035298 25200 # Node ID efca8e7ec576f61453426625451f10bdd0ad012f initial add -- working version diff -r 000000000000 -r efca8e7ec576 DKU_Fns.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/DKU_Fns.c Tue Sep 24 08:08:18 2013 -0700 @@ -0,0 +1,122 @@ +/* + * Copyright 2009 OpenSourceResearchInstitute.org + * Licensed under GNU General Public License version 2 + * + * Author: seanhalle@yahoo.com + * + */ + + +#include +#include +#include "DKU__Test_App.h" + +/*Bare smoke test of DKU wrapper library functions. + * Create one DKU instance, with a dummy kernel + * Bare bones divider and undivider + * simple root piece maker + * dummy serial kernel + */ + +int +square( int x ) + { return x*x; + } + + +DKUPiece * +rootPieceMakerFn( void *params, DKUInstance *dkuInstance ) + { DKUPiece *rootPiece; + + rootPiece = PRServ__DKU_make_empty_DKU_piece(); + rootPiece->parent = NULL; + rootPiece->payload = params; + rootPiece->dkuInstance = dkuInstance; + + return rootPiece; + } + +DKUPiece * +make_root_dku_piece_for_test_inst( int32 *data, int32 size, + DKUInstance *dkuInstance ) + { DKUPiece *rootPiece; + TestAppStruct *params; + + params = PR__malloc( sizeof(TestAppStruct) ); + params->startIter = 0; + params->endIter = size-1; + params->data = data; + params->size = size; + rootPiece = (*(dkuInstance->rootPieceMaker))( params, dkuInstance ); + return rootPiece; + } + + +void +kernelFn( void *_params, SlaveVP *animVP ) + { int32 i; + DKUPiece *piece = (DKUPiece *)_params; + TestAppStruct *params = (TestAppStruct *)piece->payload; + int32 *data = params->data; + + DEBUG__printf(dbgAppFlow, "Kernel %d", params->startIter); + + for( i=params->startIter; i <= params->endIter; ++i ) + { data[i] = square(i); + } + PRServ__DKU_end_kernel( piece, animVP ); + } + + +/*Serial kernel is called with bare app-defined struct, not DKUPiece + */ +void +serialKernelFn( void *_params, SlaveVP *animVP ) + { int32 i; + TestAppStruct *params = (TestAppStruct *)_params; + int32 *data = params->data; + + DEBUG__printf(dbgAppFlow, "SerialKernel %d", params->startIter); + + for( i=params->startIter; i < params->endIter; ++i ) + { data[i] = square(i); + } + PRServ__DKU_end_serial_kernel( animVP ); + } + +void +dividerFn( DKUPiece *pieceToDivide ) + { + int32 idx, childIdx, numChildren, size, *data; + DKUPiece *childPiece, **childrenArray; + TestAppStruct *params; + DEBUG__printf(dbgAppFlow, "divider %p", pieceToDivide) + + numChildren = pieceToDivide->numChildren; + childrenArray = PR__malloc( numChildren * sizeof(DKUPiece *) ); + size = ((TestAppStruct*)pieceToDivide->payload)->size; + data = ((TestAppStruct*)pieceToDivide->payload)->data; + int chunkSize = size/numChildren; //for portability, lang would choose this dynamically at run time + //note: should do processing to catch too small a chunksize and deal w/it + for( childIdx = 0; childIdx < numChildren; childIdx++ ) + { params = PR__malloc(sizeof(TestAppStruct)); //these define work the task performs + idx = childIdx * chunkSize; + params->startIter = idx; + params->endIter = idx + chunkSize -1; + params->data = data; + params->size = size; + childPiece = PRServ__DKU_make_child_piece_from( pieceToDivide ); + childPiece->payload = params; + childrenArray[childIdx] = childPiece; + } + params->endIter = size -1; //catch truncation error from chunkSize calc + + pieceToDivide->children = childrenArray; + } + +void undividerFn( DKUPiece *piece ) + { + //DEBUG__printf(dbgAppFlow, "Undivider %p", piece) + //nothing to do -- request handler does counting of completions + } + diff -r 000000000000 -r efca8e7ec576 DKU__Test_App.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/DKU__Test_App.h Tue Sep 24 08:08:18 2013 -0700 @@ -0,0 +1,53 @@ +/* + * Copyright 2013 OpenSourceResearchInstitute.org + * Licensed under GNU General Public License version 2 + */ + +#ifndef _DKU_TEST_APP_H_ +#define _DKU_TEST_APP_H_ + +#include + +#include "../PR_defs__turn_on_and_off.h" +#include + +/*Bare smoke test of DKU wrapper library functions. + * Create one DKU instance, with a dummy kernel + * Bare bones divider and undivider + * simple root piece maker + * dummy serial kernel + */ + +//=============================== Defines ============================== + +//============================== Structures ============================== +typedef struct + { int32 *data; + } +SeedParams; + +typedef struct + { + int32 *data; + int32 size; + int32 startIter; + int32 endIter; + } +TestAppStruct; + +//============================= Processor Functions ========================= +void test_app_seed_Fn( void *data, SlaveVP *animatingVP ); //seed VP function + +DKUPiece *rootPieceMakerFn( void *data, DKUInstance *dkuInstance ); +void kernelFn( void *_params, SlaveVP *animVP ); //used as task birth Fn +void serialKernelFn( void *_params, SlaveVP *animVP ); //used as task birth Fn +void dividerFn( DKUPiece *piece ); +void undividerFn( DKUPiece *piece ); + +DKUPiece * +make_root_dku_piece_for_test_inst( int32 *data, int32 size, + DKUInstance *dkuInstance ); + +//================================ Global Vars ============================== + +#endif /*_SSR_MATRIX_MULT_H_*/ diff -r 000000000000 -r efca8e7ec576 SeedVP.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/SeedVP.c Tue Sep 24 08:08:18 2013 -0700 @@ -0,0 +1,63 @@ +/* + * Copyright 2009 OpenSourceResearchInstitute.org + * Licensed under GNU General Public License version 2 + * + * Author: seanhalle@yahoo.com + * + */ + + +#include +#include +#include "DKU__Test_App.h" + +/*Bare smoke test of DKU wrapper library functions. + * Create one DKU instance, with a dummy kernel + * Bare bones divider and undivider + * simple root piece maker + * dummy serial kernel + */ + +//==================================================================== +#define NO_INPUT NULL + /*Just to get proto-runtime built and run, to test it.. + */ +void test_app_seed_Fn( void *_params, SlaveVP *seedVP ) + { DKUInstance *dkuInstance; + DKUPiece *rootPiece; + int32 size = 1000; + int32 *data = (int32 *) PR__malloc (size * sizeof(int32)) ; + + DEBUG__printf(dbgAppFlow, "In seed Fn") + + SeedParams *seedParams = (SeedParams *)_params; //used to comm with main() + + dkuInstance = PRServ__DKU_make_empty_DKU_instance( seedVP ); + PRServ__DKU_set_root_piece_maker( dkuInstance, &rootPieceMakerFn, seedVP ); + PRServ__DKU_set_kernel( dkuInstance, &kernelFn, seedVP ); + PRServ__DKU_set_serial_kernel( dkuInstance, &serialKernelFn, seedVP ); + PRServ__DKU_set_divider( dkuInstance, ÷rFn, seedVP ); + PRServ__DKU_set_undivider( dkuInstance, &undividerFn, seedVP ); + + rootPiece = + make_root_dku_piece_for_test_inst( data, size, dkuInstance ); +// rootPiece = PRServ__DKU_make_root_piece( dkuInstance, data, seedVP ); + + PRServ__DKU_perform_work_on( rootPiece, seedVP ); + + PRServ__DKU_wait_for_result_to_be_complete( rootPiece, seedVP ); + + seedParams->data = data; //sends results back to main() + + //Tells PR to end the process, which it will do even + // if work is active, or suspended work entities are still live, or the + // process has input ports that could trigger future work. + PR__end_process_from_inside( seedVP ); + + //This ends the last live entity capable of work, in a process + // that has no external input ports.. hence, no activity can take place + // past that point.. PR detects that, and then automatically ends the + // process. + PR__end_seedVP( seedVP ); + } +