Fast copying of objects between runtimes by binary serialization

[tmikov]

Would people be interested in a JSI API that enables very fast copying of objects between runtimes? The API would look something like:

class Serialized; // Opaque type.

std::shared_ptr<Serialized> jsi::Runtime::serialize(jsi::Value);
jsi::Value jsi::Runtime::deserialize(const Serialized &);

A value (which can be arbitrarily complex) serialized by one runtime can then be de-serialized multiple times by multiple runtimes, if desired. The runtimes must all be the same kind though! I.e. cannot serialize in Hermes and de-serialize in JSC. The semantics are similar to structuredClone():

• structuredClone
• Supported types

It is up to the developer to deliver the Serialized instance to the other runtime, potentially in another thread.

The serialization/deserialization will use internal VM APIs, so it is extremely fast, much much faster than what is possible using JSI today. Note that the Serialized object is fully opaque - once created, it can only be used to de-serialize the data and be destroyed.

This can be used as a building block of a Web Worker implementation.

[SamuelScheit]

Very interesting idea. Could this help to speed up data sharing between the react-native-reanimated worklet runtime and the js thread runtime?

[tjzel]

react-native-reanimated would be very interested to be able to access this kind of API.

A value (which can be arbitrarily complex)

What do you mean by arbitrarily complex? Would it count objects with pre-built prototypes, i.e. maps and sets? What about prototypes that exist on one runtime, but don't on another (class instances)?

---

@SamuelScheit regarding your question, it's hard to tell if it will speed up the worklets in a significant way. It would definitely help with the data sharing, however we try to keep the data sharing itself to an absolute minimum. Initialization of worklets etc. would certainly benefit from it but it's hard to estimate the overall performance gain.

Import factor here are also the new opportunities that arise. Such API could greatly simplify the codebase of Reanimated and might open a window for new features which are too difficult to implement or maintain with current API of JSI. This is particularly important as we are working on react-native-worklets, standalone library which would streamline multi-runtime approach to React Native apps.

[mrousavy]

How does this work for functions?

Can a function be created and serialized on one runtime, then deserialized and called (with proper closure) on another?

[tmikov]

No, function is not one of the supported types

[tjzel]

A few more questions:

1. Copying functions. Is it possible for the proposed API to "deep copy" functions, i.e. with their closure etc.? At the moment when a function foo calls function bar inside we have to copy both of them to another runtime manually and it relies heavily on Babel's semantic analysis outside of runtime. (damn, @mrousavy you were faster 😅)

2. Just to make sure, Serialized objects aren't tied to the runtime of their origin and could outlive it?

3. What timeline do you anticipate for some PoC of the API? We'd be happy to try it out as soon as it's available to provide instant feedback, compiling Hermes from source before it's shipped with React Native.

[tmikov]

Is it possible for the proposed API to "deep copy" functions

No, functions cannot be copied in this way. We are certainly interested in discussing a separate compiler-enabled solution for dealing with functions. The requirements are a bit unclear. What does it mean to copy a function? Also, why do functions need to be copied at all? Why not simply use a second small bytecode bundle for the second runtime? Or use the original bundle with a different entry point?

Serialized objects aren't tied to the runtime of their origin and could outlive it?

Correct. That is why the function returns a std::shared_ptr<>, making the ownership and lifetime explicit.

What timeline do you anticipate for some PoC of the API?

Not sure yet. For now it is just an idea. It seems like people think it will be useful, so we need to include it in our planning.