Rename "parallel recompilation" to "concurrent recompilation".

test/cctest/test-deoptimization.cc

 // 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 59 matching lines @@
 
  private:
   bool always_opt_;
   bool allow_natives_syntax_;
   bool use_inlining_;
 };
 
 
 // Utility class to set --allow-natives-syntax and --nouse-inlining when
 // constructed and return to their default state when destroyed.
-class AllowNativesSyntaxNoInliningNoParallel {
+class AllowNativesSyntaxNoInliningNoConcurrent {
  public:
-  AllowNativesSyntaxNoInliningNoParallel()
+  AllowNativesSyntaxNoInliningNoConcurrent()
       : allow_natives_syntax_(i::FLAG_allow_natives_syntax),
         use_inlining_(i::FLAG_use_inlining),
-        parallel_recompilation_(i::FLAG_parallel_recompilation) {
+        concurrent_recompilation_(i::FLAG_concurrent_recompilation) {
     i::FLAG_allow_natives_syntax = true;
     i::FLAG_use_inlining = false;
-    i::FLAG_parallel_recompilation = false;
+    i::FLAG_concurrent_recompilation = false;
   }
 
-  ~AllowNativesSyntaxNoInliningNoParallel() {
+  ~AllowNativesSyntaxNoInliningNoConcurrent() {
     i::FLAG_allow_natives_syntax = allow_natives_syntax_;
     i::FLAG_use_inlining = use_inlining_;
-    i::FLAG_parallel_recompilation = parallel_recompilation_;
+    i::FLAG_concurrent_recompilation = concurrent_recompilation_;
   }
 
  private:
   bool allow_natives_syntax_;
   bool use_inlining_;
-  bool parallel_recompilation_;
+  bool concurrent_recompilation_;
 };
 
 
 // Abort any ongoing incremental marking to make sure that all weak global
 // handle callbacks are processed.
 static void NonIncrementalGC() {
   HEAP->CollectAllGarbage(i::Heap::kAbortIncrementalMarkingMask);
 }
 
 
@@ skipping 229 matching lines @@
 }
 
 
 TEST(DeoptimizeBinaryOperationADDString) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
   const char* f_source = "function f(x, y) { return x + y; };";
 
   {
-    AllowNativesSyntaxNoInliningNoParallel options;
+    AllowNativesSyntaxNoInliningNoConcurrent options;
     // Compile function f and collect to type feedback to insert binary op stub
     // call in the optimized code.
     i::FLAG_prepare_always_opt = true;
     CompileRun("var count = 0;"
                "var result = 0;"
                "var deopt = false;"
                "function X() { };"
                "X.prototype.toString = function () {"
                "  if (deopt) { count++; %DeoptimizeFunction(f); } return 'an X'"
                "};");
@@ skipping 37 matching lines @@
 
 
 static void TestDeoptimizeBinaryOpHelper(LocalContext* env,
                                          const char* binary_op) {
   EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> f_source_buffer;
   OS::SNPrintF(f_source_buffer,
                "function f(x, y) { return x %s y; };",
                binary_op);
   char* f_source = f_source_buffer.start();
 
-  AllowNativesSyntaxNoInliningNoParallel options;
+  AllowNativesSyntaxNoInliningNoConcurrent options;
   // Compile function f and collect to type feedback to insert binary op stub
   // call in the optimized code.
   i::FLAG_prepare_always_opt = true;
   CompileConstructorWithDeoptimizingValueOf();
   CompileRun(f_source);
   CompileRun("for (var i = 0; i < 5; i++) {"
              "  f(8, new X());"
              "};");
 
   // Compile an optimized version of f.
@@ skipping 71 matching lines @@
 }
 
 
 TEST(DeoptimizeCompare) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
   const char* f_source = "function f(x, y) { return x < y; };";
 
   {
-    AllowNativesSyntaxNoInliningNoParallel options;
+    AllowNativesSyntaxNoInliningNoConcurrent options;
     // Compile function f and collect to type feedback to insert compare ic
     // call in the optimized code.
     i::FLAG_prepare_always_opt = true;
     CompileRun("var count = 0;"
                "var result = 0;"
                "var deopt = false;"
                "function X() { };"
                "X.prototype.toString = function () {"
                "  if (deopt) { count++; %DeoptimizeFunction(f); } return 'b'"
                "};");
@@ skipping 26 matching lines @@
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
   // Functions to generate load/store/keyed load/keyed store IC calls.
   const char* f1_source = "function f1(x) { return x.y; };";
   const char* g1_source = "function g1(x) { x.y = 1; };";
   const char* f2_source = "function f2(x, y) { return x[y]; };";
   const char* g2_source = "function g2(x, y) { x[y] = 1; };";
 
   {
-    AllowNativesSyntaxNoInliningNoParallel options;
+    AllowNativesSyntaxNoInliningNoConcurrent options;
     // Compile functions and collect to type feedback to insert ic
     // calls in the optimized code.
     i::FLAG_prepare_always_opt = true;
     CompileRun("var count = 0;"
                "var result = 0;"
                "var deopt = false;"
                "function X() { };"
                "X.prototype.__defineGetter__('y', function () {"
                "  if (deopt) { count++; %DeoptimizeFunction(f1); };"
                "  return 13;"
@@ skipping 59 matching lines @@
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
   // Functions to generate load/store/keyed load/keyed store IC calls.
   const char* f1_source = "function f1(x) { return x.y; };";
   const char* g1_source = "function g1(x) { x.y = 1; };";
   const char* f2_source = "function f2(x, y) { return x[y]; };";
   const char* g2_source = "function g2(x, y) { x[y] = 1; };";
 
   {
-    AllowNativesSyntaxNoInliningNoParallel options;
+    AllowNativesSyntaxNoInliningNoConcurrent options;
     // Compile functions and collect to type feedback to insert ic
     // calls in the optimized code.
     i::FLAG_prepare_always_opt = true;
     CompileRun("var count = 0;"
                "var result = 0;"
                "var deopt = false;"
                "function X() { };"
                "X.prototype.__defineGetter__('y', function () {"
                "  g1(this);"
                "  return 13;"
@@ skipping 47 matching lines @@
   NonIncrementalGC();
 
   CHECK(!GetJSFunction(env->Global(), "f1")->IsOptimized());
   CHECK(!GetJSFunction(env->Global(), "g1")->IsOptimized());
   CHECK(!GetJSFunction(env->Global(), "f2")->IsOptimized());
   CHECK(!GetJSFunction(env->Global(), "g2")->IsOptimized());
   CHECK_EQ(1, env->Global()->Get(v8_str("count"))->Int32Value());
   CHECK_EQ(13, env->Global()->Get(v8_str("result"))->Int32Value());
   CHECK_EQ(0, Deoptimizer::GetDeoptimizedCodeCount(Isolate::Current()));
 }