| //TODO: copyrights |
| |
| #include "device.h" |
| #include "buffer.h" |
| #include "kernel.h" |
| #include "program.h" |
| #include "worker.h" |
| #include "builtins.h" |
| #include "propertylist.h" |
| #include "commandqueue.h" |
| #include "events.h" |
| #include "memobject.h" |
| |
| #include "Thread.hpp" |
| #include "CPUID.hpp" |
| |
| #include <cstring> |
| #include <cstdlib> |
| |
| #include <iostream> |
| #include <fstream> |
| #include <sstream> |
| |
| using namespace Devices; |
| |
| CPUDevice::CPUDevice() |
| : DeviceInterface(), p_num_events(0), p_stop(false), initialized(false) |
| { |
| |
| } |
| |
| void CPUDevice::init() |
| { |
| // Initialize the locking machinery |
| p_events_cond = new sw::Event(); |
| |
| //TODO CHANGE pcore value to real |
| p_cpu_mhz = 3200; |
| |
| // Create worker threads |
| for(unsigned int i = 0; i < sw::CPUID::coreCount(); ++i) |
| { |
| p_workers[i] = new sw::Thread(worker, this); |
| } |
| |
| initialized = true; |
| } |
| |
| CPUDevice::~CPUDevice() |
| { |
| if(!initialized) |
| return; |
| |
| p_events_cond->signal(); |
| |
| p_stop = true; |
| |
| delete p_events_cond; |
| |
| for(int thread = 0; thread < sw::CPUID::coreCount(); thread++) |
| { |
| if(p_workers[thread]) |
| { |
| p_workers[thread]->join(); |
| |
| delete p_workers[thread]; |
| p_workers[thread] = 0; |
| } |
| } |
| } |
| |
| DeviceBuffer *CPUDevice::createDeviceBuffer(MemObject *buffer, cl_int *rs) |
| { |
| return (DeviceBuffer *)new CPUBuffer(this, buffer, rs); |
| } |
| |
| DeviceProgram *CPUDevice::createDeviceProgram(Program *program) |
| { |
| return (DeviceProgram *)new CPUProgram(this, program); |
| } |
| |
| DeviceKernel *CPUDevice::createDeviceKernel(Kernel *kernel, |
| llvm::Function *function) |
| { |
| return (DeviceKernel *)new CPUKernel(this, kernel, function); |
| } |
| |
| cl_int CPUDevice::initEventDeviceData(Event *event) |
| { |
| switch(event->type()) |
| { |
| case Event::MapBuffer: |
| { |
| MapBufferEvent *e = (MapBufferEvent *)event; |
| CPUBuffer *buf = (CPUBuffer *)e->buffer()->deviceBuffer(this); |
| unsigned char *data = (unsigned char *)buf->data(); |
| |
| data += e->offset(); |
| |
| e->setPtr((void *)data); |
| break; |
| } |
| case Event::MapImage: |
| { |
| MapImageEvent *e = (MapImageEvent *)event; |
| Image2D *image = (Image2D *)e->buffer(); |
| CPUBuffer *buf = (CPUBuffer *)image->deviceBuffer(this); |
| unsigned char *data = (unsigned char *)buf->data(); |
| |
| data = imageData(data, |
| e->origin(0), |
| e->origin(1), |
| e->origin(2), |
| image->row_pitch(), |
| image->slice_pitch(), |
| image->pixel_size()); |
| |
| e->setPtr((void *)data); |
| e->setRowPitch(image->row_pitch()); |
| e->setSlicePitch(image->slice_pitch()); |
| break; |
| } |
| case Event::UnmapMemObject: |
| // Nothing do to |
| break; |
| |
| case Event::NDRangeKernel: |
| case Event::TaskKernel: |
| { |
| //TODO |
| // Instantiate the JIT for the CPU program |
| KernelEvent *e = (KernelEvent *)event; |
| //Program *p = (Program *)e->kernel()->parent(); |
| //CPUProgram *prog = (CPUProgram *)p->deviceDependentProgram(this); |
| |
| /*if(!prog->initJIT()) |
| return CL_INVALID_PROGRAM_EXECUTABLE;*/ |
| |
| // Set device-specific data |
| CPUKernelEvent *cpu_e = new CPUKernelEvent(this, e); |
| e->setDeviceData((void *)cpu_e); |
| |
| break; |
| } |
| default: |
| break; |
| } |
| |
| return CL_SUCCESS; |
| } |
| |
| void CPUDevice::freeEventDeviceData(Event *event) |
| { |
| switch(event->type()) |
| { |
| case Event::NDRangeKernel: |
| case Event::TaskKernel: |
| { |
| CPUKernelEvent *cpu_e = (CPUKernelEvent *)event->deviceData(); |
| |
| if(cpu_e) |
| delete cpu_e; |
| } |
| default: |
| break; |
| } |
| } |
| |
| void CPUDevice::pushEvent(Event *event) |
| { |
| eventListResource.lock(); |
| |
| p_events.push_back(event); |
| p_num_events++; |
| p_events_cond->signal(); |
| |
| eventListResource.unlock(); |
| } |
| |
| Event *CPUDevice::getEvent(bool &stop) |
| { |
| // Return the first event in the list, if any. Remove it if it is a |
| // single-shot event. |
| while(p_num_events == 0 && !p_stop) |
| p_events_cond->wait(); |
| |
| eventListResource.lock(); |
| |
| if(p_stop) |
| { |
| eventListResource.unlock(); |
| stop = true; |
| return 0; |
| } |
| |
| Event *event = p_events.front(); |
| |
| // If the run of this event will finish it, remove it from the list |
| bool last_slot = true; |
| |
| if(event->type() == Event::NDRangeKernel || |
| event->type() == Event::TaskKernel) |
| { |
| CPUKernelEvent *ke = (CPUKernelEvent *)event->deviceData(); |
| last_slot = ke->reserve(); |
| } |
| |
| if(last_slot) |
| { |
| p_num_events--; |
| p_events.pop_front(); |
| } |
| |
| eventListResource.unlock(); |
| |
| return event; |
| } |
| |
| float CPUDevice::cpuMhz() const |
| { |
| return p_cpu_mhz; |
| } |
| |
| // From inner parentheses to outher ones : |
| // |
| // sizeof * 8 => 8 |
| // -1 => 7 |
| // 1 << $ => 10000000 |
| // -1 => 01111111 |
| // *2 => 11111110 |
| // +1 => 11111111 |
| // |
| // A simple way to do this is (1 << (sizeof(type) * 8)) - 1, but it overflows |
| // the type (for int8, 1 << $ = 100000000 = 256 > 255) |
| #define TYPE_MAX(type) ((((type)1 << ((sizeof(type) * 8) - 1)) - 1) * 2 + 1) |
| |
| cl_int CPUDevice::info(cl_device_info param_name, |
| size_t param_value_size, |
| void *param_value, |
| size_t *param_value_size_ret) const |
| { |
| void *value = 0; |
| size_t value_length = 0; |
| |
| union { |
| cl_device_type cl_device_type_var; |
| cl_uint cl_uint_var; |
| size_t size_t_var; |
| cl_ulong cl_ulong_var; |
| cl_bool cl_bool_var; |
| cl_device_fp_config cl_device_fp_config_var; |
| cl_device_mem_cache_type cl_device_mem_cache_type_var; |
| cl_device_local_mem_type cl_device_local_mem_type_var; |
| cl_device_exec_capabilities cl_device_exec_capabilities_var; |
| cl_command_queue_properties cl_command_queue_properties_var; |
| cl_platform_id cl_platform_id_var; |
| size_t work_dims[MAX_WORK_DIMS]; |
| }; |
| |
| switch(param_name) |
| { |
| case CL_DEVICE_TYPE: |
| SIMPLE_ASSIGN(cl_device_type, CL_DEVICE_TYPE_CPU); |
| break; |
| |
| case CL_DEVICE_VENDOR_ID: |
| SIMPLE_ASSIGN(cl_uint, 0); |
| break; |
| |
| case CL_DEVICE_MAX_COMPUTE_UNITS: |
| SIMPLE_ASSIGN(cl_uint, sw::CPUID::coreCount()); |
| break; |
| |
| case CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS: |
| SIMPLE_ASSIGN(cl_uint, MAX_WORK_DIMS); |
| break; |
| |
| case CL_DEVICE_MAX_WORK_GROUP_SIZE: |
| SIMPLE_ASSIGN(size_t, TYPE_MAX(size_t)); |
| break; |
| |
| case CL_DEVICE_MAX_WORK_ITEM_SIZES: |
| for(int i = 0; i<MAX_WORK_DIMS; ++i) |
| { |
| work_dims[i] = TYPE_MAX(size_t); |
| } |
| value_length = MAX_WORK_DIMS * sizeof(size_t); |
| value = &work_dims; |
| break; |
| |
| case CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR: |
| SIMPLE_ASSIGN(cl_uint, 16); |
| break; |
| |
| case CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT: |
| SIMPLE_ASSIGN(cl_uint, 8); |
| break; |
| |
| case CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT: |
| SIMPLE_ASSIGN(cl_uint, 4); |
| break; |
| |
| case CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG: |
| SIMPLE_ASSIGN(cl_uint, 2); |
| break; |
| |
| case CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT: |
| SIMPLE_ASSIGN(cl_uint, 4); |
| break; |
| |
| case CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE: |
| SIMPLE_ASSIGN(cl_uint, 2); |
| break; |
| |
| case CL_DEVICE_MAX_CLOCK_FREQUENCY: |
| SIMPLE_ASSIGN(cl_uint, cpuMhz() * 1000000); |
| break; |
| |
| case CL_DEVICE_ADDRESS_BITS: |
| SIMPLE_ASSIGN(cl_uint, 32); |
| break; |
| |
| case CL_DEVICE_MAX_READ_IMAGE_ARGS: |
| SIMPLE_ASSIGN(cl_uint, 65536); |
| break; |
| |
| case CL_DEVICE_MAX_WRITE_IMAGE_ARGS: |
| SIMPLE_ASSIGN(cl_uint, 65536); |
| break; |
| |
| case CL_DEVICE_MAX_MEM_ALLOC_SIZE: |
| SIMPLE_ASSIGN(cl_ulong, 128 * 1024 * 1024); |
| break; |
| |
| case CL_DEVICE_IMAGE2D_MAX_WIDTH: |
| SIMPLE_ASSIGN(size_t, 65536); |
| break; |
| |
| case CL_DEVICE_IMAGE2D_MAX_HEIGHT: |
| SIMPLE_ASSIGN(size_t, 65536); |
| break; |
| |
| case CL_DEVICE_IMAGE3D_MAX_WIDTH: |
| SIMPLE_ASSIGN(size_t, 65536); |
| break; |
| |
| case CL_DEVICE_IMAGE3D_MAX_HEIGHT: |
| SIMPLE_ASSIGN(size_t, 65536); |
| break; |
| |
| case CL_DEVICE_IMAGE3D_MAX_DEPTH: |
| SIMPLE_ASSIGN(size_t, 65536); |
| break; |
| |
| case CL_DEVICE_IMAGE_SUPPORT: |
| SIMPLE_ASSIGN(cl_bool, CL_TRUE); |
| break; |
| |
| case CL_DEVICE_MAX_PARAMETER_SIZE: |
| SIMPLE_ASSIGN(size_t, 65536); |
| break; |
| |
| case CL_DEVICE_MAX_SAMPLERS: |
| SIMPLE_ASSIGN(cl_uint, 16); |
| break; |
| |
| case CL_DEVICE_MEM_BASE_ADDR_ALIGN: |
| SIMPLE_ASSIGN(cl_uint, 0); |
| break; |
| |
| case CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE: |
| SIMPLE_ASSIGN(cl_uint, 16); |
| break; |
| |
| case CL_DEVICE_SINGLE_FP_CONFIG: |
| // TODO: Check what an x86 SSE engine can support. |
| SIMPLE_ASSIGN(cl_device_fp_config, |
| CL_FP_DENORM | |
| CL_FP_INF_NAN | |
| CL_FP_ROUND_TO_NEAREST); |
| break; |
| |
| case CL_DEVICE_GLOBAL_MEM_CACHE_TYPE: |
| SIMPLE_ASSIGN(cl_device_mem_cache_type, |
| CL_READ_WRITE_CACHE); |
| break; |
| |
| case CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE: |
| // TODO: Get this information from the processor |
| SIMPLE_ASSIGN(cl_uint, 16); |
| break; |
| |
| case CL_DEVICE_GLOBAL_MEM_CACHE_SIZE: |
| // TODO: Get this information from the processor |
| SIMPLE_ASSIGN(cl_ulong, 512 * 1024 * 1024); |
| break; |
| |
| case CL_DEVICE_GLOBAL_MEM_SIZE: |
| // TODO: 1 Gio seems to be enough for software acceleration |
| SIMPLE_ASSIGN(cl_ulong, 1 * 1024 * 1024 * 1024); |
| break; |
| |
| case CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE: |
| SIMPLE_ASSIGN(cl_ulong, 1 * 1024 * 1024 * 1024); |
| break; |
| |
| case CL_DEVICE_MAX_CONSTANT_ARGS: |
| SIMPLE_ASSIGN(cl_uint, 65536); |
| break; |
| |
| case CL_DEVICE_LOCAL_MEM_TYPE: |
| SIMPLE_ASSIGN(cl_device_local_mem_type, CL_GLOBAL); |
| break; |
| |
| case CL_DEVICE_LOCAL_MEM_SIZE: |
| SIMPLE_ASSIGN(cl_ulong, 1 * 1024 * 1024 * 1024); |
| break; |
| |
| case CL_DEVICE_ERROR_CORRECTION_SUPPORT: |
| SIMPLE_ASSIGN(cl_bool, CL_FALSE); |
| break; |
| |
| case CL_DEVICE_PROFILING_TIMER_RESOLUTION: |
| // TODO |
| SIMPLE_ASSIGN(size_t, 1000); // 1000 nanoseconds = 1 ms |
| break; |
| |
| case CL_DEVICE_ENDIAN_LITTLE: |
| SIMPLE_ASSIGN(cl_bool, CL_TRUE); |
| break; |
| |
| case CL_DEVICE_AVAILABLE: |
| SIMPLE_ASSIGN(cl_bool, CL_TRUE); |
| break; |
| |
| case CL_DEVICE_COMPILER_AVAILABLE: |
| SIMPLE_ASSIGN(cl_bool, CL_TRUE); |
| break; |
| |
| case CL_DEVICE_EXECUTION_CAPABILITIES: |
| SIMPLE_ASSIGN(cl_device_exec_capabilities, CL_EXEC_KERNEL | |
| CL_EXEC_NATIVE_KERNEL); |
| break; |
| |
| case CL_DEVICE_QUEUE_PROPERTIES: |
| SIMPLE_ASSIGN(cl_command_queue_properties, |
| CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE | |
| CL_QUEUE_PROFILING_ENABLE); |
| break; |
| |
| case CL_DEVICE_NAME: |
| STRING_ASSIGN("CPU"); |
| break; |
| |
| case CL_DEVICE_VENDOR: |
| STRING_ASSIGN("Mesa"); |
| break; |
| |
| case CL_DRIVER_VERSION: |
| STRING_ASSIGN("" "0.1.0"); |
| break; |
| |
| case CL_DEVICE_PROFILE: |
| STRING_ASSIGN("FULL_PROFILE"); |
| break; |
| |
| case CL_DEVICE_VERSION: |
| STRING_ASSIGN("OpenCL 1.1 Mesa " "0.1.0"); |
| break; |
| |
| case CL_DEVICE_EXTENSIONS: |
| STRING_ASSIGN("cl_khr_global_int32_base_atomics" |
| " cl_khr_global_int32_extended_atomics" |
| " cl_khr_local_int32_base_atomics" |
| " cl_khr_local_int32_extended_atomics" |
| " cl_khr_byte_addressable_store" |
| |
| " cl_khr_fp64" |
| " cl_khr_int64_base_atomics" |
| " cl_khr_int64_extended_atomics") |
| |
| break; |
| |
| case CL_DEVICE_PLATFORM: |
| SIMPLE_ASSIGN(cl_platform_id, 0); |
| break; |
| |
| case CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF: |
| SIMPLE_ASSIGN(cl_uint, 0); |
| break; |
| |
| case CL_DEVICE_HOST_UNIFIED_MEMORY: |
| SIMPLE_ASSIGN(cl_bool, CL_TRUE); |
| break; |
| |
| case CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR: |
| SIMPLE_ASSIGN(cl_uint, 16); |
| break; |
| |
| case CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT: |
| SIMPLE_ASSIGN(cl_uint, 8); |
| break; |
| |
| case CL_DEVICE_NATIVE_VECTOR_WIDTH_INT: |
| SIMPLE_ASSIGN(cl_uint, 4); |
| break; |
| |
| case CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG: |
| SIMPLE_ASSIGN(cl_uint, 2); |
| break; |
| |
| case CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT: |
| SIMPLE_ASSIGN(cl_uint, 4); |
| break; |
| |
| case CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE: |
| SIMPLE_ASSIGN(cl_uint, 2); |
| break; |
| |
| case CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF: |
| SIMPLE_ASSIGN(cl_uint, 0); |
| break; |
| |
| case CL_DEVICE_OPENCL_C_VERSION: |
| STRING_ASSIGN("OpenCL C 1.1 LLVM " "3.7.0svn"); |
| break; |
| |
| default: |
| return CL_INVALID_VALUE; |
| } |
| |
| if(param_value && param_value_size < value_length) |
| return CL_INVALID_VALUE; |
| |
| if(param_value_size_ret) |
| *param_value_size_ret = value_length; |
| |
| if(param_value) |
| std::memcpy(param_value, value, value_length); |
| |
| return CL_SUCCESS; |
| } |
| |
| |
| //GPUDevice::GPUDevice() |
| // : DeviceInterface(), p_cores(0), p_num_events(0), p_workers(0), p_stop(false), |
| // p_initialized(false) |
| //{ |
| // |
| //} |
| // |
| //void GPUDevice::init() |
| //{ |
| // if(p_initialized) |
| // return; |
| // |
| // // Initialize the locking machinery |
| // pthread_cond_init(&p_events_cond, 0); |
| // pthread_mutex_init(&p_events_mutex, 0); |
| // |
| // //TODO |
| // // Get info about the system |
| // /*p_cores = sysconf(_SC_NPROCESSORS_ONLN); |
| // p_cpu_mhz = 0.0f; |
| // |
| // std::filebuf fb; |
| // fb.open("/proc/cpuinfo", std::ios::in); |
| // std::istream is(&fb); |
| // |
| // while(!is.eof()) |
| // { |
| // std::string key, value; |
| // |
| // std::getline(is, key, ':'); |
| // is.ignore(1); |
| // std::getline(is, value); |
| // |
| // if(key.compare(0, 7, "cpu MHz") == 0) |
| // { |
| // std::istringstream ss(value); |
| // ss >> p_cpu_mhz; |
| // break; |
| // } |
| // }*/ |
| // |
| // //TODO CHANGE pcore value to real |
| // p_cores = 1; |
| // p_cpu_mhz = 3200; |
| // // Create worker threads |
| // p_workers = (pthread_t *)std::malloc(numCPUs() * sizeof(pthread_t)); |
| // |
| // for(unsigned int i = 0; i<numCPUs(); ++i) |
| // { |
| // pthread_create(&p_workers[i], 0, &worker, this); |
| // } |
| // |
| // p_initialized = true; |
| //} |
| // |
| //GPUDevice::~GPUDevice() |
| //{ |
| // if(!p_initialized) |
| // return; |
| // |
| // // Terminate the workers and wait for them |
| // pthread_mutex_lock(&p_events_mutex); |
| // |
| // p_stop = true; |
| // |
| // pthread_cond_broadcast(&p_events_cond); |
| // pthread_mutex_unlock(&p_events_mutex); |
| // |
| // for(unsigned int i = 0; i<numCPUs(); ++i) |
| // { |
| // pthread_join(p_workers[i], 0); |
| // } |
| // |
| // // Free allocated memory |
| // std::free((void *)p_workers); |
| // pthread_mutex_destroy(&p_events_mutex); |
| // pthread_cond_destroy(&p_events_cond); |
| //} |
| // |
| //DeviceBuffer *GPUDevice::createDeviceBuffer(MemObject *buffer, cl_int *rs) |
| //{ |
| // return (DeviceBuffer *)new CPUBuffer((CPUDevice *)this, buffer, rs); |
| //} |
| // |
| //DeviceProgram *GPUDevice::createDeviceProgram(Program *program) |
| //{ |
| // return (DeviceProgram *)new CPUProgram((CPUDevice *)this, program); |
| //} |
| // |
| //DeviceKernel *GPUDevice::createDeviceKernel(Kernel *kernel, |
| // llvm::Function *function) |
| //{ |
| // return (DeviceKernel *)new CPUKernel((CPUDevice *)this, kernel, function); |
| //} |
| // |
| //cl_int GPUDevice::initEventDeviceData(Event *event) |
| //{ |
| // switch(event->type()) |
| // { |
| // case Event::MapBuffer: |
| // { |
| // MapBufferEvent *e = (MapBufferEvent *)event; |
| // CPUBuffer *buf = (CPUBuffer *)e->buffer()->deviceBuffer(this); |
| // unsigned char *data = (unsigned char *)buf->data(); |
| // |
| // data += e->offset(); |
| // |
| // e->setPtr((void *)data); |
| // break; |
| // } |
| // case Event::MapImage: |
| // { |
| // MapImageEvent *e = (MapImageEvent *)event; |
| // Image2D *image = (Image2D *)e->buffer(); |
| // CPUBuffer *buf = (CPUBuffer *)image->deviceBuffer(this); |
| // unsigned char *data = (unsigned char *)buf->data(); |
| // |
| // data = imageData(data, |
| // e->origin(0), |
| // e->origin(1), |
| // e->origin(2), |
| // image->row_pitch(), |
| // image->slice_pitch(), |
| // image->pixel_size()); |
| // |
| // e->setPtr((void *)data); |
| // e->setRowPitch(image->row_pitch()); |
| // e->setSlicePitch(image->slice_pitch()); |
| // break; |
| // } |
| // case Event::UnmapMemObject: |
| // // Nothing do to |
| // break; |
| // |
| // case Event::NDRangeKernel: |
| // case Event::TaskKernel: |
| // { |
| // // Instantiate the JIT for the CPU program |
| // KernelEvent *e = (KernelEvent *)event; |
| // //Program *p = (Program *)e->kernel()->parent(); |
| // //CPUProgram *prog = (CPUProgram *)p->deviceDependentProgram(this); |
| // |
| // /*if(!prog->initJIT()) |
| // return CL_INVALID_PROGRAM_EXECUTABLE;*/ |
| // |
| // // Set device-specific data |
| // CPUKernelEvent *cpu_e = new CPUKernelEvent((CPUDevice *)this, e); |
| // e->setDeviceData((void *)cpu_e); |
| // |
| // break; |
| // } |
| // default: |
| // break; |
| // } |
| // |
| // return CL_SUCCESS; |
| //} |
| // |
| //void GPUDevice::freeEventDeviceData(Event *event) |
| //{ |
| // switch(event->type()) |
| // { |
| // case Event::NDRangeKernel: |
| // case Event::TaskKernel: |
| // { |
| // CPUKernelEvent *cpu_e = (CPUKernelEvent *)event->deviceData(); |
| // |
| // if(cpu_e) |
| // delete cpu_e; |
| // } |
| // default: |
| // break; |
| // } |
| //} |
| // |
| //void GPUDevice::pushEvent(Event *event) |
| //{ |
| // // Add an event in the list |
| // pthread_mutex_lock(&p_events_mutex); |
| // |
| // p_events.push_back(event); |
| // p_num_events++; // Way faster than STL list::size() ! |
| // |
| // pthread_cond_broadcast(&p_events_cond); |
| // pthread_mutex_unlock(&p_events_mutex); |
| //} |
| // |
| //Event *GPUDevice::getEvent(bool &stop) |
| //{ |
| // // Return the first event in the list, if any. Remove it if it is a |
| // // single-shot event. |
| // pthread_mutex_lock(&p_events_mutex); |
| // |
| // while(p_num_events == 0 && !p_stop) |
| // pthread_cond_wait(&p_events_cond, &p_events_mutex); |
| // |
| // if(p_stop) |
| // { |
| // pthread_mutex_unlock(&p_events_mutex); |
| // stop = true; |
| // return 0; |
| // } |
| // |
| // Event *event = p_events.front(); |
| // |
| // // If the run of this event will finish it, remove it from the list |
| // bool last_slot = true; |
| // |
| // if(event->type() == Event::NDRangeKernel || |
| // event->type() == Event::TaskKernel) |
| // { |
| // CPUKernelEvent *ke = (CPUKernelEvent *)event->deviceData(); |
| // last_slot = ke->reserve(); |
| // } |
| // |
| // if(last_slot) |
| // { |
| // p_num_events--; |
| // p_events.pop_front(); |
| // } |
| // |
| // pthread_mutex_unlock(&p_events_mutex); |
| // |
| // return event; |
| //} |
| // |
| //unsigned int GPUDevice::numCPUs() const |
| //{ |
| // return p_cores; |
| //} |
| // |
| //float GPUDevice::cpuMhz() const |
| //{ |
| // return p_cpu_mhz; |
| //} |
| // |
| //// From inner parentheses to outher ones : |
| //// |
| //// sizeof * 8 => 8 |
| //// -1 => 7 |
| //// 1 << $ => 10000000 |
| //// -1 => 01111111 |
| //// *2 => 11111110 |
| //// +1 => 11111111 |
| //// |
| //// A simple way to do this is (1 << (sizeof(type) * 8)) - 1, but it overflows |
| //// the type (for int8, 1 << $ = 100000000 = 256 > 255) |
| //#define TYPE_MAX(type) ((((type)1 << ((sizeof(type) * 8) - 1)) - 1) * 2 + 1) |
| // |
| //cl_int GPUDevice::info(cl_device_info param_name, |
| // size_t param_value_size, |
| // void *param_value, |
| // size_t *param_value_size_ret) const |
| //{ |
| // void *value = 0; |
| // size_t value_length = 0; |
| // |
| // union { |
| // cl_device_type cl_device_type_var; |
| // cl_uint cl_uint_var; |
| // size_t size_t_var; |
| // cl_ulong cl_ulong_var; |
| // cl_bool cl_bool_var; |
| // cl_device_fp_config cl_device_fp_config_var; |
| // cl_device_mem_cache_type cl_device_mem_cache_type_var; |
| // cl_device_local_mem_type cl_device_local_mem_type_var; |
| // cl_device_exec_capabilities cl_device_exec_capabilities_var; |
| // cl_command_queue_properties cl_command_queue_properties_var; |
| // cl_platform_id cl_platform_id_var; |
| // size_t work_dims[MAX_WORK_DIMS]; |
| // }; |
| // |
| // switch(param_name) |
| // { |
| // case CL_DEVICE_TYPE: |
| // SIMPLE_ASSIGN(cl_device_type, CL_DEVICE_TYPE_CPU); |
| // break; |
| // |
| // case CL_DEVICE_VENDOR_ID: |
| // SIMPLE_ASSIGN(cl_uint, 0); |
| // break; |
| // |
| // case CL_DEVICE_MAX_COMPUTE_UNITS: |
| // SIMPLE_ASSIGN(cl_uint, numCPUs()); |
| // break; |
| // |
| // case CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS: |
| // SIMPLE_ASSIGN(cl_uint, MAX_WORK_DIMS); |
| // break; |
| // |
| // case CL_DEVICE_MAX_WORK_GROUP_SIZE: |
| // SIMPLE_ASSIGN(size_t, TYPE_MAX(size_t)); |
| // break; |
| // |
| // case CL_DEVICE_MAX_WORK_ITEM_SIZES: |
| // for(int i = 0; i<MAX_WORK_DIMS; ++i) |
| // { |
| // work_dims[i] = TYPE_MAX(size_t); |
| // } |
| // value_length = MAX_WORK_DIMS * sizeof(size_t); |
| // value = &work_dims; |
| // break; |
| // |
| // case CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR: |
| // SIMPLE_ASSIGN(cl_uint, 16); |
| // break; |
| // |
| // case CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT: |
| // SIMPLE_ASSIGN(cl_uint, 8); |
| // break; |
| // |
| // case CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT: |
| // SIMPLE_ASSIGN(cl_uint, 4); |
| // break; |
| // |
| // case CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG: |
| // SIMPLE_ASSIGN(cl_uint, 2); |
| // break; |
| // |
| // case CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT: |
| // SIMPLE_ASSIGN(cl_uint, 4); |
| // break; |
| // |
| // case CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE: |
| // SIMPLE_ASSIGN(cl_uint, 2); |
| // break; |
| // |
| // case CL_DEVICE_MAX_CLOCK_FREQUENCY: |
| // SIMPLE_ASSIGN(cl_uint, cpuMhz() * 1000000); |
| // break; |
| // |
| // case CL_DEVICE_ADDRESS_BITS: |
| // SIMPLE_ASSIGN(cl_uint, 32); |
| // break; |
| // |
| // case CL_DEVICE_MAX_READ_IMAGE_ARGS: |
| // SIMPLE_ASSIGN(cl_uint, 65536); |
| // break; |
| // |
| // case CL_DEVICE_MAX_WRITE_IMAGE_ARGS: |
| // SIMPLE_ASSIGN(cl_uint, 65536); |
| // break; |
| // |
| // case CL_DEVICE_MAX_MEM_ALLOC_SIZE: |
| // SIMPLE_ASSIGN(cl_ulong, 128 * 1024 * 1024); |
| // break; |
| // |
| // case CL_DEVICE_IMAGE2D_MAX_WIDTH: |
| // SIMPLE_ASSIGN(size_t, 65536); |
| // break; |
| // |
| // case CL_DEVICE_IMAGE2D_MAX_HEIGHT: |
| // SIMPLE_ASSIGN(size_t, 65536); |
| // break; |
| // |
| // case CL_DEVICE_IMAGE3D_MAX_WIDTH: |
| // SIMPLE_ASSIGN(size_t, 65536); |
| // break; |
| // |
| // case CL_DEVICE_IMAGE3D_MAX_HEIGHT: |
| // SIMPLE_ASSIGN(size_t, 65536); |
| // break; |
| // |
| // case CL_DEVICE_IMAGE3D_MAX_DEPTH: |
| // SIMPLE_ASSIGN(size_t, 65536); |
| // break; |
| // |
| // case CL_DEVICE_IMAGE_SUPPORT: |
| // SIMPLE_ASSIGN(cl_bool, CL_TRUE); |
| // break; |
| // |
| // case CL_DEVICE_MAX_PARAMETER_SIZE: |
| // SIMPLE_ASSIGN(size_t, 65536); |
| // break; |
| // |
| // case CL_DEVICE_MAX_SAMPLERS: |
| // SIMPLE_ASSIGN(cl_uint, 16); |
| // break; |
| // |
| // case CL_DEVICE_MEM_BASE_ADDR_ALIGN: |
| // SIMPLE_ASSIGN(cl_uint, 0); |
| // break; |
| // |
| // case CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE: |
| // SIMPLE_ASSIGN(cl_uint, 16); |
| // break; |
| // |
| // case CL_DEVICE_SINGLE_FP_CONFIG: |
| // // TODO: Check what an x86 SSE engine can support. |
| // SIMPLE_ASSIGN(cl_device_fp_config, |
| // CL_FP_DENORM | |
| // CL_FP_INF_NAN | |
| // CL_FP_ROUND_TO_NEAREST); |
| // break; |
| // |
| // case CL_DEVICE_GLOBAL_MEM_CACHE_TYPE: |
| // SIMPLE_ASSIGN(cl_device_mem_cache_type, |
| // CL_READ_WRITE_CACHE); |
| // break; |
| // |
| // case CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE: |
| // // TODO: Get this information from the processor |
| // SIMPLE_ASSIGN(cl_uint, 16); |
| // break; |
| // |
| // case CL_DEVICE_GLOBAL_MEM_CACHE_SIZE: |
| // // TODO: Get this information from the processor |
| // SIMPLE_ASSIGN(cl_ulong, 512 * 1024 * 1024); |
| // break; |
| // |
| // case CL_DEVICE_GLOBAL_MEM_SIZE: |
| // // TODO: 1 Gio seems to be enough for software acceleration |
| // SIMPLE_ASSIGN(cl_ulong, 1 * 1024 * 1024 * 1024); |
| // break; |
| // |
| // case CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE: |
| // SIMPLE_ASSIGN(cl_ulong, 1 * 1024 * 1024 * 1024); |
| // break; |
| // |
| // case CL_DEVICE_MAX_CONSTANT_ARGS: |
| // SIMPLE_ASSIGN(cl_uint, 65536); |
| // break; |
| // |
| // case CL_DEVICE_LOCAL_MEM_TYPE: |
| // SIMPLE_ASSIGN(cl_device_local_mem_type, CL_GLOBAL); |
| // break; |
| // |
| // case CL_DEVICE_LOCAL_MEM_SIZE: |
| // SIMPLE_ASSIGN(cl_ulong, 1 * 1024 * 1024 * 1024); |
| // break; |
| // |
| // case CL_DEVICE_ERROR_CORRECTION_SUPPORT: |
| // SIMPLE_ASSIGN(cl_bool, CL_FALSE); |
| // break; |
| // |
| // case CL_DEVICE_PROFILING_TIMER_RESOLUTION: |
| // // TODO |
| // SIMPLE_ASSIGN(size_t, 1000); // 1000 nanoseconds = 1 ms |
| // break; |
| // |
| // case CL_DEVICE_ENDIAN_LITTLE: |
| // SIMPLE_ASSIGN(cl_bool, CL_TRUE); |
| // break; |
| // |
| // case CL_DEVICE_AVAILABLE: |
| // SIMPLE_ASSIGN(cl_bool, CL_TRUE); |
| // break; |
| // |
| // case CL_DEVICE_COMPILER_AVAILABLE: |
| // SIMPLE_ASSIGN(cl_bool, CL_TRUE); |
| // break; |
| // |
| // case CL_DEVICE_EXECUTION_CAPABILITIES: |
| // SIMPLE_ASSIGN(cl_device_exec_capabilities, CL_EXEC_KERNEL | |
| // CL_EXEC_NATIVE_KERNEL); |
| // break; |
| // |
| // case CL_DEVICE_QUEUE_PROPERTIES: |
| // SIMPLE_ASSIGN(cl_command_queue_properties, |
| // CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE | |
| // CL_QUEUE_PROFILING_ENABLE); |
| // break; |
| // |
| // case CL_DEVICE_NAME: |
| // STRING_ASSIGN("CPU"); |
| // break; |
| // |
| // case CL_DEVICE_VENDOR: |
| // STRING_ASSIGN("Mesa"); |
| // break; |
| // |
| // case CL_DRIVER_VERSION: |
| // STRING_ASSIGN("" "0.1.0"); |
| // break; |
| // |
| // case CL_DEVICE_PROFILE: |
| // STRING_ASSIGN("FULL_PROFILE"); |
| // break; |
| // |
| // case CL_DEVICE_VERSION: |
| // STRING_ASSIGN("OpenCL 1.1 Mesa " "0.1.0"); |
| // break; |
| // |
| // case CL_DEVICE_EXTENSIONS: |
| // STRING_ASSIGN("cl_khr_global_int32_base_atomics" |
| // " cl_khr_global_int32_extended_atomics" |
| // " cl_khr_local_int32_base_atomics" |
| // " cl_khr_local_int32_extended_atomics" |
| // " cl_khr_byte_addressable_store" |
| // |
| // " cl_khr_fp64" |
| // " cl_khr_int64_base_atomics" |
| // " cl_khr_int64_extended_atomics") |
| // |
| // break; |
| // |
| // case CL_DEVICE_PLATFORM: |
| // SIMPLE_ASSIGN(cl_platform_id, 0); |
| // break; |
| // |
| // case CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF: |
| // SIMPLE_ASSIGN(cl_uint, 0); |
| // break; |
| // |
| // case CL_DEVICE_HOST_UNIFIED_MEMORY: |
| // SIMPLE_ASSIGN(cl_bool, CL_TRUE); |
| // break; |
| // |
| // case CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR: |
| // SIMPLE_ASSIGN(cl_uint, 16); |
| // break; |
| // |
| // case CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT: |
| // SIMPLE_ASSIGN(cl_uint, 8); |
| // break; |
| // |
| // case CL_DEVICE_NATIVE_VECTOR_WIDTH_INT: |
| // SIMPLE_ASSIGN(cl_uint, 4); |
| // break; |
| // |
| // case CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG: |
| // SIMPLE_ASSIGN(cl_uint, 2); |
| // break; |
| // |
| // case CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT: |
| // SIMPLE_ASSIGN(cl_uint, 4); |
| // break; |
| // |
| // case CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE: |
| // SIMPLE_ASSIGN(cl_uint, 2); |
| // break; |
| // |
| // case CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF: |
| // SIMPLE_ASSIGN(cl_uint, 0); |
| // break; |
| // |
| // case CL_DEVICE_OPENCL_C_VERSION: |
| // STRING_ASSIGN("OpenCL C 1.1 LLVM " "3.7.0svn"); |
| // break; |
| // |
| // default: |
| // return CL_INVALID_VALUE; |
| // } |
| // |
| // if(param_value && param_value_size < value_length) |
| // return CL_INVALID_VALUE; |
| // |
| // if(param_value_size_ret) |
| // *param_value_size_ret = value_length; |
| // |
| // if(param_value) |
| // std::memcpy(param_value, value, value_length); |
| // |
| // return CL_SUCCESS; |
| //} |
