Rename Common::FifoQueue to Common::SPSCQueue

Since all queues are FIFO data structures, the name wasn't informative
as to why you'd use it over a normal queue. I originally thought it had
something to do with the hardware graphics FIFO.

This renames it using the common acronym SPSC, which stands for
single-producer single-consumer, and is most commonly used to talk about
lock-free data structures, both of which this is.

Source/Core/Common/SPSCQueue.h

@@ -0,0 +1,110 @@
+// Copyright 2010 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#pragma once
+
+// a simple lockless thread-safe,
+// single producer, single consumer queue
+
+#include <algorithm>
+#include <atomic>
+#include <cstddef>
+
+#include "Common/CommonTypes.h"
+
+namespace Common
+{
+template <typename T, bool NeedSize = true>
+class SPSCQueue
+{
+public:
+  SPSCQueue() : m_size(0) { m_write_ptr = m_read_ptr = new ElementPtr(); }
+  ~SPSCQueue()
+  {
+    // this will empty out the whole queue
+    delete m_read_ptr;
+  }
+
+  u32 Size() const
+  {
+    static_assert(NeedSize, "using Size() on SPSCQueue without NeedSize");
+    return m_size.load();
+  }
+
+  bool Empty() const { return !m_read_ptr->next.load(); }
+  T& Front() const { return m_read_ptr->current; }
+  template <typename Arg>
+  void Push(Arg&& t)
+  {
+    // create the element, add it to the queue
+    m_write_ptr->current = std::forward<Arg>(t);
+    // set the next pointer to a new element ptr
+    // then advance the write pointer
+    ElementPtr* new_ptr = new ElementPtr();
+    m_write_ptr->next.store(new_ptr, std::memory_order_release);
+    m_write_ptr = new_ptr;
+    if (NeedSize)
+      m_size++;
+  }
+
+  void Pop()
+  {
+    if (NeedSize)
+      m_size--;
+    ElementPtr* tmpptr = m_read_ptr;
+    // advance the read pointer
+    m_read_ptr = tmpptr->next.load();
+    // set the next element to nullptr to stop the recursive deletion
+    tmpptr->next.store(nullptr);
+    delete tmpptr;  // this also deletes the element
+  }
+
+  bool Pop(T& t)
+  {
+    if (Empty())
+      return false;
+
+    if (NeedSize)
+      m_size--;
+
+    ElementPtr* tmpptr = m_read_ptr;
+    m_read_ptr = tmpptr->next.load(std::memory_order_acquire);
+    t = std::move(tmpptr->current);
+    tmpptr->next.store(nullptr);
+    delete tmpptr;
+    return true;
+  }
+
+  // not thread-safe
+  void Clear()
+  {
+    m_size.store(0);
+    delete m_read_ptr;
+    m_write_ptr = m_read_ptr = new ElementPtr();
+  }
+
+private:
+  // stores a pointer to element
+  // and a pointer to the next ElementPtr
+  class ElementPtr
+  {
+  public:
+    ElementPtr() : next(nullptr) {}
+    ~ElementPtr()
+    {
+      ElementPtr* next_ptr = next.load();
+
+      if (next_ptr)
+        delete next_ptr;
+    }
+
+    T current;
+    std::atomic<ElementPtr*> next;
+  };
+
+  ElementPtr* m_write_ptr;
+  ElementPtr* m_read_ptr;
+  std::atomic<u32> m_size;
+};
+}