1 /* 2 * cl_context.h - CL context 3 * 4 * Copyright (c) 2015 Intel Corporation 5 * 6 * Licensed under the Apache License, Version 2.0 (the "License"); 7 * you may not use this file except in compliance with the License. 8 * You may obtain a copy of the License at 9 * 10 * http://www.apache.org/licenses/LICENSE-2.0 11 * 12 * Unless required by applicable law or agreed to in writing, software 13 * distributed under the License is distributed on an "AS IS" BASIS, 14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 15 * See the License for the specific language governing permissions and 16 * limitations under the License. 17 * 18 * Author: Wind Yuan <feng.yuan (at) intel.com> 19 */ 20 21 #ifndef XCAM_CL_CONTEXT_H 22 #define XCAM_CL_CONTEXT_H 23 24 #include <xcam_std.h> 25 #include <map> 26 #include <list> 27 #include <CL/cl.h> 28 #include <ocl/cl_event.h> 29 30 namespace XCam { 31 32 class CLKernel; 33 class CLDevice; 34 class CLCommandQueue; 35 36 class CLVaBuffer; 37 class CLVaImage; 38 class CLIntelContext; 39 40 /* default context: 41 * SmartPtr<CLContext> context = CLDevice::instance()->get_context(); 42 */ 43 44 class CLContext { 45 //typedef std::map<std::string, SmartPtr<CLKernel>> CLKernelMap; 46 typedef std::list<SmartPtr<CLCommandQueue>> CLCmdQueueList; 47 48 friend class CLDevice; 49 friend class CLKernel; 50 friend class CLMemory; 51 friend class CLBuffer; 52 friend class CLSubBuffer; 53 friend class CLImage; 54 friend class CLImage2D; 55 friend class CLImage2DArray; 56 57 friend class CLVaBuffer; 58 friend class CLVaImage; 59 friend class CLIntelContext; 60 61 public: 62 enum KernelBuildType { 63 KERNEL_BUILD_BINARY = 0, 64 KERNEL_BUILD_SOURCE, 65 }; 66 67 virtual ~CLContext (); 68 cl_context get_context_id () { 69 return _context_id; 70 } 71 72 XCamReturn flush (); 73 XCamReturn finish (); 74 75 void terminate (); 76 77 private: 78 static void context_pfn_notify ( 79 const char* erro_info, const void *private_info, 80 size_t cb, void *user_data); 81 static void program_pfn_notify ( 82 cl_program program, void *user_data); 83 84 explicit CLContext (SmartPtr<CLDevice> &device); 85 SmartPtr<CLCommandQueue> create_cmd_queue (SmartPtr<CLContext> &self); 86 cl_kernel generate_kernel_id ( 87 CLKernel *kernel, 88 const uint8_t *source, 89 size_t length, 90 KernelBuildType type, 91 uint8_t **gen_binary, 92 size_t *binary_size, 93 const char *build_option); 94 void destroy_kernel_id (cl_kernel &kernel_id); 95 XCamReturn execute_kernel ( 96 const SmartPtr<CLKernel> kernel, 97 const SmartPtr<CLCommandQueue> queue, 98 CLEventList &events_wait = CLEvent::EmptyList, 99 SmartPtr<CLEvent> &event_out = CLEvent::NullEvent); 100 101 XCamReturn set_event_callback ( 102 SmartPtr<CLEvent> &event, cl_int status, 103 void (*callback) (cl_event, cl_int, void*), 104 void *user_data); 105 //bool insert_kernel (SmartPtr<CLKernel> &kernel); 106 107 bool init_context (); 108 void destroy_context (); 109 bool is_valid () const { 110 return (_context_id != NULL); 111 } 112 113 bool init_cmd_queue (SmartPtr<CLContext> &self); 114 SmartPtr<CLCommandQueue> get_default_cmd_queue (); 115 116 //Memory, Image 117 cl_mem create_image ( 118 cl_mem_flags flags, const cl_image_format& format, 119 const cl_image_desc &image_info, void *host_ptr = NULL); 120 void destroy_mem (cl_mem mem_id); 121 122 // Buffer 123 cl_mem create_buffer (uint32_t size, cl_mem_flags flags, void *host_ptr); 124 125 cl_mem create_sub_buffer ( 126 cl_mem main_mem, 127 cl_buffer_region region, 128 cl_mem_flags flags = CL_MEM_READ_WRITE); 129 130 XCamReturn enqueue_read_buffer ( 131 cl_mem buf_id, void *ptr, 132 uint32_t offset, uint32_t size, 133 bool block = true, 134 CLEventList &events_wait = CLEvent::EmptyList, 135 SmartPtr<CLEvent> &event_out = CLEvent::NullEvent); 136 137 XCamReturn enqueue_write_buffer ( 138 cl_mem buf_id, void *ptr, 139 uint32_t offset, uint32_t size, 140 bool block = true, 141 CLEventList &events_wait = CLEvent::EmptyList, 142 SmartPtr<CLEvent> &event_out = CLEvent::NullEvent); 143 144 XCamReturn enqueue_map_buffer ( 145 cl_mem buf_id, void *&ptr, 146 uint32_t offset, uint32_t size, 147 bool block = true, 148 cl_map_flags map_flags = CL_MAP_READ | CL_MAP_WRITE, 149 CLEventList &events_wait = CLEvent::EmptyList, 150 SmartPtr<CLEvent> &event_out = CLEvent::NullEvent); 151 152 XCamReturn enqueue_map_image ( 153 cl_mem buf_id, void *&ptr, 154 const size_t *origin, 155 const size_t *region, 156 size_t *image_row_pitch, 157 size_t *image_slice_pitch, 158 bool block = true, 159 cl_map_flags map_flags = CL_MAP_READ | CL_MAP_WRITE, 160 CLEventList &events_wait = CLEvent::EmptyList, 161 SmartPtr<CLEvent> &event_out = CLEvent::NullEvent); 162 163 XCamReturn enqueue_unmap ( 164 cl_mem mem_id, 165 void *ptr, 166 CLEventList &events_wait = CLEvent::EmptyList, 167 SmartPtr<CLEvent> &event_out = CLEvent::NullEvent); 168 169 // return valid event count 170 static uint32_t event_list_2_id_array ( 171 CLEventList &events_wait, 172 cl_event *cl_events, uint32_t max_count); 173 174 XCAM_DEAD_COPY (CLContext); 175 176 private: 177 cl_context _context_id; 178 SmartPtr<CLDevice> _device; 179 //CLKernelMap _kernel_map; 180 CLCmdQueueList _cmd_queue_list; 181 }; 182 183 class CLCommandQueue { 184 friend class CLContext; 185 186 public: 187 virtual ~CLCommandQueue (); 188 cl_command_queue get_cmd_queue_id () { 189 return _cmd_queue_id; 190 } 191 192 private: 193 explicit CLCommandQueue (SmartPtr<CLContext> &context, cl_command_queue id); 194 void destroy (); 195 XCAM_DEAD_COPY (CLCommandQueue); 196 197 private: 198 SmartPtr<CLContext> _context; 199 cl_command_queue _cmd_queue_id; 200 }; 201 202 }; 203 204 #endif //XCAM_CL_CONTEXT_H 205
