[wasm] tracing for wasm module instances

src/wasm/wasm-module.cc

 // Copyright 2015 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.
 
 #include <memory>
 
 #include "src/base/atomic-utils.h"
 #include "src/code-stubs.h"
 
 #include "src/macro-assembler.h"
@@ skipping 10 matching lines @@
 #include "src/wasm/wasm-js.h"
 #include "src/wasm/wasm-module.h"
 #include "src/wasm/wasm-result.h"
 
 #include "src/compiler/wasm-compiler.h"
 
 namespace v8 {
 namespace internal {
 namespace wasm {
 
+#define TRACE(...)                                      \
+  do {                                                  \
+    if (FLAG_trace_wasm_instances) PrintF(__VA_ARGS__); \
+  } while (false)
+
+#define TRACE_CHAIN(instance)        \
+  do {                               \
+    instance->PrintInstancesChain(); \
+  } while (false)
+
 namespace {
 
 static const int kPlaceholderMarker = 1000000000;
 
 enum JSFunctionExportInternalField {
   kInternalModuleInstance,
   kInternalArity,
   kInternalSignature
 };
 
@@ skipping 680 matching lines @@
                                          UPDATE_WRITE_BARRIER,
                                          SKIP_ICACHE_FLUSH);
         }
       }
     }
   }
 }
 
 static void ResetCompiledModule(Isolate* isolate, JSObject* owner,
                                 WasmCompiledModule* compiled_module) {
+  TRACE("Resetting %d\n", compiled_module->instance_id());
   Object* undefined = *isolate->factory()->undefined_value();
   uint32_t old_mem_size = compiled_module->has_heap()
                               ? compiled_module->mem_size()
                               : compiled_module->default_mem_size();
   uint32_t default_mem_size = compiled_module->default_mem_size();
   Object* mem_start = compiled_module->ptr_to_heap();
   Address old_mem_address = nullptr;
   Address globals_start =
       GetGlobalStartAddressFromCodeTemplate(undefined, owner);
 
@@ skipping 33 matching lines @@
     }
   }
   compiled_module->reset_heap();
 }
 
 static void InstanceFinalizer(const v8::WeakCallbackInfo<void>& data) {
   JSObject** p = reinterpret_cast<JSObject**>(data.GetParameter());
   JSObject* owner = *p;
   WasmCompiledModule* compiled_module =
       WasmCompiledModule::cast(owner->GetInternalField(kWasmCompiledModule));
+  TRACE("Finalizing %d {\n", compiled_module->instance_id());
   Isolate* isolate = reinterpret_cast<Isolate*>(data.GetIsolate());
   DCHECK(compiled_module->has_weak_module_object());
   WeakCell* weak_module_obj = compiled_module->ptr_to_weak_module_object();
 
   // weak_module_obj may have been cleared, meaning the module object
   // was GC-ed. In that case, there won't be any new instances created,
   // and we don't need to maintain the links between instances.
   if (!weak_module_obj->cleared()) {
     JSObject* module_obj = JSObject::cast(weak_module_obj->value());
     WasmCompiledModule* current_template =
         WasmCompiledModule::cast(module_obj->GetInternalField(0));
+
+    TRACE("chain before {\n");
+    TRACE_CHAIN(current_template);
+    TRACE("}\n");
+
     DCHECK(!current_template->has_weak_prev_instance());
     WeakCell* next = compiled_module->ptr_to_weak_next_instance();
     WeakCell* prev = compiled_module->ptr_to_weak_prev_instance();
 
     if (current_template == compiled_module) {
       if (next == nullptr) {
         ResetCompiledModule(isolate, owner, compiled_module);
       } else {
         DCHECK(next->value()->IsFixedArray());
         module_obj->SetInternalField(0, next->value());
@@ skipping 17 matching lines @@
       if (next != nullptr) {
         DCHECK(!next->cleared());
         if (prev == nullptr) {
           WasmCompiledModule::cast(next->value())->reset_weak_prev_instance();
         } else {
           WasmCompiledModule::cast(next->value())
               ->set_ptr_to_weak_prev_instance(prev);
         }
       }
     }
+    TRACE("chain after {\n");
+    TRACE_CHAIN(WasmCompiledModule::cast(module_obj->GetInternalField(0)));
+    TRACE("}\n");
   }
   compiled_module->reset_weak_owning_instance();
   GlobalHandles::Destroy(reinterpret_cast<Object**>(p));
+  TRACE("}\n");
 }
 
 Handle<FixedArray> SetupIndirectFunctionTable(
     Isolate* isolate, Handle<FixedArray> wasm_functions,
     Handle<FixedArray> indirect_table_template,
     Handle<FixedArray> tables_to_replace) {
   Factory* factory = isolate->factory();
   Handle<FixedArray> cloned_indirect_tables =
       factory->CopyFixedArray(indirect_table_template);
   for (int i = 0; i < cloned_indirect_tables->length(); ++i) {
@@ skipping 334 matching lines @@
   //--------------------------------------------------------------------------
   Handle<WasmCompiledModule> compiled_module;
   Handle<FixedArray> code_table;
   Handle<FixedArray> old_code_table;
   Handle<JSObject> owner;
   // If we don't clone, this will be null(). Otherwise, this will
   // be a weak link to the original. If we lose the original to GC,
   // this will be a cleared. We'll link the instances chain last.
   MaybeHandle<WeakCell> link_to_original;
 
+  TRACE("Starting new module instantiation\n");
   {
     Handle<WasmCompiledModule> original(
         WasmCompiledModule::cast(module_object->GetInternalField(0)), isolate);
     // Always make a new copy of the code_table, since the old_code_table
     // may still have placeholders for imports.
     old_code_table = original->code_table();
     code_table = factory->CopyFixedArray(old_code_table);
 
     if (original->has_weak_owning_instance()) {
       WeakCell* tmp = original->ptr_to_weak_owning_instance();
       DCHECK(!tmp->cleared());
       // There is already an owner, clone everything.
       owner = Handle<JSObject>(JSObject::cast(tmp->value()), isolate);
       // Insert the latest clone in front.
+      TRACE("Cloning from %d\n", original->instance_id());
       compiled_module = WasmCompiledModule::Clone(isolate, original);
       // Replace the strong reference to point to the new instance here.
       // This allows any of the other instances, including the original,
       // to be collected.
       module_object->SetInternalField(0, *compiled_module);
       compiled_module->set_weak_module_object(original->weak_module_object());
       link_to_original = factory->NewWeakCell(original);
       // Don't link to original here. We remember the original
       // as a weak link. If that link isn't clear by the time we finish
       // instantiating this instance, then we link it at that time.
@@ skipping 13 matching lines @@
             break;
           }
           default:
             UNREACHABLE();
         }
       }
       RecordStats(isolate, code_table);
     } else {
       // There was no owner, so we can reuse the original.
       compiled_module = original;
+      TRACE("Reusing existing instance %d\n", compiled_module->instance_id());
     }
     compiled_module->set_code_table(code_table);
   }
 
   //--------------------------------------------------------------------------
   // Allocate the instance object.
   //--------------------------------------------------------------------------
   Handle<Map> map = factory->NewMap(
       JS_OBJECT_TYPE,
       JSObject::kHeaderSize + kWasmModuleInternalFieldCount * kPointerSize);
@@ skipping 237 matching lines @@
         Execution::Call(isolate, startup_fct, undefined, 0, nullptr);
 
     if (retval.is_null()) {
       thrower->Error("WASM.instantiateModule(): start function failed");
       return nothing;
     }
   }
 
   DCHECK(wasm::IsWasmObject(*instance));
 
-  if (compiled_module->has_weak_module_object()) {
-    instance->SetInternalField(kWasmCompiledModule, *compiled_module);
+  {
     Handle<WeakCell> link_to_owner = factory->NewWeakCell(instance);
 
     Handle<Object> global_handle = isolate->global_handles()->Create(*instance);
     Handle<WeakCell> link_to_clone = factory->NewWeakCell(compiled_module);
     {
       DisallowHeapAllocation no_gc;
       compiled_module->set_weak_owning_instance(link_to_owner);
       Handle<WeakCell> next;
       if (link_to_original.ToHandle(&next) && !next->cleared()) {
         WasmCompiledModule* original = WasmCompiledModule::cast(next->value());
         DCHECK(original->has_weak_owning_instance());
         DCHECK(!original->weak_owning_instance()->cleared());
         compiled_module->set_weak_next_instance(next);
         original->set_weak_prev_instance(link_to_clone);
       }
+
+      compiled_module->set_weak_owning_instance(link_to_owner);
+      instance->SetInternalField(kWasmCompiledModule, *compiled_module);
       GlobalHandles::MakeWeak(global_handle.location(),
                               global_handle.location(), &InstanceFinalizer,
                               v8::WeakCallbackType::kFinalizer);
     }
   }
-
+  TRACE("Finishing instance %d\n", compiled_module->instance_id());
+  TRACE_CHAIN(WasmCompiledModule::cast(module_object->GetInternalField(0)));
   return instance;
 }
 
+#if DEBUG
+uint32_t WasmCompiledModule::instance_id_counter_ = 0;
+#endif
+
 Handle<WasmCompiledModule> WasmCompiledModule::New(Isolate* isolate,
                                                    uint32_t min_memory_pages,
                                                    uint32_t globals_size,
                                                    bool export_memory,
                                                    ModuleOrigin origin) {
   Handle<FixedArray> ret =
       isolate->factory()->NewFixedArray(PropertyIndices::Count, TENURED);
   // Globals size is expected to fit into an int without overflow. This is not
   // supported by the spec at the moment, however, we don't support array
   // buffer sizes over 1g, so, for now, we avoid alocating a HeapNumber for
   // the globals size. The CHECK guards this assumption.
   CHECK_GE(static_cast<int>(globals_size), 0);
   ret->set(kID_min_memory_pages,
            Smi::FromInt(static_cast<int>(min_memory_pages)));
   ret->set(kID_globals_size, Smi::FromInt(static_cast<int>(globals_size)));
   ret->set(kID_export_memory, Smi::FromInt(static_cast<int>(export_memory)));
   ret->set(kID_origin, Smi::FromInt(static_cast<int>(origin)));
+  WasmCompiledModule::cast(*ret)->Init();
   return handle(WasmCompiledModule::cast(*ret));
 }
 
+void WasmCompiledModule::Init() {
+#if DEBUG
+  set(kID_instance_id, Smi::FromInt(instance_id_counter_++));
+  TRACE("New compiled module id: %d\n", instance_id());
+#endif
+}
+
+void WasmCompiledModule::PrintInstancesChain() {
+#if DEBUG
+  if (!FLAG_trace_wasm_instances) return;
+  for (WasmCompiledModule* current = this; current != nullptr;) {
+    PrintF("->%d", current->instance_id());
+    if (current->ptr_to_weak_next_instance() == nullptr) break;
+    CHECK(!current->ptr_to_weak_next_instance()->cleared());
+    current =
+        WasmCompiledModule::cast(current->ptr_to_weak_next_instance()->value());
+  }
+  PrintF("\n");
+#endif
+}
+
 Handle<Object> GetWasmFunctionNameOrNull(Isolate* isolate, Handle<Object> wasm,
                                          uint32_t func_index) {
   if (!wasm->IsUndefined(isolate)) {
     Handle<ByteArray> func_names_arr_obj(
         ByteArray::cast(Handle<JSObject>::cast(wasm)->GetInternalField(
             kWasmFunctionNamesArray)),
         isolate);
     // TODO(clemens): Extract this from the module bytes; skip whole function
     // name table.
     Handle<Object> name;
@@ skipping 254 matching lines @@
   WasmCompiledModule* compiled_module =
       WasmCompiledModule::cast(instance->GetInternalField(kWasmCompiledModule));
   CHECK(compiled_module->has_weak_module_object());
   CHECK(compiled_module->ptr_to_weak_module_object()->cleared());
 }
 
 }  // namespace testing
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8