Deopt marked code at safe deoptimization point when pretenuring.

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 503 matching lines @@
     int allocation_sites = 0;
     int active_allocation_sites = 0;
 
     // If the scratchpad overflowed, we have to iterate over the allocation
     // sites list.
     bool use_scratchpad =
         allocation_sites_scratchpad_length < kAllocationSiteScratchpadSize;
 
     int i = 0;
     Object* list_element = allocation_sites_list();
+    bool trigger_deoptimization = false;
     while (use_scratchpad ?
               i < allocation_sites_scratchpad_length :
               list_element->IsAllocationSite()) {
       AllocationSite* site = use_scratchpad ?
         allocation_sites_scratchpad[i] : AllocationSite::cast(list_element);
       allocation_mementos_found += site->memento_found_count();
       if (site->memento_found_count() > 0) {
         active_allocation_sites++;
       }
-      if (site->DigestPretenuringFeedback()) {
-        if (site->GetPretenureMode() == TENURED) {
-          tenure_decisions++;
-        } else {
-          dont_tenure_decisions++;
-        }
+      if (site->DigestPretenuringFeedback()) trigger_deoptimization = true;
+      if (site->GetPretenureMode() == TENURED) {

[Benedikt Meurer, 2014/01/16 11:19:37]

Shouldn't this if still depend on the previous one?

[Hannes Payer (out of office), 2014/01/16 11:41:20]

The semantics of DigestPretenuringFeedback changed.

+        tenure_decisions++;
+      } else {
+        dont_tenure_decisions++;
       }
       allocation_sites++;
       if (use_scratchpad) {
         i++;
       } else {
         list_element = site->weak_next();
       }
     }
+
+    if (trigger_deoptimization) isolate_->stack_guard()->DeoptMarkedCode();
+
     allocation_sites_scratchpad_length = 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: (mode, #visited allocation sites, #active allocation sites, "
@@ skipping 1434 matching lines @@
     AllocationSite* casted = AllocationSite::cast(cur);
     if (casted->GetPretenureMode() == flag) {
       casted->ResetPretenureDecision();
       bool got_marked = casted->dependent_code()->MarkCodeForDeoptimization(
           isolate_,
           DependentCode::kAllocationSiteTenuringChangedGroup);
       if (got_marked) marked = true;
     }
     cur = casted->weak_next();
   }
-  if (marked) Deoptimizer::DeoptimizeMarkedCode(isolate_);
+  if (marked) isolate_->stack_guard()->DeoptMarkedCode();
 }
 
 
 void Heap::EvaluateOldSpaceLocalPretenuring(
     uint64_t size_of_objects_before_gc) {
   uint64_t size_of_objects_after_gc = SizeOfObjects();
   double old_generation_survival_rate =
       (static_cast<double>(size_of_objects_after_gc) * 100) /
           static_cast<double>(size_of_objects_before_gc);
 
@@ skipping 5785 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