Patch for allowing several V8 instances in process:...

src/stub-cache.cc

 // Copyright 2006-2009 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 20 matching lines @@
 #include "arguments.h"
 #include "ic-inl.h"
 #include "stub-cache.h"
 
 namespace v8 {
 namespace internal {
 
 // -----------------------------------------------------------------------
 // StubCache implementation.
 
+StubCacheData::StubCacheData() {
+  for (int i = 0; i < kPrimaryTableSize; ++i) {
+    primary_[i].key = NULL;
+    primary_[i].value = NULL;
+  }
 
-StubCache::Entry StubCache::primary_[StubCache::kPrimaryTableSize];
-StubCache::Entry StubCache::secondary_[StubCache::kSecondaryTableSize];
+  for (int i = 0; i < kSecondaryTableSize; ++i) {
+    secondary_[i].key = NULL;
+    secondary_[i].value = NULL;
+  }
+}
 
 void StubCache::Initialize(bool create_heap_objects) {
   ASSERT(IsPowerOf2(kPrimaryTableSize));
   ASSERT(IsPowerOf2(kSecondaryTableSize));
   if (create_heap_objects) {
     HandleScope scope;
     Clear();
   }
 }
 
@@ skipping 12 matching lines @@
   // the bits are the least significant so they will be the ones
   // masked out.
   ASSERT(Code::ExtractICStateFromFlags(flags) == MONOMORPHIC);
   ASSERT(Code::kFlagsICStateShift == 0);
 
   // Make sure that the code type is not included in the hash.
   ASSERT(Code::ExtractTypeFromFlags(flags) == 0);
 
   // Compute the primary entry.
   int primary_offset = PrimaryOffset(name, flags, map);
-  Entry* primary = entry(primary_, primary_offset);
+  StubCacheData& stub_cache_data = v8_context()->stub_cache_data_;
+  Entry* primary = entry(stub_cache_data.primary_, primary_offset);
   Code* hit = primary->value;
 
   // If the primary entry has useful data in it, we retire it to the
   // secondary cache before overwriting it.
   if (hit != Builtins::builtin(Builtins::Illegal)) {
     Code::Flags primary_flags = Code::RemoveTypeFromFlags(hit->flags());
     int secondary_offset =
         SecondaryOffset(primary->key, primary_flags, primary_offset);
-    Entry* secondary = entry(secondary_, secondary_offset);
+    Entry* secondary = entry(stub_cache_data.secondary_, secondary_offset);
     *secondary = *primary;
   }
 
   // Update primary cache.
   primary->key = name;
   primary->value = code;
   return code;
 }
 
 
@@ skipping 609 matching lines @@
     Code* code = Code::cast(result);
     USE(code);
     LOG(CodeCreateEvent(Logger::LAZY_COMPILE_TAG,
                         code, code->arguments_count()));
   }
   return result;
 }
 
 
 void StubCache::Clear() {
+  StubCacheData& stub_cache_data = v8_context()->stub_cache_data_;
   for (int i = 0; i < kPrimaryTableSize; i++) {
-    primary_[i].key = Heap::empty_string();
-    primary_[i].value = Builtins::builtin(Builtins::Illegal);
+    stub_cache_data.primary_[i].key = Heap::empty_string();
+    stub_cache_data.primary_[i].value = Builtins::builtin(Builtins::Illegal);
   }
   for (int j = 0; j < kSecondaryTableSize; j++) {
-    secondary_[j].key = Heap::empty_string();
-    secondary_[j].value = Builtins::builtin(Builtins::Illegal);
+    stub_cache_data.secondary_[j].key = Heap::empty_string();
+    stub_cache_data.secondary_[j].value = Builtins::builtin(Builtins::Illegal);
   }
 }
 
 
 // ------------------------------------------------------------------------
 // StubCompiler implementation.
 
 
 // Support function for computing call IC miss stubs.
 Handle<Code> ComputeCallMiss(int argc) {
@@ skipping 187 matching lines @@
   return result;
 }
 
 
 Object* StubCompiler::CompileCallInitialize(Code::Flags flags) {
   HandleScope scope;
   int argc = Code::ExtractArgumentsCountFromFlags(flags);
   CallIC::GenerateInitialize(masm(), argc);
   Object* result = GetCodeWithFlags(flags, "CompileCallInitialize");
   if (!result->IsFailure()) {
-    Counters::call_initialize_stubs.Increment();
+    INC_COUNTER(call_initialize_stubs);
     Code* code = Code::cast(result);
     USE(code);
     LOG(CodeCreateEvent(Logger::CALL_INITIALIZE_TAG,
                         code, code->arguments_count()));
   }
   return result;
 }
 
 
 Object* StubCompiler::CompileCallPreMonomorphic(Code::Flags flags) {
   HandleScope scope;
   int argc = Code::ExtractArgumentsCountFromFlags(flags);
   // The code of the PreMonomorphic stub is the same as the code
   // of the Initialized stub.  They just differ on the code object flags.
   CallIC::GenerateInitialize(masm(), argc);
   Object* result = GetCodeWithFlags(flags, "CompileCallPreMonomorphic");
   if (!result->IsFailure()) {
-    Counters::call_premonomorphic_stubs.Increment();
+    INC_COUNTER(call_premonomorphic_stubs);
     Code* code = Code::cast(result);
     USE(code);
     LOG(CodeCreateEvent(Logger::CALL_PRE_MONOMORPHIC_TAG,
                         code, code->arguments_count()));
   }
   return result;
 }
 
 
 Object* StubCompiler::CompileCallNormal(Code::Flags flags) {
   HandleScope scope;
   int argc = Code::ExtractArgumentsCountFromFlags(flags);
   CallIC::GenerateNormal(masm(), argc);
   Object* result = GetCodeWithFlags(flags, "CompileCallNormal");
   if (!result->IsFailure()) {
-    Counters::call_normal_stubs.Increment();
+    INC_COUNTER(call_normal_stubs);
     Code* code = Code::cast(result);
     USE(code);
     LOG(CodeCreateEvent(Logger::CALL_NORMAL_TAG,
                         code, code->arguments_count()));
   }
   return result;
 }
 
 
 Object* StubCompiler::CompileCallMegamorphic(Code::Flags flags) {
   HandleScope scope;
   int argc = Code::ExtractArgumentsCountFromFlags(flags);
   CallIC::GenerateMegamorphic(masm(), argc);
   Object* result = GetCodeWithFlags(flags, "CompileCallMegamorphic");
   if (!result->IsFailure()) {
-    Counters::call_megamorphic_stubs.Increment();
+    INC_COUNTER(call_megamorphic_stubs);
     Code* code = Code::cast(result);
     USE(code);
     LOG(CodeCreateEvent(Logger::CALL_MEGAMORPHIC_TAG,
                         code, code->arguments_count()));
   }
   return result;
 }
 
 
 Object* StubCompiler::CompileCallMiss(Code::Flags flags) {
   HandleScope scope;
   int argc = Code::ExtractArgumentsCountFromFlags(flags);
   CallIC::GenerateMiss(masm(), argc);
   Object* result = GetCodeWithFlags(flags, "CompileCallMiss");
   if (!result->IsFailure()) {
-    Counters::call_megamorphic_stubs.Increment();
+    INC_COUNTER(call_megamorphic_stubs);
     Code* code = Code::cast(result);
     USE(code);
     LOG(CodeCreateEvent(Logger::CALL_MISS_TAG, code, code->arguments_count()));
   }
   return result;
 }
 
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
 Object* StubCompiler::CompileCallDebugBreak(Code::Flags flags) {
@@ skipping 93 matching lines @@
   if (!result->IsFailure()) {
     Code* code = Code::cast(result);
     USE(code);
     LOG(CodeCreateEvent(Logger::STUB_TAG, code, "ConstructStub"));
   }
   return result;
 }
 
 
 } }  // namespace v8::internal