simd 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3acc0dcd98951246c84b35036f47dedd69d798cb
-  data.tar.gz: 323dbca8597e5993d0bd48ebb8805febdf064c47
+  metadata.gz: e2917ec7ede39c14aaac0a85f4e0c6cd6cf204cd
+  data.tar.gz: 8bf4b61b6337ba5e5d833797dcffec0e2de32480
 SHA512:
-  metadata.gz: e05f61501a47ad89bf55a6a25fcda70add8aa004701336e0543c4421ca0b4a9628aab30281e0aa9c30bb79a994fad2152c7da853dc6989adea400a79c9ada05c
-  data.tar.gz: 45f06b3ead4a140d992f34c2135724f649143e58035945e9e8f8de9e0595b8fda54538cab233a494ddcb0eb1e6e1a6d0f5948084b6e29e91d461c34d901eb8ef
+  metadata.gz: e7ffa5a5ca85d1affc0326871517ba1dfde05d46544c0c8d803edf307d10ffe87dfdd8f78bbfd74b672f488d266037718dfd0c7d59b96967cb69ab3d8943b64e
+  data.tar.gz: 69a5db3a4baf9fa3b68ff13a7d418337b20a237b150253d2cfd09421b8f63f2a11a50f51cd86d5412ab5a71bc46841143132cbe6af74f31d618408b9b1040d03

data/ext/simd/simd.c

@@ -6,4 +6,5 @@ void Init_simd()
 	SIMD = rb_define_module("SIMD");
 	Init_SIMD_FloatArray(SIMD);
 	Init_SIMD_SmallFloatArray(SIMD);
+	Init_SIMD_IntArray(SIMD);
 }

data/ext/simd/simd.h

@@ -3,3 +3,4 @@
 void Init_simd();
 void Init_SIMD_FloatArray(VALUE parent);
 void Init_SIMD_SmallFloatArray(VALUE parent);
+void Init_SIMD_IntArray(VALUE parent);

data/ext/simd/simd_floatarray.c

@@ -129,45 +129,50 @@ static VALUE internal_apply_operation(VALUE self, VALUE obj, b_operation func)
 		case 0: /* Same size arrays */
 			for(i = 0; i < size; i++)
 			{
-				r[i].v = func(d1[i].v, d2[i].v);
+				func(&d1[i].v, &d2[i].v, &r[i].v);
 			}
 			break;
 		case 1: /* Operand is exactly 2 long (size of 1 sse register) */
 			for(i = 0; i < size; i++)
 			{
-				r[i].v = func(d1[i].v, d2[0].v);
+				func(&d1[i].v, &d2[0].v, &r[i].v);
 			}
 			break;
 		default: /* Self is a multiple of operand's length long */
 			for(i = 0; i < size; i++)
 			{
-				r[i].v = func(d1[i].v, d2[i % v2->len].v);
+				func(&d1[i].v, &d2[i % v2->len].v, &r[i].v);
 			}
 	}
 
+	if(rv->len != rv->len + (rv->len % 2))
+	{
+		r[size].f[1] = 1;
+	}
+
 	return(result_obj);
 }
 
 /* Function: Multiply two vectors. */
-static d2v func_multiply(d2v v1, d2v v2)
+static void func_multiply(void *v1, void *v2, void *r)
 {
-	return(v1 * v2);
+	*(d2v *)r = *(d2v *)v1 * *(d2v *)v2;
 }
 
 /* Function: Divide two vectors. */
-static d2v func_divide(d2v v1, d2v v2)
+static void func_divide(void *v1, void *v2, void *r)
 {
-	return(v1 / v2);
+	*(d2v *)r = *(d2v *)v1 / *(d2v *)v2;
 }
 
 /* Function: Add two vectors. */
-static d2v func_add(d2v v1, d2v v2)
+static void func_add(void *v1, void *v2, void *r)
 {
-	return(v1 + v2);
+	*(d2v *)r = *(d2v *)v1 + *(d2v *)v2;
 }
 
 /* Function: Subtract two vectors. */
-static d2v func_subtract(d2v v1, d2v v2)
+static void func_subtract(void *v1, void *v2, void *r)
 {
-	return(v1 - v2);
+	*(d2v *)r = *(d2v *)v1 - *(d2v *)v2;
 }

data/ext/simd/simd_floatarray.h

@@ -1,11 +1,6 @@
 #include "ruby.h"
 #include "simd_common.h"
 
-/*
-static VALUE allocate(VALUE klass);
-static void deallocate(d2v_container *floatarray);
-*/
-
 static VALUE method_initialize(VALUE self, VALUE rb_array);
 static VALUE method_multiply(VALUE self, VALUE obj);
 static VALUE method_divide(VALUE self, VALUE obj);
@@ -13,13 +8,9 @@ static VALUE method_add(VALUE self, VALUE obj);
 static VALUE method_subtract(VALUE self, VALUE obj);
 static VALUE method_to_a(VALUE self);
 
-/*
-static d2v_t *internal_allocate_vector_array(unsigned long size);
-static int internal_align_vectors(unsigned long v1, unsigned long v2);
-*/
 static VALUE internal_apply_operation(VALUE self, VALUE obj, b_operation func);
 
-static d2v func_multiply(d2v v1, d2v v2);
-static d2v func_divide(d2v v1, d2v v2);
-static d2v func_add(d2v v1, d2v v2);
-static d2v func_subtract(d2v v1, d2v v2);
+static void func_multiply(void *v1, void *v2, void *r);
+static void func_divide(void *v1, void *v2, void *r);
+static void func_add(void *v1, void *v2, void *r);
+static void func_subtract(void *v1, void *v2, void *r);

data/ext/simd/simd_intarray.c

@@ -0,0 +1,181 @@
+#include "simd_intarray.h"
+
+VALUE SIMD_IntArray = Qnil;
+
+/* Internal: Create the SIMD::FloatArray class. */
+void Init_SIMD_IntArray(VALUE parent)
+{
+	SIMD_IntArray = rb_define_class_under(parent, "IntArray", rb_cObject);
+	rb_define_alloc_func(SIMD_IntArray, allocate);
+	rb_define_method(SIMD_IntArray, "initialize", method_initialize, 1);
+	rb_define_method(SIMD_IntArray, "*", method_multiply, 1);
+	rb_define_method(SIMD_IntArray, "/", method_divide, 1);
+	rb_define_method(SIMD_IntArray, "+", method_add, 1);
+	rb_define_method(SIMD_IntArray, "-", method_subtract, 1);
+	rb_define_method(SIMD_IntArray, "length", method_length, 0);
+	rb_define_method(SIMD_IntArray, "to_a", method_to_a, 0);
+}
+
+/* Public: Initialize the FloatArray object given a Ruby Array of values
+ * which can be cast to a double. */
+static VALUE method_initialize(VALUE self, VALUE rb_array)
+{
+	vector_t *vector;
+	i4v_t *data;
+	unsigned long n,m,i;
+
+	Check_Type(rb_array, T_ARRAY);
+	Data_Get_Struct(self, vector_t, vector);
+
+	vector->len = n = RARRAY_LEN(rb_array);
+
+	if(vector->len < 4)
+	{
+		rb_raise(rb_eArgError, "Vectors must be at least 4 long");
+	}
+
+	vector->data = internal_allocate_vector_array(vector->len, sizeof(i4v_t));
+
+	data = (i4v_t *)vector->data;
+	for(i = 0; i < vector->len; i++)
+	{
+		data[i/4].f[i%4] = NUM2INT(rb_ary_entry(rb_array, i));
+	}
+
+	/* If the array is an odd number of elements, set the final element to 1 */
+	m = n + (n % 4);
+	for(i = n % 4; i > 0; i--)
+	{
+		data[m/4].f[i] = 1.0;
+	}
+
+	return(self);
+}
+
+/* Public: Multiply values contained in the data array with those contained in
+ * another FloatArray object, returning a new FloatArray. */
+static VALUE method_multiply(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, func_multiply));
+}
+
+/* Public: Divide values contained in the data array by those contained in
+ * another FloatArray object, returning a new FloatArray. */
+static VALUE method_divide(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, func_divide));
+}
+
+/* Public: add values contained in the data array with those contained in
+ * another FloatArray object, returning a new FloatArray. */
+static VALUE method_add(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, func_add));
+}
+
+/* Public: Subtract values contained in another FloatArray object from those
+ * contained in the current data array object, returning a new FloatArray. */
+static VALUE method_subtract(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, func_subtract));
+}
+
+/* Public: Return a Ruby Array containing the doubles within the data array. */
+static VALUE method_to_a(VALUE self)
+{
+	unsigned long i;
+	vector_t *vector;
+	i4v_t *data;
+	VALUE rb_array = rb_ary_new();
+
+	Data_Get_Struct(self, vector_t, vector);
+	data = (i4v_t *)vector->data;
+	for(i = 0; i < vector->len; i++)
+	{
+		rb_ary_store(rb_array, i, INT2NUM(data[i/4].f[i%4]));
+	}
+
+	return(rb_array);
+}
+
+/* Internal: Given another FloatArray object, perform an action specified via a
+ * function pointer against both. */
+static VALUE internal_apply_operation(VALUE self, VALUE obj, b_operation func)
+{
+	unsigned long size, i;
+	int align;
+	vector_t *v1, *v2, *rv;
+	i4v_t *d1, *d2, *r;
+	VALUE result_obj = allocate(SIMD_IntArray);
+
+	Data_Get_Struct(self, vector_t, v1);
+	Data_Get_Struct(obj, vector_t, v2);
+	Data_Get_Struct(result_obj, vector_t, rv);
+	rv->data = internal_allocate_vector_array(v1->len, sizeof(i4v_t));
+
+	align = internal_align_vectors(v1->len, v2->len, 4);
+
+	/* Ensure that size will be the result of ceil(len / 4.0) */
+	size = (v1->len + 3) / 4;
+
+	d1 = (i4v_t *)v1->data;
+	d2 = (i4v_t *)v2->data;
+	r  = (i4v_t *)rv->data;
+
+	rv->len = v1->len;
+
+	switch(align)
+	{
+		case 0: /* Same size arrays */
+			for(i = 0; i < size; i++)
+			{
+				func(&d1[i].v, &d2[i].v, &r[i].v);
+			}
+			break;
+		case 1: /* Operand is exactly 4 long (size of 1 sse register) */
+			for(i = 0; i < size; i++)
+			{
+				func(&d1[i].v, &d2[0].v, &r[i].v);
+			}
+			break;
+		default: /* Self is a multiple of operand's length long */
+			for(i = 0; i < size; i++)
+			{
+				func(&d1[i].v, &d2[i % v2->len].v, &r[i].v);
+			}
+	}
+
+	if(rv->len != rv->len + (rv->len % 4))
+	{
+		for(i = 3; i > rv->len + (rv->len % 4); i--)
+		{
+			r[size].f[i] = 1;
+		}
+	}
+
+	return(result_obj);
+}
+
+/* Function: Multiply two vectors. */
+static void func_multiply(void *v1, void *v2, void *r)
+{
+	*(i4v *)r = *(i4v *)v1 * *(i4v *)v2;
+}
+
+/* Function: Divide two vectors. */
+static void func_divide(void *v1, void *v2, void *r)
+{
+	*(i4v *)r = *(i4v *)v1 / *(i4v *)v2;
+}
+
+/* Function: Add two vectors. */
+static void func_add(void *v1, void *v2, void *r)
+{
+	*(i4v *)r = *(i4v *)v1 + *(i4v *)v2;
+}
+
+/* Function: Subtract two vectors. */
+static void func_subtract(void *v1, void *v2, void *r)
+{
+	*(i4v *)r = *(i4v *)v1 - *(i4v *)v2;
+}

data/ext/simd/simd_intarray.h

@@ -0,0 +1,16 @@
+#include "ruby.h"
+#include "simd_common.h"
+
+static VALUE method_initialize(VALUE self, VALUE rb_array);
+static VALUE method_multiply(VALUE self, VALUE obj);
+static VALUE method_divide(VALUE self, VALUE obj);
+static VALUE method_add(VALUE self, VALUE obj);
+static VALUE method_subtract(VALUE self, VALUE obj);
+static VALUE method_to_a(VALUE self);
+
+static VALUE internal_apply_operation(VALUE self, VALUE obj, b_operation func);
+
+static void func_multiply(void *v1, void *v2, void *r);
+static void func_divide(void *v1, void *v2, void *r);
+static void func_add(void *v1, void *v2, void *r);
+static void func_subtract(void *v1, void *v2, void *r);

data/ext/simd/simd_smallfloatarray.c

@@ -100,7 +100,7 @@ static VALUE method_to_a(VALUE self)
 
 /* Internal: Given another FloatArray object, perform an action specified via a
  * function pointer against both. */
-static VALUE internal_apply_operation(VALUE self, VALUE obj, bf_operation func)
+static VALUE internal_apply_operation(VALUE self, VALUE obj, b_operation func)
 {
 	unsigned long size, i;
 	int align;
@@ -129,45 +129,53 @@ static VALUE internal_apply_operation(VALUE self, VALUE obj, bf_operation func)
 		case 0: /* Same size arrays */
 			for(i = 0; i < size; i++)
 			{
-				r[i].v = func(d1[i].v, d2[i].v);
+				func(&d1[i].v, &d2[i].v, &r[i].v);
 			}
 			break;
 		case 1: /* Operand is exactly 4 long (size of 1 sse register) */
 			for(i = 0; i < size; i++)
 			{
-				r[i].v = func(d1[i].v, d2[0].v);
+				func(&d1[i].v, &d2[0].v, &r[i].v);
 			}
 			break;
 		default: /* Self is a multiple of operand's length long */
 			for(i = 0; i < size; i++)
 			{
-				r[i].v = func(d1[i].v, d2[i % v2->len].v);
+				func(&d1[i].v, &d2[i % v2->len].v, &r[i].v);
 			}
 	}
 
+	if(rv->len != rv->len + (rv->len % 4))
+	{
+		for(i = 3; i > rv->len + (rv->len % 4); i--)
+		{
+			r[size].f[i] = 1;
+		}
+	}
+
 	return(result_obj);
 }
 
 /* Function: Multiply two vectors. */
-static f4v func_multiply(f4v v1, f4v v2)
+static void func_multiply(void *v1, void *v2, void *r)
 {
-	return(v1 * v2);
+	*(f4v *)r = *(f4v *)v1 * *(f4v *)v2;
 }
 
 /* Function: Divide two vectors. */
-static f4v func_divide(f4v v1, f4v v2)
+static void func_divide(void *v1, void *v2, void *r)
 {
-	return(v1 / v2);
+	*(f4v *)r = *(f4v *)v1 / *(f4v *)v2;
 }
 
 /* Function: Add two vectors. */
-static f4v func_add(f4v v1, f4v v2)
+static void func_add(void *v1, void *v2, void *r)
 {
-	return(v1 + v2);
+	*(f4v *)r = *(f4v *)v1 + *(f4v *)v2;
 }
 
 /* Function: Subtract two vectors. */
-static f4v func_subtract(f4v v1, f4v v2)
+static void func_subtract(void *v1, void *v2, void *r)
 {
-	return(v1 - v2);
+	*(f4v *)r = *(f4v *)v1 - *(f4v *)v2;
 }

data/ext/simd/simd_smallfloatarray.h

@@ -1,11 +1,6 @@
 #include "ruby.h"
 #include "simd_common.h"
 
-/*
-static VALUE allocate(VALUE klass);
-static void deallocate(vector_t *vector);
-*/
-
 static VALUE method_initialize(VALUE self, VALUE rb_array);
 static VALUE method_multiply(VALUE self, VALUE obj);
 static VALUE method_divide(VALUE self, VALUE obj);
@@ -13,13 +8,9 @@ static VALUE method_add(VALUE self, VALUE obj);
 static VALUE method_subtract(VALUE self, VALUE obj);
 static VALUE method_to_a(VALUE self);
 
-/*
-static f4v_t *internal_allocate_vector_array(unsigned long size);
-static int internal_align_vectors(unsigned long v1, unsigned long v2);
-*/
-static VALUE internal_apply_operation(VALUE self, VALUE obj, bf_operation func);
+static VALUE internal_apply_operation(VALUE self, VALUE obj, b_operation func);
 
-static f4v func_multiply(f4v v1, f4v v2);
-static f4v func_divide(f4v v1, f4v v2);
-static f4v func_add(f4v v1, f4v v2);
-static f4v func_subtract(f4v v1, f4v v2);
+static void func_multiply(void *v1, void *v2, void *r);
+static void func_divide(void *v1, void *v2, void *r);
+static void func_add(void *v1, void *v2, void *r);
+static void func_subtract(void *v1, void *v2, void *r);

data/ext/simd/simd_types.h

@@ -1,6 +1,6 @@
 #pragma once
 
-/* 
+/*
  * Types for FloatArray
  *
  * Since ruby internally uses doubles for the Float type, SIMD::FloatArray will
@@ -13,7 +13,7 @@ typedef union d2v_t
 	double f[2];
 } d2v_t;
 
-/* 
+/*
  * Types for SmallFloatArray
  *
  * Since ruby internally uses doubles for the Float type, SIMD::SmallFloatArray
@@ -27,11 +27,20 @@ typedef union f4v_t
 	float f[4];
 } f4v_t;
 
+/*
+ * Types for IntArray
+ */
+typedef int __attribute__ ((vector_size (16))) i4v;
+typedef union i4v_t
+{
+	i4v v;
+	int f[4];
+} i4v_t;
+
 typedef struct vector_t
 {
 	void *data;
 	unsigned long len;
 } vector_t;
 
-typedef d2v (*b_operation)(d2v v1, d2v v2);
-typedef f4v (*bf_operation)(f4v v1, f4v v2);
+typedef void (b_operation)(void *v1, void *v2, void *r);

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simd
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Tina Wuest
@@ -38,6 +38,8 @@ files:
 - ext/simd/simd_common.h
 - ext/simd/simd_floatarray.c
 - ext/simd/simd_floatarray.h
+- ext/simd/simd_intarray.c
+- ext/simd/simd_intarray.h
 - ext/simd/simd_smallfloatarray.c
 - ext/simd/simd_smallfloatarray.h
 - ext/simd/simd_types.h