Reduce bucket count and range for wasm function count, and add "module" to some names.

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 572 matching lines @@
   /* 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)                      \
   /* Asm/Wasm. */                                                             \
-  HR(wasm_functions_per_module, V8.WasmFunctionsPerModule, 0, 10000, 101)
+  HR(wasm_functions_per_module, V8.WasmFunctionsPerModule, 1, 10000, 51)

[Ilya Sherman, 2016/04/19 09:01:08]

If you're already logging this histogram, then changing the underlying bucket
count will result in some weird meshing of data that records to 100 buckets vs.
to 50 buckets.  If the histogram has only been live on Canary or Dev builds,
that might be ok, because those builds are not very long-lasting.  OTOH, if the
code has already made it into a branch (and you're not planning to merge to that
branch), then it's going to keep causing confusion indefinitely.  In that case,
I would recommend renaming the histogram while you make this change.

[bradn, 2016/04/19 22:02:56]

Isn't on the branch yet.

 
 #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 12 matching lines @@
   /* 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)      \
   /* Asm/Wasm */                                                              \
-  HT(wasm_instantiate_time, V8.WasmInstantiateMicroSeconds, 1000000,          \
-     MICROSECOND)                                                             \
+  HT(wasm_instantiate_module_time, V8.WasmInstantiateModuleMicroSeconds,      \
+     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_module_time, V8.WasmCompileModuleMicroSeconds, 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)        \
@@ skipping 12 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)                         \
-  /* Asm/Wasm */                                                  \
-  HM(wasm_decode_peak_memory_bytes, V8.WasmDecodePeakMemoryBytes) \
-  HM(wasm_compile_function_peak_memory_bytes,                     \
-     V8.WasmCompileFunctionPeakMemoryBytes)                       \
-  HM(wasm_min_mem_pages_count, V8.WasmMinMemPagesCount)           \
-  HM(wasm_max_mem_pages_count, V8.WasmMaxMemPagesCount)           \
-  HM(wasm_function_size_bytes, V8.WasmFunctionSizeBytes)          \
+#define HISTOGRAM_MEMORY_LIST(HM)                                              \
+  HM(memory_heap_committed, V8.MemoryHeapCommitted)                            \
+  HM(memory_heap_used, V8.MemoryHeapUsed)                                      \
+  /* Asm/Wasm */                                                               \
+  HM(wasm_decode_module_peak_memory_bytes, V8.WasmDecodeModulePeakMemoryBytes) \
+  HM(wasm_compile_function_peak_memory_bytes,                                  \
+     V8.WasmCompileFunctionPeakMemoryBytes)                                    \
+  HM(wasm_min_mem_pages_count, V8.WasmMinMemPagesCount)                        \
+  HM(wasm_max_mem_pages_count, V8.WasmMaxMemPagesCount)                        \
+  HM(wasm_function_size_bytes, V8.WasmFunctionSizeBytes)                       \
   HM(wasm_module_size_bytes, V8.WasmModuleSizeBytes)
 
 // 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)                                \
@@ skipping 303 matching lines @@
 
   explicit Counters(Isolate* isolate);
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(Counters);
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COUNTERS_H_