// Copyright 2010 the V8 project authors. All rights reserved. // 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. // // Tests of the CPU profiler and utilities. #include <limits> #include <memory> #include "include/libplatform/v8-tracing.h" #include "include/v8-fast-api-calls.h" #include "include/v8-function.h" #include "include/v8-json.h" #include "include/v8-locker.h" #include "include/v8-profiler.h" #include "src/api/api-inl.h" #include "src/base/platform/platform.h" #include "src/base/strings.h" #include "src/codegen/compilation-cache.h" #include "src/codegen/source-position-table.h" #include "src/deoptimizer/deoptimize-reason.h" #include "src/execution/embedder-state.h" #include "src/execution/protectors-inl.h" #include "src/flags/flags.h" #include "src/heap/spaces.h" #include "src/init/v8.h" #include "src/libsampler/sampler.h" #include "src/logging/log.h" #include "src/objects/objects-inl.h" #include "src/profiler/cpu-profiler.h" #include "src/profiler/profiler-listener.h" #include "src/profiler/symbolizer.h" #include "src/utils/utils.h" #include "test/cctest/cctest.h" #include "test/cctest/heap/heap-utils.h" #include "test/cctest/jsonstream-helper.h" #include "test/cctest/profiler-extension.h" #include "test/common/flag-utils.h" #ifdef V8_USE_PERFETTO #include "protos/perfetto/trace/trace.pb.h" #include "src/libplatform/tracing/trace-event-listener.h" #endif namespace v8 { namespace internal { namespace test_cpu_profiler { // Helper methods static v8::Local<v8::Function> GetFunction(v8::Local<v8::Context> env, const char* name) { … } static size_t offset(const char* src, const char* substring) { … } template <typename A, typename B> static int dist(A a, B b) { … } static const char* reason(const i::DeoptimizeReason reason) { … } TEST(StartStop) { … } static void EnqueueTickSampleEvent(ProfilerEventsProcessor* proc, i::Address frame1, i::Address frame2 = kNullAddress, i::Address frame3 = kNullAddress) { … } namespace { class TestSetup { … }; } // namespace i::Tagged<i::AbstractCode> CreateCode(i::Isolate* isolate, LocalContext* env) { … } TEST(CodeEvents) { … } template <typename T> static int CompareProfileNodes(const T* p1, const T* p2) { … } TEST(TickEvents) { … } TEST(CodeMapClearedBetweenProfilesWithLazyLogging) { … } TEST(CodeMapNotClearedBetweenProfilesWithEagerLogging) { … } // http://crbug/51594 // This test must not crash. TEST(CrashIfStoppingLastNonExistentProfile) { … } // http://code.google.com/p/v8/issues/detail?id=1398 // Long stacks (exceeding max frames limit) must not be erased. TEST(Issue1398) { … } TEST(DeleteAllCpuProfiles) { … } static bool FindCpuProfile(v8::CpuProfiler* v8profiler, const v8::CpuProfile* v8profile) { … } TEST(DeleteCpuProfile) { … } TEST(ProfileStartEndTime) { … } class ProfilerHelper { … }; v8::CpuProfile* ProfilerHelper::Run(v8::Local<v8::Function> function, v8::Local<v8::Value> argv[], int argc, unsigned min_js_samples, unsigned min_external_samples, ProfilingMode mode, unsigned max_samples, v8::Local<v8::Context> context) { … } static unsigned TotalHitCount(const v8::CpuProfileNode* node) { … } static unsigned TotalHitCount(const v8::CpuProfileNode* node, const std::string& name) { … } static const v8::CpuProfileNode* FindChild(v8::Local<v8::Context> context, const v8::CpuProfileNode* node, const char* name) { … } static const v8::CpuProfileNode* FindChild(const v8::CpuProfileNode* node, const char* name) { … } static const v8::CpuProfileNode* GetChild(v8::Local<v8::Context> context, const v8::CpuProfileNode* node, const char* name) { … } static void CheckSimpleBranch(v8::Local<v8::Context> context, const v8::CpuProfileNode* node, const char* names[], int length) { … } static const ProfileNode* GetSimpleBranch(v8::Local<v8::Context> context, v8::CpuProfile* profile, const char* names[], int length) { … } struct NameLinePair { … }; static const v8::CpuProfileNode* FindChild(const v8::CpuProfileNode* node, NameLinePair pair) { … } static const v8::CpuProfileNode* GetChild(const v8::CpuProfileNode* node, NameLinePair pair) { … } static void CheckBranch(const v8::CpuProfileNode* node, NameLinePair path[], int length) { … } static const char* cpu_profiler_test_source = …; // Check that the profile tree for the script above will look like the // following: // // [Top down]: // 1062 0 (root) [-1] // 1054 0 start [-1] // 1054 1 foo [-1] // 265 0 baz [-1] // 265 1 delay [-1] // 264 264 loop [-1] // 525 3 delay [-1] // 522 522 loop [-1] // 263 0 bar [-1] // 263 1 delay [-1] // 262 262 loop [-1] // 2 2 (program) [-1] // 6 6 (garbage collector) [-1] TEST(CollectCpuProfile) { … } TEST(CollectCpuProfileCallerLineNumbers) { … } static const char* hot_deopt_no_frame_entry_test_source = …; // Check that the profile tree for the script above will look like the // following: // // [Top down]: // 1062 0 (root) [-1] // 1054 0 start [-1] // 1054 1 foo [-1] // 2 2 (program) [-1] // 6 6 (garbage collector) [-1] // // The test checks no FP ranges are present in a deoptimized function. // If 'foo' has no ranges the samples falling into the prologue will miss the // 'start' function on the stack, so 'foo' will be attached to the (root). TEST(HotDeoptNoFrameEntry) { … } TEST(CollectCpuProfileSamples) { … } static const char* cpu_profiler_test_source2 = …; // Check that the profile tree doesn't contain unexpected traces: // - 'loop' can be called only by 'delay' // - 'delay' may be called only by 'start' // The profile will look like the following: // // [Top down]: // 135 0 (root) [-1] #1 // 121 72 start [-1] #3 // 49 33 delay [-1] #4 // 16 16 loop [-1] #5 // 14 14 (program) [-1] #2 TEST(SampleWhenFrameIsNotSetup) { … } static const char* native_accessor_test_source = …; class TestApiCallbacks { … }; // Test that native accessors are properly reported in the CPU profile. // This test checks the case when the long-running accessors are called // only once and the optimizer doesn't have chance to change the invocation // code. TEST(NativeAccessorUninitializedIC) { … } // Test that native accessors are properly reported in the CPU profile. // This test makes sure that the accessors are called enough times to become // hot and to trigger optimizations. TEST(NativeAccessorMonomorphicIC) { … } static const char* native_method_test_source = …; TEST(NativeMethodUninitializedIC) { … } TEST(NativeMethodMonomorphicIC) { … } static const char* bound_function_test_source = …; TEST(BoundFunctionCall) { … } // This tests checks distribution of the samples through the source lines. static void TickLines(bool optimize) { … } TEST(TickLinesBaseline) { … } TEST(TickLinesOptimized) { … } static const char* call_function_test_source = …; // Test that if we sampled thread when it was inside FunctionCall builtin then // its caller frame will be '(unresolved function)' as we have no reliable way // to resolve it. // // [Top down]: // 96 0 (root) [-1] #1 // 1 1 (garbage collector) [-1] #4 // 5 0 (unresolved function) [-1] #5 // 5 5 call [-1] #6 // 71 70 start [-1] #3 // 1 1 bar [-1] #7 // 19 19 (program) [-1] #2 TEST(FunctionCallSample) { … } static const char* function_apply_test_source = …; // [Top down]: // 94 0 (root) [-1] #0 1 // 2 2 (garbage collector) [-1] #0 7 // 82 49 start [-1] #16 3 // 1 0 (unresolved function) [-1] #0 8 // 1 1 apply [-1] #0 9 // 32 21 test [-1] #16 4 // 2 2 bar [-1] #16 6 // 10 10 (program) [-1] #0 2 TEST(FunctionApplySample) { … } static const char* cpu_profiler_deep_stack_test_source = …; // Check a deep stack // // [Top down]: // 0 (root) 0 #1 // 2 (program) 0 #2 // 0 start 21 #3 no reason // 0 foo 21 #4 no reason // 0 foo 21 #5 no reason // .... // 0 foo 21 #254 no reason TEST(CpuProfileDeepStack) { … } static const char* js_native_js_test_source = …; static void CallJsFunction(const v8::FunctionCallbackInfo<v8::Value>& info) { … } // [Top down]: // 58 0 (root) #0 1 // 2 2 (program) #0 2 // 56 1 start #16 3 // 55 0 CallJsFunction #0 4 // 55 1 bar #16 5 // 54 54 foo #16 6 TEST(JsNativeJsSample) { … } static const char* js_native_js_runtime_js_test_source = …; // [Top down]: // 57 0 (root) #0 1 // 55 1 start #16 3 // 54 0 CallJsFunction #0 4 // 54 3 bar #16 5 // 51 51 foo #16 6 // 2 2 (program) #0 2 TEST(JsNativeJsRuntimeJsSample) { … } static void CallJsFunction2(const v8::FunctionCallbackInfo<v8::Value>& info) { … } static const char* js_native1_js_native2_js_test_source = …; // [Top down]: // 57 0 (root) #0 1 // 55 1 start #16 3 // 54 0 CallJsFunction1 #0 4 // 54 0 bar #16 5 // 54 0 CallJsFunction2 #0 6 // 54 54 foo #16 7 // 2 2 (program) #0 2 TEST(JsNative1JsNative2JsSample) { … } static const char* js_force_collect_sample_source = …; static void CallCollectSample(const v8::FunctionCallbackInfo<v8::Value>& info) { … } void InstallCollectSampleFunction(v8::Local<v8::Context> env) { … } TEST(CollectSampleAPI) { … } static const char* js_native_js_runtime_multiple_test_source = …; // The test check multiple entrances/exits between JS and native code. // // [Top down]: // (root) #0 1 // start #16 3 // CallJsFunction #0 4 // bar #16 5 // foo #16 6 // (program) #0 2 TEST(JsNativeJsRuntimeJsSampleMultiple) { … } static const char* inlining_test_source = …; // The test check multiple entrances/exits between JS and native code. // // [Top down]: // (root) #0 1 // start #16 3 // level1 #0 4 // level2 #16 5 // level3 #16 6 // action #16 7 // (program) #0 2 TEST(Inlining) { … } static const char* inlining_test_source2 = …; // [Top down]: // 0 (root):0 0 #1 // 13 start:34 6 #3 // bailed out due to 'Optimization is always disabled' // 19 level1:36 6 #4 // 16 action:29 6 #14 // bailed out due to 'Optimization is always disabled' // 2748 action:30 6 #10 // bailed out due to 'Optimization is always disabled' // 18 action:31 6 #15 // bailed out due to 'Optimization is always disabled' // 0 level2:32 6 #5 // 0 level3:26 6 #6 // 12 level4:22 6 #11 // 1315 action:17 6 #13 // bailed out due to 'Optimization is always disabled' // 1324 action:18 6 #12 // bailed out due to 'Optimization is always disabled' // 16 level4:21 6 #7 // 1268 action:17 6 #9 // bailed out due to 'Optimization is always disabled' // 1322 action:18 6 #8 // bailed out due to 'Optimization is always disabled' // 2 (program):0 0 #2 TEST(Inlining2) { … } static const char* cross_script_source_a = …; static const char* cross_script_source_b = …; TEST(CrossScriptInliningCallerLineNumbers) { … } static const char* cross_script_source_c = …; static const char* cross_script_source_d = …; static const char* cross_script_source_e = …; static const char* cross_script_source_f = …; TEST(CrossScriptInliningCallerLineNumbers2) { … } // [Top down]: // 0 (root) #0 1 // 2 (program) #0 2 // 3 (idle) #0 3 TEST(IdleTime) { … } static void CheckFunctionDetails(v8::Isolate* isolate, const v8::CpuProfileNode* node, const char* name, const char* script_name, bool is_shared_cross_origin, int script_id, int line, int column, const v8::CpuProfileNode* parent) { … } TEST(FunctionDetails) { … } TEST(FunctionDetailsInlining) { … } static const char* pre_profiling_osr_script = …; // Testing profiling of OSR code that was OSR optimized before profiling // started. Currently the behavior is not quite right so we're currently // testing a deopt event being sent to the sampling thread for a function // it knows nothing about. This deopt does mean we start getting samples // for hot so we expect some samples, just fewer than for notHot. // // We should get something like: // 0 (root):0 3 0 #1 // 12 (garbage collector):0 3 0 #5 // 5 notHot:22 0 4 #2 // 85 hot:5 0 4 #6 // 0 whenPass:2 0 4 #3 // 0 startProfiling:0 2 0 #4 // // But currently get something like: // 0 (root):0 3 0 #1 // 12 (garbage collector):0 3 0 #5 // 57 notHot:22 0 4 #2 // 33 hot:5 0 4 #6 // 0 whenPass:2 0 4 #3 // 0 startProfiling:0 2 0 #4 TEST(StartProfilingAfterOsr) { … } TEST(DontStopOnFinishedProfileDelete) { … } const char* GetBranchDeoptReason(v8::Local<v8::Context> context, i::CpuProfile* iprofile, const char* branch[], int length) { … } // deopt at top function TEST(CollectDeoptEvents) { … } TEST(SourceLocation) { … } static const char* inlined_source = …; // 0.........1.........2.........3.........4....*....5.........6......*..7 // deopt at the first level inlined function TEST(DeoptAtFirstLevelInlinedSource) { … } // deopt at the second level inlined function TEST(DeoptAtSecondLevelInlinedSource) { … } // deopt in untracked function TEST(DeoptUntrackedFunction) { … } TraceBuffer; TraceConfig; TraceObject; namespace { #ifdef V8_USE_PERFETTO class CpuProfilerListener : public platform::tracing::TraceEventListener { … }; #else class CpuProfileEventChecker : public v8::platform::tracing::TraceWriter { public: void AppendTraceEvent(TraceObject* trace_event) override { if (trace_event->name() != std::string("Profile") && trace_event->name() != std::string("ProfileChunk")) return; CHECK(!profile_id_ || trace_event->id() == profile_id_); CHECK_EQ(1, trace_event->num_args()); CHECK_EQ(TRACE_VALUE_TYPE_CONVERTABLE, trace_event->arg_types()[0]); profile_id_ = trace_event->id(); v8::ConvertableToTraceFormat* arg = trace_event->arg_convertables()[0].get(); result_json_ += result_json_.empty() ? "[" : ",\n"; arg->AppendAsTraceFormat(&result_json_); } void Flush() override { result_json_ += "]"; } const std::string& result_json() const { return result_json_; } void Reset() { result_json_.clear(); profile_id_ = 0; } private: std::string result_json_; uint64_t profile_id_ = 0; }; #endif // !V8_USE_PERFETTO } // namespace TEST(TracingCpuProfiler) { … } TEST(Issue763073) { … } static const char* js_collect_sample_api_source = …; static void CallStaticCollectSample( const v8::FunctionCallbackInfo<v8::Value>& info) { … } TEST(StaticCollectSampleAPI) { … } TEST(CodeEntriesMemoryLeak) { … } TEST(NativeFrameStackTrace) { … } TEST(SourcePositionTable) { … } TEST(MultipleProfilers) { … } // Tests that logged CodeCreateEvent calls do not crash a reused CpuProfiler. // crbug.com/929928 TEST(CrashReusedProfiler) { … } // Tests that samples from different profilers on the same isolate do not leak // samples to each other. See crbug.com/v8/8835. TEST(MultipleProfilersSampleIndependently) { … } void ProfileSomeCode(v8::Isolate* isolate) { … } class IsolateThread : public v8::base::Thread { … }; // Checking for crashes and TSAN issues with multiple isolates profiling. TEST(MultipleIsolates) { … } // Varying called function frame sizes increases the chance of something going // wrong if sampling an unlocked frame. We also prevent optimization to prevent // inlining so each function call has its own frame. const char* varying_frame_size_script = …; class UnlockingThread : public v8::base::Thread { … }; // Checking for crashes with multiple thread/single Isolate profiling. TEST(MultipleThreadsSingleIsolate) { … } // Tests that StopProfiling doesn't wait for the next sample tick in order to // stop, but rather exits early before a given wait threshold. TEST(FastStopProfiling) { … } // Tests that when current_profiles->size() is greater than the max allowable // number of concurrent profiles (100), we don't allow a new Profile to be // profiled TEST(MaxSimultaneousProfiles) { … } TEST(LowPrecisionSamplingStartStopInternal) { … } TEST(LowPrecisionSamplingStartStopPublic) { … } const char* naming_test_source = …; TEST(StandardNaming) { … } TEST(DebugNaming) { … } TEST(SampleLimit) { … } // Tests that a CpuProfile instance subsamples from a stream of tick samples // appropriately. TEST(ProflilerSubsampling) { … } // Tests that the base sampling rate of a CpuProfilesCollection is dynamically // chosen based on the GCD of its child profiles. TEST(DynamicResampling) { … } // Ensures that when a non-unit base sampling interval is set on the profiler, // that the sampling rate gets snapped to the nearest multiple prior to GCD // computation. TEST(DynamicResamplingWithBaseInterval) { … } // Tests that functions compiled after a started profiler is stopped are still // visible when the profiler is started again. (https://crbug.com/v8/9151) TEST(Bug9151StaleCodeEntries) { … } // Tests that functions from other contexts aren't recorded when filtering for // another context. TEST(ContextIsolation) { … } void ValidateEmbedderState(v8::CpuProfile* profile, EmbedderStateTag expected_tag) { … } // Tests that embedder states from other contexts aren't recorded TEST(EmbedderContextIsolation) { … } // Tests that embedder states from same context are recorded TEST(EmbedderStatePropagate) { … } // Tests that embedder states from same context are recorded // even after native context move TEST(EmbedderStatePropagateNativeContextMove) { … } // Tests that when a native context that's being filtered is moved, we continue // to track its execution. TEST(ContextFilterMovedNativeContext) { … } enum class EntryCountMode { … }; // Count the number of unique source positions. int GetSourcePositionEntryCount(i::Isolate* isolate, const char* source, EntryCountMode mode = EntryCountMode::kAll) { … } UNINITIALIZED_TEST(DetailedSourcePositionAPI) { … } UNINITIALIZED_TEST(DetailedSourcePositionAPI_Inlining) { … } namespace { struct FastApiReceiver { … }; } // namespace v8::Local<v8::Function> CreateApiCode(LocalContext* env) { … } TEST(CanStartStopProfilerWithTitlesAndIds) { … } TEST(NoProfilingProtectorCPUProfiler) { … } TEST(FastApiCPUProfiler) { … } TEST(BytecodeFlushEventsEagerLogging) { … } // Ensure that unused code entries are removed after GC with eager logging. TEST(ClearUnusedWithEagerLogging) { … } // Ensure that ProfilerCodeObserver doesn't compute estimated size when race // condition potential TEST(SkipEstimatedSizeWhenActiveProfiling) { … } TEST(CpuProfileJSONSerialization) { … } } // namespace test_cpu_profiler } // namespace internal } // namespace v8
Codebase Browser
chromium