What is Kernel Mapper

Kernel Mapper

The Kernel Mapper generates a python source code which calls Open CL kernel code. To generate a python code, Users should create a kernel definition file, a JSON file. With the python code, users can just create the object and call the function it exposed which are the kernel functions. It's pretty simple and easy to use.

Kernel Definition File

The kernel definition file contains two parts:

struct type definitions (optional)

As we known, it is possible to use struct in Open CL. This part defines the structs which are used at kernel functions, see next part. At generating phase, Kernel Mapper generates the struct header for your, like:

#ifndef __PRICE_DATA_H__
#define __PRICE_DATA_H__

typedef struct {
  long dataIndex;
  float open;
  float high;
  float low;
  float close;
} PriceData;

#endif

All structs definition will be at a single header file, kernel_structs.h. You can just include this header file to have all structs.

At python source code, you may see the code like this:

        self.PriceData = numpy.dtype([('dataIndex', numpy.int), \
                                      ('open', numpy.float32), \
                                      ('high', numpy.float32), \
                                      ('low', numpy.float32), \
                                      ('close', numpy.float32)])

All structs will be defined as member variables in a single class.

As we mentioned before, this part is optional. If you only use primitive type, like byte, short, int, float, long, double, you don't need to write this part.

definition structure

TODO

example

{
  "name": "PriceData",
  "fields": [
    { "name": "dataIndex", "type": "long" },
    { "name": "open", "type": "float" },
    { "name": "high", "type": "float" },
    { "name": "low", "type": "float" },
    { "name": "close", "type": "float" }
  ]
}

This JSON object defines the PriceData we just mentioned in previous section. It uses primitive types as its fields.

kernel function definitions

This parts defines the functions we want to implement in Open CL. We can use the primitive types or struct types which are defined at previous part as the function arguments. After the generation, Kernel Mapper generates the function declaration for you, like:

#include "kernel_structs.h"
__kernel void test_donothing(const int range,
                             const int realSize,
                             __global PriceData* inBuffer,
                             __global PriceData* outBuffer) {

}

At python source code, you may see the code like:

def test_donothing(self, range, realSize, inBuffer, outBuffer):
  ...

def prepareOutBuffer(self, size):
  ...

The prepareOutBuffer function creates a numpy array with PriceData as its type and size as its length. Before calling test_donothing, user should call prepareOutBuffer to obtain a buffer for test_donothing.

definition structure

TODO

example

{
  "name": "test_donothing",
  "arguments": [
    { "name": "range", "type": "int", "memoryType": "constant" },
    { "name": "realSize", "type": "int", "memoryType": "constant" },
    { "name": "inBuffer", "type": { "arrayType": "PriceData" }, "memoryType": "global" },
    { "name": "outBuffer", "type": { "arrayType": "PriceData" }, "memoryType": "global" }
  ]
}

This JSON object defines the test_donothing we just mentioned in previous section. It uses two constant variables and two PriceData arrays as its arguments.