[compiler-dispatcher] Use an integer job id.

It enables jobs without a SharedFunctionInfo.

BUG=v8:6093

Change-Id: Icc5f01512c270a55349087d418b6be82ad5c6cb4
Reviewed-on: https://chromium-review.googlesource.com/467148
Commit-Queue: Wiktor Garbacz <wiktorg@google.com>
Reviewed-by: Ross McIlroy <rmcilroy@chromium.org>
Reviewed-by: Jochen Eisinger <jochen@chromium.org>
Reviewed-by: Marja Hölttä <marja@chromium.org>
Cr-Commit-Position: refs/heads/master@{#44402}

src/compiler-dispatcher/compiler-dispatcher-job.h

@@ -63,6 +63,8 @@ class V8_EXPORT_PRIVATE CompilerDispatcherJob {
 
   Context* context() { return *context_; }
 
+  Handle<SharedFunctionInfo> shared() const { return shared_; }
+
   // Returns true if this CompilerDispatcherJob was created for the given
   // function.
   bool IsAssociatedWith(Handle<SharedFunctionInfo> shared) const;

src/compiler-dispatcher/compiler-dispatcher.cc

@@ -221,6 +221,8 @@ CompilerDispatcher::CompilerDispatcher(Isolate* isolate, Platform* platform,
       trace_compiler_dispatcher_(FLAG_trace_compiler_dispatcher),
       tracer_(new CompilerDispatcherTracer(isolate_)),
       task_manager_(new CancelableTaskManager()),
+      next_job_id_(0),
+      shared_to_job_id_(isolate->heap()),
       memory_pressure_level_(MemoryPressureLevel::kNone),
       abort_(false),
       idle_task_scheduled_(false),
@@ -263,6 +265,22 @@ bool CompilerDispatcher::CanEnqueue(Handle<SharedFunctionInfo> function) {
   return true;
 }
 
+CompilerDispatcher::JobId CompilerDispatcher::Enqueue(
+    std::unique_ptr<CompilerDispatcherJob> job) {
+  DCHECK(!IsFinished(job.get()));
+  bool added;
+  JobMap::const_iterator it;
+  std::tie(it, added) =
+      jobs_.insert(std::make_pair(next_job_id_++, std::move(job)));
+  DCHECK(added);
+  if (!it->second->shared().is_null()) {
+    shared_to_job_id_.Set(it->second->shared(), it->first);
+  }
+  ConsiderJobForBackgroundProcessing(it->second.get());
+  ScheduleIdleTaskIfNeeded();
+  return it->first;
+}
+
 bool CompilerDispatcher::Enqueue(Handle<SharedFunctionInfo> function) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"),
                "V8.CompilerDispatcherEnqueue");
@@ -277,10 +295,7 @@ bool CompilerDispatcher::Enqueue(Handle<SharedFunctionInfo> function) {
 
   std::unique_ptr<CompilerDispatcherJob> job(new CompilerDispatcherJob(
       isolate_, tracer_.get(), function, max_stack_size_));
-  std::pair<int, int> key(Script::cast(function->script())->id(),
-                          function->function_literal_id());
-  jobs_.insert(std::make_pair(key, std::move(job)));
-  ScheduleIdleTaskIfNeeded();
+  Enqueue(std::move(job));
   return true;
 }
 
@@ -321,10 +336,7 @@ bool CompilerDispatcher::Enqueue(
   std::unique_ptr<CompilerDispatcherJob> job(new CompilerDispatcherJob(
       isolate_, tracer_.get(), script, function, literal, parse_zone,
       parse_handles, compile_handles, max_stack_size_));
-  std::pair<int, int> key(Script::cast(function->script())->id(),
-                          function->function_literal_id());
-  jobs_.insert(std::make_pair(key, std::move(job)));
-  ScheduleIdleTaskIfNeeded();
+  Enqueue(std::move(job));
   return true;
 }
 
@@ -408,6 +420,9 @@ bool CompilerDispatcher::FinishNow(Handle<SharedFunctionInfo> function) {
   }
 
   job->second->ResetOnMainThread();
+  if (!job->second->shared().is_null()) {
+    shared_to_job_id_.Delete(job->second->shared());
+  }
   jobs_.erase(job);
   if (jobs_.empty()) {
     base::LockGuard<base::Mutex> lock(&mutex_);
@@ -430,6 +445,7 @@ void CompilerDispatcher::AbortAll(BlockingBehavior blocking) {
       it.second->ResetOnMainThread();
     }
     jobs_.clear();
+    shared_to_job_id_.Clear();
     {
       base::LockGuard<base::Mutex> lock(&mutex_);
       DCHECK(pending_background_jobs_.empty());
@@ -475,6 +491,9 @@ void CompilerDispatcher::AbortInactiveJobs() {
       PrintF("\n");
     }
     job->second->ResetOnMainThread();
+    if (!job->second->shared().is_null()) {
+      shared_to_job_id_.Delete(job->second->shared());
+    }
     jobs_.erase(job);
   }
   if (jobs_.empty()) {
@@ -516,14 +535,13 @@ void CompilerDispatcher::MemoryPressureNotification(
 
 CompilerDispatcher::JobMap::const_iterator CompilerDispatcher::GetJobFor(
     Handle<SharedFunctionInfo> shared) const {
-  if (!shared->script()->IsScript()) return jobs_.end();
-  std::pair<int, int> key(Script::cast(shared->script())->id(),
-                          shared->function_literal_id());
-  auto range = jobs_.equal_range(key);
-  for (auto job = range.first; job != range.second; ++job) {
-    if (job->second->IsAssociatedWith(shared)) return job;
-  }
-  return jobs_.end();
+  JobId* job_id_ptr = shared_to_job_id_.Find(shared);
+  JobMap::const_iterator job = jobs_.end();
+  if (job_id_ptr) {
+    job = jobs_.find(*job_id_ptr);
+    DCHECK(job == jobs_.end() || job->second->IsAssociatedWith(shared));
+  }
+  return job;
 }
 
 void CompilerDispatcher::ScheduleIdleTaskFromAnyThread() {
@@ -697,6 +715,9 @@ void CompilerDispatcher::DoIdleWork(double deadline_in_seconds) {
         tracer_->DumpStatistics();
       }
       job->second->ResetOnMainThread();
+      if (!job->second->shared().is_null()) {
+        shared_to_job_id_.Delete(job->second->shared());
+      }
       job = jobs_.erase(job);
       continue;
     } else {

src/compiler-dispatcher/compiler-dispatcher.h

@@ -5,6 +5,7 @@
 #ifndef V8_COMPILER_DISPATCHER_COMPILER_DISPATCHER_H_
 #define V8_COMPILER_DISPATCHER_COMPILER_DISPATCHER_H_
 
+#include <cstdint>
 #include <map>
 #include <memory>
 #include <unordered_set>
@@ -16,6 +17,7 @@
 #include "src/base/platform/mutex.h"
 #include "src/base/platform/semaphore.h"
 #include "src/globals.h"
+#include "src/identity-map.h"
 #include "testing/gtest/include/gtest/gtest_prod.h"
 
 namespace v8 {
@@ -65,6 +67,8 @@ class Handle;
 // thread.
 class V8_EXPORT_PRIVATE CompilerDispatcher {
  public:
+  typedef uintptr_t JobId;
+
   enum class BlockingBehavior { kBlock, kDontBlock };
 
   CompilerDispatcher(Isolate* isolate, Platform* platform,
@@ -117,6 +121,7 @@ class V8_EXPORT_PRIVATE CompilerDispatcher {
                                   bool is_isolate_locked);
 
  private:
+  FRIEND_TEST(CompilerDispatcherTest, EnqueueJob);
   FRIEND_TEST(CompilerDispatcherTest, EnqueueAndStep);
   FRIEND_TEST(CompilerDispatcherTest, EnqueueAndStepTwice);
   FRIEND_TEST(CompilerDispatcherTest, EnqueueParsed);
@@ -129,9 +134,8 @@ class V8_EXPORT_PRIVATE CompilerDispatcher {
   FRIEND_TEST(CompilerDispatcherTest, FinishNowDuringAbortAll);
   FRIEND_TEST(CompilerDispatcherTest, CompileMultipleOnBackgroundThread);
 
-  typedef std::multimap<std::pair<int, int>,
-                        std::unique_ptr<CompilerDispatcherJob>>
-      JobMap;
+  typedef std::map<JobId, std::unique_ptr<CompilerDispatcherJob>> JobMap;
+  typedef IdentityMap<JobId, FreeStoreAllocationPolicy> SharedToJobIdMap;
   class AbortTask;
   class BackgroundTask;
   class IdleTask;
@@ -147,6 +151,7 @@ class V8_EXPORT_PRIVATE CompilerDispatcher {
   void ScheduleAbortTask();
   void DoBackgroundWork();
   void DoIdleWork(double deadline_in_seconds);
+  JobId Enqueue(std::unique_ptr<CompilerDispatcherJob> job);
 
   Isolate* isolate_;
   Platform* platform_;
@@ -159,10 +164,15 @@ class V8_EXPORT_PRIVATE CompilerDispatcher {
 
   std::unique_ptr<CancelableTaskManager> task_manager_;
 
-  // Mapping from (script id, function literal id) to job. We use a multimap,
-  // as script id is not necessarily unique.
+  // Id for next job to be added
+  JobId next_job_id_;
+
+  // Mapping from job_id to job.
   JobMap jobs_;
 
+  // Mapping from SharedFunctionInfo to corresponding JobId;
+  SharedToJobIdMap shared_to_job_id_;
+
   base::AtomicValue<v8::MemoryPressureLevel> memory_pressure_level_;
 
   // The following members can be accessed from any thread. Methods need to hold

src/identity-map.h

@@ -112,7 +112,10 @@ class IdentityMap : public IdentityMapBase {
   void Set(Object* key, V v) { *(reinterpret_cast<V*>(GetEntry(key))) = v; }
 
   V Delete(Handle<Object> key) { return Delete(*key); }
-  V Delete(Object* key) { return reinterpret_cast<V>(DeleteEntry(key)); }
+  V Delete(Object* key) {
+    void* val = DeleteEntry(key);
+    return *reinterpret_cast<V*>(&val);
+  }
 
   // Removes all elements from the map.
   void Clear() { IdentityMapBase::Clear(); }

test/unittests/compiler-dispatcher/compiler-dispatcher-unittest.cc

@@ -20,6 +20,17 @@
 #include "test/unittests/test-utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+// V8 is smart enough to know something was already compiled and return compiled
+// code straight away. We need a unique name for each test function so that V8
+// returns an empty SharedFunctionInfo.
+#define _STR(x) #x
+#define STR(x) _STR(x)
+#define _SCRIPT(fn, a, b, c) a fn b fn c
+#define SCRIPT(a, b, c) _SCRIPT("f" STR(__LINE__), a, b, c)
+#define TEST_SCRIPT()                           \
+  SCRIPT("function g() { var y = 1; function ", \
+         "(x) { return x * y }; return ", "; } g();")
+
 namespace v8 {
 namespace internal {
 
@@ -270,9 +281,7 @@ TEST_F(CompilerDispatcherTest, IsEnqueued) {
   MockPlatform platform;
   CompilerDispatcher dispatcher(i_isolate(), &platform, FLAG_stack_size);
 
-  const char script[] =
-      "function g() { var y = 1; function f1(x) { return x * y }; return f1; } "
-      "g();";
+  const char script[] = TEST_SCRIPT();
   Handle<JSFunction> f = Handle<JSFunction>::cast(RunJS(isolate(), script));
   Handle<SharedFunctionInfo> shared(f->shared(), i_isolate());
 
@@ -289,9 +298,7 @@ TEST_F(CompilerDispatcherTest, FinishNow) {
   MockPlatform platform;
   CompilerDispatcher dispatcher(i_isolate(), &platform, FLAG_stack_size);
 
-  const char script[] =
-      "function g() { var y = 1; function f2(x) { return x * y }; return f2; } "
-      "g();";
+  const char script[] = TEST_SCRIPT();
   Handle<JSFunction> f = Handle<JSFunction>::cast(RunJS(isolate(), script));
   Handle<SharedFunctionInfo> shared(f->shared(), i_isolate());
 
@@ -309,9 +316,7 @@ TEST_F(CompilerDispatcherTest, IdleTask) {
   MockPlatform platform;
   CompilerDispatcher dispatcher(i_isolate(), &platform, FLAG_stack_size);
 
-  const char script[] =
-      "function g() { var y = 1; function f3(x) { return x * y }; return f3; } "
-      "g();";
+  const char script[] = TEST_SCRIPT();
   Handle<JSFunction> f = Handle<JSFunction>::cast(RunJS(isolate(), script));
   Handle<SharedFunctionInfo> shared(f->shared(), i_isolate());
 
@@ -331,9 +336,7 @@ TEST_F(CompilerDispatcherTest, IdleTaskSmallIdleTime) {
   MockPlatform platform;
   CompilerDispatcher dispatcher(i_isolate(), &platform, FLAG_stack_size);
 
-  const char script[] =
-      "function g() { var y = 1; function f4(x) { return x * y }; return f4; } "
-      "g();";
+  const char script[] = TEST_SCRIPT();
   Handle<JSFunction> f = Handle<JSFunction>::cast(RunJS(isolate(), script));
   Handle<SharedFunctionInfo> shared(f->shared(), i_isolate());
 
@@ -371,11 +374,12 @@ TEST_F(CompilerDispatcherTest, IdleTaskException) {
   MockPlatform platform;
   CompilerDispatcher dispatcher(i_isolate(), &platform, 50);
 
-  std::string script("function g() { function f5(x) { var a = ");
+  std::string func_name("f" STR(__LINE__));
+  std::string script("function g() { function " + func_name + "(x) { var a = ");
   for (int i = 0; i < 1000; i++) {
     script += "'x' + ";
   }
-  script += " 'x'; }; return f5; } g();";
+  script += " 'x'; }; return " + func_name + "; } g();";
   Handle<JSFunction> f =
       Handle<JSFunction>::cast(RunJS(isolate(), script.c_str()));
   Handle<SharedFunctionInfo> shared(f->shared(), i_isolate());
@@ -397,9 +401,7 @@ TEST_F(CompilerDispatcherTest, CompileOnBackgroundThread) {
   MockPlatform platform;
   CompilerDispatcher dispatcher(i_isolate(), &platform, FLAG_stack_size);
 
-  const char script[] =
-      "function g() { var y = 1; function f6(x) { return x * y }; return f6; } "
-      "g();";
+  const char script[] = TEST_SCRIPT();
   Handle<JSFunction> f = Handle<JSFunction>::cast(RunJS(isolate(), script));
   Handle<SharedFunctionInfo> shared(f->shared(), i_isolate());
 
@@ -442,9 +444,7 @@ TEST_F(CompilerDispatcherTest, FinishNowWithBackgroundTask) {
   MockPlatform platform;
   CompilerDispatcher dispatcher(i_isolate(), &platform, FLAG_stack_size);
 
-  const char script[] =
-      "function g() { var y = 1; function f7(x) { return x * y }; return f7; } "
-      "g();";
+  const char script[] = TEST_SCRIPT();
   Handle<JSFunction> f = Handle<JSFunction>::cast(RunJS(isolate(), script));
   Handle<SharedFunctionInfo> shared(f->shared(), i_isolate());
 
@@ -483,15 +483,11 @@ TEST_F(CompilerDispatcherTest, IdleTaskMultipleJobs) {
   MockPlatform platform;
   CompilerDispatcher dispatcher(i_isolate(), &platform, FLAG_stack_size);
 
-  const char script1[] =
-      "function g() { var y = 1; function f8(x) { return x * y }; return f8; } "
-      "g();";
+  const char script1[] = TEST_SCRIPT();
   Handle<JSFunction> f1 = Handle<JSFunction>::cast(RunJS(isolate(), script1));
   Handle<SharedFunctionInfo> shared1(f1->shared(), i_isolate());
 
-  const char script2[] =
-      "function g() { var y = 1; function f9(x) { return x * y }; return f9; } "
-      "g();";
+  const char script2[] = TEST_SCRIPT();
   Handle<JSFunction> f2 = Handle<JSFunction>::cast(RunJS(isolate(), script2));
   Handle<SharedFunctionInfo> shared2(f2->shared(), i_isolate());
 
@@ -514,11 +510,12 @@ TEST_F(CompilerDispatcherTest, FinishNowException) {
   MockPlatform platform;
   CompilerDispatcher dispatcher(i_isolate(), &platform, 50);
 
-  std::string script("function g() { function f10(x) { var a = ");
+  std::string func_name("f" STR(__LINE__));
+  std::string script("function g() { function " + func_name + "(x) { var a = ");
   for (int i = 0; i < 1000; i++) {
     script += "'x' + ";
   }
-  script += " 'x'; }; return f10; } g();";
+  script += " 'x'; }; return " + func_name + "; } g();";
   Handle<JSFunction> f =
       Handle<JSFunction>::cast(RunJS(isolate(), script.c_str()));
   Handle<SharedFunctionInfo> shared(f->shared(), i_isolate());
@@ -541,9 +538,7 @@ TEST_F(CompilerDispatcherTest, AsyncAbortAllPendingBackgroundTask) {
   MockPlatform platform;
   CompilerDispatcher dispatcher(i_isolate(), &platform, FLAG_stack_size);
 
-  const char script[] =
-      "function g() { var y = 1; function f11(x) { return x * y }; return f11; "
-      "} g();";
+  const char script[] = TEST_SCRIPT();
   Handle<JSFunction> f = Handle<JSFunction>::cast(RunJS(isolate(), script));
   Handle<SharedFunctionInfo> shared(f->shared(), i_isolate());
 
@@ -585,15 +580,11 @@ TEST_F(CompilerDispatcherTest, AsyncAbortAllRunningBackgroundTask) {
   MockPlatform platform;
   CompilerDispatcher dispatcher(i_isolate(), &platform, FLAG_stack_size);
 
-  const char script1[] =
-      "function g() { var y = 1; function f11(x) { return x * y }; return f11; "
-      "} g();";
+  const char script1[] = TEST_SCRIPT();
   Handle<JSFunction> f1 = Handle<JSFunction>::cast(RunJS(isolate(), script1));
   Handle<SharedFunctionInfo> shared1(f1->shared(), i_isolate());
 
-  const char script2[] =
-      "function g() { var y = 1; function f12(x) { return x * y }; return f12; "
-      "} g();";
+  const char script2[] = TEST_SCRIPT();
   Handle<JSFunction> f2 = Handle<JSFunction>::cast(RunJS(isolate(), script2));
   Handle<SharedFunctionInfo> shared2(f2->shared(), i_isolate());
 
@@ -669,9 +660,7 @@ TEST_F(CompilerDispatcherTest, FinishNowDuringAbortAll) {
   MockPlatform platform;
   CompilerDispatcher dispatcher(i_isolate(), &platform, FLAG_stack_size);
 
-  const char script[] =
-      "function g() { var y = 1; function f13(x) { return x * y }; return f13; "
-      "} g();";
+  const char script[] = TEST_SCRIPT();
   Handle<JSFunction> f = Handle<JSFunction>::cast(RunJS(isolate(), script));
   Handle<SharedFunctionInfo> shared(f->shared(), i_isolate());
 
@@ -749,9 +738,7 @@ TEST_F(CompilerDispatcherTest, MemoryPressure) {
   MockPlatform platform;
   CompilerDispatcher dispatcher(i_isolate(), &platform, FLAG_stack_size);
 
-  const char script[] =
-      "function g() { var y = 1; function f14(x) { return x * y }; return f14; "
-      "} g();";
+  const char script[] = TEST_SCRIPT();
   Handle<JSFunction> f = Handle<JSFunction>::cast(RunJS(isolate(), script));
   Handle<SharedFunctionInfo> shared(f->shared(), i_isolate());
 
@@ -798,9 +785,7 @@ TEST_F(CompilerDispatcherTest, MemoryPressureFromBackground) {
   MockPlatform platform;
   CompilerDispatcher dispatcher(i_isolate(), &platform, FLAG_stack_size);
 
-  const char script[] =
-      "function g() { var y = 1; function f15(x) { return x * y }; return f15; "
-      "} g();";
+  const char script[] = TEST_SCRIPT();
   Handle<JSFunction> f = Handle<JSFunction>::cast(RunJS(isolate(), script));
   Handle<SharedFunctionInfo> shared(f->shared(), i_isolate());
 
@@ -828,13 +813,29 @@ TEST_F(CompilerDispatcherTest, MemoryPressureFromBackground) {
   platform.ClearIdleTask();
 }
 
+TEST_F(CompilerDispatcherTest, EnqueueJob) {
+  MockPlatform platform;
+  CompilerDispatcher dispatcher(i_isolate(), &platform, FLAG_stack_size);
+  const char script[] = TEST_SCRIPT();
+  Handle<JSFunction> f = Handle<JSFunction>::cast(RunJS(isolate(), script));
+  Handle<SharedFunctionInfo> shared(f->shared(), i_isolate());
+  std::unique_ptr<CompilerDispatcherJob> job(
+      new CompilerDispatcherJob(i_isolate(), dispatcher.tracer_.get(), shared,
+                                dispatcher.max_stack_size_));
+  ASSERT_FALSE(dispatcher.IsEnqueued(shared));
+  dispatcher.Enqueue(std::move(job));
+  ASSERT_TRUE(dispatcher.IsEnqueued(shared));
+
+  ASSERT_TRUE(platform.IdleTaskPending());
+  platform.ClearIdleTask();
+  ASSERT_FALSE(platform.BackgroundTasksPending());
+}
+
 TEST_F(CompilerDispatcherTest, EnqueueAndStep) {
   MockPlatform platform;
   CompilerDispatcher dispatcher(i_isolate(), &platform, FLAG_stack_size);
 
-  const char script[] =
-      "function g() { var y = 1; function f16(x) { return x * y }; return f16; "
-      "} g();";
+  const char script[] = TEST_SCRIPT();
   Handle<JSFunction> f = Handle<JSFunction>::cast(RunJS(isolate(), script));
   Handle<SharedFunctionInfo> shared(f->shared(), i_isolate());
 
@@ -855,9 +856,7 @@ TEST_F(CompilerDispatcherTest, EnqueueParsed) {
   MockPlatform platform;
   CompilerDispatcher dispatcher(i_isolate(), &platform, FLAG_stack_size);
 
-  const char source[] =
-      "function g() { var y = 1; function f17(x) { return x * y }; return f17; "
-      "} g();";
+  const char source[] = TEST_SCRIPT();
   Handle<JSFunction> f = Handle<JSFunction>::cast(RunJS(isolate(), source));
   Handle<SharedFunctionInfo> shared(f->shared(), i_isolate());
   Handle<Script> script(Script::cast(shared->script()), i_isolate());
@@ -883,9 +882,7 @@ TEST_F(CompilerDispatcherTest, EnqueueAndStepParsed) {
   MockPlatform platform;
   CompilerDispatcher dispatcher(i_isolate(), &platform, FLAG_stack_size);
 
-  const char source[] =
-      "function g() { var y = 1; function f18(x) { return x * y }; return f18; "
-      "} g();";
+  const char source[] = TEST_SCRIPT();
   Handle<JSFunction> f = Handle<JSFunction>::cast(RunJS(isolate(), source));
   Handle<SharedFunctionInfo> shared(f->shared(), i_isolate());
   Handle<Script> script(Script::cast(shared->script()), i_isolate());
@@ -913,9 +910,7 @@ TEST_F(CompilerDispatcherTest, CompileParsedOutOfScope) {
   MockPlatform platform;
   CompilerDispatcher dispatcher(i_isolate(), &platform, FLAG_stack_size);
 
-  const char source[] =
-      "function g() { var y = 1; function f20(x) { return x + y }; return f20; "
-      "} g();";
+  const char source[] = TEST_SCRIPT();
   Handle<JSFunction> f = Handle<JSFunction>::cast(RunJS(isolate(), source));
   Handle<SharedFunctionInfo> shared(f->shared(), i_isolate());
   Handle<Script> script(Script::cast(shared->script()), i_isolate());
@@ -1027,9 +1022,7 @@ TEST_F(CompilerDispatcherTest, CompileLazyFinishesDispatcherJob) {
   // enqueued functions.
   CompilerDispatcher* dispatcher = i_isolate()->compiler_dispatcher();
 
-  const char source[] =
-      "function g() { var y = 1; function f16(x) { return x * y }; return f16; "
-      "} g();";
+  const char source[] = TEST_SCRIPT();
   Handle<JSFunction> f = Handle<JSFunction>::cast(RunJS(isolate(), source));
   Handle<SharedFunctionInfo> shared(f->shared(), i_isolate());
 
@@ -1076,9 +1069,7 @@ TEST_F(CompilerDispatcherTest, EnqueueAndStepTwice) {
   MockPlatform platform;
   CompilerDispatcher dispatcher(i_isolate(), &platform, FLAG_stack_size);
 
-  const char source[] =
-      "function g() { var y = 1; function f18(x) { return x * y }; return f18; "
-      "} g();";
+  const char source[] = TEST_SCRIPT();
   Handle<JSFunction> f = Handle<JSFunction>::cast(RunJS(isolate(), source));
   Handle<SharedFunctionInfo> shared(f->shared(), i_isolate());
   Handle<Script> script(Script::cast(shared->script()), i_isolate());
@@ -1118,14 +1109,10 @@ TEST_F(CompilerDispatcherTest, CompileMultipleOnBackgroundThread) {
   MockPlatform platform;
   CompilerDispatcher dispatcher(i_isolate(), &platform, FLAG_stack_size);
 
-  const char script1[] =
-      "function g() { var y = 1; function f19(x) { return x * y }; "
-      "return f19; } g();";
+  const char script1[] = TEST_SCRIPT();
   Handle<JSFunction> f1 = Handle<JSFunction>::cast(RunJS(isolate(), script1));
   Handle<SharedFunctionInfo> shared1(f1->shared(), i_isolate());
-  const char script2[] =
-      "function g() { var y = 1; function f20(x) { return x * y }; "
-      "return f20; } g();";
+  const char script2[] = TEST_SCRIPT();
   Handle<JSFunction> f2 = Handle<JSFunction>::cast(RunJS(isolate(), script2));
   Handle<SharedFunctionInfo> shared2(f2->shared(), i_isolate());