EMBIND_AOT should AOT method callers

[RReverser]

We have emval_methodCallers mechanism used for foo() and foo.call<...>(...) on emscripten::val instances here:

emscripten/src/lib/libemval.js

Lines 284 to 352 in 2fe9aeb

	// Leave id 0 undefined. It's not a big deal, but might be confusing
	// to have null be a valid method caller.
	$emval_methodCallers: [undefined],
	$emval_addMethodCaller__deps: ['$emval_methodCallers'],
	$emval_addMethodCaller: (caller) => {
	var id = emval_methodCallers.length;
	emval_methodCallers.push(caller);
	return id;
	},
	_emval_get_method_caller__deps: [
	'$emval_addMethodCaller', '$emval_lookupTypes',
	'$createNamedFunction', '$emval_returnValue',
	],
	_emval_get_method_caller: (argCount, argTypes, kind) => {
	var GenericWireTypeSize = {{{ 2 * POINTER_SIZE }}};
	var types = emval_lookupTypes(argCount, argTypes);
	var retType = types.shift();
	argCount--; // remove the shifted off return type
	#if !DYNAMIC_EXECUTION
	var argN = new Array(argCount);
	var invokerFunction = (obj, func, destructorsRef, args) => {
	var offset = 0;
	for (var i = 0; i < argCount; ++i) {
	argN[i] = types[i]['readValueFromPointer'](args + offset);
	offset += GenericWireTypeSize;
	}
	var rv = kind === /* CONSTRUCTOR */ 1 ? Reflect.construct(func, argN) : func.apply(obj, argN);
	return emval_returnValue(retType, destructorsRef, rv);
	};
	#else
	var functionBody =
	`return function (obj, func, destructorsRef, args) {\n`;
	var offset = 0;
	var argsList = []; // 'obj?, arg0, arg1, arg2, ... , argN'
	if (kind === /* FUNCTION */ 0) {
	argsList.push('obj');
	}
	var params = ['retType'];
	var args = [retType];
	for (var i = 0; i < argCount; ++i) {
	argsList.push(`arg${i}`);
	params.push(`argType${i}`);
	args.push(types[i]);
	functionBody +=
	` var arg${i} = argType${i}.readValueFromPointer(args${offset ? '+' + offset : ''});\n`;
	offset += GenericWireTypeSize;
	}
	var invoker = kind === /* CONSTRUCTOR */ 1 ? 'new func' : 'func.call';
	functionBody +=
	` var rv = ${invoker}(${argsList.join(', ')});\n`;
	if (!retType.isVoid) {
	params.push('emval_returnValue');
	args.push(emval_returnValue);
	functionBody +=
	' return emval_returnValue(retType, destructorsRef, rv);\n';
	}
	functionBody +=
	"};\n";
	var invokerFunction = new Function(...params, functionBody)(...args);
	#endif
	var functionName = `methodCaller<(${types.map(t => t.name).join(', ')}) => ${retType.name}>`;
	return emval_addMethodCaller(createNamedFunction(functionName, invokerFunction));
	},

Right now it either constructs a JS function from strings on the fly, or uses a slower mechanism with looking up all the types on each invocation.

As far as I can tell, it should be fairly straightforward to add it to the EMBIND_AOT processing so that specialized function is generated during compile-time and then reused. cc @brendandahl

[RReverser]

Although perhaps "straightforward" is an exaggeration since it can't be easily converted to a top-level static and at the moment method callers are registered lazily...

[brendandahl]

Yeah, discovering which method callers are used is the hard part. One option that would be a bigger change is we could make a "typed" version of val, where you'd define a C++ interface to a JS object. The project typescripten does something similar to this, but behind the scenes it is still built on on val. I imagine we could change it to also build some static initializers that register all the invokers.

Another option, require users to register the signatures they want to use with call or operator() in EMSCRIPTEN_BINDINGS. Something like

EMSCRIPTEN_BINDINGS(invokers) {
  register_invoker<SomeReturnType, ArgType1, ArgType2>();
}

[RReverser]

Another option, require users to register the signatures they want to use with call or operator() in EMSCRIPTEN_BINDINGS. Something like

Yeah I really don't like that option, feels like exposing implementation details.

I wonder if we can use linker shenanigans here somehow? Like, have each template link to an external C++ method caller and then find them during embind_gen? The mangling scheme is pretty well-established so it should be possible to recover precise C++ types.

[RReverser]

Or I guess you could even compute typeid-based signature in a static constexpr and store it in a custom Wasm section.

[brendandahl]

Or I guess you could even compute typeid-based signature in a static constexpr and store it in a custom Wasm section.

I tried to do something like this for another part of the bindings code, but constexpr isn't guaranteed to be computed at compile time. We'd probably need consteval.

[RReverser]

Which is not C+11... Hmm... I'd think typeid + simple concat ops would always be const, but needs testing.

As another alternative, maybe EMSCRIPTEN_KEEPALIVE aka attribute(used) with some well-known prefix? Then it doesn't even have to be constexpr, as you can detect and invoke them during generation.

[sbc100]

We have discussed moving the min embind requirement to C++17.. maybe this is a good additional motivator?

[RReverser]

consteval is C++20, would you want to jump straight to that?

[sbc100]

Yeah, maybe not. The clang default in C++17.. I'm not sure I'd want to jump ahead of that.

[RReverser]

As another alternative, maybe EMSCRIPTEN_KEEPALIVE aka attribute(used) with some well-known prefix? Then it doesn't even have to be constexpr, as you can detect and invoke them during generation.

FWIW from a quick look, this seems to work pretty well:

PS D:\emscripten> .\emcc D:\emscripten\test\code_size\embind_val_hello_world.cpp -lembind
PS D:\emscripten> wasm-objdump -x -j export a.out.wasm

a.out.wasm:     file format wasm 0x1

Section Details:

Export[18]:
 - memory[0] -> "memory"
 - func[19] <__wasm_call_ctors> -> "__wasm_call_ctors"
 - func[31] <_ZN10emscripten8internal9SignatureILNS0_21EM_METHOD_CALLER_KINDE0EbJRKNS_3valES3_EE20registerMethodCallerEv> -> "_ZN10emscripten8internal9SignatureILNS0_21EM_METHOD_CALLER_KINDE0EbJRKNS_3valES3_EE20registerMethodCallerEv"
 - func[112] <malloc> -> "malloc"
 - func[65] <_ZN10emscripten8internal9SignatureILNS0_21EM_METHOD_CALLER_KINDE0EvJNSt3__212basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEiEE20registerMethodCallerEv> -> "_ZN10emscripten8internal9SignatureILNS0_21EM_METHOD_CALLER_KINDE0EvJNSt3__212basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEiEE20registerMethodCallerEv"
 - func[66] <main> -> "main"
 - table[0] -> "__indirect_function_table"
 - func[225] <__getTypeName> -> "__getTypeName"
 - func[223] <fflush> -> "fflush"
 - func[123] <emscripten_stack_get_end> -> "emscripten_stack_get_end"
 - func[122] <emscripten_stack_get_base> -> "emscripten_stack_get_base"
 - func[128] <strerror> -> "strerror"
 - func[114] <free> -> "free"
 - func[120] <emscripten_stack_init> -> "emscripten_stack_init"
 - func[121] <emscripten_stack_get_free> -> "emscripten_stack_get_free"
 - func[220] <_emscripten_stack_restore> -> "_emscripten_stack_restore"
 - func[221] <_emscripten_stack_alloc> -> "_emscripten_stack_alloc"
 - func[222] <emscripten_stack_get_current> -> "emscripten_stack_get_current"

Or, if we want to look at the unmangled names:

PS D:\emscripten> wasm-objdump -x -j export a.out.wasm | llvm-cxxfilt

a.out.wasm:     file format wasm 0x1

Section Details:

Export[18]:
 - memory[0] -> "memory"
 - func[19] <__wasm_call_ctors> -> "__wasm_call_ctors"
 - func[31] <emscripten::internal::Signature<(emscripten::internal::EM_METHOD_CALLER_KIND)0, bool, emscripten::val const&, emscripten::val>::registerMethodCaller()> -> "emscripten::internal::Signature<(emscripten::internal::EM_METHOD_CALLER_KIND)0, bool, emscripten::val const&, emscripten::val>::registerMethodCaller()"
 - func[112] <malloc> -> "malloc"
 - func[65] <emscripten::internal::Signature<(emscripten::internal::EM_METHOD_CALLER_KIND)0, void, std::__2::basic_string<char, std::__2::char_traits<char>, std::__2::allocator<char>>, int>::registerMethodCaller()> -> "emscripten::internal::Signature<(emscripten::internal::EM_METHOD_CALLER_KIND)0, void, std::__2::basic_string<char, std::__2::char_traits<char>, std::__2::allocator<char>>, int>::registerMethodCaller()"
 - func[66] <main> -> "main"
 - table[0] -> "__indirect_function_table"
 - func[225] <__getTypeName> -> "__getTypeName"
 - func[223] <fflush> -> "fflush"
 - func[123] <emscripten_stack_get_end> -> "emscripten_stack_get_end"
 - func[122] <emscripten_stack_get_base> -> "emscripten_stack_get_base"
 - func[128] <strerror> -> "strerror"
 - func[114] <free> -> "free"
 - func[120] <emscripten_stack_init> -> "emscripten_stack_init"
 - func[121] <emscripten_stack_get_free> -> "emscripten_stack_get_free"
 - func[220] <_emscripten_stack_restore> -> "_emscripten_stack_restore"
 - func[221] <_emscripten_stack_alloc> -> "_emscripten_stack_alloc"
 - func[222] <emscripten_stack_get_current> -> "emscripten_stack_get_current"

So every instantiated caller kind gets its own entry in exports, which embind_gen should be able to find by the common prefix+suffix and invoke to register callers.

[RReverser]

I played with this idea a bit in https://github.com/RReverser/emscripten/tree/aot-method-callers and I think it's pretty feasible. Still needs quite a bit of work to actually extract types and such, but the AOT does output expected shape at least:

  var emval_methodCallers = {
  66728(obj, func, destructorsRef, args) {
  var arg0 = argType0.readValueFromPointer(args);
  var arg1 = argType1.readValueFromPointer(args+8);
  var rv = func.call(obj, arg0, arg1);
  return emval_returnValue(retType, destructorsRef, rv);
},
  66896(obj, func, destructorsRef, args) {
  var arg0 = argType0.readValueFromPointer(args);
  var arg1 = argType1.readValueFromPointer(args+8);
  var rv = func.call(obj, arg0, arg1);
  return emval_returnValue(retType, destructorsRef, rv);
},
  70728(obj, func, destructorsRef, args) {
  var arg0 = argType0.readValueFromPointer(args);
  var rv = func.call(obj, arg0);
  return emval_returnValue(retType, destructorsRef, rv);
},
  71600(obj, func, destructorsRef, args) {
  var arg0 = argType0.readValueFromPointer(args);
  var rv = func.call(obj, arg0);
  return emval_returnValue(retType, destructorsRef, rv);
},
  71732(obj, func, destructorsRef, args) {
  var arg0 = argType0.readValueFromPointer(args);
  var rv = func.call(obj, arg0);
  return emval_returnValue(retType, destructorsRef, rv);
},
};

@brendandahl is this something you'd want to take over and continue by any chance?

[brendandahl]

I can take a look, but it will be a week or two until I can.