Runtime: Remove ConcurrentMap

Author: slavapestov

include/swift/Runtime/Concurrent.h

@@ -47,271 +47,6 @@ static inline int comparePointers(const T *left, const T *right) {
   return (left == right ? 0 : std::less<const T *>()(left, right) ? -1 : 1);
 }
 
-template <class EntryTy, bool ProvideDestructor, class Allocator>
-class ConcurrentMapBase;
-
-/// The partial specialization of ConcurrentMapBase whose destructor is
-/// trivial.  The other implementation inherits from this, so this is a
-/// base for all ConcurrentMaps.
-template <class EntryTy, class Allocator>
-class ConcurrentMapBase<EntryTy, false, Allocator> : protected Allocator {
-protected:
-  struct Node {
-    std::atomic<Node*> Left;
-    std::atomic<Node*> Right;
-    EntryTy Payload;
-
-    template <class... Args>
-    Node(Args &&... args)
-      : Left(nullptr), Right(nullptr), Payload(std::forward<Args>(args)...) {}
-
-    Node(const Node &) = delete;
-    Node &operator=(const Node &) = delete;
-
-  #ifndef NDEBUG
-    void dump() const {
-      auto L = Left.load(std::memory_order_acquire);
-      auto R = Right.load(std::memory_order_acquire);
-      printf("\"%p\" [ label = \" {<f0> %08lx | {<f1> | <f2>}}\" "
-             "style=\"rounded\" shape=\"record\"];\n",
-             this, (long) Payload.getKeyValueForDump());
-
-      if (L) {
-        L->dump();
-        printf("\"%p\":f1 -> \"%p\":f0;\n", this, L);
-      }
-      if (R) {
-        R->dump();
-        printf("\"%p\":f2 -> \"%p\":f0;\n", this, R);
-      }
-    }
-  #endif
-  };
-
-  std::atomic<Node*> Root;
-
-  constexpr ConcurrentMapBase() : Root(nullptr) {}
-
-  // Implicitly trivial destructor.
-  ~ConcurrentMapBase() = default;
-
-  void destroyNode(Node *node) {
-    assert(node && "destroying null node");
-    auto allocSize = sizeof(Node) + node->Payload.getExtraAllocationSize();
-
-    // Destroy the node's payload.
-    node->~Node();
-
-    // Deallocate the node.  The static_cast here is required
-    // because LLVM's allocator API is insane.
-    this->Deallocate(static_cast<void*>(node), allocSize, alignof(Node));
-  }
-};
-
-/// The partial specialization of ConcurrentMapBase which provides a
-/// non-trivial destructor.
-template <class EntryTy, class Allocator>
-class ConcurrentMapBase<EntryTy, true, Allocator>
-    : protected ConcurrentMapBase<EntryTy, false, Allocator> {
-protected:
-  using super = ConcurrentMapBase<EntryTy, false, Allocator>;
-  using Node = typename super::Node;
-
-  constexpr ConcurrentMapBase() {}
-
-  ~ConcurrentMapBase() {
-    destroyTree(this->Root);
-  }
-
-private:
-  void destroyTree(const std::atomic<Node*> &edge) {
-    // This can be a relaxed load because destruction is not allowed to race
-    // with other operations.
-    auto node = edge.load(std::memory_order_relaxed);
-    if (!node) return;
-
-    // Destroy the node's children.
-    destroyTree(node->Left);
-    destroyTree(node->Right);
-
-    // Destroy the node itself.
-    this->destroyNode(node);
-  }
-};
-
-/// A concurrent map that is implemented using a binary tree. It supports
-/// concurrent insertions but does not support removals or rebalancing of
-/// the tree.
-///
-/// The entry type must provide the following operations:
-///
-///   /// For debugging purposes only. Summarize this key as an integer value.
-///   intptr_t getKeyIntValueForDump() const;
-///
-///   /// A ternary comparison.  KeyTy is the type of the key provided
-///   /// to find or getOrInsert.
-///   int compareWithKey(KeyTy key) const;
-///
-///   /// Return the amount of extra trailing space required by an entry,
-///   /// where KeyTy is the type of the first argument to getOrInsert and
-///   /// ArgTys is the type of the remaining arguments.
-///   static size_t getExtraAllocationSize(KeyTy key, ArgTys...)
-///
-///   /// Return the amount of extra trailing space that was requested for
-///   /// this entry.  This method is only used to compute the size of the
-///   /// object during node deallocation; it does not need to return a
-///   /// correct value so long as the allocator's Deallocate implementation
-///   /// ignores this argument.
-///   size_t getExtraAllocationSize() const;
-///
-/// If ProvideDestructor is false, the destructor will be trivial.  This
-/// can be appropriate when the object is declared at global scope.
-template <class EntryTy, bool ProvideDestructor = true,
-          class Allocator = llvm::MallocAllocator>
-class ConcurrentMap
-      : private ConcurrentMapBase<EntryTy, ProvideDestructor, Allocator> {
-  using super = ConcurrentMapBase<EntryTy, ProvideDestructor, Allocator>;
-
-  using Node = typename super::Node;
-
-  /// Inherited from base class:
-  ///   std::atomic<Node*> Root;
-  using super::Root;
-
-  /// This member stores the address of the last node that was found by the
-  /// search procedure. We cache the last search to accelerate code that
-  /// searches the same value in a loop.
-  std::atomic<Node*> LastSearch;
-
-public:
-  constexpr ConcurrentMap() : LastSearch(nullptr) {}
-
-  ConcurrentMap(const ConcurrentMap &) = delete;
-  ConcurrentMap &operator=(const ConcurrentMap &) = delete;
-
-  // ConcurrentMap<T, false> must have a trivial destructor.
-  ~ConcurrentMap() = default;
-
-public:
-
-  Allocator &getAllocator() {
-    return *this;
-  }
-
-#ifndef NDEBUG
-  void dump() const {
-    auto R = Root.load(std::memory_order_acquire);
-    printf("digraph g {\n"
-           "graph [ rankdir = \"TB\"];\n"
-           "node  [ fontsize = \"16\" ];\n"
-           "edge  [ ];\n");
-    if (R) {
-      R->dump();
-    }
-    printf("\n}\n");
-  }
-#endif
-
-  /// Search for a value by key \p Key.
-  /// \returns a pointer to the value or null if the value is not in the map.
-  template <class KeyTy>
-  EntryTy *find(const KeyTy &key) {
-    // Check if we are looking for the same key that we looked for in the last
-    // time we called this function.
-    if (Node *last = LastSearch.load(std::memory_order_acquire)) {
-      if (last->Payload.compareWithKey(key) == 0)
-        return &last->Payload;
-    }
-
-    // Search the tree, starting from the root.
-    Node *node = Root.load(std::memory_order_acquire);
-    while (node) {
-      int comparisonResult = node->Payload.compareWithKey(key);
-      if (comparisonResult == 0) {
-        LastSearch.store(node, std::memory_order_release);
-        return &node->Payload;
-      } else if (comparisonResult < 0) {
-        node = node->Left.load(std::memory_order_acquire);
-      } else {
-        node = node->Right.load(std::memory_order_acquire);
-      }
-    }
-
-    return nullptr;
-  }
-
-  /// Get or create an entry in the map.
-  ///
-  /// \returns the entry in the map and whether a new node was added (true)
-  ///   or already existed (false)
-  template <class KeyTy, class... ArgTys>
-  std::pair<EntryTy*, bool> getOrInsert(KeyTy key, ArgTys &&... args) {
-    // Check if we are looking for the same key that we looked for the
-    // last time we called this function.
-    if (Node *last = LastSearch.load(std::memory_order_acquire)) {
-      if (last && last->Payload.compareWithKey(key) == 0)
-        return { &last->Payload, false };
-    }
-
-    // The node we allocated.
-    Node *newNode = nullptr;
-
-    // Start from the root.
-    auto edge = &Root;
-
-    while (true) {
-      // Load the edge.
-      Node *node = edge->load(std::memory_order_acquire);
-
-      // If there's a node there, it's either a match or we're going to
-      // one of its children.
-      if (node) {
-      searchFromNode:
-
-        // Compare our key against the node's key.
-        int comparisonResult = node->Payload.compareWithKey(key);
-
-        // If it's equal, we can use this node.
-        if (comparisonResult == 0) {
-          // Destroy the node we allocated before if we're carrying one around.
-          if (newNode) this->destroyNode(newNode);
-
-          // Cache and report that we found an existing node.
-          LastSearch.store(node, std::memory_order_release);
-          return { &node->Payload, false };
-        }
-
-        // Otherwise, select the appropriate child edge and descend.
-        edge = (comparisonResult < 0 ? &node->Left : &node->Right);
-        continue;
-      }
-
-      // Create a new node.
-      if (!newNode) {
-        size_t allocSize =
-          sizeof(Node) + EntryTy::getExtraAllocationSize(key, args...);
-        void *memory = this->Allocate(allocSize, alignof(Node));
-        newNode = ::new (memory) Node(key, std::forward<ArgTys>(args)...);
-      }
-
-      // Try to set the edge to the new node.
-      if (std::atomic_compare_exchange_strong_explicit(edge, &node, newNode,
-                                                  std::memory_order_acq_rel,
-                                                  std::memory_order_acquire)) {
-        // If that succeeded, cache and report that we created a new node.
-        LastSearch.store(newNode, std::memory_order_release);
-        return { &newNode->Payload, true };
-      }
-
-      // Otherwise, we lost the race because some other thread initialized
-      // the edge before us.  node will be set to the current value;
-      // repeat the search from there.
-      assert(node && "spurious failure from compare_exchange_strong?");
-      goto searchFromNode;
-    }
-  }
-};
-
 /// A simple linked list representing pointers that need to be freed. This is
 /// not a concurrent data structure, just a bit of support used in the types
 /// below.

unittests/runtime/Metadata.cpp

@@ -144,39 +144,6 @@ TEST(StaticObjects, ini) {
   EXPECT_EQ(swift_retainCount(&StaticTestObj.obj), 1u);
 }
 
-TEST(Concurrent, ConcurrentMap) {
-  const int numElem = 100;
-
-  struct Entry {
-    size_t Key;
-    Entry(size_t key) : Key(key) {}
-    int compareWithKey(size_t key) const {
-      return (key == Key ? 0 : (key < Key ? -1 : 1));
-    }
-    static size_t getExtraAllocationSize(size_t key) { return 0; }
-    size_t getExtraAllocationSize() const { return 0; }
-  };
-
-  ConcurrentMap<Entry> Map;
-
-  // Add a bunch of numbers to the map concurrently.
-   auto results = RaceTest<int*>(
-    [&]() -> int* {
-      for (int i = 0; i < numElem; i++) {
-        size_t hash = (i * 123512) % 0xFFFF ;
-        Map.getOrInsert(hash);
-      }
-      return nullptr;
-    }
-  );
-
-  // Check that all of the values that we inserted are in the map.
-  for (int i=0; i < numElem; i++) {
-    size_t hash = (i * 123512) % 0xFFFF ;
-    EXPECT_TRUE(Map.find(hash));
-  }
-}
-
 FullMetadata<ClassMetadata> MetadataTest2 = {
   { { nullptr }, { &VALUE_WITNESS_SYM(Bo) } },
   { { nullptr }, ClassFlags(), 0, 0, 0, 0, 0, 0 }