Changeset 94

Timestamp:

04/11/07 15:32:52 (2 years ago)

Author:

Don Clugston

Message:

Now supports complex vectors (D code only), beginning of SSE2 version.

Files:

• trunk/mathextra/Blade.d (modified) (24 diffs)

trunk/mathextra/Blade.d

@@ -13 +13 @@
-* FEATURES:
-*  - Supports any mix of vector addition, subtraction, dot product, and multiplication
-
+, complex,
-*  - Generates either x87 asm code or pure D, depending on the complexity of
-*    the expression, and the availability of inline asm.
-*  - 80-bit precision is used whenever possible.
-*  - Supports mixed-length operations (eg, real[] + double[] + float[]).
-
-
+
-*  - When static arrays are used, mismatches in array length are detected
-*    at compile time.
@@ -36 +35 @@
-*     is possible).
-*  - Doesn't use EBP register -- this would allow an extra vector in expressions.
-
+
+
-*  - Need an SSE2 version.
-*
-* THEORY:
-a+b*c)+
-a, b, c, 
+#a+#b*#c)+#
+#a, #b, #c, #
-* This string is converted to postfix. The postfix string is converted to
-* a string containing x87 asm, which is then mixed into a function which accepts the tuple.
@@ -86 +86 @@
-// 'abstract syntax tree' constructed from multiple templates. Instead,
-// the expression is constructed as a normal, human-readable text string
-a+(b*c-
+#a+(#b*#c-#
-// This string is a template parameter for a struct, which
-// contains a tuple of all the arguments used in the expression.
@@ -98 +98 @@
-    // Find the highest used variable in the first expression...
-    char nextarg = 'a';
-0
-]>nextarg && first[i]<='z'
+1
+-1]=='#' && first[i]>nextarg
-    }
-    // Add parentheses round the first expression if required.
-    char [] ret="";
-1
+2
-        ret = "(" ~ first ~ ")";
-    } else {
@@ -110 +110 @@
-    // ... and add it to all variables in the second expression, adding
-    // parentheses if required.
-a") return ret ~ op
+#a") return ret ~ op ~ "#"
-    ret ~= op ~ "(";
-    for (int i=0; i<second.length; ++i) {
-
-
+
+
+
+
-    }
-    return ret ~ ")";
@@ -134 +136 @@
- * Stores all the arguments as a tuple, and the operations
- * as a character string.
-
+#
- * 'knownlength' is the length of vector, when known at compile time;
- *   if 'knownlength' == 0, it is unknown at compile time.
@@ -159 +161 @@
-    // All they do is update the expression string and the tuple, creating a new
-    // VectorExpr. The existing VectorExpr will not be used again.
-1
+2
-        // Optimisation: already a scalar multiply, so constant fold it.
-        VectorExpr!(BaseType, operations, knownlength, B) opMul(real x) {
@@ -168 +170 @@
-        }
-    } else {
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
-        }
-    }
@@ -184 +191 @@
-    // The opAssign operations are only valid for single vectors, not for temporaries
-    // They actually perform the calculation.
-
+#
-    void opAssign(A)(A expr) {
-        static assert(CompatibleVectors!(BaseType,A.BaseType), "Vector type mismatch in " ~ BaseType.stringof ~ "[] = " ~ A.BaseType.stringof ~ "[]");
@@ -201 +208 @@
-    }
-    void opMulAssign(A)(A w) { // Use a template to avoid unnecessary code generation
-is (A: real), "Vector type mismatch in " ~ BaseType.stringof ~ "[] *= real"
-a", "*=", knownlength, real
+(is (BaseType: creal) && is(A:ireal) || is(A:creal)) || is (A: real), "Vector type mismatch in " ~ BaseType.stringof ~ "[] *= " ~ A.stringof
+#a", "*=", knownlength, A
-    }
-  }
@@ -208 +215 @@
-
-// Convert static arrays to dynamic, but remember the length as a compile-time parameter.
-
-
+#
+#
-    a.values[0]=vals;
-    return a;
-}
-
-
-
+#
+#
-    a.values[0]=vals; return a;
-}
@@ -241 +248 @@
-                "\nPostfix: " ~ makePostfixForX87(operations, tupstr) ~ "\nTuple: " ~ tupstr);
-            static if (knownlength!=0) pragma(msg, "Length is known!");
+  static if (isSSE2AsmPossible(tupstr, operations)) {
+            const char [] q1 = generateCodeForAsmSSE2(knownlength, tupstr, makePostfixForX87(operations, tupstr), finaloperation);
+      pragma(msg, q1);
+  } else static if (isX87AsmPossible(tupstr, operations)) {
-
-            const char [] qqq = generateCodeForAsmX87(knownlength, tupstr, makePostfixForX87(operations, tupstr), finaloperation);
-            pragma(msg, "Generated code:"\n ~ qqq);
+        } else pragma(msg, "Too complicated for x87 -- generating D code instead");
-          }
-
-  // Decide which code generator to use, based on expression complexity and
-  // assembler availability.
-
+
+
+
-     mixin(generateCodeForAsmX87(knownlength, tupstr, makePostfixForX87(operations, tupstr), finaloperation));
-  } else {
-     mixin(generateCodeForD!(ReturnType)(knownlength, tupstr, finaloperation,operations));
-  }
-
-}
-
@@ -266 +279 @@
-{
-         static if (is(A == real[])  || is(A==ireal[]))    const char [] singleType = "R";
+    else static if (is(A == creal[]) || is(A==cdouble[])||is(A==cfloat[])) const char [] singleType = "Z";
-    else static if (is(A == double[])|| is(A == idouble[]))const char [] singleType = "D";
-    else static if (is(A == float[]) || is(A==ifloat[]))   const char [] singleType = "F";
-
+
+
-    else const char [] singleType = "?";
-}
@@ -288 +303 @@
-        if (isVector(typelist[i])) return i;
-    }
+    assert(0, typelist);
-}
-
-bool isVector(char var)
-{
-
+ || var=='Z'
-}
-
@@ -320 +336 @@
-{
-    char [] iter="";
-
-
-
-
-
-
+
+
+
+
+
+
+
+
-    }
-    char [] result;
@@ -349 +367 @@
-int exprLength(char [] s)
-{
+    if (s[0]=='#') return 1;
-    int numParens=0;
-    for (int i=0; i<s.length; ++i) {
@@ -357 +376 @@
-}
-
-// Converts an infix string into postfix
-char [] makePostfix(char [] operations)
-{
-    if (operations.length==1) return operations;
-
-    int x = exprLength(operations);
-    char [] first = operations[0..x+1];
-    char [] second = operations[x+2..$];
-    if (first[0]=='(') {
-        first = makePostfix(first[1..$-1]);
-    }
-    if (second[0]=='(') {
-        second = makePostfix(second[1..$-1]);
-    }
-    return first ~ second ~ operations[x+1..x+2];
-}
-
-// Converts an infix string into postfix.
-// Apply x87-specific optimisations during the conversion.
-char [] makePostfixForX87(char [] operations, char [] typelist)
-{
-
+
+
-
-    int x = exprLength(operations);
@@ -385 +388 @@
-    if (first[0]=='(') {
-        first = makePostfixForX87(first[1..$-1], typelist);
-
+ else if (first[0]=='#') first = operations[1..x+1];
-    if (second[0]=='(') {
-        second = makePostfixForX87(second[1..$-1], typelist);
-
+
+
-    // x87 OPTIMISATION #1
-    // On x87, fmul has a long latency, so we want to delay using the
@@ -431 +435 @@
-    int numVecs=0;
-    for (int i=0; i<typelist.length; ++i) {
-
+ || typelist[i]=='Z'
-    }
-    return numVecs;
@@ -440 +444 @@
-    int numVecs=0;
-    for (int i=0; i<var-'a'; ++i) {
-
+ || typelist[i]=='Z'
-    }
-    return numVecs;
@@ -492 +496 @@
-const char [][5] vectorRegister = ["EAX", "ECX", "EDX", "EBX", "EDI"];
-
-our
+the x87
-bool isX87AsmPossible(char [] typelist, char [] operations) {
-  version (D_InlineAsm_X86) {
-        // Are there enough index registers?
-
+
+
+
+
+
+
-        // BUG: should also check if it will overflow the FPU stack
-        return true;
@@ -505 +514 @@
-}
-
+// Is this expression simple enough for the SSE2 code generator?
+bool isSSE2AsmPossible(char [] typelist, char [] operations)
+{
+  version (D_InlineAsm_X86) {
+        // Does it contain any types we can't deal with?
+        foreach(ch; typelist) {
+            // can only do double vectors and scalars.
+            if (ch!='D' && ch!='S') return false;
+        }
+        return false; // not yet implemented
+  } else {
+      // Without an assembler, there's no chance!
+      return false;
+  }
+}
+
-// Create code to push all used vector registors.
-char [] pushRegisters(int numVectors)
@@ -538 +563 @@
-}
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-The key optimisation rules are:
- 1. keep the loop overhead to one clock cycle if possible.
@@ -754 +793 @@
-{
-    auto p = Vec([1.0L, 2, 18]);
-
+
+
-    auto r = Vec([17.0f, 28.25, 1]);
-    auto z = Vec([17.0i, 28.1i, 1i]);
+    auto w = Vec([2.0+17.0i, 0+28.1i, 8.1+1i]);
+
+        w*= (35.0 + 2.1i);
+
-    real d = dot(r, p+r+r);
-    assert(d==2267.625);
+
-    ireal e = dot(r, z);
-    writefln(d, " ", e);
-
- 35
+35.0
-    d = dot(r, p+r+r);
-    writefln(d, " ", e);
-    assert(d==2267.625);
+    q*=2.1L;
+
-/*
-    p = r - q*2.0;