Made iteration of global handles more efficient on scavenges.

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 1079 matching lines @@
   // No active or weak handles.
   CHECK(HandleScopeImplementer::instance()->blocks()->is_empty());
   CHECK_EQ(0, GlobalHandles::NumberOfWeakHandles());
   // We need a counter function during serialization to resolve the
   // references to counters in the code on the heap.
   CHECK(StatsTable::HasCounterFunction());
   CHECK(enabled());
   InitializeAllocators();
   reference_encoder_ = new ExternalReferenceEncoder();
   PutHeader();
-  Heap::IterateRoots(this);
+  Heap::IterateRoots(this, VISIT_ONLY_STRONG);
   PutLog();
   PutContextStack();
   Disable();
 }
 
 
 void Serializer::Finalize(byte** str, int* len) {
   writer_->GetBytes(str, len);
 }
 
@@ skipping 82 matching lines @@
   writer_->PutInt(Heap::code_space()->Size() + Heap::new_space()->Size());
   writer_->PutC('|');
   writer_->PutInt(Heap::map_space()->Size());
   writer_->PutC('|');
   writer_->PutInt(Heap::cell_space()->Size());
   writer_->PutC(']');
   // Write global handles.
   writer_->PutC('G');
   writer_->PutC('[');
   GlobalHandlesRetriever ghr(&global_handles_);
-  GlobalHandles::IterateRoots(&ghr);
+  GlobalHandles::IterateStrongRoots(&ghr);
   for (int i = 0; i < global_handles_.length(); i++) {
     writer_->PutC('N');
   }
   writer_->PutC(']');
 }
 
 
 void Serializer::PutLog() {
 #ifdef ENABLE_LOGGING_AND_PROFILING
   if (FLAG_log_code) {
@@ skipping 216 matching lines @@
     while (start < end) {
       GlobalHandles::Destroy(start++);
     }
   }
 };
 
 
 void Deserializer::Deserialize() {
   // No global handles.
   NoGlobalHandlesChecker checker;
-  GlobalHandles::IterateRoots(&checker);
+  GlobalHandles::IterateStrongRoots(&checker);
   // No active threads.
   ASSERT_EQ(NULL, ThreadState::FirstInUse());
   // No active handles.
   ASSERT(HandleScopeImplementer::instance()->blocks()->is_empty());
   reference_decoder_ = new ExternalReferenceDecoder();
   // By setting linear allocation only, we forbid the use of free list
   // allocation which is not predicted by SimulatedAddress.
   GetHeader();
-  Heap::IterateRoots(this);
+  Heap::IterateRoots(this, VISIT_ONLY_STRONG);
   GetContextStack();
   // Any global handles that have been set up by deserialization are leaked
   // since noone is keeping track of them.  So we discard them now.
   GlobalHandleDestroyer destroyer;
-  GlobalHandles::IterateRoots(&destroyer);
+  GlobalHandles::IterateStrongRoots(&destroyer);
 }
 
 
 void Deserializer::VisitPointers(Object** start, Object** end) {
   bool root = root_;
   root_ = false;
   for (Object** p = start; p < end; ++p) {
     if (root) {
       roots_++;
       // Read the next object or pointer from the stream
@@ skipping 382 matching lines @@
   // 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, ThreadState::FirstInUse());
   // No active handles.
   ASSERT(HandleScopeImplementer::instance()->blocks()->is_empty());
   ASSERT(external_reference_decoder_ == NULL);
   external_reference_decoder_ = new ExternalReferenceDecoder();
-  Heap::IterateRoots(this);
+  Heap::IterateRoots(this, VISIT_ONLY_STRONG);
   ASSERT(source_->AtEOF());
   delete external_reference_decoder_;
   external_reference_decoder_ = NULL;
 }
 
 
 // This is called on the roots.  It is the driver of the deserialization
 // process.  It is also called on the body of each function.
 void Deserializer2::VisitPointers(Object** start, Object** end) {
   // The space must be new space.  Any other space would cause ReadChunk to try
@@ skipping 250 matching lines @@
 
 
 void Serializer2::Serialize() {
   // No active threads.
   CHECK_EQ(NULL, ThreadState::FirstInUse());
   // No active or weak handles.
   CHECK(HandleScopeImplementer::instance()->blocks()->is_empty());
   CHECK_EQ(0, GlobalHandles::NumberOfWeakHandles());
   ASSERT(external_reference_encoder_ == NULL);
   external_reference_encoder_ = new ExternalReferenceEncoder();
-  Heap::IterateRoots(this);
+  Heap::IterateRoots(this, VISIT_ONLY_STRONG);
   delete external_reference_encoder_;
   external_reference_encoder_ = NULL;
 }
 
 
 void Serializer2::VisitPointers(Object** start, Object** end) {
   for (Object** current = start; current < end; current++) {
     if ((*current)->IsSmi()) {
       sink_->Put(RAW_DATA_SERIALIZATION, "RawData");
       sink_->PutInt(kPointerSize, "length");
@@ skipping 245 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