summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/analyzer.js5
-rw-r--r--src/embind/embind.js99
-rw-r--r--src/embind/emval.js177
-rw-r--r--src/library_browser.js12
-rw-r--r--src/parseTools.js15
-rw-r--r--src/postamble.js4
-rw-r--r--src/preamble.js4
-rw-r--r--system/include/emscripten/bind.h62
-rw-r--r--system/include/emscripten/val.h116
-rw-r--r--system/include/emscripten/wire.h81
-rw-r--r--system/lib/embind/bind.cpp1
-rw-r--r--tests/embind/build_benchmark2
-rw-r--r--tests/embind/embind.benchmark.js35
-rw-r--r--tests/embind/embind.test.js153
-rw-r--r--tests/embind/embind_benchmark.cpp71
-rw-r--r--tests/embind/embind_test.cpp65
-rw-r--r--tests/float_tex.cpp4
-rw-r--r--tests/gl_subdata.cpp4
-rw-r--r--tests/lua/binarytrees.lua50
-rw-r--r--tests/lua/scimark.lua424
-rw-r--r--tests/lua/src/Makefile2
-rwxr-xr-xtests/runner.py185
22 files changed, 1307 insertions, 264 deletions
diff --git a/src/analyzer.js b/src/analyzer.js
index a131406c..2cc46ab6 100644
--- a/src/analyzer.js
+++ b/src/analyzer.js
@@ -411,8 +411,9 @@ function analyzer(data, sidePass) {
// legalize parameters
legalizeFunctionParameters(value.params);
// legalize return value, if any
- if (value.assignTo && isIllegalType(item.type)) {
- bits = getBits(value.type);
+ var returnType = getReturnType(item.type);
+ if (value.assignTo && isIllegalType(returnType)) {
+ bits = getBits(returnType);
var elements = getLegalVars(item.assignTo, bits);
// legalize return value
value.assignTo = elements[0].ident;
diff --git a/src/embind/embind.js b/src/embind/embind.js
index cadee700..91386c69 100644
--- a/src/embind/embind.js
+++ b/src/embind/embind.js
@@ -131,6 +131,7 @@ function extendError(baseErrorType, errorName) {
// from https://github.com/imvu/imvujs/blob/master/src/function.js
function createNamedFunction(name, body) {
+ name = makeLegalFunctionName(name);
/*jshint evil:true*/
return new Function(
"body",
@@ -270,6 +271,10 @@ function __embind_register_void(rawType, name) {
'fromWireType': function() {
return undefined;
},
+ 'toWireType': function(destructors, o) {
+ // TODO: assert if anything else is given?
+ return undefined;
+ },
});
}
@@ -306,7 +311,7 @@ function __embind_register_integer(primitiveType, name, minRange, maxRange) {
'toWireType': function(destructors, value) {
// todo: Here we have an opportunity for -O3 level "unsafe" optimizations: we could
// avoid the following two if()s and assume value is of proper type.
- if (typeof value !== "number") {
+ if (typeof value !== "number" && typeof value !== "boolean") {
throw new TypeError('Cannot convert "' + _embind_repr(value) + '" to ' + this.name);
}
if (value < minRange || value > maxRange) {
@@ -328,8 +333,8 @@ function __embind_register_float(rawType, name) {
'toWireType': function(destructors, value) {
// todo: Here we have an opportunity for -O3 level "unsafe" optimizations: we could
// avoid the following if() and assume value is of proper type.
- if (typeof value !== "number") {
- throw new TypeError('Cannot convert "' + _embind_repr(value) + '" to ' +this.name);
+ if (typeof value !== "number" && typeof value !== "boolean") {
+ throw new TypeError('Cannot convert "' + _embind_repr(value) + '" to ' + this.name);
}
return value;
},
@@ -449,6 +454,31 @@ function __embind_register_emval(rawType, name) {
});
}
+function __embind_register_memory_view(rawType, name) {
+ var typeMapping = [
+ Int8Array,
+ Uint8Array,
+ Int16Array,
+ Uint16Array,
+ Int32Array,
+ Uint32Array,
+ Float32Array,
+ Float64Array,
+ ];
+
+ name = readLatin1String(name);
+ registerType(rawType, {
+ name: name,
+ 'fromWireType': function(handle) {
+ var type = HEAPU32[handle >> 2];
+ var size = HEAPU32[(handle >> 2) + 1]; // in elements
+ var data = HEAPU32[(handle >> 2) + 2]; // byte offset into emscripten heap
+ var TA = typeMapping[type];
+ return new TA(HEAP8.buffer, data, size);
+ },
+ });
+}
+
function runDestructors(destructors) {
while (destructors.length) {
var ptr = destructors.pop();
@@ -677,7 +707,7 @@ function __embind_finalize_tuple(rawTupleType) {
},
'toWireType': function(destructors, o) {
if (elementsLength !== o.length) {
- throw new TypeError("Incorrect number of tuple elements");
+ throw new TypeError("Incorrect number of tuple elements for " + reg.name + ": expected=" + elementsLength + ", actual=" + o.length);
}
var ptr = rawConstructor();
for (var i = 0; i < elementsLength; ++i) {
@@ -685,7 +715,7 @@ function __embind_finalize_tuple(rawTupleType) {
}
if (destructors !== null) {
destructors.push(rawDestructor, ptr);
- }
+ }
return ptr;
},
destructorFunction: rawDestructor,
@@ -802,7 +832,9 @@ var genericPointerToWireType = function(destructors, handle) {
if (this.isSmartPointer) {
var ptr = this.rawConstructor();
- destructors.push(this.rawDestructor, ptr);
+ if (destructors !== null) {
+ destructors.push(this.rawDestructor, ptr);
+ }
return ptr;
} else {
return 0;
@@ -854,7 +886,9 @@ var genericPointerToWireType = function(destructors, handle) {
clonedHandle.delete();
})
);
- destructors.push(this.rawDestructor, ptr);
+ if (destructors !== null) {
+ destructors.push(this.rawDestructor, ptr);
+ }
}
break;
@@ -1080,9 +1114,13 @@ ClassHandle.prototype.isAliasOf = function(other) {
return leftClass === rightClass && left === right;
};
+function throwInstanceAlreadyDeleted(obj) {
+ throwBindingError(getInstanceTypeName(obj) + ' instance already deleted');
+}
+
ClassHandle.prototype.clone = function() {
if (!this.$$.ptr) {
- throwBindingError(getInstanceTypeName(this) + ' instance already deleted');
+ throwInstanceAlreadyDeleted(this);
}
var clone = Object.create(Object.getPrototypeOf(this), {
@@ -1104,9 +1142,12 @@ function runDestructor(handle) {
}
}
-ClassHandle.prototype['delete'] = function() {
+ClassHandle.prototype['delete'] = function ClassHandle_delete() {
if (!this.$$.ptr) {
- throwBindingError(getInstanceTypeName(this) + ' instance already deleted');
+ throwInstanceAlreadyDeleted(this);
+ }
+ if (this.$$.deleteScheduled) {
+ throwBindingError('Object already scheduled for deletion');
}
this.$$.count.value -= 1;
@@ -1116,6 +1157,44 @@ ClassHandle.prototype['delete'] = function() {
this.$$.smartPtr = undefined;
this.$$.ptr = undefined;
};
+
+var deletionQueue = [];
+
+ClassHandle.prototype['isDeleted'] = function isDeleted() {
+ return !this.$$.ptr;
+};
+
+ClassHandle.prototype['deleteLater'] = function deleteLater() {
+ if (!this.$$.ptr) {
+ throwInstanceAlreadyDeleted(this);
+ }
+ if (this.$$.deleteScheduled) {
+ throwBindingError('Object already scheduled for deletion');
+ }
+ deletionQueue.push(this);
+ if (deletionQueue.length === 1 && delayFunction) {
+ delayFunction(flushPendingDeletes);
+ }
+ this.$$.deleteScheduled = true;
+ return this;
+};
+
+function flushPendingDeletes() {
+ while (deletionQueue.length) {
+ var obj = deletionQueue.pop();
+ obj.$$.deleteScheduled = false;
+ obj['delete']();
+ }
+}
+Module['flushPendingDeletes'] = flushPendingDeletes;
+
+var delayFunction;
+Module['setDelayFunction'] = function setDelayFunction(fn) {
+ delayFunction = fn;
+ if (deletionQueue.length && delayFunction) {
+ delayFunction(flushPendingDeletes);
+ }
+};
function RegisteredClass(
name,
diff --git a/src/embind/emval.js b/src/embind/emval.js
index c02ffa92..77270597 100644
--- a/src/embind/emval.js
+++ b/src/embind/emval.js
@@ -1,8 +1,12 @@
-/*global Module*/
+/*global Module:true, Runtime*/
/*global HEAP32*/
+/*global new_*/
+/*global createNamedFunction*/
/*global readLatin1String, writeStringToMemory*/
/*global requireRegisteredType, throwBindingError*/
+var Module = Module || {};
+
var _emval_handle_array = [{}]; // reserve zero
var _emval_free_list = [];
@@ -69,14 +73,8 @@ function __emval_incref(handle) {
function __emval_decref(handle) {
if (handle && 0 === --_emval_handle_array[handle].refcount) {
- delete _emval_handle_array[handle];
+ _emval_handle_array[handle] = undefined;
_emval_free_list.push(handle);
-
- var actual_length = _emval_handle_array.length;
- while (actual_length > 0 && _emval_handle_array[actual_length - 1] === undefined) {
- --actual_length;
- }
- _emval_handle_array.length = actual_length;
}
}
@@ -108,44 +106,73 @@ function __emval_take_value(type, v) {
var __newers = {}; // arity -> function
-function __emval_new(handle, argCount, argTypes) {
- requireHandle(handle);
- var args = parseParameters(
- argCount,
- argTypes,
- Array.prototype.slice.call(arguments, 3));
+function craftEmvalAllocator(argCount) {
+ /*This function returns a new function that looks like this:
+ function emval_allocator_3(handle, argTypes, arg0Wired, arg1Wired, arg2Wired) {
+ var argType0 = requireRegisteredType(HEAP32[(argTypes >> 2)], "parameter 0");
+ var arg0 = argType0.fromWireType(arg0Wired);
+ var argType1 = requireRegisteredType(HEAP32[(argTypes >> 2) + 1], "parameter 1");
+ var arg1 = argType1.fromWireType(arg1Wired);
+ var argType2 = requireRegisteredType(HEAP32[(argTypes >> 2) + 2], "parameter 2");
+ var arg2 = argType2.fromWireType(arg2Wired);
+ var constructor = _emval_handle_array[handle].value;
+ var emval = new constructor(arg0, arg1, arg2);
+ return emval;
+ } */
+
+ var args1 = ["requireRegisteredType", "HEAP32", "_emval_handle_array", "__emval_register"];
+ var args2 = [requireRegisteredType, HEAP32, _emval_handle_array, __emval_register];
+
+ var argsList = "";
+ var argsListWired = "";
+ for(var i = 0; i < argCount; ++i) {
+ argsList += (i!==0?", ":"")+"arg"+i; // 'arg0, arg1, ..., argn'
+ argsListWired += ", arg"+i+"Wired"; // ', arg0Wired, arg1Wired, ..., argnWired'
+ }
- // Alas, we are forced to use operator new until WebKit enables
- // constructing typed arrays without new.
- // In WebKit, Uint8Array(10) throws an error.
- // In every other browser, it's identical to new Uint8Array(10).
+ var invokerFnBody =
+ "return function emval_allocator_"+argCount+"(handle, argTypes " + argsListWired + ") {\n";
+ for(var i = 0; i < argCount; ++i) {
+ invokerFnBody +=
+ "var argType"+i+" = requireRegisteredType(HEAP32[(argTypes >> 2) + "+i+"], \"parameter "+i+"\");\n" +
+ "var arg"+i+" = argType"+i+".fromWireType(arg"+i+"Wired);\n";
+ }
+ invokerFnBody +=
+ "var constructor = _emval_handle_array[handle].value;\n" +
+ "var obj = new constructor("+argsList+");\n" +
+ "return __emval_register(obj);\n" +
+ "}\n";
+
+ args1.push(invokerFnBody);
+ var invokerFunction = new_(Function, args1).apply(null, args2);
+ return invokerFunction;
+}
+
+function __emval_new(handle, argCount, argTypes) {
+ requireHandle(handle);
+
var newer = __newers[argCount];
if (!newer) {
- var parameters = new Array(argCount);
- for (var i = 0; i < argCount; ++i) {
- parameters[i] = 'a' + i;
- }
- /*jshint evil:true*/
- newer = __newers[argCount] = new Function(
- ['c'].concat(parameters),
- "return new c(" + parameters.join(',') + ");");
+ newer = craftEmvalAllocator(argCount);
+ __newers[argCount] = newer;
}
-
- var constructor = _emval_handle_array[handle].value;
- var obj = newer.apply(undefined, [constructor].concat(args));
-/*
- // implement what amounts to operator new
- function dummy(){}
- dummy.prototype = constructor.prototype;
- var obj = new constructor;
- var rv = constructor.apply(obj, args);
- if (typeof rv === 'object') {
- obj = rv;
+
+ if (argCount === 0) {
+ return newer(handle, argTypes);
+ } else if (argCount === 1) {
+ return newer(handle, argTypes, arguments[3]);
+ } else if (argCount === 2) {
+ return newer(handle, argTypes, arguments[3], arguments[4]);
+ } else if (argCount === 3) {
+ return newer(handle, argTypes, arguments[3], arguments[4], arguments[5]);
+ } else if (argCount === 4) {
+ return newer(handle, argTypes, arguments[3], arguments[4], arguments[5], arguments[6]);
+ } else {
+ // This is a slow path! (.apply and .splice are slow), so a few specializations are present above.
+ return newer.apply(null, arguments.splice(1));
}
-*/
- return __emval_register(obj);
}
// appease jshint (technically this code uses eval)
@@ -192,38 +219,62 @@ function parseParameters(argCount, argTypes, argWireTypes) {
function __emval_call(handle, argCount, argTypes) {
requireHandle(handle);
+ var types = lookupTypes(argCount, argTypes);
+
+ var args = new Array(argCount);
+ for (var i = 0; i < argCount; ++i) {
+ args[i] = types[i].fromWireType(arguments[3 + i]);
+ }
+
var fn = _emval_handle_array[handle].value;
- var args = parseParameters(
- argCount,
- argTypes,
- Array.prototype.slice.call(arguments, 3));
var rv = fn.apply(undefined, args);
return __emval_register(rv);
}
-function __emval_call_method(handle, name, argCount, argTypes) {
- requireHandle(handle);
- name = getStringOrSymbol(name);
-
- var args = parseParameters(
- argCount,
- argTypes,
- Array.prototype.slice.call(arguments, 4));
- var obj = _emval_handle_array[handle].value;
- var rv = obj[name].apply(obj, args);
- return __emval_register(rv);
+function lookupTypes(argCount, argTypes, argWireTypes) {
+ var a = new Array(argCount);
+ for (var i = 0; i < argCount; ++i) {
+ a[i] = requireRegisteredType(
+ HEAP32[(argTypes >> 2) + i],
+ "parameter " + i);
+ }
+ return a;
}
-function __emval_call_void_method(handle, name, argCount, argTypes) {
- requireHandle(handle);
- name = getStringOrSymbol(name);
+function __emval_get_method_caller(argCount, argTypes) {
+ var types = lookupTypes(argCount, argTypes);
+
+ var retType = types[0];
+ var signatureName = retType.name + "_$" + types.slice(1).map(function (t) { return t.name; }).join("_") + "$";
+
+ var args1 = ["Runtime", "createNamedFunction", "requireHandle", "getStringOrSymbol", "_emval_handle_array", "retType"];
+ var args2 = [Runtime, createNamedFunction, requireHandle, getStringOrSymbol, _emval_handle_array, retType];
- var args = parseParameters(
- argCount,
- argTypes,
- Array.prototype.slice.call(arguments, 4));
- var obj = _emval_handle_array[handle].value;
- obj[name].apply(obj, args);
+ var argsList = ""; // 'arg0, arg1, arg2, ... , argN'
+ var argsListWired = ""; // 'arg0Wired, ..., argNWired'
+ for (var i = 0; i < argCount - 1; ++i) {
+ argsList += (i !== 0 ? ", " : "") + "arg" + i;
+ argsListWired += ", arg" + i + "Wired";
+ args1.push("argType" + i);
+ args2.push(types[1 + i]);
+ }
+
+ var invokerFnBody =
+ "return Runtime.addFunction(createNamedFunction('" + signatureName + "', function (handle, name" + argsListWired + ") {\n" +
+ "requireHandle(handle);\n" +
+ "name = getStringOrSymbol(name);\n";
+
+ for (var i = 0; i < argCount - 1; ++i) {
+ invokerFnBody += "var arg" + i + " = argType" + i + ".fromWireType(arg" + i + "Wired);\n";
+ }
+ invokerFnBody +=
+ "var obj = _emval_handle_array[handle].value;\n" +
+ "return retType.toWireType(null, obj[name](" + argsList + "));\n" +
+ "}));\n";
+
+ args1.push(invokerFnBody);
+ var invokerFunction = new_(Function, args1).apply(null, args2);
+ return invokerFunction;
}
function __emval_has_function(handle, name) {
diff --git a/src/library_browser.js b/src/library_browser.js
index 97233c36..5f9c4d06 100644
--- a/src/library_browser.js
+++ b/src/library_browser.js
@@ -311,10 +311,10 @@ mergeInto(LibraryManager.library, {
lockPointer: undefined,
resizeCanvas: undefined,
requestFullScreen: function(lockPointer, resizeCanvas) {
- this.lockPointer = lockPointer;
- this.resizeCanvas = resizeCanvas;
- if (typeof this.lockPointer === 'undefined') this.lockPointer = true;
- if (typeof this.resizeCanvas === 'undefined') this.resizeCanvas = false;
+ Browser.lockPointer = lockPointer;
+ Browser.resizeCanvas = resizeCanvas;
+ if (typeof Browser.lockPointer === 'undefined') Browser.lockPointer = true;
+ if (typeof Browser.resizeCanvas === 'undefined') Browser.resizeCanvas = false;
var canvas = Module['canvas'];
function fullScreenChange() {
@@ -335,8 +335,8 @@ mergeInto(LibraryManager.library, {
if (Module['onFullScreen']) Module['onFullScreen'](Browser.isFullScreen);
}
- if (!this.fullScreenHandlersInstalled) {
- this.fullScreenHandlersInstalled = true;
+ if (!Browser.fullScreenHandlersInstalled) {
+ Browser.fullScreenHandlersInstalled = true;
document.addEventListener('fullscreenchange', fullScreenChange, false);
document.addEventListener('mozfullscreenchange', fullScreenChange, false);
document.addEventListener('webkitfullscreenchange', fullScreenChange, false);
diff --git a/src/parseTools.js b/src/parseTools.js
index 1a58b4e7..f30883b5 100644
--- a/src/parseTools.js
+++ b/src/parseTools.js
@@ -286,11 +286,22 @@ function isVarArgsFunctionType(type) {
return type.substr(-varArgsSuffix.length) == varArgsSuffix;
}
+function getNumVars(type) { // how many variables are needed to represent this type
+ if (type in Runtime.FLOAT_TYPES) return 1;
+ return Math.max(getNumIntChunks(type), 1);
+}
+
function countNormalArgs(type, out) {
out = out || {};
if (!isFunctionType(type, out)) return -1;
- if (isVarArgsFunctionType(type)) out.numArgs--;
- return out.numArgs;
+ var ret = 0;
+ if (out.segments) {
+ for (var i = 0; i < out.segments.length; i++) {
+ ret += getNumVars(out.segments[i][0].text);
+ }
+ }
+ if (isVarArgsFunctionType(type)) ret--;
+ return ret;
}
function addIdent(token) {
diff --git a/src/postamble.js b/src/postamble.js
index 12471a19..d0b737f8 100644
--- a/src/postamble.js
+++ b/src/postamble.js
@@ -1,7 +1,7 @@
// === Auto-generated postamble setup entry stuff ===
-Module.callMain = function callMain(args) {
+Module['callMain'] = function callMain(args) {
assert(runDependencies == 0, 'cannot call main when async dependencies remain! (listen on __ATMAIN__)');
assert(!Module['preRun'] || Module['preRun'].length == 0, 'cannot call main when preRun functions remain to be called');
@@ -84,7 +84,7 @@ function run(args) {
var ret = 0;
calledRun = true;
if (Module['_main'] && shouldRunNow) {
- ret = Module.callMain(args);
+ ret = Module['callMain'](args);
if (!Module['noExitRuntime']) {
exitRuntime();
}
diff --git a/src/preamble.js b/src/preamble.js
index d10771e3..dbe5e655 100644
--- a/src/preamble.js
+++ b/src/preamble.js
@@ -777,7 +777,7 @@ Module['writeArrayToMemory'] = writeArrayToMemory;
{{{ reSign }}}
#if PRECISE_I32_MUL
-if (!Math.imul) Math.imul = function(a, b) {
+if (!Math['imul']) Math['imul'] = function(a, b) {
var ah = a >>> 16;
var al = a & 0xffff;
var bh = b >>> 16;
@@ -785,7 +785,7 @@ if (!Math.imul) Math.imul = function(a, b) {
return (al*bl + ((ah*bl + al*bh) << 16))|0;
};
#else
-Math.imul = function(a, b) {
+Math['imul'] = function(a, b) {
return (a*b)|0; // fast but imprecise
};
#endif
diff --git a/system/include/emscripten/bind.h b/system/include/emscripten/bind.h
index 7aa2a55e..cd465e45 100644
--- a/system/include/emscripten/bind.h
+++ b/system/include/emscripten/bind.h
@@ -18,7 +18,6 @@ namespace emscripten {
};
namespace internal {
- typedef void (*GenericFunction)();
typedef long GenericEnumValue;
// Implemented in JavaScript. Don't call these directly.
@@ -60,6 +59,10 @@ namespace emscripten {
TYPEID emvalType,
const char* name);
+ void _embind_register_memory_view(
+ TYPEID memoryViewType,
+ const char* name);
+
void _embind_register_function(
const char* name,
unsigned argCount,
@@ -414,11 +417,10 @@ namespace emscripten {
// TODO: This could do a reinterpret-cast if sizeof(T) === sizeof(void*)
template<typename T>
- inline void* getContext(const T& t) {
+ inline T* getContext(const T& t) {
// not a leak because this is called once per binding
- void* p = malloc(sizeof(T));
- assert(p);
- memcpy(p, &t, sizeof(T));
+ T* p = reinterpret_cast<T*>(malloc(sizeof(T)));
+ new(p) T(t);
return p;
}
@@ -749,38 +751,19 @@ namespace emscripten {
template<typename ReturnType, typename... Args>
ReturnType call(const char* name, Args&&... args) const {
- return Caller<ReturnType, Args...>::call(wrapped, name, std::forward<Args>(args)...);
+ return wrapped.call<ReturnType>(name, std::forward<Args>(args)...);
}
template<typename ReturnType, typename... Args, typename Default>
ReturnType optional_call(const char* name, Default def, Args&&... args) const {
- if (has_function(name)) {
- return Caller<ReturnType, Args...>::call(wrapped, name, std::forward<Args>(args)...);
+ if (wrapped.has_function(name)) {
+ return call<ReturnType>(name, std::forward<Args>(args)...);
} else {
return def();
}
}
private:
- bool has_function(const char* name) const {
- return wrapped.has_function(name);
- }
-
- // this class only exists because you can't partially specialize function templates
- template<typename ReturnType, typename... Args>
- struct Caller {
- static ReturnType call(const val& v, const char* name, Args&&... args) {
- return v.call(name, std::forward<Args>(args)...).template as<ReturnType>();
- }
- };
-
- template<typename... Args>
- struct Caller<void, Args...> {
- static void call(const val& v, const char* name, Args&&... args) {
- v.call_void(name, std::forward<Args>(args)...);
- }
- };
-
val wrapped;
};
@@ -844,23 +827,8 @@ namespace emscripten {
}
};
- template<typename PointerType>
- struct ptr {
- typedef PointerType pointer_type;
- };
-
namespace internal {
template<typename T>
- struct is_ptr {
- enum { value = false };
- };
-
- template<typename T>
- struct is_ptr<ptr<T>> {
- enum { value = true };
- };
-
- template<typename T>
struct SmartPtrIfNeeded {
template<typename U>
SmartPtrIfNeeded(U& cls) {
@@ -881,7 +849,6 @@ namespace emscripten {
public:
class_() = delete;
- template<typename = typename std::enable_if<!internal::is_ptr<ClassType>::value>::type>
explicit class_(const char* name) {
using namespace internal;
@@ -927,16 +894,17 @@ namespace emscripten {
policies...);
}
- template<typename... Args, typename... Policies>
- class_& constructor(ClassType* (*factory)(Args...), Policies...) {
+ template<typename... Args, typename ReturnType, typename... Policies>
+ class_& constructor(ReturnType (*factory)(Args...), Policies...) {
using namespace internal;
- typename WithPolicies<Policies...>::template ArgTypeList<AllowedRawPointer<ClassType>, Args...> args;
+ // TODO: allows all raw pointers... policies need a rethink
+ typename WithPolicies<allow_raw_pointers, Policies...>::template ArgTypeList<ReturnType, Args...> args;
_embind_register_class_constructor(
TypeID<ClassType>::get(),
args.count,
args.types,
- reinterpret_cast<GenericFunction>(&Invoker<ClassType*, Args...>::invoke),
+ reinterpret_cast<GenericFunction>(&Invoker<ReturnType, Args...>::invoke),
reinterpret_cast<GenericFunction>(factory));
return *this;
}
diff --git a/system/include/emscripten/val.h b/system/include/emscripten/val.h
index edd070e3..b712d164 100644
--- a/system/include/emscripten/val.h
+++ b/system/include/emscripten/val.h
@@ -10,7 +10,6 @@ namespace emscripten {
extern "C" {
void _emval_register_symbol(const char*);
- typedef struct _EM_SIG* EM_SIG;
typedef struct _EM_VAL* EM_VAL;
void _emval_incref(EM_VAL value);
@@ -39,34 +38,67 @@ namespace emscripten {
unsigned argCount,
internal::TYPEID argTypes[]
/*, ... */);
- EM_VAL _emval_call_method(
- EM_VAL value,
- const char* methodName,
- unsigned argCount,
- internal::TYPEID argTypes[]
- /*, ... */);
- void _emval_call_void_method(
- EM_VAL value,
- const char* methodName,
- unsigned argCount,
- internal::TYPEID argTypes[]
- /*, ...*/);
+
+ // DO NOT call this more than once per signature. It will leak function pointer offsets!
+ GenericFunction _emval_get_method_caller(
+ unsigned argCount, // including return value
+ internal::TYPEID argTypes[]);
bool _emval_has_function(
EM_VAL value,
const char* methodName);
}
- }
- template<const char* address>
- struct symbol_registrar {
- symbol_registrar() {
- internal::_emval_register_symbol(address);
- }
- };
+ template<const char* address>
+ struct symbol_registrar {
+ symbol_registrar() {
+ internal::_emval_register_symbol(address);
+ }
+ };
+
+ template<typename ReturnType, typename... Args>
+ struct Signature {
+ typedef typename BindingType<ReturnType>::WireType (*MethodCaller)(EM_VAL value, const char* methodName, typename BindingType<Args>::WireType...);
+
+ static MethodCaller get_method_caller() {
+ static MethodCaller fp = reinterpret_cast<MethodCaller>(init_method_caller());
+ return fp;
+ }
+
+ private:
+ static GenericFunction init_method_caller() {
+ WithPolicies<>::ArgTypeList<ReturnType, Args...> args;
+ return _emval_get_method_caller(args.count, args.types);
+ }
+ };
+
+ template<typename ReturnType, typename... Args>
+ struct MethodCaller {
+ static ReturnType call(EM_VAL handle, const char* methodName, Args&&... args) {
+ auto caller = Signature<ReturnType, Args...>::get_method_caller();
+ auto wireType = caller(
+ handle,
+ methodName,
+ toWireType(std::forward<Args>(args))...);
+ WireDeleter<ReturnType> deleter(wireType);
+ return BindingType<ReturnType>::fromWireType(wireType);
+ }
+ };
+
+ template<typename... Args>
+ struct MethodCaller<void, Args...> {
+ static void call(EM_VAL handle, const char* methodName, Args&&... args) {
+ auto caller = Signature<void, Args...>::get_method_caller();
+ return caller(
+ handle,
+ methodName,
+ toWireType(std::forward<Args>(args))...);
+ }
+ };
+ }
#define EMSCRIPTEN_SYMBOL(name) \
static const char name##_symbol[] = #name; \
- static const symbol_registrar<name##_symbol> name##_registrar
+ static const ::emscripten::internal::symbol_registrar<name##_symbol> name##_registrar
class val {
public:
@@ -158,7 +190,7 @@ namespace emscripten {
}
bool hasOwnProperty(const char* key) const {
- return val::global("Object")["prototype"]["hasOwnProperty"].call("call", *this, val(key)).as<bool>();
+ return val::global("Object")["prototype"]["hasOwnProperty"].call<bool>("call", *this, val(key));
}
template<typename... Args>
@@ -211,45 +243,11 @@ namespace emscripten {
toWireType(std::forward<Args>(args))...));
}
- template<typename ...Args>
- val call(const char* name, Args&&... args) const {
+ template<typename ReturnValue, typename... Args>
+ ReturnValue call(const char* name, Args&&... args) const {
using namespace internal;
- WithPolicies<>::ArgTypeList<Args...> argList;
- typedef EM_VAL (*TypedCall)(
- EM_VAL,
- const char* name,
- unsigned,
- TYPEID argTypes[],
- typename BindingType<Args>::WireType...);
- TypedCall typedCall = reinterpret_cast<TypedCall>(&_emval_call_method);
- return val(
- typedCall(
- handle,
- name,
- argList.count,
- argList.types,
- toWireType(std::forward<Args>(args))...));
- }
-
- template<typename ...Args>
- void call_void(const char* name, Args&&... args) const {
- using namespace internal;
-
- WithPolicies<>::ArgTypeList<Args...> argList;
- typedef void (*TypedCall)(
- EM_VAL,
- const char* name,
- unsigned,
- TYPEID argTypes[],
- typename BindingType<Args>::WireType...);
- TypedCall typedCall = reinterpret_cast<TypedCall>(&_emval_call_void_method);
- return typedCall(
- handle,
- name,
- argList.count,
- argList.types,
- toWireType(std::forward<Args>(args))...);
+ return MethodCaller<ReturnValue, Args...>::call(handle, name, std::forward<Args>(args)...);
}
bool has_function(const char* name) const {
diff --git a/system/include/emscripten/wire.h b/system/include/emscripten/wire.h
index 6fb15fc7..a5892216 100644
--- a/system/include/emscripten/wire.h
+++ b/system/include/emscripten/wire.h
@@ -13,6 +13,8 @@
namespace emscripten {
namespace internal {
+ typedef void (*GenericFunction)();
+
typedef const struct _TYPEID* TYPEID;
// This implementation is technically not legal, as it's not
@@ -146,6 +148,7 @@ namespace emscripten {
template<>
struct BindingType<void> {
+ typedef void WireType;
};
template<>
@@ -309,4 +312,82 @@ namespace emscripten {
WireType wt;
};
}
+
+ struct memory_view {
+ enum class Type {
+ Int8Array,
+ Uint8Array,
+ Int16Array,
+ Uint16Array,
+ Int32Array,
+ Uint32Array,
+ Float32Array,
+ Float64Array,
+ };
+
+ memory_view() = delete;
+ explicit memory_view(size_t size, const void* data)
+ : type(Type::Uint8Array)
+ , size(size)
+ , data(data)
+ {}
+ explicit memory_view(Type type, size_t size, const void* data)
+ : type(type)
+ , size(size)
+ , data(data)
+ {}
+
+ const Type type;
+ const size_t size; // in elements, not bytes
+ const void* const data;
+ };
+
+ inline memory_view typed_memory_view(size_t size, const int8_t* data) {
+ return memory_view(memory_view::Type::Int8Array, size, data);
+ }
+
+ inline memory_view typed_memory_view(size_t size, const uint8_t* data) {
+ return memory_view(memory_view::Type::Uint8Array, size, data);
+ }
+
+ inline memory_view typed_memory_view(size_t size, const int16_t* data) {
+ return memory_view(memory_view::Type::Int16Array, size, data);
+ }
+
+ inline memory_view typed_memory_view(size_t size, const uint16_t* data) {
+ return memory_view(memory_view::Type::Uint16Array, size, data);
+ }
+
+ inline memory_view typed_memory_view(size_t size, const int32_t* data) {
+ return memory_view(memory_view::Type::Int32Array, size, data);
+ }
+
+ inline memory_view typed_memory_view(size_t size, const uint32_t* data) {
+ return memory_view(memory_view::Type::Uint32Array, size, data);
+ }
+
+ inline memory_view typed_memory_view(size_t size, const float* data) {
+ return memory_view(memory_view::Type::Float32Array, size, data);
+ }
+
+ inline memory_view typed_memory_view(size_t size, const double* data) {
+ return memory_view(memory_view::Type::Float64Array, size, data);
+ }
+
+ namespace internal {
+ template<>
+ struct BindingType<memory_view> {
+ // This non-word-sized WireType only works because I
+ // happen to know that clang will pass aggregates as
+ // pointers to stack elements and we never support
+ // converting JavaScript typed arrays back into
+ // memory_view. (That is, fromWireType is not implemented
+ // on the C++ side, nor is toWireType implemented in
+ // JavaScript.)
+ typedef memory_view WireType;
+ static WireType toWireType(const memory_view& mv) {
+ return mv;
+ }
+ };
+ }
}
diff --git a/system/lib/embind/bind.cpp b/system/lib/embind/bind.cpp
index ec1648a9..12264dfd 100644
--- a/system/lib/embind/bind.cpp
+++ b/system/lib/embind/bind.cpp
@@ -59,4 +59,5 @@ EMSCRIPTEN_BINDINGS(native_and_builtin_types) {
_embind_register_std_string(TypeID<std::string>::get(), "std::string");
_embind_register_std_wstring(TypeID<std::wstring>::get(), sizeof(wchar_t), "std::wstring");
_embind_register_emval(TypeID<val>::get(), "emscripten::val");
+ _embind_register_memory_view(TypeID<memory_view>::get(), "emscripten::memory_view");
}
diff --git a/tests/embind/build_benchmark b/tests/embind/build_benchmark
index 6faad18b..3d5d816b 100644
--- a/tests/embind/build_benchmark
+++ b/tests/embind/build_benchmark
@@ -1,2 +1,2 @@
#!/bin/bash
-EMCC_LLVM_TARGET=le32-unknown-nacl ~/projects/emscripten/emcc --minify 0 --bind --post-js embind.benchmark.js -O2 --shell-file shell.html -o embind_benchmark.html embind_benchmark.cpp
+EMCC_LLVM_TARGET=le32-unknown-nacl ../../emcc --minify 0 --bind --post-js embind.benchmark.js -O2 --shell-file shell.html -o embind_benchmark.html embind_benchmark.cpp
diff --git a/tests/embind/embind.benchmark.js b/tests/embind/embind.benchmark.js
index 7b20db88..3669bc28 100644
--- a/tests/embind/embind.benchmark.js
+++ b/tests/embind/embind.benchmark.js
@@ -248,3 +248,38 @@ function _call_through_interface1() {
Module.print("C++ -> JS std::wstring through interface " + N + " iters: " + elapsed + " msecs.");
obj.delete();
}
+
+function _call_through_interface2() {
+ var N = 1000000;
+ var total = 0;
+ var obj = Module['Interface'].implement({
+ call_with_typed_array: function(ta) {
+ total += ta.length;
+ },
+ call_with_memory_view: function(ta) {
+ total += ta.length;
+ },
+ });
+
+ var start = _emscripten_get_now();
+ Module['callInterface2'](N, obj);
+ var elapsed = _emscripten_get_now() - start;
+ Module.print("C++ -> JS typed array instantiation " + N + " iters: " + elapsed + " msecs.");
+
+ var start = _emscripten_get_now();
+ Module['callInterface3'](N, obj);
+ var elapsed = _emscripten_get_now() - start;
+ Module.print("C++ -> JS memory_view instantiation" + N + " iters: " + elapsed + " msecs.");
+ obj.delete();
+}
+
+function _returns_val_benchmark() {
+ var N = 1000000;
+ var v = 1;
+ var start = _emscripten_get_now();
+ for(var i = 0; i < N; ++i) {
+ v = Module['returns_val'](v);
+ }
+ var elapsed = _emscripten_get_now() - start;
+ Module.print("returns_val " + N + " iters: " + elapsed + " msecs");
+}
diff --git a/tests/embind/embind.test.js b/tests/embind/embind.test.js
index 52b2cad8..e60e1ab3 100644
--- a/tests/embind/embind.test.js
+++ b/tests/embind/embind.test.js
@@ -5,6 +5,8 @@ module({
var CheckForLeaks = fixture("check for leaks", function() {
this.setUp(function() {
+ cm.setDelayFunction(undefined);
+
if (typeof INVOKED_FROM_EMSCRIPTEN_TEST_RUNNER === "undefined") { // TODO: Enable this to work in Emscripten runner as well!
cm._mallocDebug(2);
assert.equal(0, cm.count_emval_handles());
@@ -12,6 +14,7 @@ module({
}
});
this.tearDown(function() {
+ cm.flushPendingDeletes();
if (typeof INVOKED_FROM_EMSCRIPTEN_TEST_RUNNER === "undefined") { // TODO: Enable this to work in Emscripten runner as well!
cm._mallocAssertAllMemoryFree();
assert.equal(0, cm.count_emval_handles());
@@ -490,6 +493,15 @@ module({
assert.equal(true, cm.emval_test_not(false));
});
+ test("can pass booleans as integers", function() {
+ assert.equal(1, cm.emval_test_as_unsigned(true));
+ assert.equal(0, cm.emval_test_as_unsigned(false));
+ });
+
+ test("can pass booleans as floats", function() {
+ assert.equal(2, cm.const_ref_adder(true, true));
+ });
+
test("convert double to unsigned", function() {
var rv = cm.emval_test_as_unsigned(1.5);
assert.equal('number', typeof rv);
@@ -672,6 +684,15 @@ module({
c.delete();
});
+ test("access multiple smart ptr ctors", function() {
+ var a = new cm.MultipleSmartCtors(10);
+ assert.equal(a.WhichCtorCalled(), 1);
+ var b = new cm.MultipleCtors(20, 20);
+ assert.equal(b.WhichCtorCalled(), 2);
+ a.delete();
+ b.delete();
+ });
+
test("wrong number of constructor arguments throws", function() {
assert.throws(cm.BindingError, function() { new cm.MultipleCtors(); });
assert.throws(cm.BindingError, function() { new cm.MultipleCtors(1,2,3,4); });
@@ -1559,6 +1580,28 @@ module({
impl.delete();
});
+ test("returning null shared pointer from interfaces implemented in JS code does not leak", function() {
+ var impl = cm.AbstractClass.implement({
+ returnsSharedPtr: function() {
+ return null;
+ }
+ });
+ cm.callReturnsSharedPtrMethod(impl);
+ impl.delete();
+ // Let the memory leak test superfixture check that no leaks occurred.
+ });
+
+ test("returning a new shared pointer from interfaces implemented in JS code does not leak", function() {
+ var impl = cm.AbstractClass.implement({
+ returnsSharedPtr: function() {
+ return cm.embind_test_return_smart_derived_ptr();
+ }
+ });
+ cm.callReturnsSharedPtrMethod(impl);
+ impl.delete();
+ // Let the memory leak test superfixture check that no leaks occurred.
+ });
+
test("void methods work", function() {
var saved = {};
var impl = cm.AbstractClass.implement({
@@ -1728,6 +1771,116 @@ module({
e.delete();
f.delete();
});
+
+ BaseFixture.extend("memory view", function() {
+ test("can pass memory view from C++ to JS", function() {
+ var views = [];
+ cm.callWithMemoryView(function(view) {
+ views.push(view);
+ });
+ assert.equal(3, views.length);
+
+ assert.instanceof(views[0], Uint8Array);
+ assert.equal(8, views[0].length);
+ assert.deepEqual([0, 1, 2, 3, 4, 5, 6, 7], [].slice.call(new Uint8Array(views[0])));
+
+ assert.instanceof(views[1], Float32Array);
+ assert.equal(4, views[1].length);
+ assert.deepEqual([1.5, 2.5, 3.5, 4.5], [].slice.call(views[1]));
+
+ assert.instanceof(views[2], Int16Array);
+ assert.equal(4, views[2].length);
+ assert.deepEqual([1000, 100, 10, 1], [].slice.call(views[2]));
+ });
+ });
+
+ BaseFixture.extend("delete pool", function() {
+ test("can delete objects later", function() {
+ var v = new cm.ValHolder({});
+ v.deleteLater();
+ assert.deepEqual({}, v.getVal());
+ cm.flushPendingDeletes();
+ assert.throws(cm.BindingError, function() {
+ v.getVal();
+ });
+ });
+
+ test("calling deleteLater twice is an error", function() {
+ var v = new cm.ValHolder({});
+ v.deleteLater();
+ assert.throws(cm.BindingError, function() {
+ v.deleteLater();
+ });
+ });
+
+ test("deleteLater returns the object", function() {
+ var v = (new cm.ValHolder({})).deleteLater();
+ assert.deepEqual({}, v.getVal());
+ });
+
+ test("deleteLater throws if object is already deleted", function() {
+ var v = new cm.ValHolder({});
+ v.delete();
+ assert.throws(cm.BindingError, function() {
+ v.deleteLater();
+ });
+ });
+
+ test("delete throws if object is already scheduled for deletion", function() {
+ var v = new cm.ValHolder({});
+ v.deleteLater();
+ assert.throws(cm.BindingError, function() {
+ v.delete();
+ });
+ });
+
+ test("deleteLater invokes delay function", function() {
+ var runLater;
+ cm.setDelayFunction(function(fn) {
+ runLater = fn;
+ });
+
+ var v = new cm.ValHolder({});
+ assert.false(runLater);
+ v.deleteLater();
+ assert.true(runLater);
+ assert.false(v.isDeleted());
+ runLater();
+ assert.true(v.isDeleted());
+ });
+
+ test("deleteLater twice invokes delay function once", function() {
+ var count = 0;
+ var runLater;
+ cm.setDelayFunction(function(fn) {
+ ++count;
+ runLater = fn;
+ });
+
+ (new cm.ValHolder({})).deleteLater();
+ (new cm.ValHolder({})).deleteLater();
+ assert.equal(1, count);
+ runLater();
+ (new cm.ValHolder({})).deleteLater();
+ assert.equal(2, count);
+ });
+
+ test('The delay function is immediately invoked if the deletion queue is not empty', function() {
+ (new cm.ValHolder({})).deleteLater();
+ var count = 0;
+ cm.setDelayFunction(function(fn) {
+ ++count;
+ });
+ assert.equal(1, count);
+ });
+
+ // The idea is that an interactive application would
+ // periodically flush the deleteLater queue by calling
+ //
+ // setDelayFunction(function(fn) {
+ // setTimeout(fn, 0);
+ // });
+ });
});
/* global run_all_tests */
diff --git a/tests/embind/embind_benchmark.cpp b/tests/embind/embind_benchmark.cpp
index b6a834c9..5ae9a6be 100644
--- a/tests/embind/embind_benchmark.cpp
+++ b/tests/embind/embind_benchmark.cpp
@@ -50,6 +50,14 @@ extern void pass_gameobject_ptr_benchmark_embind_js();
extern void call_through_interface0();
extern void call_through_interface1();
+extern void call_through_interface2();
+
+extern void returns_val_benchmark();
+}
+
+emscripten::val returns_val(emscripten::val value)
+{
+ return emscripten::val(value.as<unsigned>() + 1);
}
class Vec3
@@ -135,19 +143,45 @@ class Interface
public:
virtual void call0() = 0;
virtual std::wstring call1(const std::wstring& str1, const std::wstring& str2) = 0;
+ virtual void call_with_typed_array(size_t size, const void*) = 0;
+ virtual void call_with_memory_view(size_t size, const void*) = 0;
};
+EMSCRIPTEN_SYMBOL(HEAP8);
+EMSCRIPTEN_SYMBOL(buffer);
+
+EMSCRIPTEN_SYMBOL(call0);
+EMSCRIPTEN_SYMBOL(call1);
+EMSCRIPTEN_SYMBOL(call_with_typed_array);
+EMSCRIPTEN_SYMBOL(call_with_memory_view);
+EMSCRIPTEN_SYMBOL(Uint8Array);
+
class InterfaceWrapper : public emscripten::wrapper<Interface>
{
public:
EMSCRIPTEN_WRAPPER(InterfaceWrapper);
void call0() override {
- return call<void>("call0");
+ return call<void>(call0_symbol);
}
std::wstring call1(const std::wstring& str1, const std::wstring& str2) {
- return call<std::wstring>("call1", str1, str2);
+ return call<std::wstring>(call1_symbol, str1, str2);
+ }
+
+ void call_with_typed_array(size_t size, const void* data) {
+ return call<void>(
+ call_with_typed_array_symbol,
+ emscripten::val::global(Uint8Array_symbol).new_(
+ emscripten::val::module_property(HEAP8_symbol)[buffer_symbol],
+ reinterpret_cast<uintptr_t>(data),
+ size));
+ }
+
+ void call_with_memory_view(size_t size, const void* data) {
+ return call<void>(
+ call_with_memory_view_symbol,
+ emscripten::memory_view(size, data));
}
};
@@ -180,6 +214,33 @@ void callInterface1(unsigned N, Interface& o) {
}
}
+void callInterface2(unsigned N, Interface& o) {
+ int i = 0;
+ for (unsigned i = 0; i < N; i += 8) {
+ o.call_with_typed_array(sizeof(int), &i);
+ o.call_with_typed_array(sizeof(int), &i);
+ o.call_with_typed_array(sizeof(int), &i);
+ o.call_with_typed_array(sizeof(int), &i);
+ o.call_with_typed_array(sizeof(int), &i);
+ o.call_with_typed_array(sizeof(int), &i);
+ o.call_with_typed_array(sizeof(int), &i);
+ o.call_with_typed_array(sizeof(int), &i);
+ }
+}
+
+void callInterface3(unsigned N, Interface& o) {
+ for (unsigned i = 0; i < N; i += 8) {
+ o.call_with_memory_view(sizeof(int), &i);
+ o.call_with_memory_view(sizeof(int), &i);
+ o.call_with_memory_view(sizeof(int), &i);
+ o.call_with_memory_view(sizeof(int), &i);
+ o.call_with_memory_view(sizeof(int), &i);
+ o.call_with_memory_view(sizeof(int), &i);
+ o.call_with_memory_view(sizeof(int), &i);
+ o.call_with_memory_view(sizeof(int), &i);
+ }
+}
+
EMSCRIPTEN_BINDINGS(benchmark)
{
using namespace emscripten;
@@ -225,6 +286,10 @@ EMSCRIPTEN_BINDINGS(benchmark)
function("callInterface0", &callInterface0);
function("callInterface1", &callInterface1);
+ function("callInterface2", &callInterface2);
+ function("callInterface3", &callInterface3);
+
+ function("returns_val", &returns_val);
}
void __attribute__((noinline)) emscripten_get_now_benchmark(int N)
@@ -435,4 +500,6 @@ int main()
emscripten_get_now();
call_through_interface0();
call_through_interface1();
+ call_through_interface2();
+ returns_val_benchmark();
}
diff --git a/tests/embind/embind_test.cpp b/tests/embind/embind_test.cpp
index 23761efc..3561b8a1 100644
--- a/tests/embind/embind_test.cpp
+++ b/tests/embind/embind_test.cpp
@@ -1084,6 +1084,7 @@ public:
return "optional" + s;
}
+ virtual std::shared_ptr<Derived> returnsSharedPtr() = 0;
virtual void differentArguments(int i, double d, unsigned char f, double q, std::string) = 0;
};
@@ -1103,6 +1104,10 @@ public:
}, s);
}
+ std::shared_ptr<Derived> returnsSharedPtr() {
+ return call<std::shared_ptr<Derived> >("returnsSharedPtr");
+ }
+
void differentArguments(int i, double d, unsigned char f, double q, std::string s) {
return call<void>("differentArguments", i, d, f, q, s);
}
@@ -1116,6 +1121,10 @@ class ConcreteClass : public AbstractClass {
void differentArguments(int i, double d, unsigned char f, double q, std::string s) {
}
+
+ std::shared_ptr<Derived> returnsSharedPtr() {
+ return std::shared_ptr<Derived>();
+ }
};
std::shared_ptr<AbstractClass> getAbstractClass() {
@@ -1130,6 +1139,11 @@ std::string callOptionalMethod(AbstractClass& ac, std::string s) {
return ac.optionalMethod(s);
}
+void callReturnsSharedPtrMethod(AbstractClass& ac) {
+ std::shared_ptr<Derived> sp = ac.returnsSharedPtr();
+ // unused: sp
+}
+
void callDifferentArguments(AbstractClass& ac, int i, double d, unsigned char f, double q, std::string s) {
return ac.differentArguments(i, d, f, q, s);
}
@@ -1145,9 +1159,29 @@ EMSCRIPTEN_BINDINGS(interface_tests) {
function("getAbstractClass", &getAbstractClass);
function("callAbstractMethod", &callAbstractMethod);
function("callOptionalMethod", &callOptionalMethod);
+ function("callReturnsSharedPtrMethod", &callReturnsSharedPtrMethod);
function("callDifferentArguments", &callDifferentArguments);
}
+template<typename T, size_t sizeOfArray>
+constexpr size_t getElementCount(T (&)[sizeOfArray]) {
+ return sizeOfArray;
+}
+
+static void callWithMemoryView(val v) {
+ // static so the JS test can read the memory after callTakeMemoryView runs
+ static unsigned char data[] = { 0, 1, 2, 3, 4, 5, 6, 7 };
+ v(memory_view(getElementCount(data), data));
+ static float f[] = { 1.5f, 2.5f, 3.5f, 4.5f };
+ v(typed_memory_view(getElementCount(f), f));
+ static short s[] = { 1000, 100, 10, 1 };
+ v(typed_memory_view(getElementCount(s), s));
+}
+
+EMSCRIPTEN_BINDINGS(memory_view_tests) {
+ function("callWithMemoryView", &callWithMemoryView);
+}
+
class HasExternalConstructor {
public:
HasExternalConstructor(const std::string& str)
@@ -1831,7 +1865,7 @@ int overloaded_function(int i, int j) {
class MultipleCtors {
public:
- int value;
+ int value = 0;
MultipleCtors(int i) {
value = 1;
@@ -1854,6 +1888,25 @@ public:
}
};
+class MultipleSmartCtors {
+public:
+ int value = 0;
+
+ MultipleSmartCtors(int i) {
+ value = 1;
+ assert(i == 10);
+ }
+ MultipleSmartCtors(int i, int j) {
+ value = 2;
+ assert(i == 20);
+ assert(j == 20);
+ }
+
+ int WhichCtorCalled() const {
+ return value;
+ }
+};
+
class MultipleOverloads {
public:
MultipleOverloads() {}
@@ -1960,7 +2013,15 @@ EMSCRIPTEN_BINDINGS(overloads) {
.constructor<int>()
.constructor<int, int>()
.constructor<int, int, int>()
- .function("WhichCtorCalled", &MultipleCtors::WhichCtorCalled);
+ .function("WhichCtorCalled", &MultipleCtors::WhichCtorCalled)
+ ;
+
+ class_<MultipleSmartCtors>("MultipleSmartCtors")
+ .smart_ptr<std::shared_ptr<MultipleSmartCtors>>()
+ .constructor(&std::make_shared<MultipleSmartCtors, int>)
+ .constructor(&std::make_shared<MultipleSmartCtors, int, int>)
+ .function("WhichCtorCalled", &MultipleSmartCtors::WhichCtorCalled)
+ ;
class_<MultipleOverloads>("MultipleOverloads")
.constructor<>()
diff --git a/tests/float_tex.cpp b/tests/float_tex.cpp
index 475f2bee..61531124 100644
--- a/tests/float_tex.cpp
+++ b/tests/float_tex.cpp
@@ -9,7 +9,7 @@ extern "C" {
}
static const char vertex_shader[] =
"#ifdef GL_ES\n"
- "precision highp float;\n"
+ "precision lowp float;\n"
"#endif\n"
"attribute float indices;\n"
"uniform sampler2D nodeInfo;\n"
@@ -25,7 +25,7 @@ static const char vertex_shader[] =
"}\n";
static const char fragment_shader[] =
"#ifdef GL_ES\n"
- "precision highp float;\n"
+ "precision lowp float;\n"
"#endif\n"
"\n"
"varying vec4 color;\n"
diff --git a/tests/gl_subdata.cpp b/tests/gl_subdata.cpp
index d159b2b2..5c6a9926 100644
--- a/tests/gl_subdata.cpp
+++ b/tests/gl_subdata.cpp
@@ -9,7 +9,7 @@ extern "C" {
}
static const char vertex_shader[] =
"#ifdef GL_ES\n"
- "precision highp float;\n"
+ "precision lowp float;\n"
"#endif\n"
"attribute float indices;\n"
"uniform sampler2D nodeInfo;\n"
@@ -25,7 +25,7 @@ static const char vertex_shader[] =
"}\n";
static const char fragment_shader[] =
"#ifdef GL_ES\n"
- "precision highp float;\n"
+ "precision lowp float;\n"
"#endif\n"
"\n"
"varying vec4 color;\n"
diff --git a/tests/lua/binarytrees.lua b/tests/lua/binarytrees.lua
new file mode 100644
index 00000000..2ae3dd69
--- /dev/null
+++ b/tests/lua/binarytrees.lua
@@ -0,0 +1,50 @@
+-- The Computer Language Benchmarks Game
+-- http://benchmarksgame.alioth.debian.org/
+-- contributed by Mike Pall
+
+local function BottomUpTree(item, depth)
+ if depth > 0 then
+ local i = item + item
+ depth = depth - 1
+ local left, right = BottomUpTree(i-1, depth), BottomUpTree(i, depth)
+ return { item, left, right }
+ else
+ return { item }
+ end
+end
+
+local function ItemCheck(tree)
+ if tree[2] then
+ return tree[1] + ItemCheck(tree[2]) - ItemCheck(tree[3])
+ else
+ return tree[1]
+ end
+end
+
+local N = tonumber(arg and arg[1]) or 0
+local mindepth = 4
+local maxdepth = mindepth + 2
+if maxdepth < N then maxdepth = N end
+
+do
+ local stretchdepth = maxdepth + 1
+ local stretchtree = BottomUpTree(0, stretchdepth)
+ io.write(string.format("stretch tree of depth %d\t check: %d\n",
+ stretchdepth, ItemCheck(stretchtree)))
+end
+
+local longlivedtree = BottomUpTree(0, maxdepth)
+
+for depth=mindepth,maxdepth,2 do
+ local iterations = 2 ^ (maxdepth - depth + mindepth)
+ local check = 0
+ for i=1,iterations do
+ check = check + ItemCheck(BottomUpTree(1, depth)) +
+ ItemCheck(BottomUpTree(-1, depth))
+ end
+ io.write(string.format("%d\t trees of depth %d\t check: %d\n",
+ iterations*2, depth, check))
+end
+
+io.write(string.format("long lived tree of depth %d\t check: %d\n",
+ maxdepth, ItemCheck(longlivedtree)))
diff --git a/tests/lua/scimark.lua b/tests/lua/scimark.lua
new file mode 100644
index 00000000..7e37c219
--- /dev/null
+++ b/tests/lua/scimark.lua
@@ -0,0 +1,424 @@
+------------------------------------------------------------------------------
+-- Lua SciMark (2010-12-20).
+--
+-- A literal translation of SciMark 2.0a, written in Java and C.
+-- Credits go to the original authors Roldan Pozo and Bruce Miller.
+-- See: http://math.nist.gov/scimark2/
+------------------------------------------------------------------------------
+-- Copyright (C) 2006-2010 Mike Pall. All rights reserved.
+--
+-- Permission is hereby granted, free of charge, to any person obtaining
+-- a copy of this software and associated documentation files (the
+-- "Software"), to deal in the Software without restriction, including
+-- without limitation the rights to use, copy, modify, merge, publish,
+-- distribute, sublicense, and/or sell copies of the Software, and to
+-- permit persons to whom the Software is furnished to do so, subject to
+-- the following conditions:
+--
+-- The above copyright notice and this permission notice shall be
+-- included in all copies or substantial portions of the Software.
+--
+-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+-- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+-- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+-- IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+-- CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+-- TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+-- SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+--
+-- [ MIT license: http://www.opensource.org/licenses/mit-license.php ]
+------------------------------------------------------------------------------
+
+local SCIMARK_VERSION = "2010-12-10"
+local SCIMARK_COPYRIGHT = "Copyright (C) 2006-2010 Mike Pall"
+
+local MIN_TIME = 0.8
+local RANDOM_SEED = 101009 -- Must be odd.
+local SIZE_SELECT = "small"
+
+local benchmarks = {
+ "FFT", "SOR", "MC", "SPARSE", "LU",
+ small = {
+ FFT = { 1024 },
+ SOR = { 100 },
+ MC = { },
+ SPARSE = { 1000, 5000 },
+ LU = { 100 },
+ },
+ large = {
+ FFT = { 1048576 },
+ SOR = { 1000 },
+ MC = { },
+ SPARSE = { 100000, 1000000 },
+ LU = { 1000 },
+ },
+}
+
+local abs, log, sin, floor = math.abs, math.log, math.sin, math.floor
+local pi, clock = math.pi, os.clock
+local format = string.format
+
+------------------------------------------------------------------------------
+-- Select array type: Lua tables or native (FFI) arrays
+------------------------------------------------------------------------------
+
+local darray, iarray
+
+local function array_init()
+ if jit and jit.status and jit.status() then
+ local ok, ffi = pcall(require, "ffi")
+ if ok then
+ darray = ffi.typeof("double[?]")
+ iarray = ffi.typeof("int[?]")
+ return
+ end
+ end
+ function darray(n) return {} end
+ iarray = darray
+end
+
+------------------------------------------------------------------------------
+-- This is a Lagged Fibonacci Pseudo-random Number Generator with
+-- j, k, M = 5, 17, 31. Pretty weak, but same as C/Java SciMark.
+------------------------------------------------------------------------------
+
+local rand, rand_init
+
+if jit and jit.status and jit.status() then
+ -- LJ2 has bit operations and zero-based arrays (internally).
+ local bit = require("bit")
+ local band, sar = bit.band, bit.arshift
+ function rand_init(seed)
+ local Rm, Rj, Ri = iarray(17), 16, 11
+ for i=0,16 do Rm[i] = 0 end
+ for i=16,0,-1 do
+ seed = band(seed*9069, 0x7fffffff)
+ Rm[i] = seed
+ end
+ function rand()
+ local i = band(Ri+1, sar(Ri-16, 31))
+ local j = band(Rj+1, sar(Rj-16, 31))
+ Ri, Rj = i, j
+ local k = band(Rm[i] - Rm[j], 0x7fffffff)
+ Rm[j] = k
+ return k * (1.0/2147483647.0)
+ end
+ end
+else
+ -- Better for standard Lua with one-based arrays and without bit operations.
+ function rand_init(seed)
+ local Rm, Rj = {}, 1
+ for i=1,17 do Rm[i] = 0 end
+ for i=17,1,-1 do
+ seed = (seed*9069) % (2^31)
+ Rm[i] = seed
+ end
+ function rand()
+ local j, m = Rj, Rm
+ local h = j - 5
+ if h < 1 then h = h + 17 end
+ local k = m[h] - m[j]
+ if k < 0 then k = k + 2147483647 end
+ m[j] = k
+ if j < 17 then Rj = j + 1 else Rj = 1 end
+ return k * (1.0/2147483647.0)
+ end
+ end
+end
+
+local function random_vector(n)
+ local v = darray(n+1)
+ for x=1,n do v[x] = rand() end
+ return v
+end
+
+local function random_matrix(m, n)
+ local a = {}
+ for y=1,m do
+ local v = darray(n+1)
+ a[y] = v
+ for x=1,n do v[x] = rand() end
+ end
+ return a
+end
+
+------------------------------------------------------------------------------
+-- FFT: Fast Fourier Transform.
+------------------------------------------------------------------------------
+
+local function fft_bitreverse(v, n)
+ local j = 0
+ for i=0,2*n-4,2 do
+ if i < j then
+ v[i+1], v[i+2], v[j+1], v[j+2] = v[j+1], v[j+2], v[i+1], v[i+2]
+ end
+ local k = n
+ while k <= j do j = j - k; k = k / 2 end
+ j = j + k
+ end
+end
+
+local function fft_transform(v, n, dir)
+ if n <= 1 then return end
+ fft_bitreverse(v, n)
+ local dual = 1
+ repeat
+ local dual2 = 2*dual
+ for i=1,2*n-1,2*dual2 do
+ local j = i+dual2
+ local ir, ii = v[i], v[i+1]
+ local jr, ji = v[j], v[j+1]
+ v[j], v[j+1] = ir - jr, ii - ji
+ v[i], v[i+1] = ir + jr, ii + ji
+ end
+ local theta = dir * pi / dual
+ local s, s2 = sin(theta), 2.0 * sin(theta * 0.5)^2
+ local wr, wi = 1.0, 0.0
+ for a=3,dual2-1,2 do
+ wr, wi = wr - s*wi - s2*wr, wi + s*wr - s2*wi
+ for i=a,a+2*(n-dual2),2*dual2 do
+ local j = i+dual2
+ local jr, ji = v[j], v[j+1]
+ local dr, di = wr*jr - wi*ji, wr*ji + wi*jr
+ local ir, ii = v[i], v[i+1]
+ v[j], v[j+1] = ir - dr, ii - di
+ v[i], v[i+1] = ir + dr, ii + di
+ end
+ end
+ dual = dual2
+ until dual >= n
+end
+
+function benchmarks.FFT(n)
+ local l2n = log(n)/log(2)
+ if l2n % 1 ~= 0 then
+ io.stderr:write("Error: FFT data length is not a power of 2\n")
+ os.exit(1)
+ end
+ local v = random_vector(n*2)
+ return function(cycles)
+ local norm = 1.0 / n
+ for p=1,cycles do
+ fft_transform(v, n, -1)
+ fft_transform(v, n, 1)
+ for i=1,n*2 do v[i] = v[i] * norm end
+ end
+ return ((5*n-2)*l2n + 2*(n+1)) * cycles
+ end
+end
+
+------------------------------------------------------------------------------
+-- SOR: Jacobi Successive Over-Relaxation.
+------------------------------------------------------------------------------
+
+local function sor_run(mat, m, n, cycles, omega)
+ local om4, om1 = omega*0.25, 1.0-omega
+ m = m - 1
+ n = n - 1
+ for i=1,cycles do
+ for y=2,m do
+ local v, vp, vn = mat[y], mat[y-1], mat[y+1]
+ for x=2,n do
+ v[x] = om4*((vp[x]+vn[x])+(v[x-1]+v[x+1])) + om1*v[x]
+ end
+ end
+ end
+end
+
+function benchmarks.SOR(n)
+ local mat = random_matrix(n, n)
+ return function(cycles)
+ sor_run(mat, n, n, cycles, 1.25)
+ return (n-1)*(n-1)*cycles*6
+ end
+end
+
+------------------------------------------------------------------------------
+-- MC: Monte Carlo Integration.
+------------------------------------------------------------------------------
+
+local function mc_integrate(cycles)
+ local under_curve = 0
+ local rand = rand
+ for i=1,cycles do
+ local x = rand()
+ local y = rand()
+ if x*x + y*y <= 1.0 then under_curve = under_curve + 1 end
+ end
+ return (under_curve/cycles) * 4
+end
+
+function benchmarks.MC()
+ return function(cycles)
+ local res = mc_integrate(cycles)
+ assert(math.sqrt(cycles)*math.abs(res-math.pi) < 5.0, "bad MC result")
+ return cycles * 4 -- Way off, but same as SciMark in C/Java.
+ end
+end
+
+------------------------------------------------------------------------------
+-- Sparse Matrix Multiplication.
+------------------------------------------------------------------------------
+
+local function sparse_mult(n, cycles, vy, val, row, col, vx)
+ for p=1,cycles do
+ for r=1,n do
+ local sum = 0
+ for i=row[r],row[r+1]-1 do sum = sum + vx[col[i]] * val[i] end
+ vy[r] = sum
+ end
+ end
+end
+
+function benchmarks.SPARSE(n, nz)
+ local nr = floor(nz/n)
+ local anz = nr*n
+ local vx = random_vector(n)
+ local val = random_vector(anz)
+ local vy, col, row = darray(n+1), iarray(nz+1), iarray(n+2)
+ row[1] = 1
+ for r=1,n do
+ local step = floor(r/nr)
+ if step < 1 then step = 1 end
+ local rr = row[r]
+ row[r+1] = rr+nr
+ for i=0,nr-1 do col[rr+i] = 1+i*step end
+ end
+ return function(cycles)
+ sparse_mult(n, cycles, vy, val, row, col, vx)
+ return anz*cycles*2
+ end
+end
+
+------------------------------------------------------------------------------
+-- LU: Dense Matrix Factorization.
+------------------------------------------------------------------------------
+
+local function lu_factor(a, pivot, m, n)
+ local min_m_n = m < n and m or n
+ for j=1,min_m_n do
+ local jp, t = j, abs(a[j][j])
+ for i=j+1,m do
+ local ab = abs(a[i][j])
+ if ab > t then
+ jp = i
+ t = ab
+ end
+ end
+ pivot[j] = jp
+ if a[jp][j] == 0 then error("zero pivot") end
+ if jp ~= j then a[j], a[jp] = a[jp], a[j] end
+ if j < m then
+ local recp = 1.0 / a[j][j]
+ for k=j+1,m do
+ local v = a[k]
+ v[j] = v[j] * recp
+ end
+ end
+ if j < min_m_n then
+ for i=j+1,m do
+ local vi, vj = a[i], a[j]
+ local eij = vi[j]
+ for k=j+1,n do vi[k] = vi[k] - eij * vj[k] end
+ end
+ end
+ end
+end
+
+local function matrix_alloc(m, n)
+ local a = {}
+ for y=1,m do a[y] = darray(n+1) end
+ return a
+end
+
+local function matrix_copy(dst, src, m, n)
+ for y=1,m do
+ local vd, vs = dst[y], src[y]
+ for x=1,n do vd[x] = vs[x] end
+ end
+end
+
+function benchmarks.LU(n)
+ local mat = random_matrix(n, n)
+ local tmp = matrix_alloc(n, n)
+ local pivot = iarray(n+1)
+ return function(cycles)
+ for i=1,cycles do
+ matrix_copy(tmp, mat, n, n)
+ lu_factor(tmp, pivot, n, n)
+ end
+ return 2.0/3.0*n*n*n*cycles
+ end
+end
+
+------------------------------------------------------------------------------
+-- Main program.
+------------------------------------------------------------------------------
+
+local function printf(...)
+ io.write(format(...))
+end
+
+local function fmtparams(p1, p2)
+ if p2 then return format("[%d, %d]", p1, p2)
+ elseif p1 then return format("[%d]", p1) end
+ return ""
+end
+
+local function measure(min_time, name, ...)
+ array_init()
+ rand_init(RANDOM_SEED)
+ local run = benchmarks[name](...)
+ local cycles = 1
+ repeat
+ local tm = clock()
+ local flops = run(cycles, ...)
+ tm = clock() - tm
+ if tm >= min_time then
+ local res = flops / tm * 1.0e-6
+ local p1, p2 = ...
+ printf("%-7s %8.2f %s\n", name, res, fmtparams(...))
+ return res
+ end
+ cycles = cycles * 2
+ until false
+end
+
+--printf("Lua SciMark %s based on SciMark 2.0a. %s.\n\n",
+-- SCIMARK_VERSION, SCIMARK_COPYRIGHT)
+
+while arg and arg[1] do
+ local a = table.remove(arg, 1)
+ if a == "-noffi" then
+ package.preload.ffi = nil
+ elseif a == "-small" then
+ SIZE_SELECT = "small"
+ elseif a == "-large" then
+ SIZE_SELECT = "large"
+ elseif benchmarks[a] then
+ local p = benchmarks[SIZE_SELECT][a]
+ measure(MIN_TIME, a, tonumber(arg[1]) or p[1], tonumber(arg[2]) or p[2])
+ return
+ else
+ printf("Usage: scimark [-noffi] [-small|-large] [BENCH params...]\n\n")
+ printf("BENCH -small -large\n")
+ printf("---------------------------------------\n")
+ for _,name in ipairs(benchmarks) do
+ printf("%-7s %-13s %s\n", name,
+ fmtparams(unpack(benchmarks.small[name])),
+ fmtparams(unpack(benchmarks.large[name])))
+ end
+ printf("\n")
+ os.exit(1)
+ end
+end
+
+local params = benchmarks[SIZE_SELECT]
+local sum = 0
+for _,name in ipairs(benchmarks) do
+ sum = sum + measure(MIN_TIME, name, unpack(params[name]))
+end
+printf("\nSciMark %8.2f [%s problem sizes]\n", sum / #benchmarks, SIZE_SELECT)
+io.flush()
+
+
diff --git a/tests/lua/src/Makefile b/tests/lua/src/Makefile
index 7741ef75..401e7367 100644
--- a/tests/lua/src/Makefile
+++ b/tests/lua/src/Makefile
@@ -10,7 +10,7 @@ PLAT= none
#CC= gcc
CFLAGS= -O2 -Wall -DLUA_COMPAT_ALL $(SYSCFLAGS) $(MYCFLAGS)
#LDFLAGS= $(SYSLDFLAGS) $(MYLDFLAGS)
-#LIBS= -lm $(SYSLIBS) $(MYLIBS)
+LIBS= -lm $(SYSLIBS) $(MYLIBS)
#AR= ar
#RANLIB= ranlib
diff --git a/tests/runner.py b/tests/runner.py
index ff16cbbe..afb71ad9 100755
--- a/tests/runner.py
+++ b/tests/runner.py
@@ -366,7 +366,7 @@ process(sys.argv[1])
print >> sys.stderr, '<load %s from cache> ' % cache_name,
generated_libs = []
for basename, contents in self.library_cache[cache_name]:
- bc_file = os.path.join(build_dir, basename)
+ bc_file = os.path.join(build_dir, cache_name + '_' + basename)
f = open(bc_file, 'wb')
f.write(contents)
f.close()
@@ -1179,6 +1179,53 @@ m_divisor is 1091269979
'''
self.do_run(src, 'Succeeded!')
+ def test_i64_varargs(self):
+ if Settings.USE_TYPED_ARRAYS != 2: return self.skip('full i64 stuff only in ta2')
+
+ src = r'''
+ #include <stdio.h>
+ #include <stdint.h>
+ #include <stdarg.h>
+
+ int64_t ccv_cache_generate_signature(char *msg, int len, int64_t sig_start, ...) {
+ if (sig_start < 10123)
+ printf("%s\n", msg+len);
+ va_list v;
+ va_start(v, sig_start);
+ if (sig_start > 1413)
+ printf("%d\n", va_arg(v, int));
+ else
+ printf("nada\n");
+ va_end(v);
+ return len*sig_start*(msg[0]+1);
+ }
+
+ int main(int argc, char **argv)
+ {
+ for (int i = 0; i < argc; i++) {
+ int64_t x;
+ if (i % 123123 == 0)
+ x = ccv_cache_generate_signature(argv[i], i+2, (int64_t)argc*argc, 54.111);
+ else
+ x = ccv_cache_generate_signature(argv[i], i+2, (int64_t)argc*argc, 13);
+ printf("%lld\n", x);
+ }
+ };
+ '''
+ self.do_run(src, '''in/this.program
+nada
+1536
+a
+nada
+5760
+fl
+nada
+6592
+sdfasdfasdf
+nada
+7840
+''', 'waka fleefl asdfasdfasdfasdf'.split(' '))
+
def test_i32_mul_precise(self):
if self.emcc_args == None: return self.skip('needs ta2')
@@ -12593,9 +12640,18 @@ elif 'benchmark' in str(sys.argv):
Building.COMPILER_TEST_OPTS = []
- TEST_REPS = 4
+ TEST_REPS = 2
TOTAL_TESTS = 8
+ # standard arguments for timing:
+ # 0: no runtime, just startup
+ # 1: very little runtime
+ # 2: 0.5 seconds
+ # 3: 1 second
+ # 4: 5 seconds
+ # 5: 10 seconds
+ DEFAULT_ARG = '4'
+
tests_done = 0
total_times = map(lambda x: 0., range(TOTAL_TESTS))
total_native_times = map(lambda x: 0., range(TOTAL_TESTS))
@@ -12633,15 +12689,9 @@ elif 'benchmark' in str(sys.argv):
print ' JavaScript: mean: %.3f (+-%.3f) secs median: %.3f range: %.3f-%.3f (noise: %3.3f%%) (%d runs)' % (mean, std, median, min(times), max(times), 100*std/mean, reps)
print ' Native : mean: %.3f (+-%.3f) secs median: %.3f range: %.3f-%.3f (noise: %3.3f%%) JS is %.2f X slower' % (mean_native, std_native, median_native, min(native_times), max(native_times), 100*std_native/mean_native, final)
- def do_benchmark(self, name, src, expected_output='FAIL', args=[], emcc_args=[], native_args=[], shared_args=[], force_c=False, reps=TEST_REPS):
- # standard arguments for timing:
- # 0: no runtime, just startup
- # 1: very little runtime
- # 2: 0.5 seconds
- # 3: 1 second
- # 4: 5 seconds
- # 5: 10 seconds
- args = args or ['3']
+ def do_benchmark(self, name, src, expected_output='FAIL', args=[], emcc_args=[], native_args=[], shared_args=[], force_c=False, reps=TEST_REPS, native_exec=None, output_parser=None, args_processor=None):
+ args = args or [DEFAULT_ARG]
+ if args_processor: args = args_processor(args)
dirname = self.get_dir()
filename = os.path.join(dirname, name + '.c' + ('' if force_c else 'pp'))
@@ -12671,7 +12721,10 @@ elif 'benchmark' in str(sys.argv):
if i == 0 and 'uccessfully compiled asm.js code' in js_output:
if 'asm.js link error' not in js_output:
print "[%s was asm.js'ified]" % name
- curr = time.time()-start
+ if not output_parser:
+ curr = time.time()-start
+ else:
+ curr = output_parser(js_output)
times.append(curr)
total_times[tests_done] += curr
if i == 0:
@@ -12679,7 +12732,11 @@ elif 'benchmark' in str(sys.argv):
self.assertContained(expected_output, js_output)
# Run natively
- self.build_native(filename, shared_args + native_args)
+ if not native_exec:
+ self.build_native(filename, shared_args + native_args)
+ else:
+ shutil.copyfile(native_exec, filename + '.native')
+ shutil.copymode(native_exec, filename + '.native')
global total_native_times
native_times = []
for i in range(reps):
@@ -12688,7 +12745,10 @@ elif 'benchmark' in str(sys.argv):
if i == 0:
# Sanity check on output
self.assertContained(expected_output, native_output)
- curr = time.time()-start
+ if not output_parser:
+ curr = time.time()-start
+ else:
+ curr = output_parser(native_output)
native_times.append(curr)
total_native_times[tests_done] += curr
@@ -12733,7 +12793,7 @@ elif 'benchmark' in str(sys.argv):
return 0;
}
'''
- self.do_benchmark('primes', src, 'lastprime: 3043739.')
+ self.do_benchmark('primes', src, 'lastprime:')
def test_memops(self):
src = '''
@@ -12766,7 +12826,7 @@ elif 'benchmark' in str(sys.argv):
return 0;
}
'''
- self.do_benchmark('memops', src, 'final: 400.')
+ self.do_benchmark('memops', src, 'final:')
def zzztest_files(self):
src = r'''
@@ -12863,7 +12923,7 @@ elif 'benchmark' in str(sys.argv):
return 0;
}
'''
- self.do_benchmark('copy', src, 'sum:2836\n')
+ self.do_benchmark('copy', src, 'sum:')
def test_fannkuch(self):
src = open(path_from_root('tests', 'fannkuch.cpp'), 'r').read().replace(
@@ -12883,7 +12943,7 @@ elif 'benchmark' in str(sys.argv):
'''
)
assert 'switch(arg)' in src
- self.do_benchmark('fannkuch', src, 'Pfannkuchen(11) = 51.')
+ self.do_benchmark('fannkuch', src, 'Pfannkuchen(')
def test_corrections(self):
src = r'''
@@ -12916,7 +12976,7 @@ elif 'benchmark' in str(sys.argv):
return 0;
}
'''
- self.do_benchmark('corrections', src, 'final: 40006013:10225.', emcc_args=['-s', 'CORRECT_SIGNS=1', '-s', 'CORRECT_OVERFLOWS=1', '-s', 'CORRECT_ROUNDINGS=1'])
+ self.do_benchmark('corrections', src, 'final:', emcc_args=['-s', 'CORRECT_SIGNS=1', '-s', 'CORRECT_OVERFLOWS=1', '-s', 'CORRECT_ROUNDINGS=1'])
def fasta(self, name, double_rep, emcc_args=[]):
src = open(path_from_root('tests', 'fasta.cpp'), 'r').read().replace('double', double_rep)
@@ -12934,7 +12994,7 @@ elif 'benchmark' in str(sys.argv):
}
''')
assert 'switch(arg)' in src
- self.do_benchmark('fasta', src, '''GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA\nTCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT\nAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG\nGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG\nCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT\nGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA\nGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA\nTTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG\nAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA\nGCCTGGGCGA''')
+ self.do_benchmark('fasta', src, '')
def test_fasta_float(self):
self.fasta('fasta_float', 'float')
@@ -12951,59 +13011,62 @@ elif 'benchmark' in str(sys.argv):
def test_life(self):
src = open(path_from_root('tests', 'life.c'), 'r').read()
- self.do_benchmark('life', src, '''--------------------------------
- [][] [] []
- [][] [][] [] []
- [][] [] []
- [][] [] []
- [] [][] []
- [][] [] [] [] []
- [][] [] [] [] []
- [] [][] []
- [][] [][]
- [][] [][] [] []
- [][] [][] [][] []
- [][] []
- []
- []
- [] []
-[] [][][] [] []
- [] [][][][][][] [] [][]
- [] [][] [] [] [][] [] []
-[] [] [][] [] []
- [][] [] [][][] [][]
- [] [] [][][]
- [][] [][][][]
- [][] [][] []
- [] [][] []
- [][]
- [][] []
- [] [][][][][]
-[][][] [][]
- [][] [] [][][]
- [] [] [][]
- []
- [] [][] [][][]
---------------------------------''', shared_args=['-std=c99'], force_c=True)
-
- def test_nbody_java(self): # tests xmlvm compiled java, including bitcasts of doubles, i64 math, etc.
+ self.do_benchmark('life', src, '''--------------------------------''', shared_args=['-std=c99'], force_c=True)
+
+ def test_zzz_java_nbody(self): # tests xmlvm compiled java, including bitcasts of doubles, i64 math, etc.
args = [path_from_root('tests', 'nbody-java', x) for x in os.listdir(path_from_root('tests', 'nbody-java')) if x.endswith('.c')] + \
['-I' + path_from_root('tests', 'nbody-java')]
self.do_benchmark('nbody_java', '', '''Time(s)''',
force_c=True, emcc_args=args + ['-s', 'PRECISE_I64_MATH=1', '--llvm-lto', '0'], native_args=args + ['-lgc', '-std=c99', '-target', 'x86_64-pc-linux-gnu', '-lm'])
- def test_zlib(self):
+ def lua(self, benchmark, expected, output_parser=None, args_processor=None):
+ shutil.copyfile(path_from_root('tests', 'lua', benchmark + '.lua'), benchmark + '.lua')
+ #shutil.copyfile(path_from_root('tests', 'lua', 'binarytrees.lua'), 'binarytrees.lua')
+ #shutil.copyfile(path_from_root('tests', 'lua', 'scimark.lua'), 'scimark.lua')
+ emcc_args = self.get_library('lua', [os.path.join('src', 'lua'), os.path.join('src', 'liblua.a')], make=['make', 'generic'], configure=None) + \
+ ['--embed-file', benchmark + '.lua']
+ #['--embed-file', 'binarytrees.lua', '--embed-file', 'scimark.lua'] + ['--minify', '0']
+ shutil.copyfile(emcc_args[0], emcc_args[0] + '.bc')
+ emcc_args[0] += '.bc'
+ native_args = self.get_library('lua_native', [os.path.join('src', 'lua'), os.path.join('src', 'liblua.a')], make=['make', 'generic'], configure=None, native=True)
+
+ self.do_benchmark('lua_' + benchmark, '', expected,
+ force_c=True, args=[benchmark + '.lua'], emcc_args=emcc_args, native_args=native_args, native_exec=os.path.join('building', 'lua_native', 'src', 'lua'),
+ output_parser=output_parser, args_processor=args_processor)
+
+ def test_zzz_lua_scimark(self):
+ def output_parser(output):
+ return 1.0/float(re.search('\nSciMark +([\d\.]+) ', output).group(1))
+
+ self.lua('scimark', '[small problem sizes]', output_parser=output_parser)
+
+ def test_zzz_lua_binarytrees(self):
+ def args_processor(args):
+ arg = int(DEFAULT_ARG)
+ if arg == 0:
+ return args + ['0']
+ elif arg == 1:
+ return args + ['9.5']
+ elif arg == 2:
+ return args + ['11.99']
+ elif arg == 3:
+ return args + ['12.85']
+ elif arg == 4:
+ return args + ['14.72']
+ elif arg == 5:
+ return args + ['15.82']
+ self.lua('binarytrees', 'long lived tree of depth', args_processor=args_processor)
+
+ def test_zzz_zlib(self):
src = open(path_from_root('tests', 'zlib', 'benchmark.c'), 'r').read()
emcc_args = self.get_library('zlib', os.path.join('libz.a'), make_args=['libz.a']) + \
['-I' + path_from_root('tests', 'zlib')]
native_args = self.get_library('zlib_native', os.path.join('libz.a'), make_args=['libz.a'], native=True) + \
['-I' + path_from_root('tests', 'zlib')]
- self.do_benchmark('zlib', src, '''sizes: 100000,25906
-ok.
-''',
+ self.do_benchmark('zlib', src, '''ok.''',
force_c=True, emcc_args=emcc_args, native_args=native_args)
- def test_yyy_box2d(self): # Called thus so it runs late in the alphabetical cycle... it is long
+ def test_zzz_box2d(self): # Called thus so it runs late in the alphabetical cycle... it is long
src = open(path_from_root('tests', 'box2d', 'Benchmark.cpp'), 'r').read()
js_lib = self.get_library('box2d', [os.path.join('box2d.a')], configure=None)
generated by cgit v1.2.3-70-g09d2 (git 2.46.0) at 2025-09-18 19:38:16 +0000