yadriggy 1.0.0

data/lib/yadriggy/c/ffi.rb

@@ -0,0 +1,301 @@
+# Copyright (C) 2017- Shigeru Chiba.  All rights reserved.
+
+require 'ffi'
+
+module Yadriggy
+  module C
+
+    # @abstract
+    # A wrapper of memory object accessible from Ruby and C code.
+    #
+    class FFIArray
+      # @return [FFI::MemoryPointer] the object holding all data.
+      def memory_pointer()
+        @array
+      end
+
+      def ==(obj)
+        obj.is_a?(FFIArray) && @array == obj.memory_pointer
+      end
+
+      # Obtains the size.
+      # @return [Integer] the number of elements.
+      def size
+        @array.size / @array.type_size
+      end
+
+      # Obtain the size.
+      # @return [Integer] the number of elements.
+      def length() size() end
+
+      # Initializes the element values.
+      def set_values
+        size.times {|i| self[i] = yield i }
+      end
+
+      # Converts all the elements into an array.
+      # This method is available only within Ruby.
+      def to_a(*args, &proc)
+        Array.new(size) {|i| self[i] }
+      end
+
+      # Obtain the element type.
+      # All the subclasses have to override this method.
+      def self.element_type()
+        Undef
+      end
+    end
+
+    # Array of 32bit integers.
+    # In C, the type of this array is `arrayof(Int)`.
+    #
+    class IntArray < FFIArray
+      # @param [Integer] size  array size.
+      # @param [FFI::MemoryPointer] ptr  a memory pointer or nil.
+      #   If nil, a new memory block is allocated.
+      def initialize(size, ptr=nil)
+        if ptr.nil?
+          @array = FFI::MemoryPointer.new(:int32, size)
+        else
+          @array = ptr
+        end
+      end
+
+      def [](index)
+        @array.get_int32(index * 4)
+      end
+
+      def []=(index, value)
+        @array.put_int32(index * 4, value)
+      end
+
+      def self.element_type()
+        Integer
+      end
+    end
+
+    # Array of 64bit floating point numbers.
+    # In C, the type of this array is `arrayof(Float)`.
+    #
+    class FloatArray < FFIArray
+      # @param [Integer] size  array size.
+      # @param [FFI::MemoryPointer] ptr  a memory pointer or nil.
+      #   If nil, a new memory block is allocated.
+      def initialize(size, ptr=nil)
+        if ptr.nil?
+          @array = FFI::MemoryPointer.new(:double, size)
+        else
+          @array = ptr
+        end
+      end
+
+      def [](index)
+        @array.get_float64(index * 8)
+      end
+
+      def []=(index, value)
+        @array.put_float64(index * 8, value)
+      end
+
+      def self.element_type()
+        Float
+      end
+    end
+
+    # Array of 32bit floating point numbers.
+    # In C, the type of this array is `arrayof(Float32)`.
+    #
+    class Float32Array < FFIArray
+      # @param [Integer] size  array size.
+      # @param [FFI::MemoryPointer] ptr  a memory pointer or nil.
+      #   If nil, a new memory block is allocated.
+      def initialize(size, ptr=nil)
+        if ptr.nil?
+          @array = FFI::MemoryPointer.new(:float, size)
+        else
+          @array = ptr
+        end
+      end
+
+      def [](index)
+        @array.get_float32(index * 4)
+      end
+
+      def []=(index, value)
+        @array.put_float32(index * 4, value)
+      end
+
+      def self.element_type()
+        CType::Float32
+      end
+    end
+
+    # @private
+    # Attaches functions to a module.  The functions are retrieved
+    # from the library generated by compiling Ruby methods.
+    #
+    # @param [Module] module_obj  the module object.
+    # @param [Array<String>] func_names  the function names in C.
+    # @param [Array<Type>] method_types  the types of the original methods.
+    # @param [String] lib_name  the library name.
+    # @param [String] dir  the directory where the library is found.
+    # @return [Module] the module object `module_obj`.
+    def self.attach(module_obj, func_names, method_types, lib_name, dir='./')
+      module_obj.module_eval('extend FFI::Library')
+      module_obj.ffi_lib("#{dir}lib#{lib_name}#{Config::LibExtension}")
+      func_names.each_with_index do |name,i|
+        mtype = method_types[i]
+        module_obj.attach_function((name + '__org').to_sym,
+                                   name.to_sym,
+                                   CFI::param_types(mtype),
+                                   CFI::return_type(mtype))
+        ivk_name = invoker_name(mtype)
+        module_obj.module_eval <<-code, __FILE__, __LINE__
+          def self.#{name}(*args)
+            Yadriggy::C::invoke#{ivk_name}(self, :#{name}__org, args)
+          end
+        code
+      end
+      module_obj
+    end
+
+    # @private
+    # Generates a Ruby source file.  When the file is executed,
+    # it retrieves functions from the library generated by
+    # compiling Ruby methods, and then it attaches the functions
+    # to a specified module.
+    #
+    # @param [String] module_name  the module name.
+    # @param [Array<String>] func_names  the function names in C.
+    # @param [Array<Type>] method_types  the types of the original methods.
+    # @param [String] lib_name  the library name.
+    # @param [String] dir  the directory where the library is found.
+    # @return [String] the generated file name.
+    def self.make_attach_file(module_name, func_names, method_types,
+                              lib_name, dir='./')
+      file_name0 = module_name.gsub(/::|\./, '_').downcase
+      file_name = "#{dir}#{file_name0}.rb"
+      printer = Yadriggy::FilePrinter.new(file_name)
+      printer << "require 'yadriggy/c/ffi'" << :nl << :nl
+      printer << "module #{module_name} extend FFI::Library" << :nl
+      printer << "  self.ffi_lib(\"#{dir}lib#{lib_name}#{Config::LibExtension}\")" << :nl
+      func_names.each_with_index do |name,i|
+        mtype = method_types[i]
+        printer << "  self.attach_function(:\"#{name}__org\", "
+        printer <<     ":\"#{name}\", "
+        printer <<     "#{CFI::param_types(mtype).to_s}, "
+        printer <<     ":#{CFI::return_type(mtype)})"
+        printer << :nl
+
+        printer << "  def self.#{name}(*args)" << :nl
+        printer << "    Yadriggy::C::invoke#{invoker_name(mtype)}(self, "
+        printer <<       ":\"#{name}__org\", args)" << :nl
+        printer << '  end' << :nl
+      end
+      printer << 'end' << :nl
+
+      printer.output
+      printer.close
+      file_name
+    end
+
+    # @private
+    def self.invoker_name(mtype)
+      case ArrayType.role(MethodType.role(mtype)&.result_type)&.element_type
+      when RubyClass::Integer
+        '_int'
+      when RubyClass::Float
+        '_float'
+      when CType::Float32Type
+        '_float32'
+      else
+        ''
+      end
+    end
+
+    # @private
+    def self.invoke_int(module_obj, func_name, args)
+      r = invoke(module_obj, func_name, args)
+      IntArray.new(0, r)
+    end
+
+    # @private
+    def self.invoke_float(module_obj, func_name, args)
+      r = invoke(module_obj, func_name, args)
+      FloatArray.new(0, r)
+    end
+
+    # @private
+    def self.invoke_float32(module_obj, func_name, args)
+      r = invoke(module_obj, func_name, args)
+      Float32Array.new(0, r)
+    end
+
+    # @private
+    def self.invoke(module_obj, func_name, args)
+      args2 = args.map do |e|
+        if e.is_a?(IntArray) || e.is_a?(FloatArray) || e.is_a?(Float32Array)
+          e.memory_pointer
+        else
+          e
+        end
+      end
+      module_obj.method(func_name).call(*args2)
+    end
+
+    # @private
+    # C Function Interface
+    module CFI
+      def self.param_types(method_type)
+        method_type.params.map do |t|
+          c_type(t)
+        end
+      end
+
+      def self.return_type(method_type)
+        c_type(method_type.result_type)
+      end
+
+      # @param [Type] type
+      # @return [String] type name in C.
+      def self.c_type_name(type)
+        type = type.supertype if InstanceType.role(type)
+        if type == RubyClass::Integer || type == Integer
+          'int32_t'
+        elsif type == RubyClass::Float || type == Float
+          'double'
+        elsif type == CType::Void
+          'void'
+        elsif type == RubyClass::String || type == String
+          'char*'
+        elsif type == CType::Float32Type || type == CType::Float32
+          'float'
+        else
+          at = ArrayType.role(type)
+          raise "bad type #{type.inspect}" if at.nil?
+          "#{c_type_name(at.element_type)}*"
+        end
+      end
+
+      # @param [Type] type
+      # @return [Symbol] type name for FFI
+      def self.c_type(type)
+        type = type.supertype if InstanceType.role(type)
+        if type == RubyClass::Integer || type == Integer
+          :int32
+        elsif type == RubyClass::Float || type == Float
+          :double
+        elsif type == CType::Void
+          :void
+        elsif type == RubyClass::String || type == String
+          :string
+        elsif type == CType::Float32Type || type == CType::Float32
+          :float
+        else
+          raise "bad type #{type}" if ArrayType.role(type).nil?
+          :pointer
+        end
+      end
+    end
+  end
+end

data/lib/yadriggy/c/opencl.rb

@@ -0,0 +1,458 @@
+# Copyright (C) 2017- Shigeru Chiba.  All rights reserved.
+
+require 'yadriggy/c/ctype.rb'
+require 'yadriggy/c/codegen'
+require 'yadriggy/c/ctypecheck'
+require 'yadriggy/c/program'
+require 'yadriggy/c/config'
+
+module Yadriggy
+  module C
+    # Compiles OpenCL methods into binary code.
+    #
+    def self.ocl_compile(obj, lib_name=nil, dir=Config::WorkDir,
+                         module_name=nil)
+      mod, funcs = compile0(obj, lib_name, dir, module_name,
+                            OclTypeChecker, OclCodeGen)
+      mod
+    end
+
+    class Program
+      # Compiles this class and makes a module including the
+      # compiled OpenCL methods.
+      #
+      # @param [String] module_name  a module name.
+      # @param [String] lib_name  the name of the generated library.
+      # @param [String] dir  the directory name where generated files
+      #   are stored.  The default value is `.`.
+      # @param [Array<Object>] args  an array of the arguments to the
+      #   `initialize` method.  The default value is `nil` (no arguments).
+      # @return [Module] the module where methods are attached.
+      def self.ocl_compile(module_name=nil, lib_name=nil,
+                           dir: Config::WorkDir, args: nil)
+        if args.nil?
+          obj = self.new
+        else
+          obj = self.new(*args)
+        end
+        Yadriggy::C.ocl_compile(obj, lib_name, dir, module_name)
+      end
+    end
+
+    module CType  # also see ctype.rb
+      # OpenCL array.
+      #
+      class OclArray < IvarObj
+        def initialize(size)
+          @size = size
+        end
+
+        def self.type()
+          Float32Type
+        end
+
+        def type()
+          Float32Type
+        end
+
+        def size()
+          @size
+        end
+
+        def sizes()
+          [ @size ]
+        end
+
+        def copyfrom(array, len) ! Integer
+          typedecl array: arrayof(Float32), len: Integer,
+                   native: 'return 0;'
+          return 0
+        end
+
+        def copyto(array, len) ! Integer
+          typedecl array: arrayof(Float32), len: Integer,
+                   native: 'return 0;'
+          return 0
+        end
+      end
+    end
+
+    class OclTypeChecker < ClangTypeChecker
+      # A map from blocks to their names and free variables.
+      #
+      # @return [Hash<Block,Tuple<String,Hash<Symbol,Type>,Set<Object>>]
+      #   a map to tuples of a block name, free variables, and instance
+      #   variables accessed in the block.
+      attr_reader :blocks
+
+      def initialize(syntax=nil)
+        super(syntax)
+        @blocks = {}
+        @block_count = 0
+      end
+
+      def method_with_block?(name)
+        super || name == 'ocl_times'
+      end
+
+      def typecheck_call_with_block(ast)
+        if ast.name.name == 'ocl_times'
+          type_assert(type(ast.receiver) == RubyClass::Integer,
+                      'the receiver must be an integer')
+          type_assert(ast.block.params.size == 1,
+                      "wrong number of block parameters")
+          tenv = FreeVarFinder.new(type_env)
+          type_as(ast.block.params[0], RubyClass::Integer)
+          tenv.bind_name(ast.block.params[0], RubyClass::Integer)
+          tenv.bind_name(:return, Void)
+
+          old_ins_vars = @instance_variables
+          @instance_variables = Set.new
+          type(ast.block, tenv)
+          captured_ins_vars = @instance_variables
+          @instance_variables = old_ins_vars
+          @instance_variables += captured_ins_vars
+
+          @blocks[ast.block] = ["block#{@block_count}", tenv.free_variables,
+            captured_ins_vars]
+          @block_count += 1
+          Void
+        else
+          super
+        end
+      end
+
+      rule(ArrayRef) do
+        array_type = type(ast.array)
+        if array_type <= RubyClass[OclArray]
+          indexes = ast.indexes
+          type_assert(indexes.size == 1, 'bad array index')
+          itype = type(indexes[0])
+          type_assert(itype <= RubyClass::Integer, 'bad array index')
+          OclArray.type
+        else
+          proceed(ast)
+        end
+      end
+    end
+
+    # OpenCL-code generator
+    #
+    class OclCodeGen < CodeGen
+
+      # @see {OclTypeChecker#method_with_block?}
+      rule(Call) do
+        if ast.name.name == 'copyfrom'
+          @printer << 'ocl_err_check(clEnqueueWriteBuffer(commands, '
+          check(ast.receiver)
+          @printer << ', CL_TRUE, 0, sizeof(float) * '
+          check(ast.args[1]) # length
+          @printer << ', '
+          check(ast.args[0]) # array
+          @printer << ', 0, NULL, NULL), "' << ast.name.name << '")'
+        elsif ast.name.name == 'copyto'
+          @printer << 'ocl_err_check(clEnqueueReadBuffer(commands, '
+          check(ast.receiver)
+          @printer << ', CL_TRUE, 0, sizeof(float) * '
+          check(ast.args[1]) # length
+          @printer << ', '
+          check(ast.args[0]) # array
+          @printer << ', 0, NULL, NULL), "' << ast.name.name << '")'
+        elsif ast.name.name == 'ocl_times'
+          name_and_vars = @typechecker.blocks[ast.block]
+          @printer << name_and_vars[0] << '_call('
+          check(ast.receiver)
+          name_and_vars[1].each do |sym, t|
+            @printer << ', ' << sym.to_s
+          end
+          @printer << ')'
+        else
+          proceed(ast)
+        end
+      end
+
+      def build_cmd
+        super + Config::OpenCLoptions
+      end
+
+      def headers()
+        super
+        Config::OpenCLHeaders.each {|h| @printer << h << :nl }
+        @printer << :nl
+      end
+
+      def variable_declarations()
+        super
+        @gvariables.each do |obj, name|
+          if obj.is_a?(CType::OclArray)
+            @printer << 'static cl_mem ' << name << ';' << :nl
+          end
+        end
+        @typechecker.blocks.each do |obj, name_and_vars|
+          @printer << 'static cl_kernel ' << name_and_vars[0] << ';' << :nl
+        end
+        @printer << :nl
+      end
+
+      def preamble
+        super
+        @printer << 'int ocl_init(int);'  << :nl
+        @printer << 'void ocl_finish();' << :nl << :nl
+
+        print_kernel_source
+        @printer << HelperSource
+        print_ocl_init
+        print_ocl_finish
+        print_callers
+      end
+
+      def expand_functions(func_names, func_types)
+        voidFunc = MethodType.new([], Void)
+        return func_names + ['ocl_init', 'ocl_finish'],
+               func_types + [MethodType.new([Integer], Void),
+                             MethodType.new([], Void)]
+      end
+
+      private
+
+      def print_ocl_init
+        @printer << 'int ocl_init(int is_gpu) {' << :nl
+        @printer << '  if (ocl_initialized) return 0;' << :nl
+        @printer << '  ocl_initialized = 1;' << :nl
+        @printer << '  if (ocl_init0(is_gpu)) return 1;' << :nl << :nl
+        print_create_kernel_code
+        print_create_buffer_code
+        @printer << :nl << '  return 0;' << :nl << '}' << :nl << :nl
+      end
+
+      def print_ocl_finish
+        @printer << 'void ocl_finish() {' << :nl
+        @printer << '  if (!ocl_initialized) return;' << :nl
+        @printer << '  ocl_initialized = 0;' << :nl
+        @gvariables.each do |obj, name|
+          if obj.is_a?(CType::OclArray)
+            @printer << "  clReleaseMemObject(#{name});" << :nl
+          end
+        end
+
+        @typechecker.blocks.each do |obj, name_vars|
+          @printer << '  clReleaseKernel(' << name_vars[0] << ');' << :nl
+        end
+
+        @printer << '  clReleaseProgram(program);' << :nl
+        @printer << '  clReleaseCommandQueue(commands);' << :nl
+        @printer << '  clReleaseContext(context);' << :nl
+        @printer << '}' << :nl << :nl
+      end
+
+      # generate kenrel source.
+      def print_kernel_source
+        @printer << 'static const char* kernelSource = ' << :nl << '"'
+        @printer = KernelPrinter.new(@printer)
+        @typechecker.blocks.each do |blk, name_vars|
+          func_name = name_vars[0]
+          @printer << '__kernel void ' << func_name << '('
+
+          all_free_vars = name_vars[1].to_a
+          all_free_vars += name_vars[2].map do |obj|
+            [@gvariables[obj], obj.class]
+          end
+
+          first = true
+          all_free_vars.each do |name, type|
+            if first then first = false else @printer << ', ' end
+            print_type_in_kernel(type)
+            @printer << name
+          end
+          @printer << ') {'
+          @printer.down
+          local_var_declarations(blk)
+          @printer << 'int ' << blk.params[0].name
+          @printer << ' = get_global_id(0);' << :nl
+          check(blk.body)
+          @printer << ';' unless blk.body.is_a?(Exprs)
+          @printer.up
+          @printer << '}' << :nl
+        end
+        @printer = @printer.printer
+        @printer << ' ";' << :nl << :nl
+      end
+
+      # @param [Type|Class] type
+      def print_type_in_kernel(type)
+        if type == CType::OclArray || type == RubyClass[CType::OclArray]
+          @printer << '__global float* '
+        else
+          @printer << c_type(type) << ' '
+        end
+      end
+
+      def c_type(type)
+        if @printer.is_a?(KernelPrinter) &&
+            (type == RubyClass::Integer || type == Integer)
+          return 'int'
+        else
+          super
+        end
+      end
+
+      class KernelPrinter
+        attr_reader :printer
+
+        def initialize(printer)
+          @printer = printer
+        end
+
+        def down()
+          @printer << "\"\\"
+          @printer.down
+          @printer << '"'
+        end
+
+        def up()
+          @printer << "\"\\"
+          @printer.up
+          @printer << '"'
+        end
+
+        def nl()
+          @printer << "\"\\" << :nl << '"'
+          self
+        end
+
+        def << (code)
+          code == :nl ? nl : @printer << code
+          self
+        end
+      end
+
+      # generate the code for creating kernels.
+      def print_create_kernel_code
+        @printer << '  int err;' << :nl
+        @typechecker.blocks.each do |blk, name_vars|
+          @printer << '  ' << name_vars[0]
+          @printer << ' = clCreateKernel(program, "' << name_vars[0] << '", &err);' << :nl
+          @printer << '  if (err != CL_SUCCESS) {' << :nl
+          @printer << '    fprintf(stderr, "error: clCreateKernel\n");' << :nl
+          @printer << '    return 1; }' << :nl
+        end
+        @printer << :nl
+      end
+
+      # generate the code for creating buffers.
+      def print_create_buffer_code
+        @gvariables.each do |obj, name|
+          if obj.is_a?(CType::OclArray)
+            @printer << "  #{name} = clCreateBuffer(context, CL_MEM_READ_WRITE,"\
+                        " sizeof(float) * #{obj.size}, NULL, NULL);" << :nl
+            @printer << "  if (!#{name}) {" << :nl
+            @printer << '    fprintf(stderr, "error: clCreateBuffer\n");'
+            @printer << ' return 1; }' << :nl
+          end
+        end
+      end
+
+      def print_callers
+        @typechecker.blocks.each do |blk, name_and_vars|
+          name = name_and_vars[0]
+          @printer << 'static void ' << name << '_call(size_t p0'
+          name_and_vars[1].each_with_index do |name_type, i|
+            type = name_type[1]
+            tname = if type <= RubyClass[CType::OclArray]
+                      'cl_mem'
+                    else
+                      c_type(type)
+                    end
+            @printer << ', ' << tname << " p#{i + 1}"
+          end
+          @printer << ') {'
+          @printer.down
+          @printer << 'size_t global;' << :nl
+          @printer << 'int err = 0;' << :nl
+
+          i = name_and_vars[1].size
+          name_and_vars[2].each do |obj|
+            i += 1
+            @printer << "cl_mem p#{i} = #{@gvariables[obj]};" << :nl
+          end
+          i.times do |j|
+            @printer << "err  |= clSetKernelArg(#{name}, #{j}, sizeof(p#{j + 1}), &p#{j + 1});" << :nl
+          end
+
+          @printer << 'ocl_err_check(err, "clSetKernelArg");' << :nl
+          @printer << 'global = p0;' << :nl
+          @printer << 'ocl_err_check(clEnqueueNDRangeKernel(commands, '
+          @printer << name << ', 1, NULL, &global, NULL, 0, NULL, NULL), "clEnqueueNDRangeKernel");' << :nl
+          @printer << 'clFinish(commands);' << :nl
+          @printer.up
+          @printer << '}' << :nl
+        end
+      end
+
+      HelperSource = <<'EOS'
+static int ocl_initialized = 0;
+static cl_device_id device_id;
+static cl_context context;
+static cl_command_queue commands;
+static cl_program program;
+
+static int ocl_err_check(int err, const char* msg) {
+  if (err == CL_SUCCESS)
+    return 0;
+  else {
+    fprintf(stderr, "OpenCL Error: %s, %d\n", msg, err);
+    return 1;
+  }
+}
+
+static int ocl_init0(int gpu) {
+  cl_device_id devices[4];
+  cl_uint num_devices;
+  int err = clGetDeviceIDs(NULL,
+                gpu > 0? CL_DEVICE_TYPE_GPU : CL_DEVICE_TYPE_CPU,
+                sizeof(devices) / sizeof(devices[0]), devices, &num_devices);
+  if (err != CL_SUCCESS) {
+    fprintf(stderr, "error: clGetDeviceIDs\n");
+    return 1;
+  }
+
+  int id = num_devices < gpu ? num_devices : gpu;
+  device_id = devices[id < 1 ? 0 : id - 1];
+
+  context = clCreateContext(0, 1, &device_id, NULL, NULL, &err);
+  if (!context) {
+    fprintf(stderr, "error: clCreateContext\n");
+    return 1;
+  }
+
+  commands = clCreateCommandQueue(context, device_id, 0, &err);
+  if (!commands) {
+    fprintf(stderr, "error: clCreateCommandQueue\n");
+    return 1;
+  }
+
+  program = clCreateProgramWithSource(context, 1,
+                (const char **)&kernelSource, NULL, &err);
+  if (!program) {
+    fprintf(stderr, "error: clCreateProgramWithSource\n");
+    return 1;
+  }
+
+  err = clBuildProgram(program, 0, NULL, NULL, NULL, NULL);
+  if (err != CL_SUCCESS) {
+    size_t len;
+    char buffer[2048];
+    fprintf(stderr, "error: clBuildProgram\n");
+    clGetProgramBuildInfo(program, device_id, CL_PROGRAM_BUILD_LOG,
+                          sizeof(buffer), buffer, &len);
+    fprintf(stderr, "%s\n", buffer);
+    return 1;
+  }
+
+  return 0;
+}
+
+EOS
+    end
+  end
+end