metacl 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 792d99fee2e47cc7aab8a97d71a727064b2fd081
+  data.tar.gz: 8ca813049935f3c77ea061d4ca45f68589c3173f
+SHA512:
+  metadata.gz: 976bf50850d7d48b7c7c198275335f9d3d60d102f069f8f8c3dfd31dd14d1faaf3be3e8cbecdd42b948de5d0380442d11cbf76ae7b0b723c9f016ada9b89c52f
+  data.tar.gz: 7c0a8940b4c4c4439ed1ffc6bc60b0d40d344ec2a4a9fe982fa168604b71e5f0708e6959c0c059fcff6b590f9178539e057e6f624747fb57ec163ce497f8856b

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.idea
+bin/test*.rb

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in metacl.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Roman Kolesnev
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Metacl
+
+DSL that generates C code for different computation platforms (pure C, OpenCL, Intel Phi)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'metacl'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install metacl
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/metacl/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/metacl

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+require 'metacl'
+
+source = ARGV[0]
+dest   = ARGV[1] || source.gsub('mcl', 'cpp')
+
+code = MetaCL::Program.create source
+
+File.open(dest, 'w') { |file| file.write(code) }

data/lib/metacl.rb

@@ -0,0 +1,14 @@
+require 'mustache'
+require 'ostruct'
+
+require 'metacl/version'
+
+require 'metacl/utils'
+require 'metacl/templates'
+require 'metacl/refinements'
+require 'metacl/logic'
+require 'metacl/dsl'
+require 'metacl/program'
+
+module MetaCL
+end

data/lib/metacl/dsl.rb

@@ -0,0 +1,5 @@
+require 'metacl/dsl/expression'
+require 'metacl/dsl/data_definitions'
+require 'metacl/dsl/directs'
+require 'metacl/dsl/expression_applicator'
+require 'metacl/dsl/root'

data/lib/metacl/dsl/data_definitions.rb

@@ -0,0 +1,26 @@
+module MetaCL
+  module DSL
+    module DataDefinitions
+
+      def numeric(name, type, options = {})
+        value = options[:value]
+        @program.resources.add_numeric name, type
+
+        @inner_code << Templates::InitNumeric.render(name, type, value, @program.platform) << "\n\n"
+      end
+
+      def array(name, type, length, options = {})
+        @program.resources.add_array name, length, type
+
+        @inner_code << Templates::InitArray.render(name, type, length, options[:fill_with], @program.platform) << "\n\n"
+      end
+
+      def matrix(name, type, size_n, size_m, options = {})
+        @program.resources.add_matrix name, size_n, size_m, type
+
+        @inner_code << Templates::InitMatrix.render(name, type, size_n, size_m, options[:fill_with], @program.platform) << "\n\n"
+      end
+
+    end
+  end
+end

data/lib/metacl/dsl/directs.rb

@@ -0,0 +1,13 @@
+module MetaCL
+  module DSL
+    module Directs
+      def direct(string)
+        @inner_code << string << "\n"
+      end
+
+      def direct_pre(string)
+        @outer_code << string << "\n"
+      end
+    end
+  end
+end

data/lib/metacl/dsl/expression.rb

@@ -0,0 +1,30 @@
+module MetaCL
+  module DSL
+    class Expression
+      attr_reader :tree
+
+      def initialize(program, &block)
+        @program = program
+        @tree = instance_eval(&block)
+      end
+
+      def sum(index, from, to, expression)
+        Logic::Node.new :aggregator, expression, nil, index: index, from: from, to: to, type: :+
+      end
+
+      def mul(index, from, to, expression)
+        Logic::Node.new :aggregator, expression, nil, index: index, from: from, to: to, type: :*
+      end
+
+      def method_missing(name, *args)
+        sub_expression = @program.resources.expressions_hash[name.to_sym]
+        substitution = sub_expression.args.map.with_index { |param, index| [param, args[index]] }.to_h
+        sub_expression.root_node.get_tree_with_substitution(substitution)
+      end
+
+      def self.construct(program, &block)
+        Expression.new(program, &block).tree
+      end
+    end
+  end
+end

data/lib/metacl/dsl/expression_applicator.rb

@@ -0,0 +1,92 @@
+module MetaCL
+  module DSL
+    class ExpressionApplicator
+      attr_reader :code
+
+      def initialize(program, expr, result_matrix, options = {})
+        @program, @expr = program, expr.deep_clone
+        @result_matrix  = program.resources.matrices_hash[result_matrix]
+
+        @left_border  = options[:from]  || [0, 0]
+        @right_border = options[:to]    || [@result_matrix.size_n, @result_matrix.size_m]
+
+        @var_letter   = 't'
+
+        prepare_tree
+        code_generation
+
+        @code = Templates::ExpressionApplicatorWrapper.render(@left_border, @right_border, @expr.params.code || '', @expr.objects, @result_matrix, @program.platform)
+      end
+
+      def self.construct(program, expr, result_matrix, options = {})
+        ExpressionApplicator.new(program, expr, result_matrix, options).code
+      end
+
+      def prepare_tree
+        pt_vars_gen
+      end
+
+      # pt means prepare_tree
+
+      def pt_vars_gen
+        vars_count = 0
+
+        @expr.walk do |node|
+          case node.type
+            when :data
+              index_i = node.params.index_i || 'i'
+              index_j = node.params.index_j || 'j'
+              data    = @program.resources[node.params.name]
+              node.params.object = data
+              case data.klass
+                when :matrix
+                  node.params.var = "#{data.name}[(#{index_i})*#{data.size_m} + (#{index_j})]"
+                when :array
+                  node.params.var = "#{data.name}[#{index_i}]"
+                when :numeric
+                  node.params.var = data.name
+              end
+            when :operator, :aggregator
+              vars_count += 1
+              node.params.var = @var_letter + vars_count.to_s
+            when :const
+              node.params.var = node.params.data.to_s
+          end
+        end
+      end
+
+      def code_generation
+        @expr.walk do |node|
+          case node.type
+            when :operator
+              left_var    = node.left_child.params.var
+              right_var   = node.right_child.params.var
+              left_code   = node.left_child.params.code   || ''
+              right_code  = node.right_child.params.code  || ''
+              node.params.code = left_code + right_code + "float #{node.params.var} = #{left_var} #{node.params.type} #{right_var};\n"
+            when :aggregator
+              code          = node.left_child.params.code || ''
+              subresult_var = node.left_child.params.var
+              iterator      = node.params.index
+              from, to      = node.params.from, node.params.to
+              type          = 'float'
+              var           = node.params.var
+              operator      = node.params.type
+              node.params.code = Templates::Aggregator.render(@program.platform,
+                                                              code: code,
+                                                              subresult_var: subresult_var,
+                                                              iterator: iterator,
+                                                              from: from,
+                                                              to: to,
+                                                              type: type,
+                                                              var: var,
+                                                              operator: operator
+              ) + "\n"
+          end
+        end
+
+        @expr.params.code += "#{@result_matrix.name}[i*#{@result_matrix.size_m} + j] = #{@expr.params.var};\n"
+      end
+    end
+  end
+end

data/lib/metacl/dsl/root.rb

@@ -0,0 +1,46 @@
+module MetaCL
+  module DSL
+    class Root
+      attr_reader :code
+
+      include Directs
+      include DataDefinitions
+
+      using Refinements
+
+      def initialize(program, filename)
+        @program = program
+        super() # call initializers from modules
+        @inner_code = ""
+        @outer_code = ""
+
+        instance_eval IO.read(filename), filename
+
+        @code = Templates::Wrapper.render(@inner_code, @outer_code, @program.platform)
+      end
+
+      def platform(name)
+        @program.set_platform name # TODO platform check
+      end
+
+      def prints(string)
+        @inner_code << Templates::Prints.render(string, @program.platform) << "\n"
+      end
+
+      def expression(name, *args, &block)
+        tree = Expression.construct(@program, &block)
+        @program.resources.add_expression(name, tree, args)
+      end
+
+      def apply_expression(matrix_name, options = {}, &block)
+        expr = Expression.construct(@program, &block)
+        @inner_code << ExpressionApplicator.construct(@program, expr, matrix_name, options) << "\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
+    end
+  end
+end

data/lib/metacl/logic.rb

@@ -0,0 +1,2 @@
+require 'metacl/logic/resource_manager'
+require 'metacl/logic/node'

data/lib/metacl/logic/node.rb

@@ -0,0 +1,92 @@
+module MetaCL
+  module Logic
+    class Node
+      using Refinements
+      attr_reader   :type, :params, :left_child, :right_child
+
+      def initialize(type, left_child = nil, right_child = nil, params = {})
+        @type = type
+        @params = OpenStruct.new(params)
+        @left_child, @right_child = left_child, right_child
+      end
+
+      def deep_clone
+        Marshal.load(Marshal.dump(self)) # TODO: write a proper solution
+      end
+
+      def leaf?
+        not (left_child or right_child)
+      end
+
+      def nodify
+        self
+      end
+
+      def [](index_i, index_j = nil)
+        params.index_i = index_i
+        params.index_j = index_j
+        self
+      end
+
+      def walk(&block)
+        @left_child.walk(&block)  if @left_child
+        @right_child.walk(&block) if @right_child
+        yield self
+      end
+
+      def nodes
+        result = []
+        walk { |node| result << node }
+      end
+
+      def leaves
+        nodes.select(&:leaf?)
+      end
+
+      def objects
+        leaves.map { |x| x.params.object }.compact.uniq
+      end
+
+      def +(arg)
+        Node.new :operator, self, arg.nodify, type: :+
+      end
+
+      def -(arg)
+        Node.new :operator, self, arg.nodify, type: :-
+      end
+
+      def /(arg)
+        Node.new :operator, self, arg.nodify, type: :/
+      end
+
+      def *(arg)
+        Node.new :operator, self, arg.nodify, type: :*
+      end
+
+      def debug(tab = 0)
+        text = '  ' * tab << @type.to_s << ' ' << "{ #{ @params.to_h.map { |k, v| "#{k}: #{v}"}.join ', ' } }" << "\n"
+        if @left_child
+          text << '  ' * tab << "left: \n"
+          text << @left_child.debug(tab+1)
+        end
+        if @right_child
+          text << '  ' * tab << "right: \n"
+          text << @right_child.debug(tab+1)
+        end
+        text
+      end
+
+      def to_s
+        debug
+      end
+
+      def get_tree_with_substitution(subst)
+        new_tree = self.deep_clone
+        new_tree.leaves.each do
+          |leaf| leaf.params.name = subst[leaf.params.name]
+        end
+        new_tree
+      end
+    end
+  end
+end

data/lib/metacl/logic/resource_manager.rb

@@ -0,0 +1,53 @@
+module MetaCL
+  module Logic
+    class ResourceManager
+      def initialize
+        @namespace = {}
+      end
+
+      def add_numeric(name, type = nil) # name check
+        @namespace[name] = OpenStruct.new(name: name, klass: :numeric, type: type)
+      end
+
+      def add_array(name, length, type = nil) # name check
+        @namespace[name] = OpenStruct.new(name: name, klass: :array, type: type, length: length)
+      end
+
+      def add_matrix(name, size_n, size_m, type = nil)
+        @namespace[name] = OpenStruct.new(name: name, klass: :matrix, type: type, size_n: size_n, size_m: size_m)
+      end
+
+      def add_expression(name, root_node, args = [])
+        @namespace[name] = OpenStruct.new(name: name, klass: :expression, args: args, root_node: root_node)
+      end
+
+      def numerics
+        @namespace.values.select { |e| e.klass == :numeric }
+      end
+
+      def arrays
+        @namespace.values.select { |e| e.klass == :array }
+      end
+
+      def matrices
+        @namespace.values.select { |e| e.klass == :matrix }
+      end
+
+      def expressions
+        @namespace.values.select { |e| e.klass == :expression }
+      end
+
+      def expressions_hash
+        Hash[expressions.map { |e| [e.name, e] }]
+      end
+
+      def matrices_hash
+        Hash[matrices.map { |e| [e.name, e] }]
+      end
+
+      def [](arg)
+        @namespace[arg]
+      end
+    end
+  end
+end

data/lib/metacl/program.rb

@@ -0,0 +1,19 @@
+module MetaCL
+  class Program
+    attr_accessor :code, :platform, :resources
+
+    def initialize(filename)
+      @platform   = :cpp
+      @resources  = Logic::ResourceManager.new
+      @code       = DSL::Root.new(self, filename).code
+    end
+
+    def set_platform(platform)
+      @platform = platform
+    end
+
+    def self.create(filename)
+      Program.new(filename).code
+    end
+  end
+end

data/lib/metacl/refinements.rb

@@ -0,0 +1,31 @@
+module MetaCL
+  module Refinements
+    refine Symbol do
+      def nodify
+        Logic::Node.new :data, nil, nil, name: self
+      end
+
+      def +(arg)
+        self.nodify + arg.nodify
+      end
+
+      def -(arg)
+        self.nodify - arg.nodify
+      end
+
+      def *(arg)
+        self.nodify * arg.nodify
+      end
+
+      def [](*args)
+        self.nodify[*args]
+      end
+    end
+
+    refine Numeric do
+      def nodify
+        Logic::Node.new :const, nil, nil, data: self
+      end
+    end
+  end
+end

data/lib/metacl/templates.rb

@@ -0,0 +1,9 @@
+require 'metacl/templates/wrapper'
+require 'metacl/templates/prints'
+require 'metacl/templates/init_numeric'
+require 'metacl/templates/init_array'
+require 'metacl/templates/init_matrix'
+require 'metacl/templates/kernel'
+require 'metacl/templates/expression_applicator_wrapper'
+require 'metacl/templates/print_matrix'
+require 'metacl/templates/aggregator'

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

@@ -0,0 +1,6 @@
+{{type}} {{var}} = 0;
+for (int {{iterator}} = {{from}}; {{iterator}} < {{to}}; ++{{iterator}})
+{
+{{{code}}}
+    {{var}} {{operator}}= {{subresult_var}};
+}

data/lib/metacl/templates/aggregator.rb

@@ -0,0 +1,13 @@
+module MetaCL
+  module Templates
+    class Aggregator < Mustache
+      attr_reader :type, :var, :iterator, :from, :to, :subresult_var, :operator, :code
+
+      def render(platform, options = {})
+        @type, @var, @iterator, @from, @to, @subresult_var, @operator, @code = options.values_at(:type, :var, :iterator, :from, :to, :subresult_var, :operator, :code)
+        @code = Utils.tab_text(@code)
+        super IO.read("#{__dir__}/aggregator.any.template")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+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}}}

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

@@ -0,0 +1,7 @@
+for (int i = {{n_from}}; i < {{n_to}}; ++i)
+{
+    for (int j = {{m_from}}; j < {{m_to}}; ++j)
+    {
+{{{code}}}
+    }
+}

data/lib/metacl/templates/expression_applicator_wrapper.rb

@@ -0,0 +1,90 @@
+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
+
+      def render(from_border, to_border, code, objects, result_object, 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
+
+        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|
+          case x.klass
+            when :matrix, :array
+              params << "buffer_#{x.name}"
+            when :numeric
+              # TODO
+          end
+        end
+
+        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/init_array.cl.template

@@ -0,0 +1,2 @@
+std::vector<{{type}}> {{name}}({{length}}{{#fill_with}}, {{fill_with}}{{/fill_with}});
+cl::Buffer buffer_{{name}}(context,CL_MEM_READ_WRITE,sizeof({{type}})*{{length}});

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

@@ -0,0 +1 @@
+std::vector<{{type}}> {{name}}({{length}}{{#fill_with}}, {{fill_with}}{{/fill_with}});

data/lib/metacl/templates/init_array.rb

@@ -0,0 +1,12 @@
+module MetaCL
+  module Templates
+    class InitArray < Mustache
+      attr_reader :name, :type, :length, :fill_with
+
+      def render(name, type, length, fill_with, platform)
+        @name, @type, @length, @fill_with = name, type, length, fill_with
+        super IO.read("#{__dir__}/init_array.#{platform}.template")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,2 @@
+std::vector<{{type}}> {{name}}({{size_n}} * {{size_m}}{{#fill_with}}, {{fill_with}}{{/fill_with}});
+cl::Buffer buffer_{{name}}(context,CL_MEM_READ_WRITE,sizeof({{type}})*{{size_n}}*{{size_m}});

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

@@ -0,0 +1 @@
+std::vector<{{type}}> {{name}}({{size_n}} * {{size_m}}{{#fill_with}}, {{fill_with}}{{/fill_with}});

data/lib/metacl/templates/init_matrix.rb

@@ -0,0 +1,12 @@
+module MetaCL
+  module Templates
+    class InitMatrix < Mustache
+      attr_accessor :name, :type, :size_n, :size_m, :fill_with
+
+      def render(name, type, size_n, size_m, fill_with, platform)
+        @name, @type, @size_n, @size_m, @fill_with = name, type, size_n, size_m, fill_with
+        super IO.read("#{__dir__}/init_matrix.#{platform}.template")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,2 @@
+{{type}} {{name}}{{#value}} = {{value}}{{/value}};
+cl::Buffer buffer_{{name}}(context, CL_MEM_READ_WRITE, sizeof({{type}}));

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

@@ -0,0 +1 @@
+{{type}} {{name}}{{#value}} = {{value}}{{/value}};

data/lib/metacl/templates/init_numeric.rb

@@ -0,0 +1,12 @@
+module MetaCL
+  module Templates
+    class InitNumeric < Mustache
+      attr_accessor :name, :type, :value
+
+      def render(name, type, value, platform)
+        @name, @type, @value = name, type, value
+        super IO.read("#{__dir__}/init_numeric.#{platform}.template")
+      end
+    end
+  end
+end

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

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

data/lib/metacl/templates/kernel.rb

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

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

@@ -0,0 +1,8 @@
+for (int i = 0; i < {{size_n}}; ++i)
+{
+    for (int j = 0; j < {{size_m}}; ++j)
+    {
+        std::cout << {{matrix_name}}[i*{{size_m}} + j] << " ";
+    }
+    std::cout << std::endl;
+}

data/lib/metacl/templates/print_matrix.rb

@@ -0,0 +1,13 @@
+module MetaCL
+  module Templates
+    class PrintMatrix < Mustache
+      attr_reader :size_n, :size_m, :matrix_name
+
+      def render(matrix_name, size_n, size_m, platform)
+        @size_n, @size_m, @matrix_name = size_n, size_m, matrix_name
+
+        super IO.read("#{__dir__}/print_matrix.any.template")
+      end
+    end
+  end
+end

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

@@ -0,0 +1 @@
+std::cout << "{{string}}";

data/lib/metacl/templates/prints.rb

@@ -0,0 +1,12 @@
+module MetaCL
+  module Templates
+    class Prints < Mustache
+      attr_accessor :string
+
+      def render(string, platform)
+        @string = string
+        super IO.read("#{__dir__}/prints.any.template")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+#include <iostream>
+
+#if defined(__APPLE__) || defined(__MACOSX)
+#include <OpenCL/cl.hpp>
+#else
+#include <CL/cl.hpp>
+#endif
+
+{{{outer_code}}}
+
+int main(){
+    //get all platforms (drivers)
+    std::vector<cl::Platform> all_platforms;
+    cl::Platform::get(&all_platforms);
+    if(all_platforms.size()==0){
+        std::cout<<" No platforms found. Check OpenCL installation!\n";
+        exit(1);
+    }
+    cl::Platform default_platform=all_platforms[0];
+    std::cout << "Using platform: "<<default_platform.getInfo<CL_PLATFORM_NAME>()<<"\n";
+
+    //get default device of the default platform
+    std::vector<cl::Device> all_devices;
+    default_platform.getDevices(CL_DEVICE_TYPE_GPU, &all_devices);
+    if(all_devices.size()==0){
+        std::cout<<" No devices found. Check OpenCL installation!\n";
+        exit(1);
+    }
+    cl::Device default_device=all_devices[0];
+    std::cout<< "Using device: "<<default_device.getInfo<CL_DEVICE_NAME>()<<"\n";
+
+    cl::Context context({default_device});
+
+    cl::Program::Sources sources;
+
+{{{inner_code}}}
+
+    return 0;
+}

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

@@ -0,0 +1,10 @@
+#include <iostream>
+#include <vector>
+
+{{{outer_code}}}
+
+int main()
+{
+{{{inner_code}}}
+    return 0;
+}

data/lib/metacl/templates/wrapper.rb

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

data/lib/metacl/utils.rb

@@ -0,0 +1,15 @@
+module MetaCL
+  class Utils
+    class << self
+      def tab_text(text, tabs = 1, tab_size = 4)
+        text.split("\n").map{ |s| ' '*tab_size*tabs + s }.join("\n")
+      end
+
+      def stringify_text(text)
+        text.split("\n").map{ |s| '"' + s.gsub('"', '""') + '\\n"' }.tap { |t|
+          t[-1] = t[-1] + ";"
+        }.join("\n")
+      end
+    end
+  end
+end

data/lib/metacl/version.rb

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

data/metacl.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'metacl/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "metacl"
+  spec.version       = MetaCL::VERSION
+  spec.authors       = ["Roman Kolesnev"]
+  spec.email         = ["rvkolesnev@gmail.com"]
+  spec.summary       = %q{DSL for prototyping computation apps}
+  spec.description   = %q{DSL that generates C code for different computation platforms (pure C, OpenCL, Intel Phi)}
+  spec.homepage      = "https://github.com/ffloyd/metacl"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "mustache"
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "pry"
+end

metadata

@@ -0,0 +1,161 @@
+--- !ruby/object:Gem::Specification
+name: metacl
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Roman Kolesnev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mustache
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: DSL that generates C code for different computation platforms (pure C,
+  OpenCL, Intel Phi)
+email:
+- rvkolesnev@gmail.com
+executables:
+- metacl
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/metacl
+- lib/metacl.rb
+- lib/metacl/dsl.rb
+- lib/metacl/dsl/data_definitions.rb
+- lib/metacl/dsl/directs.rb
+- lib/metacl/dsl/expression.rb
+- lib/metacl/dsl/expression_applicator.rb
+- lib/metacl/dsl/root.rb
+- lib/metacl/logic.rb
+- lib/metacl/logic/node.rb
+- lib/metacl/logic/resource_manager.rb
+- lib/metacl/program.rb
+- lib/metacl/refinements.rb
+- lib/metacl/templates.rb
+- lib/metacl/templates/aggregator.any.template
+- lib/metacl/templates/aggregator.rb
+- lib/metacl/templates/expression_applicator_wrapper.cl.template
+- lib/metacl/templates/expression_applicator_wrapper.cpp.template
+- lib/metacl/templates/expression_applicator_wrapper.rb
+- lib/metacl/templates/init_array.cl.template
+- lib/metacl/templates/init_array.cpp.template
+- lib/metacl/templates/init_array.rb
+- lib/metacl/templates/init_matrix.cl.template
+- lib/metacl/templates/init_matrix.cpp.template
+- lib/metacl/templates/init_matrix.rb
+- lib/metacl/templates/init_numeric.cl.template
+- lib/metacl/templates/init_numeric.cpp.template
+- lib/metacl/templates/init_numeric.rb
+- lib/metacl/templates/kernel.cl.template
+- lib/metacl/templates/kernel.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/wrapper.cl.template
+- lib/metacl/templates/wrapper.cpp.template
+- lib/metacl/templates/wrapper.rb
+- lib/metacl/utils.rb
+- lib/metacl/version.rb
+- metacl.gemspec
+homepage: https://github.com/ffloyd/metacl
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: DSL for prototyping computation apps
+test_files: []