Use an allocation site scratchpad to speed up allocaton site processing during gc.

src/heap.cc

 // Copyright 2012 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 130 matching lines @@
       last_idle_notification_gc_count_init_(false),
       mark_sweeps_since_idle_round_started_(0),
       gc_count_at_last_idle_gc_(0),
       scavenges_since_last_idle_round_(kIdleScavengeThreshold),
       full_codegen_bytes_generated_(0),
       crankshaft_codegen_bytes_generated_(0),
       gcs_since_last_deopt_(0),
 #ifdef VERIFY_HEAP
       no_weak_object_verification_scope_depth_(0),
 #endif
+      allocation_sites_scratchpad_pointer(0),

[mvstanton, 2013/12/13 10:30:17]

How about using the word count or length instead of pointer for the name.

[Hannes Payer (out of office), 2013/12/18 14:29:19]

Done.

       promotion_queue_(this),
       configured_(false),
       chunks_queued_for_free_(NULL),
       relocation_mutex_(NULL) {
   // Allow build-time customization of the max semispace size. Building
   // V8 with snapshots and a non-default max semispace size is much
   // easier if you can define it as part of the build environment.
 #if defined(V8_MAX_SEMISPACE_SIZE)
   max_semispace_size_ = reserved_semispace_size_ = V8_MAX_SEMISPACE_SIZE;
 #endif
@@ skipping 336 matching lines @@
 void Heap::RepairFreeListsAfterBoot() {
   PagedSpaces spaces(this);
   for (PagedSpace* space = spaces.next();
        space != NULL;
        space = spaces.next()) {
     space->RepairFreeListsAfterBoot();
   }
 }
 
 
-void Heap::GarbageCollectionEpilogue() {
+void Heap::ProcessPretenuringFeedback() {
   if (FLAG_allocation_site_pretenuring) {
     int tenure_decisions = 0;
     int dont_tenure_decisions = 0;
     int allocation_mementos_found = 0;
+    int allocation_sites = 0;
+    int active_allocation_sites = 0;
+    bool use_scratchpad =
+        allocation_sites_scratchpad_pointer < kAllocationSiteScratchpadSize;
 
-    Object* cur = allocation_sites_list();
-    while (cur->IsAllocationSite()) {
-      AllocationSite* casted = AllocationSite::cast(cur);
-      allocation_mementos_found += casted->memento_found_count()->value();
-      if (casted->DigestPretenuringFeedback()) {
-        if (casted->GetPretenureMode() == TENURED) {
-          tenure_decisions++;
-        } else {
-          dont_tenure_decisions++;
+    if (use_scratchpad) {

[Hannes Payer (out of office), 2013/12/12 15:26:05]

Should I make an Iterator for that duplicated piece of code?

[mvstanton, 2013/12/13 10:30:17]

Yep that is a good idea. Alternatively, a function that accepts an
AllocationSite, but I see it would have to accept all these statistics variables
which wouldn't be fun.

[Hannes Payer (out of office), 2013/12/18 14:29:19]

I decided to do the simplified version, not beautiful but an extra iterator is
overkill. WDYT?

+      for (int i = 0; i < allocation_sites_scratchpad_pointer; i++) {
+        AllocationSite* casted = allocation_sites_scratchpad[i];
+        allocation_mementos_found += casted->memento_found_count()->value();
+        if (casted->memento_found_count()->value() > 0) {
+          active_allocation_sites++;
         }
+        if (casted->DigestPretenuringFeedback()) {
+          if (casted->GetPretenureMode() == TENURED) {
+            tenure_decisions++;
+          } else {
+            dont_tenure_decisions++;
+          }
+        }
+        allocation_sites++;
       }
-      cur = casted->weak_next();
+    } else {
+      Object* cur = allocation_sites_list();
+      while (cur->IsAllocationSite()) {
+        AllocationSite* casted = AllocationSite::cast(cur);
+        allocation_mementos_found += casted->memento_found_count()->value();
+        if (casted->memento_found_count()->value() > 0) {
+          active_allocation_sites++;
+        }
+        if (casted->DigestPretenuringFeedback()) {
+          if (casted->GetPretenureMode() == TENURED) {
+            tenure_decisions++;
+          } else {
+            dont_tenure_decisions++;
+          }
+        }
+        cur = casted->weak_next();
+        allocation_sites++;
+      }
     }
+    allocation_sites_scratchpad_pointer = 0;
 
     // TODO(mvstanton): Pretenure decisions are only made once for an allocation
     // site. Find a sane way to decide about revisiting the decision later.
 
     if (FLAG_trace_track_allocation_sites &&
         (allocation_mementos_found > 0 ||
          tenure_decisions > 0 ||
          dont_tenure_decisions > 0)) {
-      PrintF("GC: (#mementos, #tenure decisions, #donttenure decisions) "
-             "(%d, %d, %d)\n",
+      PrintF("GC(%d): (#allocation sites, #active allocation sites, "
+             "#mementos, #tenure decisions, #donttenure decisions) "
+             "(%d, %d, %d, %d, %d)\n",
+             use_scratchpad,
+             allocation_sites,
+             active_allocation_sites,
              allocation_mementos_found,
              tenure_decisions,
              dont_tenure_decisions);
     }
   }
+}
 
+
+void Heap::GarbageCollectionEpilogue() {
   store_buffer()->GCEpilogue();
 
   // In release mode, we only zap the from space under heap verification.
   if (Heap::ShouldZapGarbage()) {
     ZapFromSpace();
   }
 
 #ifdef VERIFY_HEAP
   if (FLAG_verify_heap) {
     Verify();
@@ skipping 1006 matching lines @@
   // Set age mark.
   new_space_.set_age_mark(new_space_.top());
 
   new_space_.LowerInlineAllocationLimit(
       new_space_.inline_allocation_limit_step());
 
   // Update how much has survived scavenge.
   IncrementYoungSurvivorsCounter(static_cast<int>(
       (PromotedSpaceSizeOfObjects() - survived_watermark) + new_space_.Size()));
 
+  ProcessPretenuringFeedback();
+
   LOG(isolate_, ResourceEvent("scavenge", "end"));
 
   gc_state_ = NOT_IN_GC;
 
   scavenges_since_last_idle_round_++;
 }
 
 
 String* Heap::UpdateNewSpaceReferenceInExternalStringTableEntry(Heap* heap,
                                                                 Object** p) {
@@ skipping 6379 matching lines @@
       static_cast<int>(object_sizes_last_time_[index]));
   CODE_AGE_LIST_COMPLETE(ADJUST_LAST_TIME_OBJECT_COUNT)
 #undef ADJUST_LAST_TIME_OBJECT_COUNT
 
   OS::MemCopy(object_counts_last_time_, object_counts_, sizeof(object_counts_));
   OS::MemCopy(object_sizes_last_time_, object_sizes_, sizeof(object_sizes_));
   ClearObjectStats();
 }
 
 } }  // namespace v8::internal