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); }