Thread/Isolate refactoring: new(Isolate) -> new(Zone)

runtime/vm/compiler.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/compiler.h"
 
 #include "vm/assembler.h"
 
 #include "vm/ast_printer.h"
 #include "vm/block_scheduler.h"
@@ skipping 55 matching lines @@
 
 DECLARE_FLAG(bool, trace_failed_optimization_attempts);
 DECLARE_FLAG(bool, trace_inlining_intervals);
 DECLARE_FLAG(bool, trace_irregexp);
 DECLARE_FLAG(bool, trace_patching);
 
 // TODO(zerny): Factor out unoptimizing/optimizing pipelines and remove
 // separate helpers functions & `optimizing` args.
 class CompilationPipeline : public ZoneAllocated {
  public:
-  static CompilationPipeline* New(Isolate* isolate, const Function& function);
+  static CompilationPipeline* New(Zone* zone, const Function& function);
 
   virtual void ParseFunction(ParsedFunction* parsed_function) = 0;
   virtual FlowGraph* BuildFlowGraph(
       ParsedFunction* parsed_function,
       const ZoneGrowableArray<const ICData*>& ic_data_array,
-      intptr_t osr_id) = 0;
+      intptr_t osr_id,
+      Zone* zone) = 0;

[Ivan Posva, 2015/03/13 21:56:49]

We generally pass Isolate* as the first parameter, probably should do the same
for Zone*.

[koda, 2015/03/14 00:46:36]

Done.

   virtual void FinalizeCompilation() = 0;
   virtual ~CompilationPipeline() { }
 };
 
 
 class DartCompilationPipeline : public CompilationPipeline {
  public:
   virtual void ParseFunction(ParsedFunction* parsed_function) {
     Parser::ParseFunction(parsed_function);
     parsed_function->AllocateVariables();
   }
 
   virtual FlowGraph* BuildFlowGraph(
       ParsedFunction* parsed_function,
       const ZoneGrowableArray<const ICData*>& ic_data_array,
-      intptr_t osr_id) {
+      intptr_t osr_id,
+      Zone* zone) {
     // Build the flow graph.
     FlowGraphBuilder builder(*parsed_function,
                              ic_data_array,
                              NULL,  // NULL = not inlining.
                              osr_id);
 
     return builder.BuildGraph();
   }
 
   virtual void FinalizeCompilation() { }
 };
 
 
 class IrregexpCompilationPipeline : public CompilationPipeline {
  public:
-  explicit IrregexpCompilationPipeline(Isolate* isolate)
-    : backtrack_goto_(NULL),
-      isolate_(isolate) { }
+  IrregexpCompilationPipeline() : backtrack_goto_(NULL) { }
 
   virtual void ParseFunction(ParsedFunction* parsed_function) {
     RegExpParser::ParseFunction(parsed_function);
     // Variables are allocated after compilation.
   }
 
   virtual FlowGraph* BuildFlowGraph(
       ParsedFunction* parsed_function,
       const ZoneGrowableArray<const ICData*>& ic_data_array,
-      intptr_t osr_id) {
+      intptr_t osr_id,
+      Zone* zone) {
     // Compile to the dart IR.
     RegExpEngine::CompilationResult result =
         RegExpEngine::Compile(parsed_function->regexp_compile_data(),
                               parsed_function,
                               ic_data_array);
     backtrack_goto_ = result.backtrack_goto;
 
     // Allocate variables now that we know the number of locals.
     parsed_function->AllocateIrregexpVariables(result.num_stack_locals);
 
     // Build the flow graph.
     FlowGraphBuilder builder(*parsed_function,
                              ic_data_array,
                              NULL,  // NULL = not inlining.
                              osr_id);
 
-    return new(isolate_) FlowGraph(*parsed_function,
-                                   result.graph_entry,
-                                   result.num_blocks);
+    return new(zone) FlowGraph(*parsed_function,
+                               result.graph_entry,
+                               result.num_blocks);
   }
 
   virtual void FinalizeCompilation() {
-    backtrack_goto_->ComputeOffsetTable(isolate_);
+    backtrack_goto_->ComputeOffsetTable();
   }
 
  private:
   IndirectGotoInstr* backtrack_goto_;
-  Isolate* isolate_;
+  Zone* zone_;

[Ivan Posva, 2015/03/13 21:56:49]

Where is zone_ being set?

[koda, 2015/03/14 00:46:36]

Removed (leftover from previous version).

 };
 
-CompilationPipeline* CompilationPipeline::New(Isolate* isolate,
+CompilationPipeline* CompilationPipeline::New(Zone* zone,
                                               const Function& function) {
   if (function.IsIrregexpFunction()) {
-    return new(isolate) IrregexpCompilationPipeline(isolate);
+    return new(zone) IrregexpCompilationPipeline();
   } else {
-    return new(isolate) DartCompilationPipeline();
+    return new(zone) DartCompilationPipeline();
   }
 }
 
 
 // Compile a function. Should call only if the function has not been compiled.
 //   Arg0: function object.
 DEFINE_RUNTIME_ENTRY(CompileFunction, 1) {
   const Function& function = Function::CheckedHandle(arguments.ArgAt(0));
   ASSERT(!function.HasCode());
-  const Error& error = Error::Handle(Compiler::CompileFunction(isolate,
+  const Error& error = Error::Handle(Compiler::CompileFunction(thread,
                                                                function));
   if (!error.IsNull()) {
     Exceptions::PropagateError(error);
   }
 }
 
 
 RawError* Compiler::Compile(const Library& library, const Script& script) {
   Isolate* isolate = Isolate::Current();
   StackZone zone(isolate);
@@ skipping 184 matching lines @@
 static bool CompileParsedFunctionHelper(CompilationPipeline* pipeline,
                                         ParsedFunction* parsed_function,
                                         bool optimized,
                                         intptr_t osr_id) {
   const Function& function = parsed_function->function();
   if (optimized && !function.IsOptimizable()) {
     return false;
   }
   TimerScope timer(FLAG_compiler_stats, &CompilerStats::codegen_timer);
   bool is_compiled = false;
-  Isolate* isolate = Isolate::Current();
+  Thread* thread = Thread::Current();
+  Zone* zone = thread->zone();
+  Isolate* isolate = thread->isolate();
   HANDLESCOPE(isolate);
 
   // We may reattempt compilation if the function needs to be assembled using
   // far branches on ARM and MIPS. In the else branch of the setjmp call,
   // done is set to false, and use_far_branches is set to true if there is a
   // longjmp from the ARM or MIPS assemblers. In all other paths through this
   // while loop, done is set to true. use_far_branches is always false on ia32
   // and x64.
   bool done = false;
   // volatile because the variable may be clobbered by a longjmp.
   volatile bool use_far_branches = false;
   while (!done) {
     const intptr_t prev_deopt_id = isolate->deopt_id();
     isolate->set_deopt_id(0);
     LongJumpScope jump;
     if (setjmp(*jump.Set()) == 0) {
       FlowGraph* flow_graph = NULL;
 
       // Class hierarchy analysis is registered with the isolate in the
       // constructor and unregisters itself upon destruction.
       CHA cha(isolate);
 
       // TimerScope needs an isolate to be properly terminated in case of a
       // LongJump.
       {
         TimerScope timer(FLAG_compiler_stats,
                          &CompilerStats::graphbuilder_timer,
                          isolate);
         ZoneGrowableArray<const ICData*>* ic_data_array =
-            new(isolate) ZoneGrowableArray<const ICData*>();
+            new(zone) ZoneGrowableArray<const ICData*>();
         if (optimized) {
           ASSERT(function.HasCode());
           // Extract type feedback before the graph is built, as the graph
           // builder uses it to attach it to nodes.
           ASSERT(function.deoptimization_counter() <
                  FLAG_deoptimization_counter_threshold);
           function.RestoreICDataMap(ic_data_array);
           if (FLAG_print_ic_data_map) {
             for (intptr_t i = 0; i < ic_data_array->length(); i++) {
               if ((*ic_data_array)[i] != NULL) {
                 ISL_Print("%" Pd " ", i);
                 FlowGraphPrinter::PrintICData(*(*ic_data_array)[i]);
               }
             }
           }
         }
 
         flow_graph = pipeline->BuildFlowGraph(parsed_function,
                                               *ic_data_array,
-                                              osr_id);
+                                              osr_id,
+                                              zone);
       }
 
       const bool print_flow_graph =
           (FLAG_print_flow_graph ||
           (optimized && FLAG_print_flow_graph_optimized)) &&
           FlowGraphPrinter::ShouldPrint(function);
 
       if (print_flow_graph) {
         if (osr_id == Isolate::kNoDeoptId) {
           FlowGraphPrinter::PrintGraph("Before Optimizations", flow_graph);
@@ skipping 595 matching lines @@
     // We got an error during compilation.
     error = isolate->object_store()->sticky_error();
     isolate->object_store()->clear_sticky_error();
     return error.raw();
   }
   UNREACHABLE();
   return Error::null();
 }
 
 
-RawError* Compiler::CompileFunction(Isolate* isolate,
+RawError* Compiler::CompileFunction(Thread* thread,
                                     const Function& function) {
-  VMTagScope tagScope(isolate, VMTag::kCompileUnoptimizedTagId);
-  CompilationPipeline* pipeline = CompilationPipeline::New(isolate, function);
+  VMTagScope tagScope(thread->isolate(), VMTag::kCompileUnoptimizedTagId);
+  CompilationPipeline* pipeline =
+      CompilationPipeline::New(thread->zone(), function);
   return CompileFunctionHelper(pipeline, function, false, Isolate::kNoDeoptId);
 }
 
 
-RawError* Compiler::CompileOptimizedFunction(Isolate* isolate,
+RawError* Compiler::CompileOptimizedFunction(Thread* thread,
                                              const Function& function,
                                              intptr_t osr_id) {
-  VMTagScope tagScope(isolate, VMTag::kCompileOptimizedTagId);
-  CompilationPipeline* pipeline = CompilationPipeline::New(isolate, function);
+  VMTagScope tagScope(thread->isolate(), VMTag::kCompileOptimizedTagId);
+  CompilationPipeline* pipeline =
+      CompilationPipeline::New(thread->zone(), function);
   return CompileFunctionHelper(pipeline, function, true, osr_id);
 }
 
 
 // This is only used from unit tests.
 RawError* Compiler::CompileParsedFunction(
     ParsedFunction* parsed_function) {
   Isolate* isolate = Isolate::Current();
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
@@ skipping 13 matching lines @@
     error = isolate->object_store()->sticky_error();
     isolate->object_store()->clear_sticky_error();
     return error.raw();
   }
   UNREACHABLE();
   return Error::null();
 }
 
 
 RawError* Compiler::CompileAllFunctions(const Class& cls) {
-  Isolate* isolate = Isolate::Current();
-  Error& error = Error::Handle(isolate);
-  Array& functions = Array::Handle(isolate, cls.functions());
-  Function& func = Function::Handle(isolate);
+  Thread* thread = Thread::Current();
+  Zone* zone = thread->zone();
+  Error& error = Error::Handle(zone);
+  Array& functions = Array::Handle(zone, cls.functions());
+  Function& func = Function::Handle(zone);
   // Class dynamic lives in the vm isolate. Its array fields cannot be set to
   // an empty array.
   if (functions.IsNull()) {
     ASSERT(cls.IsDynamicClass());
     return error.raw();
   }
   // Compile all the regular functions.
   for (int i = 0; i < functions.Length(); i++) {
     func ^= functions.At(i);
     ASSERT(!func.IsNull());
     if (!func.HasCode() &&
         !func.is_abstract() &&
         !func.IsRedirectingFactory()) {
-      error = CompileFunction(isolate, func);
+      error = CompileFunction(thread, func);
       if (!error.IsNull()) {
         return error.raw();
       }
       func.ClearCode();
     }
   }
   // Inner functions get added to the closures array. As part of compilation
   // more closures can be added to the end of the array. Compile all the
   // closures until we have reached the end of the "worklist".
   GrowableObjectArray& closures =
-      GrowableObjectArray::Handle(isolate, cls.closures());
+      GrowableObjectArray::Handle(zone, cls.closures());
   if (!closures.IsNull()) {
     for (int i = 0; i < closures.Length(); i++) {
       func ^= closures.At(i);
       if (!func.HasCode()) {
-        error = CompileFunction(isolate, func);
+        error = CompileFunction(thread, func);
         if (!error.IsNull()) {
           return error.raw();
         }
         func.ClearCode();
       }
     }
   }
   return error.raw();
 }
 
@@ skipping 92 matching lines @@
     const Object& result =
       PassiveObject::Handle(isolate->object_store()->sticky_error());
     isolate->object_store()->clear_sticky_error();
     return result.raw();
   }
   UNREACHABLE();
   return Object::null();
 }
 
 }  // namespace dart