2010-10-04 14:30:43 +00:00
|
|
|
// Copyright 2010 the V8 project authors. All rights reserved.
|
2008-07-03 15:10:15 +00:00
|
|
|
// Redistribution and use in source and binary forms, with or without
|
|
|
|
|
// modification, are permitted provided that the following conditions are
|
|
|
|
|
// met:
|
|
|
|
|
//
|
|
|
|
|
// * Redistributions of source code must retain the above copyright
|
|
|
|
|
// notice, this list of conditions and the following disclaimer.
|
|
|
|
|
// * Redistributions in binary form must reproduce the above
|
|
|
|
|
// copyright notice, this list of conditions and the following
|
|
|
|
|
// disclaimer in the documentation and/or other materials provided
|
|
|
|
|
// with the distribution.
|
|
|
|
|
// * Neither the name of Google Inc. nor the names of its
|
|
|
|
|
// contributors may be used to endorse or promote products derived
|
|
|
|
|
// from this software without specific prior written permission.
|
|
|
|
|
//
|
|
|
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
|
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
|
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
|
|
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
|
|
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
|
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
|
|
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
|
|
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
|
|
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
|
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
|
|
|
|
|
|
#ifndef V8_V8_COUNTERS_H_
|
|
|
|
|
#define V8_V8_COUNTERS_H_
|
|
|
|
|
|
2010-12-17 08:58:04 +00:00
|
|
|
#include "allocation.h"
|
2008-07-03 15:10:15 +00:00
|
|
|
#include "counters.h"
|
2010-12-17 08:58:04 +00:00
|
|
|
#include "v8globals.h"
|
2008-07-03 15:10:15 +00:00
|
|
|
|
2009-05-25 10:05:56 +00:00
|
|
|
namespace v8 {
|
|
|
|
|
namespace internal {
|
2008-07-03 15:10:15 +00:00
|
|
|
|
2009-05-14 10:29:48 +00:00
|
|
|
#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 */ \
|
|
|
|
|
/* 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) \
|
2010-10-04 14:30:43 +00:00
|
|
|
HT(compile_lazy, V8.CompileLazy)
|
Initial infrastructure for fast compilation of top-level code. The
fast code generator is optimized for compilation time and code size.
Currently it is only implemented on IA32. It is potentially triggered
for any code in the global scope (including code eval'd in the global
scope). It performs a syntactic check and chooses to compile in fast
mode if the AST contains only supported constructs and matches some
other constraints.
Initially supported constructs are
* ExpressionStatement,
* ReturnStatement,
* VariableProxy (variable references) to parameters and
stack-allocated locals,
* Assignment with lhs a parameter or stack-allocated local, and
* Literal
This allows compilation of literals at the top level and not much
else.
All intermediate values are allocated to temporaries and the stack is
used for all temporaries. The extra memory traffic is a known issue.
The code generated for 'true' is:
0 push ebp
1 mov ebp,esp
3 push esi
4 push edi
5 push 0xf5cca135 ;; object: 0xf5cca135 <undefined>
10 cmp esp,[0x8277efc]
16 jnc 27 (0xf5cbbb1b)
22 call 0xf5cac960 ;; code: STUB, StackCheck, minor: 0
27 push 0xf5cca161 ;; object: 0xf5cca161 <true>
32 mov eax,[esp]
35 mov [ebp+0xf4],eax
38 pop eax
39 mov eax,[ebp+0xf4]
42 mov esp,ebp ;; js return
44 pop ebp
45 ret 0x4
48 mov eax,0xf5cca135 ;; object: 0xf5cca135 <undefined>
53 mov esp,ebp ;; js return
55 pop ebp
56 ret 0x4
Review URL: http://codereview.chromium.org/273050
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3067 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-14 19:30:50 +00:00
|
|
|
|
2008-07-03 15:10:15 +00:00
|
|
|
|
|
|
|
|
// 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.
|
2010-01-27 11:08:32 +00:00
|
|
|
#define STATS_COUNTER_LIST_1(SC) \
|
|
|
|
|
/* Global Handle Count*/ \
|
|
|
|
|
SC(global_handles, V8.GlobalHandles) \
|
|
|
|
|
/* Mallocs from PCRE */ \
|
|
|
|
|
SC(pcre_mallocs, V8.PcreMallocCount) \
|
|
|
|
|
/* OS Memory allocated */ \
|
|
|
|
|
SC(memory_allocated, V8.OsMemoryAllocated) \
|
2010-08-25 13:25:54 +00:00
|
|
|
SC(normalized_maps, V8.NormalizedMaps) \
|
2010-01-27 11:08:32 +00:00
|
|
|
SC(props_to_dictionary, V8.ObjectPropertiesToDictionary) \
|
|
|
|
|
SC(elements_to_dictionary, V8.ObjectElementsToDictionary) \
|
|
|
|
|
SC(alive_after_last_gc, V8.AliveAfterLastGC) \
|
|
|
|
|
SC(objs_since_last_young, V8.ObjsSinceLastYoung) \
|
|
|
|
|
SC(objs_since_last_full, V8.ObjsSinceLastFull) \
|
|
|
|
|
SC(symbol_table_capacity, V8.SymbolTableCapacity) \
|
|
|
|
|
SC(number_of_symbols, V8.NumberOfSymbols) \
|
|
|
|
|
SC(script_wrappers, V8.ScriptWrappers) \
|
|
|
|
|
SC(call_initialize_stubs, V8.CallInitializeStubs) \
|
|
|
|
|
SC(call_premonomorphic_stubs, V8.CallPreMonomorphicStubs) \
|
|
|
|
|
SC(call_normal_stubs, V8.CallNormalStubs) \
|
|
|
|
|
SC(call_megamorphic_stubs, V8.CallMegamorphicStubs) \
|
|
|
|
|
SC(arguments_adaptors, V8.ArgumentsAdaptors) \
|
|
|
|
|
SC(compilation_cache_hits, V8.CompilationCacheHits) \
|
|
|
|
|
SC(compilation_cache_misses, V8.CompilationCacheMisses) \
|
|
|
|
|
SC(regexp_cache_hits, V8.RegExpCacheHits) \
|
|
|
|
|
SC(regexp_cache_misses, V8.RegExpCacheMisses) \
|
2010-08-26 13:59:37 +00:00
|
|
|
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) \
|
2010-01-27 11:08:32 +00:00
|
|
|
/* Amount of evaled source code. */ \
|
|
|
|
|
SC(total_eval_size, V8.TotalEvalSize) \
|
|
|
|
|
/* Amount of loaded source code. */ \
|
|
|
|
|
SC(total_load_size, V8.TotalLoadSize) \
|
|
|
|
|
/* Amount of parsed source code. */ \
|
|
|
|
|
SC(total_parse_size, V8.TotalParseSize) \
|
|
|
|
|
/* Amount of source code skipped over using preparsing. */ \
|
|
|
|
|
SC(total_preparse_skipped, V8.TotalPreparseSkipped) \
|
2010-09-07 12:52:16 +00:00
|
|
|
/* Number of symbol lookups skipped using preparsing */ \
|
|
|
|
|
SC(total_preparse_symbols_skipped, V8.TotalPreparseSymbolSkipped) \
|
2010-01-27 11:08:32 +00:00
|
|
|
/* Amount of compiled source code. */ \
|
|
|
|
|
SC(total_compile_size, V8.TotalCompileSize) \
|
|
|
|
|
/* Amount of source code compiled with the old codegen. */ \
|
|
|
|
|
SC(total_old_codegen_source_size, V8.TotalOldCodegenSourceSize) \
|
|
|
|
|
/* Amount of source code compiled with the full codegen. */ \
|
2010-03-23 11:40:38 +00:00
|
|
|
SC(total_full_codegen_source_size, V8.TotalFullCodegenSourceSize) \
|
|
|
|
|
/* Number of contexts created from scratch. */ \
|
|
|
|
|
SC(contexts_created_from_scratch, V8.ContextsCreatedFromScratch) \
|
|
|
|
|
/* Number of contexts created by partial snapshot. */ \
|
2010-08-30 08:54:43 +00:00
|
|
|
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)
|
2008-07-03 15:10:15 +00:00
|
|
|
|
|
|
|
|
|
2010-02-09 16:14:14 +00:00
|
|
|
#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, \
|
|
|
|
|
V8.GCCompactorCausedByOldspaceExhaustion) \
|
|
|
|
|
SC(gc_compactor_caused_by_weak_handles, \
|
|
|
|
|
V8.GCCompactorCausedByWeakHandles) \
|
|
|
|
|
SC(gc_last_resort_from_js, V8.GCLastResortFromJS) \
|
|
|
|
|
SC(gc_last_resort_from_handles, V8.GCLastResortFromHandles) \
|
2010-08-16 16:06:46 +00:00
|
|
|
SC(map_slow_to_fast_elements, V8.MapSlowToFastElements) \
|
|
|
|
|
SC(map_fast_to_slow_elements, V8.MapFastToSlowElements) \
|
2011-03-09 15:01:16 +00:00
|
|
|
SC(map_to_external_array_elements, V8.MapToExternalArrayElements) \
|
2010-02-09 16:14:14 +00:00
|
|
|
/* How is the generic keyed-load stub used? */ \
|
|
|
|
|
SC(keyed_load_generic_smi, V8.KeyedLoadGenericSmi) \
|
|
|
|
|
SC(keyed_load_generic_symbol, V8.KeyedLoadGenericSymbol) \
|
2010-06-01 21:11:38 +00:00
|
|
|
SC(keyed_load_generic_lookup_cache, V8.KeyedLoadGenericLookupCache) \
|
2010-02-09 16:14:14 +00:00
|
|
|
SC(keyed_load_generic_slow, V8.KeyedLoadGenericSlow) \
|
|
|
|
|
SC(keyed_load_external_array_slow, V8.KeyedLoadExternalArraySlow) \
|
2010-06-10 05:06:39 +00:00
|
|
|
/* How is the generic keyed-call stub used? */ \
|
|
|
|
|
SC(keyed_call_generic_smi_fast, V8.KeyedCallGenericSmiFast) \
|
|
|
|
|
SC(keyed_call_generic_smi_dict, V8.KeyedCallGenericSmiDict) \
|
|
|
|
|
SC(keyed_call_generic_lookup_cache, V8.KeyedCallGenericLookupCache) \
|
|
|
|
|
SC(keyed_call_generic_lookup_dict, V8.KeyedCallGenericLookupDict) \
|
|
|
|
|
SC(keyed_call_generic_value_type, V8.KeyedCallGenericValueType) \
|
|
|
|
|
SC(keyed_call_generic_slow, V8.KeyedCallGenericSlow) \
|
|
|
|
|
SC(keyed_call_generic_slow_load, V8.KeyedCallGenericSlowLoad) \
|
2010-02-09 16:14:14 +00:00
|
|
|
/* Count how much the monomorphic keyed-load stubs are hit. */ \
|
|
|
|
|
SC(keyed_load_function_prototype, V8.KeyedLoadFunctionPrototype) \
|
|
|
|
|
SC(keyed_load_string_length, V8.KeyedLoadStringLength) \
|
|
|
|
|
SC(keyed_load_array_length, V8.KeyedLoadArrayLength) \
|
|
|
|
|
SC(keyed_load_constant_function, V8.KeyedLoadConstantFunction) \
|
|
|
|
|
SC(keyed_load_field, V8.KeyedLoadField) \
|
|
|
|
|
SC(keyed_load_callback, V8.KeyedLoadCallback) \
|
|
|
|
|
SC(keyed_load_interceptor, V8.KeyedLoadInterceptor) \
|
|
|
|
|
SC(keyed_load_inline, V8.KeyedLoadInline) \
|
|
|
|
|
SC(keyed_load_inline_miss, V8.KeyedLoadInlineMiss) \
|
|
|
|
|
SC(named_load_inline, V8.NamedLoadInline) \
|
|
|
|
|
SC(named_load_inline_miss, V8.NamedLoadInlineMiss) \
|
|
|
|
|
SC(named_load_global_inline, V8.NamedLoadGlobalInline) \
|
|
|
|
|
SC(named_load_global_inline_miss, V8.NamedLoadGlobalInlineMiss) \
|
2010-09-30 17:39:31 +00:00
|
|
|
SC(dont_delete_hint_hit, V8.DontDeleteHintHit) \
|
|
|
|
|
SC(dont_delete_hint_miss, V8.DontDeleteHintMiss) \
|
2010-09-20 13:50:27 +00:00
|
|
|
SC(named_load_global_stub, V8.NamedLoadGlobalStub) \
|
|
|
|
|
SC(named_load_global_stub_miss, V8.NamedLoadGlobalStubMiss) \
|
2010-02-09 16:14:14 +00:00
|
|
|
SC(keyed_store_field, V8.KeyedStoreField) \
|
2010-12-07 11:31:57 +00:00
|
|
|
SC(named_store_inline_field, V8.NamedStoreInlineField) \
|
2010-02-09 16:14:14 +00:00
|
|
|
SC(keyed_store_inline, V8.KeyedStoreInline) \
|
2010-12-07 11:31:57 +00:00
|
|
|
SC(named_load_inline_generic, V8.NamedLoadInlineGeneric) \
|
|
|
|
|
SC(named_load_inline_field, V8.NamedLoadInlineFast) \
|
|
|
|
|
SC(keyed_load_inline_generic, V8.KeyedLoadInlineGeneric) \
|
|
|
|
|
SC(keyed_load_inline_fast, V8.KeyedLoadInlineFast) \
|
|
|
|
|
SC(named_load_full, V8.NamedLoadFull) \
|
|
|
|
|
SC(keyed_load_full, V8.KeyedLoadFull) \
|
|
|
|
|
SC(keyed_store_inline_generic, V8.KeyedStoreInlineGeneric) \
|
|
|
|
|
SC(keyed_store_inline_fast, V8.KeyedStoreInlineFast) \
|
|
|
|
|
SC(named_store_inline_generic, V8.NamedStoreInlineGeneric) \
|
|
|
|
|
SC(named_store_inline_fast, V8.NamedStoreInlineFast) \
|
|
|
|
|
SC(keyed_store_full, V8.KeyedStoreFull) \
|
|
|
|
|
SC(named_store_full, V8.NamedStoreFull) \
|
2010-02-09 16:14:14 +00:00
|
|
|
SC(keyed_store_inline_miss, V8.KeyedStoreInlineMiss) \
|
|
|
|
|
SC(named_store_global_inline, V8.NamedStoreGlobalInline) \
|
|
|
|
|
SC(named_store_global_inline_miss, V8.NamedStoreGlobalInlineMiss) \
|
2010-06-30 12:27:49 +00:00
|
|
|
SC(store_normal_miss, V8.StoreNormalMiss) \
|
|
|
|
|
SC(store_normal_hit, V8.StoreNormalHit) \
|
2010-08-16 16:06:46 +00:00
|
|
|
SC(cow_arrays_created_stub, V8.COWArraysCreatedStub) \
|
|
|
|
|
SC(cow_arrays_created_runtime, V8.COWArraysCreatedRuntime) \
|
|
|
|
|
SC(cow_arrays_converted, V8.COWArraysConverted) \
|
2010-06-23 09:10:21 +00:00
|
|
|
SC(call_miss, V8.CallMiss) \
|
|
|
|
|
SC(keyed_call_miss, V8.KeyedCallMiss) \
|
|
|
|
|
SC(load_miss, V8.LoadMiss) \
|
|
|
|
|
SC(keyed_load_miss, V8.KeyedLoadMiss) \
|
2010-02-09 16:14:14 +00:00
|
|
|
SC(call_const, V8.CallConst) \
|
|
|
|
|
SC(call_const_fast_api, V8.CallConstFastApi) \
|
|
|
|
|
SC(call_const_interceptor, V8.CallConstInterceptor) \
|
|
|
|
|
SC(call_const_interceptor_fast_api, V8.CallConstInterceptorFastApi) \
|
|
|
|
|
SC(call_global_inline, V8.CallGlobalInline) \
|
|
|
|
|
SC(call_global_inline_miss, V8.CallGlobalInlineMiss) \
|
|
|
|
|
SC(constructed_objects, V8.ConstructedObjects) \
|
|
|
|
|
SC(constructed_objects_runtime, V8.ConstructedObjectsRuntime) \
|
|
|
|
|
SC(constructed_objects_stub, V8.ConstructedObjectsStub) \
|
2010-07-02 14:15:04 +00:00
|
|
|
SC(negative_lookups, V8.NegativeLookups) \
|
2010-07-23 08:47:15 +00:00
|
|
|
SC(negative_lookups_miss, V8.NegativeLookupsMiss) \
|
2010-02-09 16:14:14 +00:00
|
|
|
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(zone_segment_bytes, V8.ZoneSegmentBytes) \
|
|
|
|
|
SC(compute_entry_frame, V8.ComputeEntryFrame) \
|
|
|
|
|
SC(generic_binary_stub_calls, V8.GenericBinaryStubCalls) \
|
|
|
|
|
SC(generic_binary_stub_calls_regs, V8.GenericBinaryStubCallsRegs) \
|
|
|
|
|
SC(string_add_runtime, V8.StringAddRuntime) \
|
|
|
|
|
SC(string_add_native, V8.StringAddNative) \
|
2010-03-26 23:33:37 +00:00
|
|
|
SC(string_add_runtime_ext_to_ascii, V8.StringAddRuntimeExtToAscii) \
|
2010-02-09 16:14:14 +00:00
|
|
|
SC(sub_string_runtime, V8.SubStringRuntime) \
|
|
|
|
|
SC(sub_string_native, V8.SubStringNative) \
|
2010-09-01 17:20:36 +00:00
|
|
|
SC(string_add_make_two_char, V8.StringAddMakeTwoChar) \
|
2010-02-09 16:14:14 +00:00
|
|
|
SC(string_compare_native, V8.StringCompareNative) \
|
|
|
|
|
SC(string_compare_runtime, V8.StringCompareRuntime) \
|
|
|
|
|
SC(regexp_entry_runtime, V8.RegExpEntryRuntime) \
|
2010-02-12 11:55:04 +00:00
|
|
|
SC(regexp_entry_native, V8.RegExpEntryNative) \
|
2010-02-16 09:41:11 +00:00
|
|
|
SC(number_to_string_native, V8.NumberToStringNative) \
|
2010-02-23 10:29:02 +00:00
|
|
|
SC(number_to_string_runtime, V8.NumberToStringRuntime) \
|
|
|
|
|
SC(math_acos, V8.MathAcos) \
|
|
|
|
|
SC(math_asin, V8.MathAsin) \
|
|
|
|
|
SC(math_atan, V8.MathAtan) \
|
|
|
|
|
SC(math_atan2, V8.MathAtan2) \
|
|
|
|
|
SC(math_ceil, V8.MathCeil) \
|
|
|
|
|
SC(math_cos, V8.MathCos) \
|
|
|
|
|
SC(math_exp, V8.MathExp) \
|
|
|
|
|
SC(math_floor, V8.MathFloor) \
|
|
|
|
|
SC(math_log, V8.MathLog) \
|
|
|
|
|
SC(math_pow, V8.MathPow) \
|
|
|
|
|
SC(math_round, V8.MathRound) \
|
|
|
|
|
SC(math_sin, V8.MathSin) \
|
|
|
|
|
SC(math_sqrt, V8.MathSqrt) \
|
|
|
|
|
SC(math_tan, V8.MathTan) \
|
|
|
|
|
SC(transcendental_cache_hit, V8.TranscendentalCacheHit) \
|
2010-12-01 10:04:34 +00:00
|
|
|
SC(transcendental_cache_miss, V8.TranscendentalCacheMiss) \
|
2010-12-07 11:31:57 +00:00
|
|
|
SC(stack_interrupts, V8.StackInterrupts) \
|
|
|
|
|
SC(runtime_profiler_ticks, V8.RuntimeProfilerTicks) \
|
|
|
|
|
SC(other_ticks, V8.OtherTicks) \
|
|
|
|
|
SC(js_opt_ticks, V8.JsOptTicks) \
|
|
|
|
|
SC(js_non_opt_ticks, V8.JsNonoptTicks) \
|
|
|
|
|
SC(js_other_ticks, V8.JsOtherTicks) \
|
|
|
|
|
SC(smi_checks_removed, V8.SmiChecksRemoved) \
|
|
|
|
|
SC(map_checks_removed, V8.MapChecksRemoved) \
|
2010-12-01 10:04:34 +00:00
|
|
|
SC(quote_json_char_count, V8.QuoteJsonCharacterCount) \
|
2011-01-05 11:17:37 +00:00
|
|
|
SC(quote_json_char_recount, V8.QuoteJsonCharacterReCount)
|
2008-07-03 15:10:15 +00:00
|
|
|
|
2010-03-23 11:40:38 +00:00
|
|
|
|
2008-07-03 15:10:15 +00:00
|
|
|
// This file contains all the v8 counters that are in use.
|
2011-03-18 20:35:07 +00:00
|
|
|
class Counters {
|
2008-07-03 15:10:15 +00:00
|
|
|
public:
|
2009-03-13 16:06:31 +00:00
|
|
|
#define HT(name, caption) \
|
2011-03-18 20:35:07 +00:00
|
|
|
HistogramTimer* name() { return &name##_; }
|
2009-03-13 16:06:31 +00:00
|
|
|
HISTOGRAM_TIMER_LIST(HT)
|
|
|
|
|
#undef HT
|
2008-07-03 15:10:15 +00:00
|
|
|
|
2008-09-15 08:59:31 +00:00
|
|
|
#define SC(name, caption) \
|
2011-03-18 20:35:07 +00:00
|
|
|
StatsCounter* name() { return &name##_; }
|
2008-07-03 15:10:15 +00:00
|
|
|
STATS_COUNTER_LIST_1(SC)
|
|
|
|
|
STATS_COUNTER_LIST_2(SC)
|
|
|
|
|
#undef SC
|
|
|
|
|
|
|
|
|
|
enum Id {
|
|
|
|
|
#define RATE_ID(name, caption) k_##name,
|
2009-03-13 16:06:31 +00:00
|
|
|
HISTOGRAM_TIMER_LIST(RATE_ID)
|
2008-07-03 15:10:15 +00:00
|
|
|
#undef RATE_ID
|
|
|
|
|
#define COUNTER_ID(name, caption) k_##name,
|
2011-03-18 20:35:07 +00:00
|
|
|
STATS_COUNTER_LIST_1(COUNTER_ID)
|
|
|
|
|
STATS_COUNTER_LIST_2(COUNTER_ID)
|
2008-07-03 15:10:15 +00:00
|
|
|
#undef COUNTER_ID
|
|
|
|
|
#define COUNTER_ID(name) k_##name,
|
2011-03-18 20:35:07 +00:00
|
|
|
STATE_TAG_LIST(COUNTER_ID)
|
2008-07-03 15:10:15 +00:00
|
|
|
#undef COUNTER_ID
|
|
|
|
|
stats_counter_count
|
|
|
|
|
};
|
|
|
|
|
|
2011-03-18 20:35:07 +00:00
|
|
|
StatsCounter* state_counters(StateTag state) {
|
|
|
|
|
return &state_counters_[state];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
#define HT(name, caption) \
|
|
|
|
|
HistogramTimer name##_;
|
|
|
|
|
HISTOGRAM_TIMER_LIST(HT)
|
|
|
|
|
#undef HT
|
|
|
|
|
|
|
|
|
|
#define SC(name, caption) \
|
|
|
|
|
StatsCounter name##_;
|
|
|
|
|
STATS_COUNTER_LIST_1(SC)
|
|
|
|
|
STATS_COUNTER_LIST_2(SC)
|
|
|
|
|
#undef SC
|
|
|
|
|
|
|
|
|
|
enum {
|
|
|
|
|
#define COUNTER_ID(name) __##name,
|
|
|
|
|
STATE_TAG_LIST(COUNTER_ID)
|
|
|
|
|
#undef COUNTER_ID
|
|
|
|
|
kSlidingStateWindowCounterCount
|
|
|
|
|
};
|
|
|
|
|
|
2008-07-03 15:10:15 +00:00
|
|
|
// Sliding state window counters.
|
2011-03-18 20:35:07 +00:00
|
|
|
StatsCounter state_counters_[kSlidingStateWindowCounterCount];
|
|
|
|
|
friend class Isolate;
|
|
|
|
|
|
|
|
|
|
DISALLOW_IMPLICIT_CONSTRUCTORS(Counters);
|
2008-07-03 15:10:15 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
} } // namespace v8::internal
|
|
|
|
|
|
2009-05-04 13:36:43 +00:00
|
|
|
#endif // V8_V8_COUNTERS_H_
|
