From 1083d1f817ae5a2c4f61d1ade3349667ae59abb5 Mon Sep 17 00:00:00 2001 From: "yurys@chromium.org" Date: Thu, 29 Aug 2013 10:42:55 +0000 Subject: [PATCH] Remove deprecated profiler API This change removes --prof-lazy command line flag that was introduced for the old CPU profiler implementation in Chrome DevTools. DevTools now use profiler API defined in v8-profiler.h This change also removes methods for pausing resuming --prof profiler. These methods were deprecated in v.3.20 (https://code.google.com/p/v8/source/browse/branches/3.20/include/v8.h#4629) After this change the profiler will always start if --prof option is passed and can be stopped either in the tests or if write to log file fails. BUG=None R=bmeurer@chromium.org, loislo@chromium.org Review URL: https://codereview.chromium.org/23478010 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@16417 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- include/v8.h | 22 ----------- src/api.cc | 18 --------- src/cpu-profiler.cc | 6 +-- src/cpu-profiler.h | 2 +- src/flag-definitions.h | 3 -- src/log-utils.cc | 5 --- src/log.cc | 61 +++++------------------------- src/log.h | 17 +++------ test/cctest/test-log.cc | 98 ++++--------------------------------------------- 9 files changed, 26 insertions(+), 206 deletions(-) diff --git a/include/v8.h b/include/v8.h index 51bd362..9ba928b 100644 --- a/include/v8.h +++ b/include/v8.h @@ -4547,28 +4547,6 @@ class V8_EXPORT V8 { intptr_t change_in_bytes); /** - * Suspends recording of tick samples in the profiler. - * When the V8 profiling mode is enabled (usually via command line - * switches) this function suspends recording of tick samples. - * Profiling ticks are discarded until ResumeProfiler() is called. - * - * See also the --prof and --prof_auto command line switches to - * enable V8 profiling. - */ - V8_DEPRECATED(static void PauseProfiler()); - - /** - * Resumes recording of tick samples in the profiler. - * See also PauseProfiler(). - */ - V8_DEPRECATED(static void ResumeProfiler()); - - /** - * Return whether profiler is currently paused. - */ - V8_DEPRECATED(static bool IsProfilerPaused()); - - /** * Retrieve the V8 thread id of the calling thread. * * The thread id for a thread should only be retrieved after the V8 diff --git a/src/api.cc b/src/api.cc index ebd2b81..43c920d 100644 --- a/src/api.cc +++ b/src/api.cc @@ -6735,24 +6735,6 @@ void V8::RemoveCallCompletedCallback(CallCompletedCallback callback) { } -void V8::PauseProfiler() { - i::Isolate* isolate = i::Isolate::Current(); - isolate->logger()->PauseProfiler(); -} - - -void V8::ResumeProfiler() { - i::Isolate* isolate = i::Isolate::Current(); - isolate->logger()->ResumeProfiler(); -} - - -bool V8::IsProfilerPaused() { - i::Isolate* isolate = i::Isolate::Current(); - return isolate->logger()->IsProfilerPaused(); -} - - int V8::GetCurrentThreadId() { i::Isolate* isolate = i::Isolate::Current(); EnsureInitializedForIsolate(isolate, "V8::GetCurrentThreadId()"); diff --git a/src/cpu-profiler.cc b/src/cpu-profiler.cc index 0802687..74d1f03 100644 --- a/src/cpu-profiler.cc +++ b/src/cpu-profiler.cc @@ -430,8 +430,8 @@ void CpuProfiler::StartProcessorIfNotStarted() { if (processor_ == NULL) { Logger* logger = isolate_->logger(); // Disable logging when using the new implementation. - saved_logging_nesting_ = logger->logging_nesting_; - logger->logging_nesting_ = 0; + saved_is_logging_ = logger->is_logging_; + logger->is_logging_ = false; generator_ = new ProfileGenerator(profiles_); Sampler* sampler = logger->sampler(); processor_ = new ProfilerEventsProcessor( @@ -501,7 +501,7 @@ void CpuProfiler::StopProcessor() { sampler->Stop(); need_to_stop_sampler_ = false; } - logger->logging_nesting_ = saved_logging_nesting_; + logger->is_logging_ = saved_is_logging_; } diff --git a/src/cpu-profiler.h b/src/cpu-profiler.h index 41473d7..e3d38ba 100644 --- a/src/cpu-profiler.h +++ b/src/cpu-profiler.h @@ -265,7 +265,7 @@ class CpuProfiler : public CodeEventListener { unsigned next_profile_uid_; ProfileGenerator* generator_; ProfilerEventsProcessor* processor_; - int saved_logging_nesting_; + bool saved_is_logging_; bool need_to_stop_sampler_; bool is_profiling_; diff --git a/src/flag-definitions.h b/src/flag-definitions.h index 01677ea..f19c4a6 100644 --- a/src/flag-definitions.h +++ b/src/flag-definitions.h @@ -775,9 +775,6 @@ DEFINE_bool(log_snapshot_positions, false, DEFINE_bool(log_suspect, false, "Log suspect operations.") DEFINE_bool(prof, false, "Log statistical profiling information (implies --log-code).") -DEFINE_bool(prof_lazy, false, - "Used with --prof, only does sampling and logging" - " when profiler is active.") DEFINE_bool(prof_browser_mode, true, "Used with --prof, turns on browser-compatible mode for profiling.") DEFINE_bool(log_regexp, false, "Log regular expression execution.") diff --git a/src/log-utils.cc b/src/log-utils.cc index 98f4fdf..909d4a5 100644 --- a/src/log-utils.cc +++ b/src/log-utils.cc @@ -64,11 +64,6 @@ void Log::Initialize(const char* log_file_name) { // --prof implies --log-code. if (FLAG_prof) FLAG_log_code = true; - // --prof_lazy controls --log-code. - if (FLAG_prof_lazy) { - FLAG_log_code = false; - } - // If we're logging anything, we need to open the log file. if (Log::InitLogAtStart()) { if (strcmp(log_file_name, kLogToConsole) == 0) { diff --git a/src/log.cc b/src/log.cc index 59d494a..2852025 100644 --- a/src/log.cc +++ b/src/log.cc @@ -563,7 +563,6 @@ class Profiler: public Thread { virtual void Run(); // Pause and Resume TickSample data collection. - bool paused() const { return paused_; } void pause() { paused_ = true; } void resume() { paused_ = false; } @@ -623,7 +622,7 @@ class Ticker: public Sampler { ASSERT(profiler_ == NULL); profiler_ = profiler; IncreaseProfilingDepth(); - if (!FLAG_prof_lazy && !IsActive()) Start(); + if (!IsActive()) Start(); } void ClearProfiler() { @@ -710,8 +709,7 @@ Logger::Logger(Isolate* isolate) ticker_(NULL), profiler_(NULL), log_events_(NULL), - logging_nesting_(0), - cpu_profiler_nesting_(0), + is_logging_(false), log_(new Log(this)), ll_logger_(NULL), jit_logger_(NULL), @@ -1521,43 +1519,11 @@ void Logger::TickEvent(TickSample* sample, bool overflow) { } -bool Logger::IsProfilerPaused() { - return profiler_ == NULL || profiler_->paused(); -} - - -void Logger::PauseProfiler() { +void Logger::StopProfiler() { if (!log_->IsEnabled()) return; if (profiler_ != NULL) { - // It is OK to have negative nesting. - if (--cpu_profiler_nesting_ == 0) { - profiler_->pause(); - if (FLAG_prof_lazy) { - ticker_->Stop(); - FLAG_log_code = false; - LOG(ISOLATE, UncheckedStringEvent("profiler", "pause")); - } - --logging_nesting_; - } - } -} - - -void Logger::ResumeProfiler() { - if (!log_->IsEnabled()) return; - if (profiler_ != NULL) { - if (cpu_profiler_nesting_++ == 0) { - ++logging_nesting_; - if (FLAG_prof_lazy) { - profiler_->Engage(); - LOG(ISOLATE, UncheckedStringEvent("profiler", "resume")); - FLAG_log_code = true; - LogCompiledFunctions(); - LogAccessorCallbacks(); - if (!ticker_->IsActive()) ticker_->Start(); - } - profiler_->resume(); - } + profiler_->pause(); + is_logging_ = false; } } @@ -1565,7 +1531,7 @@ void Logger::ResumeProfiler() { // This function can be called when Log's mutex is acquired, // either from main or Profiler's thread. void Logger::LogFailure() { - PauseProfiler(); + StopProfiler(); } @@ -1865,11 +1831,6 @@ bool Logger::SetUp(Isolate* isolate) { FLAG_log_snapshot_positions = true; } - // --prof_lazy controls --log-code. - if (FLAG_prof_lazy) { - FLAG_log_code = false; - } - SmartArrayPointer log_file_name = PrepareLogFileName(FLAG_logfile); log_->Initialize(*log_file_name); @@ -1882,17 +1843,13 @@ bool Logger::SetUp(Isolate* isolate) { ticker_ = new Ticker(isolate, kSamplingIntervalMs); if (Log::InitLogAtStart()) { - logging_nesting_ = 1; + is_logging_ = true; } if (FLAG_prof) { profiler_ = new Profiler(isolate); - if (FLAG_prof_lazy) { - profiler_->pause(); - } else { - logging_nesting_ = 1; - profiler_->Engage(); - } + is_logging_ = true; + profiler_->Engage(); } if (FLAG_log_internal_timer_events || FLAG_prof) timer_.Start(); diff --git a/src/log.h b/src/log.h index adf95ff..81d45e5 100644 --- a/src/log.h +++ b/src/log.h @@ -341,19 +341,16 @@ class Logger { void LogRuntime(Vector format, JSArray* args); bool is_logging() { - return logging_nesting_ > 0; + return is_logging_; } bool is_logging_code_events() { return is_logging() || jit_logger_ != NULL; } - // Pause/Resume collection of profiling data. - // When data collection is paused, CPU Tick events are discarded until - // data collection is Resumed. - void PauseProfiler(); - void ResumeProfiler(); - bool IsProfilerPaused(); + // Stop collection of profiling data. + // When data collection is paused, CPU Tick events are discarded. + void StopProfiler(); void LogExistingFunction(Handle shared, Handle code); @@ -435,13 +432,9 @@ class Logger { friend class TimeLog; friend class Profiler; template friend class VMState; - friend class LoggerTestHelper; - - int logging_nesting_; - int cpu_profiler_nesting_; - + bool is_logging_; Log* log_; LowLevelLogger* ll_logger_; JitLogger* jit_logger_; diff --git a/test/cctest/test-log.cc b/test/cctest/test-log.cc index 8bcb5f7..6bf56f0 100644 --- a/test/cctest/test-log.cc +++ b/test/cctest/test-log.cc @@ -27,7 +27,6 @@ // // Tests of logging functions from log.h -#define V8_DISABLE_DEPRECATIONS 1 #ifdef __linux__ #include #include @@ -44,7 +43,6 @@ #include "v8utils.h" #include "cctest.h" #include "vm-state-inl.h" -#undef V8_DISABLE_DEPRECATIONS using v8::internal::Address; using v8::internal::EmbeddedVector; @@ -56,13 +54,12 @@ namespace { class ScopedLoggerInitializer { public: - explicit ScopedLoggerInitializer(bool prof_lazy) + ScopedLoggerInitializer() : saved_log_(i::FLAG_log), - saved_prof_lazy_(i::FLAG_prof_lazy), saved_prof_(i::FLAG_prof), temp_file_(NULL), // Need to run this prior to creating the scope. - trick_to_run_init_flags_(init_flags_(prof_lazy)), + trick_to_run_init_flags_(init_flags_()), scope_(v8::Isolate::GetCurrent()), env_(v8::Context::New(v8::Isolate::GetCurrent())), logger_(i::Isolate::Current()->logger()) { @@ -73,7 +70,6 @@ class ScopedLoggerInitializer { env_->Exit(); logger_->TearDown(); if (temp_file_ != NULL) fclose(temp_file_); - i::FLAG_prof_lazy = saved_prof_lazy_; i::FLAG_prof = saved_prof_; i::FLAG_log = saved_log_; } @@ -91,16 +87,14 @@ class ScopedLoggerInitializer { } private: - static bool init_flags_(bool prof_lazy) { + static bool init_flags_() { i::FLAG_log = true; i::FLAG_prof = true; - i::FLAG_prof_lazy = prof_lazy; i::FLAG_logfile = i::Log::kLogToTemporaryFile; - return prof_lazy; + return false; } const bool saved_log_; - const bool saved_prof_lazy_; const bool saved_prof_; FILE* temp_file_; const bool trick_to_run_init_flags_; @@ -124,70 +118,6 @@ static const char* StrNStr(const char* s1, const char* s2, int n) { } -TEST(ProfLazyMode) { - ScopedLoggerInitializer initialize_logger(true); - Logger* logger = initialize_logger.logger(); - - if (!i::V8::UseCrankshaft()) return; - - logger->StringEvent("test-start", ""); - CompileRun("var a = (function(x) { return x + 1; })(10);"); - logger->StringEvent("test-profiler-start", ""); - v8::V8::ResumeProfiler(); - CompileRun( - "var b = (function(x) { return x + 2; })(10);\n" - "var c = (function(x) { return x + 3; })(10);\n" - "var d = (function(x) { return x + 4; })(10);\n" - "var e = (function(x) { return x + 5; })(10);"); - v8::V8::PauseProfiler(); - logger->StringEvent("test-profiler-stop", ""); - CompileRun("var f = (function(x) { return x + 6; })(10);"); - // Check that profiling can be resumed again. - logger->StringEvent("test-profiler-start-2", ""); - v8::V8::ResumeProfiler(); - CompileRun( - "var g = (function(x) { return x + 7; })(10);\n" - "var h = (function(x) { return x + 8; })(10);\n" - "var i = (function(x) { return x + 9; })(10);\n" - "var j = (function(x) { return x + 10; })(10);"); - v8::V8::PauseProfiler(); - logger->StringEvent("test-profiler-stop-2", ""); - logger->StringEvent("test-stop", ""); - - bool exists = false; - i::Vector log( - i::ReadFile(initialize_logger.StopLoggingGetTempFile(), &exists, true)); - CHECK(exists); - - const char* test_start_position = - StrNStr(log.start(), "test-start,", log.length()); - CHECK_NE(NULL, test_start_position); - const char* test_profiler_start_position = - StrNStr(log.start(), "test-profiler-start,", log.length()); - CHECK_NE(NULL, test_profiler_start_position); - CHECK_GT(test_profiler_start_position, test_start_position); - const char* test_profiler_stop_position = - StrNStr(log.start(), "test-profiler-stop,", log.length()); - CHECK_NE(NULL, test_profiler_stop_position); - CHECK_GT(test_profiler_stop_position, test_profiler_start_position); - const char* test_profiler_start_2_position = - StrNStr(log.start(), "test-profiler-start-2,", log.length()); - CHECK_NE(NULL, test_profiler_start_2_position); - CHECK_GT(test_profiler_start_2_position, test_profiler_stop_position); - - // Nothing must be logged until profiling is resumed. - CHECK_EQ(NULL, StrNStr(test_start_position, - "code-creation,", - static_cast(test_profiler_start_position - - test_start_position))); - // Nothing must be logged while profiling is suspended. - CHECK_EQ(NULL, StrNStr(test_profiler_stop_position, - "code-creation,", - static_cast(test_profiler_start_2_position - - test_profiler_stop_position))); -} - - // BUG(913). Need to implement support for profiling multiple VM threads. #if 0 @@ -396,7 +326,7 @@ static void ObjMethod1(const v8::FunctionCallbackInfo& args) { TEST(LogCallbacks) { - ScopedLoggerInitializer initialize_logger(false); + ScopedLoggerInitializer initialize_logger; Logger* logger = initialize_logger.logger(); v8::Local obj = @@ -445,7 +375,7 @@ static void Prop2Getter(v8::Local property, TEST(LogAccessorCallbacks) { - ScopedLoggerInitializer initialize_logger(false); + ScopedLoggerInitializer initialize_logger; Logger* logger = initialize_logger.logger(); v8::Local obj = @@ -486,18 +416,6 @@ TEST(LogAccessorCallbacks) { } -TEST(IsLoggingPreserved) { - ScopedLoggerInitializer initialize_logger(false); - Logger* logger = initialize_logger.logger(); - - CHECK(logger->is_logging()); - logger->ResumeProfiler(); - CHECK(logger->is_logging()); - logger->PauseProfiler(); - CHECK(logger->is_logging()); -} - - typedef i::NativesCollection TestSources; @@ -514,7 +432,7 @@ TEST(EquivalenceOfLoggingAndTraversal) { CHECK(!i::V8::IsRunning()); // Start with profiling to capture all code events from the beginning. - ScopedLoggerInitializer initialize_logger(false); + ScopedLoggerInitializer initialize_logger; Logger* logger = initialize_logger.logger(); // Compile and run a function that creates other functions. @@ -523,7 +441,7 @@ TEST(EquivalenceOfLoggingAndTraversal) { " obj.test =\n" " (function a(j) { return function b() { return j; } })(100);\n" "})(this);"); - v8::V8::PauseProfiler(); + logger->StopProfiler(); HEAP->CollectAllGarbage(i::Heap::kMakeHeapIterableMask); logger->StringEvent("test-logging-done", ""); -- 2.7.4