working on code generation

Author: mikolalysenko

contour.js

@@ -1,6 +1,8 @@
 "use strict"
 
 var pool = require("typedarray-pool")
+var beautify = require("js-beautify")
+var invert = require("invert-permutation")
 
 module.exports = createSurfaceExtractor
 
@@ -11,6 +13,9 @@ function array(i) {
 function data(i) {
   return "d" + i
 }
+function cube(i,bitmask) {
+  return "c" + i + "_" + bitmask
+}
 function shape(i) {
   return "s" + i
 }
@@ -35,14 +40,24 @@ function index(i) {
 function step(i,j) {
   return "u" + i + "_" + j
 }
+function pcube(bitmask) {
+  return "b" + bitmask
+}
+function pdelta(bitmask) {
+  return "e" + bitmask
+}
+function vert(i) {
+  return "v" + i
+}
 var VERTEX_IDS = "V"
 var PHASES = "P"
 var VERTEX_COUNT = "N"
 var POOL_SIZE = "Q"
+var POINTER = "X"
 
 //Generates the surface procedure
-function compileSurfaceProcedure(vertexFunc, faceFunc, phaseFunc, scalarArgs, order, typesignature) {
-  var arrayArgs = typesignature.length
+function compileSurfaceProcedure(vertexFunc, faceFunc, phaseFunc, scalarArgs, order, typesig) {
+  var arrayArgs = typesig.length
   var dimension = order.length
 
   var funcName = "extractContour" + order.join("_")
@@ -60,39 +75,40 @@ function compileSurfaceProcedure(vertexFunc, faceFunc, phaseFunc, scalarArgs, or
 
   //Shape
   for(var i=0; i<dimension; ++i) {
-    vars.push(shape(i) + "=" + array(i) + ".shape[" + i + "]|0")
+    vars.push(shape(i) + "=" + array(0) + ".shape[" + i + "]|0")
   }
   //Data, stride, offset pointers
   for(var i=0; i<arrayArgs; ++i) {
     vars.push(data(i) + "=" + array(i) + ".data",
               offset(i) + "=" + array(i) + ".offset")
     for(var j=0; j<dimension; ++j) {
-      vars.push(stride(i,j) + "=" + array(i) + ".stride[" + j + "]")
+      vars.push(stride(i,j) + "=" + array(i) + ".stride[" + j + "]|0")
     }
   }
-  //Pointer and delta variables
+  //Pointer, delta and cube variables
   for(var i=0; i<arrayArgs; ++i) {
-    var ptrStr = [offset(i)]
-    for(var j=0; j<dimension; ++i) {
-      ptrStr.push(stride(i,j))
-    }
-    vars.push(pointer(i) + "=" + ptrStr.join("+"))
-    for(var j=1; j<1<<dimension; ++i) {
-      ptrStr.length = 0
+    vars.push(pointer(i) + "=" + offset(i))
+    vars.push(cube(i,0))
+    for(var j=1; j<(1<<dimension); ++j) {
+      var ptrStr = []
       for(var k=0; k<dimension; ++k) {
         if(j & (1<<k)) {
-          ptrStr.push("-" + stride(i,j))
+          ptrStr.push("-" + stride(i,k))
         }
       }
       vars.push(delta(i,j) + "=" + ptrStr.join(""))
+      vars.push(cube(i,j))
     }
   }
+
   //Create step variables
   for(var i=0; i<arrayArgs; ++i) {
     for(var j=0; j<dimension; ++j) {
-      var stepVal = [ stride(i,j) ]
-      //TODO: Compute step variables here
-      vars.push(step(i,j) + "=(" + stepVal.join("+") + ")|0")
+      var stepVal = [ stride(i,order[j]) ]
+      for(var k=j-1; k>=0; --k) {
+        stepVal.push(stride(i, order[k]) + "*" + shape(order[k]))
+      }
+      vars.push(step(i,order[j]) + "=(" + stepVal.join("-") + ")|0")
     }
   }
   //Create index variables
@@ -101,21 +117,176 @@ function compileSurfaceProcedure(vertexFunc, faceFunc, phaseFunc, scalarArgs, or
   }
   //Vertex count
   vars.push(VERTEX_COUNT + "=0")
-  //Compute pool size
+  //Compute pool size, initialize pool step
   var sizeVariable = ["2"]
   for(var i=dimension-2; i>=0; --i) {
     sizeVariable.push(shape(order[i]))
   }
   //Previous phases and vertex_ids
   vars.push(POOL_SIZE + "=(" + sizeVariable.join("*") + ")|0",
             PHASES + "=mallocUint32(" + POOL_SIZE + ")",
-            VERTEX_IDS + "=mallocUint32(" + POOL_SIZE + ")")
+            VERTEX_IDS + "=mallocUint32(" + POOL_SIZE + ")",
+            POINTER + "=0")
+  //Create cube variables for phases
+  vars.push(pcube(0) + "=0")
+  for(var j=1; j<(1<<dimension); ++j) {
+    var cubeDelta = []
+    var cubeStep = [ "1" ]
+    for(var k=dimension-1; k>=0; --k) {
+      if(j & (1<<order[k])) {
+        cubeDelta.push(cubeStep.join("*"))
+      }
+      cubeStep.push(shape(order[k]))
+    }
+    vars.push(pdelta(j) + "=-(" + cubeDelta.join("+") + ")|0",
+              pcube(j) + "=0")
+  }
+  for(var i=0; i<(1<<dimension)-1; ++i) {
+    vars.push(vert(i) + "=0")
+  }
+
+  function forLoopBegin(i, start) {
+    code.push("for(", index(order[i]), "=", start, ";",
+      index(order[i]), "<", shape(order[i]), ";",
+      "++", index(order[i]), "){")
+  }
+
+  function forLoopEnd(i) {
+    for(var j=0; j<arrayArgs; ++j) {
+      code.push(pointer(j), "+=", step(j,order[i]), ";")
+    }
+    code.push("}")
+  }
+
+  function fillEmptySlice(k) {
+    for(var i=k-1; i>=0; --i) {
+      forLoopBegin(i, 0) 
+    }
+    var phaseFuncArgs = []
+    for(var i=0; i<arrayArgs; ++i) {
+      if(typesig[i]) {
+        phaseFuncArgs.push(data(i) + ".get(" + pointer(i) + ")")
+      } else {
+        phaseFuncArgs.push(data(i) + "[" + pointer(i) + "]")
+      }
+    }
+    for(var i=0; j<scalarArgs; ++i) {
+      phaseFuncArgs.push(scalar(i))
+    }
+    code.push(PHASES, "[", POINTER, "++]=phase(", phaseFuncArgs.join(), ");")
+    for(var i=0; i<k; ++i) {
+      forLoopEnd(i)
+    }
+    for(var j=0; j<arrayArgs; ++j) {
+      code.push(pointer(j), "+=", step(j,order[k]), ";")
+    }
+  }
+
+  function processGridCell(mask) {
+    //Read in local data
+    for(var i=0; i<arrayArgs; ++i) {
+      if(typesig[i]) {
+        code.push(cube(i,0), "=", data(i), ".get(", pointer(i), ");")
+      } else {
+        code.push(cube(i,0), "=", data(i), "[", pointer(i), "];")
+      }
+    }
 
-  //Generate outermost loop
+    //Read in phase
+    var phaseFuncArgs = []
+    for(var i=0; i<arrayArgs; ++i) {
+      phaseFuncArgs.push(cube(i,0))
+    }
+    for(var i=0; j<scalarArgs; ++i) {
+      phaseFuncArgs.push(scalar(i))
+    }
+    code.push(pcube(0), "=", PHASES, "[", POINTER, "]=phase(", phaseFuncArgs.join(), ");")
+    
+    //Read in other cube data
+    for(var j=1; j<(1<<dimension); ++j) {
+      code.push(pcube(j), "=", PHASES, "[", POINTER, "+", pdelta(j), "];")
+    }
 
-  //Generate inner loops
+    //Check for boundary crossing
+    var vertexPredicate = []
+    for(var j=1; j<(1<<dimension); ++j) {
+      vertexPredicate.push("(" + pcube(0) + "!==" + pcube(j) + ")")
+    }
+    code.push("if(", vertexPredicate.join("||"), "){")
+
+    //Read in boundary data
+    var vertexArgs = []
+    for(var i=0; i<dimension; ++i) {
+      vertexArgs.push(index(i))
+    }
+    for(var i=0; i<arrayArgs; ++i) {
+      vertexArgs.push(cube(i,0))
+      for(var j=1; j<(1<<dimension); ++j) {
+        if(typesig[i]) {
+          code.push(cube(i,j), "=", data(i), ".get(", pointer(i), "+", delta(i,j), ");")
+        } else {
+          code.push(cube(i,j), "=", data(i), "[", pointer(i), "+", delta(i,j), "];")
+        }
+        vertexArgs.push(cube(i,j))
+      }
+    }
+    for(var i=0; i<scalarArgs; ++i) {
+      vertexArgs.push(scalar(i))
+    }
+    for(var i=0; i<(1<<dimension); ++i) {
+      vertexArgs.push(pcube(i))
+    }
 
+    //Generate vertex
+    code.push("vertex(", vertexArgs.join(), ");",
+      vert(0), "=", VERTEX_IDS, "[", POINTER, "]=", VERTEX_COUNT, "++;")
 
+    //TODO: Check face crossing
+    if(mask < (1<<dimension)-1) {
+      for(var j=1; j<(1<<dimension); ++j) {
+        if((j & mask) === 0) {
+          code.push(vert(j), "=", VERTEX_IDS, "[", POINTER, "+", pcube(j), "];")
+        }
+      }
+      var corner = pcube((1<<dimension)-1)
+      for(var j=0; j<dimension; ++j) {
+        if(mask & (1<<j)) {
+          //Check face
+          var edge = pcube(((1<<dimension)-1)^(1<<j))
+          var faceArgs = []
+
+          faceArgs.push(corner, edge)
+          code.push("if(", corner, "!==", edge, "){",
+            "face(", faceArgs.join(), ")}")
+        }
+      }
+
+      code.push("/*" + mask + "*/")
+    }
+
+    //Increment pointer, close off if statement
+    code.push("}",
+      POINTER, "+=1;")
+  }
+
+  function createLoop(i, mask) {
+    if(i < 0) {
+      processGridCell(mask)
+      return
+    }
+    fillEmptySlice(i)
+    code.push("if(", shape(order[i]), ">0){")
+    createLoop(i-1, mask|(1<<i))
+    for(var j=0; j<arrayArgs; ++j) {
+      code.push(pointer(j), "+=", step(j,i), ";")
+    }
+    forLoopBegin(i, 2)
+    createLoop(i-1, mask)
+    forLoopEnd(i)
+    code.push("}")
+  }
+
+  createLoop(dimension-1, 0)
 
   //Release scratch memory
   code.push("freeUint32(", VERTEX_IDS, ");freeUint32(", PHASES, ");")
@@ -128,6 +299,10 @@ function compileSurfaceProcedure(vertexFunc, faceFunc, phaseFunc, scalarArgs, or
       code.join(""),
     "}",
     "return ", funcName ].join("")
+
+  //Print code
+  console.log(beautify(procedureCode))
+
   var proc = new Function(
     "vertex", 
     "face", 
@@ -173,19 +348,21 @@ function createSurfaceExtractor(args) {
   }
   var getters = args.getters || []
   var typesig = new Array(arrays)
+  console.log(getters)
   for(var i=0; i<arrays; ++i) {
+    console.log("here1")
     if(getters.indexOf(i) >= 0) {
       typesig[i] = true
     } else {
       typesig[i] = false
     }
+    console.log("here2")
   }
   return compileSurfaceProcedure(
     args.vertex,
     args.face,
     args.phase,
-    dimension,
     scalars,
     order,
-    typeSignature)
+    typesig)
 }

test/test.js

@@ -0,0 +1,22 @@
+"use strict"
+
+var tape = require("tape")
+var createExtractor = require("../contour.js")
+
+tape("test-vectorize", function(t) {
+
+  var testVectorizer = createExtractor({
+    order: [1, 0],
+    vertex: function(x, y, p00, p01, p10, p11, s00, s01, s10, s11) {
+      console.log("got vertex:", x, y)
+    },
+    phase: function(s) {
+      return s < 0
+    },
+    face: function(i, j, p0, p11) {
+      console.log("face", i, j)
+    }
+  })
+
+  t.end()
+})