source: CIVL/examples/translation/openclversion2.15/arrKernels.cvl@ 0e052af2

  /*
  cl_kernel kernel;
  kernel = clCreateKernel(arguments, "nothing");
  
  ((args*)kernel.arguments)->param[0] = (int*)malloc(sizeof(int));
  memcpy(((args*)kernel.arguments)->param[0], &star, sizeof(int));
  
  ((args*)kernel.arguments)->param[1] = one;
  
  clReleaseKernel(kernel);
  
  printf("single kernel works\n");
  */


#include "cl.cvl"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <civlc.h>

int numArgs = 2;
int numKernels = 3;

typedef struct
{
  void * param[numArgs];
  int mallocflag[numArgs];
}args;

cl_kernel clCreateKernel(args * argument, char * function)
{
  cl_kernel kernel;
  kernel.arguments = argument;
  kernel.method = function;
  
  for(int j = 0; j < numArgs; j++)
  {
    ((args*)kernel.arguments)->mallocflag[j] = 0;
  }
  
  return kernel;
}

void clReleaseKernel(cl_kernel kernel)
{
  for (int i = 0; i < numArgs; i++)
  {
    printf("I am argument %d with value %d\n", i, ((args*)kernel.arguments)->mallocflag[i]);
    if (((args*)kernel.arguments)->mallocflag[i] == 1)
    {
      printf("and I pass the flag check\n");
      free(((args*)kernel.arguments)->param[i]);
    }
  }
}

int main(int argc, char** argv)
{
  args * arguments;
  arguments = (args*)malloc(sizeof(args) * numKernels);
  
  
  int star = 1;
  
  int * one = (int*)malloc(sizeof(int));
  memcpy(one, &star, sizeof(int));

  //cl_kernel *kernels = (cl_kernel*)malloc(numKernels * sizeof(cl_kernel));
  cl_kernel kernels[numKernels];
  
  printf("%d, %d\n", star, *one);

  for (int i = 0; i < numKernels; i++)
  {
    kernels[i] = clCreateKernel(arguments+i, "eh");
    

  }
  for (int j = 0; j < numKernels; j++)
  {
    //printf("starts here\n");
    ((args*)kernels[j].arguments)->param[0] = (int*)malloc(sizeof(int));
    ((args*)kernels[j].arguments)->mallocflag[0] = 1;
    //printf("malloc works\n");
    memcpy(((args*)kernels[j].arguments)->param[0], &star, sizeof(int));
    
    //printf("I am kernel of index %d, with a value of %d\n", j, ((args*)kernels[j].arguments)->param[0]);
    
    //((args*)kernels[j].arguments)->param[1] = one;
    
    

  }
  
  //printf("assigned properly\n");
  
  for (int k = 0; k < numKernels; k++)
  {
    clReleaseKernel(kernels[k]);
  }
  
  for (int k = 0; k < numKernels; k++)
  {
    //free(((args*)kernels[k].arguments)->param[0]);
  }
  
  
  free(one);
  free(arguments);
  return 0;
}