Add a stress testing flag --background-compilation-stop-alot; add an extra check if background compilation is being stopped.

BUG=
[email protected]

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

Author: Srdjan Mitrovic

runtime/vm/code_generator.cc

@@ -1405,6 +1405,9 @@ DEFINE_RUNTIME_ENTRY(OptimizeInvokedFunction, 1) {
       if (FLAG_enable_inlining_annotations) {
         FATAL("Cannot enable inlining annotations and background compilation");
       }
+      if (FLAG_background_compilation_stop_alot) {
+        BackgroundCompiler::Stop(isolate);
+      }
       // Reduce the chance of triggering optimization while the function is
       // being optimized in the background. INT_MIN should ensure that it takes
       // long time to trigger optimization.

runtime/vm/compiler.cc

@@ -473,6 +473,7 @@ class CompileParsedFunctionHelper : public ValueObject {
   void FinalizeCompilation(Assembler* assembler,
                            FlowGraphCompiler* graph_compiler,
                            FlowGraph* flow_graph);
+  void CheckIfBackgroundCompilerIsBeingStopped();
 
   ParsedFunction* parsed_function_;
   const bool optimized_;
@@ -666,6 +667,16 @@ NOT_IN_PRODUCT(
 }
 
 
+void CompileParsedFunctionHelper::CheckIfBackgroundCompilerIsBeingStopped() {
+  ASSERT(Compiler::IsBackgroundCompilation());
+  if (!isolate()->background_compiler()->is_running()) {
+    // The background compiler is being stopped.
+    Compiler::AbortBackgroundCompilation(Thread::kNoDeoptId,
+        "Background compilation is being stopped");
+  }
+}
+
+
 // Return false if bailed out.
 // If optimized_result_code is not NULL then it is caller's responsibility
 // to install code.
@@ -1133,19 +1144,17 @@ bool CompileParsedFunctionHelper::Compile(CompilationPipeline* pipeline) {
           // changes code page access permissions (makes them temporary not
           // executable).
           {
+            CheckIfBackgroundCompilerIsBeingStopped();
             SafepointOperationScope safepoint_scope(thread());
             // Do not Garbage collect during this stage and instead allow the
             // heap to grow.
             NoHeapGrowthControlScope no_growth_control;
-            if (!isolate()->background_compiler()->is_running()) {
-              // The background compiler is being stopped.
-              Compiler::AbortBackgroundCompilation(Thread::kNoDeoptId,
-                  "Background compilation is being stopped");
-            }
+            CheckIfBackgroundCompilerIsBeingStopped();
             FinalizeCompilation(&assembler, &graph_compiler, flow_graph);
           }
           // TODO(srdjan): Enable this and remove the one from
-          // 'BackgroundCompiler::CompileOptimized'
+          // 'BackgroundCompiler::CompileOptimized' once cause of time-outs
+          // is resolved.
           // if (isolate()->heap()->NeedsGarbageCollection()) {
           //   isolate()->heap()->CollectAllGarbage();
           // }
@@ -1916,7 +1925,10 @@ void BackgroundCompiler::VisitPointers(ObjectPointerVisitor* visitor) {
 
 void BackgroundCompiler::Stop(Isolate* isolate) {
   BackgroundCompiler* task = isolate->background_compiler();
-  ASSERT(task != NULL);
+  if (task == NULL) {
+    // Nothing to stop.
+    return;
+  }
   BackgroundCompilationQueue* function_queue = task->function_queue();
 
   Monitor* queue_monitor = task->queue_monitor_;

runtime/vm/flag_list.h

@@ -33,6 +33,8 @@ P(always_megamorphic_calls, bool, false,                                       \
   "Instance call always as megamorphic.")                                      \
 C(background_compilation, false, true, bool, true,                             \
   "Run optimizing compilation in background")                                  \
+R(background_compilation_stop_alot, false, bool, false,                        \
+  "Stress test system: stop background compiler often.")                       \
 R(break_at_isolate_spawn, false, bool, false,                                  \
   "Insert a one-time breakpoint at the entrypoint for all spawned isolates")   \
 C(collect_code, false, true, bool, true,                                       \

runtime/vm/isolate.h

@@ -381,6 +381,8 @@ class Isolate : public BaseIsolate {
     return background_compiler_;
   }
   void set_background_compiler(BackgroundCompiler* value) {
+    // Do not overwrite a background compiler (memory leak).
+    ASSERT((value == NULL) || (background_compiler_ == NULL));
     background_compiler_ = value;
   }