[wasm] Make print_wasm_code_size into a regular V8 counter.

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 "src/base/atomic-utils.h"
 #include "src/macro-assembler.h"
 #include "src/objects.h"
 #include "src/property-descriptor.h"
 #include "src/v8.h"
 
@@ skipping 528 matching lines @@
   }
 
   Isolate* isolate_;
   std::vector<compiler::WasmCompilationUnit*>* compilation_units_;
   std::queue<compiler::WasmCompilationUnit*>* executed_units_;
   base::Semaphore* on_finished_;
   base::Mutex* result_mutex_;
   base::AtomicNumber<size_t>* next_unit_;
 };
 
-// Records statistics on the code generated by compiling WASM functions.
-struct CodeStats {
-  size_t code_size;
-  size_t reloc_size;
+static void RecordStats(Isolate* isolate, Code* code) {
+  isolate->counters()->wasm_generated_code_size()->Increment(code->body_size());
+  isolate->counters()->wasm_reloc_size()->Increment(
+      code->relocation_info()->length());
+}
 
-  inline CodeStats() : code_size(0), reloc_size(0) {}
+static void RecordStats(Isolate* isolate,
+                        const std::vector<Handle<Code>>& functions) {
+  for (Handle<Code> c : functions) RecordStats(isolate, *c);
+}
 
-  inline void Record(Code* code) {
-    if (FLAG_print_wasm_code_size) {
-      code_size += code->body_size();
-      reloc_size += code->relocation_info()->length();
-    }
+static void RecordStats(Isolate* isolate, Handle<FixedArray> functions) {
+  DisallowHeapAllocation no_gc;
+  for (int i = 0; i < functions->length(); ++i) {
+    RecordStats(isolate, Code::cast(functions->get(i)));
   }
-
-  void Record(const std::vector<Handle<Code>>& functions) {
-    if (FLAG_print_wasm_code_size) {
-      for (Handle<Code> c : functions) Record(*c);
-    }
-  }
-
-  void Record(Handle<FixedArray> functions) {
-    if (FLAG_print_wasm_code_size) {
-      DisallowHeapAllocation no_gc;
-      for (int i = 0; i < functions->length(); ++i) {
-        Code* code = Code::cast(functions->get(i));
-        Record(code);
-      }
-    }
-  }
-
-  inline void Report() {
-    if (FLAG_print_wasm_code_size) {
-      PrintF("Total generated wasm code: %zu bytes\n", code_size);
-      PrintF("Total generated wasm reloc: %zu bytes\n", reloc_size);
-    }
-  }
-};
+}
 
 Handle<FixedArray> GetImportsMetadata(Factory* factory,
                                       const WasmModule* module) {
   Handle<FixedArray> ret = factory->NewFixedArray(
       static_cast<int>(module->import_table.size()), TENURED);
   for (size_t i = 0; i < module->import_table.size(); ++i) {
     const WasmImport& import = module->import_table[i];
     WasmName module_name = module->GetNameOrNull(import.module_name_offset,
                                                  import.module_name_length);
     WasmName function_name = module->GetNameOrNull(import.function_name_offset,
@@ skipping 311 matching lines @@
     uint32_t mem_size = static_cast<uint32_t>(memory->byte_length()->Number());
     RelocateInstanceCode(instance, mem_start,
                          WasmModule::kPageSize * min_mem_pages, mem_size);
     LoadDataSegments(compiled_module, mem_start, mem_size);
   }
   return true;
 }
 
 bool SetupImports(Isolate* isolate, Handle<FixedArray> compiled_module,
                   Handle<JSObject> instance, ErrorThrower* thrower,
-                  Handle<JSReceiver> ffi, CodeStats* stats) {
+                  Handle<JSReceiver> ffi) {
   //-------------------------------------------------------------------------
   // Compile wrappers to imported functions.
   //-------------------------------------------------------------------------
   std::vector<Handle<Code>> import_code;
   MaybeHandle<FixedArray> maybe_import_data =
       compiled_module->GetValue<FixedArray>(kImportData);
   if (!maybe_import_data.is_null()) {
     Handle<FixedArray> import_data = maybe_import_data.ToHandleChecked();
     if (!CompileWrappersToImportedFunctions(isolate, ffi, import_code,
                                             import_data, thrower)) {
       return false;
     }
   }
 
-  stats->Record(import_code);
+  RecordStats(isolate, import_code);
 
   Handle<FixedArray> code_table = Handle<FixedArray>(
       FixedArray::cast(instance->GetInternalField(kWasmModuleCodeTable)));
   // TODO(mtrofin): get the code off std::vector and on FixedArray, for
   // consistency.
   std::vector<Handle<Code>> function_code(code_table->length());
   for (int i = 0; i < code_table->length(); ++i) {
     Handle<Code> code = Handle<Code>(Code::cast(code_table->get(i)));
     function_code[i] = code;
   }
 
   instance->SetInternalField(kWasmModuleFunctionTable, Smi::FromInt(0));
   LinkImports(isolate, function_code, import_code);
   return true;
 }
 
 bool SetupExportsObject(Handle<FixedArray> compiled_module, Isolate* isolate,
-                        Handle<JSObject> instance, ErrorThrower* thrower,
-                        CodeStats* stats) {
+                        Handle<JSObject> instance, ErrorThrower* thrower) {
   Factory* factory = isolate->factory();
   bool mem_export =
       static_cast<bool>(Smi::cast(compiled_module->get(kExportMem))->value());
   ModuleOrigin origin = static_cast<ModuleOrigin>(
       Smi::cast(compiled_module->get(kOrigin))->value());
 
   MaybeHandle<FixedArray> maybe_exports =
       compiled_module->GetValue<FixedArray>(kExports);
   if (!maybe_exports.is_null() || mem_export) {
     PropertyDescriptor desc;
     desc.set_writable(false);
 
     Handle<JSObject> exports_object = instance;
     if (origin == kWasmOrigin) {
       // Create the "exports" object.
       Handle<JSFunction> object_function = Handle<JSFunction>(
           isolate->native_context()->object_function(), isolate);
       exports_object = factory->NewJSObject(object_function, TENURED);
       Handle<String> exports_name = factory->InternalizeUtf8String("exports");
       JSObject::AddProperty(instance, exports_name, exports_object, READ_ONLY);
     }
     if (!maybe_exports.is_null()) {
       Handle<FixedArray> exports = maybe_exports.ToHandleChecked();
 
       int exports_size = exports->length();
       for (int i = 0; i < exports_size; ++i) {
         if (thrower->error()) return false;
         Handle<JSFunction> function = exports->GetValueChecked<JSFunction>(i);
-        stats->Record(function->code());
+        RecordStats(isolate, function->code());
         Handle<String> name =
             Handle<String>(String::cast(function->shared()->name()));
         function->SetInternalField(0, *instance);
 
         desc.set_value(function);
         Maybe<bool> status = JSReceiver::DefineOwnProperty(
             isolate, exports_object, name, &desc, Object::THROW_ON_ERROR);
         if (!status.IsJust()) {
           thrower->Error("export of %.*s failed.", name->length(),
                          name->ToCString().get());
@@ skipping 145 matching lines @@
 //  * installs named properties on the object for exported functions
 //  * compiles wasm code to machine code
 MaybeHandle<JSObject> WasmModule::Instantiate(
     Isolate* isolate, Handle<FixedArray> compiled_module,
     Handle<JSReceiver> ffi, Handle<JSArrayBuffer> memory) {
   HistogramTimerScope wasm_instantiate_module_time_scope(
       isolate->counters()->wasm_instantiate_module_time());
   ErrorThrower thrower(isolate, "WasmModule::Instantiate()");
   Factory* factory = isolate->factory();
 
-  CodeStats code_stats;
   // These fields are compulsory.
   Handle<FixedArray> code_table =
       compiled_module->GetValueChecked<FixedArray>(kFunctions);
 
-  code_stats.Record(code_table);
+  RecordStats(isolate, code_table);
 
   MaybeHandle<JSObject> nothing;
 
   Handle<Map> map = factory->NewMap(
       JS_OBJECT_TYPE,
       JSObject::kHeaderSize + kWasmModuleInternalFieldCount * kPointerSize);
   Handle<JSObject> js_object = factory->NewJSObjectFromMap(map, TENURED);
   js_object->SetInternalField(kWasmModuleCodeTable, *code_table);
 
   if (!(SetupInstanceHeap(isolate, compiled_module, js_object, memory,
                           &thrower) &&
         SetupGlobals(isolate, compiled_module, js_object, &thrower) &&
-        SetupImports(isolate, compiled_module, js_object, &thrower, ffi,
-                     &code_stats) &&
-        SetupExportsObject(compiled_module, isolate, js_object, &thrower,
-                           &code_stats))) {
+        SetupImports(isolate, compiled_module, js_object, &thrower, ffi) &&
+        SetupExportsObject(compiled_module, isolate, js_object, &thrower))) {
     return nothing;
   }
 
   SetDebugSupport(factory, compiled_module, js_object);
 
   // Run the start function if one was specified.
   MaybeHandle<JSFunction> maybe_startup_fct =
       compiled_module->GetValue<JSFunction>(kStartupFunction);
   if (!maybe_startup_fct.is_null()) {
     HandleScope scope(isolate);
     Handle<JSFunction> startup_fct = maybe_startup_fct.ToHandleChecked();
-    code_stats.Record(startup_fct->code());
+    RecordStats(isolate, startup_fct->code());
     startup_fct->SetInternalField(0, *js_object);
     // Call the JS function.
     Handle<Object> undefined = isolate->factory()->undefined_value();
     MaybeHandle<Object> retval =
         Execution::Call(isolate, startup_fct, undefined, 0, nullptr);
 
     if (retval.is_null()) {
       thrower.Error("WASM.instantiateModule(): start function failed");
       return nothing;
     }
   }
 
-  code_stats.Report();
-
   DCHECK(wasm::IsWasmObject(*js_object));
   return js_object;
 }
 
 // TODO(mtrofin): remove this once we move to WASM_DIRECT_CALL
 Handle<Code> ModuleEnv::GetCodeOrPlaceholder(uint32_t index) const {
   DCHECK(IsValidFunction(index));
   if (!placeholders.empty()) return placeholders[index];
   DCHECK_NOT_NULL(instance);
   return instance->function_code[index];
@@ skipping 189 matching lines @@
     return static_cast<int32_t>(HeapNumber::cast(*result)->value());
   }
   thrower.Error("WASM.compileRun() failed: Return value should be number");
   return -1;
 }
 
 }  // namespace testing
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8