simd 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 11df730f8e1819314d0c0cdf188b24a01e0939cf
-  data.tar.gz: 35be81c3b191dc4b12d587145535813aef3c2e5b
+  metadata.gz: 8f0bff704f3580fee55205c32ada6a1844dde4ae
+  data.tar.gz: 9e4f9d097fa20a349b77279535d39ea695a881a4
 SHA512:
-  metadata.gz: 1d02246e5e09becf5f301803cc97a6756a93ae8d6d7858b0218adca7d688573892bbd7e83325c277dee65663e5168f570d8f220d75fa7c81098a8b9d490b8370
-  data.tar.gz: bdd5f50f1e590f839a3067761ad0c865b831e3e97002f2155168f943e9b1258e5f0cc95e6b9481074954865e09c99e2e28ceaeb19480184e4ddf4b9a58b406db
+  metadata.gz: ccaa110b5ff7708c5e14dd5355f4361544832b412c2d150e9849f8106c55e1183252cbe540163941b65968037369b8618b5e66c9267e75807553aa2e7e8ccda5
+  data.tar.gz: e107fe3e242f6baa6d93ab6edf2886f58499d70fd690f6f1c72d7bff165932ce953026d480b0ac3a41c5e35d1ec4dc8b96c19d38d19857f0fdc8c7e759c3fa44

data/ext/simd/simd_floatarray.c

@@ -2,87 +2,123 @@
 
 VALUE SIMD_FloatArray = Qnil;
 
+/* Internal: Create the SIMD::FloatArray class. */
 void Init_SIMD_FloatArray(VALUE parent)
 {
 	SIMD_FloatArray = rb_define_class_under(parent, "FloatArray", rb_cObject);
 	rb_define_alloc_func(SIMD_FloatArray, allocate);
 	rb_define_method(SIMD_FloatArray, "initialize", method_initialize, 1);
 	rb_define_method(SIMD_FloatArray, "*", method_multiply, 1);
+	rb_define_method(SIMD_FloatArray, "/", method_divide, 1);
+	rb_define_method(SIMD_FloatArray, "+", method_add, 1);
+	rb_define_method(SIMD_FloatArray, "-", method_subtract, 1);
 	rb_define_method(SIMD_FloatArray, "length", method_length, 0);
 	rb_define_method(SIMD_FloatArray, "to_a", method_to_a, 0);
 }
 
+/* Internal: Allocate memory for the vector container. */
 static VALUE allocate(VALUE klass)
 {
-	double_vector_wrapper *vector = malloc(sizeof(double_vector_wrapper));
-	vector->data = NULL;
+	d2v_container *vector = malloc(sizeof(d2v_container));
+	if(vector == NULL)
+	{
+		rb_raise(rb_eNoMemError, "Unable to allocate memory");
+	}
 
+	vector->data = NULL; /* Avoid potentially freeing unitialized memory. */
 	return(Data_Wrap_Struct(klass, NULL, deallocate, vector));
 }
 
-static void deallocate(double_vector_wrapper *vector)
+/* Internal: Free memory from the vector container and the data array. */
+static void deallocate(d2v_container *vector)
 {
-	free(vector);
+	if(vector)
+	{
+		if(vector->data)
+		{
+			free(vector->data);
+		}
+		free(vector);
+	}
 }
 
+/* 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)
 {
-	double_vector_wrapper *vector;
-	long n,m,i;
+	d2v_container *vector;
+	unsigned long n,m,i;
 
 	Check_Type(rb_array, T_ARRAY);
+	Data_Get_Struct(self, d2v_container, vector);
 
-	Data_Get_Struct(self, double_vector_wrapper, vector);
 	vector->len = n = RARRAY_LEN(rb_array);
-	m = n + (n % 2);
-	vector->data = malloc(((m / 2) * sizeof(d2v_t)));
+
+	if(vector->len < 2)
+	{
+		rb_raise(rb_eArgError, "Vectors must be at least 2 long");
+	}
+
+	vector->data = internal_allocate_vector_array(vector->len);
 
 	for(i = 0; i < n; i++)
 		vector->data[i/2].f[i%2] = NUM2DBL(rb_ary_entry(rb_array, i));
 
+	/* If the array is an odd number of elements, set the final element to 1 */
+	m = n + (n % 2);
 	if(n < m)
+	{
 		vector->data[m/2].f[1] = 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)
 {
-	long size, i;
-	double_vector_wrapper *vector, *vector2, *result;
-
-	Data_Get_Struct(self, double_vector_wrapper, vector);
-	Data_Get_Struct(obj, double_vector_wrapper, vector2);
-
-	if(vector->len != vector2->len && vector2->len != 2)
-		rb_raise(rb_eArgError, "Vectors must be the same size, or 2.");
+	return(internal_apply_operation(self, obj, func_multiply));
+}
 
-	size = vector->len + (vector->len % 2);
-	result = malloc(sizeof(double_vector_wrapper));
-	result->data = malloc(size * sizeof(d2v_t));
-	result->len = vector->len;
+/* 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));
+}
 
-	for(i = 0; i < size / 2; i++)
-		result->data[i].v = vector->data[i].v * vector2->data[i].v;
+/* 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));
+}
 
-	return(Data_Wrap_Struct(SIMD_FloatArray, NULL, deallocate, result));
+/* 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 the number of elements in the Array. */
 static VALUE method_length(VALUE self)
 {
-	double_vector_wrapper *vector;
-	Data_Get_Struct(self, double_vector_wrapper, vector);
+	d2v_container *vector;
+	Data_Get_Struct(self, d2v_container, vector);
 
 	return(INT2NUM(vector->len));
 }
 
+/* Public: Return a Ruby Array containing the doubles within the data array. */
 static VALUE method_to_a(VALUE self)
 {
-	long i;
-	double_vector_wrapper *vector;
+	unsigned long i;
+	d2v_container *vector;
 	VALUE rb_array = rb_ary_new();
 
-	Data_Get_Struct(self, double_vector_wrapper, vector);
+	Data_Get_Struct(self, d2v_container, vector);
 	for(i = 0; i < vector->len; i++)
 	{
 		rb_ary_store(rb_array, i, DBL2NUM(vector->data[i/2].f[i%2]));
@@ -90,3 +126,110 @@ static VALUE method_to_a(VALUE self)
 
 	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;
+	d2v_container *v1, *v2, *r;
+	VALUE result_obj = allocate(SIMD_FloatArray);
+
+	Data_Get_Struct(self, d2v_container, v1);
+	Data_Get_Struct(obj, d2v_container, v2);
+	Data_Get_Struct(result_obj, d2v_container, r);
+
+	align = internal_align_vectors(v1->len, v2->len);
+
+	/* Ensure that size will be the result of ceil(len / 2.0) */
+	size = (v1->len + 1) / 2;
+	r->data = internal_allocate_vector_array(v1->len);
+	r->len = v1->len;
+
+	switch(align)
+	{
+		case 0: /* Same size arrays */
+			for(i = 0; i < size; i++)
+			{
+				r->data[i].v = func(v1->data[i].v, v2->data[i].v);
+			}
+			break;
+		case 1: /* Operand is exactly 2 long (size of 1 sse register) */
+			for(i = 0; i < size; i++)
+			{
+				r->data[i].v = func(v1->data[i].v, v2->data[0].v);
+			}
+			break;
+		default: /* Self is a multiple of operand's length long */
+			for(i = 0; i < size; i++)
+			{
+				r->data[i].v = func(v1->data[i].v, v2->data[i % v2->len].v);
+			}
+	}
+
+	return(result_obj);
+}
+
+/* Internal: Allocate memory for the data array. */
+static d2v_t *internal_allocate_vector_array(unsigned long size)
+{
+	d2v_t *vector = malloc(((size + (size % 2)) / 2 + 1) * sizeof(d2v_t));
+	if(vector == NULL)
+	{
+		rb_raise(rb_eNoMemError, "Unable to allocate memory");
+	}
+
+	return(vector);
+}
+
+/* Internal: Determine if two arrays can be acted upon, by being of equal
+ * lengths or with the operand's length being a multiple of the data array's. */
+static int internal_align_vectors(unsigned long v1, unsigned long v2)
+{
+	if((v1 % 2) != (v2 % 2))
+	{
+		rb_raise(rb_eArgError, "Both Vectors must be of even or odd length.");
+	}
+
+	if(v1 == v2)
+	{
+		return(0);
+	}
+	if(v2 == 2)
+	{
+		return(1);
+	}
+	if(v1 % v2 == 0)
+	{
+		return(2);
+	}
+
+	rb_raise(rb_eArgError, "Vector length must be evenly divisible by operand.");
+	/* Never reached */
+	return(-1);
+}
+
+/* Function: Multiply two vectors. */
+static d2v func_multiply(d2v v1, d2v v2)
+{
+	return(v1 * v2);
+}
+
+/* Function: Divide two vectors. */
+static d2v func_divide(d2v v1, d2v v2)
+{
+	return(v1 / v2);
+}
+
+/* Function: Add two vectors. */
+static d2v func_add(d2v v1, d2v v2)
+{
+	return(v1 + v2);
+}
+
+/* Function: Subtract two vectors. */
+static d2v func_subtract(d2v v1, d2v v2)
+{
+	return(v1 - v2);
+}

data/ext/simd/simd_floatarray.h

@@ -1,22 +1,22 @@
 #include "ruby.h"
-
-typedef double __attribute__ ((vector_size (16))) v2d;
-typedef union d2v_t
-{
-	v2d v;
-	double f[2];
-} d2v_t;
-
-typedef struct double_vector_wrapper
-{
-	d2v_t *data;
-	long len;
-} double_vector_wrapper;
+#include "simd_types.h"
 
 static VALUE allocate(VALUE klass);
-static void deallocate(double_vector_wrapper *floatarray);
+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);
+static VALUE method_add(VALUE self, VALUE obj);
+static VALUE method_subtract(VALUE self, VALUE obj);
 static VALUE method_length(VALUE self);
 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);

data/ext/simd/simd_types.h

@@ -0,0 +1,20 @@
+/* 
+ * Types for FloatArray
+ *
+ * Since ruby internally uses doubles for the Float type, SIMD::FloatArray will
+ * use packed double operations by default.
+ */
+typedef double __attribute__ ((vector_size (16))) d2v;
+typedef union d2v_t
+{
+	d2v v;
+	double f[2];
+} d2v_t;
+
+typedef struct d2v_container
+{
+	d2v_t *data;
+	unsigned long len;
+} d2v_container;
+
+typedef d2v (*b_operation)(d2v v1, d2v v2);

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simd
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Tina Wuest
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-09 00:00:00.000000000 Z
+date: 2014-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -36,6 +36,7 @@ files:
 - ext/simd/simd.h
 - ext/simd/simd_floatarray.c
 - ext/simd/simd_floatarray.h
+- ext/simd/simd_types.h
 homepage: https://gitlab.com/wuest/simd-ruby
 licenses: []
 metadata: {}