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

src/serialize.cc

 // Copyright 2006-2008 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 26 matching lines @@
 #include "runtime.h"
 #include "serialize.h"
 #include "stub-cache.h"
 #include "v8threads.h"
 #include "top.h"
 #include "bootstrapper.h"
 
 namespace v8 {
 namespace internal {
 
+class ExternalReferenceTable;
+
+class SerializerPrivateData {
+ public:
+  ExternalReferenceTable* external_reference_table_;
+  HashMap* serialization_map_;
+  SerializerPrivateData()
+    :serialization_map_(NULL),
+    external_reference_table_(NULL) {
+  }
+};
+
+SerializerData::SerializerData()
+  :private_data_(*new SerializerPrivateData()),
+  serialization_enabled_(false),
+  too_late_to_enable_now_(false) {
+}
+
+SerializerData::~SerializerData() {
+  delete &private_data_;
+}
+
 // Mapping objects to their location after deserialization.
 // This is used during building, but not at runtime by V8.
 class SerializationAddressMapper {
  public:
   static bool IsMapped(HeapObject* obj) {
     EnsureMapExists();
-    return serialization_map_->Lookup(Key(obj), Hash(obj), false) != NULL;
+    return v8_context()->serializer_data_.private_data_.
+      serialization_map_->Lookup(Key(obj), Hash(obj), false) != NULL;
   }
 
   static int MappedTo(HeapObject* obj) {
     ASSERT(IsMapped(obj));
-    return reinterpret_cast<intptr_t>(serialization_map_->Lookup(Key(obj),
-                                      Hash(obj),
-                                      false)->value);
+    return reinterpret_cast<intptr_t>(v8_context()->serializer_data_.
+      private_data_.serialization_map_->Lookup(
+        Key(obj),
+        Hash(obj),
+        false)->value);
   }
 
   static void Map(HeapObject* obj, int to) {
     EnsureMapExists();
     ASSERT(!IsMapped(obj));
-    HashMap::Entry* entry =
-        serialization_map_->Lookup(Key(obj), Hash(obj), true);
+    HashMap::Entry* entry = v8_context()->serializer_data_.private_data_.
+      serialization_map_->Lookup(Key(obj), Hash(obj), true);
     entry->value = Value(to);
   }
 
   static void Zap() {
-    if (serialization_map_ != NULL) {
-      delete serialization_map_;
+    HashMap*& serialization_map = v8_context()->serializer_data_.
+      private_data_.serialization_map_;
+    if (serialization_map != NULL) {
+      delete serialization_map;
     }
-    serialization_map_ = NULL;
+    serialization_map = NULL;
   }
 
  private:
   static bool SerializationMatchFun(void* key1, void* key2) {
     return key1 == key2;
   }
 
   static uint32_t Hash(HeapObject* obj) {
     return reinterpret_cast<intptr_t>(obj->address());
   }
 
   static void* Key(HeapObject* obj) {
     return reinterpret_cast<void*>(obj->address());
   }
 
   static void* Value(int v) {
     return reinterpret_cast<void*>(v);
   }
 
   static void EnsureMapExists() {
-    if (serialization_map_ == NULL) {
-      serialization_map_ = new HashMap(&SerializationMatchFun);
+    HashMap*& serialization_map = v8_context()->serializer_data_.
+      private_data_.serialization_map_;
+    if (serialization_map == NULL) {
+      serialization_map = new HashMap(&SerializationMatchFun);
     }
   }
-
-  static HashMap* serialization_map_;
 };
 
 
-HashMap* SerializationAddressMapper::serialization_map_ = NULL;
 
 
 
 
 // -----------------------------------------------------------------------------
 // Coding of external references.
 
 // The encoding of an external reference. The type is in the high word.
 // The id is in the low word.
 static uint32_t EncodeExternal(TypeCode type, uint16_t id) {
   return static_cast<uint32_t>(type) << 16 | id;
 }
 
 
 static int* GetInternalPointer(StatsCounter* counter) {
   // All counters refer to dummy_counter, if deserializing happens without
   // setting up counters.
   static int dummy_counter = 0;
   return counter->Enabled() ? counter->GetInternalPointer() : &dummy_counter;
 }
 
 
 // ExternalReferenceTable is a helper class that defines the relationship
 // between external references and their encodings. It is used to build
 // hashmaps in ExternalReferenceEncoder and ExternalReferenceDecoder.
 class ExternalReferenceTable {
  public:
   static ExternalReferenceTable* instance() {
-    if (!instance_) instance_ = new ExternalReferenceTable();
-    return instance_;
+    ExternalReferenceTable*& instance = v8_context()->serializer_data_.
+      private_data_.external_reference_table_;
+    if (!instance) instance = new ExternalReferenceTable();
+    return instance;
   }
 
   int size() const { return refs_.length(); }
 
   Address address(int i) { return refs_[i].address; }
 
   uint32_t code(int i) { return refs_[i].code; }
 
   const char* name(int i) { return refs_[i].name; }
 
   int max_id(int code) { return max_id_[code]; }
 
  private:
-  static ExternalReferenceTable* instance_;
 
   ExternalReferenceTable() : refs_(64) { PopulateTable(); }
   ~ExternalReferenceTable() { }
 
   struct ExternalReferenceEntry {
     Address address;
     uint32_t code;
     const char* name;
   };
 
   void PopulateTable();
 
   // For a few types of references, we can get their address from their id.
   void AddFromId(TypeCode type, uint16_t id, const char* name);
 
   // For other types of references, the caller will figure out the address.
   void Add(Address address, TypeCode type, uint16_t id, const char* name);
 
   List<ExternalReferenceEntry> refs_;
   int max_id_[kTypeCodeCount];
 };
 
 
-ExternalReferenceTable* ExternalReferenceTable::instance_ = NULL;
 
 
 void ExternalReferenceTable::AddFromId(TypeCode type,
                                        uint16_t id,
                                        const char* name) {
   Address address;
   switch (type) {
     case C_BUILTIN: {
       ExternalReference ref(static_cast<Builtins::CFunctionId>(id));
       address = ref.address();
@@ skipping 125 matching lines @@
 
   // Stat counters
   struct StatsRefTableEntry {
     StatsCounter* counter;
     uint16_t id;
     const char* name;
   };
 
   static const StatsRefTableEntry stats_ref_table[] = {
 #define COUNTER_ENTRY(name, caption) \
-  { &Counters::name, \
+  { &COUNTER(name), \
     Counters::k_##name, \
     "Counters::" #name },
 
   STATS_COUNTER_LIST_1(COUNTER_ENTRY)
   STATS_COUNTER_LIST_2(COUNTER_ENTRY)
 #undef COUNTER_ENTRY
   };  // end of stats_ref_table[].
 
   for (size_t i = 0; i < ARRAY_SIZE(stats_ref_table); ++i) {
     Add(reinterpret_cast<Address>(
@@ skipping 211 matching lines @@
 
 
 ExternalReferenceDecoder::~ExternalReferenceDecoder() {
   for (int type = kFirstTypeCode; type < kTypeCodeCount; ++type) {
     DeleteArray(encodings_[type]);
   }
   DeleteArray(encodings_);
 }
 
 
-bool Serializer::serialization_enabled_ = false;
-bool Serializer::too_late_to_enable_now_ = false;
-
 
 Deserializer::Deserializer(SnapshotByteSource* source)
     : source_(source),
       external_reference_decoder_(NULL) {
 }
 
 
 // This routine both allocates a new object, and also keeps
 // track of where objects have been allocated so that we can
 // fix back references when deserializing.
@@ skipping 649 matching lines @@
       fullness_[space] = RoundUp(fullness_[space], Page::kPageSize);
     }
   }
   int allocation_address = fullness_[space];
   fullness_[space] = allocation_address + size;
   return allocation_address;
 }
 
 
 } }  // namespace v8::internal