Age inline caches after context disposal.

src/mark-compact.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 1031 matching lines @@
     heap->mark_compact_collector()->RecordRelocSlot(rinfo, object);
     MarkBit mark = Marking::MarkBitFrom(object);
     heap->mark_compact_collector()->MarkObject(object, mark);
   }
 
   static inline void VisitCodeTarget(Heap* heap, RelocInfo* rinfo) {
     ASSERT(RelocInfo::IsCodeTarget(rinfo->rmode()));
     Code* target = Code::GetCodeFromTargetAddress(rinfo->target_address());
     if (FLAG_cleanup_code_caches_at_gc && target->is_inline_cache_stub()
         && (target->ic_state() == MEGAMORPHIC ||
-            heap->mark_compact_collector()->flush_monomorphic_ics_)) {
+            heap->mark_compact_collector()->flush_monomorphic_ics_ ||
+            target->context_disposed_count() !=
+            heap->global_context_disposed_count())) {
       IC::Clear(rinfo->pc());

[Vyacheslav Egorov (Chromium), 2012/03/22 14:47:05]

I would expect we reset counter to be equal to
heap_->global_context_disposed_count() otherwise we would flush again on the
next GC even if the context was not disposed.

surely reset should not happen in the place but at the place which calls
visitor.

[ulan, 2012/03/23 10:47:13]

As discussed offline, this should work because we flush stub caches on GC

       target = Code::GetCodeFromTargetAddress(rinfo->target_address());
     }
     MarkBit code_mark = Marking::MarkBitFrom(target);
     heap->mark_compact_collector()->MarkObject(target, code_mark);
     heap->mark_compact_collector()->RecordRelocSlot(rinfo, target);
   }
 
   static inline void VisitDebugTarget(Heap* heap, RelocInfo* rinfo) {
     ASSERT((RelocInfo::IsJSReturn(rinfo->rmode()) &&
             rinfo->IsPatchedReturnSequence()) ||
@@ skipping 334 matching lines @@
   }
 
 
   static void VisitSharedFunctionInfoAndFlushCodeGeneric(
       Map* map, HeapObject* object, bool known_flush_code_candidate) {
     Heap* heap = map->GetHeap();
     SharedFunctionInfo* shared = reinterpret_cast<SharedFunctionInfo*>(object);
 
     if (shared->IsInobjectSlackTrackingInProgress()) shared->DetachInitialMap();
 
+    if (shared->context_disposed_count() !=
+        heap->global_context_disposed_count()) {
+      shared->set_context_disposed_count(heap->global_context_disposed_count());

[Vyacheslav Egorov (Chromium), 2012/03/22 14:47:05]

I suppose this piece of code is here to prevent optimizer from optimizing to
early. 

There are heuristics that try to decide whether function should be optimized
based on the amount of initialized ICs.

Why do we need to reset opt_count separately? I would expect initialized ICs
heuristic to cover it.

Also we were discussing with Jakob if we should move opt_count to the code
object itself. This would allow to easily adjust it when we clear ICs instead of
doing special (spooky) handling of shared function info.

[ulan, 2012/03/23 10:47:13]

This is to prevent us from marking a function as non-optimizable after N page
reloads when the opt_count reaches kMaxOptCount.

I will submit this part as a separate CL.

On 2012/03/22 14:47:05, Vyacheslav Egorov wrote:

+      shared->set_opt_count(0);
+    }
+
     if (!known_flush_code_candidate) {
       known_flush_code_candidate = IsFlushable(heap, shared);
       if (known_flush_code_candidate) {
         heap->mark_compact_collector()->code_flusher()->AddCandidate(shared);
       }
     }
 
     VisitSharedFunctionInfoFields(heap, object, known_flush_code_candidate);
   }
 
@@ skipping 2712 matching lines @@
   while (buffer != NULL) {
     SlotsBuffer* next_buffer = buffer->next();
     DeallocateBuffer(buffer);
     buffer = next_buffer;
   }
   *buffer_address = NULL;
 }
 
 
 } }  // namespace v8::internal