mirror of
https://github.com/gabime/spdlog.git
synced 2025-01-13 01:10:26 +08:00
27e7412640
Paths pointing to the root of the library where replaced for ones relatives to each file. For example, inside /include/spdlog/details/file_helper.h: This will look for os.h in /include/spdlog/details/spdlog/details/ which doesn't exists. replaced with:
177 lines
5.5 KiB
C++
177 lines
5.5 KiB
C++
/*
|
|
A modified version of Bounded MPMC queue by Dmitry Vyukov.
|
|
|
|
Original code from:
|
|
http://www.1024cores.net/home/lock-free-algorithms/queues/bounded-mpmc-queue
|
|
|
|
licensed by Dmitry Vyukov under the terms below:
|
|
|
|
Simplified BSD license
|
|
|
|
Copyright (c) 2010-2011 Dmitry Vyukov. All rights reserved.
|
|
Redistribution and use in source and binary forms, with or without modification,
|
|
are permitted provided that the following conditions are met:
|
|
1. Redistributions of source code must retain the above copyright notice, this list of
|
|
conditions and the following disclaimer.
|
|
|
|
2. Redistributions in binary form must reproduce the above copyright notice, this list
|
|
of conditions and the following disclaimer in the documentation and/or other materials
|
|
provided with the distribution.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY DMITRY VYUKOV "AS IS" AND ANY EXPRESS OR IMPLIED
|
|
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
|
|
SHALL DMITRY VYUKOV OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
|
|
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
|
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
|
|
OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
|
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
The views and conclusions contained in the software and documentation are those of the authors and
|
|
should not be interpreted as representing official policies, either expressed or implied, of Dmitry Vyukov.
|
|
*/
|
|
|
|
/*
|
|
The code in its current form adds the license below:
|
|
|
|
Copyright(c) 2015 Gabi Melman.
|
|
Distributed under the MIT License (http://opensource.org/licenses/MIT)
|
|
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "../common.h"
|
|
|
|
#include <atomic>
|
|
#include <utility>
|
|
|
|
namespace spdlog
|
|
{
|
|
namespace details
|
|
{
|
|
|
|
template<typename T>
|
|
class mpmc_bounded_queue
|
|
{
|
|
public:
|
|
|
|
using item_type = T;
|
|
mpmc_bounded_queue(size_t buffer_size)
|
|
:max_size_(buffer_size),
|
|
buffer_(new cell_t[buffer_size]),
|
|
buffer_mask_(buffer_size - 1)
|
|
{
|
|
//queue size must be power of two
|
|
if (!((buffer_size >= 2) && ((buffer_size & (buffer_size - 1)) == 0)))
|
|
throw spdlog_ex("async logger queue size must be power of two");
|
|
|
|
for (size_t i = 0; i != buffer_size; i += 1)
|
|
buffer_[i].sequence_.store(i, std::memory_order_relaxed);
|
|
enqueue_pos_.store(0, std::memory_order_relaxed);
|
|
dequeue_pos_.store(0, std::memory_order_relaxed);
|
|
}
|
|
|
|
~mpmc_bounded_queue()
|
|
{
|
|
delete[] buffer_;
|
|
}
|
|
|
|
|
|
bool enqueue(T&& data)
|
|
{
|
|
cell_t* cell;
|
|
size_t pos = enqueue_pos_.load(std::memory_order_relaxed);
|
|
for (;;)
|
|
{
|
|
cell = &buffer_[pos & buffer_mask_];
|
|
size_t seq = cell->sequence_.load(std::memory_order_acquire);
|
|
intptr_t dif = static_cast<intptr_t>(seq) - static_cast<intptr_t>(pos);
|
|
if (dif == 0)
|
|
{
|
|
if (enqueue_pos_.compare_exchange_weak(pos, pos + 1, std::memory_order_relaxed))
|
|
break;
|
|
}
|
|
else if (dif < 0)
|
|
{
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
pos = enqueue_pos_.load(std::memory_order_relaxed);
|
|
}
|
|
}
|
|
cell->data_ = std::move(data);
|
|
cell->sequence_.store(pos + 1, std::memory_order_release);
|
|
return true;
|
|
}
|
|
|
|
bool dequeue(T& data)
|
|
{
|
|
cell_t* cell;
|
|
size_t pos = dequeue_pos_.load(std::memory_order_relaxed);
|
|
for (;;)
|
|
{
|
|
cell = &buffer_[pos & buffer_mask_];
|
|
size_t seq =
|
|
cell->sequence_.load(std::memory_order_acquire);
|
|
intptr_t dif = static_cast<intptr_t>(seq) - static_cast<intptr_t>(pos + 1);
|
|
if (dif == 0)
|
|
{
|
|
if (dequeue_pos_.compare_exchange_weak(pos, pos + 1, std::memory_order_relaxed))
|
|
break;
|
|
}
|
|
else if (dif < 0)
|
|
return false;
|
|
else
|
|
pos = dequeue_pos_.load(std::memory_order_relaxed);
|
|
}
|
|
data = std::move(cell->data_);
|
|
cell->sequence_.store(pos + buffer_mask_ + 1, std::memory_order_release);
|
|
return true;
|
|
}
|
|
|
|
bool is_empty()
|
|
{
|
|
size_t front, front1, back;
|
|
// try to take a consistent snapshot of front/tail.
|
|
do
|
|
{
|
|
front = enqueue_pos_.load(std::memory_order_acquire);
|
|
back = dequeue_pos_.load(std::memory_order_acquire);
|
|
front1 = enqueue_pos_.load(std::memory_order_relaxed);
|
|
}
|
|
while (front != front1);
|
|
return back == front;
|
|
}
|
|
|
|
private:
|
|
struct cell_t
|
|
{
|
|
std::atomic<size_t> sequence_;
|
|
T data_;
|
|
};
|
|
|
|
size_t const max_size_;
|
|
|
|
static size_t const cacheline_size = 64;
|
|
typedef char cacheline_pad_t[cacheline_size];
|
|
|
|
cacheline_pad_t pad0_;
|
|
cell_t* const buffer_;
|
|
size_t const buffer_mask_;
|
|
cacheline_pad_t pad1_;
|
|
std::atomic<size_t> enqueue_pos_;
|
|
cacheline_pad_t pad2_;
|
|
std::atomic<size_t> dequeue_pos_;
|
|
cacheline_pad_t pad3_;
|
|
|
|
mpmc_bounded_queue(mpmc_bounded_queue const&) = delete;
|
|
void operator= (mpmc_bounded_queue const&) = delete;
|
|
};
|
|
|
|
} // ns details
|
|
} // ns spdlog
|