ShuriZma
/
pcsx2
mirror of https://github.com/PCSX2/pcsx2.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

gsdx: Avoid "using namespace std" in spsc queue

This commit is contained in:
Jonathan Li 2017-03-15 00:19:13 +00:00
parent 9865270e68
commit 448ca97d93
1 changed files with 18 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
plugins/GSdx/boost_spsc_queue.hpp
View File

@ -46,17 +46,14 @@
#include <atomic>
// I don't like it
using namespace std;
template <typename T, size_t max_size>
class ringbuffer_base
{
static const int padding_size = 64 - sizeof(size_t);
atomic<size_t> write_index_;
std::atomic<size_t> write_index_;
char padding1[padding_size]; /* force read_index and write_index to different cache lines */
atomic<size_t> read_index_;
std::atomic<size_t> read_index_;
char padding2[padding_size]; /* force read_index and pending_pop_read_index to different cache lines */
size_t pending_pop_read_index;
@ -103,23 +100,23 @@ public:
bool push(T const & t)
{
const size_t write_index = write_index_.load(memory_order_relaxed); // only written from push thread
const size_t write_index = write_index_.load(std::memory_order_relaxed); // only written from push thread
const size_t next = next_index(write_index);
if (next == read_index_.load(memory_order_acquire))
if (next == read_index_.load(std::memory_order_acquire))
return false; /* ringbuffer is full */
new (buffer + write_index) T(t); // copy-construct
write_index_.store(next, memory_order_release);
write_index_.store(next, std::memory_order_release);
return true;
}
bool pop (T & ret)
{
const size_t write_index = write_index_.load(memory_order_acquire);
const size_t read_index = read_index_.load(memory_order_relaxed); // only written from pop thread
const size_t write_index = write_index_.load(std::memory_order_acquire);
const size_t read_index = read_index_.load(std::memory_order_relaxed); // only written from pop thread
if (empty(write_index, read_index))
return false;
@ -127,13 +124,13 @@ public:
buffer[read_index].~T();
size_t next = next_index(read_index);
read_index_.store(next, memory_order_release);
read_index_.store(next, std::memory_order_release);
return true;
}
T& front()
{
pending_pop_read_index = read_index_.load(memory_order_relaxed); // only written from pop thread
pending_pop_read_index = read_index_.load(std::memory_order_relaxed); // only written from pop thread
return buffer[pending_pop_read_index];
}
@ -143,14 +140,14 @@ public:
buffer[pending_pop_read_index].~T();
size_t next = next_index(pending_pop_read_index);
read_index_.store(next, memory_order_release);
read_index_.store(next, std::memory_order_release);
}
template <typename Functor>
bool consume_one(Functor & f)
{
const size_t write_index = write_index_.load(memory_order_acquire);
const size_t read_index = read_index_.load(memory_order_relaxed); // only written from pop thread
const size_t write_index = write_index_.load(std::memory_order_acquire);
const size_t read_index = read_index_.load(std::memory_order_relaxed); // only written from pop thread
if (empty(write_index, read_index))
return false;
@ -158,7 +155,7 @@ public:
buffer[read_index].~T();
size_t next = next_index(read_index);
read_index_.store(next, memory_order_release);
read_index_.store(next, std::memory_order_release);
return true;
}
@ -169,8 +166,8 @@ public:
* */
void reset(void)
{
write_index_.store(0, memory_order_relaxed);
read_index_.store(0, memory_order_release);
write_index_.store(0, std::memory_order_relaxed);
read_index_.store(0, std::memory_order_release);
}
/** Check if the ringbuffer is empty
@ -180,7 +177,7 @@ public:
* */
bool empty(void)
{
return empty(write_index_.load(memory_order_relaxed), read_index_.load(memory_order_relaxed));
return empty(write_index_.load(std::memory_order_relaxed), read_index_.load(std::memory_order_relaxed));
}
/**
@ -194,8 +191,8 @@ public:
size_t size() const
{
const size_t write_index = write_index_.load(memory_order_relaxed);
const size_t read_index = read_index_.load(memory_order_relaxed);
const size_t write_index = write_index_.load(std::memory_order_relaxed);
const size_t read_index = read_index_.load(std::memory_order_relaxed);
if (read_index > write_index) {
return (write_index + max_size) - read_index;
} else {