First, we need to define the CnC graph:
// Declarations // The tag values are the odd numbers in the range [3..n] <string oddNums>; // The prime numbers as identified by the compute step [string->int primes]; // Step execution // The compute step may produce a prime number (in the form of a tag instance) (compute) -> [primes]; // Step prescription // For each oddNums instance, there is <oddNums> :: (python compute); // Input from the environment: initialize all tags env -> <oddNums>; // Output to the environment is the collection of the prime numbers [primes] -> env;
The CnC graph states that oddNums
is a Tag Collection with strings as the tags.
Currently, strings are the only supported tag types in CnC-Python.
Next, we define the Item Collection primes
which has strings as tags and integer as its values. These types are defined in the format tagType->itemType
before the name of the Item Collection.
We define the implementation language of the Step in the Step prescription as in (python compute)
. In CnC-Python, python is the only allowable value. In future releases we plan to expan this value to include other languages such as C, C++, Fortran, Matlab, etc.
env
is a special keyword representing the environment and in this example we define the environment will put string tags into the oddNums
Tag Collection and read the results from the primes
Item Collection.
After defining the CnC graph, we need to run this file using the CnC-Python translator using the following command:
cnc_t FindPrimes.cnc
Running the command will generate the following directories: hj-cnc-api
, sidl
, java-client
, py-lib
, user-code
, and hj-main
. In short, these are what the directories represent:
Directory Name |
Function |
---|---|
|
Wrapper classes for the HJ-CnC runtime used by Babel while generating SIDL server/client code |
|
SIDL files used by the program. This includes the SIDL file for the runtime wrapper classes as well as the Step and Item Collections for the current program |
|
The java client generated from the SIDL files used by the HJ program to call into the python implementation |
|
The generated python files that are invoked from the HJ program |
|
This is the only directory the user should need to edit. It will contain template files for the python Steps as well as an application class to attach start and end event handlers. The even handlers are used to place values from the environment into Item Collections and read results back from Item Collections. |
|
The generated HJ files that manages code to make native invocations into the python implementations using the Babel runtime. The user launches the CnC-Python program using a generated script that invokes the generated HJ main class. |
Back to the example, once the translator completes running there should be the following files in the user-code
directory:
class Application: @staticmethod def onStart(args, oddNums): # TODO fill out the body of the function # e.g. operation on output item collections: anItemCollection.put(aTag, aValue) # e.g. operation on tag collections: aTagCollection.putTag(aTag) pass @staticmethod def onEnd(primes): # TODO fill out the body of the function # e.g. operation on input item collections: anItemCollection.get(aTag) # e.g. operation on input item collections: anItemCollection.printContents() pass
and
class ComputeStep: @staticmethod def createAwaitsList(tupleContainer, tag ): # TODO fill out the body of the function # e.g. tupleContainer.add(itemCollection, tagValue) # e.g. operation on item collections: anItemCollection.get(aTag) pass @staticmethod def compute(tag , outPrimes): # TODO fill out the body of the function # e.g. operation on input item collections: anItemCollection.get(aTag) # e.g. operation on output item collections: anItemCollection.put(aTag, aValue) # e.g. operation on tag collections: aTagCollection.putTag(aTag) return True
Rename both files to userFindPrimesApp.py
and userComputeStep.py
. The userFindPrimesApp.py
provides the onStart
and onEnd
functions. The function signatures are determined by detecting the environment interactions in the CnC graph. The onStart
function also provides access to any command line arguments used while launching the program. The userComputeStep.py
file provides the file the user needs to edit to provide the Step implementation. A Step needs to implement the createAwaitsList
and compute
functions. The createAwaitsList
function allows the user to specify the input data dependences on Item Collections. Once these dependences have been satisfied the compute
function will be invoked.
Below are simple implementations for the two python files:
import time class Application: startTime = 0 endTime = 0 @staticmethod def onStart(args, oddNums): # e.g. operation on output item collections: anItemCollection.put(aTag, aValue) # e.g. operation on tag collections: aTagCollection.putTag(aTag) if len(args) > 0: firstArg = args[0] print("py: processing " + firstArg) intValue = int(firstArg) Application.startTime = time.clock() for i in xrange(3, intValue, 2): oddNums.putTag(str(i)) else: print("py: usage FindPrimesMain <num_items>") @staticmethod def onEnd(primes): # e.g. operation on input item collections: anItemCollection.get(aTag) # e.g. operation on input item collections: anItemCollection.printContents() Application.endTime = time.clock() elapsedTime = int((Application.endTime - Application.startTime) * 1000) print "py: Elapsed time:", elapsedTime, "ms" primes.printContents()
and
class ComputeStep: @staticmethod def createAwaitsList(tupleContainer, tag ): # e.g. tupleContainer.add(itemCollection, tagValue) # e.g. operation on item collections: anItemCollection.get(aTag) # no dependencies, do nothing pass @staticmethod def compute(tag , outPrimes): # e.g. operation on input item collections: anItemCollection.get(aTag) # e.g. operation on output item collections: anItemCollection.put(aTag, aValue) # e.g. operation on tag collections: aTagCollection.putTag(aTag) candidate = int(tag) if ComputeStep.isPrime(candidate): outPrimes.put(str(candidate), candidate) return True @staticmethod def isPrime(n): for k in xrange(3, n, 2): if n % k == 0: return False return True
Please refer to the Partition-String example to see an example of how to implement the createAwaitsList
function.