Optimize functions on a second thread.

src/compiler.h

 // 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 21 matching lines @@
 #include "ast.h"
 #include "zone.h"
 
 namespace v8 {
 namespace internal {
 
 class ScriptDataImpl;
 
 // CompilationInfo encapsulates some information known at compile time.  It
 // is constructed based on the resources available at compile-time.
-class CompilationInfo BASE_EMBEDDED {
+class CompilationInfo {
  public:
   CompilationInfo(Handle<Script> script, Zone* zone);
   CompilationInfo(Handle<SharedFunctionInfo> shared_info, Zone* zone);
   CompilationInfo(Handle<JSFunction> closure, Zone* zone);
 
   virtual ~CompilationInfo();
 
   Isolate* isolate() {
     ASSERT(Isolate::Current() == isolate_);
     return isolate_;
@@ skipping 120 matching lines @@
 
   // Disable all optimization attempts of this info for the rest of the
   // current compilation pipeline.
   void AbortOptimization();
 
   void set_deferred_handles(DeferredHandles* deferred_handles) {
     ASSERT(deferred_handles_ == NULL);
     deferred_handles_ = deferred_handles;
   }
 
+  void SaveHandles() {
+    SaveHandle(&closure_);
+    SaveHandle(&shared_info_);
+    SaveHandle(&calling_context_);
+    SaveHandle(&script_);
+  }
+
  private:
   Isolate* isolate_;
 
   // Compilation mode.
   // BASE is generated by the full codegen, optionally prepared for bailouts.
   // OPTIMIZE is optimized code generated by the Hydrogen-based backend.
   // NONOPT is generated by the full codegen and is not prepared for
   //   recompilation/bailouts.  These functions are never recompiled.
   enum Mode {
     BASE,
@@ skipping 68 matching lines @@
   // Compilation mode flag and whether deoptimization is allowed.
   Mode mode_;
   int osr_ast_id_;
 
   // The zone from which the compilation pipeline working on this
   // CompilationInfo allocates.
   Zone* zone_;
 
   DeferredHandles* deferred_handles_;
 
+  template<typename T>
+  void SaveHandle(Handle<T> *object) {
+    if (!object->is_null()) {
+      Handle<T> handle(*(*object));
+      *object = handle;
+    }
+  }
+
   DISALLOW_COPY_AND_ASSIGN(CompilationInfo);
 };
 
 
 // Exactly like a CompilationInfo, except also creates and enters a
 // Zone on construction and deallocates it on exit.
 class CompilationInfoWithZone: public CompilationInfo {
  public:
   explicit CompilationInfoWithZone(Handle<Script> script)
       : CompilationInfo(script, &zone_),
@@ skipping 45 matching lines @@
  public:
   explicit OptimizingCompiler(CompilationInfo* info)
       : info_(info),
         oracle_(NULL),
         graph_builder_(NULL),
         graph_(NULL),
         chunk_(NULL),
         time_taken_to_create_graph_(0),
         time_taken_to_optimize_(0),
         time_taken_to_codegen_(0),
-        last_status_(FAILED) { }
+        last_status_(FAILED),
+        abort_optimization_(false) { }
 
   enum Status {
     FAILED, BAILED_OUT, SUCCEEDED
   };
 
   MUST_USE_RESULT Status CreateGraph();
   MUST_USE_RESULT Status OptimizeGraph();
   MUST_USE_RESULT Status GenerateAndInstallCode();
 
   Status last_status() const { return last_status_; }
   CompilationInfo* info() const { return info_; }
 
+  void DoPendingAbort() {
+    if (abort_optimization_) {
+      info_->AbortOptimization();
+      info_->shared_info()->DisableOptimization();
+    }
+  }
+
  private:
   CompilationInfo* info_;
   TypeFeedbackOracle* oracle_;
   HGraphBuilder* graph_builder_;
   HGraph* graph_;
   LChunk* chunk_;
   int64_t time_taken_to_create_graph_;
   int64_t time_taken_to_optimize_;
   int64_t time_taken_to_codegen_;
   Status last_status_;
+  bool abort_optimization_;

[Yang, 2012/07/19 15:56:01]

imo checking for BAILED_OUT status after the parallelizable phase is sufficient
to determine whether to DoPendingAbort. Also please add assertions to
AbortOptimization and DeferAbortOptimization that we are in the expected thread
(if FLAG_parallel_recompilation).

[sanjoy, 2012/07/19 16:25:36]

Done.

 
   MUST_USE_RESULT Status SetLastStatus(Status status) {
     last_status_ = status;
     return last_status_;
   }
   void RecordOptimizationStats();
   MUST_USE_RESULT Status AbortOptimization() {
     info_->AbortOptimization();
     info_->shared_info()->DisableOptimization();
     return SetLastStatus(BAILED_OUT);
   }
+  MUST_USE_RESULT Status DeferAbortOptimization() {
+    abort_optimization_ = true;
+    return SetLastStatus(BAILED_OUT);
+  }
 
   struct Timer {
     Timer(OptimizingCompiler* compiler, int64_t* location)
         : compiler_(compiler),
           start_(OS::Ticks()),
           location_(location) { }
 
     ~Timer() {
       *location_ += (OS::Ticks() - start_);
     }
@@ skipping 45 matching lines @@
   static Handle<SharedFunctionInfo> CompileEval(Handle<String> source,
                                                 Handle<Context> context,
                                                 bool is_global,
                                                 LanguageMode language_mode,
                                                 int scope_position);
 
   // Compile from function info (used for lazy compilation). Returns true on
   // success and false if the compilation resulted in a stack overflow.
   static bool CompileLazy(CompilationInfo* info);
 
+  static void RecompileParallel(Handle<JSFunction> function);
+
   // Compile a shared function info object (the function is possibly lazily
   // compiled).
   static Handle<SharedFunctionInfo> BuildFunctionInfo(FunctionLiteral* node,
                                                       Handle<Script> script);
 
   // Set the function info for a newly compiled function.
   static void SetFunctionInfo(Handle<SharedFunctionInfo> function_info,
                               FunctionLiteral* lit,
                               bool is_toplevel,
                               Handle<Script> script);
 
+  static void InstallOptimizedCode(OptimizingCompiler* info);
+
 #ifdef ENABLE_DEBUGGER_SUPPORT
   static bool MakeCodeForLiveEdit(CompilationInfo* info);
 #endif
 
   static void RecordFunctionCompilation(Logger::LogEventsAndTags tag,
                                         CompilationInfo* info,
                                         Handle<SharedFunctionInfo> shared);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_COMPILER_H_