[wasm] Transferrable modules

include/v8.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /** \mainpage V8 API Reference Guide
  *
  * V8 is Google's open source JavaScript engine.
  *
  * This set of documents provides reference material generated from the
  * V8 header file, include/v8.h.
@@ skipping 90 matching lines @@
 class StackFrame;
 class StackTrace;
 class String;
 class StringObject;
 class Symbol;
 class SymbolObject;
 class Private;
 class Uint32;
 class Utils;
 class Value;
+class WasmCompiledModule;
 template <class T> class Local;
 template <class T>
 class MaybeLocal;
 template <class T> class Eternal;
 template<class T> class NonCopyablePersistentTraits;
 template<class T> class PersistentBase;
 template <class T, class M = NonCopyablePersistentTraits<T> >
 class Persistent;
 template <class T>
 class Global;
@@ skipping 1586 matching lines @@
      * object, using the same ID if this SharedArrayBuffer has already been
      * serialized in this buffer. When deserializing, this ID will be passed to
      * ValueDeserializer::TransferSharedArrayBuffer as |transfer_id|.
      *
      * If the object cannot be serialized, an
      * exception should be thrown and Nothing<uint32_t>() returned.
      */
     virtual Maybe<uint32_t> GetSharedArrayBufferId(
         Isolate* isolate, Local<SharedArrayBuffer> shared_array_buffer);
 
+    virtual Maybe<uint32_t> GetWasmModuleTransferId(

[jbroman, 2017/03/13 18:53:37]

Here and elsewhere: Before landing, add comments to new public API, like the
nearby methods?

[Mircea Trofin, 2017/03/15 18:02:28]

Done.

+        Isolate* isolate, Local<WasmCompiledModule> module);
     /*
      * Allocates memory for the buffer of at least the size provided. The actual
      * size (which may be greater or equal) is written to |actual_size|. If no
      * buffer has been allocated yet, nullptr will be provided.
      *
      * If the memory cannot be allocated, nullptr should be returned.
      * |actual_size| will be ignored. It is assumed that |old_buffer| is still
      * valid in this case and has not been modified.
      */
     virtual void* ReallocateBufferMemory(void* old_buffer, size_t size,
@@ skipping 90 matching lines @@
   class V8_EXPORT Delegate {
    public:
     virtual ~Delegate() {}
 
     /*
      * The embedder overrides this method to read some kind of host object, if
      * possible. If not, a suitable exception should be thrown and
      * MaybeLocal<Object>() returned.
      */
     virtual MaybeLocal<Object> ReadHostObject(Isolate* isolate);
+    virtual MaybeLocal<WasmCompiledModule> GetWasmModuleFromId(Isolate* isolate,
+                                                               uint32_t id);

[jbroman, 2017/03/13 18:53:38]

Ditto: we've tried to reduce the number of virtual calls to the delegate. Could
this be implemented as something like:

void TransferWasmModule(uint32_t transfer_id, Local<WasmCompiledModule> module);

(analogous to how array buffers work)

[Mircea Trofin, 2017/03/15 18:02:28]

This is more like transferring SharedArrayBuffers, hence a design similar to
GetSharedBufferId().

[Mircea Trofin, 2017/03/16 20:17:27]

As discussed offline - changed the design on deserializer side to match
TransferSharedArrayBuffer, for the sake of similarity. We don't believe virtual
calls matter much in this case, but we do care about reducing chattiness across
boundary between embedder and V8. We want to revisit the design on both SAB and
wasm side, and opened v8:6106 to track.

+    virtual bool AllowInlineWasm() const { return false; }

[jbroman, 2017/03/13 18:53:37]

Is there a reason this might vary over the lifetime of the serializer? If not,
it's one fewer virtual call if this is just a configured boolean, like
SetSupportsLegacyWireFormat.

[Mircea Trofin, 2017/03/15 18:02:28]

Following the SetSupportsLegacyWireFormat would, actually,
allow it to vary over the lifetime of the serializer, wouldn't it?

   };
 
   ValueDeserializer(Isolate* isolate, const uint8_t* data, size_t size);
   ValueDeserializer(Isolate* isolate, const uint8_t* data, size_t size,
                     Delegate* delegate);
   ~ValueDeserializer();
 
   /*
    * Reads and validates a header (including the format version).
    * May, for example, reject an invalid or unsupported wire format.
@@ skipping 2064 matching lines @@
  private:
   Proxy();
   static void CheckCast(Value* obj);
 };
 
 class V8_EXPORT WasmCompiledModule : public Object {
  public:
   typedef std::pair<std::unique_ptr<const uint8_t[]>, size_t> SerializedModule;
   // A buffer that is owned by the caller.
   typedef std::pair<const uint8_t*, size_t> CallerOwnedBuffer;
+
+  // An opaque, native heap object for transferring wasm modules. It
+  // supports move semantics, and does not support copy semantics.
+  class TransferrableModule final {
+   public:
+    TransferrableModule(TransferrableModule&& src) = default;
+    TransferrableModule(const TransferrableModule& src) = delete;
+
+    TransferrableModule& operator=(TransferrableModule&& src) = default;
+    TransferrableModule& operator=(const TransferrableModule& src) = delete;
+
+   private:
+    typedef std::pair<std::unique_ptr<const uint8_t[]>, size_t> OwnedBuffer;
+    friend class WasmCompiledModule;
+    TransferrableModule(OwnedBuffer&& code, OwnedBuffer&& bytes)
+        : compiled_code(std::move(code)), wire_bytes(std::move(bytes)) {}
+
+    OwnedBuffer compiled_code = {nullptr, 0};
+    OwnedBuffer wire_bytes = {nullptr, 0};
+  };
+
+  TransferrableModule AsTransferrableModule();
+  static MaybeLocal<WasmCompiledModule> FromTransferrableModule(
+      Isolate* isolate, TransferrableModule&);

[jbroman, 2017/03/13 18:53:38]

(destructive) lvalue-ref parameter here is strange. I'd have expected
pass-by-value or rvalue-ref.

[Mircea Trofin, 2017/03/15 18:02:28]

It's remnants from debugging something. What I want is const
TransferrableModule&. Pass-by-value doesn't work by design (no copy); and
rvalue-ref isn't what I want either, because the ownership stays with the
caller.

+
   // Get the wasm-encoded bytes that were used to compile this module.
   Local<String> GetWasmWireBytes();
 
   // Serialize the compiled module. The serialized data does not include the
   // uncompiled bytes.
   SerializedModule Serialize();
 
   // If possible, deserialize the module, otherwise compile it from the provided
   // uncompiled bytes.
   static MaybeLocal<WasmCompiledModule> DeserializeOrCompile(
       Isolate* isolate, const CallerOwnedBuffer& serialized_module,
       const CallerOwnedBuffer& wire_bytes);
   V8_INLINE static WasmCompiledModule* Cast(Value* obj);
 
  private:
   static MaybeLocal<WasmCompiledModule> Deserialize(
       Isolate* isolate, const CallerOwnedBuffer& serialized_module,
       const CallerOwnedBuffer& wire_bytes);
   static MaybeLocal<WasmCompiledModule> Compile(Isolate* isolate,
                                                 const uint8_t* start,
                                                 size_t length);
+  static CallerOwnedBuffer AsCallerOwned(
+      const TransferrableModule::OwnedBuffer& buff) {
+    return {buff.first.get(), buff.second};
+  }
+
   WasmCompiledModule();
   static void CheckCast(Value* obj);
 };
 
 #ifndef V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT
 // The number of required internal fields can be defined by embedder.
 #define V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT 2
 #endif
 
 
@@ skipping 5874 matching lines @@
  */
 
 
 }  // namespace v8
 
 
 #undef TYPE_CHECK
 
 
 #endif  // INCLUDE_V8_H_