Re-optimize faster after making a pretenuring decision.

src/objects.h

Index: src/objects.h
diff --git a/src/objects.h b/src/objects.h
index fa399000b49f95cdf7e0f3314fb3109b7e116d16..7ee178b4daa0ffb6cbf7937de23002fe1320b8b0 100644
--- a/src/objects.h
+++ b/src/objects.h
@@ -5461,6 +5461,9 @@ class Code: public HeapObject {
   inline bool marked_for_deoptimization();
   inline void set_marked_for_deoptimization(bool flag);
 
+  inline bool marked_for_instant_optimization();
+  inline void set_marked_for_instant_optimization(bool flag);
+
   // [constant_pool]: The constant pool for this function.
   inline ConstantPoolArray* constant_pool();
   inline void set_constant_pool(Object* constant_pool);
@@ -5635,6 +5638,10 @@ class Code: public HeapObject {
   void PrintDeoptLocation(FILE* out, int bailout_id);
   bool CanDeoptAt(Address pc);
 
+  void GetICCounts(int* ic_with_type_info_count,
+                   int* ic_total_count,
+                   int* percentage);
+
 #ifdef VERIFY_HEAP
   void VerifyEmbeddedObjectsDependency();
 #endif
@@ -5718,11 +5725,14 @@ class Code: public HeapObject {
   static const int kInvalidatedWeakStubFirstBit =
       kWeakStubFirstBit + kWeakStubBitCount;
   static const int kInvalidatedWeakStubBitCount = 1;
+  static const int kMarkedForInstantOptimizationFirstBit =
+      kInvalidatedWeakStubFirstBit + kInvalidatedWeakStubBitCount + 1;
+  static const int kMarkedForInstantOptimizationBitCount = 1;

[titzer, 2014/05/12 12:05:24]

This bit is just carrying stuff through the deoptimizer, to a place that I don't
think it belongs. I think you want to gather the list of functions to reoptimize
outside of the deoptimization infrastructure and then process them there.

[Hannes Payer (out of office), 2014/05/12 16:31:19]

This is problematic on so many levels:
1) For allocation sites when we set the stack guard for deoptimization at gc
time we just have the dependent code i.e. the code objects. There is no mapping
from code to JSFunction (and friends). Getting the JSFunction would require us
to go over all  JSFunctions and find the given code objects.
2) If we have that, we could just mark the JSFunction for optimization. One
problem with that approach is that an active activation on the stack would never
get replaced.
3) If we want a list of functions, this list would have to be weak. I do not
want to add another weak list.

WDYT?

 
   STATIC_ASSERT(kStackSlotsFirstBit + kStackSlotsBitCount <= 32);
   STATIC_ASSERT(kHasFunctionCacheFirstBit + kHasFunctionCacheBitCount <= 32);
-  STATIC_ASSERT(kInvalidatedWeakStubFirstBit +
-                kInvalidatedWeakStubBitCount <= 32);
+  STATIC_ASSERT(kMarkedForInstantOptimizationFirstBit +
+                kMarkedForInstantOptimizationBitCount <= 32);
 
   class StackSlotsField: public BitField<int,
       kStackSlotsFirstBit, kStackSlotsBitCount> {};  // NOLINT
@@ -5737,6 +5747,9 @@ class Code: public HeapObject {
   class InvalidatedWeakStubField: public BitField<bool,
       kInvalidatedWeakStubFirstBit,
       kInvalidatedWeakStubBitCount> {};  // NOLINT
+  class MarkedForInstantOptimizationField: public BitField<bool,
+      kMarkedForInstantOptimizationFirstBit,
+      kMarkedForInstantOptimizationBitCount> {};  // NOLINT
 
   // KindSpecificFlags2 layout (ALL)
   static const int kIsCrankshaftedBit = 0;
@@ -5881,7 +5894,9 @@ class DependentCode: public FixedArray {
                                     DependentCode::DependencyGroup group);
 
   bool MarkCodeForDeoptimization(Isolate* isolate,
-                                 DependentCode::DependencyGroup group);
+                                 DependentCode::DependencyGroup group,
+                                 bool instant_optimize = false);
+
   void AddToDependentICList(Handle<Code> stub);
 
   // The following low-level accessors should only be used by this class