void WebCLKernel::setArg(unsigned index, const ScriptValue& value, ExceptionState& es) { v8::Isolate* isolate = value.isolate(); v8::Handle<v8::Value> object(value.v8Value()); if (V8WebCLMemoryObject::hasInstance(object, isolate)) { WebCLMemoryObject* memoryObject; memoryObject = V8WebCLMemoryObject::toImplWithTypeCheck(isolate, object); setArg(index, memoryObject, es); return; } if (V8WebCLSampler::hasInstance(object, isolate)) { WebCLSampler* sampler; sampler = V8WebCLSampler::toImplWithTypeCheck(isolate, object); setArg(index, sampler, es); return; } if (V8ArrayBufferView::hasInstance(object, isolate)) { DOMArrayBufferView* arrayBufferView; arrayBufferView = object->IsArrayBufferView() ? V8ArrayBufferView::toImpl(v8::Handle<v8::ArrayBufferView>::Cast(object)) : 0; setArg(index, arrayBufferView, es); return; } es.throwWebCLException(WebCLException::INVALID_ARG_VALUE, WebCLException::invalidArgValueMessage); }
void * reduce_phase2(const void * _exp) { if(isA(_exp, Integer())) return domainCast(_exp, Real()); else if(isA(_exp, Real()) || isA(_exp, Var())) return copy(_exp); else if(isA(_exp, Sum()) || isA(_exp, Product())) { void * s = copy(_exp); size_t i; for(i = 0; i < size(s); ++i) { delete(argv(s, i)); setArgv(s, i, reduce_phase2(argv(_exp, i))); } return s; } else if(isA(_exp, Pow())) { void * p = copy(_exp); delete(base(p)); delete(power(p)); setBase(p, reduce_phase2(base(_exp))); setPower(p, reduce_phase2(power(_exp))); return p; } else if(isOf(_exp, Apply_1())) { void * f = copy(_exp); delete(arg(f)); setArg(f, reduce_phase2(arg(_exp))); return f; } assert(0); }
void LLUIString::setArgs(const LLSD& sd) { if (!sd.isMap()) return; for(LLSD::map_const_iterator sd_it = sd.beginMap(); sd_it != sd.endMap(); ++sd_it) { setArg(sd_it->first, sd_it->second.asString()); } format(); }
cl_int clSetKernelArg(cl_kernel d_kernel, cl_uint arg_indx, size_t arg_size, const void * arg_value) { auto kernel = pobj(d_kernel); if (!kernel->isA(Coal::Object::T_Kernel)) return CL_INVALID_KERNEL; return kernel->setArg(arg_indx, arg_size, arg_value); }
void LLUIString::setArgs(const LLSD& sd) { LLFastTimer timer(FTM_UI_STRING); if (!sd.isMap()) return; for(LLSD::map_const_iterator sd_it = sd.beginMap(); sd_it != sd.endMap(); ++sd_it) { setArg(sd_it->first, sd_it->second.asString()); } dirty(); }
arg* getArg(char* buffer,int nbArg,int c,int sock){ int i,j,taille,estNegatif; char* nbArgTmp; estNegatif=1; arg* tabArg=malloc(nbArg*sizeof(arg)); for(i=0;i <nbArg;i++){ if(buffer[++c]==1 || buffer[c]==3){//l'argument est un entier tabArg[i].type=buffer[c]; if(buffer[c]==3){ estNegatif=-1; } else{ estNegatif=1; } taille=buffer[++c]; nbArgTmp=malloc(taille*(sizeof(char))+1); for(j=0;j<taille;j++){ nbArgTmp[j]=buffer[++c]; printf("arg numero%d %c \n",i,nbArgTmp[j]); } nbArgTmp[j]='\0'; printf("argument est %d et sa taille est %d et son string %s\n",atoi(nbArgTmp),taille,nbArgTmp); tabArg[i].arg=setArg(atoi(nbArgTmp)*estNegatif); free(nbArgTmp); } else if (buffer[c]==2){//l'argument est un char* tabArg[i].type=2; taille=buffer[++c]; nbArgTmp=malloc((taille+1)*(sizeof(char))); for(j=0;j<taille;j++){ nbArgTmp[j]=buffer[++c]; } nbArgTmp[j]='\0'; tabArg[i].arg=setArg2(nbArgTmp); free(nbArgTmp); } else{ perror("type d'argument innatendu"); printf("\n%d\n",buffer[c]); char a= MAUVAIS_ARGUMENTS; write(sock,&a,1); close(sock); return NULL; } } printf("fini le traitement ici\n"); return tabArg; }
bool OpenCLKernel::setArg(int argNumber, msa::OpenCLMemoryObject& memObject){ // tig: if the buffer has a corresponding gl object, we need to flag it, // so that it can be bound and then unbound upon run(). if ( !clKernel ) return false; // ----------| invariant: we have a valid kernel. // if this object has an openGL representation it needs to be flagged as blocked // whenever openCL runs on it. // we'll do this automatically in run(), but we first have to register all objects // that have such dependencies. if (memObject.hasCorrespondingGLObject){ // make sure we haven't stored this object before. if (find(mOpenGLInteropArguments.begin(),mOpenGLInteropArguments.end(), memObject.clMemObject) == mOpenGLInteropArguments.end()){ mOpenGLInteropArguments.push_back(memObject.clMemObject); } } bool result = setArg(argNumber, &memObject.clMemObject, sizeof(&memObject.clMemObject)); return result; }
int main(int argc, char* argv[]) { try { cl::Context context(DEVICE); cl::Program program(context, util::loadProgram("add.cl"), /* build= */ true); cl::CommandQueue queue(context); // create host and device data int sum=0; auto bufferSum = cl::Buffer(context, CL_MEM_READ_WRITE, 1 * sizeof(int)); // copy host-to-device queue.enqueueWriteBuffer(bufferSum, /* blocking= */ CL_TRUE, /* offset= */ 0, /* size= */ 1 * sizeof(int), &sum); auto kernel=cl::Kernel(program, "AtomicSum"); // bind device buffer to first argument in kernel invocation kernel.setArg(0,bufferSum); // run the kernel //queue.enqueueNDRangeKernel(kernel, cl::NullRange, cl::NDRange(range), cl::NullRange); queue.enqueueNDRangeKernel(kernel, cl::NullRange, cl::NDRange(range)); queue.finish(); // copy device-to-host queue.enqueueReadBuffer(bufferSum, /* blocking= */ CL_TRUE, /* offset= */ 0, /* size= */ 1 * sizeof(int), &sum); std::cout << "Sum: " << sum << " (should be " << range << ")" << std::endl; } catch (cl::Error err) { std::cout << "Exception\n"; std::cerr << "ERROR: " << err.what() << std::endl; } return 0; }
str OPTvolcanoImplementation(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci) { int i, limit; int mvcvar = -1; int count=0; InstrPtr p,q, *old = mb->stmt; char buf[256]; lng usec = GDKusec(); str msg = MAL_SUCCEED; (void) pci; (void) cntxt; (void) stk; /* to fool compilers */ if ( mb->inlineProp ) return MAL_SUCCEED; limit= mb->stop; if ( newMalBlkStmt(mb, mb->ssize + 20) < 0) throw(MAL,"optimizer.volcano", SQLSTATE(HY001) MAL_MALLOC_FAIL); for (i = 0; i < limit; i++) { p = old[i]; pushInstruction(mb,p); if( getModuleId(p) == sqlRef && getFunctionId(p)== mvcRef ){ mvcvar = getArg(p,0); continue; } if( count < MAXdelays && getModuleId(p) == algebraRef ){ if( getFunctionId(p) == selectRef || getFunctionId(p) == thetaselectRef || getFunctionId(p) == likeselectRef || getFunctionId(p) == joinRef ){ q= newInstruction(0,languageRef,blockRef); setDestVar(q, newTmpVariable(mb,TYPE_any)); q = pushArgument(mb,q,mvcvar); q = pushArgument(mb,q,getArg(p,0)); mvcvar= getArg(q,0); pushInstruction(mb,q); count++; } continue; } if( count < MAXdelays && getModuleId(p) == groupRef ){ if( getFunctionId(p) == subgroupdoneRef || getFunctionId(p) == groupdoneRef ){ q= newInstruction(0,languageRef,blockRef); setDestVar(q, newTmpVariable(mb,TYPE_any)); q = pushArgument(mb,q,mvcvar); q = pushArgument(mb,q,getArg(p,0)); mvcvar= getArg(q,0); pushInstruction(mb,q); count++; } } if( getModuleId(p) == sqlRef){ if ( getFunctionId(p) == bindRef || getFunctionId(p) == bindidxRef || getFunctionId(p)== tidRef || getFunctionId(p)== appendRef || getFunctionId(p)== updateRef || getFunctionId(p)== deleteRef ){ setArg(p,p->retc,mvcvar); } } } GDKfree(old); /* Defense line against incorrect plans */ if( count){ chkTypes(cntxt->usermodule, mb, FALSE); chkFlow(mb); chkDeclarations(mb); } /* keep all actions taken as a post block comment */ usec = GDKusec()- usec; snprintf(buf,256,"%-20s actions=%2d time=" LLFMT " usec","volcano",count,usec); newComment(mb,buf); if( count >= 0) addtoMalBlkHistory(mb); return msg; }
cl_int Kernel::setArg(cl_uint index, const inviwo::BufferCLGL& value) { return setArg(index, value.get()); }
void GLTextureStage::setOp(OpType alpha, TextureOp op) { if(mStage != 0) { glActiveTexture(GL_TEXTURE0 + mStage); } bool wasEnabled = isEnabled(); ops[alpha] = op; bool enabled = isEnabled(); if(wasEnabled != enabled) { if(enabled) { glEnable(GL_TEXTURE_2D); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE); renderer->maxTextureStage = std::max<size_t>(mStage, renderer->maxTextureStage); } else { glDisable(GL_TEXTURE_2D); if(renderer->maxTextureStage == mStage) { renderer->maxTextureStage = 0; for(int stage = mStage - 1; stage >= 0; stage--) { if(renderer->GetTextureStage(stage)->isEnabled()) { renderer->maxTextureStage = stage; break; } } } } } CHECK_GL; switch(op) { case OpDisable: { setOp(alpha, GL_REPLACE, 1); setArg(alpha, Arg0, ArgCurrent); CHECK_GL; break; } case OpSelectArg1: { setOp(alpha, GL_REPLACE, 1); setArg(alpha, Arg0, args[alpha][Arg0]); CHECK_GL; break; } case OpSelectArg2: { setOp(alpha, GL_REPLACE, 1); setArg(alpha, Arg0, args[alpha][Arg1]); CHECK_GL; break; } case OpModulate: { setOp(alpha, GL_MODULATE, 1); setArg(alpha, Arg0, args[alpha][Arg0]); setArg(alpha, Arg1, args[alpha][Arg1]); CHECK_GL; break; } case OpModulate2X: { setOp(alpha, GL_MODULATE, 2); setArg(alpha, Arg0, args[alpha][Arg0]); setArg(alpha, Arg1, args[alpha][Arg1]); CHECK_GL; break; } case OpModulate4X: { setOp(alpha, GL_MODULATE, 4); setArg(alpha, Arg0, args[alpha][Arg0]); setArg(alpha, Arg1, args[alpha][Arg1]); CHECK_GL; break; } case OpAddSigned: { setOp(alpha, GL_ADD_SIGNED, 1); setArg(alpha, Arg0, args[alpha][Arg0]); setArg(alpha, Arg1, args[alpha][Arg1]); CHECK_GL; break; } } if(mStage != 0) { glActiveTexture(GL_TEXTURE0); } }
void GLTextureStage::setOp(OpType alpha, TextureOp op) { if(mStage != 0) { glActiveTexture(GL_TEXTURE0 + mStage); } bool wasEnabled = isEnabled(); ops[alpha] = op; bool enabled = isEnabled(); if(wasEnabled != enabled) { if(enabled) { glEnable(GL_TEXTURE_2D); setTexEnv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE); renderer->maxTextureStage = std::max<size_t>(mStage, renderer->maxTextureStage); } else { glDisable(GL_TEXTURE_2D); if(renderer->maxTextureStage == mStage) { renderer->maxTextureStage = 0; for(int stage = mStage - 1; stage >= 0; stage--) { if(renderer->GetTextureStage(stage)->isEnabled()) { renderer->maxTextureStage = stage; break; } } } } } switch(op) { case OpDisable: { setOp(alpha, GL_REPLACE, 1); setArg(alpha, GL_PREVIOUS); break; } case OpSelectArg1: { setOp(alpha, GL_REPLACE, 1); setArg(alpha, GL_TEXTURE); break; } case OpModulate: { setOp(alpha, GL_MODULATE, 1); setArg(alpha, GL_TEXTURE); break; } case OpModulate2X: { setOp(alpha, GL_MODULATE, 2); setArg(alpha, GL_TEXTURE); break; } case OpModulate4X: { setOp(alpha, GL_MODULATE, 4); setArg(alpha, GL_TEXTURE); break; } } if(mStage != 0) { glActiveTexture(GL_TEXTURE0); } }
cryptoHolder_t * clparser(int argc, char ** argv){ cryptoHolder_t * ans; if((ans = calloc(sizeof(cryptoHolder_t), 1)) == NULL) return NULL; parserADT parser = newParser(argc, argv); char * aOpt[4] = {"aes128", "aes192", "aes256", "des"}; char * mOpt[4] = {"ecb", "cfb", "ofb", "cbc"}; setArg(parser, 1, "-in", 0, 1, ARG_TYPE1, 0, NULL); setArg(parser, 2, "-out", 0, 1, ARG_TYPE1, 0, NULL); setArg(parser, 3, "-e", 0, 1, ARG_TYPE0, 0, NULL); setArg(parser, 4, "-d", 0, 1, ARG_TYPE0, 0, NULL); setArg(parser, 5, "-pass", 0, 1, ARG_TYPE1, 0, NULL); setArg(parser, 6, "-K", 0, 1, ARG_TYPE1, 0, NULL); setArg(parser, 7, "-iv", 0, 1, ARG_TYPE1, 0, NULL); setArg(parser, 8, "-a", 0, 1, ARG_TYPE1, 4, aOpt); setArg(parser, 9, "-m", 0, 1, ARG_TYPE1, 4, mOpt); setArg(parser, 10, "-h", 0, 1, ARG_TYPE0, 0, NULL); //help encryption_t encriptation = newEncryptation(); int error = 0; keyIv_t keyIv = {NULL, NULL}; passOrKey_t passOrKey = -1; while(!noMoreArgs(parser) && !error){ switch (getArg(parser)) { case 1: LOG("reading source file\n"); printf("Source file: %s\n", getValue(parser)); if(ans->sourceFile != NULL){ WARN("sourceFile already set\n"); error = 1; break; } if((ans->sourceFile = malloc(sizeof(char) * (strlen(getValue(parser)) + 1))) == NULL) { ERROR("mem alloc failed\n"); error = 1; break; } strcpy(ans->sourceFile, getValue(parser)); LOG("finish reading source file\n"); break; case 2: LOG("reading target file\n"); printf("Target file: %s\n", getValue(parser)); if(ans->targetFile != NULL){ WARN("targetFile already set\n"); error = 1; break; } if((ans->targetFile = malloc(sizeof(char) * (strlen(getValue(parser)) + 1))) == NULL) { ERROR("mem alloc failed\n"); error = 1; break; } strcpy(ans->targetFile, getValue(parser)); LOG("finish reading target file\n"); break; case 3: printf("Encription\n"); if(isSetCryptoEncryptOrDecrypt(encriptation)) error = 1; else setCryptoEncryptOrDecrypt(&encriptation, encrypOrDecrypt_encrypt); break; case 4: printf("Desencription\n"); if(isSetCryptoEncryptOrDecrypt(encriptation)) error = 1; else setCryptoEncryptOrDecrypt(&encriptation, encrypOrDecrypt_decrypt); break; case 5: printf("Pass: %s\n", getValue(parser)); if(isSetCryptoPassKeyIv(encriptation) || isSetCryptoPassOrKey(encriptation)){ error = 1; break; } // create the pass and set the encriptation passKeyIv_t passKeyIv; if((passKeyIv.password = malloc(sizeof(char) * (strlen(getValue(parser)) + 1))) == NULL){ ERROR("memory alloc failed\n"); error = 1; break; } passOrKey = passOrKey_pass; setCryptoPassOrKey(&encriptation, passOrKey); strcpy((char*)passKeyIv.password, getValue(parser)); setCryptoPassKeyIv(&encriptation, passKeyIv); break; case 6: printf("Key: %s\n", getValue(parser)); if(keyIv.key != NULL){ error = 1; break; } if((keyIv.key = malloc(sizeof(char) * strlen(getValue(parser)) + 1)) == NULL){ error = 1; break; } strcpy((char*)keyIv.key, getValue(parser)); if(keyIv.iv != NULL){ passKeyIv_t passKeyIv; passKeyIv.keyIv = keyIv; setCryptoPassKeyIv(&encriptation, passKeyIv); } passOrKey = passOrKey_key; setCryptoPassOrKey(&encriptation, passOrKey); break; case 7: printf("IV: %s\n", getValue(parser)); if(keyIv.iv != NULL){ error = 1; break; } if((keyIv.iv = malloc(sizeof(char) * strlen(getValue(parser)) + 1)) == NULL){ error = 1; break; } strcpy((char*)keyIv.iv, getValue(parser)); if(keyIv.key != NULL){ passKeyIv_t passKeyIv; passKeyIv.keyIv = keyIv; setCryptoPassKeyIv(&encriptation, passKeyIv); } break; passOrKey = passOrKey_key; setCryptoPassOrKey(&encriptation, passOrKey); case 8: printf("Encription algorithm: %s\n", getValue(parser)); if(isSetCryptoAlgorithm(encriptation)) error = 1; else{ algorithm_t alg; if(strcmp(getValue(parser), "aes128") == 0) alg = algorithm_aes128; else if(strcmp(getValue(parser), "aes192") == 0) alg = algorithm_aes192; else if(strcmp(getValue(parser), "aes256") == 0) alg = algorithm_aes256; else if(strcmp(getValue(parser), "des") == 0) alg = algorithm_des; else{ error = 1; break; } setCryptoAlgorithm(&encriptation, alg); } break; case 9: printf("Block method: %s\n", getValue(parser)); if(isSetCryptoCiphermode(encriptation)) error = 1; else{ ciphermode_t cipher; if(strcmp(getValue(parser), "ecb") == 0) { LOG("ciphermode is ecb\n"); cipher = ciphermode_ecb; } else if(strcmp(getValue(parser), "cfb") == 0) { cipher = ciphermode_cfb; LOG("ciphermode is cfb\n"); }else if(strcmp(getValue(parser), "ofb") == 0) { cipher = ciphermode_ofb; LOG("ciphermode is ofb\n"); }else if(strcmp(getValue(parser), "cbc") == 0) { cipher = ciphermode_cbc; LOG("ciphermode is cbc\n"); }else{ error = 1; break; } setCryptoCiphermode(&encriptation, cipher); } break; case 10: showHelp(); return NULL; break; default: error = 1; break; } } if(error){ printf("ERROR: Argument not understood %s\n", getValue(parser)); return NULL; } freeParser(parser); ans->encription = encriptation; return ans; }
configuration_t *clparser(int argc, char ** argv) { configuration_t *conf; char *aOpt[] = {"aes128", "aes192", "aes256", "des"}; char *mOpt[] = {"ecb", "cfb", "ofb", "cbc"}; char *stegOpt[] = {"LSB1", "LSB4", "LSBE", "WANTED"}; if((conf = calloc(sizeof(configuration_t),1)) == NULL){ return NULL; } parserADT parser = newParser(argc, argv); setArg(parser, arg_in, "-in", 0, 1, ARG_TYPE1, 0, NULL); setArg(parser, arg_out, "-out", 0, 1, ARG_TYPE1, 0, NULL); setArg(parser, arg_porter, "-p", 0, 1, ARG_TYPE1, 0, NULL); setArg(parser, arg_embed, "-embed", 1, 1, ARG_TYPE0, 0, NULL); setArg(parser, arg_extract, "-extract", 1, 1, ARG_TYPE0, 0, NULL); setArg(parser, arg_pass, "-pass", 1, 1, ARG_TYPE1, 0, NULL); setArg(parser, arg_algorithm, "-a", 1, 1, ARG_TYPE1, SIZE_OF_ARRAY(aOpt), aOpt); setArg(parser, arg_ciphermode, "-m", 1, 1, ARG_TYPE1, SIZE_OF_ARRAY(mOpt) , mOpt); setArg(parser, arg_steg, "-steg", 1, 1, ARG_TYPE1, SIZE_OF_ARRAY(stegOpt), stegOpt); setArg(parser, arg_help, "-h", 1, 1, ARG_TYPE0, 0, NULL); //help int error = 0; while(!noMoreArgs(parser) && !error){ switch(getArg(parser)){ case arg_out: error = !processArg(&conf->targetFile, getValue(parser), "target file"); break; case arg_in: error = !processArg(&conf->sourceFile, getValue(parser), "source file"); break; case arg_porter: error = !processArg(&conf->carrierFile, getValue(parser), "carrier file"); break; case arg_embed: if(conf->embed == steg_notSet){ LOG("embed/extract is embed\n"); conf->embed = steg_embed; if(conf->encriptation != NULL) { conf->encriptation->encrypOrDecrypt = encrypOrDecrypt_encrypt; } } else { printf("embed/extract already set\n"); error = 1; } break; case arg_extract: if(conf->embed == steg_notSet){ LOG("embed/extract is extract\n"); conf->embed = steg_extract; if(conf->encriptation != NULL) { conf->encriptation->encrypOrDecrypt = encrypOrDecrypt_decrypt; } } else { printf("embed/extract already set\n"); error = 1; } break; case arg_pass: if(!initEncrypt(conf)){ error = 1; } else { error = !processArg((char**)&conf->encriptation->passKeyIv.password, getValue(parser), "password"); } break; case arg_algorithm: if(!initEncrypt(conf)){ error = 1; } else { algorithm_t alg = getCryptoAlgorithm(getValue(parser)); if(alg != algorithm_none){ setCryptoAlgorithm(conf->encriptation, alg); } else { printf("encryptation algorithm not reconized: %s\n", getValue(parser)); error = 1; } } break; case arg_ciphermode: if(!initEncrypt(conf)){ error = 1; } else { ciphermode_t cipherm = getCipherMode(getValue(parser)); if(cipherm != ciphermode_none){ setCryptoCiphermode(conf->encriptation, cipherm); } else { printf("ciphermode not reconized: %s\n", getValue(parser)); error = 1; } } break; case arg_steg: if(conf->stegMode != stegMode_none){ printf("steg already set\n"); error = 1; } else { stegMode_t mode = getStegMode(getValue(parser)); if(mode == stegMode_none){ printf("steg mode not reconized: %s\n", getValue(parser)); error = 1; } else { conf->stegMode = mode; } } break; case arg_help: showHelp(); return NULL; break; default: error = 1; break; } } return conf; }
//------------------------------------------------------- coResult simtKernel_cl::setArg (coUint _argIndex, simtBuffer* _val) { simtBuffer_cl* clBuffer = static_cast<simtBuffer_cl*>( _val ); cl_mem mem = clBuffer ? clBuffer->getMem_cl() : nullptr; return setArg(_argIndex, &mem, sizeof(cl_mem)); }
//------------------------------------------------------- coResult simtKernel_cl::setArg (coUint _argIndex, simtImage* _val) { simtImage_cl* clImage = static_cast<simtImage_cl*>( _val ); cl_mem mem = clImage ? clImage->getMem_cl() : nullptr; return setArg(_argIndex, &mem, sizeof(cl_mem)); }
int Thread::start(void* arg) { setArg(arg); int code = pthread_create(&threadId,0,Thread::EntryPoint,this); return code; }
cl_int Kernel::setArg(cl_uint index, const inviwo::ImageCL& value) { return setArg(index, value.getLayerCL()->get()); }
void cluster_t::init_opencl(){ if(run_gpu){ // initialize the GPU if necessary #ifdef USE_GPU debug_opencl = false; proxmap_t::init_opencl(); cerr<<"Initializing OpenCL for cluster sub class\n"; cerr<<"P is "<<p<<", Workgroup width is "<<variable_blocks<<endl; // CREATE KERNELS createKernel("init_U",kernel_init_U); createKernel("update_U",kernel_update_U); createKernel("update_map_distance",kernel_update_map_distance); createKernel("init_v_project_coeff",kernel_init_v_project_coeff); createKernel("store_U_project",kernel_store_U_project); createKernel("store_U_project_prev",kernel_store_U_project_prev); createKernel("iterate_projection",kernel_iterate_projection); createKernel("evaluate_obj",kernel_evaluate_obj); createKernel("get_U_norm_diff",kernel_get_U_norm_diff); cerr<<"Kernels created\n"; // CREATE BUFFERS createBuffer<float>(CL_MEM_READ_WRITE,n*p,"buffer_U",buffer_U); createBuffer<float>(CL_MEM_READ_WRITE,n*p,"buffer_U_prev",buffer_U_prev); createBuffer<float>(CL_MEM_READ_WRITE,n*p,"buffer_U_project",buffer_U_project); createBuffer<float>(CL_MEM_READ_WRITE,n*p,"buffer_U_project_orig",buffer_U_project_orig); createBuffer<float>(CL_MEM_READ_WRITE,n*p,"buffer_U_project_prev",buffer_U_project_prev); createBuffer<float>(CL_MEM_READ_WRITE,triangle_dim,"buffer_V_project_coeff",buffer_V_project_coeff); createBuffer<float>(CL_MEM_READ_ONLY,n*p,"buffer_rawdata",buffer_rawdata); createBuffer<float>(CL_MEM_READ_ONLY,triangle_dim,"buffer_weights",buffer_weights); createBuffer<int>(CL_MEM_READ_ONLY,n,"buffer_offsets",buffer_offsets); createBuffer<float>(CL_MEM_READ_WRITE,variable_blocks,"buffer_variable_block_norms1",buffer_variable_block_norms1); createBuffer<float>(CL_MEM_READ_WRITE,variable_blocks,"buffer_variable_block_norms2",buffer_variable_block_norms2); createBuffer<float>(CL_MEM_READ_WRITE,n*variable_blocks,"buffer_subject_variable_block_norms",buffer_subject_variable_block_norms); createBuffer<float>(CL_MEM_READ_ONLY,1,"buffer_unweighted_lambda",buffer_unweighted_lambda); createBuffer<float>(CL_MEM_READ_ONLY,1,"buffer_dist_func",buffer_dist_func); createBuffer<float>(CL_MEM_READ_ONLY,1,"buffer_rho",buffer_rho); createBuffer<float>(CL_MEM_READ_WRITE,n,"buffer_n_norms",buffer_n_norms); createBuffer<float>(CL_MEM_READ_WRITE,triangle_dim,"buffer_n2_norms",buffer_n2_norms); ////createBuffer<>(CL_MEM_READ_ONLY,,"buffer_",buffer_); cerr<<"GPU Buffers created\n"; // initialize anything here writeToBuffer(buffer_U,n*p,U,"buffer_U"); writeToBuffer(buffer_U_prev,n*p,U_prev,"buffer_U_prev"); writeToBuffer(buffer_U_project,n*p,U_project,"buffer_U_project"); writeToBuffer(buffer_U_project_orig,n*p,U_project_orig,"buffer_U_project_orig"); writeToBuffer(buffer_rawdata,n*p,rawdata,"buffer_rawdata"); writeToBuffer(buffer_offsets,n,offsets,"buffer_offsets"); cerr<<"GPU Buffers initialized\n"; // SET KERNEL ARGUMENTS HERE int arg; //int kernelWorkGroupSize; arg = 0; setArg(kernel_update_U,arg,p,"kernel_update_U"); setArg(kernel_update_U,arg,*buffer_dist_func,"kernel_update_U"); setArg(kernel_update_U,arg,*buffer_rho,"kernel_update_U"); setArg(kernel_update_U,arg,*buffer_U,"kernel_update_U"); setArg(kernel_update_U,arg,*buffer_U_prev,"kernel_update_U"); setArg(kernel_update_U,arg,*buffer_rawdata,"kernel_update_U"); setArg(kernel_update_U,arg,*buffer_U_project,"kernel_update_U"); arg = 0; setArg(kernel_init_U,arg,p,"kernel_init_U"); setArg(kernel_init_U,arg,*buffer_rawdata,"kernel_init_U"); setArg(kernel_init_U,arg,*buffer_U,"kernel_init_U"); setArg(kernel_init_U,arg,*buffer_U_project,"kernel_init_U"); setArg(kernel_init_U,arg,*buffer_U_project_orig,"kernel_init_U"); arg = 0; setArg(kernel_update_map_distance,arg,n,"kernel_update_map_distance"); setArg(kernel_update_map_distance,arg,p,"kernel_update_map_distance"); setArg(kernel_update_map_distance,arg,*buffer_U,"kernel_update_map_distance"); setArg(kernel_update_map_distance,arg,*buffer_U_project,"kernel_update_map_distance"); setArg(kernel_update_map_distance,arg,*buffer_variable_block_norms1,"kernel_update_map_distance"); setArg(kernel_update_map_distance,arg,*buffer_variable_block_norms2,"kernel_update_map_distance"); setArg(kernel_update_map_distance,arg,cl::__local(sizeof(float)*BLOCK_WIDTH),"kernel_update_map_distance"); setArg(kernel_update_map_distance,arg,cl::__local(sizeof(float)*BLOCK_WIDTH),"kernel_update_map_distance"); arg = 0; setArg(kernel_init_v_project_coeff,arg,n,"kernel_init_v_project_coeff"); setArg(kernel_init_v_project_coeff,arg,p,"kernel_init_v_project_coeff"); setArg(kernel_init_v_project_coeff,arg,variable_blocks,"kernel_init_v_project_coeff"); setArg(kernel_init_v_project_coeff,arg,*buffer_unweighted_lambda,"kernel_init_v_project_coeff"); setArg(kernel_init_v_project_coeff,arg,*buffer_weights,"kernel_init_v_project_coeff"); setArg(kernel_init_v_project_coeff,arg,*buffer_U_project_orig,"kernel_init_v_project_coeff"); setArg(kernel_init_v_project_coeff,arg,*buffer_V_project_coeff,"kernel_init_v_project_coeff"); setArg(kernel_init_v_project_coeff,arg,*buffer_offsets,"kernel_init_v_project_coeff"); setArg(kernel_init_v_project_coeff,arg,cl::__local(sizeof(float)*BLOCK_WIDTH),"kernel_init_v_project_coeff"); arg = 0; setArg(kernel_store_U_project,arg,p,"kernel_store_U_project"); setArg(kernel_store_U_project,arg,*buffer_U,"kernel_store_U_project"); setArg(kernel_store_U_project,arg,*buffer_U_project,"kernel_store_U_project"); setArg(kernel_store_U_project,arg,*buffer_U_project_orig,"kernel_store_U_project"); arg = 0; setArg(kernel_store_U_project_prev,arg,p,"kernel_store_U_project_prev"); setArg(kernel_store_U_project_prev,arg,*buffer_U_project,"kernel_store_U_project_prev"); setArg(kernel_store_U_project_prev,arg,*buffer_U_project_prev,"kernel_store_U_project_prev"); arg = 0; setArg(kernel_iterate_projection,arg,n,"kernel_iterate_projection"); setArg(kernel_iterate_projection,arg,p,"kernel_iterate_projection"); setArg(kernel_iterate_projection,arg,variable_blocks,"kernel_iterate_projection"); setArg(kernel_iterate_projection,arg,*buffer_U,"kernel_iterate_projection"); setArg(kernel_iterate_projection,arg,*buffer_U_project,"kernel_iterate_projection"); setArg(kernel_iterate_projection,arg,*buffer_U_project_orig,"kernel_iterate_projection"); setArg(kernel_iterate_projection,arg,*buffer_U_project_prev,"kernel_iterate_projection"); setArg(kernel_iterate_projection,arg,*buffer_offsets,"kernel_iterate_projection"); setArg(kernel_iterate_projection,arg,*buffer_weights,"kernel_iterate_projection"); setArg(kernel_iterate_projection,arg,*buffer_V_project_coeff,"kernel_iterate_projection"); setArg(kernel_iterate_projection,arg,*buffer_subject_variable_block_norms,"kernel_iterate_projection"); setArg(kernel_iterate_projection,arg,cl::__local(sizeof(float)*BLOCK_WIDTH),"kernel_iterate_projection"); setArg(kernel_iterate_projection,arg,cl::__local(sizeof(float)*BLOCK_WIDTH),"kernel_iterate_projection"); setArg(kernel_iterate_projection,arg,cl::__local(sizeof(float)*BLOCK_WIDTH),"kernel_iterate_projection"); setArg(kernel_iterate_projection,arg,cl::__local(sizeof(float)*BLOCK_WIDTH),"kernel_iterate_projection"); arg = 0; setArg(kernel_evaluate_obj,arg,n,"kernel_evaluate_obj"); setArg(kernel_evaluate_obj,arg,p,"kernel_evaluate_obj"); setArg(kernel_evaluate_obj,arg,variable_blocks,"kernel_evaluate_obj"); setArg(kernel_evaluate_obj,arg,*buffer_offsets,"kernel_evaluate_obj"); setArg(kernel_evaluate_obj,arg,*buffer_rawdata,"kernel_evaluate_obj"); setArg(kernel_evaluate_obj,arg,*buffer_U,"kernel_evaluate_obj"); setArg(kernel_evaluate_obj,arg,*buffer_U_prev,"kernel_evaluate_obj"); setArg(kernel_evaluate_obj,arg,*buffer_U_project,"kernel_evaluate_obj"); setArg(kernel_evaluate_obj,arg,*buffer_weights,"kernel_evaluate_obj"); setArg(kernel_evaluate_obj,arg,*buffer_V_project_coeff,"kernel_evaluate_obj"); setArg(kernel_evaluate_obj,arg,*buffer_n_norms,"kernel_evaluate_obj"); setArg(kernel_evaluate_obj,arg,*buffer_n2_norms,"kernel_evaluate_obj"); setArg(kernel_evaluate_obj,arg,cl::__local(sizeof(float)*BLOCK_WIDTH),"kernel_evaluate_obj"); setArg(kernel_evaluate_obj,arg,cl::__local(sizeof(float)*BLOCK_WIDTH),"kernel_evaluate_obj"); arg = 0; setArg(kernel_get_U_norm_diff,arg,n,"kernel_get_U_norm_diff"); setArg(kernel_get_U_norm_diff,arg,p,"kernel_get_U_norm_diff"); setArg(kernel_get_U_norm_diff,arg,variable_blocks,"kernel_get_U_norm_diff"); setArg(kernel_get_U_norm_diff,arg,*buffer_U,"kernel_get_U_norm_diff"); setArg(kernel_get_U_norm_diff,arg,*buffer_U_prev,"kernel_get_U_norm_diff"); setArg(kernel_get_U_norm_diff,arg,*buffer_n_norms,"kernel_get_U_norm_diff"); setArg(kernel_get_U_norm_diff,arg,cl::__local(sizeof(float)*BLOCK_WIDTH),"kernel_get_U_norm_diff"); //setArg(kernel_reduce_weights2,arg,g_people,"kernel_reduce_weights2"); //kernelWorkGroupSize = kernel_reduce_weights2->getWorkGroupInfo<CL_KERNEL_WORK_GROUP_SIZE>(devices[0], &err); //clSafe(err,"get workgroup size kernel reduce_weights2"); //cerr<<"reduce_weights2 kernel work group size is "<<kernelWorkGroupSize<<endl; cerr<<"GPU kernel arguments assigned.\n"; #endif } }