[Isolates] Minimize TLS accesses during startup deserialization.

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 228 matching lines @@
       Debug::k_debug_break_return_address << kDebugIdShift,
       "Debug::debug_break_return_address()");
   Add(Debug_Address(Debug::k_restarter_frame_function_pointer).address(isolate),
       DEBUG_ADDRESS,
       Debug::k_restarter_frame_function_pointer << kDebugIdShift,
       "Debug::restarter_frame_function_pointer_address()");
 #endif
 
   // Stat counters
   struct StatsRefTableEntry {
-    StatsCounter* counter;
+    StatsCounter* (Counters::*counter)();
     uint16_t id;
     const char* name;
   };
 
   const StatsRefTableEntry stats_ref_table[] = {
 #define COUNTER_ENTRY(name, caption) \
-  { COUNTERS->name(), \
+  { &Counters::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[].
 
+  Counters* counters = isolate->counters();
   for (size_t i = 0; i < ARRAY_SIZE(stats_ref_table); ++i) {
-    Add(reinterpret_cast<Address>(
-            GetInternalPointer(stats_ref_table[i].counter)),
+    Add(reinterpret_cast<Address>(GetInternalPointer(
+            (counters->*(stats_ref_table[i].counter))())),
         STATS_COUNTER,
         stats_ref_table[i].id,
         stats_ref_table[i].name);
   }
 
   // Top addresses
-  const char* top_address_format = "Isolate::%s";
 
   const char* AddressNames[] = {
-#define C(name) #name,
+#define C(name) "Isolate::" #name,
     ISOLATE_ADDRESS_LIST(C)
     ISOLATE_ADDRESS_LIST_PROF(C)
     NULL
 #undef C
   };
 
-  int top_format_length = StrLength(top_address_format) - 2;
   for (uint16_t i = 0; i < Isolate::k_isolate_address_count; ++i) {
-    const char* address_name = AddressNames[i];
-    Vector<char> name =
-        Vector<char>::New(top_format_length + StrLength(address_name) + 1);
-    const char* chars = name.start();
-    OS::SNPrintF(name, top_address_format, address_name);
     Add(isolate->get_address_from_id((Isolate::AddressId)i),
-        TOP_ADDRESS, i, chars);
+        TOP_ADDRESS, i, AddressNames[i]);
   }
 
   // Extensions
   Add(FUNCTION_ADDR(GCExtension::GC), EXTENSION, 1,
       "GCExtension::GC");
 
   // Accessors
 #define ACCESSOR_DESCRIPTOR_DECLARATION(name) \
   Add((Address)&Accessors::name, \
       ACCESSOR, \
@@ skipping 228 matching lines @@
   }
   DeleteArray(encodings_);
 }
 
 
 bool Serializer::serialization_enabled_ = false;
 bool Serializer::too_late_to_enable_now_ = false;
 
 
 Deserializer::Deserializer(SnapshotByteSource* source)
-    : source_(source),
+    : isolate_(NULL),
+      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.
 Address Deserializer::Allocate(int space_index, Space* space, int size) {
   Address address;
   if (!SpaceIsLarge(space_index)) {
@@ skipping 58 matching lines @@
   }
   ASSERT(SpaceIsPaged(space));
   int page_of_pointee = offset >> kPageSizeBits;
   Address object_address = pages_[space][page_of_pointee] +
                            (offset & Page::kPageAlignmentMask);
   return HeapObject::FromAddress(object_address);
 }
 
 
 void Deserializer::Deserialize() {
+  isolate_ = Isolate::Current();
   // Don't GC while deserializing - just expand the heap.
   AlwaysAllocateScope always_allocate;
   // Don't use the free lists while deserializing.
   LinearAllocationScope allocate_linearly;
   // No active threads.
-  ASSERT_EQ(NULL,
-      Isolate::Current()->thread_manager()->FirstThreadStateInUse());
+  ASSERT_EQ(NULL, isolate_->thread_manager()->FirstThreadStateInUse());
   // No active handles.
-  ASSERT(Isolate::Current()->handle_scope_implementer()->blocks()->is_empty());
+  ASSERT(isolate_->handle_scope_implementer()->blocks()->is_empty());
   // Make sure the entire partial snapshot cache is traversed, filling it with
   // valid object pointers.
-  Isolate::Current()->set_serialize_partial_snapshot_cache_length(
+  isolate_->set_serialize_partial_snapshot_cache_length(
       Isolate::kPartialSnapshotCacheCapacity);
   ASSERT_EQ(NULL, external_reference_decoder_);
   external_reference_decoder_ = new ExternalReferenceDecoder();
-  HEAP->IterateStrongRoots(this, VISIT_ONLY_STRONG);
-  HEAP->IterateWeakRoots(this, VISIT_ALL);
+  isolate_->heap()->IterateStrongRoots(this, VISIT_ONLY_STRONG);
+  isolate_->heap()->IterateWeakRoots(this, VISIT_ALL);
 }
 
 
 void Deserializer::DeserializePartial(Object** root) {
+  isolate_ = Isolate::Current();
   // Don't GC while deserializing - just expand the heap.
   AlwaysAllocateScope always_allocate;
   // Don't use the free lists while deserializing.
   LinearAllocationScope allocate_linearly;
   if (external_reference_decoder_ == NULL) {
     external_reference_decoder_ = new ExternalReferenceDecoder();
   }
   VisitPointer(root);
 }
 
@@ skipping 28 matching lines @@
   int size = source_->GetInt() << kObjectAlignmentBits;
   Address address = Allocate(space_number, space, size);
   *write_back = HeapObject::FromAddress(address);
   Object** current = reinterpret_cast<Object**>(address);
   Object** limit = current + (size >> kPointerSizeLog2);
   if (FLAG_log_snapshot_positions) {
     LOG(SnapshotPositionEvent(address, source_->position()));
   }
   ReadChunk(current, limit, space_number, address);
 
-  if (space == space->heap()->map_space()) {
+  if (space_number == MAP_SPACE) {
     ASSERT(size == Map::kSize);
     HeapObject* obj = HeapObject::FromAddress(address);
     Map* map = reinterpret_cast<Map*>(obj);
-    map->set_heap(space->heap());
+    map->set_heap(isolate_->heap());
   }
 }
 
 
 // This macro is always used with a constant argument so it should all fold
 // away to almost nothing in the generated code.  It might be nicer to do this
 // with the ternary operator but there are type issues with that.
 #define ASSIGN_DEST_SPACE(space_number)                                        \
   Space* dest_space;                                                           \
   if (space_number == NEW_SPACE) {                                             \
-    dest_space = HEAP->new_space();                                            \
+    dest_space = isolate->heap()->new_space();                                \
   } else if (space_number == OLD_POINTER_SPACE) {                              \
-    dest_space = HEAP->old_pointer_space();                                    \
+    dest_space = isolate->heap()->old_pointer_space();                         \
   } else if (space_number == OLD_DATA_SPACE) {                                 \
-    dest_space = HEAP->old_data_space();                                       \
+    dest_space = isolate->heap()->old_data_space();                            \
   } else if (space_number == CODE_SPACE) {                                     \
-    dest_space = HEAP->code_space();                                           \
+    dest_space = isolate->heap()->code_space();                                \
   } else if (space_number == MAP_SPACE) {                                      \
-    dest_space = HEAP->map_space();                                            \
+    dest_space = isolate->heap()->map_space();                                 \
   } else if (space_number == CELL_SPACE) {                                     \
-    dest_space = HEAP->cell_space();                                           \
+    dest_space = isolate->heap()->cell_space();                                \
   } else {                                                                     \
     ASSERT(space_number >= LO_SPACE);                                          \
-    dest_space = HEAP->lo_space();                                             \
+    dest_space = isolate->heap()->lo_space();                                  \
   }
 
 
 static const int kUnknownOffsetFromStart = -1;
 
 
 void Deserializer::ReadChunk(Object** current,
                              Object** limit,
                              int source_space,
                              Address address) {
-  Isolate* isolate = Isolate::Current();
+  Isolate* const isolate = isolate_;
   while (current < limit) {
     int data = source_->Get();
     switch (data) {
 #define CASE_STATEMENT(where, how, within, space_number)                       \
       case where + how + within + space_number:                                \
       ASSERT((where & ~kPointedToMask) == 0);                                  \
       ASSERT((how & ~kHowToCodeMask) == 0);                                    \
       ASSERT((within & ~kWhereToPointMask) == 0);                              \
       ASSERT((space_number & ~kSpaceMask) == 0);
 
 #define CASE_BODY(where, how, within, space_number_if_any, offset_from_start)  \
       {                                                                        \
         bool emit_write_barrier = false;                                       \
         bool current_was_incremented = false;                                  \
         int space_number =  space_number_if_any == kAnyOldSpace ?              \
                             (data & kSpaceMask) : space_number_if_any;         \
         if (where == kNewObject && how == kPlain && within == kStartOfObject) {\
           ASSIGN_DEST_SPACE(space_number)                                      \
           ReadObject(space_number, dest_space, current);                       \
           emit_write_barrier =                                                 \
             (space_number == NEW_SPACE && source_space != NEW_SPACE);          \
         } else {                                                               \
           Object* new_object = NULL;  /* May not be a real Object pointer. */  \
           if (where == kNewObject) {                                           \
             ASSIGN_DEST_SPACE(space_number)                                    \
             ReadObject(space_number, dest_space, &new_object);                 \
           } else if (where == kRootArray) {                                    \
             int root_id = source_->GetInt();                                   \
-            new_object = HEAP->roots_address()[root_id];                       \
+            new_object = isolate->heap()->roots_address()[root_id];            \
           } else if (where == kPartialSnapshotCache) {                         \
             int cache_index = source_->GetInt();                               \
             new_object = isolate->serialize_partial_snapshot_cache()           \
                 [cache_index];                                                 \
           } else if (where == kExternalReference) {                            \
             int reference_id = source_->GetInt();                              \
             Address address = external_reference_decoder_->                    \
                 Decode(reference_id);                                          \
             new_object = reinterpret_cast<Object*>(address);                   \
           } else if (where == kBackref) {                                      \
@@ skipping 25 matching lines @@
             if (within == kFirstInstruction) {                                 \
               location_of_branch_data += Assembler::kCallTargetSize;           \
               current = reinterpret_cast<Object**>(location_of_branch_data);   \
               current_was_incremented = true;                                  \
             }                                                                  \
           } else {                                                             \
             *current = new_object;                                             \
           }                                                                    \
         }                                                                      \
         if (emit_write_barrier) {                                              \
-          HEAP->RecordWrite(address, static_cast<int>(                         \
+          isolate->heap()->RecordWrite(address, static_cast<int>(              \
               reinterpret_cast<Address>(current) - address));                  \
         }                                                                      \
         if (!current_was_incremented) {                                        \
           current++;   /* Increment current if it wasn't done above. */        \
         }                                                                      \
         break;                                                                 \
       }                                                                        \
 
 // This generates a case and a body for each space.  The large object spaces are
 // very rare in snapshots so they are grouped in one body.
@@ skipping 144 matching lines @@
           CPU::FlushICache(last_object_address_, Page::kPageSize);
         }
         break;
       }
 
       case kNativesStringResource: {
         int index = source_->Get();
         Vector<const char> source_vector = Natives::GetScriptSource(index);
         NativesExternalStringResource* resource =
             new NativesExternalStringResource(
-                Isolate::Current()->bootstrapper(), source_vector.start());
+                isolate->bootstrapper(), source_vector.start());
         *current++ = reinterpret_cast<Object*>(resource);
         break;
       }
 
       case kSynchronize: {
         // If we get here then that indicates that you have a mismatch between
         // the number of GC roots when serializing and deserializing.
         UNREACHABLE();
       }
 
@@ skipping 523 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