vector_sse 0.0.1.pre

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 98eb4a76855923685b4f2857b834900304bb85c8
+  data.tar.gz: 5ca280566cecbd8cf474e6950ebf21dfe3104199
+SHA512:
+  metadata.gz: 39cbc928cf7f4fc555d8edca11caa0eefb28d34b23356c837f2ef453afd06d6f1b6798c802ad4cad76f65fe3ae25fd6dee459f32fc731bfaad386e4ecf9dbf49
+  data.tar.gz: df243d6d5260ac8f414ccfb5b2c68dfc0a090304cd7c0d49947dc0a6d880dbe966a9cba265d6bedb7caadd41fd6d7bc55e9776929ab453870d85d3c17112b04f

data/.gitignore

@@ -0,0 +1,4 @@
+test_vectorops.rb
+vector_sse-*.gem
+tmp/
+*.sublime-*

data/LICENSE.txt

@@ -0,0 +1,23 @@
+Copyright (c) 2015, Robert Glissmann
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,100 @@
+## Welcome to VectorSSE ##
+
+VectorSSE is a Ruby gem that uses x86 Streaming SIMD Extensions (SSE) to accelerate
+array and matrix computations. SIMD instructions perform a single operation
+on a vector of data rather than on a single value. Vector operations can
+improve the performance of algorithms that exhibit data-level parallelism.
+
+A simple example:
+Let us say you need to compute the sum of an array containing 1000 floating
+point numbers. One approach is to loop through the array and consecutively add
+each element to a running sum. Another approach is to break the problem
+into a set of smaller, independent computations that can be performed in parallel
+with SIMD instructions. For example, we can break the 1000-element array into
+four 250-element arrays and use SIMD extensions to find four sums in parallel.
+Of course, this leaves us with four separate sums, so we must add these using
+normal, non-SSE instructions to yield the overall sum of the 1000-element array.
+
+
+## Install the gem ##
+
+Install it with [RubyGems](https://rubygems.org/) (currently pre-release)
+
+    gem install vector_sse --pre
+
+or add this to your Gemfile if you use [Bundler](http://gembundler.com/):
+
+    gem "vector_sse"
+
+
+## Getting Started ##
+
+The VectorSSE gem defines two data types: the Array class, which inherits from
+the core Array class, and the Matrix class. Unlike typical Ruby containers, the
+Array and Matrix classes are intended to store a homogeneous data type. At this
+time, the supported data types include signed 32 and 64-bit signed integers,
+32-bit floating point, and double-precision floating point. The type is
+identified when the Array or Matrix is constructed so that all operations can
+use the appropriate implementation.
+
+
+### Example: Multiply two matrices ###
+
+     require 'vector_sse'
+
+     left = VectorSSE::Matrix.new( VectorSSE::Type::F32, 4, 4, [
+           1.2,  2.3,  3.4,  4.5,
+           5.6,  6.7,  7.8,  8.9,
+           9.05, 10.9, 11.85, 12.2,
+           13.43, 14.85, 15.67, 16.5
+     ])
+     right = VectorSSE::Matrix.new( VectorSSE::Type::F32, 4, 2, [
+           1,  2,
+           5,  6,
+           9, 10,
+          13, 14
+     ])
+
+     product = left * right
+
+
+### Example: Scale a matrix by a scalar value ###
+
+     require 'vector_sse'
+
+     left = VectorSSE::Matrix.new( VectorSSE::Type::F32, 4, 4, [
+          1.2,  2.3,  3.4,  4.5,
+          5.6,  6.7,  7.8,  8.9,
+          9.05, 10.9, 11.85, 12.2,
+          13.43, 14.85, 15.67, 16.5
+     ])
+
+     product = left * 3.14
+
+
+### Example: Subtract Arrays and find the sum of the elements of an Array ###
+
+     require 'vector_sse'
+
+     # Initialize a four element integer array
+     left = VectoSSE::Array.new( VectorSSE::Type::S32, 10 )
+     left.fill([
+          1, 2, 3, 4, 5, 6, 7, 8, 9, 10
+     ])
+     right = VectoSSE::Array.new( VectorSSE::Type::S32, 10 )
+     right.fill([
+          10, 9, 8, 7, 6, 5, 4, 3, 2, 1
+     ])
+
+     # Subtract the arrays
+     result = left - right
+
+     # Get the sum of the elements of an array
+     sum = left.sum
+
+
+## License and copyright ##
+
+VectorSSE is released under the BSD License.
+
+Copyright: (C) 2015 by Robert Glissmann. All Rights Reserved.

data/Rakefile

@@ -0,0 +1,9 @@
+require 'rake/extensiontask'
+require 'rake/testtask'
+require 'rspec/core/rake_task'
+
+Rake::ExtensionTask.new "vector_sse" do |ext|
+  ext.lib_dir = "lib/vector_sse"
+end
+
+RSpec::Core::RakeTask.new( :spec )

data/ext/vector_sse/.gitignore

@@ -0,0 +1 @@
+Makefile

data/ext/vector_sse/extconf.rb

@@ -0,0 +1,13 @@
+require 'mkmf'
+
+# Give it a name
+extension_name = 'vector_sse'
+
+$CFLAGS << ' -O3'
+
+# Check for dependencies
+have_header( 'emmintrin.h' )
+
+# Do the work
+create_makefile "vector_sse/vector_sse"
+

data/ext/vector_sse/vector_sse.c

@@ -0,0 +1,80 @@
+//
+// Copyright (c) 2015, Robert Glissmann
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+
+
+// Include the Ruby headers and goodies
+#include <emmintrin.h>
+#include <stdio.h>
+#include "ruby.h"
+
+#include "vector_sse_add.h"
+#include "vector_sse_sum.h"
+#include "vector_sse_mul.h"
+#include "vector_sse_vec_mul.h"
+
+// TODO:
+struct vector_sse_result {
+   VALUE result;
+   VALUE overflow;
+};
+
+// Defining a space for information and references about the module to be stored internally
+VALUE VectorSSE = Qnil;
+
+// Prototype for the initialization method - Ruby calls this, not you
+void Init_vector_sse();
+
+
+// The initialization method for this module
+void Init_vector_sse() {
+
+   VectorSSE = rb_define_module("VectorSSE");
+
+   rb_define_singleton_method( VectorSSE, "add_s32", method_vec_add_s32, 2 );
+   rb_define_singleton_method( VectorSSE, "add_s64", method_vec_add_s64, 2 );
+   rb_define_singleton_method( VectorSSE, "add_f32", method_vec_add_f32, 2 );
+   rb_define_singleton_method( VectorSSE, "add_f64", method_vec_add_f64, 2 );
+
+   rb_define_singleton_method( VectorSSE, "sub_s32", method_vec_sub_s32, 2 );
+   rb_define_singleton_method( VectorSSE, "sub_s64", method_vec_sub_s64, 2 );
+   rb_define_singleton_method( VectorSSE, "sub_f32", method_vec_sub_f32, 2 );
+   rb_define_singleton_method( VectorSSE, "sub_f64", method_vec_sub_f64, 2 );
+
+   rb_define_singleton_method( VectorSSE, "sum_s32", method_vec_sum_s32, 1 );
+   rb_define_singleton_method( VectorSSE, "sum_s64", method_vec_sum_s64, 1 );
+   rb_define_singleton_method( VectorSSE, "sum_f32", method_vec_sum_f32, 1 );
+   rb_define_singleton_method( VectorSSE, "sum_f64", method_vec_sum_f64, 1 );
+
+   rb_define_singleton_method( VectorSSE, "mul_s32", method_mat_mul_s32, 6 );
+   rb_define_singleton_method( VectorSSE, "mul_s64", method_mat_mul_s64, 6 );
+   rb_define_singleton_method( VectorSSE, "mul_f32", method_mat_mul_f32, 6 );
+
+   rb_define_singleton_method( VectorSSE, "vec_mul_s32", method_vec_mul_s32, 2 );
+   rb_define_singleton_method( VectorSSE, "vec_mul_s64", method_vec_mul_s64, 2 );
+   rb_define_singleton_method( VectorSSE, "vec_mul_f32", method_vec_mul_f32, 2 );
+   rb_define_singleton_method( VectorSSE, "vec_mul_f64", method_vec_mul_f64, 2 );
+}
+

data/ext/vector_sse/vector_sse_add.c

@@ -0,0 +1,127 @@
+//
+// Copyright (c) 2015, Robert Glissmann
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+
+// %% license-end-token %%
+// 
+// Author: Robert.Glissmann@gmail.com (Robert Glissmann)
+// 
+// 
+
+#include <emmintrin.h>
+#include "vector_sse_add.h"
+
+#define  TEMPLATE_ADD_S( FUNC_NAME, TYPE, OFTYPE, TYPE_SIZE, CONV_IN, CONV_OUT, EL_PER_VEC, ADD ) \
+VALUE FUNC_NAME( VALUE self, VALUE left, VALUE right ) \
+{ \
+   uint32_t length = 0; \
+   uint32_t offset = 0; \
+   uint32_t vector_pos = 0; \
+   uint32_t input_index = 0; \
+\
+   TYPE left_segment[ EL_PER_VEC ]; \
+   TYPE right_segment[ EL_PER_VEC ]; \
+   TYPE result_segment[ EL_PER_VEC ]; \
+\
+   __m128i left_vec; \
+   __m128i right_vec; \
+   __m128i* result_vec = (__m128i*)result_segment; \
+\
+   __m128i sign_left;  \
+   __m128i sign_right; \
+   const OFTYPE OVERFLOW_MASK = ( (OFTYPE)0x1 << (TYPE_SIZE-1) ); \
+   TYPE overflow[ EL_PER_VEC ]; \
+   __m128i* overflow_vec = (__m128i*)overflow; \
+\
+   VALUE result = Qnil; \
+\
+   Check_Type( left, T_ARRAY ); \
+   Check_Type( right, T_ARRAY ); \
+\
+   if ( RARRAY_LEN( left ) != RARRAY_LEN( right ) ) \
+   { \
+      rb_raise( rb_eRuntimeError, "Vector lengths must be the same" ); \
+   } \
+\
+   length = RARRAY_LEN( left ); \
+   result = rb_ary_new2( length ); \
+\
+   if ( length > 0 ) \
+   { \
+      for ( offset = 0; offset < length; offset += EL_PER_VEC ) \
+      { \
+         for ( vector_pos = 0; vector_pos < EL_PER_VEC; ++vector_pos ) \
+         { \
+            input_index = offset + vector_pos; \
+            if ( input_index < length ) \
+            { \
+               left_segment[ vector_pos ] = CONV_IN( rb_ary_entry( left, input_index ) ); \
+               right_segment[ vector_pos ] = CONV_IN( rb_ary_entry( right, input_index ) ); \
+            } \
+            else \
+            { \
+               left_segment[ vector_pos ] = 0; \
+               right_segment[ vector_pos ] = 0; \
+            } \
+         } \
+\
+         left_vec = _mm_loadu_si128( (const __m128i *)left_segment ); \
+         right_vec = _mm_loadu_si128( (const __m128i *)right_segment ); \
+         *result_vec = ADD( left_vec, right_vec ); \
+\
+         sign_left = _mm_xor_si128(*result_vec, left_vec); \
+         sign_right = _mm_xor_si128(*result_vec, right_vec); \
+         *overflow_vec = _mm_and_si128(sign_left, sign_right); \
+\
+         for ( vector_pos = 0; vector_pos < EL_PER_VEC; ++vector_pos ) \
+         { \
+            if ( 0 && ( (OFTYPE)overflow[ vector_pos ] & OVERFLOW_MASK ) ) \
+            { \
+               rb_raise( rb_eRuntimeError, "Vector addition overflow" ); \
+            } \
+\
+            input_index = offset + vector_pos; \
+\
+            if ( input_index < length ) \
+            { \
+               rb_ary_push( result, CONV_OUT( result_segment[ vector_pos ] ) ); \
+            } \
+         } \
+      } \
+   } \
+\
+   return result; \
+}
+
+
+TEMPLATE_ADD_S( method_vec_add_s32, int32_t, int32_t, 32, NUM2INT, INT2NUM, 4, _mm_add_epi32 );
+TEMPLATE_ADD_S( method_vec_add_s64, int64_t, int64_t, 64, NUM2LL, LL2NUM, 2, _mm_add_epi64 );
+TEMPLATE_ADD_S( method_vec_add_f32, float, int32_t, 32, NUM2DBL, DBL2NUM, 4, _mm_add_ps );
+TEMPLATE_ADD_S( method_vec_add_f64, double, int64_t, 64, NUM2DBL, DBL2NUM, 2, _mm_add_pd );
+
+TEMPLATE_ADD_S( method_vec_sub_s32, int32_t, int32_t, 32, NUM2INT, INT2NUM, 4, _mm_sub_epi32 );
+TEMPLATE_ADD_S( method_vec_sub_s64, int64_t, int64_t, 64, NUM2LL, LL2NUM, 2, _mm_sub_epi64 );
+TEMPLATE_ADD_S( method_vec_sub_f32, float, int32_t, 32, NUM2DBL, DBL2NUM, 4, _mm_sub_ps );
+TEMPLATE_ADD_S( method_vec_sub_f64, double, int64_t, 64, NUM2DBL, DBL2NUM, 2, _mm_sub_pd );

data/ext/vector_sse/vector_sse_add.h

@@ -0,0 +1,48 @@
+//
+// Copyright (c) 2015, Robert Glissmann
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+
+// %% license-end-token %%
+// 
+// Author: Robert.Glissmann@gmail.com (Robert Glissmann)
+// 
+// 
+
+#ifndef  VECTOR_SSE_ADD_H
+#define  VECTOR_SSE_ADD_H
+
+#include "ruby.h"
+
+VALUE method_vec_add_s32( VALUE self, VALUE left, VALUE right );
+VALUE method_vec_add_s64( VALUE self, VALUE left, VALUE right );
+VALUE method_vec_add_f32( VALUE self, VALUE left, VALUE right );
+VALUE method_vec_add_f64( VALUE self, VALUE left, VALUE right );
+
+VALUE method_vec_sub_s32( VALUE self, VALUE left, VALUE right );
+VALUE method_vec_sub_s64( VALUE self, VALUE left, VALUE right );
+VALUE method_vec_sub_f32( VALUE self, VALUE left, VALUE right );
+VALUE method_vec_sub_f64( VALUE self, VALUE left, VALUE right );
+
+#endif  // VECTOR_SSE_ADD_H