Reland "Optimize function across closures."

R=mvstanton@chromium.org

Review URL: https://codereview.chromium.org/703603003

Cr-Commit-Position: refs/heads/master@{#25142}
git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@25142 ce2b1a6d-e550-0410-aec6-3dcde31c8c00

diff --git a/src/code-stubs-hydrogen.cc b/src/code-stubs-hydrogen.cc
index 5579e054cdcdbe74b44e26efd8a9dc8b12ec3306..af4ee50f977e9df76c950c3d9bd4209cda1b0517 100644 (file)
--- a/src/code-stubs-hydrogen.cc
+++ b/src/code-stubs-hydrogen.cc
@@ -1549,47 +1549,67 @@ HValue* CodeStubGraphBuilder<FastNewClosureStub>::BuildCodeStub() {
 
   AddIncrementCounter(counters->fast_new_closure_total());
 
-  // Create a new closure from the given function info in new space
-  HValue* size = Add<HConstant>(JSFunction::kSize);
-  HInstruction* js_function = Add<HAllocate>(size, HType::JSObject(),
-                                             NOT_TENURED, JS_FUNCTION_TYPE);
-
-  int map_index = Context::FunctionMapIndex(casted_stub()->strict_mode(),
-                                            casted_stub()->kind());
-
-  // Compute the function map in the current native context and set that
-  // as the map of the allocated object.
-  HInstruction* native_context = BuildGetNativeContext();
-  HInstruction* map_slot_value = Add<HLoadNamedField>(
-      native_context, static_cast<HValue*>(NULL),
-      HObjectAccess::ForContextSlot(map_index));
-  Add<HStoreNamedField>(js_function, HObjectAccess::ForMap(), map_slot_value);
-
-  // Initialize the rest of the function.
-  Add<HStoreNamedField>(js_function, HObjectAccess::ForPropertiesPointer(),
-                        empty_fixed_array);
-  Add<HStoreNamedField>(js_function, HObjectAccess::ForElementsPointer(),
-                        empty_fixed_array);
-  Add<HStoreNamedField>(js_function, HObjectAccess::ForLiteralsPointer(),
-                        empty_fixed_array);
-  Add<HStoreNamedField>(js_function, HObjectAccess::ForPrototypeOrInitialMap(),
-                        graph()->GetConstantHole());
-  Add<HStoreNamedField>(js_function,
-                        HObjectAccess::ForSharedFunctionInfoPointer(),
-                        shared_info);
-  Add<HStoreNamedField>(js_function, HObjectAccess::ForFunctionContextPointer(),
-                        context());
-
-  // Initialize the code pointer in the function to be the one
-  // found in the shared function info object.
-  // But first check if there is an optimized version for our context.
-  if (FLAG_cache_optimized_code) {
-    BuildInstallFromOptimizedCodeMap(js_function, shared_info, native_context);
-  } else {
-    BuildInstallCode(js_function, shared_info);
+  IfBuilder optimize_now(this);
+  HInstruction* compile_hint = Add<HLoadNamedField>(
+      shared_info, static_cast<HValue*>(NULL), HObjectAccess::ForCompileHint());
+  HValue* hint_mask = Add<HConstant>(
+      static_cast<int32_t>(1 << SharedFunctionInfo::kOptimizeNextClosure));
+  HInstruction* optimize =
+      AddUncasted<HBitwise>(Token::BIT_AND, compile_hint, hint_mask);
+  optimize_now.If<HCompareNumericAndBranch>(optimize, hint_mask, Token::EQ);
+  optimize_now.Then();
+  {
+    Add<HPushArguments>(context(), shared_info, graph()->GetConstantFalse());
+    Push(Add<HCallRuntime>(isolate()->factory()->empty_string(),
+                           Runtime::FunctionForId(Runtime::kNewClosure), 3));
   }
-
-  return js_function;
+  optimize_now.Else();
+  {
+    // Create a new closure from the given function info in new space
+    HValue* size = Add<HConstant>(JSFunction::kSize);
+    HInstruction* js_function =
+        Add<HAllocate>(size, HType::JSObject(), NOT_TENURED, JS_FUNCTION_TYPE);
+
+    int map_index = Context::FunctionMapIndex(casted_stub()->strict_mode(),
+                                              casted_stub()->kind());
+
+    // Compute the function map in the current native context and set that
+    // as the map of the allocated object.
+    HInstruction* native_context = BuildGetNativeContext();
+    HInstruction* map_slot_value =
+        Add<HLoadNamedField>(native_context, static_cast<HValue*>(NULL),
+                             HObjectAccess::ForContextSlot(map_index));
+    Add<HStoreNamedField>(js_function, HObjectAccess::ForMap(), map_slot_value);
+
+    // Initialize the rest of the function.
+    Add<HStoreNamedField>(js_function, HObjectAccess::ForPropertiesPointer(),
+                          empty_fixed_array);
+    Add<HStoreNamedField>(js_function, HObjectAccess::ForElementsPointer(),
+                          empty_fixed_array);
+    Add<HStoreNamedField>(js_function, HObjectAccess::ForLiteralsPointer(),
+                          empty_fixed_array);
+    Add<HStoreNamedField>(js_function,
+                          HObjectAccess::ForPrototypeOrInitialMap(),
+                          graph()->GetConstantHole());
+    Add<HStoreNamedField>(js_function,
+                          HObjectAccess::ForSharedFunctionInfoPointer(),
+                          shared_info);
+    Add<HStoreNamedField>(
+        js_function, HObjectAccess::ForFunctionContextPointer(), context());
+
+    // Initialize the code pointer in the function to be the one
+    // found in the shared function info object.
+    // But first check if there is an optimized version for our context.
+    if (FLAG_cache_optimized_code) {
+      BuildInstallFromOptimizedCodeMap(js_function, shared_info,
+                                       native_context);
+    } else {
+      BuildInstallCode(js_function, shared_info);
+    }
+    Push(js_function);
+  }
+  optimize_now.End();
+  return Pop();
 }
 
 

diff --git a/src/compiler.cc b/src/compiler.cc
index ba5f3fd56ea511d39162be59ff77f22f85cc9c22..2349640029056a4070f05b297e18c4890eed2918 100644 (file)
--- a/src/compiler.cc
+++ b/src/compiler.cc
@@ -1361,6 +1361,7 @@ MaybeHandle<Code> Compiler::GetOptimizedCode(Handle<JSFunction> function,
   PostponeInterruptsScope postpone(isolate);
 
   Handle<SharedFunctionInfo> shared = info->shared_info();
+  shared->set_optimize_next_closure(false);
   if (shared->code()->kind() != Code::FUNCTION ||
       ScopeInfo::Empty(isolate) == shared->scope_info()) {
     // The function was never compiled. Compile it unoptimized first.

diff --git a/src/factory.cc b/src/factory.cc
index 72974a317c18646800178b4c10340a85b444afcf..c500212b0a708c494ca10c35212458266f95fe2b 100644 (file)
--- a/src/factory.cc
+++ b/src/factory.cc
@@ -1358,6 +1358,14 @@ Handle<JSObject> Factory::NewFunctionPrototype(Handle<JSFunction> function) {
 }
 
 
+static bool ShouldOptimizeNewClosure(Isolate* isolate,
+                                     Handle<SharedFunctionInfo> info) {
+  return isolate->use_crankshaft() && !info->is_toplevel() &&
+         info->is_compiled() && info->allows_lazy_compilation() &&
+         !info->optimization_disabled() && !isolate->DebuggerHasBreakPoints();
+}
+
+
 Handle<JSFunction> Factory::NewFunctionFromSharedFunctionInfo(
     Handle<SharedFunctionInfo> info,
     Handle<Context> context,
@@ -1395,14 +1403,11 @@ Handle<JSFunction> Factory::NewFunctionFromSharedFunctionInfo(
     return result;
   }
 
-  if (isolate()->use_crankshaft() &&
-      FLAG_always_opt &&
-      result->is_compiled() &&
-      !info->is_toplevel() &&
-      info->allows_lazy_compilation() &&
-      !info->optimization_disabled() &&
-      !isolate()->DebuggerHasBreakPoints()) {
+  if (FLAG_always_opt && ShouldOptimizeNewClosure(isolate(), info)) {
     result->MarkForOptimization();
+  } else if (info->optimize_next_closure() &&
+             ShouldOptimizeNewClosure(isolate(), info)) {
+    result->AttemptConcurrentOptimization();
   }
   return result;
 }

diff --git a/src/hydrogen-instructions.h b/src/hydrogen-instructions.h
index 810a2fdd520d26e0d636e97ee470681210f293ac..f590381f9effe34037a3e6eec3661f03fc9c6236 100644 (file)
--- a/src/hydrogen-instructions.h
+++ b/src/hydrogen-instructions.h
@@ -6121,6 +6121,11 @@ class HObjectAccess FINAL {
                          SharedFunctionInfo::kOptimizedCodeMapOffset);
   }
 
+  static HObjectAccess ForCompileHint() {
+    return HObjectAccess(kInobject, SharedFunctionInfo::kCompilerHintsOffset,
+                         Representation::Smi());
+  }
+
   static HObjectAccess ForFunctionContextPointer() {
     return HObjectAccess(kInobject, JSFunction::kContextOffset);
   }

diff --git a/src/objects-inl.h b/src/objects-inl.h
index 85584c43e400f44eabb37ac66f96470efbbb72c2..ff81d9d6b074775248865b3079e7d79746623068 100644 (file)
--- a/src/objects-inl.h
+++ b/src/objects-inl.h
@@ -5516,9 +5516,9 @@ BOOL_ACCESSORS(SharedFunctionInfo, start_position_and_type, is_expression,
 BOOL_ACCESSORS(SharedFunctionInfo, start_position_and_type, is_toplevel,
                kIsTopLevelBit)
 
-BOOL_ACCESSORS(SharedFunctionInfo,
-               compiler_hints,
-               allows_lazy_compilation,
+BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, optimize_next_closure,
+               kOptimizeNextClosure)
+BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, allows_lazy_compilation,
                kAllowLazyCompilation)
 BOOL_ACCESSORS(SharedFunctionInfo,
                compiler_hints,

diff --git a/src/objects.cc b/src/objects.cc
index 258390c4d5cb2b62ff079e31d90de3e5595b6fcb..6e68c365bb5aaa33ee6975aa39b825221dd300b3 100644 (file)
--- a/src/objects.cc
+++ b/src/objects.cc
@@ -9204,12 +9204,27 @@ void JSFunction::MarkForOptimization() {
 }
 
 
-void JSFunction::MarkForConcurrentOptimization() {
-  DCHECK(is_compiled() || GetIsolate()->DebuggerHasBreakPoints());
+void JSFunction::AttemptConcurrentOptimization() {
+  Isolate* isolate = GetIsolate();
+  if (!isolate->concurrent_recompilation_enabled() ||
+      isolate->bootstrapper()->IsActive()) {
+    MarkForOptimization();
+    return;
+  }
+  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;
+  }
+  DCHECK(!IsInOptimizationQueue());
+  DCHECK(is_compiled() || isolate->DebuggerHasBreakPoints());
   DCHECK(!IsOptimized());
   DCHECK(shared()->allows_lazy_compilation() || code()->optimizable());
   DCHECK(!shared()->is_generator());
-  DCHECK(GetIsolate()->concurrent_recompilation_enabled());
+  DCHECK(isolate->concurrent_recompilation_enabled());
   if (FLAG_trace_concurrent_recompilation) {
     PrintF("  ** Marking ");
     ShortPrint();

diff --git a/src/objects.h b/src/objects.h
index 9333e9edc4003e2dd7a9f4bb7884eb6645ed2d6e..d4120054153194e591dd378737b0d00934ecfc8a 100644 (file)
--- a/src/objects.h
+++ b/src/objects.h
@@ -6787,6 +6787,8 @@ class SharedFunctionInfo: public HeapObject {
   inline int ic_age();
   inline void set_ic_age(int age);
 
+  DECL_BOOLEAN_ACCESSORS(optimize_next_closure)
+
   // Indicates if this function can be lazy compiled.
   // This is used to determine if we can safely flush code from a function
   // when doing GC if we expect that the function will no longer be used.
@@ -7077,6 +7079,7 @@ class SharedFunctionInfo: public HeapObject {
   enum CompilerHints {
     kAllowLazyCompilation,
     kAllowLazyCompilationWithoutContext,
+    kOptimizeNextClosure,
     kOptimizationDisabled,
     kStrictModeFunction,
     kUsesArguments,
@@ -7302,7 +7305,7 @@ class JSFunction: public JSObject {
   // Mark this function for lazy recompilation. The function will be
   // recompiled the next time it is executed.
   void MarkForOptimization();
-  void MarkForConcurrentOptimization();
+  void AttemptConcurrentOptimization();
   void MarkInOptimizationQueue();
 
   // Tells whether or not the function is already marked for lazy

diff --git a/src/runtime-profiler.cc b/src/runtime-profiler.cc
index f786846b365ba1cc43ac04a4803dbeef8c803a92..7330262e234c2ee1ea65465a3ffb7f81618bb288 100644 (file)
--- a/src/runtime-profiler.cc
+++ b/src/runtime-profiler.cc
@@ -106,23 +106,8 @@ void RuntimeProfiler::Optimize(JSFunction* function, const char* reason) {
     PrintF("]\n");
   }
 
-
-  if (isolate_->concurrent_recompilation_enabled() &&
-      !isolate_->bootstrapper()->IsActive()) {
-    if (isolate_->concurrent_osr_enabled() &&
-        isolate_->optimizing_compiler_thread()->IsQueuedForOSR(function)) {
-      // 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;
-    }
-    DCHECK(!function->IsInOptimizationQueue());
-    function->MarkForConcurrentOptimization();
-  } else {
-    // The next call to the function will trigger optimization.
-    function->MarkForOptimization();
-  }
+  function->shared()->set_optimize_next_closure(true);
+  function->AttemptConcurrentOptimization();
 }
 
 

diff --git a/src/runtime/runtime-test.cc b/src/runtime/runtime-test.cc
index 49959844bfd73ddb6c60a111292ce338550b0a76..0a7221344baebf3b6f8c57824aaf3446af301bda 100644 (file)
--- a/src/runtime/runtime-test.cc
+++ b/src/runtime/runtime-test.cc
@@ -75,7 +75,7 @@ RUNTIME_FUNCTION(Runtime_OptimizeFunctionOnNextCall) {
           *function, Code::kMaxLoopNestingMarker);
     } else if (type->IsOneByteEqualTo(STATIC_CHAR_VECTOR("concurrent")) &&
                isolate->concurrent_recompilation_enabled()) {
-      function->MarkForConcurrentOptimization();
+      function->AttemptConcurrentOptimization();
     }
   }