Upgrade V8 to version 4.9.385.28
https://chromium.googlesource.com/v8/v8/+/4.9.385.28
FPIIM-449
Change-Id: I4b2e74289d4bf3667f2f3dc8aa2e541f63e26eb4
diff --git a/src/counters.h b/src/counters.h
index 41107cf..d8a3f09 100644
--- a/src/counters.h
+++ b/src/counters.h
@@ -8,6 +8,7 @@
#include "include/v8.h"
#include "src/allocation.h"
#include "src/base/platform/elapsed-timer.h"
+#include "src/base/platform/time.h"
#include "src/globals.h"
#include "src/objects.h"
@@ -223,13 +224,16 @@
// A HistogramTimer allows distributions of results to be created.
class HistogramTimer : public Histogram {
public:
- HistogramTimer() { }
- HistogramTimer(const char* name,
- int min,
- int max,
- int num_buckets,
- Isolate* isolate)
- : Histogram(name, min, max, num_buckets, isolate) {}
+ enum Resolution {
+ MILLISECOND,
+ MICROSECOND
+ };
+
+ HistogramTimer() {}
+ HistogramTimer(const char* name, int min, int max, Resolution resolution,
+ int num_buckets, Isolate* isolate)
+ : Histogram(name, min, max, num_buckets, isolate),
+ resolution_(resolution) {}
// Start the timer.
void Start();
@@ -249,6 +253,7 @@
private:
base::ElapsedTimer timer_;
+ Resolution resolution_;
};
// Helper class for scoping a HistogramTimer.
@@ -291,85 +296,261 @@
#endif
};
+
+// A histogram timer that can aggregate events within a larger scope.
+//
+// Intended use of this timer is to have an outer (aggregating) and an inner
+// (to be aggregated) scope, where the inner scope measure the time of events,
+// and all those inner scope measurements will be summed up by the outer scope.
+// An example use might be to aggregate the time spent in lazy compilation
+// while running a script.
+//
+// Helpers:
+// - AggregatingHistogramTimerScope, the "outer" scope within which
+// times will be summed up.
+// - AggregatedHistogramTimerScope, the "inner" scope which defines the
+// events to be timed.
+class AggregatableHistogramTimer : public Histogram {
+ public:
+ AggregatableHistogramTimer() {}
+ AggregatableHistogramTimer(const char* name, int min, int max,
+ int num_buckets, Isolate* isolate)
+ : Histogram(name, min, max, num_buckets, isolate) {}
+
+ // Start/stop the "outer" scope.
+ void Start() { time_ = base::TimeDelta(); }
+ void Stop() { AddSample(static_cast<int>(time_.InMicroseconds())); }
+
+ // Add a time value ("inner" scope).
+ void Add(base::TimeDelta other) { time_ += other; }
+
+ private:
+ base::TimeDelta time_;
+};
+
+
+// A helper class for use with AggregatableHistogramTimer.
+class AggregatingHistogramTimerScope {
+ public:
+ explicit AggregatingHistogramTimerScope(AggregatableHistogramTimer* histogram)
+ : histogram_(histogram) {
+ histogram_->Start();
+ }
+ ~AggregatingHistogramTimerScope() { histogram_->Stop(); }
+
+ private:
+ AggregatableHistogramTimer* histogram_;
+};
+
+
+// A helper class for use with AggregatableHistogramTimer.
+class AggregatedHistogramTimerScope {
+ public:
+ explicit AggregatedHistogramTimerScope(AggregatableHistogramTimer* histogram)
+ : histogram_(histogram) {
+ timer_.Start();
+ }
+ ~AggregatedHistogramTimerScope() { histogram_->Add(timer_.Elapsed()); }
+
+ private:
+ base::ElapsedTimer timer_;
+ AggregatableHistogramTimer* histogram_;
+};
+
+
+// AggretatedMemoryHistogram collects (time, value) sample pairs and turns
+// them into time-uniform samples for the backing historgram, such that the
+// backing histogram receives one sample every T ms, where the T is controlled
+// by the FLAG_histogram_interval.
+//
+// More formally: let F be a real-valued function that maps time to sample
+// values. We define F as a linear interpolation between adjacent samples. For
+// each time interval [x; x + T) the backing histogram gets one sample value
+// that is the average of F(t) in the interval.
+template <typename Histogram>
+class AggregatedMemoryHistogram {
+ public:
+ AggregatedMemoryHistogram()
+ : is_initialized_(false),
+ start_ms_(0.0),
+ last_ms_(0.0),
+ aggregate_value_(0.0),
+ last_value_(0.0),
+ backing_histogram_(NULL) {}
+
+ explicit AggregatedMemoryHistogram(Histogram* backing_histogram)
+ : AggregatedMemoryHistogram() {
+ backing_histogram_ = backing_histogram;
+ }
+
+ // Invariants that hold before and after AddSample if
+ // is_initialized_ is true:
+ //
+ // 1) For we processed samples that came in before start_ms_ and sent the
+ // corresponding aggregated samples to backing histogram.
+ // 2) (last_ms_, last_value_) is the last received sample.
+ // 3) last_ms_ < start_ms_ + FLAG_histogram_interval.
+ // 4) aggregate_value_ is the average of the function that is constructed by
+ // linearly interpolating samples received between start_ms_ and last_ms_.
+ void AddSample(double current_ms, double current_value);
+
+ private:
+ double Aggregate(double current_ms, double current_value);
+ bool is_initialized_;
+ double start_ms_;
+ double last_ms_;
+ double aggregate_value_;
+ double last_value_;
+ Histogram* backing_histogram_;
+};
+
+
+template <typename Histogram>
+void AggregatedMemoryHistogram<Histogram>::AddSample(double current_ms,
+ double current_value) {
+ if (!is_initialized_) {
+ aggregate_value_ = current_value;
+ start_ms_ = current_ms;
+ last_value_ = current_value;
+ last_ms_ = current_ms;
+ is_initialized_ = true;
+ } else {
+ const double kEpsilon = 1e-6;
+ const int kMaxSamples = 1000;
+ if (current_ms < last_ms_ + kEpsilon) {
+ // Two samples have the same time, remember the last one.
+ last_value_ = current_value;
+ } else {
+ double sample_interval_ms = FLAG_histogram_interval;
+ double end_ms = start_ms_ + sample_interval_ms;
+ if (end_ms <= current_ms + kEpsilon) {
+ // Linearly interpolate between the last_ms_ and the current_ms.
+ double slope = (current_value - last_value_) / (current_ms - last_ms_);
+ int i;
+ // Send aggregated samples to the backing histogram from the start_ms
+ // to the current_ms.
+ for (i = 0; i < kMaxSamples && end_ms <= current_ms + kEpsilon; i++) {
+ double end_value = last_value_ + (end_ms - last_ms_) * slope;
+ double sample_value;
+ if (i == 0) {
+ // Take aggregate_value_ into account.
+ sample_value = Aggregate(end_ms, end_value);
+ } else {
+ // There is no aggregate_value_ for i > 0.
+ sample_value = (last_value_ + end_value) / 2;
+ }
+ backing_histogram_->AddSample(static_cast<int>(sample_value + 0.5));
+ last_value_ = end_value;
+ last_ms_ = end_ms;
+ end_ms += sample_interval_ms;
+ }
+ if (i == kMaxSamples) {
+ // We hit the sample limit, ignore the remaining samples.
+ aggregate_value_ = current_value;
+ start_ms_ = current_ms;
+ } else {
+ aggregate_value_ = last_value_;
+ start_ms_ = last_ms_;
+ }
+ }
+ aggregate_value_ = current_ms > start_ms_ + kEpsilon
+ ? Aggregate(current_ms, current_value)
+ : aggregate_value_;
+ last_value_ = current_value;
+ last_ms_ = current_ms;
+ }
+ }
+}
+
+
+template <typename Histogram>
+double AggregatedMemoryHistogram<Histogram>::Aggregate(double current_ms,
+ double current_value) {
+ double interval_ms = current_ms - start_ms_;
+ double value = (current_value + last_value_) / 2;
+ // The aggregate_value_ is the average for [start_ms_; last_ms_].
+ // The value is the average for [last_ms_; current_ms].
+ // Return the weighted average of the aggregate_value_ and the value.
+ return aggregate_value_ * ((last_ms_ - start_ms_) / interval_ms) +
+ value * ((current_ms - last_ms_) / interval_ms);
+}
+
+
#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(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)
-#define HISTOGRAM_TIMER_LIST(HT) \
- /* Garbage collection timers. */ \
- HT(gc_compactor, V8.GCCompactor) \
- HT(gc_scavenger, V8.GCScavenger) \
- HT(gc_context, V8.GCContext) /* GC context cleanup time */ \
- HT(gc_idle_notification, V8.GCIdleNotification) \
- HT(gc_incremental_marking, V8.GCIncrementalMarking) \
- HT(gc_low_memory_notification, V8.GCLowMemoryNotification) \
- /* Parsing timers. */ \
- HT(parse, V8.Parse) \
- HT(parse_lazy, V8.ParseLazy) \
- HT(pre_parse, V8.PreParse) \
- /* Total compilation times. */ \
- HT(compile, V8.Compile) \
- HT(compile_eval, V8.CompileEval) \
- /* Serialization as part of compilation (code caching) */ \
- HT(compile_serialize, V8.CompileSerialize) \
- HT(compile_deserialize, V8.CompileDeserialize)
+#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 */ \
+ HT(gc_idle_notification, V8.GCIdleNotification, 10000, MILLISECOND) \
+ HT(gc_incremental_marking, V8.GCIncrementalMarking, 10000, MILLISECOND) \
+ HT(gc_incremental_marking_start, V8.GCIncrementalMarkingStart, 10000, \
+ MILLISECOND) \
+ HT(gc_incremental_marking_finalize, V8.GCIncrementalMarkingFinalize, 10000, \
+ MILLISECOND) \
+ HT(gc_low_memory_notification, V8.GCLowMemoryNotification, 10000, \
+ MILLISECOND) \
+ /* Parsing timers. */ \
+ HT(parse, V8.ParseMicroSeconds, 1000000, MICROSECOND) \
+ 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)
-#define HISTOGRAM_PERCENTAGE_LIST(HP) \
- /* Heap fragmentation. */ \
- HP(external_fragmentation_total, \
- V8.MemoryExternalFragmentationTotal) \
- HP(external_fragmentation_old_pointer_space, \
- V8.MemoryExternalFragmentationOldPointerSpace) \
- HP(external_fragmentation_old_data_space, \
- V8.MemoryExternalFragmentationOldDataSpace) \
- HP(external_fragmentation_code_space, \
- V8.MemoryExternalFragmentationCodeSpace) \
- HP(external_fragmentation_map_space, \
- V8.MemoryExternalFragmentationMapSpace) \
- HP(external_fragmentation_cell_space, \
- V8.MemoryExternalFragmentationCellSpace) \
- HP(external_fragmentation_property_cell_space, \
- V8.MemoryExternalFragmentationPropertyCellSpace) \
- HP(external_fragmentation_lo_space, \
- V8.MemoryExternalFragmentationLoSpace) \
- /* Percentages of heap committed to each space. */ \
- HP(heap_fraction_new_space, \
- V8.MemoryHeapFractionNewSpace) \
- HP(heap_fraction_old_pointer_space, \
- V8.MemoryHeapFractionOldPointerSpace) \
- HP(heap_fraction_old_data_space, \
- V8.MemoryHeapFractionOldDataSpace) \
- HP(heap_fraction_code_space, \
- V8.MemoryHeapFractionCodeSpace) \
- HP(heap_fraction_map_space, \
- V8.MemoryHeapFractionMapSpace) \
- HP(heap_fraction_cell_space, \
- V8.MemoryHeapFractionCellSpace) \
- HP(heap_fraction_property_cell_space, \
- V8.MemoryHeapFractionPropertyCellSpace) \
- HP(heap_fraction_lo_space, \
- V8.MemoryHeapFractionLoSpace) \
- /* Percentage of crankshafted codegen. */ \
- HP(codegen_fraction_crankshaft, \
- V8.CodegenFractionCrankshaft) \
+#define AGGREGATABLE_HISTOGRAM_TIMER_LIST(AHT) \
+ AHT(compile_lazy, V8.CompileLazyMicroSeconds)
-#define HISTOGRAM_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_cell_space_committed, \
- V8.MemoryHeapSampleCellSpaceCommitted) \
- HM(heap_sample_property_cell_space_committed, \
- V8.MemoryHeapSamplePropertyCellSpaceCommitted) \
- HM(heap_sample_code_space_committed, \
- V8.MemoryHeapSampleCodeSpaceCommitted) \
- HM(heap_sample_maximum_committed, \
- V8.MemoryHeapSampleMaximumCommitted) \
+#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, \
+ V8.MemoryExternalFragmentationCodeSpace) \
+ HP(external_fragmentation_map_space, V8.MemoryExternalFragmentationMapSpace) \
+ HP(external_fragmentation_lo_space, V8.MemoryExternalFragmentationLoSpace) \
+ /* Percentages of heap committed to each space. */ \
+ HP(heap_fraction_new_space, V8.MemoryHeapFractionNewSpace) \
+ HP(heap_fraction_old_space, V8.MemoryHeapFractionOldSpace) \
+ HP(heap_fraction_code_space, V8.MemoryHeapFractionCodeSpace) \
+ HP(heap_fraction_map_space, V8.MemoryHeapFractionMapSpace) \
+ HP(heap_fraction_lo_space, V8.MemoryHeapFractionLoSpace) \
+ /* Percentage of crankshafted codegen. */ \
+ 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)
// WARNING: STATS_COUNTER_LIST_* is a very large macro that is causing MSVC
@@ -399,11 +580,6 @@
SC(arguments_adaptors, V8.ArgumentsAdaptors) \
SC(compilation_cache_hits, V8.CompilationCacheHits) \
SC(compilation_cache_misses, V8.CompilationCacheMisses) \
- SC(string_ctor_calls, V8.StringConstructorCalls) \
- SC(string_ctor_conversions, V8.StringConstructorConversions) \
- SC(string_ctor_cached_number, V8.StringConstructorCachedNumber) \
- SC(string_ctor_string_value, V8.StringConstructorStringValue) \
- SC(string_ctor_gc_required, V8.StringConstructorGCRequired) \
/* Amount of evaled source code. */ \
SC(total_eval_size, V8.TotalEvalSize) \
/* Amount of loaded source code. */ \
@@ -486,7 +662,6 @@
SC(megamorphic_stub_cache_updates, V8.MegamorphicStubCacheUpdates) \
SC(array_function_runtime, V8.ArrayFunctionRuntime) \
SC(array_function_native, V8.ArrayFunctionNative) \
- SC(for_in, V8.ForIn) \
SC(enum_cache_hits, V8.EnumCacheHits) \
SC(enum_cache_misses, V8.EnumCacheMisses) \
SC(fast_new_closure_total, V8.FastNewClosureTotal) \
@@ -508,6 +683,7 @@
SC(math_asin, V8.MathAsin) \
SC(math_atan, V8.MathAtan) \
SC(math_atan2, V8.MathAtan2) \
+ SC(math_clz32, V8.MathClz32) \
SC(math_exp, V8.MathExp) \
SC(math_floor, V8.MathFloor) \
SC(math_log, V8.MathLog) \
@@ -527,31 +703,22 @@
SC(new_space_bytes_available, V8.MemoryNewSpaceBytesAvailable) \
SC(new_space_bytes_committed, V8.MemoryNewSpaceBytesCommitted) \
SC(new_space_bytes_used, V8.MemoryNewSpaceBytesUsed) \
- SC(old_pointer_space_bytes_available, \
- V8.MemoryOldPointerSpaceBytesAvailable) \
- SC(old_pointer_space_bytes_committed, \
- V8.MemoryOldPointerSpaceBytesCommitted) \
- SC(old_pointer_space_bytes_used, V8.MemoryOldPointerSpaceBytesUsed) \
- SC(old_data_space_bytes_available, V8.MemoryOldDataSpaceBytesAvailable) \
- SC(old_data_space_bytes_committed, V8.MemoryOldDataSpaceBytesCommitted) \
- SC(old_data_space_bytes_used, V8.MemoryOldDataSpaceBytesUsed) \
+ SC(old_space_bytes_available, V8.MemoryOldSpaceBytesAvailable) \
+ SC(old_space_bytes_committed, V8.MemoryOldSpaceBytesCommitted) \
+ SC(old_space_bytes_used, V8.MemoryOldSpaceBytesUsed) \
SC(code_space_bytes_available, V8.MemoryCodeSpaceBytesAvailable) \
SC(code_space_bytes_committed, V8.MemoryCodeSpaceBytesCommitted) \
SC(code_space_bytes_used, V8.MemoryCodeSpaceBytesUsed) \
SC(map_space_bytes_available, V8.MemoryMapSpaceBytesAvailable) \
SC(map_space_bytes_committed, V8.MemoryMapSpaceBytesCommitted) \
SC(map_space_bytes_used, V8.MemoryMapSpaceBytesUsed) \
- SC(cell_space_bytes_available, V8.MemoryCellSpaceBytesAvailable) \
- SC(cell_space_bytes_committed, V8.MemoryCellSpaceBytesCommitted) \
- SC(cell_space_bytes_used, V8.MemoryCellSpaceBytesUsed) \
- SC(property_cell_space_bytes_available, \
- V8.MemoryPropertyCellSpaceBytesAvailable) \
- SC(property_cell_space_bytes_committed, \
- V8.MemoryPropertyCellSpaceBytesCommitted) \
- SC(property_cell_space_bytes_used, V8.MemoryPropertyCellSpaceBytesUsed) \
SC(lo_space_bytes_available, V8.MemoryLoSpaceBytesAvailable) \
SC(lo_space_bytes_committed, V8.MemoryLoSpaceBytesCommitted) \
- SC(lo_space_bytes_used, V8.MemoryLoSpaceBytesUsed)
+ SC(lo_space_bytes_used, V8.MemoryLoSpaceBytesUsed) \
+ SC(turbo_escape_allocs_replaced, V8.TurboEscapeAllocsReplaced) \
+ SC(crankshaft_escape_allocs_replaced, V8.CrankshaftEscapeAllocsReplaced) \
+ SC(turbo_escape_loads_replaced, V8.TurboEscapeLoadsReplaced) \
+ SC(crankshaft_escape_loads_replaced, V8.CrankshaftEscapeLoadsReplaced)
// This file contains all the v8 counters that are in use.
@@ -562,11 +729,16 @@
HISTOGRAM_RANGE_LIST(HR)
#undef HR
-#define HT(name, caption) \
+#define HT(name, caption, max, res) \
HistogramTimer* name() { return &name##_; }
HISTOGRAM_TIMER_LIST(HT)
#undef HT
+#define AHT(name, caption) \
+ AggregatableHistogramTimer* name() { return &name##_; }
+ AGGREGATABLE_HISTOGRAM_TIMER_LIST(AHT)
+#undef AHT
+
#define HP(name, caption) \
Histogram* name() { return &name##_; }
HISTOGRAM_PERCENTAGE_LIST(HP)
@@ -574,6 +746,14 @@
#define HM(name, caption) \
Histogram* name() { return &name##_; }
+ HISTOGRAM_LEGACY_MEMORY_LIST(HM)
+ HISTOGRAM_MEMORY_LIST(HM)
+#undef HM
+
+#define HM(name, caption) \
+ AggregatedMemoryHistogram<Histogram>* aggregated_##name() { \
+ return &aggregated_##name##_; \
+ }
HISTOGRAM_MEMORY_LIST(HM)
#undef HM
@@ -614,13 +794,17 @@
#undef SC
enum Id {
-#define RATE_ID(name, caption) k_##name,
+#define RATE_ID(name, caption, max, res) k_##name,
HISTOGRAM_TIMER_LIST(RATE_ID)
#undef RATE_ID
+#define AGGREGATABLE_ID(name, caption) k_##name,
+ AGGREGATABLE_HISTOGRAM_TIMER_LIST(AGGREGATABLE_ID)
+#undef AGGREGATABLE_ID
#define PERCENTAGE_ID(name, caption) k_##name,
HISTOGRAM_PERCENTAGE_LIST(PERCENTAGE_ID)
#undef PERCENTAGE_ID
#define MEMORY_ID(name, caption) k_##name,
+ HISTOGRAM_LEGACY_MEMORY_LIST(MEMORY_ID)
HISTOGRAM_MEMORY_LIST(MEMORY_ID)
#undef MEMORY_ID
#define COUNTER_ID(name, caption) k_##name,
@@ -653,11 +837,15 @@
HISTOGRAM_RANGE_LIST(HR)
#undef HR
-#define HT(name, caption) \
- HistogramTimer name##_;
+#define HT(name, caption, max, res) HistogramTimer name##_;
HISTOGRAM_TIMER_LIST(HT)
#undef HT
+#define AHT(name, caption) \
+ AggregatableHistogramTimer name##_;
+ AGGREGATABLE_HISTOGRAM_TIMER_LIST(AHT)
+#undef AHT
+
#define HP(name, caption) \
Histogram name##_;
HISTOGRAM_PERCENTAGE_LIST(HP)
@@ -665,6 +853,12 @@
#define HM(name, caption) \
Histogram name##_;
+ HISTOGRAM_LEGACY_MEMORY_LIST(HM)
+ HISTOGRAM_MEMORY_LIST(HM)
+#undef HM
+
+#define HM(name, caption) \
+ AggregatedMemoryHistogram<Histogram> aggregated_##name##_;
HISTOGRAM_MEMORY_LIST(HM)
#undef HM
@@ -705,6 +899,7 @@
DISALLOW_IMPLICIT_CONSTRUCTORS(Counters);
};
-} } // namespace v8::internal
+} // namespace internal
+} // namespace v8
#endif // V8_COUNTERS_H_