metacl 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 792d99fee2e47cc7aab8a97d71a727064b2fd081
-  data.tar.gz: 8ca813049935f3c77ea061d4ca45f68589c3173f
+  metadata.gz: f78c15cdb7d30650509f1fe663a854b9ffc5d5e9
+  data.tar.gz: 6225085ec4af69bb79757e38fc4472f6665104c6
 SHA512:
-  metadata.gz: 976bf50850d7d48b7c7c198275335f9d3d60d102f069f8f8c3dfd31dd14d1faaf3be3e8cbecdd42b948de5d0380442d11cbf76ae7b0b723c9f016ada9b89c52f
-  data.tar.gz: 7c0a8940b4c4c4439ed1ffc6bc60b0d40d344ec2a4a9fe982fa168604b71e5f0708e6959c0c059fcff6b590f9178539e057e6f624747fb57ec163ce497f8856b
+  metadata.gz: 2073478d343372b2a74ca9448e0cbd7c4d60014c9883944f2e7e5730444140b24df908882c23478070120a18d14af0eb0868ca346d3ebf48a62628f38f7bf03c
+  data.tar.gz: 4c8efdd5cf387bea3f8866c29201028f631a4dbf47918d58778fe1d26b487ce1703633ca9b45ee3917ce01099fd845c25ba0913bd5547f81ec92fb5e8661a34b

data/README.md

@@ -18,7 +18,11 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+    $ metacl some.mcl
+    
+Translates some.mcl to some.cpp. Example compile command for OS X (also you must have cl.hpp in OpenCL folder):
+
+    $ clang++ -framework OpenCL -stdlib=libc++ -std=gnu++11 some.cpp
 
 ## Contributing
 

data/lib/metacl/dsl.rb

@@ -2,4 +2,5 @@ require 'metacl/dsl/expression'
 require 'metacl/dsl/data_definitions'
 require 'metacl/dsl/directs'
 require 'metacl/dsl/expression_applicator'
+require 'metacl/dsl/gpu_transer'
 require 'metacl/dsl/root'

data/lib/metacl/dsl/expression_applicator.rb

@@ -1,10 +1,19 @@
 module MetaCL
   module DSL
     class ExpressionApplicator
-      attr_reader :code
+      @@counter = 0
+      attr_reader :code, :init_code
 
       def initialize(program, expr, result_matrix, options = {})
-        @program, @expr = program, expr.deep_clone
+        @@counter += 1
+        @program = program
+        @expr = if expr.kind_of? Logic::Node
+                  expr.deep_clone
+                elsif expr.kind_of? Symbol
+                  Logic::Node.new :data, nil, nil, name: expr
+                elsif expr.kind_of? Numeric
+                  Logic::Node.new :const, nil, nil, data: expr
+                end
         @result_matrix  = program.resources.matrices_hash[result_matrix]
 
         @left_border  = options[:from]  || [0, 0]
@@ -15,11 +24,17 @@ module MetaCL
         prepare_tree
         code_generation
 
-        @code = Templates::ExpressionApplicatorWrapper.render(@left_border, @right_border, @expr.params.code || '', @expr.objects, @result_matrix, @program.platform)
+        @init_code = if @program.platform == :cl
+                       Templates::KernelInit.render(@left_border, @right_border, @expr.params.code || '', @result_matrix, @expr.objects, @@counter, @program.platform)
+                     else
+                       ''
+                     end
+        @code = Templates::ExpressionApplicatorWrapper.render(@left_border, @right_border, @expr.params.code || '', @expr.objects, @result_matrix, @@counter, @program.platform)
       end
 
       def self.construct(program, expr, result_matrix, options = {})
-        ExpressionApplicator.new(program, expr, result_matrix, options).code
+        e = ExpressionApplicator.new(program, expr, result_matrix, options)
+        [e.code, e.init_code]
       end
 
       def prepare_tree
@@ -85,6 +100,7 @@ module MetaCL
           end
         end
 
+        @expr.params.code ||= ''
         @expr.params.code += "#{@result_matrix.name}[i*#{@result_matrix.size_m} + j] = #{@expr.params.var};\n"
       end
     end

data/lib/metacl/dsl/gpu_transer.rb

@@ -0,0 +1,21 @@
+module MetaCL
+  module DSL
+    module GPUTransfers
+      def upload_to_gpu(*args)
+        args.each do |name|
+          object = @program.resources[name]
+          @inner_code << Templates::UploadToGPU.render(object, @program.platform)
+        end
+        @inner_code  << "\n"
+      end
+
+      def download_from_gpu(*args)
+        args.each do |name|
+          object = @program.resources[name]
+          @inner_code << Templates::DownloadFromGPU.render(object, @program.platform)
+        end
+        @inner_code  << "\n"
+      end
+    end
+  end
+end

data/lib/metacl/dsl/root.rb

@@ -5,18 +5,20 @@ module MetaCL
 
       include Directs
       include DataDefinitions
+      include GPUTransfers
 
       using Refinements
 
       def initialize(program, filename)
         @program = program
         super() # call initializers from modules
-        @inner_code = ""
-        @outer_code = ""
+        @inner_code     = ""
+        @post_init_code = ""
+        @outer_code     = ""
 
         instance_eval IO.read(filename), filename
 
-        @code = Templates::Wrapper.render(@inner_code, @outer_code, @program.platform)
+        @code = Templates::Wrapper.render(@inner_code, @post_init_code, @outer_code, @program.platform)
       end
 
       def platform(name)
@@ -24,7 +26,7 @@ module MetaCL
       end
 
       def prints(string)
-        @inner_code << Templates::Prints.render(string, @program.platform) << "\n"
+        @inner_code << Templates::Prints.render(string, @program.platform) << "\n\n"
       end
 
       def expression(name, *args, &block)
@@ -34,13 +36,21 @@ module MetaCL
 
       def apply_expression(matrix_name, options = {}, &block)
         expr = Expression.construct(@program, &block)
-        @inner_code << ExpressionApplicator.construct(@program, expr, matrix_name, options) << "\n"
+        code, init_code = ExpressionApplicator.construct(@program, expr, matrix_name, options)
+        @inner_code << code << "\n\n"
+        @post_init_code << init_code << "\n\n"
       end
 
       def print_matrix(name)
         matrix = @program.resources.matrices_hash[name]
         @inner_code << Templates::PrintMatrix.render(matrix.name, matrix.size_n, matrix.size_m, @program.platform)
       end
+
+      def repeat(count, &block)
+        @inner_code << Templates::Iterate.render(count) << "\n"
+        instance_eval(&block)
+        @inner_code << "}\n\n"
+      end
     end
   end
 end

data/lib/metacl/templates.rb

@@ -6,4 +6,8 @@ require 'metacl/templates/init_matrix'
 require 'metacl/templates/kernel'
 require 'metacl/templates/expression_applicator_wrapper'
 require 'metacl/templates/print_matrix'
-require 'metacl/templates/aggregator'
+require 'metacl/templates/aggregator'
+require 'metacl/templates/upload_to_gpu'
+require 'metacl/templates/download_from_gpu'
+require 'metacl/templates/kernel_init'
+require 'metacl/templates/iterate'

data/lib/metacl/templates/download_from_gpu.rb

@@ -0,0 +1,14 @@
+module MetaCL
+  module Templates
+    class DownloadFromGPU < Mustache
+
+      def render(object, platform)
+        if platform == :cl
+          "queue.enqueueReadBuffer(buffer_#{object.name},CL_TRUE,0,sizeof(#{object.type})*#{object.size_n}*#{object.size_m},#{object.name}.data());\n"
+        else
+          ""
+        end
+      end
+    end
+  end
+end

data/lib/metacl/templates/expression_applicator_wrapper.cl.template

@@ -1,21 +1 @@
-std::string kernel_code =
-{{{kernel_code}}}
-
-sources.push_back({kernel_code.c_str(),kernel_code.length()});
-
-cl::Program program(context,sources);
-if(program.build({default_device})!=CL_SUCCESS){
-    std::cout<<" Error building: "<<program.getBuildInfo<CL_PROGRAM_BUILD_LOG>(default_device)<<"\n";
-    exit(1);
-}
-
-//create queue to which we will push commands for the device.
-cl::CommandQueue queue(context,default_device);
-
-{{{push_buffers}}}
-
-auto metacl_program = cl::make_kernel<{{{template_params}}}>(program, "metacl_program");
-cl::EnqueueArgs eargs(queue, cl::NullRange, cl::NDRange({{n_to}} - {{n_from}}, {{m_to}} - {{m_from}}), cl::NullRange);
-metacl_program(eargs, {{{kernel_params}}}).wait();
-
-{{{pop_buffer}}}
+metacl_program{{counter}}(eargs{{counter}}, {{{kernel_params}}}).wait();

data/lib/metacl/templates/expression_applicator_wrapper.rb

@@ -2,54 +2,23 @@ module MetaCL
   module Templates
     class ExpressionApplicatorWrapper < Mustache
       attr_reader :n_from, :n_to, :m_from, :m_to, :code
-      attr_reader :kernel_code, :push_buffers, :template_params, :kernel_params, :pop_buffer
+      attr_reader :kernel_params, :counter
 
-      def render(from_border, to_border, code, objects, result_object, platform)
+      def render(from_border, to_border, code, objects, result_object, counter, platform)
         @n_from, @m_from  = from_border
         @n_to, @m_to      = to_border
-        @code             = Utils.tab_text(code, platform == :cl ? 1 : 2)
         @objects          = objects
         @result_object    = result_object
+        @code             = Utils.tab_text(code, platform == :cl ? 1 : 2)
+        @counter          = counter
 
         if platform == :cl
-          gen_push_buffers
-          gen_template_params
           gen_kernel_params
-          gen_pop_buffer
-          gen_kernel_code
         end
 
         super IO.read("#{__dir__}/expression_applicator_wrapper.#{platform}.template")
       end
 
-      def gen_push_buffers
-        @push_buffers = ""
-        @objects.each do |x|
-          case x.klass
-            when :matrix
-              @push_buffers << "queue.enqueueWriteBuffer(buffer_#{x.name},CL_TRUE,0,sizeof(#{x.type})*#{x.size_n}*#{x.size_m},#{x.name}.data());\n"
-            when :array
-              @push_buffers << "queue.enqueueWriteBuffer(buffer_#{x.name},CL_TRUE,0,sizeof(#{x.type})*#{x.length},#{x.name}.data());\n"
-            when :numeric
-              # TODO: @push_buffers << "queue.enqueueWriteBuffer(buffer_#{x.name},CL_TRUE,0,sizeof(#{x.type}),#{x.name};\n"
-          end
-        end
-      end
-
-      def gen_template_params
-        params = []
-        @objects.each do |x|
-          case x.klass
-            when :matrix, :array
-              params << "cl::Buffer&"
-            when :numeric
-              # TODO
-          end
-        end
-        params << "cl::Buffer&" # for result
-        @template_params = params.join(', ')
-      end
-
       def gen_kernel_params
         params = []
         @objects.each do |x|
@@ -64,27 +33,6 @@ module MetaCL
         params << "buffer_#{@result_object.name}"
         @kernel_params = params.join(', ')
       end
-
-      def gen_pop_buffer
-        x = @result_object
-        @pop_buffer = "queue.enqueueReadBuffer(buffer_#{x.name},CL_TRUE,0,sizeof(#{x.type})*#{x.size_n}*#{x.size_m},#{x.name}.data());\n"
-      end
-
-      def gen_kernel_code
-        params = []
-        @objects.each do |x|
-          case x.klass
-            when :matrix, :array
-              params << "global const #{x.type}* #{x.name}"
-            when :numeric
-              # TODO
-          end
-        end
-        params << "global #{@result_object.type}* #{@result_object.name}"
-
-        @kernel_code = Templates::Kernel.render(params.join(', '), @code, @n_from, @m_from)
-        @kernel_code = Utils.stringify_text(@kernel_code)
-      end
     end
   end
 end

data/lib/metacl/templates/iterate.any.template

@@ -0,0 +1 @@
+for (int iterator{{counter}} = 0; iterator{{counter}} < {{repeats}}; ++iterator{{counter}}) {

data/lib/metacl/templates/iterate.rb

@@ -0,0 +1,16 @@
+module MetaCL
+  module Templates
+    class Iterate < Mustache
+      @@counter = 0
+      attr_reader :counter, :repeats
+
+      def render(repeats)
+        @@counter += 1
+        @counter = @@counter
+        @repeats = repeats
+        #@code = Utils.tab_text(code, 1)
+        super IO.read("#{__dir__}/iterate.any.template")
+      end
+    end
+  end
+end

data/lib/metacl/templates/kernel.cl.template

@@ -1,4 +1,4 @@
-void kernel metacl_program({{{params}}}) {
+void kernel metacl_program{{counter}}({{{params}}}) {
     int i = get_global_id(0) + {{n_from}};
     int j = get_global_id(1) + {{m_from}};
 {{{code}}}

data/lib/metacl/templates/kernel.rb

@@ -1,9 +1,10 @@
 module MetaCL
   module Templates
     class Kernel < Mustache
-      attr_reader :params, :code, :n_from, :m_from
+      attr_reader :params, :code, :n_from, :m_from, :counter
 
-      def render(params, code, n_from, m_from)
+      def render(params, code, n_from, m_from, counter)
+        @counter = counter
         @params, @code = params, code
         @n_from, @m_from = n_from, m_from
         super IO.read("#{__dir__}/kernel.cl.template")

data/lib/metacl/templates/kernel_init.cl.template

@@ -0,0 +1,16 @@
+cl::Program::Sources sources{{counter}};
+
+std::string kernel_code{{counter}} =
+{{{kernel_code}}}
+
+sources{{counter}}.push_back({kernel_code{{counter}}.c_str(),kernel_code{{counter}}.length()});
+
+cl::Program program{{counter}}(context,sources{{counter}});
+if(program{{counter}}.build({default_device})!=CL_SUCCESS){
+    std::cout<<" Error building: "<<program{{counter}}.getBuildInfo<CL_PROGRAM_BUILD_LOG>(default_device)<<"\n";
+    exit(1);
+}
+
+auto metacl_program{{counter}} = cl::make_kernel<{{{template_params}}}>(program{{counter}}, "metacl_program{{counter}}");
+
+cl::EnqueueArgs eargs{{counter}}(queue, cl::NullRange, cl::NDRange({{n_to}} - {{n_from}}, {{m_to}} - {{m_from}}), cl::NullRange);

data/lib/metacl/templates/kernel_init.rb

@@ -0,0 +1,51 @@
+module MetaCL
+  module Templates
+    class KernelInit < Mustache
+      attr_reader :counter, :kernel_code, :n_from, :m_from, :n_to, :m_to, :template_params
+
+      def render(from_border, to_border, code, result_object, objects, counter, platform)
+        if platform == :cl
+          @counter        = counter
+          @code           = Utils.tab_text(code, 1)
+          @result_object  = result_object
+          @objects        = objects
+          @n_from, @m_from  = from_border
+          @n_to, @m_to      = to_border
+          gen_kernel_code
+          gen_template_params
+          super IO.read("#{__dir__}/kernel_init.cl.template")
+        end
+      end
+
+      def gen_kernel_code
+        params = []
+        @objects.each do |x|
+          case x.klass
+            when :matrix, :array
+              params << "global const #{x.type}* #{x.name}"
+            when :numeric
+              # TODO
+          end
+        end
+        params << "global #{@result_object.type}* #{@result_object.name}"
+
+        @kernel_code = Templates::Kernel.render(params.join(', '), @code, @n_from, @m_from, @counter)
+        @kernel_code = Utils.stringify_text(@kernel_code)
+      end
+
+      def gen_template_params
+        params = []
+        @objects.each do |x|
+          case x.klass
+            when :matrix, :array
+              params << "cl::Buffer&"
+            when :numeric
+              # TODO
+          end
+        end
+        params << "cl::Buffer&" # for result
+        @template_params = params.join(', ')
+      end
+    end
+  end
+end

data/lib/metacl/templates/upload_to_gpu.rb

@@ -0,0 +1,20 @@
+module MetaCL
+  module Templates
+    class UploadToGPU < Mustache
+
+      def render(object, platform)
+        if platform == :cl
+          case object.klass
+            when :matrix
+              @result = "queue.enqueueWriteBuffer(buffer_#{object.name},CL_TRUE,0,sizeof(#{object.type})*#{object.size_n}*#{object.size_m},#{object.name}.data());\n"
+            when :array
+              @result = "queue.enqueueWriteBuffer(buffer_#{object.name},CL_TRUE,0,sizeof(#{object.type})*#{object.length},#{object.name}.data());\n"
+            when :numeric
+              # TODO: @push_buffers << "queue.enqueueWriteBuffer(buffer_#{x.name},CL_TRUE,0,sizeof(#{x.type}),#{x.name};\n"
+          end
+        end
+        @result || ''
+      end
+    end
+  end
+end

data/lib/metacl/templates/wrapper.cl.template

@@ -31,7 +31,10 @@ int main(){
 
     cl::Context context({default_device});
 
-    cl::Program::Sources sources;
+    //create queue to which we will push commands for the device.
+    cl::CommandQueue queue(context,default_device);
+
+{{{post_init_code}}}
 
 {{{inner_code}}}
 

data/lib/metacl/templates/wrapper.cpp.template

@@ -5,6 +5,7 @@
 
 int main()
 {
+{{{post_init_code}}}
 {{{inner_code}}}
     return 0;
 }

data/lib/metacl/templates/wrapper.rb

@@ -1,10 +1,10 @@
 module MetaCL
   module Templates
     class Wrapper < Mustache
-      attr_accessor :inner_code, :outer_code
+      attr_accessor :inner_code, :outer_code, :post_init_code
 
-      def render(inner_code, outer_code, platform)
-        @inner_code, @outer_code = Utils.tab_text(inner_code), outer_code
+      def render(inner_code, post_init_code, outer_code, platform)
+        @inner_code, @post_init_code, @outer_code = Utils.tab_text(inner_code), Utils.tab_text(post_init_code), outer_code
         super IO.read("#{__dir__}/wrapper.#{platform}.template")
       end
     end

data/lib/metacl/version.rb

@@ -1,3 +1,3 @@
 module MetaCL
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: metacl
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Roman Kolesnev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-25 00:00:00.000000000 Z
+date: 2014-06-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mustache
@@ -101,6 +101,7 @@ files:
 - lib/metacl/dsl/directs.rb
 - lib/metacl/dsl/expression.rb
 - lib/metacl/dsl/expression_applicator.rb
+- lib/metacl/dsl/gpu_transer.rb
 - lib/metacl/dsl/root.rb
 - lib/metacl/logic.rb
 - lib/metacl/logic/node.rb
@@ -110,6 +111,7 @@ files:
 - lib/metacl/templates.rb
 - lib/metacl/templates/aggregator.any.template
 - lib/metacl/templates/aggregator.rb
+- lib/metacl/templates/download_from_gpu.rb
 - lib/metacl/templates/expression_applicator_wrapper.cl.template
 - lib/metacl/templates/expression_applicator_wrapper.cpp.template
 - lib/metacl/templates/expression_applicator_wrapper.rb
@@ -122,12 +124,17 @@ files:
 - lib/metacl/templates/init_numeric.cl.template
 - lib/metacl/templates/init_numeric.cpp.template
 - lib/metacl/templates/init_numeric.rb
+- lib/metacl/templates/iterate.any.template
+- lib/metacl/templates/iterate.rb
 - lib/metacl/templates/kernel.cl.template
 - lib/metacl/templates/kernel.rb
+- lib/metacl/templates/kernel_init.cl.template
+- lib/metacl/templates/kernel_init.rb
 - lib/metacl/templates/print_matrix.any.template
 - lib/metacl/templates/print_matrix.rb
 - lib/metacl/templates/prints.any.template
 - lib/metacl/templates/prints.rb
+- lib/metacl/templates/upload_to_gpu.rb
 - lib/metacl/templates/wrapper.cl.template
 - lib/metacl/templates/wrapper.cpp.template
 - lib/metacl/templates/wrapper.rb