opencl — управление основным файлом c ++

Я получил 2 файла cpp .. 1 из них с основной функцией .. другой с дополнительной функцией

void Mysecondary Function in file02.cpp()
{
task 01;
tasl 02;
task 03;
...
task 10;
}

---

void main Function in file01.cpp()
{
Mysecondary Function();
}

-эти задачи зависят друг от друга (поэтому я не могу разбить их во многих функциях и вызывать каждую в одиночку)

-я хочу вызывать основную функцию … делать, например, первые 4 задачи … затем (УДЕРЖАТЬ) и делать некоторые вещи в моей главной функции … затем (ПРОДОЛЖИТЬ) другие задачи

-заметки:
эти задачи — что-то вроде инициализации данных … установки данных … после выполнения этих данных … (и я не могу поместить их в заголовок в качестве переменных для их хранения …)

так это как (один вызов) для вторичной функции … так что я не делаю (многие инициализации)

заключение:
если я позвоню что-то вроде:

void main(){

function 1();
function 2();
function 3();
}

что происходит, когда программа завершает функцию 1, она запускает функцию 2 … и так далее

что я хочу это:

void main(){

function 1(do some tasks and HOLD);
function 2();
function 1(do rest tasks(like looping on data and copying data));
function 3();
at the end ..function 1(free);
}

редактировать: извините за неясность

основная проблема — ошибка компиляции (1 библиотека создает плагин (это основная библиотека)
и он не принимает заголовок другой библиотеки (библиотеки вычислений) из-за проблем с окнами)

так что я сделал это:

main file.cpp
#include main plugin library
#include inbetween header (that header got the other library functions)inbetween.h
#ifndef SECONDARY_H
#define SECONDARY_H

class secondary function()
{
global:
some stuff
}secondary.cpp

#include my calculation library(which do conflict if i include it in the header or the    other cpp file)
#include inbetween.h

definition of secondary function stuff

эти функции выполняют (инициализируют) вызовы gpu с помощью opencl …
после (инициализация) … мне нужно (выполнить) … проблема в том, что я не могу вызвать функцию инициализации 2 раза (будет глупо: D)

редактировать 2: это функция .cpp файл

#include <stdio.h>
#include <stdcl.h>
#include "CLFunction.h"#include "CLHeaderCall.h"
char kernel_source[] =
"__kernel void matvecmult_kern( ""   uint n, ""   __global float* aa, ""   __global float* b,  ""   __global float* c "") ""{ ""   int i = get_global_id(0); ""   int j;""   float tmp = 0.0f;""   for(j=0;j<n;j++) tmp += aa[i*n+j] * b[j];""   c[i] = tmp;""}";int CLFunction::Initializer()
{
if(!xxx){
stdcl_init(); // this is only necessary for Windows
}

n = 64;
cp = (stdgpu)? stdgpu : stdcpu;
devnum = 0;
clh = clsopen(cp,kernel_source,CLLD_NOW);
clopen(cp,0,CLLD_NOW);
krn = clsym(cp,clh,"matvecmult_kern",0);

printf("Initializer done\n");
return 1;
}int CLFunction::CLSetData()
{
/* allocate OpenCL device-sharable memory */
aa = (float*)clmalloc(cp,n*n*sizeof(cl_float),0);
b = (float*)clmalloc(cp,n*sizeof(cl_float),0);
c = (float*)clmalloc(cp,n*sizeof(cl_float),0);

clndrange_t ndr = clndrange_init1d( 0, n, 32);
NDR = &ndr;
/* initialize vectors a[] and b[], zero c[] */

for(i=0;i<n;i++) for(j=0;j<n;j++) aa[i*n+j] = 1.1f*i*j;
for(i=0;i<n;i++) b[i] = 2.2f*i;
for(i=0;i<n;i++) c[i] = 0.0f;/* define the computational domain and workgroup size */
//clndrange_t ndr = clndrange_init1d( 0, n, 64);

/* non-blocking sync vectors a and b to device memory (copy to GPU)*/
clmsync(cp,devnum,aa,CL_MEM_DEVICE|CL_EVENT_NOWAIT);
clmsync(cp,devnum,b,CL_MEM_DEVICE|CL_EVENT_NOWAIT);

printf("SetData Done");
return 1;
}int CLFunction::MyClFunction()
{
/* set the kernel arguments */
clarg_set(cp,krn,0,n);
clarg_set_global(cp,krn,1,aa);
clarg_set_global(cp,krn,2,b);
clarg_set_global(cp,krn,3,c);

/* non-blocking fork of the OpenCL kernel to execute on the GPU */
clfork(cp,devnum,krn,NDR,CL_EVENT_NOWAIT);

/* non-blocking sync vector c to host memory (copy back to host) */
clmsync(cp,0,c,CL_MEM_HOST|CL_EVENT_NOWAIT);

/* force execution of operations in command queue (non-blocking call) */
clflush(cp,devnum,0);

/* block on completion of operations in command queue */
clwait(cp,devnum,CL_ALL_EVENT);for(i=0;i<n;i++)
{
printf("%d %f %f\n",i,b[i],c[i]);
H = b[i];
//H[i] = b[i];
}
return 1;
}

void CLFunction::FreeCL()
{
clfree(aa);
clfree(b);
clfree(c);

clclose(cp,clh);
}

//int CLFunction::AllInOne()
//{
//  if(!xxx){
//      stdcl_init(); // this is only necessary for Windows
//  }
//
//
//   cl_uint n = 64;
//  /* use default contexts, if no GPU use CPU */
//   //CLCONTEXT* cp = (stdgpu)? stdgpu : stdcpu;
//#if(1)
//   unsigned int devnum = 0;
//
//   clopen(stdgpu,0,CLLD_NOW);
//
//
//   void* clh = clsopen(stdgpu,kernel_source,CLLD_NOW);
//   cl_kernel krn = clsym(stdgpu,clh,"matvecmult_kern",0);
//
//   /* allocate OpenCL device-sharable memory */
//   aa = (float*)clmalloc(stdgpu,n*n*sizeof(cl_float),0);
//   cl_float* b = (float*)clmalloc(stdgpu,n*sizeof(cl_float),0);
//   cl_float* c = (float*)clmalloc(stdgpu,n*sizeof(cl_float),0);
//
//   clndrange_t ndr = clndrange_init1d( 0, n, 32);
//
//   /* initialize vectors a[] and b[], zero c[] */
//   int i,j;
//   for(i=0;i<n;i++) for(j=0;j<n;j++) aa[i*n+j] = 1.1f*i*j;
//   for(i=0;i<n;i++) b[i] = 2.2f*i;
//   for(i=0;i<n;i++) c[i] = 0.0f;
//
//   /* define the computational domain and workgroup size */
//   //clndrange_t ndr = clndrange_init1d( 0, n, 64);
//
//   /* non-blocking sync vectors a and b to device memory (copy to GPU)*/
//   clmsync(stdgpu,devnum,aa,CL_MEM_DEVICE|CL_EVENT_NOWAIT);
//   clmsync(stdgpu,devnum,b,CL_MEM_DEVICE|CL_EVENT_NOWAIT);
//
//   /* set the kernel arguments */
//   clarg_set(stdgpu,krn,0,n);
//   clarg_set_global(stdgpu,krn,1,aa);
//   clarg_set_global(stdgpu,krn,2,b);
//   clarg_set_global(stdgpu,krn,3,c);
//
//   /* non-blocking fork of the OpenCL kernel to execute on the GPU */
//   clfork(stdgpu,devnum,krn,&ndr,CL_EVENT_NOWAIT);
//
//   /* non-blocking sync vector c to host memory (copy back to host) */
//   clmsync(stdgpu,0,c,CL_MEM_HOST|CL_EVENT_NOWAIT);
//
//   /* force execution of operations in command queue (non-blocking call) */
//   clflush(stdgpu,devnum,0);
//
//   /* block on completion of operations in command queue */
//   clwait(stdgpu,devnum,CL_ALL_EVENT);
//
//   for(i=0;i<n;i++) printf("%d %f %f\n",i,b[i],c[i]);
//
//   clfree(aa);
//   clfree(b);
//   clfree(c);
//
//   clclose(stdgpu,clh);
//#endif
//   return 1;
//}

и заголовок

#ifndef CLHEADERCALL_H
#define CLHEADERCALL_H
#endif

#include <stdio.h>
#include <stdcl.h>

cl_float* aa;
cl_float* b;
cl_float* c;

cl_uint n;
CLCONTEXT* cp;
unsigned int devnum;
void* clh;
cl_kernel krn;
clndrange_t* NDR;

int i,j;

другой заголовок

#ifndef CLFUNCTION_H
#define CLFUNCTION_H
#endif

class CLFunction
{
public:

CLFunction(const bool xxxxx = 0) :
xxx(xxxxx)
{
}
bool xxx;
int Initializer();
int CLSetData();
int MyClFunction();
void FreeCL();

//int AllInOne();

//int MMM();
float H;
//int i,j;

};