Runtime: Remove ConcurrentList

Author: slavapestov

include/swift/Runtime/Concurrent.h

@@ -33,110 +33,6 @@
 
 namespace swift {
 
-/// This is a node in a concurrent linked list.
-template <class ElemTy> struct ConcurrentListNode {
-  ConcurrentListNode(ElemTy Elem) : Payload(Elem), Next(nullptr) {}
-  ConcurrentListNode(const ConcurrentListNode &) = delete;
-  ConcurrentListNode &operator=(const ConcurrentListNode &) = delete;
-
-  /// The element.
-  ElemTy Payload;
-  /// Points to the next link in the chain.
-  ConcurrentListNode<ElemTy> *Next;
-};
-
-/// This is a concurrent linked list. It supports insertion at the beginning
-/// of the list and traversal using iterators.
-/// This is a very simple implementation of a concurrent linked list
-/// using atomic operations. The 'push_front' method allocates a new link
-/// and attempts to compare and swap the old head pointer with pointer to
-/// the new link. This operation may fail many times if there are other
-/// contending threads, but eventually the head pointer is set to the new
-/// link that already points to the old head value. Notice that the more
-/// difficult feature of removing links is not supported.
-/// See 'push_front' for more details.
-template <class ElemTy> struct ConcurrentList {
-  ConcurrentList() : First(nullptr) {}
-  ~ConcurrentList() {
-    clear();
-  }
-
-  /// Remove all of the links in the chain. This method leaves
-  /// the list at a usable state and new links can be added.
-  /// Notice that this operation is non-sendable because
-  /// we have no way of ensuring that no one is currently
-  /// traversing the list.
-  void clear() {
-    // Iterate over the list and delete all the nodes.
-    auto Ptr = First.load(std::memory_order_acquire);
-    First.store(nullptr, std:: memory_order_release);
-
-    while (Ptr) {
-      auto N = Ptr->Next;
-      delete Ptr;
-      Ptr = N;
-    }
-  }
-
-  ConcurrentList(const ConcurrentList &) = delete;
-  ConcurrentList &operator=(const ConcurrentList &) = delete;
-
-  /// A list iterator.
-  struct ConcurrentListIterator :
-      public std::iterator<std::forward_iterator_tag, ElemTy> {
-
-    /// Points to the current link.
-    ConcurrentListNode<ElemTy> *Ptr;
-    /// C'tor.
-    ConcurrentListIterator(ConcurrentListNode<ElemTy> *P) : Ptr(P) {}
-    /// Move to the next element.
-    ConcurrentListIterator &operator++() {
-      Ptr = Ptr->Next;
-      return *this;
-    }
-    /// Access the element.
-    ElemTy &operator*() { return Ptr->Payload; }
-    /// Same?
-    bool operator==(const ConcurrentListIterator &o) const {
-      return o.Ptr == Ptr;
-    }
-    /// Not the same?
-    bool operator!=(const ConcurrentListIterator &o) const {
-      return o.Ptr != Ptr;
-    }
-  };
-
-  /// Iterator entry point.
-  typedef ConcurrentListIterator iterator;
-  /// Marks the beginning of the list.
-  iterator begin() const {
-    return ConcurrentListIterator(First.load(std::memory_order_acquire));
-  }
-  /// Marks the end of the list.
-  iterator end() const { return ConcurrentListIterator(nullptr); }
-
-  /// Add a new item to the list.
-  void push_front(ElemTy Elem) {
-    /// Allocate a new node.
-    ConcurrentListNode<ElemTy> *N = new ConcurrentListNode<ElemTy>(Elem);
-    // Point to the first element in the list.
-    N->Next = First.load(std::memory_order_acquire);
-    auto OldFirst = N->Next;
-    // Try to replace the current First with the new node.
-    while (!std::atomic_compare_exchange_weak_explicit(&First, &OldFirst, N,
-                                               std::memory_order_release,
-                                               std::memory_order_relaxed)) {
-      // If we fail, update the new node to point to the new head and try to
-      // insert before the new
-      // first element.
-      N->Next = OldFirst;
-    }
-  }
-
-  /// Points to the first link in the list.
-  std::atomic<ConcurrentListNode<ElemTy> *> First;
-};
-
 /// A utility function for ordering two integers, which is useful
 /// for implementing compareWithKey.
 template <class T>

unittests/runtime/Metadata.cpp

@@ -144,30 +144,6 @@ TEST(StaticObjects, ini) {
   EXPECT_EQ(swift_retainCount(&StaticTestObj.obj), 1u);
 }
 
-TEST(Concurrent, ConcurrentList) {
-  const int numElem = 100;
-  const int elemVal = 1;
-
-  ConcurrentList<int> List;
-  auto results = RaceTest<int*>(
-    [&]() -> int* {
-        for (int i = 0; i < numElem; i++)
-          List.push_front(elemVal);
-        return nullptr;
-    }
-  );
-
-  size_t ListLen = std::distance(List.begin(), List.end());
-  // Check that all of the values are initialized properly.
-  for (auto A : List) {
-    EXPECT_EQ(elemVal, A);
-  }
-
-  // Check that the length of the list is correct.
-  EXPECT_EQ(ListLen, results.size() * numElem);
-}
-
-
 TEST(Concurrent, ConcurrentMap) {
   const int numElem = 100;