ikra 0.0.1 → 0.0.2

data/lib/config/configuration.rb

@@ -1,18 +1,43 @@
+require 'fileutils'
+
+require_relative "../symbolic/symbolic"
+
 module Ikra
     module Configuration
         JOB_REORDERING = true
         @@expect_file_name = "last_generated"
 
         def self.resource_file_name(file_name)
-        	File.expand_path("resources/cuda/#{file_name}", File.dirname(File.dirname(File.expand_path(__FILE__))))
+            File.expand_path("resources/cuda/#{file_name}", File.dirname(File.dirname(File.expand_path(__FILE__))))
+        end
+
+        def self.codegen_expect_file_name_for(file_name)
+            FileUtils.mkdir_p(File.expand_path("gen/codegen_expect", File.dirname(File.dirname(File.dirname(File.expand_path(__FILE__))))))
+            
+            File.expand_path("gen/codegen_expect/#{file_name}", File.dirname(File.dirname(File.dirname(File.expand_path(__FILE__)))))
+        end
+
+        def self.log_file_name_for(test_case_name)
+            FileUtils.mkdir_p(File.expand_path("gen/log", File.dirname(File.dirname(File.dirname(File.expand_path(__FILE__))))))
+
+            File.expand_path("gen/log/#{test_case_name}.log", File.dirname(File.dirname(File.dirname(File.expand_path(__FILE__)))))
         end
 
         def self.codegen_expect_file_name
-        	File.expand_path("gen/codegen_expect/#{@@expect_file_name}.cu", File.dirname(File.dirname(File.dirname(File.expand_path(__FILE__)))))
+            if @@expect_file_name == nil
+                # Do not generate expect file
+                return nil
+            end
+
+            return codegen_expect_file_name_for(@@expect_file_name + ".cu")
         end
 
         def self.codegen_expect_file_name=(value)
-        	@@expect_file_name = value
+            @@expect_file_name = value
+        end
+
+        def self.reset_state
+            Symbolic::ArrayCommand.reset_unique_id
         end
     end
 end

data/lib/config/os_configuration.rb

@@ -1,25 +1,78 @@
 require "rbconfig"
+require "logger"
 
 module Ikra
     module Configuration
+
+        # These values are used only if auto configuration fails
+        @cuda_manual_nvcc = "/usr/local/cuda-8.0/bin/nvcc"
+        @cuda_manual_common_include = "/home/matthias/NVIDIA_CUDA-7.5_Samples/common/inc"
+        @cuda_manual_cupti_include = "/usr/local/cuda-7.5/extras/CUPTI/include"
+
+        @is_initialized = false
+        @auto_config = true
+
         class << self
             SUPPORTED_OS = [:linux, :macosx]
-            CUDA_NVCC = "/Developer/NVIDIA/CUDA-7.5/bin/nvcc"
+            ATTEMPT_AUTO_CONFIG = true
+
+            attr_accessor :cuda_manual_nvcc
+            attr_accessor :cuda_manual_common_include
+            attr_accessor :cuda_manual_cupti_include
+            attr_accessor :auto_config
+
+            def is_initialized?
+                return @is_initialized
+            end
 
-            def check_software_configuration
+            def reinitialize!
                 if !SUPPORTED_OS.include?(operating_system)
-                    raise "Operating system not supported: #{operating_system}"
+                    raise AssertionError.new("Operating system not supported: #{operating_system}")
+                end
+
+                @cuda_nvcc = cuda_manual_nvcc
+                @cuda_common_include = cuda_manual_common_include
+                @cuda_cupti_include = cuda_manual_cupti_include
+
+                # Auto configuration
+                if auto_config
+                    Log.info("Attempting CUDA path auto configuration")
+
+                    nvcc_path = %x(which nvcc)
+
+                    if $?.exitstatus == 0
+                        cuda_path = File.expand_path("../..", nvcc_path)
+                        @cuda_nvcc = File.expand_path("bin/nvcc", cuda_path)
+                        @cuda_common_include = File.expand_path("samples/common/inc", cuda_path)
+                        @cuda_cupti_include = File.expand_path("extras/CUPTI/include", cuda_path)
+                    else
+                        Log.warn("CUDA path auto configuration failed")
+                    end
                 end
 
                 # Check if nvcc is installed
-                %x(#{CUDA_NVCC})
+                %x(#{@cuda_nvcc} 2>&1)
                 if $?.exitstatus != 1
-                    raise "nvcc not installed"
+                    raise AssertionError.new("nvcc not installed")
                 end
+
+                if !File.directory?(@cuda_common_include)
+                    raise AssertionError.new("Directory does not exist: #{@cuda_common_include}. Check OS configuration!")
+                end
+
+                if !File.directory?(@cuda_cupti_include)
+                    raise AssertionError.new("Directory does not exist: #{@cuda_cupti_include}. Check OS configuration!")
+                end
+
+                @is_initialized = true
             end
 
             def nvcc_invocation_string(in_file, out_file)
-                "#{CUDA_NVCC} -o #{out_file} -I/usr/local/cuda/samples/common/inc --shared -Xcompiler -fPIC #{in_file}"
+                if !is_initialized?
+                    reinitialize!
+                end
+
+                return "#{@cuda_nvcc} -o #{out_file} -I#{@cuda_common_include} -I#{@cuda_cupti_include} --shared -Xcompiler -fPIC -std=c++11 #{in_file} 2>&1"
             end
 
             def so_suffix
@@ -30,7 +83,7 @@ module Ikra
                 elsif operating_system == :windows
                     "dll"
                 else
-                    raise "Operating system not supported"
+                    raise AssertionError.new("Operating system not supported")
                 end
             end
 
@@ -48,9 +101,9 @@ module Ikra
                     when /solaris|bsd/
                         :unix
                     else
-                        raise "Unknown operating system"
+                        raise AssertionError.new("Unknown operating system")
                 end
             end
         end
     end
-end
+end

data/lib/cpu/cpu_implementation.rb

@@ -0,0 +1,39 @@
+class Array 
+    def stencil(neighbors, out_of_range_value, use_parameter_array: true, with_index: false, &block)
+        copy = self.dup
+
+        return Array.new(size) do |index|
+            if neighbors.min + index < 0 || neighbors.max + index > size - 1
+                out_of_range_value
+            else
+                values = neighbors.map do |offset|
+                    copy[index + offset]
+                end
+
+                if use_parameter_array
+                    if with_index
+                        block.call(values, index)
+                    else
+                        block.call(values)
+                    end
+                else
+                    if with_index
+                        block.call(*values, index)
+                    else
+                        block.call(*values)
+                    end
+                end
+            end
+        end
+    end
+
+    def combine(*others, &block)
+        return Array.new(self.size) do |index|
+            other_elements = others.map do |other|
+                other[index]
+            end
+
+            block.call(self[index], *other_elements)
+        end
+    end
+end

data/lib/ikra.rb

@@ -1,7 +1,17 @@
 require "logger"
-require_relative "symbolic/symbolic"
-require_relative "entity"
 
 module Ikra
     Log = Logger.new(STDOUT)
-end
+
+    class AssertionError < RuntimeError
+
+    end
+end
+
+require_relative "ruby_core/ruby_integration"
+require_relative "symbolic/symbolic"
+require_relative "entity"
+require_relative "translator/cuda_errors"
+require_relative "cpu/cpu_implementation"
+
+Ikra::Translator::CommandTranslator::ProgramBuilder::Launcher.reset_time

data/lib/resources/cuda/allocate_device_memory.cpp

@@ -0,0 +1,5 @@
+    timeStartMeasure();
+    /*{type}*/ * /*{name}*/;
+    checkErrorReturn(program_result, cudaMalloc(&/*{name}*/, /*{bytes}*/));
+    program_result->device_allocations->push_back(/*{name}*/);
+    timeReportMeasure(program_result, allocate_memory);

data/lib/resources/cuda/allocate_host_memory.cpp

@@ -0,0 +1 @@
+    /*{type}*/ * /*{name}*/ = (/*{type}*/ *) malloc(/*{bytes}*/);

data/lib/resources/cuda/allocate_memcpy_environment_to_device.cpp

@@ -0,0 +1,11 @@
+    /* Allocate device environment and copy over struct */
+    environment_t */*{dev_env}*/;
+
+    timeStartMeasure();
+    checkErrorReturn(program_result, cudaMalloc(&/*{dev_env}*/, sizeof(environment_t)));
+    timeReportMeasure(program_result, allocate_memory);
+
+    timeStartMeasure();
+    checkErrorReturn(program_result, cudaMemcpy(/*{dev_env}*/, /*{host_env}*/, sizeof(environment_t), cudaMemcpyHostToDevice));
+    timeReportMeasure(program_result, transfer_memory);
+    

data/lib/resources/cuda/ast/assignment.cpp

@@ -0,0 +1 @@
+/*{target}*/ = /*{source}*/

data/lib/resources/cuda/block_function_head.cpp

@@ -1 +1,7 @@
-__device__ /*{return_type}*/ /*{name}*/(/*{parameters}*/)
+
+// TODO: There should be a better to check if /*{name}*/ is already defined
+#ifndef /*{name}*/_func
+#define /*{name}*/_func
+__device__ /*{result_type}*/ /*{name}*/(/*{parameters}*/)
+/*{body}*/
+#endif

data/lib/resources/cuda/entry_point.cpp

@@ -0,0 +1,47 @@
+#undef checkErrorReturn
+#define checkErrorReturn(result_var, expr) \
+if (result_var->last_error = expr) \
+{\
+    cudaError_t error = cudaGetLastError();\
+    printf("!!! Cuda Failure %s:%d (%i): '%s'\n", __FILE__, __LINE__, expr, cudaGetErrorString(error));\
+    cudaDeviceReset();\
+    return result_var;\
+}
+
+extern "C" EXPORT result_t *launch_kernel(environment_t */*{host_env_var_name}*/)
+{
+    // CUDA Initialization
+    program_result = new result_t();
+    program_result->device_allocations = new vector<void*>();
+
+    timeStartMeasure();
+
+    cudaError_t cudaStatus = cudaSetDevice(0);
+
+    if (cudaStatus != cudaSuccess) {
+        fprintf(stderr, "cudaSetDevice failed! Do you have a CUDA-capable GPU installed?\n");
+        program_result->last_error = -1;
+        return program_result;
+    }
+
+    checkErrorReturn(program_result, cudaFree(0));
+
+    timeReportMeasure(program_result, setup_cuda);
+
+
+    /* Prepare environment */
+    /*{prepare_environment}*/
+
+    /* Launch all kernels */
+    /*{launch_all_kernels}*/
+
+    /* Copy over result to the host */
+    program_result->result = /*{host_result_array}*/;
+
+    /* Free device memory */
+    /*{free_device_memory}*/
+
+    delete program_result->device_allocations;
+    
+    return program_result;
+}

data/lib/resources/cuda/env_builder_copy_array.cpp

@@ -1,4 +1,10 @@
 
     void * temp_ptr_/*{field}*/ = /*{host_env}*/->/*{field}*/;
-    checkCudaErrors(cudaMalloc((void **) &/*{host_env}*/->/*{field}*/, /*{size_bytes}*/));
-    checkCudaErrors(cudaMemcpy(/*{host_env}*/->/*{field}*/, temp_ptr_/*{field}*/, /*{size_bytes}*/, cudaMemcpyHostToDevice));
+
+    timeStartMeasure();
+    checkErrorReturn(program_result, cudaMalloc((void **) &/*{host_env}*/->/*{field}*/, /*{size_bytes}*/));
+    timeReportMeasure(program_result, allocate_memory);
+
+    timeStartMeasure();
+    checkErrorReturn(program_result, cudaMemcpy(/*{host_env}*/->/*{field}*/, temp_ptr_/*{field}*/, /*{size_bytes}*/, cudaMemcpyHostToDevice));
+    timeReportMeasure(program_result, transfer_memory);

data/lib/resources/cuda/free_device_memory.cpp

@@ -0,0 +1,3 @@
+    timeStartMeasure();
+    checkErrorReturn(program_result, cudaFree(/*{name}*/));
+    timeReportMeasure(program_result, free_memory);

data/lib/resources/cuda/free_memory_for_command.cpp

@@ -0,0 +1,24 @@
+({
+    /*{type}*/ cmd_to_free = /*{receiver}*/;
+
+    timeStartMeasure();
+    bool freed_memory = false;
+
+    if (cmd_to_free->result != 0) {
+        checkErrorReturn(program_result, cudaFree(cmd_to_free->result));;
+
+        // Remove from list of allocations
+        program_result->device_allocations->erase(
+            std::remove(
+                program_result->device_allocations->begin(),
+                program_result->device_allocations->end(),
+                cmd_to_free->result),
+            program_result->device_allocations->end());
+
+        freed_memory = true;
+    }
+
+    timeReportMeasure(program_result, free_memory);
+    
+    freed_memory;
+})

data/lib/resources/cuda/header.cpp

@@ -1,4 +1,8 @@
 #include <stdio.h>
+#include <assert.h>
+#include <chrono>
+#include <vector>
+#include <algorithm>
 
 #include <helper_cuda.h>
 #include <helper_cuda_gl.h>
@@ -30,17 +34,27 @@ typedef int obj_id_t;
 typedef int class_id_t;
 /* ----- END Class Type ----- */
 
-/* ----- BEGIN Union Type ----- */
-typedef struct union_type_struct
-{
-    class_id_t class_id;
-    obj_id_t object_id;
-} union_t;
-/* ----- END Union Type ----- */
-
-
 /* ----- BEGIN Environment (lexical variables) ----- */
 // environment_struct must be defined later
 typedef struct environment_struct environment_t;
 /* ----- END Environment (lexical variables) ----- */
 
+
+/* ----- BEGIN Forward declarations ----- */
+typedef struct result_t result_t;
+/* ----- END Forward declarations ----- */
+
+// Define program result variable. Also contains benchmark numbers.
+result_t *program_result;
+
+// Variables for measuring time
+chrono::high_resolution_clock::time_point start_time;
+chrono::high_resolution_clock::time_point end_time;
+
+/* ----- BEGIN Macros ----- */
+#define timeStartMeasure() start_time = chrono::high_resolution_clock::now();
+
+#define timeReportMeasure(result_var, variable_name) \
+end_time = chrono::high_resolution_clock::now(); \
+result_var->time_##variable_name = result_var->time_##variable_name + chrono::duration_cast<chrono::microseconds>(end_time - start_time).count();
+/* ----- END Macros ----- */

data/lib/resources/cuda/header_structs.cpp

@@ -0,0 +1,92 @@
+/* ----- BEGIN Structs ----- */
+struct variable_size_array_t {
+    void *content;
+    int size;
+
+    variable_size_array_t(void *content_ = NULL, int size_ = 0) : content(content_), size(size_) { }; 
+
+    static const variable_size_array_t error_return_value;
+};
+
+// error_return_value is used in case a host section terminates abnormally
+const variable_size_array_t variable_size_array_t::error_return_value = 
+    variable_size_array_t(NULL, 0);
+
+/* ----- BEGIN Union Type ----- */
+typedef union union_type_value {
+    obj_id_t object_id;
+    int int_;
+    float float_;
+    bool bool_;
+    void *pointer;
+    variable_size_array_t variable_size_array;
+
+    __host__ __device__ union_type_value(int value) : int_(value) { };
+    __host__ __device__ union_type_value(float value) : float_(value) { };
+    __host__ __device__ union_type_value(bool value) : bool_(value) { };
+    __host__ __device__ union_type_value(void *value) : pointer(value) { };
+    __host__ __device__ union_type_value(variable_size_array_t value) : variable_size_array(value) { };
+
+    __host__ __device__ static union_type_value from_object_id(obj_id_t value)
+    {
+        return union_type_value(value);
+    }
+
+    __host__ __device__ static union_type_value from_int(int value)
+    {
+        return union_type_value(value);
+    }
+
+    __host__ __device__ static union_type_value from_float(float value)
+    {
+        return union_type_value(value);
+    }
+
+    __host__ __device__ static union_type_value from_bool(bool value)
+    {
+        return union_type_value(value);
+    }
+
+    __host__ __device__ static union_type_value from_pointer(void *value)
+    {
+        return union_type_value(value);
+    }
+
+    __host__ __device__ static union_type_value from_variable_size_array_t(variable_size_array_t value)
+    {
+        return union_type_value(value);
+    }
+} union_v_t;
+
+typedef struct union_type_struct
+{
+    class_id_t class_id;
+    union_v_t value;
+
+    __host__ __device__ union_type_struct(
+        class_id_t class_id_ = 0, union_v_t value_ = union_v_t(0))
+        : class_id(class_id_), value(value_) { };
+
+    static const union_type_struct error_return_value;
+} union_t;
+
+// error_return_value is used in case a host section terminates abnormally
+const union_type_struct union_t::error_return_value = union_type_struct(0, union_v_t(0));
+/* ----- END Union Type ----- */
+
+typedef struct result_t {
+    /*{result_type}*/ result;
+    int last_error;
+
+    uint64_t time_setup_cuda;
+    uint64_t time_prepare_env;
+    uint64_t time_kernel;
+    uint64_t time_free_memory;
+    uint64_t time_transfer_memory;
+    uint64_t time_allocate_memory;
+
+    // Memory management
+    vector<void*> *device_allocations;
+} result_t;
+/* ----- END Structs ----- */
+