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