Introduce an OptimizingCompiler class, responsible for maintaining the state needed to run Cranksha…

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 294 matching lines @@
   ~CompilationHandleScope() {
     info_->set_deferred_handles(deferred_.Detach());
   }
 
  private:
   DeferredHandleScope deferred_;
   CompilationInfo* info_;
 };
 
 
+class HGraph;
+class HGraphBuilder;
+class LChunk;
+
+// A helper class that calls the three phases in Crankshaft and keeps

[danno, 2012/07/16 12:19:09]

nit: compilation phases
maybe you should list what they are?

[sanjoy, 2012/07/16 13:46:46]

Done.

+// track of its state.
+class OptimizingCompiler: public ZoneObject {
+ public:
+  explicit OptimizingCompiler(CompilationInfo* info)
+      : info_(info),
+        oracle_(NULL),
+        graph_builder_(NULL),
+        graph_(NULL),
+        chunk_(NULL),
+        total_time_taken_(0),
+        is_inline_bailout_(false),
+        last_status_(FAILED) { }
+
+  enum Status {
+    FAILED, BAILED_OUT, SUCCEEDED
+  };
+
+  Status CreateHGraph() {

[danno, 2012/07/16 12:19:09]

Just call this CreateGraph()

[sanjoy, 2012/07/16 13:46:46]

Done.

+    last_status_ = InnerCreateHGraph();
+    return last_status_;
+  }
+  Status OptimizeHGraph() {

[danno, 2012/07/16 12:19:09]

OptimizeGraph

[sanjoy, 2012/07/16 13:46:46]

Done.

+    last_status_ = InnerOptimizeHGraph();
+    return last_status_;
+  }
+  Status GenerateAndInstallCode() {
+    last_status_ = InnerGenerateAndInstallCode();
+    if (last_status_ == SUCCEEDED) RecordOptimizationStats();
+    return last_status_;
+  }
+
+  Status last_status() const { return last_status_; }
+  CompilationInfo* info() const { return info_; }
+
+ private:
+  CompilationInfo* info_;
+  TypeFeedbackOracle* oracle_;
+  HGraphBuilder* graph_builder_;
+  HGraph* graph_;
+  LChunk* chunk_;
+  int64_t total_time_taken_;
+  bool is_inline_bailout_;
+  Status last_status_;
+
+  Status InnerCreateHGraph();

[danno, 2012/07/16 12:19:09]

I don't understand why you need these "Inner" methods. Why not just implement
directly?

[sanjoy, 2012/07/16 13:46:46]

I wanted to have a central place to set last_status_.  I've now added a
SetLastStatus method that also returns the set status so that I can do `return
SetLastStatus(FAILED'.

+  Status InnerOptimizeHGraph();
+  Status InnerGenerateAndInstallCode();
+
+  void RecordOptimizationStats();
+
+  void AbortCrankshaft() {
+    info_->AbortOptimization();
+    if (!is_inline_bailout_) {
+      // Mark the shared code as unoptimizable unless it was an inlined
+      // function that bailed out.
+      info_->shared_info()->DisableOptimization();
+    }
+  }
+
+  struct Timer {
+    explicit Timer(OptimizingCompiler* compiler)
+        : compiler_(compiler),
+          start_(OS::Ticks()) { }
+
+    ~Timer() {
+      compiler_->total_time_taken_ += (OS::Ticks() - start_);

[danno, 2012/07/16 12:19:09]

Perhaps divide this up into three counters, one for each phase so that we can
track the total time taken plus for each phase?

[sanjoy, 2012/07/16 13:46:46]

Done.

+    }
+
+    OptimizingCompiler* compiler_;
+    int64_t start_;
+  };
+};
+
+
 // The V8 compiler
 //
 // General strategy: Source code is translated into an anonymous function w/o
 // parameters which then can be executed. If the source code contains other
 // functions, they will be compiled and allocated as part of the compilation
 // of the source code.
 
 // Please note this interface returns shared function infos.  This means you
 // need to call Factory::NewFunctionFromSharedFunctionInfo before you have a
 // real function with a context.
@@ skipping 51 matching lines @@
 
   static void RecordFunctionCompilation(Logger::LogEventsAndTags tag,
                                         CompilationInfo* info,
                                         Handle<SharedFunctionInfo> shared);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_COMPILER_H_