From 9a8344b1e779641973c49790d974c162446d8f5c Mon Sep 17 00:00:00 2001 From: "dcarney@chromium.org" Date: Wed, 11 Sep 2013 08:39:38 +0000 Subject: [PATCH] some random isolate threading R=svenpanne@chromium.org BUG= Review URL: https://codereview.chromium.org/23494046 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@16636 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- src/bootstrapper.cc | 4 ++-- src/bootstrapper.h | 5 ++--- src/checks.cc | 28 +++++++--------------------- src/isolate.h | 15 ++++++++++----- src/jsregexp.cc | 10 +++++----- src/jsregexp.h | 4 ++-- src/mark-compact.cc | 2 -- src/objects.cc | 2 +- 8 files changed, 29 insertions(+), 41 deletions(-) diff --git a/src/bootstrapper.cc b/src/bootstrapper.cc index 764c846..58b115d 100644 --- a/src/bootstrapper.cc +++ b/src/bootstrapper.cc @@ -98,7 +98,7 @@ Handle Bootstrapper::NativesSourceLookup(int index) { void Bootstrapper::Initialize(bool create_heap_objects) { - extensions_cache_.Initialize(create_heap_objects); + extensions_cache_.Initialize(isolate_, create_heap_objects); } @@ -147,7 +147,7 @@ void Bootstrapper::TearDown() { delete_these_arrays_on_tear_down_ = NULL; } - extensions_cache_.Initialize(false); // Yes, symmetrical + extensions_cache_.Initialize(isolate_, false); // Yes, symmetrical } diff --git a/src/bootstrapper.h b/src/bootstrapper.h index e6456bd..bac9f40 100644 --- a/src/bootstrapper.h +++ b/src/bootstrapper.h @@ -44,9 +44,8 @@ class SourceCodeCache BASE_EMBEDDED { public: explicit SourceCodeCache(Script::Type type): type_(type), cache_(NULL) { } - void Initialize(bool create_heap_objects) { - cache_ = create_heap_objects ? - Isolate::Current()->heap()->empty_fixed_array() : NULL; + void Initialize(Isolate* isolate, bool create_heap_objects) { + cache_ = create_heap_objects ? isolate->heap()->empty_fixed_array() : NULL; } void Iterate(ObjectVisitor* v) { diff --git a/src/checks.cc b/src/checks.cc index 8208682..7108d18 100644 --- a/src/checks.cc +++ b/src/checks.cc @@ -31,33 +31,19 @@ #include "platform.h" -// TODO(isolates): is it necessary to lift this? -static int fatal_error_handler_nesting_depth = 0; - // Contains protection against recursive calls (faults while handling faults). extern "C" void V8_Fatal(const char* file, int line, const char* format, ...) { i::AllowHandleDereference allow_deref; i::AllowDeferredHandleDereference allow_deferred_deref; fflush(stdout); fflush(stderr); - fatal_error_handler_nesting_depth++; - // First time we try to print an error message - if (fatal_error_handler_nesting_depth < 2) { - i::OS::PrintError("\n\n#\n# Fatal error in %s, line %d\n# ", file, line); - va_list arguments; - va_start(arguments, format); - i::OS::VPrintError(format, arguments); - va_end(arguments); - i::OS::PrintError("\n#\n"); - i::OS::DumpBacktrace(); - } - // First two times we may try to print a stack dump. - if (fatal_error_handler_nesting_depth < 3) { - if (i::FLAG_stack_trace_on_abort) { - // Call this one twice on double fault - i::Isolate::Current()->PrintStack(stderr); - } - } + i::OS::PrintError("\n\n#\n# Fatal error in %s, line %d\n# ", file, line); + va_list arguments; + va_start(arguments, format); + i::OS::VPrintError(format, arguments); + va_end(arguments); + i::OS::PrintError("\n#\n"); + i::OS::DumpBacktrace(); i::OS::Abort(); } diff --git a/src/isolate.h b/src/isolate.h index 99283c9..b826ec5 100644 --- a/src/isolate.h +++ b/src/isolate.h @@ -1426,12 +1426,15 @@ class SaveContext BASE_EMBEDDED { class AssertNoContextChange BASE_EMBEDDED { #ifdef DEBUG public: - AssertNoContextChange() : context_(Isolate::Current()->context()) { } + AssertNoContextChange() + : isolate_(Isolate::Current()), + context_(isolate_->context()) { } ~AssertNoContextChange() { - ASSERT(Isolate::Current()->context() == *context_); + ASSERT(isolate_->context() == *context_); } private: + Isolate* isolate_; Handle context_; #else public: @@ -1445,15 +1448,17 @@ class AssertNoContextChangeWithHandleScope BASE_EMBEDDED { #ifdef DEBUG public: AssertNoContextChangeWithHandleScope() : - scope_(Isolate::Current()), - context_(Isolate::Current()->context(), Isolate::Current()) { + isolate_(Isolate::Current()), + scope_(isolate_), + context_(isolate_->context(), isolate_) { } ~AssertNoContextChangeWithHandleScope() { - ASSERT(Isolate::Current()->context() == *context_); + ASSERT(isolate_->context() == *context_); } private: + Isolate* isolate_; HandleScope scope_; Handle context_; #else diff --git a/src/jsregexp.cc b/src/jsregexp.cc index f1cb96d..3a3d915 100644 --- a/src/jsregexp.cc +++ b/src/jsregexp.cc @@ -1085,8 +1085,8 @@ class RecursionCheck { }; -static RegExpEngine::CompilationResult IrregexpRegExpTooBig() { - return RegExpEngine::CompilationResult("RegExp too big"); +static RegExpEngine::CompilationResult IrregexpRegExpTooBig(Isolate* isolate) { + return RegExpEngine::CompilationResult(isolate, "RegExp too big"); } @@ -1143,7 +1143,7 @@ RegExpEngine::CompilationResult RegExpCompiler::Assemble( while (!work_list.is_empty()) { work_list.RemoveLast()->Emit(this, &new_trace); } - if (reg_exp_too_big_) return IrregexpRegExpTooBig(); + if (reg_exp_too_big_) return IrregexpRegExpTooBig(zone_->isolate()); Handle code = macro_assembler_->GetCode(pattern); heap->IncreaseTotalRegexpCodeGenerated(code->Size()); @@ -5999,7 +5999,7 @@ RegExpEngine::CompilationResult RegExpEngine::Compile( bool is_ascii, Zone* zone) { if ((data->capture_count + 1) * 2 - 1 > RegExpMacroAssembler::kMaxRegister) { - return IrregexpRegExpTooBig(); + return IrregexpRegExpTooBig(zone->isolate()); } RegExpCompiler compiler(data->capture_count, ignore_case, is_ascii, zone); @@ -6063,7 +6063,7 @@ RegExpEngine::CompilationResult RegExpEngine::Compile( analysis.EnsureAnalyzed(node); if (analysis.has_failed()) { const char* error_message = analysis.error_message(); - return CompilationResult(error_message); + return CompilationResult(zone->isolate(), error_message); } // Create the correct assembler for the architecture. diff --git a/src/jsregexp.h b/src/jsregexp.h index 01ceaf4..dfd415d 100644 --- a/src/jsregexp.h +++ b/src/jsregexp.h @@ -1615,9 +1615,9 @@ struct RegExpCompileData { class RegExpEngine: public AllStatic { public: struct CompilationResult { - explicit CompilationResult(const char* error_message) + CompilationResult(Isolate* isolate, const char* error_message) : error_message(error_message), - code(Isolate::Current()->heap()->the_hole_value()), + code(isolate->heap()->the_hole_value()), num_registers(0) {} CompilationResult(Object* code, int registers) : error_message(NULL), diff --git a/src/mark-compact.cc b/src/mark-compact.cc index 17ac4a8..901674d 100644 --- a/src/mark-compact.cc +++ b/src/mark-compact.cc @@ -1788,8 +1788,6 @@ void MarkCompactCollector::PrepareThreadForCodeFlushing(Isolate* isolate, void MarkCompactCollector::PrepareForCodeFlushing() { - ASSERT(heap() == Isolate::Current()->heap()); - // Enable code flushing for non-incremental cycles. if (FLAG_flush_code && !FLAG_flush_code_incrementally) { EnableCodeFlushing(!was_marked_incrementally_); diff --git a/src/objects.cc b/src/objects.cc index 027506f..f329c27 100644 --- a/src/objects.cc +++ b/src/objects.cc @@ -9892,7 +9892,7 @@ void SharedFunctionInfo::DisableOptimization(BailoutReason reason) { if (code()->kind() == Code::FUNCTION) { code()->set_optimizable(false); } - PROFILE(Isolate::Current(), + PROFILE(GetIsolate(), LogExistingFunction(Handle(this), Handle(code()))); if (FLAG_trace_opt) { -- 2.7.4