Extension state made per-siolate in genesis

src/api.cc

 // Copyright 2011 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 286 matching lines @@
 // may not have TLS initialized yet. However, in initializing APIs it
 // may be too early to call EnsureInitialized() - some pre-init
 // parameters still have to be configured.
 static inline i::Isolate* EnterIsolateIfNeeded() {
   i::Isolate* isolate = i::Isolate::UncheckedCurrent();
   if (isolate != NULL)
     return isolate;
 
   i::Isolate::EnterDefaultIsolate();
   isolate = i::Isolate::Current();
-  return isolate;
+return isolate;

[danno, 2011/11/15 09:46:47]

nit: indent

 }
 
 
 StartupDataDecompressor::StartupDataDecompressor()
     : raw_data(i::NewArray<char*>(V8::GetCompressedStartupDataCount())) {
   for (int i = 0; i < V8::GetCompressedStartupDataCount(); ++i) {
     raw_data[i] = NULL;
   }
 }
 
@@ skipping 161 matching lines @@
     isolate->ScheduleThrow(*Utils::OpenHandle(*value));
   }
   return v8::Undefined();
 }
 
 
 RegisteredExtension* RegisteredExtension::first_extension_ = NULL;
 
 
 RegisteredExtension::RegisteredExtension(Extension* extension)
-    : extension_(extension), state_(UNVISITED) { }
+    : extension_(extension) { }
 
 
 void RegisteredExtension::Register(RegisteredExtension* that) {
   that->next_ = first_extension_;
   first_extension_ = that;
 }
 
 
 void RegisterExtension(Extension* that) {
   RegisteredExtension* extension = new RegisteredExtension(that);
   RegisteredExtension::Register(extension);
 }
 
 
+namespace internal {
+

[Vitaly Repeshko, 2011/11/15 18:14:17]

nit: Remove one blank line.

+
+static uint32_t Hash(RegisteredExtension* extension) {
+  return v8::internal::ComputeIntegerHash(
+            reinterpret_cast<uint32_t>(extension));

[Vitaly Repeshko, 2011/11/15 18:14:17]

I'm not sure it'll work with 64 bit pointers. I think you need something like
static_cast<uint32_t>(reinterpret_cast<uintptr_t>(extension)).

+}
+
+static bool MatchRegisteredExtensions(void* key1, void* key2) {
+  return key1 == key2;
+}
+
+static Allocator* ExtensionStatesAllocator() {
+  static Allocator default_allocator;

[Vitaly Repeshko, 2011/11/15 18:14:17]

Allocate the allocator with "new" to avoid issues with static destructors.

+  return &default_allocator;
+}
+
+ExtensionStates::ExtensionStates()
+  : HashMap(MatchRegisteredExtensions, ExtensionStatesAllocator(), 8)
+  {}
+
+ExtensionTraversalState ExtensionStates::get_state(
+    RegisteredExtension* extension) {
+  i::HashMap::Entry* entry = Lookup(extension, Hash(extension), false);
+  if (entry == NULL) {
+    entry = Lookup(extension, Hash(extension), true);

[Vitaly Repeshko, 2011/11/15 18:14:17]

Can't you simply return UNVISITED?

+    entry->value = reinterpret_cast<void*>(
+        static_cast<int>(UNVISITED));
+  }
+  return static_cast<ExtensionTraversalState>(
+      reinterpret_cast<int>(entry->value));

[Vitaly Repeshko, 2011/11/15 18:14:17]

Again, I think it has to be something like
static_cast<ExtensionTraversalState>(reintepret_cast<intptr_t>(entry->value)).

+}
+
+void ExtensionStates::set_state(RegisteredExtension* extension,
+                                ExtensionTraversalState state) {
+  Lookup(extension, Hash(extension), true)->value =
+      reinterpret_cast<void*>(static_cast<int>(state));
+}
+}

[Vitaly Repeshko, 2011/11/15 18:14:17]

nit:  // namespace internal

+
 Extension::Extension(const char* name,
                      const char* source,
                      int dep_count,
                      const char** deps,
                      int source_length)
     : name_(name),
       source_length_(source_length >= 0 ?
                   source_length : (source ? strlen(source) : 0)),
       source_(source, source_length_),
       dep_count_(dep_count),
@@ skipping 5603 matching lines @@
 
 
 char* HandleScopeImplementer::Iterate(ObjectVisitor* v, char* storage) {
   HandleScopeImplementer* scope_implementer =
       reinterpret_cast<HandleScopeImplementer*>(storage);
   scope_implementer->IterateThis(v);
   return storage + ArchiveSpacePerThread();
 }
 
 } }  // namespace v8::internal