Changeset 93

Timestamp:

04/05/07 15:35:52 (2 years ago)

Author:

Don Clugston

Message:

Added a code generator for D code. Preliminary use of known vector length. Code cleanup. Better comments.

Files:

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

trunk/mathextra/Blade.d

@@ -14 +14 @@
-*  - Supports any mix of vector addition, subtraction, dot product, and multiplication
-*    by a real or pure imaginary scalar.
+*  - 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[]).
-*  - Supports both real and imaginary vectors, and detects type mismatches between them.
-*    (Complex numbers are not yet supported).
-
+
+
-*
-* BUGS/ FUTURE DIRECTIONS:
@@ -30 +33 @@
-*  - Not optimal for the case of multiple real vectors (they could share a counter).
-*  - Not optimal for the case where all vectors are 80-bit (two counters are used, but only is required).
-
+full 
-*     is possible).
-*  - Doesn't use EBP register -- this would allow an extra vector in expressions.
-*  - Doesn't support complex numbers.
- D and a
+
-*
-* THEORY:
@@ -56 +59 @@
-}
-
-
-char [] itoa(ulong x)
-{
@@ -81 +83 @@
-//    PART 1 -- Expression Templates
-// -------------------------------------------
+// Unlike expression templates in other languages, there is no
+// 'abstract syntax tree' constructed from multiple templates. Instead,
+// the expression is constructed as a normal, human-readable text string
+// (for example, "a+(b*c-d)").
+// This string is a template parameter for a struct, which
+// contains a tuple of all the arguments used in the expression.
+// The advantage of this approach is that it's very easy to manipulate the
+// text string.
-
-// When we join two expressions together, we need to 'shuffle' all the variables
-first
+second
-char [] joinExpressions(char [] op, char [] first, char [] second)
-{
@@ -109 +119 @@
-}
-
+// Check for type mismatches when performing vector assignment.
-template CompatibleVectors(A, B)
-{
@@ -119 +130 @@
-
-/**
-
+
+
- * Stores all the arguments as a tuple, and the operations
- * as a character string.
- * Note that if operations=="a", it's a single vector; otherwise, it's a temporary.
-.
-I
+;
+  i
- */
-struct VectorExpr(BaseType_, char[] operations, int knownlength, B...) {
@@ -144 +156 @@
-    }
-public:
+    // Operations which are valid for both vectors and temporaries.
+    // All they do is update the expression string and the tuple, creating a new
+    // VectorExpr. The existing VectorExpr will not be used again.
-    static if (operations.length>1 && operations[$-2]=='*') {
-        // Optimisation: already a scalar multiply, so constant fold it.
@@ -168 +183 @@
-
-    // The opAssign operations are only valid for single vectors, not for temporaries
+    // They actually perform the calculation.
-  static if (operations=="a") {
-    void opAssign(A)(A expr) {
-        static assert(CompatibleVectors!(BaseType,A.BaseType), "Vector type mismatch in " ~ BaseType.stringof ~ "[] = " ~ A.BaseType.stringof ~ "[]");
-        static assert(len==0 || expr.len == 0 || len == expr.len, "Vector lengths must match");
-
+void, 
-    }
-    void opAddAssign(A)(A expr) {
-        static assert(CompatibleVectors!(BaseType,A.BaseType), "Vector type mismatch in " ~ BaseType.stringof ~ "[] += " ~ A.BaseType.stringof ~ "[]");
-        static assert(len==0 || expr.len == 0 || len == expr.len, "Vector lengths must match");
-
+void, 
-    }
-    void opSubAssign(A)(A expr) {
-        static assert(CompatibleVectors!(BaseType,A.BaseType), "Vector type mismatch in " ~ BaseType.stringof ~ "[] -= " ~ A.BaseType.stringof ~ "[]");
-        static assert(len==0 || expr.len == 0 || len == expr.len, "Vector lengths must match");
-
+void, 
-    }
-    void opMulAssign(A)(A w) { // Use a template to avoid unnecessary code generation
-        static assert(is (A: real), "Vector type mismatch in " ~ BaseType.stringof ~ "[] *= real");
-
+void, 
-    }
-  }
@@ -210 +226 @@
-    static if (is(A.BaseType: ireal) && is(B.BaseType:ireal))
-        const MUL = -1;
-    else static if (is(typeof(A.BaseType*B.BaseType): ireal))
-        const MUL = 1i;
-    else const MUL = 1;
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-  }
-
-
-
-
+
-
-// ------------------------------------------------
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-// ------------------------------------------------
-
@@ -292 +402 @@
-    if (operations[x+1]=='-') {
-        if (second[$-1]=='*' && first[$-1]!='*') {
-~
+_
-        }
-    }
@@ -302 +412 @@
-    }
-    if (second.length==1 && typelist[second[0]-'a']=='R' && operations[x+1]=='-') {
-~
+_
-    }
-    return first ~ second ~ operations[x+1..x+2];
-}
-
-template singleType(A)
-{
-         static if (is(A == real[])  || is(A==ireal[]))    const char [] singleType = "R";
-    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 static if (is(A == real))   const char [] singleType = "S";
-    else const char [] singleType = "?";
-}
-
-// A CTFE function can't randomly index a tuple, so convert the type information
-// into a char[].
-template vectorTupleToString(X...)
-{
-    static if (X.length==1) const char [] vectorTupleToString = singleType!(X[0]);
-    else  const char [] vectorTupleToString = singleType!(X[0]) ~ vectorTupleToString!(X[1..$]);
-}
-
-// -------------------------------
-3 -- Parsing
+5 -- Mixins to generate x87 ASM code
-// -------------------------------
-
-bool isInstruction(char op)
-{
-
-
-
-
-
-
-
-
-
+
+
+
+
+
-{
-    int numVecs=0;
@@ -347 +436 @@
-}
-
-
-int vectorNum(char [] typelist, char var)
-{
@@ -366 +454 @@
-}
-
-// -------------------------------
-//   PART 4 -- Generate x87 ASM code
-// -------------------------------
-
-char [] operandSize(char var)
@@ -386 +471 @@
-        case '+': return "fadd";
-        case '-': return "fsub";
-~
+_
-    }
-}
@@ -406 +491 @@
-// use EBX, ESI, and EDI. Finally, use the frame register EBP.
-const char [][5] vectorRegister = ["EAX", "ECX", "EDX", "EBX", "EDI"];
+
+// Is this expression simple enough for our code generator?
+bool isX87AsmPossible(char [] typelist, char [] operations) {
+  version (D_InlineAsm_X86) {
+        // Are there enough index registers?
+        if (countVectors(typelist) >= vectorRegister.length) return false;
+        // BUG: should also check if it will overflow the FPU stack
+        return true;
+  } else {
+      // Without an assembler, there's no chance!
+      return false;
+  }
+}
-
-// Create code to push all used vector registors.
@@ -473 +571 @@
-
-*/
-makeAsmX87(
+generateCodeForAsmX87(int knownlength, 
-{
-    char [] result="";
@@ -479 +577 @@
-
-    // Create local variables for everything (avoid bug #1028)
-    // Also assert that all vectors are the same length
-    bool firstvec=true;
-    int vecnum = 0;
-    int scalarnum = 0;
-    for (int i=0; i< typelist.length;++i) {
-        if (typelist[i]=='S'){
-            result~= "  real var" ~ itoa(i) ~ " = expr[" ~ itoa(i) ~ "];\n";
-            ++scalarnum;
-        } else {
-            result~= "  auto vec" ~ itoa(i) ~ " = expr[" ~itoa(i) ~"].ptr;\n";
@@ -492 +586 @@
-                incrementRealVectors ~= "  add " ~ vectorRegister[vecnum] ~ ", " ~ REALSIZE ~ ";\n";
-            }
-            if (firstvec) {
-                result~= "  int veclength = expr[" ~itoa(i) ~"].length;\n";
-                firstvec = false;
-            } else result~="  assert(veclength == expr[" ~ itoa(i) ~ `].length, "vectors are different lengths");`\n;
-            ++vecnum;
-        }
-    }
-
+
+
-    bool isDotProduct = (operations[$-1]=='.');
-    int numScalarsOnStack=0;
-
-
-
+
+
+
+
-
-    // Load all the vector pointers into registers, and push all the scalars onto the stack
@@ -528 +621 @@
-
-    if (isDotProduct) result ~= "  fldz;"\n;
-
-
-
+
+
+
+
+
+
-    if (!isDotProduct && operations.length==1 && finaloperation[0]=='*') {
-            ++numScalarsOnStack;
@@ -542 +638 @@
-    char [] mainbody = "";
-    char [] firstbody = "";
+
+    // We need to keep track of how many things are on the FPU stack.
+    // Every time something is pushed, the indices of our variables change!
-    int numOnStack = 0; // How much of the FP stack is being used?
-