Revert "[compiler-dispatcher] Use an integer job id."

This reverts commit 4bca9dc7.

Reason for revert: Breaks mips builder:
https://build.chromium.org/p/client.v8.ports/builders/V8%20Mips%20-%20builder/builds/8600

Original change's description:
> [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}

TBR=rmcilroy@chromium.org,marja@chromium.org,jochen@chromium.org,rmcilroy@google.com,wiktorg@google.com
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=v8:6093

Change-Id: Ie8d26f4e2d42f67a1cfa91269e80e407ed3f0799
Reviewed-on: https://chromium-review.googlesource.com/468887Reviewed-by: Michael Achenbach <machenbach@chromium.org>
Commit-Queue: Michael Achenbach <machenbach@chromium.org>
Cr-Commit-Position: refs/heads/master@{#44404}

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

@@ -63,8 +63,6 @@ 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,8 +221,6 @@ 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),
@@ -265,22 +263,6 @@ 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");
@@ -295,7 +277,10 @@ bool CompilerDispatcher::Enqueue(Handle<SharedFunctionInfo> function) {
 
   std::unique_ptr<CompilerDispatcherJob> job(new CompilerDispatcherJob(
       isolate_, tracer_.get(), function, max_stack_size_));
-  Enqueue(std::move(job));
+  std::pair<int, int> key(Script::cast(function->script())->id(),
+                          function->function_literal_id());
+  jobs_.insert(std::make_pair(key, std::move(job)));
+  ScheduleIdleTaskIfNeeded();
   return true;
 }
 
@@ -336,7 +321,10 @@ 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_));
-  Enqueue(std::move(job));
+  std::pair<int, int> key(Script::cast(function->script())->id(),
+                          function->function_literal_id());
+  jobs_.insert(std::make_pair(key, std::move(job)));
+  ScheduleIdleTaskIfNeeded();
   return true;
 }
 
@@ -420,9 +408,6 @@ 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_);
@@ -445,7 +430,6 @@ 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());
@@ -491,9 +475,6 @@ 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()) {
@@ -535,13 +516,14 @@ void CompilerDispatcher::MemoryPressureNotification(
 
 CompilerDispatcher::JobMap::const_iterator CompilerDispatcher::GetJobFor(
     Handle<SharedFunctionInfo> shared) const {
-  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;
+  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();
 }
 
 void CompilerDispatcher::ScheduleIdleTaskFromAnyThread() {
@@ -715,9 +697,6 @@ 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,7 +5,6 @@
 #ifndef V8_COMPILER_DISPATCHER_COMPILER_DISPATCHER_H_
 #define V8_COMPILER_DISPATCHER_COMPILER_DISPATCHER_H_
 
-#include <cstdint>
 #include <map>
 #include <memory>
 #include <unordered_set>
@@ -17,7 +16,6 @@
 #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 {
@@ -67,8 +65,6 @@ class Handle;
 // thread.
 class V8_EXPORT_PRIVATE CompilerDispatcher {
  public:
-  typedef uintptr_t JobId;
-
   enum class BlockingBehavior { kBlock, kDontBlock };
 
   CompilerDispatcher(Isolate* isolate, Platform* platform,
@@ -121,7 +117,6 @@ 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);
@@ -134,8 +129,9 @@ class V8_EXPORT_PRIVATE CompilerDispatcher {
   FRIEND_TEST(CompilerDispatcherTest, FinishNowDuringAbortAll);
   FRIEND_TEST(CompilerDispatcherTest, CompileMultipleOnBackgroundThread);
 
-  typedef std::map<JobId, std::unique_ptr<CompilerDispatcherJob>> JobMap;
-  typedef IdentityMap<JobId, FreeStoreAllocationPolicy> SharedToJobIdMap;
+  typedef std::multimap<std::pair<int, int>,
+                        std::unique_ptr<CompilerDispatcherJob>>
+      JobMap;
   class AbortTask;
   class BackgroundTask;
   class IdleTask;
@@ -151,7 +147,6 @@ 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_;
@@ -164,15 +159,10 @@ class V8_EXPORT_PRIVATE CompilerDispatcher {
 
   std::unique_ptr<CancelableTaskManager> task_manager_;
 
-  // Id for next job to be added
-  JobId next_job_id_;
-
-  // Mapping from job_id to job.
+  // Mapping from (script id, function literal id) to job. We use a multimap,
+  // as script id is not necessarily unique.
   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,10 +112,7 @@ 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) {
-    void* val = DeleteEntry(key);
-    return *reinterpret_cast<V*>(&val);
-  }
+  V Delete(Object* key) { return reinterpret_cast<V>(DeleteEntry(key)); }
 
   // Removes all elements from the map.
   void Clear() { IdentityMapBase::Clear(); }