int deviceCodersGetInterface(char header, int mode, BOOL fillDeviceArgumentList) {
if (header == COMMAND_CLEAR_CODERS) {
// Same INPUT / OUTPUT
if (fillDeviceArgumentList) {
setFunctionNoArgument("clrCoders");
}
return 0;
} else if (header == COMMAND_GET_WHEEL_POSITION) {
if (mode == DEVICE_MODE_INPUT) {
if (fillDeviceArgumentList) {
setFunctionNoArgument("codersVal");
}
return 0;
} else if (mode == DEVICE_MODE_OUTPUT) {
if (fillDeviceArgumentList) {
setFunction("codersVal", 3);
setArgument(0, DEVICE_ARG_UNSIGNED_HEX_8, "left");
setArgumentSeparator(1);
setArgument(2, DEVICE_ARG_UNSIGNED_HEX_8, "right");
}
return 17;
}
} else if (header == COMMAND_DEBUG_GET_WHEEL_POSITION) {
// Same INPUT / OUTPUT
if (fillDeviceArgumentList) {
setFunctionNoArgument("dbgCodersVal");
}
return 0;
}
return DEVICE_HEADER_NOT_HANDLED;
}
/*!
* Begins execution of this kernel object's OpenCL kernel using the given OpenCL
* command queue and kernel arguments, returning the OpenCL event associated with
* the kernel execution.
*
* @param queue The OpenCL command queue this kernel is executed on.
*
* @param buffer The OpenCL memory buffer where a row is stored and will
* be transformed by this kernel execution.
*
* @param type The mathematical operation type that will be used for the transform.
*
* @param amount The amount that will be used for the mathematical transform.
*
* @return OpenCL event associated with this kernel's execution.
*/
::OpenCL::Event MathTransform::OpenCL::Kernel::execute(::OpenCL::CommandQueue* queue, ::OpenCL::Buffer<cl_float>* buffer, Operation type, int amount)
{
// Lock this kernel's underlying kernel class so arguments can be set.
Locker locker {lock()};
// Set the arguments this OpenCL kernel requires. This includes the global memory
// buffer where the row is held, the local memory buffer, the operation type,
// and the amount.
setBuffer(GlobalBuffer,buffer);
setArgument(GlobalSize,buffer->size());
setLocalMemory<cl_float>(LocalValue,1);
setArgument(Type,static_cast<int>(type));
setArgument(Amount,amount);
// Set the work sizes. The global work size is determined by the row size, but
// it must also be a multiple of the local work size, so it is rounded up
// accordingly.
int localWorkSize = 1;
int workgroupSize = (buffer->size() + localWorkSize - 1) / localWorkSize;
setSizes(0, workgroupSize * localWorkSize, localWorkSize);
// Execute this object's OpenCL kernel with the given command queue, returning its
// generated OpenCL event.
return ::OpenCL::Kernel::execute(queue);
}
label CommonPluginFunction::readArgument(
label index,
const string &content,
CommonValueExpressionDriver &driver
)
{
if(index>=argumentNames_.size()) {
FatalErrorIn("CommonPluginFunction::readArgument")
<< "Index " << index << " too big. Only values from 0 to"
<< argumentNames_.size()-1 << " possible"
<< endl
<< exit(FatalError);
}
word startSymbol=argumentTypes_[index];
if(index+1 < argumentTypes_.size()) {
startSymbol+="_SC";
} else {
startSymbol+="_CL";
}
if(debug || parentDriver_.traceParsing()) {
Info << "Using start symbol " << startSymbol << endl;
}
driver.parse(content,startSymbol);
if(driver.getResultType()!=argumentTypes_[index]) {
FatalErrorIn("CommonPluginFunction::readArgument")
<< "Result type " << driver.getResultType()
<< "differs from expected type " << argumentTypes_[index]
<< endl
<< exit(FatalError);
}
setArgument(index,content,driver);
return driver.parserLastPos();
}
int deviceTestGetInterface(char commandHeader, DeviceInterfaceMode mode, bool fillDeviceArgumentList) {
if (commandHeader == COMMAND_TEST) {
if (fillDeviceArgumentList) {
setFunction("test", 2, 1);
setArgumentUnsignedHex2(0, "a");
setArgumentUnsignedHex2(1, "b");
setResultUnsignedHex2(0, "result");
}
return commandLengthValueForMode(mode, 4, 2);
}
else if (commandHeader == COMMAND_SIMPLE_TEST) {
if (fillDeviceArgumentList) {
setFunctionNoArgumentAndNoResult("simpleTest");
}
return commandLengthValueForMode(mode, 0, 0);
}
else if (commandHeader == COMMAND_HEAVY_TEST) {
if (fillDeviceArgumentList) {
setFunction("heavyTest", 10, 1);
setArgumentUnsignedHex2(0, "a");
setArgumentUnsignedHex2(1, "b");
setArgumentUnsignedHex4(2, "c");
setArgumentUnsignedHex4(3, "d");
setArgumentUnsignedHex2(4, "e");
setArgumentSeparator(5);
setArgumentUnsignedHex2(6, "f");
setArgumentUnsignedHex4(7, "g");
setArgument(8, DEVICE_ARG_UNSIGNED_HEX_6, "h");
setArgumentUnsignedHex2(9, "i");
setResult(0, DEVICE_ARG_UNSIGNED_HEX_6, "result");
}
return commandLengthValueForMode(mode, 29, 6);
}
// Debug Test
else if (commandHeader == COMMAND_DEBUG_TEST) {
if (fillDeviceArgumentList) {
setFunctionNoArgumentAndNoResult("debugTest");
}
return commandLengthValueForMode(mode, 0, 0);
}
else if (commandHeader == COMMAND_GENERATE_NOTIFY_TEST) {
if (fillDeviceArgumentList) {
setFunction("generateNotifyTest", 1, 0);
setArgumentUnsignedHex2(0, "notifyTestValue");
}
return commandLengthValueForMode(mode, 2, 0);
}
// Handle a notification test
else if (mode == DEVICE_MODE_NOTIFY) {
if (commandHeader == NOTIFY_TEST) {
if (fillDeviceArgumentList) {
setNotification("notifyTest", 1);
setArgumentUnsignedHex2(0, "notifyArg0");
}
return 2;
}
}
return DEVICE_HEADER_NOT_HANDLED;
}
void Request::requestReceived(const QString &peerAddress, const QStringList &header, const bool &is_http10, const QString &method, const QString &argument, const QHash<QString, QString> ¶msHeader, const QString &content, HttpRange *range, const int &timeSeekRangeStart, const int &timeSeekRangeEnd)
{
if (!replyInProgress)
{
replyInProgress = true;
clock.start();
setPeerAddress(peerAddress);
setHttp10(is_http10);
setMethod(method);
setArgument(argument);
setTextContent(content);
m_params = paramsHeader;
m_range = range;
m_header = header;
this->timeSeekRangeStart = timeSeekRangeStart;
this->timeSeekRangeEnd = timeSeekRangeEnd;
emit readyToReply(method, argument, paramsHeader, isHttp10(), data(contentRole).toString(), getRange(), getTimeSeekRangeStart(), getTimeSeekRangeEnd());
if (data(argumentRole) == "description/fetch") {
// new renderer is connecting to server
emit newRenderer(data(peerAddressRole).toString(), getPort(), getParamHeader("USER-AGENT"));
}
}
else
{
qWarning() << QString("unable to read request (socket %1), a reply is in progress.").arg(socketDescriptor()).toUtf8().constData();
}
}
// Create a new stacklet to run the seed.
void
stackletFork(Seed* seed)
{
DEBUG_PRINT("Forking a stacklet.\n");
seed->joinCounter = 2;
void* stackletBuf = calloc(1, STACKLET_SIZE);
DEBUG_PRINT("\tAllocate stackletBuf %p\n", stackletBuf);
stubBase = stackletBuf + STACKLET_SIZE;
Stub* stackletStub = (Stub *)(stubBase - sizeof(Stub));
stackletStub->stackletBuf = stackletBuf;
stackletStub->seed = seed;
stackletStub->stubRoutine = stubRoutine;
setArgument(seed->argv);
void* routine = seed->routine;
restoreStackPointer(stackletStub);
goto *routine; //XXX rsp is already changed
}
/**
* @param line A script line to call a function, e.g. "calc(x=10)"
*/
ScriptLineCall::ScriptLineCall(boost::shared_ptr<Namespace> ns,
ScriptFunctionGetter& getter,
const Kernel::EParser& code):
m_namespace(ns)
{
std::string name(code.name());
m_call_function = getter.getFunction(name);
if (!m_call_function)
{
throw std::invalid_argument("Unknown function "+name+" in module ");
}
for(int i=0; i<code.size(); ++i) // looping the function arguments
{
const Kernel::EParser& arg = code[i];
if (arg.name() != "=")
{
throw std::invalid_argument("Actual function arguments must be passed as name=value");
}
std::string name = arg[0].name();
const Kernel::EParser& value = arg[1];
setArgument(name,value);
}
check();
}
int deviceMotionGetInterface(char commandHeader, DeviceInterfaceMode mode, bool fillDeviceArgumentList) {
if (commandHeader == COMMAND_MOTION_LOAD_DEFAULT_PARAMETERS) {
if (fillDeviceArgumentList) {
setFunctionNoArgumentAndNoResult("loadDefaultParameters");
}
return commandLengthValueForMode(mode, 0, 0);
}
// goto
else if (commandHeader == COMMAND_MOTION_GOTO_IN_PULSE) {
if (fillDeviceArgumentList) {
setFunction("gotoPulse", 4, 0);
setArgument(0, DEVICE_ARG_SIGNED_HEX_6, "left");
setArgument(1, DEVICE_ARG_SIGNED_HEX_6, "right");
setArgumentUnsignedHex2(2, "a");
setArgumentUnsignedHex2(3, "s");
}
return commandLengthValueForMode(mode, 16, 0);
}// forward MM
else if (commandHeader == COMMAND_MOTION_FORWARD_IN_MM) {
if (fillDeviceArgumentList) {
setFunction("forwardMM", 1, 0);
setArgumentUnsignedHex4(0, "distMM");
}
return commandLengthValueForMode(mode, 4, 0);
}// backward MM
else if (commandHeader == COMMAND_MOTION_BACKWARD_IN_MM) {
if (fillDeviceArgumentList) {
setFunction("backwardMM", 1, 0);
setArgumentUnsignedHex4(0, "distMM");
}
return commandLengthValueForMode(mode, 4, 0);
}// turn left in degree
else if (commandHeader == COMMAND_MOTION_LEFT_IN_DECI_DEGREE) {
if (fillDeviceArgumentList) {
setFunction("rotLeftDecDeg", 1, 0);
setArgumentUnsignedHex4(0, "leftAngleDecDeg");
}
return commandLengthValueForMode(mode, 4, 0);
}// turn right in degree
else if (commandHeader == COMMAND_MOTION_RIGHT_IN_DECI_DEGREE) {
if (fillDeviceArgumentList) {
setFunction("rotRightDecDeg", 1, 0);
setArgumentUnsignedHex4(0, "rightAngleDecDeg");
}
return commandLengthValueForMode(mode, 4, 0);
}// ONLY ONE WHEEL
// turn left (only right in degree
else if (commandHeader == COMMAND_MOTION_LEFT_ONE_WHEEL_IN_DECI_DEGREE) {
if (fillDeviceArgumentList) {
setFunction("rotLeft1WheelDecDeg", 1, 0);
setArgumentUnsignedHex4(0, "leftAngleDecDeg");
}
return commandLengthValueForMode(mode, 4, 0);
}// turn right (only right wheel) in degree
else if (commandHeader == COMMAND_MOTION_RIGHT_ONE_WHEEL_IN_DECI_DEGREE) {
if (fillDeviceArgumentList) {
setFunction("rotRight1WheelDecDeg", 1, 0);
setArgumentUnsignedHex4(0, "rightAngleDecDeg");
}
return commandLengthValueForMode(mode, 4, 0);
}
// motion : Cancel
else if (commandHeader == COMMAND_MOTION_CANCEL) {
// Same INPUT/OUTPUT
if (fillDeviceArgumentList) {
setFunctionNoArgumentAndNoResult("cancelMot");
}
return commandLengthValueForMode(mode, 0, 0);
}// motion : Obstacle
else if (commandHeader == COMMAND_MOTION_OBSTACLE) {
// Same INPUT/OUTPUT
if (fillDeviceArgumentList) {
setFunctionNoArgumentAndNoResult("motionObstacle");
}
return commandLengthValueForMode(mode, 0, 0);
}// Calibration
else if (commandHeader == COMMAND_SQUARE_CALIBRATION) {
if (fillDeviceArgumentList) {
setFunction("squareCalib", 3, 0);
setArgumentUnsignedHex2(0, "left/right");
setArgumentSeparator(1);
setArgumentUnsignedHex4(2, "length");
}
return commandLengthValueForMode(mode, 7, 0);
}// Parameters
else if (commandHeader == COMMAND_GET_MOTION_PARAMETERS) {
if (fillDeviceArgumentList) {
setFunction("getMotionParam", 1, 2);
setArgumentUnsignedHex2(0, "motionType");
setResultUnsignedHex2(0, "a");
setResultUnsignedHex2(1, "s");
}
return commandLengthValueForMode(mode, 2, 4);
} else if (commandHeader == COMMAND_SET_MOTION_PARAMETERS) {
if (fillDeviceArgumentList) {
setFunction("setMotionParam", 3, 0);
setArgumentUnsignedHex2(0, "motionType");
setArgumentUnsignedHex2(1, "a");
setArgumentUnsignedHex2(2, "s");
}
return commandLengthValueForMode(mode, 6, 0);
}
// MODE REPLACE / ADD
else if (commandHeader == COMMAND_MOTION_MODE_ADD) {
if(fillDeviceArgumentList) {
setFunctionNoArgumentAndNoResult("motionModeAdd");
}
return commandLengthValueForMode(mode, 0, 0);
}
else if (commandHeader == COMMAND_MOTION_MODE_REPLACE) {
if(fillDeviceArgumentList) {
setFunctionNoArgumentAndNoResult("motionModeReplace");
}
return commandLengthValueForMode(mode, 0, 0);
}
else if (commandHeader == COMMAND_MOTION_MODE_GET) {
if (fillDeviceArgumentList) {
setFunction("motionModeGet", 0, 1);
setResultUnsignedChar1(0, "value");
}
return commandLengthValueForMode(mode, 0, 1);
}
// NOTIFICATION
if (DEVICE_MODE_NOTIFY == mode) {
if (commandHeader == NOTIFY_MOTION_STATUS_REACHED) {
if (fillDeviceArgumentList) {
fillNotifyResults("notifyReached");
}
return 14;
}
else if (commandHeader == NOTIFY_MOTION_STATUS_FAILED) {
if (fillDeviceArgumentList) {
fillNotifyResults("notifyFailed");
}
return 14;
}
else if (commandHeader == NOTIFY_MOTION_STATUS_OBSTACLE) {
if (fillDeviceArgumentList) {
fillNotifyResults("notifyObstacle");
}
return 14;
}
else if (commandHeader == NOTIFY_MOTION_STATUS_MOVING) {
if (fillDeviceArgumentList) {
fillNotifyResults("notifyMoving");
}
return 14;
}
}
return DEVICE_HEADER_NOT_HANDLED;
}
int parseArgument(int argc, char *argv[]){
int strLen,strPos;
char *dataStr, *optStr;
for(int i=1;i<argc;i++){
strLen = (int)strlen(argv[i]);
//length of less than 2 character is exception. || didn't start with '-'
if(strLen<2 || argv[i][0]!='-') return 0;
else{ //option flag start.
//Support for long option name(ex: --host=example.com)
if(argv[i][1] == '-'){
//only option name of '--' is ignored.
if(strLen==2) return 0;
else{
//search of split char '=' of between option and data.(without '--')
dataStr = strchr(&argv[i][2],'=');
// found
if(dataStr!=NULL){
//Position value of '=' in string. (ex: abc=123 -> 4)
strPos = (int)(dataStr-&argv[i][2])+1;
//option name string copy.
optStr = malloc(sizeof(char)*strPos);
strncpy(optStr, &argv[i][2], strPos-1);
//data string copy.
dataStr = malloc(sizeof(char)*(strlen(&argv[i][2])-strPos+1));
strncpy(dataStr, &argv[i][2]+strPos, strlen(&argv[i][2])-strPos);
}
// no found(it means this option isn't contain data.) (==NULL)
else{
//option name string copy.
optStr = malloc(sizeof(char)*(strLen-1));
strcpy(optStr,&argv[i][2]);
//data string set to default.
dataStr = malloc(sizeof(char));
*dataStr = '1';
}
}
}
//one length option name.
else{
//Has a spacer between option name and data.
if(strLen==2){
optStr = malloc(sizeof(char)*strLen);
strcpy(optStr,&argv[i][1]);
//next data none.
if(!(i+1 < argc)){
//data string set to default.
dataStr = malloc(sizeof(char));
*dataStr = '1';
}
else{
//next data none. new option starting.
if(argv[i+1][0]=='-'){
//data string set to default.
dataStr = malloc(sizeof(char));
*dataStr = '1';
}
else{
//data string set to default.
dataStr = malloc(sizeof(char) * (strlen(argv[++i])+1));
strcpy(dataStr,argv[i]);
}
}
}
//No spacer between option name and data.
else{
optStr = malloc(sizeof(char)*2);
strncpy(optStr,&argv[i][1],1);
//data string set to default.
dataStr = malloc(sizeof(char)*strlen(&argv[i][1]));
strcpy(dataStr,&argv[i][1]+1);
}
}
}
//set options.
setArgument(optStr,dataStr); //opt 설정.
//freeing memory.
free(dataStr);
free(optStr);
}
return 1;
}
//------------------------------------------------------------------------------
void Kernel::setArgument(unsigned int index, const Buffer& buffer) {
cl_mem rawBuffer = buffer.getId();
setArgument(index, sizeof(cl_mem), &rawBuffer);
}
void runFJob() {
int w, h[NJOBS], n;
float x1, y1[NJOBS], x2, y2[NJOBS];
float diff = ((1.0*jobHeight) / HEIGHT) * 0.01;
x1 = 0.40; //left
y1[0] = 0.20; //up
for (int i = 1; i < NJOBS; i++)
y1[i] = y1[i-1]+diff;//0.20828125;
x2 = 0.41; //right
y2[0] = 0.20 + diff;//down
for (int i = 1; i < NJOBS; i++)
y2[i] = y2[i-1]+diff;
w = WIDTH; // -
for (int i = 0; i < NJOBS; i++)
h[i] = jobHeight;//- +
n = MAXITER;// +
init_rgb();
printf ("x1=%f y1=%f x2=%f y2=%f w=%d h=%d n=%d file=%s\n",
x1, y1[0], x2, y2[1], w, h[0], n, "file.ppm");
nGlobItems[0] = 512;
nGlobItems[1] = jobHeight < 512 ? jobHeight : 512;
int nGlobItemsProfile[2] = {512,512};
nItemsGroup[0] = 8;
nItemsGroup[1] = (jobHeight % 8) == 0 ? 8 : (jobHeight % 4 == 0) ? 4 : (jobHeight % 2 == 0) ? 2 : 1;
int nItemsGroupGPU[2];
nItemsGroupGPU[0] = nItemsGroupGPU[1] = groupSize;
//jobs for initial profiling
/* float y1Prof=0.20, y2Prof=0.21;
int wProf =1024, hProf =1024, nProf = 1048576;
for (int i = 0; i < nPUs ; i++) {
Job *job = createJob();
setJobID(job, -1-i);
setAllowPU(job, CL_DEVICE_TYPE_CPU);
if (GPUs)
setAllowPU(job, CL_DEVICE_TYPE_GPU);
setJobCategory(job, 1);
loadSourceFile(job, "mandel.cl");
setStartingKernel(job, "calc_tile");
setArgument(job, INPUT, 1 * sizeof(float), &x1);
setArgument(job, INPUT, 1 * sizeof(float), &y2Prof);
setArgument(job, INPUT, 1 * sizeof(float), &x2);
setArgument(job, INPUT, 1 * sizeof(float), &y1Prof);
setArgument(job, INPUT, 1 * sizeof(int), &wProf);
setArgument(job, INPUT, 1 * sizeof(int), &hProf);
setArgument(job, INPUT, 1 * sizeof(int), &nProf);
setArgument(job, OUTPUT, wProf*hProf * sizeof(int), NULL);
setDimensions(job, 2, nGlobItemsProfile, nItemsGroup);
setResultCollector(job, defaultRCID);
requestResultNotification(job);
if (i == 0) {
sleep(50);
// printf("Type something to send the first PROFILING job.\n");
// char asd[100];
// scanf("%s",asd);
}
sendJobToExec(job, defaultSchedID);
}
printf("JM (%i): Sent all PROFILING jobs.\n", myid);
//jobs for actual work
*/sleep(50);
for (int i = 0; i < NJOBS; i++) {
job[i] = createJob();
setJobID(job[i], i);
setAllowPU(job[i], CL_DEVICE_TYPE_CPU);
if (GPUs)
setAllowPU(job[i], CL_DEVICE_TYPE_GPU);
setJobCategory(job[i], 1);
loadSourceFile(job[i], "mandel.cl");
setStartingKernel(job[i], "calc_tile");
setArgument(job[i], INPUT, 1 * sizeof(float), &x1);
setArgument(job[i], INPUT, 1 * sizeof(float), &(y2[(NJOBS-1)-i]));
setArgument(job[i], INPUT, 1 * sizeof(float), &x2);
setArgument(job[i], INPUT, 1 * sizeof(float), &(y1[(NJOBS-1)-i]));
setArgument(job[i], INPUT, 1 * sizeof(int), &w);
setArgument(job[i], INPUT, 1 * sizeof(int), &(h[i]));
setArgument(job[i], INPUT, 1 * sizeof(int), &n);
setArgument(job[i], OUTPUT, w*(h[i]) * sizeof(int), NULL);
setDimensions(job[i], 2, nGlobItems, nItemsGroup);
setResultCollector(job[i], defaultRCID);
requestResultNotification(job[i]);
}
pthread_mutex_lock(&end_mutex);
// while(profilesReceived != nPUs)
// pthread_cond_wait(&profile_over, &end_mutex);
pthread_mutex_unlock(&end_mutex);
//char asd[100];
sleep(7);
printf("\n\n\n#####PROFILING OVER#####\n");// Type something to send the first (real) job.\n");
// scanf("%s",asd);
sleep(2);
if (gettimeofday(&start, NULL)) {
perror("gettimeofday");
exit (EXIT_FAILURE);
}
// printf("JM: Sending now!\n");
for (int i = 0; i < NJOBS; i++)
sendJobToExec(job[i], defaultSchedID);
}
label CommonPluginFunction::readArgument(
label index,
const string &content,
const word &type
) {
if(debug || parentDriver_.traceParsing()) {
Info << "CommonPluginFunction::readArgument "
<< index << " " << type << " : " << content << endl;
}
if(index>=argumentNames_.size()) {
FatalErrorIn("CommonPluginFunction::readArgument")
<< "Index " << index << " too big. Only values from 0 to"
<< argumentNames_.size()-1 << " possible"
<< endl
<< exit(FatalError);
}
label consumed=0;
string tc="";
{
bool atStart=true;
forAll(content,i){
if(isspace(content[i]) && atStart) {
consumed++;
} else {
atStart=false;
tc+=content[i];
}
}
if(debug || parentDriver_.traceParsing()) {
Info << "Removed leading spaces: " << tc << endl;
}
}
if(type=="word") {
tc.replace(",",";");
if(debug || parentDriver_.traceParsing()) {
Info << "Replacing , with ; :" << tc << endl;
}
}
IStringStreamWithPos is(tc);
if(type=="word") {
word value;
is.read(value);
if(debug || parentDriver_.traceParsing()) {
Info << "Read word: " << value
<< "(stream pos: " << label(is.pos()) << ")" << endl;
}
setArgument(index,value);
} else if(type=="string") {
string value;
is.read(value);
if(debug || parentDriver_.traceParsing()) {
Info << "Read string: " << value
<< "(stream pos: " << label(is.pos()) << ")" << endl;
}
setArgument(index,value);
} else if(type=="scalar") {
scalar value;
is.read(value);
if(debug || parentDriver_.traceParsing()) {
Info << "Read scalar: " << value
<< "(stream pos: " << label(is.pos()) << ")" << endl;
}
setArgument(index,value);
} else if(type=="bool") {
bool value(readBool(is));
if(debug || parentDriver_.traceParsing()) {
Info << "Read bool: " << value
<< "(stream pos: " << label(is.pos()) << ")" << endl;
}
setArgument(index,value);
} else if(type=="label") {
label value;
is.read(value);
if(debug || parentDriver_.traceParsing()) {
Info << "Read label: " << value
<< "(stream pos: " << label(is.pos()) << ")" << endl;
}
setArgument(index,value);
} else if(type=="vector") {
vector value;
is >> value;
if(debug || parentDriver_.traceParsing()) {
Info << "Read vector: " << value
<< "(stream pos: " << label(is.pos()) << ")" << endl;
}
setArgument(index,value);
} else {
void Kernel::setArgument(uint32_t index, MemoryBuffer& memoryBuffer) {
cl_mem id = memoryBuffer.id();
setArgument(index, sizeof(cl_mem), &id);
}
