opencl-bindings 1.0.0pre2 → 1.0.0pre3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: aea7dd9c7cc8149f8f2fc81b86edb83da2d71343
-  data.tar.gz: 1a14cd6169148349dd56c1fba9f9322fea6b924a
+  metadata.gz: d8cf2f7b42d28415dce84ced6ebfab2d1799aa37
+  data.tar.gz: 37e5a5b0b377d61c94e7df9b5f9e9ce235298b16
 SHA512:
-  metadata.gz: fb1debe697a01f8c984c79abaf8f7d6a03d28d35b08ba857f1443aecff055ac2ec2628c8495f764ee84086d9c4e6aba2078ab10a925048045cd6eceb90cd7a0c
-  data.tar.gz: b350bd39fa361a6e54438e7a60365786a9b4c8deac95cc5b63dfa62ab862d3ec85b680fab290175c78b7f97c60b7496df5e5118ebf05d49180cc21ddb7a5fc80
+  metadata.gz: e0b55bca3fe471829448760b6630c7120aaa2290a0cdf22ab7119cf89922c3de328175e7b4640d16494e4ec13f7cb9dbca6eafa056b2b854963c947f7bd49bec
+  data.tar.gz: 996d769c1593283e05b3c7eabd2d14a9238596fe3e0b878ec67543e8e0f854183009caa86bbeecb0ff99442908d99d13d5f4ec5158ba3d973331191fcbf8e489

data/ChangeLog

@@ -1,3 +1,8 @@
+2015-11-26  vaiorabbit  <http://twitter.com/vaiorabbit>
+
+	* sample/Mandelbrot/mandelbrot_prof.rb, mandelbrot_prof.cl: Added.
+	* sample/util/clu.rb (CLUEvent.getEventProfilingInfo): Added.
+
 2015-11-23  vaiorabbit  <http://twitter.com/vaiorabbit>
 
 	* sample/report_env.rb: Added.

data/README.md

@@ -5,7 +5,7 @@
 A Ruby binding for OpenCL 1.2
 
 *   Created : 2015-10-25
-*   Last modified : 2015-11-23
+*   Last modified : 2015-11-26
 
 
 ## Features ##

data/lib/opencl.rb

@@ -964,7 +964,7 @@ module OpenCL
 
     # Profiling APIs
 
-    # cl_event          :  event
+    # cl_event          : event
     # cl_profiling_info : param_name 
     # size_t            : param_value_size
     # void *            : param_value 

data/sample/report_env.rb

@@ -94,8 +94,8 @@ $enum2pack = {
   OpenCL::CL_DEVICE_VENDOR_ID => "L",
   OpenCL::CL_DEVICE_MAX_COMPUTE_UNITS => "L",
   OpenCL::CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS => "L",
-  OpenCL::CL_DEVICE_MAX_WORK_GROUP_SIZE => "L",
-  OpenCL::CL_DEVICE_MAX_WORK_ITEM_SIZES => "L3",
+  OpenCL::CL_DEVICE_MAX_WORK_GROUP_SIZE => "Q",
+  OpenCL::CL_DEVICE_MAX_WORK_ITEM_SIZES => "Q3",
   OpenCL::CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR => "L",
   OpenCL::CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT => "L",
   OpenCL::CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT => "L",
@@ -107,13 +107,13 @@ $enum2pack = {
   OpenCL::CL_DEVICE_MAX_READ_IMAGE_ARGS => "L",
   OpenCL::CL_DEVICE_MAX_WRITE_IMAGE_ARGS => "L",
   OpenCL::CL_DEVICE_MAX_MEM_ALLOC_SIZE => "L",
-  OpenCL::CL_DEVICE_IMAGE2D_MAX_WIDTH => "L",
-  OpenCL::CL_DEVICE_IMAGE2D_MAX_HEIGHT => "L",
-  OpenCL::CL_DEVICE_IMAGE3D_MAX_WIDTH => "L",
-  OpenCL::CL_DEVICE_IMAGE3D_MAX_HEIGHT => "L",
-  OpenCL::CL_DEVICE_IMAGE3D_MAX_DEPTH => "L",
+  OpenCL::CL_DEVICE_IMAGE2D_MAX_WIDTH => "Q",
+  OpenCL::CL_DEVICE_IMAGE2D_MAX_HEIGHT => "Q",
+  OpenCL::CL_DEVICE_IMAGE3D_MAX_WIDTH => "Q",
+  OpenCL::CL_DEVICE_IMAGE3D_MAX_HEIGHT => "Q",
+  OpenCL::CL_DEVICE_IMAGE3D_MAX_DEPTH => "Q",
   OpenCL::CL_DEVICE_IMAGE_SUPPORT => "cl_bool",
-  OpenCL::CL_DEVICE_MAX_PARAMETER_SIZE => "L",
+  OpenCL::CL_DEVICE_MAX_PARAMETER_SIZE => "Q",
   OpenCL::CL_DEVICE_MAX_SAMPLERS => "L",
   OpenCL::CL_DEVICE_MEM_BASE_ADDR_ALIGN => "L",
   OpenCL::CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE => "L",
@@ -127,7 +127,7 @@ $enum2pack = {
   OpenCL::CL_DEVICE_LOCAL_MEM_TYPE => "L",
   OpenCL::CL_DEVICE_LOCAL_MEM_SIZE => "L",
   OpenCL::CL_DEVICE_ERROR_CORRECTION_SUPPORT => "cl_bool",
-  OpenCL::CL_DEVICE_PROFILING_TIMER_RESOLUTION => "L",
+  OpenCL::CL_DEVICE_PROFILING_TIMER_RESOLUTION => "Q",
   OpenCL::CL_DEVICE_ENDIAN_LITTLE => "cl_bool",
   OpenCL::CL_DEVICE_AVAILABLE => "cl_bool",
   OpenCL::CL_DEVICE_COMPILER_AVAILABLE => "cl_bool",
@@ -153,8 +153,8 @@ $enum2pack = {
   OpenCL::CL_DEVICE_OPENCL_C_VERSION => "Z*",
   OpenCL::CL_DEVICE_LINKER_AVAILABLE => "cl_bool",
   OpenCL::CL_DEVICE_BUILT_IN_KERNELS => "Z*",
-  OpenCL::CL_DEVICE_IMAGE_MAX_BUFFER_SIZE => "L",
-  OpenCL::CL_DEVICE_IMAGE_MAX_ARRAY_SIZE => "L",
+  OpenCL::CL_DEVICE_IMAGE_MAX_BUFFER_SIZE => "Q",
+  OpenCL::CL_DEVICE_IMAGE_MAX_ARRAY_SIZE => "Q",
   OpenCL::CL_DEVICE_PARENT_DEVICE => "Q",
   OpenCL::CL_DEVICE_PARTITION_MAX_SUB_DEVICES => "L",
   OpenCL::CL_DEVICE_PARTITION_PROPERTIES => "L",
@@ -162,7 +162,7 @@ $enum2pack = {
   OpenCL::CL_DEVICE_PARTITION_TYPE => "L",
   OpenCL::CL_DEVICE_REFERENCE_COUNT => "L",
   OpenCL::CL_DEVICE_PREFERRED_INTEROP_USER_SYNC => "L",
-  OpenCL::CL_DEVICE_PRINTF_BUFFER_SIZE => "L",
+  OpenCL::CL_DEVICE_PRINTF_BUFFER_SIZE => "Q",
   OpenCL::CL_DEVICE_IMAGE_PITCH_ALIGNMENT => "L",
   OpenCL::CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT => "L"
 }

data/sample/util/clu.rb

@@ -255,8 +255,8 @@ end
 class CLUContext
   attr_reader :context
 
-  def initialize
-    @context = nil # cl_context
+  def initialize(h = nil)
+    @context = h # cl_context
   end
 
   def handle
@@ -411,8 +411,8 @@ end
 class CLUMemory
   attr_reader :mem # cl_mem
 
-  def initialize
-    @mem = nil
+  def initialize(h = nil)
+    @mem = h
   end
 
   def handle
@@ -691,8 +691,8 @@ end
 class CLUCommandQueue
   attr_reader :command_queue # cl_command_queue
 
-  def initialize
-    @command_queue = nil # cl_command_queue
+  def initialize(h = nil)
+    @command_queue = h # cl_command_queue
   end
 
   def handle
@@ -720,7 +720,7 @@ class CLUCommandQueue
 
   def self.newCommandQueue(context, device, properties = 0, error_info: nil)
     obj = CLUCommandQueue.new
-    ret = obj.createCommandQueue(context, device, 0, error_info: error_info)
+    ret = obj.createCommandQueue(context, device, properties, error_info: error_info)
     return ret == nil ? nil : obj
   end
 
@@ -1134,8 +1134,8 @@ end
 class CLUProgram
   attr_reader :program # cl_program
 
-  def initialize
-    @program = nil
+  def initialize(h = nil)
+    @program = h
   end
 
   def handle
@@ -1216,8 +1216,8 @@ end
 class CLUKernel
   attr_reader :kernel, :name # cl_kernel and the name of '__kernel' entry point
 
-  def initialize
-    @kernel = nil
+  def initialize(h = nil)
+    @kernel = h
     @name = nil
   end
 
@@ -1497,6 +1497,226 @@ end
 
 ################################################################################
 
+class CLUEvent
+  attr_reader :event # cl_event
+
+  def initialize(h = nil)
+    @event = h
+  end
+
+  def handle
+    @event
+  end
+
+  # const cl_event *    : event_list
+  def self.waitForEvents(event_list)
+    event_list.collect! {|event| event.kind_of?(CLUEvent) ? event.handle.to_i : event}
+    # cl_uint : num_events
+    num_events = event_list.length
+
+    err = OpenCL.clWaitForEvents(num_events, event_list.pack("Q*"))
+    return err
+  end
+
+  def wait(event: @event)
+    return self.class.waitForEvents([event])
+  end
+
+  # cl_context          : context
+  def createUserEvent(context, error_info: nil)
+    context = context.handle if context.kind_of? CLUContext
+    errcode_ret_buf = ' ' * 4
+
+    cl_event = OpenCL.clCreateUserEvent(context, errcode_ret_buf)
+    errcode_ret = errcode_ret_buf.unpack("l")[0]
+    error_info << errcode_ret if error_info != nil
+
+    if errcode_ret == OpenCL::CL_SUCCESS
+      @event = cl_event
+      return @event
+    else
+      return nil
+    end
+  end
+
+  def self.newUserEvent(context, error_info: nil)
+    obj = CLUEvent.new
+    ret = obj.createUserEvent(context, error_info: error_info)
+    return ret == nil ? nil : obj
+  end
+
+  # cl_event   : event
+  # cl_int     : execution_status
+  def setUserEventStatus(execution_status, event: @event)
+    err = OpenCL.clSetUserEventStatus(event, execution_status)
+    return err
+  end
+
+  # cl_event : event
+  # cl_int   : command_exec_callback_type
+  # void *   : pfn_notify(cl_program, void*)
+  # void *   : user_data
+  def setEventCallback(command_exec_callback_type, pfn_notify, user_data, event: @event)
+    err = OpenCL.clSetEventCallback(event, command_exec_callback_type, pfn_notify, user_data)
+    return err
+  end
+
+  # cl_event : event
+  def retainEvent(event: @event)
+    return OpenCL.clRetainEvent(event)
+  end
+
+  alias_method :retain, :retainEvent
+
+  # cl_event : event
+  def releaseEvent(event: @event)
+    return OpenCL.clReleaseEvent(event)
+  end
+
+  alias_method :release, :releaseEvent
+
+  # cl_event      : event
+  # cl_event_info : param_name
+  def getEventInfo(param_name, event: @event, error_info: nil)
+    # size_t          : param_value_size
+    # void *          : param_value
+    # size_t *        : param_value_size_ret
+    param_value_buf_length = 1024
+    param_value_buf = ' ' * param_value_buf_length
+    param_value_size_ret_buf = ' ' * 4
+
+    err = OpenCL.clGetEventInfo(event, param_name, param_value_buf_length, param_value_buf, param_value_size_ret_buf)
+    error_info << err if error_info != nil
+
+    param_value_size_ret = param_value_size_ret_buf.unpack("L")[0]
+
+    unpack_format = @@event_info_param2unpack[param_name]
+    return param_value_buf.unpack(unpack_format)[0]
+  end
+
+  @@event_info_param2unpack = {
+    OpenCL::CL_EVENT_COMMAND_QUEUE => "Q",
+    OpenCL::CL_EVENT_CONTEXT => "Q",
+    OpenCL::CL_EVENT_COMMAND_TYPE => "L",
+    OpenCL::CL_EVENT_COMMAND_EXECUTION_STATUS => "l",
+    OpenCL::CL_EVENT_REFERENCE_COUNT => "L",
+  }
+
+  # cl_event          : event
+  # cl_profiling_info : param_name 
+  def getEventProfilingInfo(param_name, event: @event, error_info: nil)
+    # size_t          : param_value_size
+    # void *          : param_value
+    # size_t *        : param_value_size_ret
+    param_value_buf_length = 1024
+    param_value_buf = ' ' * param_value_buf_length
+    param_value_size_ret_buf = ' ' * 4
+
+    err = OpenCL.clGetEventProfilingInfo(event, param_name, param_value_buf_length, param_value_buf, param_value_size_ret_buf)
+    error_info << err if error_info != nil
+
+    param_value_size_ret = param_value_size_ret_buf.unpack("L")[0]
+
+    unpack_format = @@event_profinfo_param2unpack[param_name]
+    return param_value_buf.unpack(unpack_format)[0]
+  end
+
+  @@event_profinfo_param2unpack = {
+    OpenCL::CL_PROFILING_COMMAND_QUEUED => "Q",
+    OpenCL::CL_PROFILING_COMMAND_SUBMIT => "Q",
+    OpenCL::CL_PROFILING_COMMAND_START => "Q",
+    OpenCL::CL_PROFILING_COMMAND_END => "Q",
+  }
+end
+
+################################################################################
+
+class CLUSampler
+  attr_reader :sampler # cl_sampler
+
+  def initialize(h = nil)
+    @sampler = h
+  end
+
+  def handle
+    @sampler
+  end
+
+  # cl_context          : context
+  # cl_bool             : normalized_coords
+  # cl_addressing_mode  : addressing_mode
+  # cl_filter_mode      : filter_mode
+  def createSampler(context, normalized_coords, addressing_mode, filter_mode, error_info: nil)
+    context = context.handle if context.kind_of? CLUContext
+    errcode_ret_buf = ' ' * 4
+
+    cl_smp = OpenCL.clCreateSampler(context, normalized_coords, addressing_mode, filter_mode, errcode_ret_buf)
+    errcode_ret = errcode_ret_buf.unpack("l")[0]
+    error_info << errcode_ret if error_info != nil
+
+    if errcode_ret == OpenCL::CL_SUCCESS
+      @sampler = cl_smp
+      return @sampler
+    else
+      return nil
+    end
+  end
+
+  def self.newSampler(context, normalized_coords, addressing_mode, filter_mode, error_info: nil)
+    obj = CLUSampler.new
+    ret = obj.createSampler(context, normalized_coords, addressing_mode, filter_mode, error_info: error_info)
+    return ret == nil ? nil : obj
+  end
+
+  # cl_sampler : sampler
+  def retainSampler(sampler: @sampler)
+    return OpenCL.clRetainSampler(sampler)
+  end
+
+  alias_method :retain, :retainSampler
+
+  # cl_sampler : sampler
+  def releaseSampler(sampler: @sampler)
+    return OpenCL.clReleaseSampler(sampler)
+  end
+
+  alias_method :release, :releaseSampler
+
+  # cl_sampler      : sampler
+  # cl_sampler_info : param_name
+  def getSamplerInfo(param_name, sampler: @sampler, error_info: nil)
+    # size_t          : param_value_size
+    # void *          : param_value
+    # size_t *        : param_value_size_ret
+    param_value_buf_length = 1024
+    param_value_buf = ' ' * param_value_buf_length
+    param_value_size_ret_buf = ' ' * 4
+
+    err = OpenCL.clGetSamplerInfo(sampler, param_name, param_value_buf_length, param_value_buf, param_value_size_ret_buf)
+    error_info << err if error_info != nil
+
+    param_value_size_ret = param_value_size_ret_buf.unpack("L")[0]
+
+    unpack_format = @@param2unpack[param_name]
+    case unpack_format
+    when "cl_bool"
+      return param_value_buf.unpack("L")[0] == 0 ? false : true
+    else
+      return param_value_buf.unpack(unpack_format)[0]
+    end
+  end
+
+  @@param2unpack = {
+    OpenCL::CL_SAMPLER_REFERENCE_COUNT => "L",
+    OpenCL::CL_SAMPLER_CONTEXT => "Q",
+    OpenCL::CL_SAMPLER_NORMALIZED_COORDS => "cl_bool",
+    OpenCL::CL_SAMPLER_ADDRESSING_MODE => "L",
+    OpenCL::CL_SAMPLER_FILTER_MODE => "L",
+  }
+end
+
+################################################################################
+
 class CLU
 
   @@image_format = {

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opencl-bindings
 version: !ruby/object:Gem::Version
-  version: 1.0.0pre2
+  version: 1.0.0pre3
 platform: ruby
 authors:
 - vaiorabbit
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-23 00:00:00.000000000 Z
+date: 2015-11-26 00:00:00.000000000 Z
 dependencies: []
 description: |
   Ruby bindings for OpenCL 1.2 using Fiddle (For MRI >= 2.0.0).