vector_sse 0.0.1.pre

data/ext/vector_sse/vector_sse_mul.c

@@ -0,0 +1,340 @@
+//
+// 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_mul.h"
+
+#define  SSE_VECTOR_WIDTH    (4)
+
+VALUE method_mat_mul_s32( VALUE self, VALUE left, VALUE left_rows_rb, VALUE left_cols_rb, VALUE right, VALUE right_rows_rb, VALUE right_cols_rb )
+{
+   uint32_t left_row = 0;
+   uint32_t right_col = 0;
+   uint32_t common = 0;
+   uint32_t vector_pos = 0;
+   uint32_t input_index = 0;
+   uint32_t pos = 0;
+
+   int32_t left_segment[ SSE_VECTOR_WIDTH ];
+   int32_t right_segment[ SSE_VECTOR_WIDTH ];
+   int64_t result_segment[ SSE_VECTOR_WIDTH/2 ];
+
+   __m128i* left_vec = NULL;
+   __m128i* right_vec = NULL;
+   __m128i result_vec;
+
+   VALUE result = Qnil;
+
+   int64_t* result_native = NULL;
+
+   uint32_t left_rows = NUM2INT( left_rows_rb );
+   uint32_t left_cols = NUM2INT( left_cols_rb );
+   uint32_t right_rows = NUM2INT( right_rows_rb );
+   uint32_t right_cols = NUM2INT( right_cols_rb );
+
+   uint32_t left_length = left_rows * left_cols;
+   uint32_t right_length = right_rows * right_cols;
+   uint32_t result_length = left_rows * right_cols;
+
+   int32_t* left_native = NULL;
+   int32_t* right_native = NULL;
+   int64_t* partial_native = NULL;
+   int64_t* temp = NULL;
+
+   left_native  = (int32_t*) malloc( left_length * sizeof(int32_t) );
+   right_native = (int32_t*) malloc( right_length * sizeof(int32_t) );
+   result_native = (int64_t*) malloc( result_length * sizeof(int64_t) );
+   partial_native = (int64_t*) malloc( left_cols * sizeof(int64_t) );
+
+   memset(partial_native,0,left_cols*sizeof(int64_t) );
+
+   for ( pos = 0; pos < left_length; ++pos )
+   {
+      left_native[ pos ] = NUM2INT( rb_ary_entry( left, pos ) );
+   }
+   for ( pos = 0; pos < right_length; ++pos )
+   {
+      right_native[ pos ] = NUM2INT( rb_ary_entry( right, pos ) );
+   }
+
+   for ( left_row = 0; left_row < left_rows; ++left_row )
+   {
+      for ( right_col = 0; right_col < right_cols; ++right_col )
+      {
+         for ( common = 0; common < left_cols; common += (SSE_VECTOR_WIDTH/2) )
+         {
+            memset( left_segment, 0, sizeof( left_segment ) );
+            memset( right_segment, 0, sizeof( right_segment ) );
+
+            input_index = common;
+            left_segment[ 0 ] = left_native[ left_row * left_cols + input_index ];
+            right_segment[ 0 ] = right_native[ input_index * right_cols + right_col ];
+
+            input_index = common + 1;
+            if ( input_index < left_cols )
+            {
+               left_segment[ 2 ] = left_native[ left_row * left_cols + input_index ];
+               right_segment[ 2 ] = right_native[ input_index * right_cols + right_col ];
+            }
+
+            left_vec  = ( __m128i *)left_segment;
+            right_vec = ( __m128i *)right_segment;
+            result_vec = _mm_mul_epu32( *left_vec, *right_vec );
+
+            _mm_store_si128( (__m128i*)result_segment, result_vec );
+            for ( pos = 0; pos < SSE_VECTOR_WIDTH/2; ++pos )
+            {
+               if ( (common + pos) < left_cols )
+               {
+                  partial_native[ common + pos ] = result_segment[ pos ];
+               }
+            }
+         }
+
+         result_native[ left_row * right_cols + right_col ] = 0;
+         temp = &result_native[ left_row * right_cols + right_col ];
+         for ( common = 0; common < left_cols; ++common )
+         {
+            (*temp) += partial_native[ common ];
+         }
+      }
+   }
+
+   result = rb_ary_new2( result_length );
+   for ( pos = 0; pos < result_length; ++pos )
+   {
+      rb_ary_push( result, INT2NUM( result_native[ pos ] ) );
+   }
+
+   free( left_native );
+   free( right_native );
+   free( result_native );
+   free( partial_native );
+
+   return result;
+}
+
+VALUE method_mat_mul_s64( VALUE self, VALUE left, VALUE left_rows_rb, VALUE left_cols_rb, VALUE right, VALUE right_rows_rb, VALUE right_cols_rb )
+{
+   uint32_t left_row = 0;
+   uint32_t right_col = 0;
+   uint32_t common = 0;
+   uint32_t vector_pos = 0;
+   uint32_t input_index = 0;
+   uint32_t pos = 0;
+
+   int64_t left_segment[ SSE_VECTOR_WIDTH ];
+   int64_t right_segment[ SSE_VECTOR_WIDTH ];
+
+   __m128i* left_vec = NULL;
+   __m128i* right_vec = NULL;
+   __m128i result_vec;
+
+   VALUE result = Qnil;
+
+   int64_t* result_native = NULL;
+
+   uint32_t left_rows = NUM2INT( left_rows_rb );
+   uint32_t left_cols = NUM2INT( left_cols_rb );
+   uint32_t right_rows = NUM2INT( right_rows_rb );
+   uint32_t right_cols = NUM2INT( right_cols_rb );
+
+   uint32_t left_length = left_rows * left_cols;
+   uint32_t right_length = right_rows * right_cols;
+   uint32_t result_length = left_rows * right_cols;
+
+   int64_t* left_native = NULL;
+   int64_t* right_native = NULL;
+   int64_t* partial_native = NULL;
+   int64_t* temp = NULL;
+
+
+   left_native  = (int64_t*) malloc( left_length * sizeof(int64_t) );
+   right_native = (int64_t*) malloc( right_length * sizeof(int64_t) );
+   result_native = (int64_t*) malloc( result_length * sizeof(int64_t) );
+   partial_native = (int64_t*) malloc( left_cols * sizeof(int64_t) );
+
+   memset(partial_native,0,left_cols*sizeof(int64_t) );
+
+   for ( pos = 0; pos < left_length; ++pos )
+   {
+      left_native[ pos ] = NUM2LL( rb_ary_entry( left, pos ) );
+   }
+   for ( pos = 0; pos < right_length; ++pos )
+   {
+      right_native[ pos ] = NUM2LL( rb_ary_entry( right, pos ) );
+   }
+
+   for ( left_row = 0; left_row < left_rows; ++left_row )
+   {
+      for ( right_col = 0; right_col < right_cols; ++right_col )
+      {
+         for ( common = 0; common < left_cols; ++common )
+         {
+            partial_native[ common ] =
+               left_native[ left_row * left_cols + common ] *
+               right_native[ common * right_cols + right_col ];
+         }
+
+         result_native[ left_row * right_cols + right_col ] = 0;
+         temp = &result_native[ left_row * right_cols + right_col ];
+         for ( common = 0; common < left_cols; ++common )
+         {
+            (*temp) += partial_native[ common ];
+         }
+      }
+   }
+
+   result = rb_ary_new2( result_length );
+   for ( pos = 0; pos < result_length; ++pos )
+   {
+      rb_ary_push( result, LL2NUM( result_native[ pos ] ) );
+   }
+
+   free( left_native );
+   free( right_native );
+   free( result_native );
+   free( partial_native );
+
+   return result;
+}
+
+VALUE method_mat_mul_f32( VALUE self, VALUE left, VALUE left_rows_rb, VALUE left_cols_rb, VALUE right, VALUE right_rows_rb, VALUE right_cols_rb )
+{
+   uint32_t left_row = 0;
+   uint32_t right_col = 0;
+   uint32_t common = 0;
+   uint32_t vector_pos = 0;
+   uint32_t input_index = 0;
+   uint32_t pos = 0;
+
+   float left_segment[ SSE_VECTOR_WIDTH ];
+   float right_segment[ SSE_VECTOR_WIDTH ];
+   float result_segment[ SSE_VECTOR_WIDTH ];
+
+   __m128i* left_vec = NULL;
+   __m128i* right_vec = NULL;
+   __m128i result_vec;
+
+   VALUE result = Qnil;
+
+   float* result_native = NULL;
+
+   uint32_t left_rows = NUM2UINT( left_rows_rb );
+   uint32_t left_cols = NUM2UINT( left_cols_rb );
+   uint32_t right_rows = NUM2UINT( right_rows_rb );
+   uint32_t right_cols = NUM2UINT( right_cols_rb );
+
+   uint32_t left_length = left_rows * left_cols;
+   uint32_t right_length = right_rows * right_cols;
+   uint32_t result_length = left_rows * right_cols;
+
+   float* left_native = NULL;
+   float* right_native = NULL;
+   float* partial_native = NULL;
+   float* temp = NULL;
+
+   left_native  = (float*) malloc( left_length * sizeof(float) );
+   right_native = (float*) malloc( right_length * sizeof(float) );
+   result_native = (float*) malloc( result_length * sizeof(float) );
+   partial_native = (float*) malloc( left_cols * sizeof(float) );
+
+   memset( partial_native, 0, left_cols * sizeof(float) );
+
+   for ( pos = 0; pos < left_length; ++pos )
+   {
+      left_native[ pos ] = NUM2DBL( rb_ary_entry( left, pos ) );
+   }
+   for ( pos = 0; pos < right_length; ++pos )
+   {
+      right_native[ pos ] = NUM2DBL( rb_ary_entry( right, pos ) );
+   }
+
+   for ( left_row = 0; left_row < left_rows; ++left_row )
+   {
+      for ( right_col = 0; right_col < right_cols; ++right_col )
+      {
+         for ( common = 0; common < left_cols; common += SSE_VECTOR_WIDTH )
+         {
+            for ( pos = 0; pos < SSE_VECTOR_WIDTH; ++pos )
+            {
+               input_index = common + pos;
+
+               if ( input_index < left_cols )
+               {
+                  left_segment[ pos ]  = left_native[ left_row * left_cols + input_index ];
+                  right_segment[ pos ] = right_native[ input_index * right_cols + right_col ];
+               }
+               else
+               {
+                  left_segment[ pos ]  = 0;
+                  right_segment[ pos ] = 0;
+               }
+            }
+
+            left_vec   = ( __m128i *)left_segment;
+            right_vec  = ( __m128i *)right_segment;
+            result_vec = _mm_mul_ps( *left_vec, *right_vec );
+
+            _mm_store_si128( (__m128i*)result_segment, result_vec );
+            for ( pos = 0; pos < SSE_VECTOR_WIDTH; ++pos )
+            {
+               if ( (common + pos) < left_cols )
+               {
+                  partial_native[ common + pos ] = result_segment[ pos ];
+               }
+            }
+         }
+
+         result_native[ left_row * right_cols + right_col ] = 0;
+         temp = &result_native[ left_row * right_cols + right_col ];
+         for ( common = 0; common < left_cols; ++common )
+         {
+            (*temp) += partial_native[ common ];
+         }
+      }
+   }
+
+   result = rb_ary_new2( result_length );
+   for ( pos = 0; pos < result_length; ++pos )
+   {
+      rb_ary_push( result, DBL2NUM( result_native[ pos ] ) );
+   }
+
+   free( left_native );
+   free( right_native );
+   free( result_native );
+   free( partial_native );
+
+   return result;
+}
+

data/ext/vector_sse/vector_sse_mul.h

@@ -0,0 +1,43 @@
+//
+// 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_MUL_H
+#define  VECTOR_SSE_MUL_H
+
+#include "ruby.h"
+
+VALUE method_mat_mul_s32( VALUE self, VALUE left, VALUE left_rows_rb, VALUE left_cols_rb, VALUE right, VALUE right_rows_rb, VALUE right_cols_rb );
+VALUE method_mat_mul_s64( VALUE self, VALUE left, VALUE left_rows_rb, VALUE left_cols_rb, VALUE right, VALUE right_rows_rb, VALUE right_cols_rb );
+VALUE method_mat_mul_f32( VALUE self, VALUE left, VALUE left_rows_rb, VALUE left_cols_rb, VALUE right, VALUE right_rows_rb, VALUE right_cols_rb );
+VALUE method_mat_mul_f64( VALUE self, VALUE left, VALUE left_rows_rb, VALUE left_cols_rb, VALUE right, VALUE right_rows_rb, VALUE right_cols_rb );
+
+#endif // VECTOR_SSE_MUL_H

data/ext/vector_sse/vector_sse_sum.c

@@ -0,0 +1,118 @@
+//
+// 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 <string.h>
+#include <emmintrin.h>
+#include "vector_sse_sum.h"
+
+#define  TEMPLATE_SUM_S( FUNC_NAME, TYPE, OFTYPE, TYPE_SIZE, CONV_IN, CONV_OUT, EL_PER_VEC, ADD ) \
+VALUE FUNC_NAME( VALUE self, VALUE vector ) \
+{ \
+   uint32_t length      = 0; \
+   uint32_t offset      = 0; \
+   uint32_t vector_pos  = 0; \
+   uint32_t input_index = 0; \
+\
+   TYPE  result = 0; \
+\
+   TYPE left_segment[ EL_PER_VEC ]; \
+   TYPE right_segment[ EL_PER_VEC ]; \
+   TYPE result_segment[ EL_PER_VEC ]; \
+   TYPE vector_segment[ EL_PER_VEC ]; \
+\
+   __m128i left_vec; \
+   __m128i right_vec; \
+   __m128i result_vec; \
+\
+   __m128i sign_left; \
+   __m128i sign_right; \
+   const OFTYPE OVERFLOW_MASK = ( (OFTYPE)0x1 << (TYPE_SIZE-1) ); \
+   OFTYPE overflow[ EL_PER_VEC ]; \
+   __m128i* overflow_vec = (__m128i*)overflow; \
+\
+   Check_Type( vector, T_ARRAY ); \
+\
+   length = RARRAY_LEN( vector ); \
+\
+   if ( length > 0 ) \
+   { \
+      memset( &result_vec, 0, sizeof( result_vec ) ); \
+\
+      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 ) \
+            { \
+               vector_segment[ vector_pos ] = CONV_IN( rb_ary_entry( vector, input_index ) ); \
+            } \
+            else \
+            { \
+               vector_segment[ vector_pos ] = 0; \
+            } \
+         } \
+\
+         right_vec = _mm_loadu_si128( (const __m128i *)vector_segment ); \
+         left_vec  = _mm_loadu_si128( &result_vec ); \
+\
+         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 ( ( (OFTYPE)overflow[ vector_pos ] & OVERFLOW_MASK ) ) \
+            { \
+               rb_raise( rb_eRuntimeError, "Vector addition overflow" ); \
+            } \
+         } \
+      } \
+\
+      _mm_store_si128( (__m128i*)result_segment, result_vec ); \
+\
+      for ( vector_pos = 0; vector_pos < EL_PER_VEC; ++vector_pos ) \
+      { \
+         result += result_segment[ vector_pos ]; \
+      } \
+   } \
+\
+   return CONV_OUT( result ); \
+}
+
+TEMPLATE_SUM_S( method_vec_sum_s32, int32_t, int32_t, 32, NUM2INT, INT2NUM, 4, _mm_add_epi32 );
+TEMPLATE_SUM_S( method_vec_sum_s64, int64_t, int64_t, 64, NUM2LL, LL2NUM, 2, _mm_add_epi64 );
+TEMPLATE_SUM_S( method_vec_sum_f32, float, int32_t, 32, NUM2DBL, DBL2NUM, 4, _mm_add_ps );
+TEMPLATE_SUM_S( method_vec_sum_f64, double, int64_t, 32, NUM2DBL, DBL2NUM, 2, _mm_add_pd );
+

data/ext/vector_sse/vector_sse_sum.h

@@ -0,0 +1,43 @@
+//
+// 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_SUM_H
+#define  VECTOR_SSE_SUM_H
+
+#include "ruby.h"
+
+VALUE method_vec_sum_s32( VALUE self, VALUE vector );
+VALUE method_vec_sum_s64( VALUE self, VALUE vector );
+VALUE method_vec_sum_f32( VALUE self, VALUE vector );
+VALUE method_vec_sum_f64( VALUE self, VALUE vector );
+
+#endif // VECTOR_SSE_SUM_H

data/ext/vector_sse/vector_sse_vec_mul.c

@@ -0,0 +1,157 @@
+//
+// 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 <string.h>
+#include <emmintrin.h>
+#ifdef __SSE4_1__  // modern CPU - use SSE 4.1
+#include <smmintrin.h>
+#endif
+#include "vector_sse_vec_mul.h"
+
+#define  SSE_VECTOR_WIDTH    (4)
+// #define  EL_PER_VEC    SSE_VECTOR_WIDTH
+
+static inline __m128i mul_s32( const __m128i* a, const __m128i* b )
+{
+#ifdef __SSE4_1__
+    return _mm_mullo_epi32(*a, *b);
+#else               // old CPU - use SSE 2
+    __m128i tmp1 = _mm_mul_epu32(*a,*b); /* mul 2,0*/
+    __m128i tmp2 = _mm_mul_epu32( _mm_srli_si128(*a,4), _mm_srli_si128(*b,4)); /* mul 3,1 */
+    return _mm_unpacklo_epi32(_mm_shuffle_epi32(tmp1, _MM_SHUFFLE (0,0,2,0)), _mm_shuffle_epi32(tmp2, _MM_SHUFFLE (0,0,2,0))); /* shuffle results to [63..0] and pack */
+#endif
+}
+
+static inline __m128i mul_s64( const __m128i* left_vec, const __m128i* right_vec  )
+{
+   // a * b = ( a0 * S + a1 ) * ( b0 * S + b1 )
+   //       = a0 * b0 * S^2 + ( a0 * b1 + a1 * b0 ) * S + a1 * b1
+
+   int64_t left[ 2 ];
+   int64_t right[ 2 ];
+   int64_t result[ 2 ];
+   _mm_store_si128( (__m128i*)left, *left_vec );
+   _mm_store_si128( (__m128i*)right, *right_vec );
+   result[0] = left[0] * right[1];
+   result[1] = left[1] * right[1];
+   return _mm_loadu_si128( (const __m128i *)result );
+}
+
+static inline __m128i mul_f32(const __m128i* a, const __m128i* b )
+{
+   return _mm_mul_ps( *a, *b );
+}
+
+static inline __m128i mul_f64(const __m128i* a, const __m128i* b )
+{
+   return _mm_mul_pd( *a, *b );
+}
+
+
+#define  TEMPLATE_VEC_MUL_S( FUNC_NAME, TYPE, TYPE_SIZE, CONV_IN, CONV_OUT, EL_PER_VEC, MULOP ) \
+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; \
+\
+   VALUE  result = Qnil; \
+\
+   TYPE left_segment[ EL_PER_VEC ];  \
+   TYPE right_segment[ EL_PER_VEC ]; \
+\
+   __m128i left_vec;  \
+   __m128i right_vec; \
+\
+   TYPE result_segment[ EL_PER_VEC ]; \
+   __m128i result_vec; \
+\
+   __m128i sign_left;  \
+   __m128i sign_right; \
+\
+   Check_Type( left, T_ARRAY );  \
+   Check_Type( right, T_ARRAY ); \
+\
+   length = RARRAY_LEN( left );    \
+   result = rb_ary_new2( length ); \
+\
+   if ( length > 0 ) \
+   { \
+      memset( &result_vec, 0, sizeof( result_vec ) ); \
+\
+      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 = MULOP( &left_vec, &right_vec ); \
+\
+         _mm_store_si128( (__m128i*)result_segment, result_vec ); \
+\
+         for ( vector_pos = 0; vector_pos < EL_PER_VEC; ++vector_pos ) \
+         { \
+            input_index = offset + vector_pos; \
+\
+            if ( input_index < length ) \
+            { \
+               rb_ary_push( result, CONV_OUT( result_segment[ vector_pos ] ) ); \
+            } \
+         } \
+      } \
+   } \
+\
+   return result; \
+}
+
+
+TEMPLATE_VEC_MUL_S( method_vec_mul_s32, int32_t, 32, NUM2INT, INT2NUM, 4, mul_s32 );
+TEMPLATE_VEC_MUL_S( method_vec_mul_s64, int64_t, 64, NUM2LL, LL2NUM, 2, mul_s64 );
+TEMPLATE_VEC_MUL_S( method_vec_mul_f32, float, 32, NUM2DBL, DBL2NUM, 4, mul_f32 );
+TEMPLATE_VEC_MUL_S( method_vec_mul_f64, double, 64, NUM2DBL, DBL2NUM, 2, mul_f64 );
+