Re-optimize faster after making a pretenuring decision.

src/objects.cc

 // Copyright 2013 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 9889 matching lines @@
     return true;
   }
   if (filter[filter.length() - 1] == '*' &&
       name->IsUtf8EqualTo(filter.SubVector(0, filter.length() - 1), true)) {
     return true;
   }
   return false;
 }
 
 
+void JSFunction::Optimize(const char* reason) {

[titzer, 2014/02/18 09:24:48]

Looks like you copied this right out of the compiler, TODOs and all. Please put
it back.

[Hannes Payer (out of office), 2014/05/12 09:37:08]

This code was part of runtime-profiler. It should not be part of the
runtime-profiler since it operates on the JSFunction. Moved it to the compiler.
Done.

+  ASSERT(IsOptimizable());
+
+  if (FLAG_trace_opt && PassesFilter(FLAG_hydrogen_filter)) {
+    PrintF("[marking ");
+    ShortPrint();
+    PrintF(" for recompilation, reason: %s", reason);
+    if (FLAG_type_info_threshold > 0) {
+      int typeinfo, total, percentage;
+      Code* code = shared()->code();
+      code->GetICCounts(&typeinfo, &total, &percentage);
+      PrintF(", ICs with typeinfo: %d/%d (%d%%)", typeinfo, total, percentage);
+    }
+    PrintF("]\n");
+  }
+
+  Isolate* isolate = GetIsolate();
+
+  if (isolate->concurrent_recompilation_enabled() &&
+      !isolate->bootstrapper()->IsActive()) {
+    if (isolate->concurrent_osr_enabled() &&
+        isolate->optimizing_compiler_thread()->IsQueuedForOSR(this)) {
+      // Do not attempt regular recompilation if we already queued this for OSR.
+      // TODO(yangguo): This is necessary so that we don't install optimized
+      // code on a function that is already optimized, since OSR and regular
+      // recompilation race.  This goes away as soon as OSR becomes one-shot.
+      return;
+    }
+    ASSERT(!IsInOptimizationQueue());
+    MarkForConcurrentOptimization();
+  } else {
+    // The next call to the function will trigger optimization.
+    MarkForOptimization();
+  }
+}
+
+
 MaybeObject* Oddball::Initialize(Heap* heap,
                                  const char* to_string,
                                  Object* to_number,
                                  byte kind) {
   String* internalized_to_string;
   { MaybeObject* maybe_string =
       heap->InternalizeUtf8String(
           CStrVector(to_string));
     if (!maybe_string->To(&internalized_to_string)) return maybe_string;
   }
@@ skipping 1341 matching lines @@
                             GetElementsKind(), new_elements);
   }
 
   if (IsJSArray()) {
     JSArray::cast(this)->set_length(Smi::FromInt(length));
   }
   return new_elements;
 }
 
 
+void Code::GetICCounts(int* ic_with_type_info_count,
+                       int* ic_total_count,
+                       int* percentage) {
+  *ic_total_count = 0;
+  *ic_with_type_info_count = 0;
+  Object* raw_info = type_feedback_info();
+  if (raw_info->IsTypeFeedbackInfo()) {
+    TypeFeedbackInfo* info = TypeFeedbackInfo::cast(raw_info);
+    *ic_with_type_info_count = info->ic_with_type_info_count();
+    *ic_total_count = info->ic_total_count();
+  }
+  *percentage = *ic_total_count > 0
+      ? 100 * *ic_with_type_info_count / *ic_total_count
+      : 100;
+}
+
+
 bool Code::IsWeakEmbeddedObject(Kind kind, Object* object) {
   if (kind != Code::OPTIMIZED_FUNCTION) return false;
 
   if (object->IsMap()) {
     return Map::cast(object)->CanTransition() &&
            FLAG_collect_maps &&
            FLAG_weak_embedded_maps_in_optimized_code;
   }
 
   if (object->IsJSObject() ||
@@ skipping 465 matching lines @@
   int end = starts.at(group + 1);
   for (int i = start; i < end; i++) {
     if (object_at(i) == code) return true;
   }
   return false;
 }
 
 
 bool DependentCode::MarkCodeForDeoptimization(
     Isolate* isolate,
-    DependentCode::DependencyGroup group) {
+    DependentCode::DependencyGroup group,
+    bool reoptimize) {
   DisallowHeapAllocation no_allocation_scope;
   DependentCode::GroupStartIndexes starts(this);
   int start = starts.at(group);
   int end = starts.at(group + 1);
   int code_entries = starts.number_of_entries();
   if (start == end) return false;
 
   // Mark all the code that needs to be deoptimized.
   bool marked = false;
   for (int i = start; i < end; i++) {
     if (is_code_at(i)) {
       Code* code = code_at(i);
       if (!code->marked_for_deoptimization()) {
         code->set_marked_for_deoptimization(true);
         marked = true;
+        if (reoptimize) code->set_marked_for_reoptimization(true);
       }
     } else {
       CompilationInfo* info = compilation_info_at(i);
       info->AbortDueToDependencyChange();
     }
   }
   // Compact the array by moving all subsequent groups to fill in the new holes.
   for (int src = end, dst = start; src < code_entries; src++, dst++) {
     copy(src, dst);
   }
@@ skipping 950 matching lines @@
 }
 
 
 void JSObject::TransitionElementsKind(Handle<JSObject> object,
                                       ElementsKind to_kind) {
   CALL_HEAP_FUNCTION_VOID(object->GetIsolate(),
                           object->TransitionElementsKind(to_kind));
 }
 
 
-const double AllocationSite::kPretenureRatio = 0.60;
+const double AllocationSite::kPretenureRatio = 0.50;
 
 
 void AllocationSite::ResetPretenureDecision() {
   set_pretenure_decision(kUndecided);
   set_memento_found_count(0);
   set_memento_create_count(0);
 }
 
 
 PretenureFlag AllocationSite::GetPretenureMode() {
@@ skipping 3744 matching lines @@
 #define ERROR_MESSAGES_TEXTS(C, T) T,
   static const char* error_messages_[] = {
       ERROR_MESSAGES_LIST(ERROR_MESSAGES_TEXTS)
   };
 #undef ERROR_MESSAGES_TEXTS
   return error_messages_[reason];
 }
 
 
 } }  // namespace v8::internal