호스트 프로그램의 구조

int main()

{

cl_platform_id*

cl_device_type

cl_device_id

cl_context

cl_command_queue

cl_program

cl_kernel

cl_mem

cl_int err;

cl_uint num_platforms;

cl_uint num_dev=0;

// 플랫폼 ID 얻기 (Device 확인, 정보 가져오기)

cl_int clGetPlatformIDs(      cl_uint num_entries,              (플랫폼 수)

cl_platform_id *platforms,   (플랫폼 정보를 담을 구조체 리스트)
cl_uint *num_platforms)     (플랫폼 갯수를 담을 변수)

// 플랫폼 정보 언기

cl_int clGetPlatformInfo(     cl_platform_id platform,              (플랫폼 ID)
                                          cl_platform_info param_name,    (해당 플랫폼에서 얻을 정보)
                                          size_t param_value_size,              (버퍼의 크기)
                                          void *param_value,                      (저장할 버퍼)
                                          size_t *param_value_size_ret)      (실제 반환 될 크기)

// 디바이스ID 얻기

 cl_int clGetDeviceIDs (       cl_platform_id  platform ,        (플랫폼 ID)

                                          cl_device_type  device_type ,    (얻을 정보 종류)
                                          cl_uint  num_entries ,              (디바이스 갯수)
                                          cl_device_id  *devices ,            (저장할 디바이스 구조체)
                                          cl_uint  *num_devices )           (반환 될 디바이스 갯수)GetDeviceIDs이고,

// 디바이스 정보 얻기

 cl_int clGetDeviceInfo (     cl_device_id  device ,                    (디바이스 ID)
                                         cl_device_info  param_name ,      (얻을 정보)
                                         size_t  param_value_size ,            (버퍼 크기)
                                         void  *param_value ,                   (버퍼)
                                         size_t  *param_value_size_ret )   (반환되는 버퍼의 크기)

// 컨텍스트 생성

cl_context clCreateContext(       const cl_context_properties *properties,        (플랫폼의 구성정보)
                                                 cl_uint num_devices,                                    (생성 할 디바이스 수)
                                                 const cl_device_id *devices,                          (디바이스 ID)
                                                (void CL_CALLBACK  *pfn_notify)                 (콜백함수)

( const char *errinfo,
  const void *private_info, size_t cb,
  void *user_data
),

     void *user_data,                                      (콜백함수에 넘길 유저데이터)
     cl_int *errcode_ret)                                  (에러 반환)

------------------------------------------ Runtime APIs ----------------------------------------------------

//디바이스에 연결할 커맨드 큐 생성

cl_command_queue clCreateCommandQueue(       cl_context context,                      
                                                                              cl_device_id device,
                                                                              cl_command_queue_properties properties,
                                                                              cl_int *errcode_ret)

// 프로그램 생성

 cl_program clCreateProgramWithSource (        cl_context context,        (컨택스트)
                                                                         cl_uint count,              (갯수)
                                                                         const char **strings,   (소스 문자열)
                                                                         const size_t *lengths,  (소스 크기)
                                                                         cl_int *errcode_ret)     (에러 형태)

// 프로그램 빌드

 cl_int clBuildProgram (        cl_program program,                                    (프로그램 ID)
                                           cl_uint num_devices,                                     (장치 갯수)
                                           const cl_device_id *device_list,                      (컴파일 할 장치)
                                           const char *options,                                     (빌드 옵션)
                                           void (CL_CALLBACK *pfn_notify)                  (콜백 함수)

(cl_program program, void *user_data), 

 void *user_data)                                           (콜백함수의 사용자 데이터)

// 커널생성

 cl_kernel clCreateKernel (      cl_program  program,           
                                             const char *kernel_name,   
                                             cl_int *errcode_ret)             

// 버퍼 생성

 cl_mem clCreateBuffer (        cl_context context,        (컨텍스트)
                                              cl_mem_flags flags,       (옵션)
                                              size_t size,                     (크기)
                                              void *host_ptr,              (호스트 주소)
                                              cl_int *errcode_ret)       (에러)

// 압력버퍼쓰기

 cl_int clEnqueueWriteBuffer (   cl_command_queue command_queue,
                                                 cl_mem buffer,
                                                 cl_bool blocking_write,
                                                 size_t offset,
                                                 size_t size,
                                                 const void *ptr,
                                                 cl_uint num_events_in_wait_list,
                                                 const cl_event *event_wait_list,
                                                 cl_event *event)

// 커널 파라미터 설정(바인딩)

 cl_int clSetKernelArg (    cl_kernel kernel,            (연결할 커널)
                                       cl_uint arg_index,         (인덱스)
                                       size_t arg_size,             (인자 크기)
                                       const void *arg_value) (인자 값)

// 커널 실행

 cl_int clEnqueueNDRangeKernel (  cl_command_queue command_queue,
                                                      cl_kernel kernel,
                                                      cl_uint work_dim,
                                                      const size_t *global_work_offset,
                                                      const size_t *global_work_size,
                                                      const size_t *local_work_size,
                                                      cl_uint num_events_in_wait_list,
                                                      const cl_event *event_wait_list,
                                                      cl_event *event)

// 출력 버퍼 읽기

 cl_int clEnqueueReadBuffer (    cl_command_queue command_queue,
                                                 cl_mem buffer,
                                                 cl_bool blocking_read,
                                                 size_t offset,
                                                 size_t size,
                                                 void *ptr,
                                                 cl_uint num_events_in_wait_list,
                                                 const cl_event *event_wait_list,
                                                 cl_event *event)

// 자원 해제

clRelease();

return 0;

}