[wasm] Adding metrics for Asm/Wasm.

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/macro-assembler.h"
 #include "src/objects.h"
 #include "src/v8.h"
 
 #include "src/simulator.h"
 
@@ skipping 364 matching lines @@
 }
 
 // Instantiates a wasm module as a JSObject.
 //  * allocates a backing store of {mem_size} bytes.
 //  * installs a named property "memory" for that buffer if exported
 //  * installs named properties on the object for exported functions
 //  * compiles wasm code to machine code
 MaybeHandle<JSObject> WasmModule::Instantiate(Isolate* isolate,
                                               Handle<JSObject> ffi,
                                               Handle<JSArrayBuffer> memory) {
+  HistogramTimerScope wasm_instantiate_time_scope(
+      isolate->counters()->wasm_instantiate_time());
   this->shared_isolate = isolate;  // TODO(titzer): have a real shared isolate.
   ErrorThrower thrower(isolate, "WasmModule::Instantiate()");
   Factory* factory = isolate->factory();
 
   //-------------------------------------------------------------------------
   // Allocate the instance and its JS counterpart.
   //-------------------------------------------------------------------------
   Handle<Map> map = factory->NewMap(
       JS_OBJECT_TYPE,
       JSObject::kHeaderSize + kWasmModuleInternalFieldCount * kPointerSize);
   WasmModuleInstance instance(this);
   instance.context = isolate->native_context();
   instance.js_object = factory->NewJSObjectFromMap(map, TENURED);
   Handle<FixedArray> code_table =
       factory->NewFixedArray(static_cast<int>(functions.size()), TENURED);
   instance.js_object->SetInternalField(kWasmModuleCodeTable, *code_table);
 
   //-------------------------------------------------------------------------
   // Allocate and initialize the linear memory.
   //-------------------------------------------------------------------------
+  isolate->counters()->wasm_min_mem_pages_memory()->AddSample(
+      instance.module->min_mem_pages);
+  isolate->counters()->wasm_max_mem_pages_memory()->AddSample(
+      instance.module->max_mem_pages);
   if (memory.is_null()) {
     if (!AllocateMemory(&thrower, isolate, &instance)) {
       return MaybeHandle<JSObject>();
     }
   } else {
     SetMemory(&instance, memory);
   }
   instance.js_object->SetInternalField(kWasmMemArrayBuffer,
                                        *instance.mem_buffer);
   LoadDataSegments(this, instance.mem_start, instance.mem_size);
 
   //-------------------------------------------------------------------------
   // Allocate the globals area if necessary.
   //-------------------------------------------------------------------------
   if (!AllocateGlobals(&thrower, isolate, &instance)) {
     return MaybeHandle<JSObject>();
   }
   if (!instance.globals_buffer.is_null()) {
     instance.js_object->SetInternalField(kWasmGlobalsArrayBuffer,
                                          *instance.globals_buffer);
   }
 
+  HistogramTimerScope wasm_compile_time_scope(
+      isolate->counters()->wasm_compile_time());
+
   //-------------------------------------------------------------------------
   // Compile wrappers to imported functions.
   //-------------------------------------------------------------------------
   uint32_t index = 0;
   instance.function_table = BuildFunctionTable(isolate, this);
   WasmLinker linker(isolate, functions.size());
   ModuleEnv module_env;
   module_env.module = this;
   module_env.instance = &instance;
   module_env.linker = &linker;
@@ skipping 14 matching lines @@
           module_name, function_name);
       instance.import_code.push_back(code);
       index++;
     }
   }
 
   //-------------------------------------------------------------------------
   // Compile all functions in the module.
   //-------------------------------------------------------------------------
 
+  isolate->counters()->wasm_functions_per_module()->AddSample(
+      static_cast<int>(functions.size()));
+
   // First pass: compile each function and initialize the code table.
   index = FLAG_skip_compiling_wasm_funcs;
   while (index < functions.size()) {
     const WasmFunction& func = functions[index];
     if (thrower.error()) break;
     DCHECK_EQ(index, func.func_index);
 
     WasmName str = GetName(func.name_offset, func.name_length);
     WasmName str_null = {nullptr, 0};
     Handle<String> name = factory->InternalizeUtf8String(
@@ skipping 66 matching lines @@
 
     if (mem_export) {
       // Export the memory as a named property.
       Handle<String> name = factory->InternalizeUtf8String("memory");
       JSObject::AddProperty(exports_object, name, instance.mem_buffer,
                             READ_ONLY);
     }
   }
 
   // Run the start function if one was specified.
   if (this->start_function_index >= 0) {

[ahaas, 2016/04/11 08:03:08]

Is it intended that the execution of the start function is part of the
compilation time?

[bradn, 2016/04/13 00:22:45]

Oops, done.
I've embedded it in a block, as I'd like to avoid a big refactor in this change
to allow it to be cherry picked.

     HandleScope scope(isolate);
     uint32_t index = static_cast<uint32_t>(this->start_function_index);
     Handle<String> name = isolate->factory()->NewStringFromStaticChars("start");
     Handle<Code> code = linker.GetFunctionCode(index);
     Handle<JSFunction> jsfunc = compiler::CompileJSToWasmWrapper(
         isolate, &module_env, name, code, instance.js_object, index);
 
     // Call the JS function.
     Handle<Object> undefined(isolate->heap()->undefined_value(), isolate);
     MaybeHandle<Object> retval =
@@ skipping 131 matching lines @@
   }
   if (result->IsHeapNumber()) {
     return static_cast<int32_t>(HeapNumber::cast(*result)->value());
   }
   thrower.Error("WASM.compileRun() failed: Return value should be number");
   return -1;
 }
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8