fix: Proper kernel.toString() unit tests (good grief, so many!) for CPU and GPU

feat: `switch` statements
feat: `kernel.toString()` has as well `.getPixels()`
fix: Proper fallback when arguments or constants are not supported
fix: Removal of infamous `|| 'Number'` for argument types and return types
fix: detect circlical logic in `FunctionBuilder.lookupReturnType()` and tests
fix: Allow subKernels to get their type detected as well
fix: `FunctionNode`'s `typeLookupMap` didn't have 'Float' or 'Integer'
feat: Turn off context checking in kernel, via `{ checkContext: false }`, used for `kernel.toString()`
fix: `GPU.upgradeDeprecatedCreateKernelSettings` to have a default return value
fix: Typings
fix: `kernelRunShortcut()` to better switch kernel when replacing
feat: It order to flatten methods, for `kernel.toString()` `utils.flattenFunctionToString()` and light unit testing of it
fix: Added sinon for testing
fix: Bump gl-wiretap

Author: robertleeplummerjr

bin/gpu-browser-core.js

@@ -16,7 +16,7 @@
   "dependencies": {
     "acorn": "^5.1.1",
     "gl": "^4.3.3",
-    "gl-wiretap": "^0.3.0",
+    "gl-wiretap": "^0.6.0",
     "gpu-mock.js": "^1.0.1"
   },
   "devDependencies": {
@@ -31,6 +31,7 @@
     "gulp-strip-comments": "^2.4.5",
     "merge-stream": "^1.0.1",
     "qunit": "^2.9.1",
+    "sinon": "^7.3.2",
     "vinyl-buffer": "^1.0.0",
     "vinyl-source-stream": "^2.0.0"
   },

bin/gpu-browser-core.min.js

@@ -373,6 +373,31 @@ class CPUFunctionNode extends FunctionNode {
 
   }
 
+  astSwitchStatement(ast, retArr) {
+    const { discriminant, cases } = ast;
+    retArr.push('switch (');
+    this.astGeneric(discriminant, retArr);
+    retArr.push(') {\n');
+    for (let i = 0; i < cases.length; i++) {
+      if (cases[i].test === null) {
+        retArr.push('default:\n');
+        this.astGeneric(cases[i].consequent, retArr);
+        if (cases[i].consequent && cases[i].consequent.length > 0) {
+          retArr.push('break;\n');
+        }
+        continue;
+      }
+      retArr.push('case ');
+      this.astGeneric(cases[i].test, retArr);
+      retArr.push(':\n');
+      if (cases[i].consequent && cases[i].consequent.length > 0) {
+        this.astGeneric(cases[i].consequent, retArr);
+        retArr.push('break;\n');
+      }
+    }
+    retArr.push('\n}');
+  }
+
   /**
    * @desc Parses the abstract syntax tree for *This* expression
    * @param {Object} tNode - An ast Node
@@ -486,11 +511,19 @@ class CPUFunctionNode extends FunctionNode {
       case 'ArrayTexture(4)':
       case 'HTMLImage':
       default:
-        const isInput = this.isInput(synonymName || name);
+        let size;
+        let isInput;
+        if (origin === 'constants') {
+          const constant = this.constants[name];
+          isInput = this.constantTypes[name] === 'Input';
+          size = isInput ? constant.size : null;
+        } else {
+          isInput = this.isInput(synonymName || name);
+          size = isInput ? this.argumentSizes[this.argumentNames.indexOf(name)] : null;
+        }
         retArr.push(`${ markupName }`);
         if (zProperty && yProperty) {
           if (isInput) {
-            const size = this.argumentSizes[this.argumentNames.indexOf(name)];
             retArr.push('[(');
             this.astGeneric(zProperty, retArr);
             retArr.push(`*${ size[1] * size[0]})+(`);
@@ -511,7 +544,6 @@ class CPUFunctionNode extends FunctionNode {
           }
         } else if (yProperty) {
           if (isInput) {
-            const size = this.argumentSizes[this.argumentNames.indexOf(name)];
             retArr.push('[(');
             this.astGeneric(yProperty, retArr);
             retArr.push(`*${ size[0] })+`);

bin/gpu-browser.js

@@ -1,66 +1,146 @@
 const { utils } = require('../../utils');
-const { kernelRunShortcut } = require('../../kernel-run-shortcut');
+const { Input } = require('../../input');
 
-function removeFnNoise(fn) {
-  if (/^function /.test(fn)) {
-    fn = fn.substring(9);
+function constantsToString(constants) {
+  const results = [];
+  for (const p in constants) {
+    const constant = constants[p];
+    switch (typeof constant) {
+      case 'number':
+      case 'boolean':
+        results.push(`${p}:${constant}`);
+    }
   }
-  return fn.replace(/[_]typeof/g, 'typeof');
-}
-
-function removeNoise(str) {
-  return str
-    .replace(/^[A-Za-z]+/, 'function')
-    .replace(/[_]typeof/g, 'typeof');
+  return `{ ${ results.join() } }`;
 }
 
 function cpuKernelString(cpuKernel, name) {
-  return `() => {
-    ${ kernelRunShortcut.toString() };
-    const utils = {
-      allPropertiesOf: ${ removeNoise(utils.allPropertiesOf.toString()) },
-      clone: ${ removeNoise(utils.clone.toString()) },
-      isArray: ${ removeNoise(utils.isArray.toString()) },
-    };
-    let Input = function() {};
-    class ${ name || 'Kernel' } {
-      constructor() {        
-        this.canvas = null;
-        this.context = null;
-        this.built = false;
-        this.program = null;
-        this.argumentNames = ${ JSON.stringify(cpuKernel.argumentNames) };
-        this.argumentTypes = ${ JSON.stringify(cpuKernel.argumentTypes) };
-        this.argumentSizes = ${ JSON.stringify(cpuKernel.argumentSizes) };
-        this.output = ${ JSON.stringify(cpuKernel.output) };
-        this._kernelString = \`${ cpuKernel._kernelString }\`;
-        this.output = ${ JSON.stringify(cpuKernel.output) };
-        this.run = function() {
-          this.run = null;
-          this.build(arguments);
-          return this.run.apply(this, arguments);
-        }.bind(this);
-        this.thread = {
-          x: 0,
-          y: 0,
-          z: 0
-        };
+  const header = [];
+  const thisProperties = [];
+  const beforeReturn = [];
+
+  const useFunctionKeyword = !/^function/.test(cpuKernel.color.toString());
+
+  header.push(
+    '  const { context, canvas, constants } = settings;',
+    `  const output = new Int32Array(${JSON.stringify(Array.from(cpuKernel.output))});`,
+    `  const _constants = ${constantsToString(cpuKernel.constants)};`,
+  );
+
+  thisProperties.push(
+    '    constants: _constants,',
+    '    context,',
+    '    output,',
+    '    thread: {x: 0, y: 0, z: 0},',
+  );
+
+  if (cpuKernel.graphical) {
+    header.push(`  const _imageData = context.createImageData(${cpuKernel.output[0]}, ${cpuKernel.output[1]});`);
+    header.push(`  const _colorData = new Uint8ClampedArray(${cpuKernel.output[0]} * ${cpuKernel.output[1]} * 4);`);
+
+    const colorFn = utils.flattenFunctionToString((useFunctionKeyword ? 'function ' : '') + cpuKernel.color.toString(), {
+      thisLookup: (propertyName) => {
+        switch (propertyName) {
+          case '_colorData':
+            return '_colorData';
+          case '_imageData':
+            return '_imageData';
+          case 'output':
+            return 'output';
+          case 'thread':
+            return 'this.thread';
+        }
+        return JSON.stringify(cpuKernel[propertyName]);
+      },
+      findDependency: (object, name) => {
+        return null;
       }
-      setCanvas(canvas) { this.canvas = canvas; return this; }
-      setContext(context) { this.context = context; return this; }
-      setInput(Type) { Input = Type; }
-      ${ removeFnNoise(cpuKernel.build.toString()) }
-      setupArguments() {}
-      ${ removeFnNoise(cpuKernel.setupConstants.toString()) }
-      translateSource() {}
-      pickRenderStrategy() {}
-      run () { ${ cpuKernel.kernelString } }
-      getKernelString() { return this._kernelString; }
-      ${ removeFnNoise(cpuKernel.validateSettings.toString()) }
-      ${ removeFnNoise(cpuKernel.checkOutput.toString()) }
-    };
-    return kernelRunShortcut(new Kernel());
-  };`;
+    });
+
+    const getPixelsFn = utils.flattenFunctionToString((useFunctionKeyword ? 'function ' : '') + cpuKernel.getPixels.toString(), {
+      thisLookup: (propertyName) => {
+        switch (propertyName) {
+          case '_colorData':
+            return '_colorData';
+          case '_imageData':
+            return '_imageData';
+          case 'output':
+            return 'output';
+          case 'thread':
+            return 'this.thread';
+        }
+        return JSON.stringify(cpuKernel[propertyName]);
+      },
+      findDependency: () => {
+        return null;
+      }
+    });
+
+    thisProperties.push(
+      '    _imageData,',
+      '    _colorData,',
+      `    color: ${colorFn},`,
+    );
+
+    beforeReturn.push(
+      `  kernel.getPixels = ${getPixelsFn};`
+    );
+  }
+
+  const constantTypes = [];
+  const constantKeys = Object.keys(cpuKernel.constantTypes);
+  for (let i = 0; i < constantKeys.length; i++) {
+    constantTypes.push(cpuKernel.constantTypes[constantKeys]);
+  }
+  if (cpuKernel.argumentTypes.indexOf('HTMLImageArray') !== -1 || constantTypes.indexOf('HTMLImageArray') !== -1) {
+    const flattenedImageTo3DArray = utils.flattenFunctionToString((useFunctionKeyword ? 'function ' : '') + cpuKernel._imageTo3DArray.toString(), {
+      doNotDefine: ['canvas'],
+      findDependency: (object, name) => {
+        if (object === 'this') {
+          return (useFunctionKeyword ? 'function ' : '') + cpuKernel[name].toString();
+        }
+        return null;
+      },
+      thisLookup: (propertyName) => {
+        switch (propertyName) {
+          case 'canvas':
+            return;
+          case 'context':
+            return 'context';
+        }
+      }
+    })
+    beforeReturn.push(flattenedImageTo3DArray);
+    thisProperties.push(`    _imageTo2DArray,`);
+    thisProperties.push(`    _imageTo3DArray,`);
+  } else if (cpuKernel.argumentTypes.indexOf('HTMLImage') !== -1 || constantTypes.indexOf('HTMLImage') !== -1) {
+    const flattenedImageTo2DArray = utils.flattenFunctionToString((useFunctionKeyword ? 'function ' : '') + cpuKernel._imageTo2DArray.toString(), {
+      findDependency: () => {
+        debugger;
+      }
+    });
+    beforeReturn.push(flattenedImageTo2DArray);
+    thisProperties.push(`    _imageTo2DArray,`);
+  }
+
+  return `function(settings) {
+${ header.join('\n') }
+  for (const p in constants) {
+    const constant = constants[p];
+    switch (typeof constant) {
+      case 'number':
+      case 'boolean':
+        continue;
+    }
+    _constants[p] = constant;
+  }
+  const kernel = (function() {
+${cpuKernel._kernelString}
+  })
+    .apply({ ${thisProperties.join('\n')} });
+  ${ beforeReturn.join('\n') }
+  return kernel;
+}`;
 }
 
 module.exports = {

bin/gpu-browser.min.js

@@ -75,7 +75,7 @@ class FunctionBuilder {
 
     const onNestedFunction = (fnString, returnType) => {
       functionBuilder.addFunctionNode(new FunctionNode(fnString, Object.assign({}, nodeOptions, {
-        returnType: returnType || 'Number', // TODO: I think this needs removed
+        returnType: returnType,
         lookupReturnType,
         lookupArgumentType,
         lookupFunctionArgumentTypes,
@@ -161,7 +161,6 @@ class FunctionBuilder {
           name,
           isSubKernel: true,
           isRootKernel: false,
-          returnType: 'Number', // TODO: I think this needs removed
         }));
       });
     }
@@ -378,25 +377,36 @@ class FunctionBuilder {
 
   lookupArgumentType(argumentName, requestingNode) {
     const index = requestingNode.argumentNames.indexOf(argumentName);
-    if (index === -1) return null;
-    if (this.lookupChain.length === 0) return null;
+    if (index === -1) {
+      return null;
+    }
+    if (this.lookupChain.length === 0) {
+      return null;
+    }
     let link = this.lookupChain[this.lookupChain.length - 1 - this.argumentChain.length];
-    if (!link) return null;
+    if (!link) {
+      return null;
+    }
     const {
       ast,
       requestingNode: parentRequestingNode
     } = link;
-    if (ast.arguments.length === 0) return null;
-    const usedVariable = ast.arguments[index];
-    if (!usedVariable) return null;
+    if (ast.arguments.length === 0) {
+      return null;
+    }
+    const usedArgument = ast.arguments[index];
+    if (!usedArgument) {
+      return null;
+    }
+
     this.argumentChain.push(argumentName);
-    const type = parentRequestingNode.getType(usedVariable);
+
+    const type = parentRequestingNode.getType(usedArgument);
     this.argumentChain.pop();
     return type;
   }
 
   lookupReturnType(functionName, ast, requestingNode) {
-    // TODO: track circlical logic
     if (ast.type !== 'CallExpression') {
       throw new Error(`expected ast type of "CallExpression", but is ${ ast.type }`);
     }
@@ -407,6 +417,22 @@ class FunctionBuilder {
       if (node.returnType) {
         return node.returnType;
       } else {
+        for (let i = 0; i < this.lookupChain.length; i++) {
+          // detect circlical logic
+          if (this.lookupChain[i].ast === ast) {
+            // detect if arguments have not resolved, preventing a return type
+            // if so, go ahead and resolve them, so we can resolve the return type
+            if (node.argumentTypes.length === 0 && ast.arguments.length > 0) {
+              const args = ast.arguments;
+              for (let j = 0; j < args.length; j++) {
+                node.argumentTypes[j] = requestingNode.getType(args[j]);
+              }
+              return node.returnType = node.getType(node.getJsAST());
+            }
+
+            throw new Error('circlical logic detected!');
+          }
+        }
         // get ready for a ride!
         this.lookupChain.push({
           name: requestingNode.name,
@@ -533,7 +559,12 @@ class FunctionBuilder {
   }
 
   getKernelResultType() {
-    return this.rootNode.getType(this.rootNode.ast);
+    return this.rootNode.returnType || this.rootNode.getType(this.rootNode.ast);
+  }
+
+  getSubKernelResultType(index) {
+    const subKernelNode = this.subKernelNodes[index];
+    return subKernelNode.returnType || subKernelNode.getType(subKernelNode.getJsAST());
   }
 
   getReturnTypes() {