simd 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e2917ec7ede39c14aaac0a85f4e0c6cd6cf204cd
-  data.tar.gz: 8bf4b61b6337ba5e5d833797dcffec0e2de32480
+  metadata.gz: c15d248c872e4369c45e4151faf81e9761ea1587
+  data.tar.gz: cdfc5170454be15be1bc75ccc5eba08aa96c884d
 SHA512:
-  metadata.gz: e7ffa5a5ca85d1affc0326871517ba1dfde05d46544c0c8d803edf307d10ffe87dfdd8f78bbfd74b672f488d266037718dfd0c7d59b96967cb69ab3d8943b64e
-  data.tar.gz: 69a5db3a4baf9fa3b68ff13a7d418337b20a237b150253d2cfd09421b8f63f2a11a50f51cd86d5412ab5a71bc46841143132cbe6af74f31d618408b9b1040d03
+  metadata.gz: 38df7b30a113b325bba7be834fcbe24c44738706495579af5a9e4b508e4db4375e2f36b16a97612eab4dd8da379c450d062c6e0bceb6e8ddf308a952ecf6419c
+  data.tar.gz: 342680d7f4f6690c8b3338de32ef192aaadb2952461e62e86a848650414b09d793d71e70c5b38909e0c882f062e346995f86f40d3dbf1de692cbe3eb0cfb0c73

data/ext/simd/simd.c

@@ -7,4 +7,5 @@ void Init_simd()
 	Init_SIMD_FloatArray(SIMD);
 	Init_SIMD_SmallFloatArray(SIMD);
 	Init_SIMD_IntArray(SIMD);
+	Init_SIMD_LongArray(SIMD);
 }

data/ext/simd/simd.h

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

data/ext/simd/simd_intarray.c

@@ -12,6 +12,9 @@ void Init_SIMD_IntArray(VALUE parent)
 	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, "&", method_and, 1);
+	rb_define_method(SIMD_IntArray, "|", method_or, 1);
+	rb_define_method(SIMD_IntArray, "^", method_xor, 1);
 	rb_define_method(SIMD_IntArray, "length", method_length, 0);
 	rb_define_method(SIMD_IntArray, "to_a", method_to_a, 0);
 }
@@ -73,6 +76,27 @@ static VALUE method_add(VALUE self, VALUE obj)
 	return(internal_apply_operation(self, obj, func_add));
 }
 
+/* Public: and values contained in the data array with those contained in
+ * another FloatArray object, returning a new FloatArray. */
+static VALUE method_and(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, func_and));
+}
+
+/* Public: or values contained in the data array with those contained in
+ * another FloatArray object, returning a new FloatArray. */
+static VALUE method_or(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, func_or));
+}
+
+/* Public: xor values contained in the data array with those contained in
+ * another FloatArray object, returning a new FloatArray. */
+static VALUE method_xor(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, func_xor));
+}
+
 /* 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)
@@ -179,3 +203,21 @@ static void func_subtract(void *v1, void *v2, void *r)
 {
 	*(i4v *)r = *(i4v *)v1 - *(i4v *)v2;
 }
+
+/* Function: Perform a binary AND on two vectors. */
+static void func_and(void *v1, void *v2, void *r)
+{
+	*(i4v *)r = *(i4v *)v1 & *(i4v *)v2;
+}
+
+/* Function: Perform a binary OR on two vectors. */
+static void func_or(void *v1, void *v2, void *r)
+{
+	*(i4v *)r = *(i4v *)v1 | *(i4v *)v2;
+}
+
+/* Function: Perform a binary XOR on two vectors. */
+static void func_xor(void *v1, void *v2, void *r)
+{
+	*(i4v *)r = *(i4v *)v1 ^ *(i4v *)v2;
+}

data/ext/simd/simd_intarray.h

@@ -5,6 +5,9 @@ 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_and(VALUE self, VALUE obj);
+static VALUE method_or(VALUE self, VALUE obj);
+static VALUE method_xor(VALUE self, VALUE obj);
 static VALUE method_subtract(VALUE self, VALUE obj);
 static VALUE method_to_a(VALUE self);
 
@@ -14,3 +17,6 @@ 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);
+static void func_and(void *v1, void *v2, void *r);
+static void func_or(void *v1, void *v2, void *r);
+static void func_xor(void *v1, void *v2, void *r);

data/ext/simd/simd_longarray.c

@@ -0,0 +1,220 @@
+#include "simd_longarray.h"
+
+VALUE SIMD_LongArray = Qnil;
+
+/* Internal: Create the SIMD::FloatArray class. */
+void Init_SIMD_LongArray(VALUE parent)
+{
+	SIMD_LongArray = rb_define_class_under(parent, "LongArray", rb_cObject);
+	rb_define_alloc_func(SIMD_LongArray, allocate);
+	rb_define_method(SIMD_LongArray, "initialize", method_initialize, 1);
+	rb_define_method(SIMD_LongArray, "*", method_multiply, 1);
+	rb_define_method(SIMD_LongArray, "/", method_divide, 1);
+	rb_define_method(SIMD_LongArray, "+", method_add, 1);
+	rb_define_method(SIMD_LongArray, "-", method_subtract, 1);
+	rb_define_method(SIMD_LongArray, "&", method_and, 1);
+	rb_define_method(SIMD_LongArray, "|", method_or, 1);
+	rb_define_method(SIMD_LongArray, "^", method_xor, 1);
+	rb_define_method(SIMD_LongArray, "length", method_length, 0);
+	rb_define_method(SIMD_LongArray, "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;
+	l2v_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 < 2)
+	{
+		rb_raise(rb_eArgError, "Vectors must be at least 2 long");
+	}
+
+	vector->data = internal_allocate_vector_array(vector->len, sizeof(l2v_t));
+
+	data = (l2v_t *)vector->data;
+	for(i = 0; i < vector->len; i++)
+	{
+		data[i/2].f[i%2] = NUM2LONG(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);
+	for(i = n % 2; i > 0; i--)
+	{
+		data[m/2].f[i] = 1;
+	}
+
+	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: and values contained in the data array with those contained in
+ * another FloatArray object, returning a new FloatArray. */
+static VALUE method_and(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, func_and));
+}
+
+/* Public: or values contained in the data array with those contained in
+ * another FloatArray object, returning a new FloatArray. */
+static VALUE method_or(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, func_or));
+}
+
+/* Public: xor values contained in the data array with those contained in
+ * another FloatArray object, returning a new FloatArray. */
+static VALUE method_xor(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, func_xor));
+}
+
+/* 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;
+	l2v_t *data;
+	VALUE rb_array = rb_ary_new();
+
+	Data_Get_Struct(self, vector_t, vector);
+	data = (l2v_t *)vector->data;
+	for(i = 0; i < vector->len; i++)
+	{
+		rb_ary_store(rb_array, i, LONG2NUM(data[i/2].f[i%2]));
+	}
+
+	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;
+	l2v_t *d1, *d2, *r;
+	VALUE result_obj = allocate(SIMD_LongArray);
+
+	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(l2v_t));
+
+	align = internal_align_vectors(v1->len, v2->len, 2);
+
+	/* Ensure that size will be the result of ceil(len / 4.0) */
+	size = (v1->len + 1) / 2;
+
+	d1 = (l2v_t *)v1->data;
+	d2 = (l2v_t *)v2->data;
+	r  = (l2v_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 % 2))
+	{
+		r[size].f[1] = 1;
+	}
+
+	return(result_obj);
+}
+
+/* Function: Multiply two vectors. */
+static void func_multiply(void *v1, void *v2, void *r)
+{
+	*(l2v *)r = *(l2v *)v1 * *(l2v *)v2;
+}
+
+/* Function: Divide two vectors. */
+static void func_divide(void *v1, void *v2, void *r)
+{
+	*(l2v *)r = *(l2v *)v1 / *(l2v *)v2;
+}
+
+/* Function: Add two vectors. */
+static void func_add(void *v1, void *v2, void *r)
+{
+	*(l2v *)r = *(l2v *)v1 + *(l2v *)v2;
+}
+
+/* Function: Subtract two vectors. */
+static void func_subtract(void *v1, void *v2, void *r)
+{
+	*(l2v *)r = *(l2v *)v1 - *(l2v *)v2;
+}
+
+/* Function: Perform a binary AND on two vectors. */
+static void func_and(void *v1, void *v2, void *r)
+{
+	*(l2v *)r = *(l2v *)v1 & *(l2v *)v2;
+}
+
+/* Function: Perform a binary OR on two vectors. */
+static void func_or(void *v1, void *v2, void *r)
+{
+	*(l2v *)r = *(l2v *)v1 | *(l2v *)v2;
+}
+
+/* Function: Perform a binary XOR on two vectors. */
+static void func_xor(void *v1, void *v2, void *r)
+{
+	*(l2v *)r = *(l2v *)v1 ^ *(l2v *)v2;
+}

data/ext/simd/simd_longarray.h

@@ -0,0 +1,22 @@
+#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_and(VALUE self, VALUE obj);
+static VALUE method_or(VALUE self, VALUE obj);
+static VALUE method_xor(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);
+static void func_and(void *v1, void *v2, void *r);
+static void func_or(void *v1, void *v2, void *r);
+static void func_xor(void *v1, void *v2, void *r);

data/ext/simd/simd_types.h

@@ -1,18 +1,5 @@
 #pragma once
 
-/*
- * 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;
-
 /*
  * Types for SmallFloatArray
  *
@@ -27,6 +14,19 @@ typedef union f4v_t
 	float f[4];
 } f4v_t;
 
+/*
+ * 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;
+
 /*
  * Types for IntArray
  */
@@ -37,6 +37,16 @@ typedef union i4v_t
 	int f[4];
 } i4v_t;
 
+/*
+ * Types for LongArray
+ */
+typedef long int __attribute__ ((vector_size (16))) l2v;
+typedef union l2v_t
+{
+	l2v v;
+	long int f[2];
+} l2v_t;
+
 typedef struct vector_t
 {
 	void *data;

metadata

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