feat: Finally add the missing json with gpu-core feature!

And add unit tests

Author: robertleeplummerjr

README.md

@@ -82,7 +82,7 @@ yarn add gpu.js
 Download the latest version of GPU.js and include the files in your HTML page using the following tags:
 
 ```html
-<script src="/path/to/js/gpu.min.js"></script>
+<script src="/path/to/js/gpu-browser.min.js"></script>
 ```
 
 In JavaScript, initialize the library:

src/backend/cpu/kernel.js

@@ -407,6 +407,12 @@ class CPUKernel extends Kernel {
 	}
 
 	static destroyContext(context) {}
+
+	toJSON() {
+		const json = super.toJSON();
+		json.functionNodes = FunctionBuilder.fromKernel(this, CPUFunctionNode).toJSON();
+		return json;
+	}
 }
 
 module.exports = {

src/backend/function-builder.js

@@ -42,13 +42,19 @@ class FunctionBuilder {
 			output,
 		}, extraNodeOptions || {});
 
-		const rootNode = new FunctionNode(kernel.source, Object.assign({}, nodeOptions, {
+		const rootNodeOptions = Object.assign({}, nodeOptions, {
 			isRootKernel: true,
 			name: 'kernel',
 			argumentNames,
 			argumentTypes,
 			argumentSizes,
-		}));
+		});
+
+		if (typeof kernel.source === 'object' && kernel.source.functionNodes) {
+			return new FunctionBuilder().fromJSON(kernel.source.functionNodes, FunctionNode);
+		}
+
+		const rootNode = new FunctionNode(kernel.source, rootNodeOptions);
 
 		let functionNodes = null;
 		if (kernel.functions) {
@@ -200,7 +206,9 @@ class FunctionBuilder {
 	 * @returns {Array} The full string, of all the various functions. Trace optimized if functionName given
 	 */
 	getPrototypes(functionName) {
-		this.rootNode.toString();
+		if (this.rootNode) {
+			this.rootNode.toString();
+		}
 		if (functionName) {
 			return this.getPrototypesFromFunctionNames(this.traceFunctionCalls(functionName, []).reverse());
 		}
@@ -245,6 +253,30 @@ class FunctionBuilder {
 		return ret;
 	}
 
+	toJSON() {
+		return this.traceFunctionCalls(this.rootNode.name).reverse().map(name => {
+			if (this.nativeFunctions[name]) {
+				return {
+					name,
+					source: this.nativeFunctions[name]
+				};
+			} else if (this.functionMap[name]) {
+				return this.functionMap[name].toJSON();
+			} else {
+				throw new Error(`function ${ name } not found`);
+			}
+		});
+	}
+
+	fromJSON(jsonFunctionNodes, FunctionNode) {
+		this.functionMap = {};
+		for (let i = 0; i < jsonFunctionNodes.length; i++) {
+			const jsonFunctionNode = jsonFunctionNodes[i];
+			this.functionMap[jsonFunctionNode.settings.name] = new FunctionNode(jsonFunctionNode.ast, jsonFunctionNode.settings);
+		}
+		return this;
+	}
+
 	/**
 	 * @desc Get string for a particular function name
 	 * @param {String} functionName - Function name to trace from. If null, it returns the WHOLE builder stack

src/backend/function-node.js

@@ -21,9 +21,9 @@ class FunctionNode {
 		settings = settings || {};
 
 		this.source = source;
-		this.name = settings.isRootKernel ?
+		this.name = typeof source === 'string' ? settings.isRootKernel ?
 			'kernel' :
-			(settings.name || utils.getFunctionNameFromString(source));
+			(settings.name || utils.getFunctionNameFromString(source)) : null;
 		this.calledFunctions = [];
 		this.calledFunctionsArguments = {};
 		this.constants = {};
@@ -33,14 +33,12 @@ class FunctionNode {
 		this.parent = null;
 		this.debug = null;
 		this.prototypeOnly = null;
-		this.constants = null;
-		this.output = null;
 		this.declarations = {};
 		this.states = [];
 		this.lookupReturnType = null;
 		this.onNestedFunction = null;
 		this.loopMaxIterations = null;
-		this.argumentNames = utils.getArgumentNamesFromString(this.source);
+		this.argumentNames = (typeof this.source === 'string' ? utils.getArgumentNamesFromString(this.source) : null);
 		this.argumentTypes = {};
 		this.argumentSizes = [];
 		this.returnType = null;
@@ -175,8 +173,8 @@ class FunctionNode {
 	 * @returns {Object} The function AST Object, note that result is cached under this.ast;
 	 */
 	getJsAST(inParser) {
-		if (this.ast) {
-			return this.ast;
+		if (typeof this.source === 'object') {
+			return this.ast = this.source;
 		}
 
 		inParser = inParser || acorn;
@@ -261,6 +259,30 @@ class FunctionNode {
 		throw new Error(`"toString" not defined on ${ this.constructor.name }`);
 	}
 
+	toJSON() {
+		const settings = {
+			source: this.source,
+			name: this.name,
+			constants: this.constants,
+			constantTypes: this.constantTypes,
+			isRootKernel: this.isRootKernel,
+			isSubKernel: this.isSubKernel,
+			debug: this.debug,
+			prototypeOnly: this.prototypeOnly,
+			output: this.output,
+			loopMaxIterations: this.loopMaxIterations,
+			argumentNames: this.argumentNames,
+			argumentTypes: this.argumentTypes,
+			argumentSizes: this.argumentSizes,
+			returnType: this.returnType
+		};
+
+		return {
+			ast: this.ast,
+			settings
+		};
+	}
+
 	/**
 	 * @desc Parses the abstract syntax tree for generically to its respective function
 	 * @param {Object} ast - the AST object to parse

src/backend/kernel.js

@@ -24,22 +24,26 @@ class Kernel {
 
 	/**
 	 *
-	 * @param {string} source
+	 * @param {string|object} source
 	 * @param [settings]
 	 */
 	constructor(source, settings) {
-		if (typeof source !== 'string') {
-			throw new Error('source not a string');
-		}
-		if (!utils.isFunctionString(source)) {
-			throw new Error('source not a function string');
+		if (typeof source === 'object') {
+			settings = source.settings;
+		} else {
+			if (typeof source !== 'string') {
+				throw new Error('source not a string');
+			}
+			if (!utils.isFunctionString(source)) {
+				throw new Error('source not a function string');
+			}
 		}
 
 		/**
 		 * Name of the arguments found from parsing source argument
 		 * @type {String[]}
 		 */
-		this.argumentNames = utils.getArgumentNamesFromString(source);
+		this.argumentNames = typeof source === 'string' ? utils.getArgumentNamesFromString(source) : null;
 		this.argumentTypes = null;
 		this.argumentSizes = null;
 
@@ -193,6 +197,10 @@ class Kernel {
 			this.argumentTypes.push(utils.getVariableType(arg));
 			this.argumentSizes.push(arg.constructor === Input ? arg.size : null);
 		}
+
+		if (this.argumentNames.length !== args.length) {
+			throw new Error(`arguments are miss-aligned`);
+		}
 	}
 
 	/**
@@ -403,8 +411,25 @@ class Kernel {
 			}
 		}
 	}
+
+	toJSON() {
+		const settings = {
+			output: this.output,
+			threadDim: this.threadDim,
+			outputToTexture: this.outputToTexture,
+			argumentNames: this.argumentNames,
+			argumentsTypes: this.argumentTypes,
+			argumentsLength: this.argumentsLength,
+			constants: this.constants,
+			constantsLength: this.constantsLength,
+			maxTexSize: this.maxTexSize,
+		};
+		return {
+			settings
+		};
+	}
 }
 
 module.exports = {
 	Kernel
-};
+};

src/backend/web-gl/kernel.js

@@ -1255,7 +1255,7 @@ class WebGLKernel extends GLKernel {
 				} else if (type === 'Integer' || type === 'Float') {
 					result.push(`uniform float user_${name}`);
 				} else {
-					throw new Error(`Param type ${name} not supported in WebGL, only WebGL2`);
+					throw new Error(`Param type ${type} not supported in WebGL`);
 				}
 			}
 		}
@@ -1493,6 +1493,12 @@ class WebGLKernel extends GLKernel {
 			extension.loseContext();
 		}
 	}
+
+	toJSON() {
+		const json = super.toJSON();
+		json.functionNodes = FunctionBuilder.fromKernel(this, WebGLFunctionNode).toJSON();
+		return json;
+	}
 }
 
 module.exports = {

src/backend/web-gl2/kernel.js

@@ -945,6 +945,12 @@ class WebGL2Kernel extends WebGLKernel {
 		this.extensions.EXT_color_buffer_float = null;
 		this.extensions.OES_texture_float_linear = null;
 	}
+
+	toJSON() {
+		const json = super.toJSON();
+		json.functionNodes = FunctionBuilder.fromKernel(this, WebGL2FunctionNode).toJSON();
+		return json;
+	}
 }
 
 module.exports = {

src/gpu.js

@@ -167,7 +167,7 @@ class GPU {
 	 *
 	 * @desc This creates a callable function object to call the kernel function with the argument parameter set
 	 *
-	 * @param {Function|String} source - The calling to perform the conversion
+	 * @param {Function|String|object} source - The calling to perform the conversion
 	 * @param {Object} [settings] - The parameter configuration object
 	 * @property {String} settings.dimensions - Thread dimension array (Defaults to [1024])
 	 * @property {String} settings.mode - CPU / GPU configuration mode (Defaults to null)
@@ -181,13 +181,13 @@ class GPU {
 	 */
 	createKernel(source, settings) {
 		if (typeof source === 'undefined') {
-			throw 'Missing source parameter';
+			throw new Error('Missing source parameter');
 		}
-		if (!utils.isFunction(source) && typeof source !== 'string') {
-			throw 'source parameter not a function';
+		if (typeof source !== 'object' && !utils.isFunction(source) && typeof source !== 'string') {
+			throw new Error('source parameter not a function');
 		}
 
-		source = typeof source !== 'string' ? source.toString() : source;
+		source = typeof source === 'function' ? source.toString() : source;
 		const mergedSettings = Object.assign({
 			context: this.context,
 			canvas: this.canvas,

test/all.html

@@ -49,6 +49,7 @@
   <script type="module" src="features/image-array.js"></script>
   <script type="module" src="features/infinity.js"></script>
   <script type="module" src="features/input.js"></script>
+  <script type="module" src="features/json.js"></script>
   <script type="module" src="features/loops.js"></script>
   <script type="module" src="features/math-object.js"></script>
   <script type="module" src="features/nested-function.js"></script>

test/features/json.js

@@ -0,0 +1,44 @@
+const { assert, skip, test, module: describe } = require('qunit');
+const { GPU } = require('../../src');
+
+describe('json serialize');
+
+function testJSONSerialize(mode) {
+  const gpu = new GPU({mode});
+
+  const kernel = gpu.createKernel(function (value) {
+    return value;
+  }, {output: [1]});
+
+  kernel(1);
+
+  const json = kernel.toJSON();
+
+  const jsonKernel = gpu.createKernel(json);
+
+  assert.equal(jsonKernel(3)[0], 3);
+}
+
+test('auto', () => {
+  testJSONSerialize();
+});
+
+test('gpu', () => {
+  testJSONSerialize('gpu');
+});
+
+(GPU.isWebGLSupported ? test : skip)('webgl', () => {
+  testJSONSerialize('webgl');
+});
+
+(GPU.isWebGL2Supported ? test : skip)('webgl2', () => {
+  testJSONSerialize('webgl2');
+});
+
+(GPU.isHeadlessGLSupported ? test : skip)('headlessgl', () => {
+  testJSONSerialize('headlessgl');
+});
+
+test('cpu', () => {
+  testJSONSerialize('cpu');
+});