[wasm] Adding metrics for Asm/Wasm.

src/counters.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.
 
 #ifndef V8_COUNTERS_H_
 #define V8_COUNTERS_H_
 
 #include "include/v8.h"
 #include "src/allocation.h"
 #include "src/base/platform/elapsed-timer.h"
@@ skipping 570 matching lines @@
 
 #define HISTOGRAM_RANGE_LIST(HR)                                              \
   /* Generic range histograms */                                              \
   HR(detached_context_age_in_gc, V8.DetachedContextAgeInGC, 0, 20, 21)        \
   HR(gc_idle_time_allotted_in_ms, V8.GCIdleTimeAllottedInMS, 0, 10000, 101)   \
   HR(gc_idle_time_limit_overshot, V8.GCIdleTimeLimit.Overshot, 0, 10000, 101) \
   HR(gc_idle_time_limit_undershot, V8.GCIdleTimeLimit.Undershot, 0, 10000,    \
      101)                                                                     \
   HR(code_cache_reject_reason, V8.CodeCacheRejectReason, 1, 6, 6)             \
   HR(errors_thrown_per_context, V8.ErrorsThrownPerContext, 0, 200, 20)        \
-  HR(debug_feature_usage, V8.DebugFeatureUsage, 1, 7, 7)
+  HR(debug_feature_usage, V8.DebugFeatureUsage, 1, 7, 7)                      \
+  /* Asm/Wasm. */                                                             \
+  HR(wasm_functions_per_module, V8.WasmFunctionsPerModule, 0, 10000, 101)
 
 #define HISTOGRAM_TIMER_LIST(HT)                                              \
   /* Garbage collection timers. */                                            \
   HT(gc_compactor, V8.GCCompactor, 10000, MILLISECOND)                        \
   HT(gc_finalize, V8.GCFinalizeMC, 10000, MILLISECOND)                        \
   HT(gc_finalize_reduce_memory, V8.GCFinalizeMCReduceMemory, 10000,           \
      MILLISECOND)                                                             \
   HT(gc_scavenger, V8.GCScavenger, 10000, MILLISECOND)                        \
   HT(gc_context, V8.GCContext, 10000,                                         \
      MILLISECOND) /* GC context cleanup time */                               \
@@ skipping 10 matching lines @@
   HT(parse_lazy, V8.ParseLazyMicroSeconds, 1000000, MICROSECOND)              \
   HT(pre_parse, V8.PreParseMicroSeconds, 1000000, MICROSECOND)                \
   /* Compilation times. */                                                    \
   HT(compile, V8.CompileMicroSeconds, 1000000, MICROSECOND)                   \
   HT(compile_eval, V8.CompileEvalMicroSeconds, 1000000, MICROSECOND)          \
   /* Serialization as part of compilation (code caching) */                   \
   HT(compile_serialize, V8.CompileSerializeMicroSeconds, 100000, MICROSECOND) \
   HT(compile_deserialize, V8.CompileDeserializeMicroSeconds, 1000000,         \
      MICROSECOND)                                                             \
   /* Total compilation time incl. caching/parsing */                          \
-  HT(compile_script, V8.CompileScriptMicroSeconds, 1000000, MICROSECOND)
-
+  HT(compile_script, V8.CompileScriptMicroSeconds, 1000000, MICROSECOND)      \
+  /* Asm/Wasm */                                                              \
+  HT(wasm_instantiate_time, V8.WasmInstantiateMicroSeconds, 1000000,          \
+     MICROSECOND)                                                             \
+  HT(wasm_decode_module_time, V8.WasmDecodeModuleMicroSeconds, 1000000,       \
+     MICROSECOND)                                                             \
+  HT(wasm_decode_function_time, V8.WasmDecodeFunctionMicroSeconds, 1000000,   \
+     MICROSECOND)                                                             \
+  HT(wasm_compile_time, V8.WasmCompileMicroSeconds, 1000000, MICROSECOND)     \
+  HT(wasm_compile_function_time, V8.WasmCompileFunctionMicroSeconds, 1000000, \
+     MICROSECOND)
 
 #define AGGREGATABLE_HISTOGRAM_TIMER_LIST(AHT) \
   AHT(compile_lazy, V8.CompileLazyMicroSeconds)
 
 
 #define HISTOGRAM_PERCENTAGE_LIST(HP)                                          \
   /* Heap fragmentation. */                                                    \
   HP(external_fragmentation_total, V8.MemoryExternalFragmentationTotal)        \
   HP(external_fragmentation_old_space, V8.MemoryExternalFragmentationOldSpace) \
   HP(external_fragmentation_code_space,                                        \
@@ skipping 10 matching lines @@
   HP(codegen_fraction_crankshaft, V8.CodegenFractionCrankshaft)
 
 
 #define HISTOGRAM_LEGACY_MEMORY_LIST(HM)                                      \
   HM(heap_sample_total_committed, V8.MemoryHeapSampleTotalCommitted)          \
   HM(heap_sample_total_used, V8.MemoryHeapSampleTotalUsed)                    \
   HM(heap_sample_map_space_committed, V8.MemoryHeapSampleMapSpaceCommitted)   \
   HM(heap_sample_code_space_committed, V8.MemoryHeapSampleCodeSpaceCommitted) \
   HM(heap_sample_maximum_committed, V8.MemoryHeapSampleMaximumCommitted)
 
-#define HISTOGRAM_MEMORY_LIST(HM)                   \
-  HM(memory_heap_committed, V8.MemoryHeapCommitted) \
-  HM(memory_heap_used, V8.MemoryHeapUsed)
-
+#define HISTOGRAM_MEMORY_LIST(HM)                                         \
+  HM(memory_heap_committed, V8.MemoryHeapCommitted)                       \
+  HM(memory_heap_used, V8.MemoryHeapUsed)                                 \
+  /* Asm/Wasm */                                                          \
+  HM(wasm_decode_peak_memory, V8.WasmDecodePeakMemory)                    \
+  HM(wasm_instantiate_peak_memory, V8.WasmInstantiatePeakMemory)          \
+  HM(wasm_compile_function_peak_memory, V8.WasmCompileFunctionPeakMemory) \
+  HM(wasm_min_mem_pages_memory, V8.WasmMinMemPagesMemory)                 \
+  HM(wasm_max_mem_pages_memory, V8.WasmMaxMemPagesMemory)                 \
+  HM(wasm_function_bytes, V8.WasmFunctionBytes)                           \
+  HM(wasm_module_bytes, V8.WasmModuleBytes)
 
 // WARNING: STATS_COUNTER_LIST_* is a very large macro that is causing MSVC
 // Intellisense to crash.  It was broken into two macros (each of length 40
 // lines) rather than one macro (of length about 80 lines) to work around
 // this problem.  Please avoid using recursive macros of this length when
 // possible.
 #define STATS_COUNTER_LIST_1(SC)                                      \
   /* Global Handle Count*/                                            \
   SC(global_handles, V8.GlobalHandles)                                \
   /* OS Memory allocated */                                           \
@@ skipping 28 matching lines @@
   /* Number of contexts created from scratch. */                      \
   SC(contexts_created_from_scratch, V8.ContextsCreatedFromScratch)    \
   /* Number of contexts created by partial snapshot. */               \
   SC(contexts_created_by_snapshot, V8.ContextsCreatedBySnapshot)      \
   /* Number of code objects found from pc. */                         \
   SC(pc_to_code, V8.PcToCode)                                         \
   SC(pc_to_code_cached, V8.PcToCodeCached)                            \
   /* The store-buffer implementation of the write barrier. */         \
   SC(store_buffer_overflows, V8.StoreBufferOverflows)
 
-
 #define STATS_COUNTER_LIST_2(SC)                                               \
   /* Number of code stubs. */                                                  \
   SC(code_stubs, V8.CodeStubs)                                                 \
   /* Amount of stub code. */                                                   \
   SC(total_stubs_code_size, V8.TotalStubsCodeSize)                             \
   /* Amount of (JS) compiled code. */                                          \
   SC(total_compiled_code_size, V8.TotalCompiledCodeSize)                       \
   SC(gc_compactor_caused_by_request, V8.GCCompactorCausedByRequest)            \
   SC(gc_compactor_caused_by_promoted_data, V8.GCCompactorCausedByPromotedData) \
   SC(gc_compactor_caused_by_oldspace_exhaustion,                               \
@@ skipping 39 matching lines @@
   SC(regexp_entry_native, V8.RegExpEntryNative)                                \
   SC(number_to_string_native, V8.NumberToStringNative)                         \
   SC(number_to_string_runtime, V8.NumberToStringRuntime)                       \
   SC(math_atan2_runtime, V8.MathAtan2Runtime)                                  \
   SC(math_clz32_runtime, V8.MathClz32Runtime)                                  \
   SC(math_exp_runtime, V8.MathExpRuntime)                                      \
   SC(math_log_runtime, V8.MathLogRuntime)                                      \
   SC(math_pow_runtime, V8.MathPowRuntime)                                      \
   SC(stack_interrupts, V8.StackInterrupts)                                     \
   SC(runtime_profiler_ticks, V8.RuntimeProfilerTicks)                          \
-  SC(runtime_calls, V8.RuntimeCalls)                          \
+  SC(runtime_calls, V8.RuntimeCalls)                                           \
   SC(bounds_checks_eliminated, V8.BoundsChecksEliminated)                      \
   SC(bounds_checks_hoisted, V8.BoundsChecksHoisted)                            \
   SC(soft_deopts_requested, V8.SoftDeoptsRequested)                            \
   SC(soft_deopts_inserted, V8.SoftDeoptsInserted)                              \
   SC(soft_deopts_executed, V8.SoftDeoptsExecuted)                              \
   /* Number of write barriers in generated code. */                            \
   SC(write_barriers_dynamic, V8.WriteBarriersDynamic)                          \
   SC(write_barriers_static, V8.WriteBarriersStatic)                            \
   SC(new_space_bytes_available, V8.MemoryNewSpaceBytesAvailable)               \
   SC(new_space_bytes_committed, V8.MemoryNewSpaceBytesCommitted)               \
@@ skipping 197 matching lines @@
 
   explicit Counters(Isolate* isolate);
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(Counters);
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COUNTERS_H_