Tenure allocation sites only when semi-space is maximum size.

src/objects-inl.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // Review notes:
 //
 // - The use of macros in these inline functions may seem superfluous
 // but it is absolutely needed to make sure gcc generates optimal
 // code. gcc is not happy when attempting to inline too deep.
 //
@@ skipping 1559 matching lines @@
 }
 
 
 inline void AllocationSite::IncrementMementoCreateCount() {
   ASSERT(FLAG_allocation_site_pretenuring);
   int value = memento_create_count();
   set_memento_create_count(value + 1);
 }
 
 
+inline bool AllocationSite::MakePretenuringDecision(double ratio) {
+  // Currently we just need to deopt when we make a state transition to tenure.
+  if (ratio >= kPretenureRatio) {
+    // We just transition into tenure state when the semi-space was at
+    // maximum capacity.
+    Heap* heap = GetHeap();
+    if (heap->changed_to_max_semi_space_size() &&

[mvstanton, 2014/06/02 13:31:25]

Since the allocation sites are processed in bulk, and this predicate
(changed_to_max_semi_space_size()) won't change between the start of the
processing and the end of it, it might be better to pass that value in to
DigestPretenuringFeedback().

What do you think? This might also reduce the need for a boolean versus a
predicate that just checks the space capacity against max capacity.

[Hannes Payer (out of office), 2014/06/02 14:56:52]

Done.

+        heap->new_space()->IsAtMaximumCapacity()) {
+      set_deopt_dependent_code(true);
+      set_pretenure_decision(kTenure);
+      return true;
+    }
+    set_pretenure_decision(kMaybeTenure);
+  } else {
+    set_pretenure_decision(kDontTenure);
+  }
+  return false;
+}
+
+
 inline bool AllocationSite::DigestPretenuringFeedback() {
-  bool decision_changed = false;
+  bool deopt = false;
   int create_count = memento_create_count();
   int found_count = memento_found_count();
   bool minimum_mementos_created = create_count >= kPretenureMinimumCreated;
   double ratio =
       minimum_mementos_created || FLAG_trace_pretenuring_statistics ?
           static_cast<double>(found_count) / create_count : 0.0;
-  PretenureFlag current_mode = GetPretenureMode();
+  PretenureDecision current_decision = pretenure_decision();
 
-  // TODO(hpayer): Add an intermediate state MAYBE_TENURE which collects
-  // more lifetime feedback for tenuring candidates. In the meantime, we
-  // just allow transitions from undecided to tenured or not tenured.
-  if (minimum_mementos_created && pretenure_decision() == kUndecided) {
-    PretenureDecision result = ratio >= kPretenureRatio
-        ? kTenure
-        : kDontTenure;
-    set_pretenure_decision(result);
-    if (current_mode != GetPretenureMode()) {
-      decision_changed = true;
-      set_deopt_dependent_code(true);
+  // Here we just allow state transitions from undecided or maybe tenure
+  // to don't tenure, maybe tenure, or tenure.
+  if (minimum_mementos_created) {
+    if ((current_decision == kUndecided || current_decision == kMaybeTenure)) {
+      deopt = MakePretenuringDecision(ratio);
     }
   }
 
   if (FLAG_trace_pretenuring_statistics) {
     PrintF(
         "AllocationSite(%p): (created, found, ratio) (%d, %d, %f) %s => %s\n",
          static_cast<void*>(this), create_count, found_count, ratio,
-         current_mode == TENURED ? "tenured" : "not tenured",
-         GetPretenureMode() == TENURED ? "tenured" : "not tenured");
+         PretenureDecisionName(current_decision),
+         PretenureDecisionName(pretenure_decision()));
   }
 
   // Clear feedback calculation fields until the next gc.
   set_memento_found_count(0);
   set_memento_create_count(0);
-  return decision_changed;
+  return deopt;
 }
 
 
 void JSObject::EnsureCanContainHeapObjectElements(Handle<JSObject> object) {
   JSObject::ValidateElements(object);
   ElementsKind elements_kind = object->map()->elements_kind();
   if (!IsFastObjectElementsKind(elements_kind)) {
     if (IsFastHoleyElementsKind(elements_kind)) {
       TransitionElementsKind(object, FAST_HOLEY_ELEMENTS);
     } else {
@@ skipping 5243 matching lines @@
 #undef READ_SHORT_FIELD
 #undef WRITE_SHORT_FIELD
 #undef READ_BYTE_FIELD
 #undef WRITE_BYTE_FIELD
 #undef NOBARRIER_READ_BYTE_FIELD
 #undef NOBARRIER_WRITE_BYTE_FIELD
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_INL_H_