Experimental scanner multithreading fix.

src/isolate.cc

 // Copyright 2012 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
@@ skipping 22 matching lines @@
 #include "ast.h"
 #include "bootstrapper.h"
 #include "codegen.h"
 #include "compilation-cache.h"
 #include "cpu-profiler.h"
 #include "debug.h"
 #include "deoptimizer.h"
 #include "heap-profiler.h"
 #include "hydrogen.h"
 #include "isolate-inl.h"
+#include "lexer/experimental-scanner.h"
 #include "lithium-allocator.h"
 #include "log.h"
 #include "messages.h"
 #include "platform.h"
 #include "regexp-stack.h"
 #include "runtime-profiler.h"
 #include "sampler.h"
 #include "scopeinfo.h"
 #include "serialize.h"
 #include "simulator.h"
@@ skipping 1238 matching lines @@
   for (Object* prototype = *obj; !prototype->IsNull();
        prototype = prototype->GetPrototype(this)) {
     if (!prototype->IsJSObject()) return false;
     if (JSObject::cast(prototype)->map()->constructor() == error_constructor) {
       return true;
     }
   }
   return false;
 }
 
+
+void Isolate::UpdateScannersAfterGC(v8::Isolate* isolate,
+                                    GCType,
+                                    GCCallbackFlags) {
+  reinterpret_cast<i::Isolate*>(isolate)->UpdateScannersAfterGC();
+}
+
+
+void Isolate::UpdateScannersAfterGC() {
+  for (std::set<ScannerBase*>::const_iterator it = scanners_.begin();
+       it != scanners_.end();
+       ++it)
+    (*it)->UpdateBufferBasedOnHandle();
+}
+
+
 static int fatal_exception_depth = 0;
 
 void Isolate::DoThrow(Object* exception, MessageLocation* location) {
   ASSERT(!has_pending_exception());
 
   HandleScope scope(this);
   Handle<Object> exception_handle(exception, this);
 
   // Determine reporting and whether the exception is caught externally.
   bool catchable_by_javascript = is_catchable_by_javascript(exception);
@@ skipping 1203 matching lines @@
     Isolate::code_stub_interface_descriptor(int index) {
   return code_stub_interface_descriptors_ + index;
 }
 
 
 Object* Isolate::FindCodeObject(Address a) {
   return inner_pointer_to_code_cache()->GcSafeFindCodeForInnerPointer(a);
 }
 
 
+void Isolate::AddScanner(ScannerBase* scanner) {
+  if (scanners_.empty()) {
+    heap()->AddGCEpilogueCallback(

[ulan, 2013/12/02 15:05:42]

Not sure. It is probably better do AddGCEpilogueCallback at initialization once.
Because adding/removing callbacks is linear in number of existing callbacks. In
the worst case we will do this on each compilation.

+        &Isolate::UpdateScannersAfterGC, kGCTypeAll, false);
+  }
+  scanners_.insert(scanner);
+}
+
+
+void Isolate::RemoveScanner(ScannerBase* scanner) {
+  scanners_.erase(scanner);
+  if (scanners_.empty()) {
+    heap()->RemoveGCEpilogueCallback(&Isolate::UpdateScannersAfterGC);
+  }
+}
+
+
 #ifdef DEBUG
 #define ISOLATE_FIELD_OFFSET(type, name, ignored)                       \
 const intptr_t Isolate::name##_debug_offset_ = OFFSET_OF(Isolate, name##_);
 ISOLATE_INIT_LIST(ISOLATE_FIELD_OFFSET)
 ISOLATE_INIT_ARRAY_LIST(ISOLATE_FIELD_OFFSET)
 #undef ISOLATE_FIELD_OFFSET
 #endif
 
 } }  // namespace v8::internal