Start();
// Register to get ticks.
- LOGGER->ticker_->SetProfiler(this);
+ Logger* logger = isolate_->logger();
+ logger->ticker_->SetProfiler(this);
- LOGGER->ProfilerBeginEvent();
+ logger->ProfilerBeginEvent();
}
if (!engaged_) return;
// Stop receiving ticks.
- LOGGER->ticker_->ClearProfiler();
+ isolate_->logger()->ticker_->ClearProfiler();
// Terminate the worker thread by setting running_ to false,
// inserting a fake element in the queue and then wait for
}
-void Logger::LogRuntime(Isolate* isolate,
- Vector<const char> format,
+void Logger::LogRuntime(Vector<const char> format,
JSArray* args) {
if (!log_->IsEnabled() || !FLAG_log_runtime) return;
- HandleScope scope(isolate);
+ HandleScope scope(isolate_);
LogMessageBuilder msg(this);
for (int i = 0; i < format.length(); i++) {
char c = format[i];
void Logger::NewEventStatic(const char* name, void* object, size_t size) {
- LOGGER->NewEvent(name, object, size);
+ Isolate::Current()->logger()->NewEvent(name, object, size);
}
void Logger::DeleteEventStatic(const char* name, void* object) {
- LOGGER->DeleteEvent(name, object);
+ Isolate::Current()->logger()->DeleteEvent(name, object);
}
void Logger::CallbackEventInternal(const char* prefix, Name* name,
// Need to run this prior to creating the scope.
trick_to_run_init_flags_(init_flags_(prof_lazy)),
scope_(v8::Isolate::GetCurrent()),
- env_(v8::Context::New()) {
+ env_(v8::Context::New()),
+ logger_(i::Isolate::Current()->logger()) {
env_->Enter();
}
~ScopedLoggerInitializer() {
env_->Exit();
- LOGGER->TearDown();
+ logger_->TearDown();
if (temp_file_ != NULL) fclose(temp_file_);
i::FLAG_prof_lazy = saved_prof_lazy_;
i::FLAG_prof = saved_prof_;
v8::Handle<v8::Context>& env() { return env_; }
+ Logger* logger() { return logger_; }
+
FILE* StopLoggingGetTempFile() {
- temp_file_ = LOGGER->TearDown();
+ temp_file_ = logger_->TearDown();
CHECK_NE(NULL, temp_file_);
fflush(temp_file_);
rewind(temp_file_);
const bool trick_to_run_init_flags_;
v8::HandleScope scope_;
v8::Handle<v8::Context> env_;
+ Logger* logger_;
DISALLOW_COPY_AND_ASSIGN(ScopedLoggerInitializer);
};
TEST(ProfLazyMode) {
ScopedLoggerInitializer initialize_logger(true);
+ Logger* logger = initialize_logger.logger();
if (!i::V8::UseCrankshaft()) return;
- LOGGER->StringEvent("test-start", "");
+ logger->StringEvent("test-start", "");
CompileRun("var a = (function(x) { return x + 1; })(10);");
- LOGGER->StringEvent("test-profiler-start", "");
+ logger->StringEvent("test-profiler-start", "");
v8::V8::ResumeProfiler();
CompileRun(
"var b = (function(x) { return x + 2; })(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", "");
+ 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", "");
+ logger->StringEvent("test-profiler-start-2", "");
v8::V8::ResumeProfiler();
CompileRun(
"var g = (function(x) { return x + 7; })(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", "");
+ logger->StringEvent("test-profiler-stop-2", "");
+ logger->StringEvent("test-stop", "");
bool exists = false;
i::Vector<const char> log(
i_source->set_resource(NULL);
// Must not crash.
- LOGGER->LogCompiledFunctions();
+ i::Isolate::Current()->logger()->LogCompiledFunctions();
}
TEST(LogCallbacks) {
ScopedLoggerInitializer initialize_logger(false);
+ Logger* logger = initialize_logger.logger();
v8::Persistent<v8::FunctionTemplate> obj =
v8::Persistent<v8::FunctionTemplate>::New(v8::Isolate::GetCurrent(),
initialize_logger.env()->Global()->Set(v8_str("Obj"), obj->GetFunction());
CompileRun("Obj.prototype.method1.toString();");
- LOGGER->LogCompiledFunctions();
+ logger->LogCompiledFunctions();
bool exists = false;
i::Vector<const char> log(
TEST(LogAccessorCallbacks) {
ScopedLoggerInitializer initialize_logger(false);
+ Logger* logger = initialize_logger.logger();
v8::Persistent<v8::FunctionTemplate> obj =
v8::Persistent<v8::FunctionTemplate>::New(v8::Isolate::GetCurrent(),
inst->SetAccessor(v8_str("prop1"), Prop1Getter, Prop1Setter);
inst->SetAccessor(v8_str("prop2"), Prop2Getter);
- LOGGER->LogAccessorCallbacks();
+ logger->LogAccessorCallbacks();
bool exists = false;
i::Vector<const char> log(
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());
+ CHECK(logger->is_logging());
+ logger->ResumeProfiler();
+ CHECK(logger->is_logging());
+ logger->PauseProfiler();
+ CHECK(logger->is_logging());
}
// Start with profiling to capture all code events from the beginning.
ScopedLoggerInitializer initialize_logger(false);
+ Logger* logger = initialize_logger.logger();
// Compile and run a function that creates other functions.
CompileRun(
"})(this);");
v8::V8::PauseProfiler();
HEAP->CollectAllGarbage(i::Heap::kMakeHeapIterableMask);
- LOGGER->StringEvent("test-logging-done", "");
+ logger->StringEvent("test-logging-done", "");
// Iterate heap to find compiled functions, will write to log.
- LOGGER->LogCompiledFunctions();
- LOGGER->StringEvent("test-traversal-done", "");
+ logger->LogCompiledFunctions();
+ logger->StringEvent("test-traversal-done", "");
bool exists = false;
i::Vector<const char> log(