Alternative to thread-local globals and functions

[eqrion]

Here's an alternative proposal that provides the ability for shared wasm to implement a form of TLS along with access to unshared state from shared contexts.

This is an evolution of ideas that Luke has mentioned, with some tweaks and additions.

There's two parts:

1. context locals for wasm/user accessible mutable storage during the lifetime of a wasm stack. This provides a space for values like the shadow stack pointer used by linear memory languages.
2. Tweaking rules of shared to allow access to unshared through params/locals/etc

Context locals

The idea here is that we can make available some amount of space in the VM managed context for wasm code to use as mutable storage. The lifetime of values stored there are scoped to an execution stack.

1. Introduce a context type of [vt*]

• e.g. (type (context (field $ssp i32) ...))
• This describes a mutable set of value types available within an execution stack of wasm functions, called context locals
• We would define some small implementation limit (e.g. 6 types + no SIMD) so that engines can statically allocate the maximum needed space in an easily accessible VM context data structure.
• To start, all value types must be defaultable (no non-nullable values)

2. Parameterize function types by a context type

• e.g. (type (func (context $s) (param i32))
• This defines what kind of context a function must be called on, and what context local variables are available
• Functions may only call other functions with exactly the same context type

3. Introduce instructions for accessing the context mutable storage

• cx_local.get $i
• cx_local.set $i
• These instructions use the context type from the function they are in to validate

4. Exported wasm functions called from JS will have context locals default initialized

5. Calling an imported JS function will save the context locals and restore it upon JS returning. This allows the imported JS function to call into wasm again and not have context interference.

6. Introduce a block instruction for switching the context type for a nested set of instructions

• cx.switch $to : [$to-vars...] -> []
• This allows crossing module boundaries that don't agree on the context type by switching it for a scope.
• Runtime semantics:
  1. Switches the context to a new type with $to-vars as initial context locals
  2. Execute the block body under the new context type
  3. Upon exit, switch back to the previous context type and initialize its values by popping the results of the inner block (this avoids a hidden separate stack of values)
  4. TBD about unwinding due to exceptions

All together, this extension would allow wasm code fast access to a small set of variables of it's choice without threading it all the way through params.

This should be sufficient for the use-case of shadow stack pointers in linear memory languages, and is useful in the next step below.

Accessing unshared from shared functions

The first step here is to break shared back into two separate concepts for functions, depending on the behavior around stack suspension.

1. Plain shared funcs can only access shared module state, but they can have params, results, locals that are unshared. The resulting funcref can be shared, can be captured in an unshared suspended stack, but cannot be captured in a shared suspended stack. This is safe because the called func state (locals/etc) are stuck on the same thread, so it can contain unshared things.
2. sharey-shared (term thanks to Conrad) funcs are the same as above, but can only have shared params, results, locals. This allows them to be captured in a shared suspended stack that can then be passed between threads.

For shared funcs then, they can access any unshared state that they need through params or the context. You could imagine a context that holds a GC struct that acts as the unshared imports for the module. Any entry point into the module will need to setup the context correctly, but from that point on there is no extra cost.

For sharey-shared funcs then, the details will depend on the nature of a future stack proposal, but here's a rough outline of how it could work. None of this would need to be done until there is a consensus stack proposal.

The first step, is to introduce a shared-barrier block instruction which prevents any suspension as a shared stack (suspending as an unshared stack is permitted) while within this block body. This then switches the validation of this function from sharey-shared to just shared.

The second step is to still allow a sharey-shared func to have a context type that includes unshared state. However, it may not be accessed by the func unless it performs the above shared-barrier.

The final step is to allow a sharey-shared func with unshared context to be suspended into a shared stack, but we define this process to default-initialize any unshared variables within the context. Then we allow the context of a shared stack to be initialized by whatever code is resuming that stack. It can then setup any unshared state to the appropriate value for that thread it is executing on.

With the above, a sharey-shared func can access unshared state by entering a shared-barrier and then accessing the context. It can still be captured in a shared stack and sent to another thread, as long as the other thread knows how to reconstruct the unshared state (which is the assumption for TLS as well).

Comparison with TLS

I believe the above is sufficient to implement the main use cases for TLS I know of:

1. Maintaining the shadow stack pointer
2. Maintaining a block of thread-local data (either GC or linear memory)
3. Calling known unshared functions (like console.log) from shared code

It does this without introducing any shared -> unshared edges, which is the subject of #34.

It is a lower level feature, so toolchains will need to be responsible to initialize context on module entry points and when resuming shared stacks. But I believe the toolchain can be much smarter about this than engines can.

With engine implemented wasm TLS, engines need to instrument all indirect calls (which are very hot) to observe module crossings and (1) perform a concurrent hash lookup and then (2) possibly lazily create TLS blocks for the instance and all imported TLS. This is not just on crossing into a instance, but also when returning from that instance as the sharey-shared func may have suspended and resumed on a different thread.

SM today already has two call paths for same-instance and cross-instance, but this would make the performance gap significantly worse.

Staging

None of the above would preclude adding engine supported wasm TLS in the future.

context locals seem generally useful and possibly faster storage for certain programs than importing a global. Starting with shared instead of sharey-shared seems reasonable if it gives us an easy way to access unshared state from shared wasm, and we don't even have a consensus stack proposal yet.

So I'd propose we start with the above, and revisit engine supported wasm TLS in the future if it proves necessary and engine architectures have evolved.

[tlively]

Most of the benefit here is in the context branding of functions and the cx.switch instruction, which makes the boundary between "context domains" explicit and decouples it from instance boundaries. This is an attractive property, but it also introduces a large amount of language complexity. Given that we already have to do extra work on cross-instance calls, I would want to know more about how much of a performance regression the TLS global idea would have to inform how much extra complexity we would want to accept here.

Apart from the statically checked context branding, the context locals design and the TLS globals design could be implemented on top of one another without too much effort, which is why I say most of the benefit is in the branding.

I'm totally on board with splitting shared and sharey-shared functions as soon as we have a reason to do so, whether that's related to TLS or anything else. The shared-barrier block instruction you describe makes a lot of sense. In the design with TLS globals, we could allow access to TLS globals containing unshared state from inside a shared-barrier block.

Regarding shared -> unshared TLS edges, the TLS globals design does not introduce such edges in core Wasm either. All shared -> unshared edges come from JS-side features like shared function wrappers, thread-bound data, WeakMap and FinalizationRegistry. This TLS design could perhaps avoid the need for shared function wrappers, but at the cost of having to pass all JS imports as part of the context on every call into the module. In practice, this means that the branded "context domains" will coincide with instance boundaries anyway (making cross-instance indirect calls nearly impossible!). This would also inhibit existing optimizations of well-known imports like Math.sqrt and would be at odds with the goal of keeping the set of context variables below a small fixed number.

[eqrion]

Most of the benefit here is in the context branding of functions and the cx.switch instruction, which makes the boundary between "context domains" explicit and decouples it from instance boundaries. This is an attractive property, but it also introduces a large amount of language complexity. Given that we already have to do extra work on cross-instance calls, I would want to know more about how much of a performance regression the TLS global idea would have to inform how much extra complexity we would want to accept here.

I think it's debatable which approach introduces more language complexity. thread-local functions which appear as shared but actually dispatch to a mutable thread-local function are not a simple concept (as the implementation implications reveal).

And just to quantify what I mean when I say that we already do have extra work on cross-instance indirect calls, it's 10-12 instructions depending on if the instance has a memory or not. They're all pretty simple loads stores. And this was already enough to motivate doing some significant work to avoid doing this on same-instance indirect calls.

From the explainer for getting a TLS block on a cross-instance call the likely implementation seems like a concurrent hash map lookup, followed by possibly lazily initializing the block and re-inserting it back into the concurrent hash map. With sharey-shared funcs (which are what we have now), you need to do this both on entering and leaving the instance for two lookups (you may have been swapped to a different thread during the call).

Empirical data is good, but I also think we have some analytical data to expect this is going to hurt.

Regarding shared -> unshared TLS edges, the TLS globals design does not introduce such edges in core Wasm either. All shared -> unshared edges come from JS-side features like shared function wrappers, thread-bound data, WeakMap and FinalizationRegistry.

Yes, understood, that's why I included thread-local functions in this description. Regarding JS WeakMap, would it not be possible to disallow storing these new shared wasm values as keys in the map? There are no backwards compat concerns here that I know of, we haven't added these values yet.

This TLS design could perhaps avoid the need for shared function wrappers, but at the cost of having to pass all JS imports as part of the context on every call into the module. In practice, this means that the branded "context domains" will coincide with instance boundaries anyway (making cross-instance indirect calls nearly impossible!). This would also inhibit existing optimizations of well-known imports like Math.sqrt and would be at odds with the goal of keeping the set of context variables below a small fixed number.

I would expect that in any design here where we're trying to run shared code on a new worker, we need a prepare step to acquire all the local functions (e.g. console.log) and bundle them together for wasm. In the proposal today, that would be finding all the thread-local functions and calling initialize on them.

With this alternative, all that local state could be put in a wasm gc struct that's allocated during the prepare step. Then upon entry points into the shared functions from JS, that struct would need to be provided as the a single context field. I'd imagine you would have a local closure that holds the context and inner shared function alive.

Calling a local function from your shared code would just be a cx_local.get; struct.get; call_ref. Whereas doing a call_ref on a thread_local function seems simple, but in practice is hiding a TLS lookup which is not needed if your context just has the local function available directly.

You could also choose a more generic context type than just a typed struct, such as the pair of:
[externref $globalThis, lookupProperty: (externref, externref) -> externref] if your toolchain doesn't want to ever switch contexts and also has independent modules.

Can you elaborate on why cross-instance indirect calls would be nearly impossible? I think you have several options depending on what your toolchain is trying to do. If it's to an 'independent module of unknown language', you would switch to an empty context type (as per ABI) and then call it. If that language was implemented with a context, it would need to initialize itself. The easiest way to do that is with a local function that closes over the context and the shared function to call.

[conrad-watt]

Thoughts:

The shadow stack pointer could already be passed around via regular function arguments as a calling convention if desired. Packing some of the function arguments into a new "context" concept and making its passing between calls implicit doesn't seem to change things much - I don't see threading through the params as more complicated than a context, since the Wasm code is toolchain generated, and JS code at the boundary needs to construct a context just as explicitly as passing an additional param. It looks to me like this is roughly the same as just removing thread-local globals and forcing the shadow stack pointer to be passed as a function argument, which could be done without further language extensions.

Similarly if we make "shared non-suspendable" the preferred semantics, JS access can just be passed through regular function arguments.

If ephemeron-style shared->unshared edges are a concern, then I think we could also go with thread-local functions that don't root cross-thread, as in @syg's flavour 2.

[conrad-watt]

IMO this leaves us with some choices that could be considered independently

• Are stack pointers passed via

  1. function params, or
  2. thread-local globals?

• Are JS functions passed via

  1. Wasm function params (implies shared-non-suspendable semantics), or
  2. flavour 1 thread-local functions (implies shared->non-shared ephemerons), or
  3. flavour 2 thread-local functions?

EDIT: of course, there's also "some other thing" for both of these, such as some version of the thread ID idea that @lukewagner has championed.

[tlively]

From the explainer for getting a TLS block on a cross-instance call the likely implementation seems like a concurrent hash map lookup, followed by possibly lazily initializing the block and re-inserting it back into the concurrent hash map.

I expect the happy path where the TLS has already been initialized could be optimized by e.g. having a thread-local (at the engine level) bitmap where a bit corresponds to an instance and says whether that instance's TLS is initialized. I hope that this would be a few more loads similar to the work for current indirect calls. This extra work only has to happen for indirect calls with shared function types, so it won't regress existing code.

With sharey-shared funcs (which are what we have now), you need to do this both on entering and leaving the instance for two lookups (you may have been swapped to a different thread during the call).

I think the process of resuming the shared continuation would have to be responsible for patching in the proper context for the point of resumption because the resumed function could depend on that new context before returning. So function returns would be able to assume the proper context is already installed.

Regarding JS WeakMap, would it not be possible to disallow storing these new shared wasm values as keys in the map?

Yes, that would work. Alternatively we could require shared keys to map only to shared values. Similar solutions might work for FinalizationRegistry.

With this alternative, all that local state could be put in a wasm gc struct that's allocated during the prepare step. Then upon entry points into the shared functions from JS, that struct would need to be provided as the a single context field.

Yes, but between the extra indirection and the lost optimization potential because this struct and its contents are not well-known at compile time, I'm not sure this would end up being faster than the TLS lookup in the thread-local globals approach.

Can you elaborate on why cross-instance indirect calls would be nearly impossible?

Because the context types for modules with different imports would be different (unless the context had even more indirection), so a single call_indirect or call_ref could not uniformly target functions from different modules. This would basically prevent us from using shared functions in LLVM/Emscripten because all this call overhead would not be worth the improved dlopen implementation.

Packing some of the function arguments into a new "context" concept and making its passing between calls implicit doesn't seem to change things much - I don't see threading through the params as more complicated than a context...

I agree. With my toolchain implementer hat on, I'd rather change my ABI to pass a context param because that would have essentially the same benefits and drawbacks with less "new stuff" to deal with.

[eqrion]

Thoughts:

The shadow stack pointer could already be passed around via regular function arguments as a calling convention if desired. Packing some of the function arguments into a new "context" concept and making its passing between calls implicit doesn't seem to change things much - I don't see threading through the params as more complicated than a context

The point of context locals are to be faster and more efficient than passing params, not simpler, which is important for things like the shadow stack pointer. It also could be useful for some sketches of shared-suspendable, but that's more speculative. If we could get away with just params, that's fine, but from previous discussions that seemed unlikely.

Similarly if we make "shared non-suspendable" the preferred semantics, JS access can just be passed through regular function arguments.

Agreed. Context locals would just be an optimization.

If ephemeron-style shared->unshared edges are a concern, then I think we could also go with thread-local functions that don't root cross-thread, as in @syg's flavour 2.

I wrote a comment in the other thread, #34 (reply in thread), that expresses concern about flavor 2.

[eqrion]

From the explainer for getting a TLS block on a cross-instance call the likely implementation seems like a concurrent hash map lookup, followed by possibly lazily initializing the block and re-inserting it back into the concurrent hash map.

I expect the happy path where the TLS has already been initialized could be optimized by e.g. having a thread-local (at the engine level) bitmap where a bit corresponds to an instance and says whether that instance's TLS is initialized. I hope that this would be a few more loads similar to the work for current indirect calls. This extra work only has to happen for indirect calls with shared function types, so it won't regress existing code.

A bitmap would just tell you if the TLS was allocated, you would then still need to look it up. Instead of a bitmap you could have a dense array of pointers, and do a null check to see if it has been allocated yet or else use the pointer you find.

But in either approach, the size of the array needs to be big enough for all live instances in the system. With the number of instances being dynamic this implies that the array may grow over time and need re-allocation, so you need to introduce locking when reading/writing from the array to avoid races. I'm curious if anyone has any better ideas, but I wasn't able to think of any. You also have an issue that you'll want to re-use old slots to keep the array dense, which also puts constraints on how fancy you can get with concurrency.

With sharey-shared funcs (which are what we have now), you need to do this both on entering and leaving the instance for two lookups (you may have been swapped to a different thread during the call).

I think the process of resuming the shared continuation would have to be responsible for patching in the proper context for the point of resumption because the resumed function could depend on that new context before returning. So function returns would be able to assume the proper context is already installed.

If I understand you right, It's not just the function at the point of resumption, it's every function (that uses TLS) on the shared stack that will need their TLS invalidated and re-looked up. But you also might be saying that you could have the resume instruction perform that invalidation and patch up all the TLS pointers by iterating over the stack frames, instead of doing it on cross-instance function returns. That could also be a viable way of doing it.

With this alternative, all that local state could be put in a wasm gc struct that's allocated during the prepare step. Then upon entry points into the shared functions from JS, that struct would need to be provided as the a single context field.

Yes, but between the extra indirection and the lost optimization potential because this struct and its contents are not well-known at compile time, I'm not sure this would end up being faster than the TLS lookup in the thread-local globals approach.

Why would the struct type not be well-known at compile time? The toolchain creates the struct knowing the set of local functions it wants to have access to from shared funcs.

Here's how I understand the call path to an imported shared funcref, which is actually thread-local, would look:

1. Load a pointer from the pinned VM context/Instance to the imported shared funcref (which is a tuple of Instance*, code*)
2. Perform an indirect call to the code* passing it a pinned Instance*
3. The code* will be a stub that performs a TLS lookup to find a local funcref
4. Trap if that has not been initialized yet on this thread
5. Perform an indirect call to the local function, and return

There's other approaches depending on whether you want to have all callers check whether their shared funcref is actually thread-local and inline extra code paths for that, but that slows down non thread-local calls.

I think paying an extra load to get a struct from the VM context, but then avoiding the extra indirect call to the stub and the TLS lookup would likely be worth it.

Can you elaborate on why cross-instance indirect calls would be nearly impossible?

Because the context types for modules with different imports would be different (unless the context had even more indirection), so a single call_indirect or call_ref could not uniformly target functions from different modules. This would basically prevent us from using shared functions in LLVM/Emscripten because all this call overhead would not be worth the improved dlopen implementation.

In this case of dlopen + shared + thread-locals, I think it's the worst case of TLS both for engine and source language. If the engine is handling it, we have to do the TLS management as described previously. If you're using params/context for accessing unshared state, you'd need to do an equivalent yourself. One way could be to use a common supertype (e.g. structref) for the unshared state struct, then perform a type check in function prologues that lazily acquires the correct unshared state struct when there is a mismatch.

In either case, there's new overhead and I think they could be comparable. It's also the case that this is the worst case, and other source languages may have easier situations.

I agree. With my toolchain implementer hat on, I'd rather change my ABI to pass a context param because that would have essentially the same benefits and drawbacks with less "new stuff" to deal with.

That's also fine with me, it's just an optimization to reduce the amount of memory traffic for having to pass data around.

Taking a small step back, I don't want it to be lost that avoiding shared -> unshared ephemeron edges is a main motivation for me here. So I acknowledge this isn't as simple for toolchains to adopt as thread-local globals and funcs, but it's much simpler for Gecko to actually implement and ship.

[conrad-watt]

The point of context locals are to be faster and more efficient than passing params, not simpler, which is important for things like the shadow stack pointer

For my benefit, could you give me a brief sketch of why they can be faster?

I wrote a comment in the other thread, #34 (reply in thread), that expresses concern about flavor 2.

Replied there - if non-shared Wasm objects could ever be WeakMap keys (not sure) I think the ship has already sailed. I also think that a user shouldn't be reasoning in the margins about surprising ways to keep objects rooted. From the point of view of keeping TLS functioning, they should just remember to keep the thread-local function rooted in each thread they want to use it. I think one could also construct surprising WeakMap behaviours in pure JS, so I'm not sure that Wasm is much stranger here.

[eqrion]

The point of context locals are to be faster and more efficient than passing params, not simpler, which is important for things like the shadow stack pointer

For my benefit, could you give me a brief sketch of why they can be faster?

A context local can be stored in highly accessible VM state. In SM we generally have a pinned register that stores state like the active instance. So writing/reading to a context local would just be a single store or load from that register.

While the number of params that can be passed by register is limited (on x86 to none!), so every one is precious. So if all wasm functions start passing extra state in new params, that forces some params onto the stack. Passing a value also becomes linear in depth of the call stack, versus re-using the implicit VM state that already has to be passed to funcs.

And if the value your passing needs to be mutated by functions you are calling, then you also need to return it linearly as well.

Compared to plain globals, they are the same speed as globals defined locally and not exported. For globals that are imported or exported, they would save an indirection.

I wrote a comment in the other thread, #34 (reply in thread), that expresses concern about flavor 2.

Replied there - if non-shared Wasm objects could ever be WeakMap keys (not sure) I think the ship has already sailed. I also think that a user shouldn't be reasoning in the margins about surprising ways to keep objects rooted. From the point of view of keeping TLS functioning, they should just remember to keep the thread-local function rooted in each thread they want to use it. I think one could also construct surprising WeakMap behaviours in pure JS, so I'm not sure that Wasm is much stranger here.

I will reply in that thread.

[conrad-watt]

A context local can be stored in highly accessible VM state. In SM we generally have a pinned register that stores state like the active instance. So writing/reading to a context local would just be a single store or load from that register.

Could thread-local globals declared in the same instance as the current function be made similarly fast, by pinning a register pointing to the current thread+instance's TLS entries (allocated as a contiguous block rather than as a hashmap)? One might need to check "is the TLS for this thread+instance initialised yet", which could be done either per-access or per-instance boundary crossing into a shared function.

EDIT:

I missed the above paragraph in your OP

With engine implemented wasm TLS, engines need to instrument all indirect calls (which are very hot) to observe module crossings and (1) perform a concurrent hash lookup and then (2) possibly lazily create TLS blocks for the instance and all imported TLS. This is not just on crossing into a instance, but also when returning from that instance as the sharey-shared func may have suspended and resumed on a different thread.

SM today already has two call paths for same-instance and cross-instance, but this would make the performance gap significantly worse.

I think this would only be necessary for calls/returns/resumptions to shared functions, so there shouldn't be any regression for existing code. I agree this could make cross-instance for shared functions slower, depending on the exact structure of the initialisation checks. I would expect the "inline is-already-initialised" path to be the one that's almost exclusively exercised during runtime, with the "out-of-line create new TLS" case being mainly hit during the initial set-up of the thread, so hopefully the runtime overhead could be not much more than a single load + check.

[rossberg]

Just want to say the (perhaps?) obvious that TLS ultimately is just a special case of dynamic scoping. And the need for dynamic scoping comes up in other control abstractions. We should perhaps keep the broader picture in mind.

We e.g. have the typed continuation / effect handlers proposal, which could express TLS pretty easily. So if that proposal was adopted, there would be at least 2 ways of implementing TLS without any additional feature: via calling conventions with a context parameter (poor-man's dynamic scoping) or via handlers. And if it's not adopted, we'll need some substitute for efficient dynamic scoping anyway.

Neither may be quite as optimisable as a specialised construct for TLS, but before we have explored that, the idea of adding extra features with significant complexity and possible semantic redundancy looks like premature optimisation rather than MVP material.

[eqrion]

I think this would only be necessary for calls/returns/resumptions to shared functions, so there shouldn't be any regression for existing code. I agree this could make cross-instance for shared functions slower, depending on the exact structure of the initialisation checks. I would expect the "inline is-already-initialised" path to be the one that's almost exclusively exercised during runtime, with the "out-of-line create new TLS" case being mainly hit during the initial set-up of the thread, so hopefully the runtime overhead could be not much more than a single load + check.

Why would this not be required for unshared functions? They could import a thread-local global/function that is in use on other threads (and so legitimately is acting as TLS) and use it. We'd still need to acquire this upon unshared module crossings.

As for the fast path, also see my other comment in this thread :)

A bitmap would just tell you if the TLS was allocated, you would then still need to look it up. Instead of a bitmap you could have a dense array of pointers, and do a null check to see if it has been allocated yet or else use the pointer you find.

But in either approach, the size of the array needs to be big enough for all live instances in the system. With the number of instances being dynamic this implies that the array may grow over time and need re-allocation, so you need to introduce locking when reading/writing from the array to avoid races. I'm curious if anyone has any better ideas, but I wasn't able to think of any. You also have an issue that you'll want to re-use old slots to keep the array dense, which also puts constraints on how fancy you can get with concurrency.

[eqrion]

Just want to say the (perhaps?) obvious that TLS ultimately is just a special case of dynamic scoping. And the need for dynamic scoping comes up in other control abstractions. We should perhaps keep the broader picture in mind.

We e.g. have the typed continuation / effect handlers proposal, which could express TLS pretty easily. So if that proposal was adopted, there would be at least 2 ways of implementing TLS without any additional feature: via calling conventions with a context parameter (poor-man's dynamic scoping) or via handlers. And if it's not adopted, we'll need some substitute for efficient dynamic scoping anyway.

Neither may be quite as optimisable as a specialised construct for TLS, but before we have explored that, the idea of adding extra features with significant complexity and possible semantic redundancy looks like premature optimisation rather than MVP material.

I have gotten the impression that effect handlers are not going to be fast enough for a hot mutable field like the shadow stack pointer. When it comes to calling out to unshared JS though, I could see optimized effect handlers being fast enough. I would be fine with that as well.

What they have in common with using params/context for passing the unshared state into shared wasm is that it requires the toolchain to handle the worst case that @tlively mentioned above where you have shared code + dynamic linking + indirect calls, where-as the current proposed TLS design handles that for you. (IMO at the cost of engines having to handle this worst case everywhere).

[conrad-watt]

Why would this not be required for unshared functions? They could import a thread-local global/function that is in use on other threads (and so legitimately is acting as TLS) and use it. We'd still need to acquire this upon unshared module crossings.

Argh, I think you're right.

As for the fast path, also see my other comment in this thread :)

I also find your point here quite compelling.

[eqrion]

Because the context types for modules with different imports would be different (unless the context had even more indirection), so a single call_indirect or call_ref could not uniformly target functions from different modules. This would basically prevent us from using shared functions in LLVM/Emscripten because all this call overhead would not be worth the improved dlopen implementation.

Would having a uniform ABI with an unshared param/context local of globalThis and then using JS property access to get whatever you want work for the 'call JS function' case?

edit: @tlively

edit edit: Or really, just any hash map with string keys that is managed per-thread. You'd have the 'prepare' step that would have called .initialize() on the thread-local functions instead insert into this hashmap.