Use a hash map for thread id lookup, rather than a linked list

When using node-fibers, we find ourselves spending 65% of our CPU time
traversing the thread table linked list.  Let's try a real data structure.

Author: zarvox

deps/v8/src/isolate.cc

@@ -8,6 +8,7 @@
 
 #include <fstream>  // NOLINT(readability/streams)
 #include <sstream>
+#include <unordered_map>
 
 #include "src/assembler-inl.h"
 #include "src/ast/ast-value-factory.h"
@@ -2095,7 +2096,7 @@ char* Isolate::RestoreThread(char* from) {
 
 
 Isolate::ThreadDataTable::ThreadDataTable()
-    : list_(NULL) {
+    : table_() {
 }
 
 
@@ -2155,34 +2156,38 @@ Isolate::PerIsolateThreadData::~PerIsolateThreadData() {
 Isolate::PerIsolateThreadData*
     Isolate::ThreadDataTable::Lookup(Isolate* isolate,
                                      ThreadId thread_id) {
-  for (PerIsolateThreadData* data = list_; data != NULL; data = data->next_) {
-    if (data->Matches(isolate, thread_id)) return data;
-  }
+  // We assume thread_ids are unique per-process, not just per-isolate.
+  // I hope this winds up being true.
+  auto t = table_.find(thread_id);
+  if (t == table_.end()) return NULL;
+  auto data = t->second;
+  if (data->Matches(isolate, thread_id)) return data;
   return NULL;
 }
 
 
 void Isolate::ThreadDataTable::Insert(Isolate::PerIsolateThreadData* data) {
-  if (list_ != NULL) list_->prev_ = data;
-  data->next_ = list_;
-  list_ = data;
+  table_[data->thread_id_] = data;
 }
 
 
 void Isolate::ThreadDataTable::Remove(PerIsolateThreadData* data) {
-  if (list_ == data) list_ = data->next_;
-  if (data->next_ != NULL) data->next_->prev_ = data->prev_;
-  if (data->prev_ != NULL) data->prev_->next_ = data->next_;
+  table_.erase(data->thread_id_);
   delete data;
 }
 
 
 void Isolate::ThreadDataTable::RemoveAllThreads(Isolate* isolate) {
-  PerIsolateThreadData* data = list_;
-  while (data != NULL) {
-    PerIsolateThreadData* next = data->next_;
-    if (data->isolate() == isolate) Remove(data);
-    data = next;
+  std::vector<PerIsolateThreadData*> values_to_remove;
+  for (auto& x: table_) {
+    PerIsolateThreadData* value = x.second;
+    if (value->isolate_ == isolate) {
+      values_to_remove.push_back(value);
+    }
+  }
+
+  for (auto& value: values_to_remove) {
+    Remove(value);
   }
 }
 

deps/v8/src/isolate.h

@@ -8,6 +8,7 @@
 #include <cstddef>
 #include <memory>
 #include <queue>
+#include <unordered_map>
 
 #include "include/v8-debug.h"
 #include "src/allocation.h"
@@ -243,6 +244,10 @@ class ThreadId {
     return *this;
   }
 
+  bool operator==(const ThreadId& other) const {
+    return Equals(other);
+  }
+
   // Returns ThreadId for current thread.
   static ThreadId Current() { return ThreadId(GetCurrentThreadId()); }
 
@@ -283,6 +288,13 @@ class ThreadId {
   friend class Isolate;
 };
 
+template <class T> struct ThreadIdHasher;
+template<> struct ThreadIdHasher<ThreadId> {
+  std::size_t operator()(ThreadId const& t) const {
+    // passthrough to std::hash on the thread id int
+    return std::hash<int>()(t.ToInteger());
+  }
+};
 
 #define FIELD_ACCESSOR(type, name)                 \
   inline void set_##name(type v) { name##_ = v; }  \
@@ -1347,7 +1359,7 @@ class Isolate {
     void RemoveAllThreads(Isolate* isolate);
 
    private:
-    PerIsolateThreadData* list_;
+    std::unordered_map<ThreadId, PerIsolateThreadData*, ThreadIdHasher<ThreadId> > table_;
   };
 
   // These items form a stack synchronously with threads Enter'ing and Exit'ing