mirror of
https://github.com/Chatterino/chatterino2.git
synced 2024-11-13 19:49:51 +01:00
81caf1aae0
* Use circular buffer for LimitedQueue * Reduce copying of snapshot * Small optimizations * Remove unneeded lock statements * Add LimitedQueue tests * Fix includes for limited queue benchmark * Update CHANGELOG.md * Use correct boost version iterators * Use a shared_mutex to clarify reads and writes * Update `find`/`rfind` to return the result as a boost::optional * Use `[[nodiscard]]` where applicable * Update comments * Add a couple more doc comments * Replace size with get get is a safe (locked & checked) version of at * Use std::vector in LimitedQueueSnapshot * Update LimitedQueue benchmarks * Add mutex guard to buffer accessors We do not know whether T is an atomic type or not so we can't safely say that we can copy the value at a certain address of the buffer. See https://stackoverflow.com/a/2252478 * Update doc comments, add first/last getters * Make limit_ const * Omit `else` if the if-case always returns * Title case category comments * Remove `at` * Fix `get` comment * Privatize/comment/lock property accessors - `limit` is now private - `space` is now private - `full` has been removed - `empty` now locks * Remove `front` function * Remove `back` method * Add comment to `first` * Add comment to `last` Co-authored-by: Rasmus Karlsson <rasmus.karlsson@pajlada.com>
117 lines
2.4 KiB
C++
117 lines
2.4 KiB
C++
#include "messages/LimitedQueue.hpp"
|
|
|
|
#include <benchmark/benchmark.h>
|
|
|
|
#include <memory>
|
|
#include <numeric>
|
|
#include <vector>
|
|
|
|
using namespace chatterino;
|
|
|
|
void BM_LimitedQueue_PushBack(benchmark::State &state)
|
|
{
|
|
LimitedQueue<int> queue(1000);
|
|
for (auto _ : state)
|
|
{
|
|
queue.pushBack(1);
|
|
}
|
|
}
|
|
|
|
void BM_LimitedQueue_PushFront_One(benchmark::State &state)
|
|
{
|
|
std::vector<int> items = {1};
|
|
LimitedQueue<int> queue(2);
|
|
|
|
for (auto _ : state)
|
|
{
|
|
state.PauseTiming();
|
|
queue.clear();
|
|
state.ResumeTiming();
|
|
queue.pushFront(items);
|
|
}
|
|
}
|
|
|
|
void BM_LimitedQueue_PushFront_Many(benchmark::State &state)
|
|
{
|
|
std::vector<int> items;
|
|
items.resize(10000);
|
|
std::iota(items.begin(), items.end(), 0);
|
|
|
|
for (auto _ : state)
|
|
{
|
|
state.PauseTiming();
|
|
LimitedQueue<int> queue(1000);
|
|
state.ResumeTiming();
|
|
queue.pushFront(items);
|
|
}
|
|
}
|
|
|
|
void BM_LimitedQueue_Replace(benchmark::State &state)
|
|
{
|
|
LimitedQueue<int> queue(1000);
|
|
for (int i = 0; i < 1000; ++i)
|
|
{
|
|
queue.pushBack(i);
|
|
}
|
|
|
|
for (auto _ : state)
|
|
{
|
|
queue.replaceItem(500, 500);
|
|
}
|
|
}
|
|
|
|
void BM_LimitedQueue_Snapshot(benchmark::State &state)
|
|
{
|
|
LimitedQueue<int> queue(1000);
|
|
for (int i = 0; i < 1000; ++i)
|
|
{
|
|
queue.pushBack(i);
|
|
}
|
|
|
|
for (auto _ : state)
|
|
{
|
|
auto snapshot = queue.getSnapshot();
|
|
benchmark::DoNotOptimize(snapshot);
|
|
}
|
|
}
|
|
|
|
void BM_LimitedQueue_Snapshot_ExpensiveCopy(benchmark::State &state)
|
|
{
|
|
LimitedQueue<std::shared_ptr<int>> queue(1000);
|
|
for (int i = 0; i < 1000; ++i)
|
|
{
|
|
queue.pushBack(std::make_shared<int>(i));
|
|
}
|
|
|
|
for (auto _ : state)
|
|
{
|
|
auto snapshot = queue.getSnapshot();
|
|
benchmark::DoNotOptimize(snapshot);
|
|
}
|
|
}
|
|
|
|
void BM_LimitedQueue_Find(benchmark::State &state)
|
|
{
|
|
LimitedQueue<int> queue(1000);
|
|
for (int i = 0; i < 10000; ++i)
|
|
{
|
|
queue.pushBack(i);
|
|
}
|
|
|
|
for (auto _ : state)
|
|
{
|
|
auto res = queue.find([](const auto &val) {
|
|
return val == 500;
|
|
});
|
|
benchmark::DoNotOptimize(res);
|
|
}
|
|
}
|
|
|
|
BENCHMARK(BM_LimitedQueue_PushBack);
|
|
BENCHMARK(BM_LimitedQueue_PushFront_One);
|
|
BENCHMARK(BM_LimitedQueue_PushFront_Many);
|
|
BENCHMARK(BM_LimitedQueue_Replace);
|
|
BENCHMARK(BM_LimitedQueue_Snapshot);
|
|
BENCHMARK(BM_LimitedQueue_Snapshot_ExpensiveCopy);
|
|
BENCHMARK(BM_LimitedQueue_Find);
|