microsoft
/
L4
зеркало из https://github.com/microsoft/L4.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Apply clang-format (Chromium) (#13)

This commit is contained in:
Terry Kim 2019-07-13 20:19:07 -07:00 коммит произвёл GitHub
Родитель 32a7737afe
Коммит 64e70ac102
Не найден ключ, соответствующий данной подписи
Идентификатор ключа GPG: 4AEE18F83AFDEB23
64 изменённых файлов: 5013 добавлений и 5896 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

2
.gitignore поставляемый
Просмотреть файл

@ -67,3 +67,5 @@ ipch/
*.vsp
*.vspx
*.sap
*.htm
*.user

456
Benchmark/main.cpp
Просмотреть файл

@ -2,28 +2,21 @@
#include "L4/Log/PerfCounter.h"
#include <algorithm>
#include <boost/any.hpp>
#include <boost/program_options.hpp>
#include <chrono>
#include <condition_variable>
#include <iostream>
#include <string>
#include <thread>
#include <boost/any.hpp>
#include <boost/program_options.hpp>
class Timer
{
class Timer {
public:
Timer()
: m_start{ std::chrono::high_resolution_clock::now() }
{}
Timer() : m_start{std::chrono::high_resolution_clock::now()} {}
void Reset()
{
m_start = std::chrono::high_resolution_clock::now();
}
void Reset() { m_start = std::chrono::high_resolution_clock::now(); }
std::chrono::microseconds GetElapsedTime()
{
std::chrono::microseconds GetElapsedTime() {
return std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::high_resolution_clock::now() - m_start);
}
@ -32,30 +25,25 @@ private:
std::chrono::time_point<std::chrono::steady_clock> m_start;
};
class SynchronizedTimer
{
class SynchronizedTimer {
public:
SynchronizedTimer() = default;
void Start()
{
if (m_isStarted)
{
void Start() {
if (m_isStarted) {
return;
}
m_isStarted = true;
m_startCount = std::chrono::high_resolution_clock::now().time_since_epoch().count();
m_startCount =
std::chrono::high_resolution_clock::now().time_since_epoch().count();
}
void End()
{
m_endCount = std::chrono::high_resolution_clock::now().time_since_epoch().count();
void End() {
m_endCount =
std::chrono::high_resolution_clock::now().time_since_epoch().count();
}
std::chrono::microseconds GetElapsedTime()
{
std::chrono::microseconds GetElapsedTime() {
std::chrono::nanoseconds start{m_startCount};
std::chrono::nanoseconds end{m_endCount};
@ -68,25 +56,19 @@ private:
std::atomic_uint64_t m_endCount;
};
struct PerThreadInfoForWriteTest
{
struct PerThreadInfoForWriteTest {
std::thread m_thread;
std::size_t m_dataSetSize = 0;
std::chrono::microseconds m_totalTime;
};
struct PerThreadInfoForReadTest
{
struct PerThreadInfoForReadTest {
std::thread m_thread;
std::size_t m_dataSetSize = 0;
std::chrono::microseconds m_totalTime;
};
struct CommandLineOptions
{
struct CommandLineOptions {
static constexpr std::size_t c_defaultDataSetSize = 1000000;
static constexpr std::uint32_t c_defaultNumBuckets = 1000000;
static constexpr std::uint16_t c_defaultKeySize = 16;
@ -116,29 +98,24 @@ struct CommandLineOptions
std::uint64_t m_cacheSizeInBytes = 0U;
bool m_forceTimeBasedEviction = false;
bool IsCachingModule() const
{
bool IsCachingModule() const {
static const std::string c_cachingModulePrefix{"cache"};
return m_module.substr(0, c_cachingModulePrefix.size()) == c_cachingModulePrefix;
return m_module.substr(0, c_cachingModulePrefix.size()) ==
c_cachingModulePrefix;
}
};
class DataGenerator
{
class DataGenerator {
public:
DataGenerator(
std::size_t dataSetSize,
DataGenerator(std::size_t dataSetSize,
std::uint16_t keySize,
std::uint32_t valueSize,
bool randomizeValueSize,
bool isDebugMode = false)
: m_dataSetSize{ dataSetSize }
, m_keySize{ keySize }
{
if (isDebugMode)
{
std::cout << "Generating data set with size = " << dataSetSize << std::endl;
: m_dataSetSize{dataSetSize}, m_keySize{keySize} {
if (isDebugMode) {
std::cout << "Generating data set with size = " << dataSetSize
<< std::endl;
}
Timer timer;
@ -146,11 +123,11 @@ public:
// Populate keys.
m_keys.resize(m_dataSetSize);
m_keysBuffer.resize(m_dataSetSize);
for (std::size_t i = 0; i < m_dataSetSize; ++i)
{
for (std::size_t i = 0; i < m_dataSetSize; ++i) {
m_keysBuffer[i].resize(keySize);
std::generate(m_keysBuffer[i].begin(), m_keysBuffer[i].end(), std::rand);
std::snprintf(reinterpret_cast<char*>(m_keysBuffer[i].data()), keySize, "%llu", i);
std::snprintf(reinterpret_cast<char*>(m_keysBuffer[i].data()), keySize,
"%llu", i);
m_keys[i].m_data = m_keysBuffer[i].data();
m_keys[i].m_size = m_keySize;
}
@ -161,27 +138,24 @@ public:
// Populate values.
m_values.resize(m_dataSetSize);
std::size_t currentIndex = 0;
for (std::size_t i = 0; i < m_dataSetSize; ++i)
{
for (std::size_t i = 0; i < m_dataSetSize; ++i) {
m_values[i].m_data = &m_valuesBuffer[currentIndex % c_valuesBufferSize];
m_values[i].m_size = randomizeValueSize ? rand() % valueSize : valueSize;
currentIndex += valueSize;
}
if (isDebugMode)
{
if (isDebugMode) {
std::cout << "Finished generating data in "
<< timer.GetElapsedTime().count() << " microseconds" << std::endl;
<< timer.GetElapsedTime().count() << " microseconds"
<< std::endl;
}
}
L4::IReadOnlyHashTable::Key GetKey(std::size_t index) const
{
L4::IReadOnlyHashTable::Key GetKey(std::size_t index) const {
return m_keys[index % m_dataSetSize];
}
L4::IReadOnlyHashTable::Value GetValue(std::size_t index) const
{
L4::IReadOnlyHashTable::Value GetValue(std::size_t index) const {
return m_values[index % m_dataSetSize];
}
@ -197,9 +171,7 @@ private:
std::array<std::uint8_t, c_valuesBufferSize> m_valuesBuffer;
};
void PrintHardwareInfo()
{
void PrintHardwareInfo() {
SYSTEM_INFO sysInfo;
GetSystemInfo(&sysInfo);
@ -207,108 +179,100 @@ void PrintHardwareInfo()
printf("Hardware information: \n");
printf("-------------------------------------\n");
printf("%22s | %10u |\n", "OEM ID", sysInfo.dwOemId);
printf("%22s | %10u |\n", "Number of processors", sysInfo.dwNumberOfProcessors);
printf("%22s | %10u |\n", "Number of processors",
sysInfo.dwNumberOfProcessors);
printf("%22s | %10u |\n", "Page size", sysInfo.dwPageSize);
printf("%22s | %10u |\n", "Processor type", sysInfo.dwProcessorType);
printf("-------------------------------------\n");
printf("\n");
}
void PrintOptions(const CommandLineOptions& options)
{
void PrintOptions(const CommandLineOptions& options) {
printf("------------------------------------------------------\n");
printf("%39s | %10llu |\n", "Data set size", options.m_dataSetSize);
printf("%39s | %10lu |\n", "Number of hash table buckets", options.m_numBuckets);
printf("%39s | %10lu |\n", "Number of hash table buckets",
options.m_numBuckets);
printf("%39s | %10lu |\n", "Key size", options.m_keySize);
printf("%39s | %10lu |\n", "Value type", options.m_valueSize);
printf("%39s | %10lu |\n", "Number of iterations per GetContext()", options.m_numIterationsPerGetContext);
printf("%39s | %10lu |\n", "Epoch processing interval (ms)", options.m_epochProcessingIntervalInMilli);
printf("%39s | %10lu |\n", "Number of actions queue", options.m_numActionsQueue);
printf("%39s | %10lu |\n", "Number of iterations per GetContext()",
options.m_numIterationsPerGetContext);
printf("%39s | %10lu |\n", "Epoch processing interval (ms)",
options.m_epochProcessingIntervalInMilli);
printf("%39s | %10lu |\n", "Number of actions queue",
options.m_numActionsQueue);
if (options.IsCachingModule())
{
printf("%39s | %10lu |\n", "Record time to live (s)", options.m_recordTimeToLiveInSeconds);
printf("%39s | %10llu |\n", "Cache size in bytes", options.m_cacheSizeInBytes);
printf("%39s | %10lu |\n", "Force time-based eviction", options.m_forceTimeBasedEviction);
if (options.IsCachingModule()) {
printf("%39s | %10lu |\n", "Record time to live (s)",
options.m_recordTimeToLiveInSeconds);
printf("%39s | %10llu |\n", "Cache size in bytes",
options.m_cacheSizeInBytes);
printf("%39s | %10lu |\n", "Force time-based eviction",
options.m_forceTimeBasedEviction);
}
printf("------------------------------------------------------\n\n");
}
void PrintHashTableCounters(const L4::HashTablePerfData& perfData)
{
void PrintHashTableCounters(const L4::HashTablePerfData& perfData) {
printf("HashTableCounter:\n");
printf("----------------------------------------------------\n");
for (auto i = 0; i < static_cast<std::uint16_t>(L4::HashTablePerfCounter::Count); ++i)
{
printf("%35s | %12llu |\n",
L4::c_hashTablePerfCounterNames[i],
for (auto i = 0;
i < static_cast<std::uint16_t>(L4::HashTablePerfCounter::Count); ++i) {
printf("%35s | %12llu |\n", L4::c_hashTablePerfCounterNames[i],
perfData.Get(static_cast<L4::HashTablePerfCounter>(i)));
}
printf("----------------------------------------------------\n\n");
}
L4::HashTableConfig CreateHashTableConfig(const CommandLineOptions& options)
{
L4::HashTableConfig CreateHashTableConfig(const CommandLineOptions& options) {
return L4::HashTableConfig(
"Table1",
L4::HashTableConfig::Setting{ options.m_numBuckets },
"Table1", L4::HashTableConfig::Setting{options.m_numBuckets},
options.IsCachingModule()
? boost::optional<L4::HashTableConfig::Cache>{
L4::HashTableConfig::Cache{
? boost::optional<
L4::HashTableConfig::Cache>{L4::HashTableConfig::Cache{
options.m_cacheSizeInBytes,
std::chrono::seconds{options.m_recordTimeToLiveInSeconds},
options.m_forceTimeBasedEviction}}
: boost::none);
}
L4::EpochManagerConfig CreateEpochManagerConfig(const CommandLineOptions& options)
{
L4::EpochManagerConfig CreateEpochManagerConfig(
const CommandLineOptions& options) {
return L4::EpochManagerConfig(
10000U,
std::chrono::milliseconds(options.m_epochProcessingIntervalInMilli),
options.m_numActionsQueue);
}
void ReadPerfTest(const CommandLineOptions& options)
{
void ReadPerfTest(const CommandLineOptions& options) {
printf("Performing read-perf which reads all the records inserted:\n");
PrintOptions(options);
auto dataGenerator = std::make_unique<DataGenerator>(
options.m_dataSetSize,
options.m_keySize,
options.m_valueSize,
options.m_dataSetSize, options.m_keySize, options.m_valueSize,
options.m_randomizeValueSize);
L4::LocalMemory::HashTableService service(CreateEpochManagerConfig(options));
const auto hashTableIndex = service.AddHashTable(CreateHashTableConfig(options));
const auto hashTableIndex =
service.AddHashTable(CreateHashTableConfig(options));
// Insert data set.
auto context = service.GetContext();
auto& hashTable = context[hashTableIndex];
std::vector<std::uint32_t> randomIndices(options.m_dataSetSize);
for (std::uint32_t i = 0U; i < options.m_dataSetSize; ++i)
{
for (std::uint32_t i = 0U; i < options.m_dataSetSize; ++i) {
randomIndices[i] = i;
}
if (options.m_numThreads > 0)
{
if (options.m_numThreads > 0) {
// Randomize index only if multiple threads are running
// not to skew the results.
std::random_shuffle(randomIndices.begin(), randomIndices.end());
}
for (int i = 0; i < options.m_dataSetSize; ++i)
{
for (int i = 0; i < options.m_dataSetSize; ++i) {
auto key = dataGenerator->GetKey(randomIndices[i]);
auto val = dataGenerator->GetValue(randomIndices[i]);
@ -324,9 +288,9 @@ void ReadPerfTest(const CommandLineOptions& options)
const auto isCachingModule = options.IsCachingModule();
bool isReady = false;
const std::size_t dataSetSizePerThread = options.m_dataSetSize / options.m_numThreads;
for (std::uint16_t i = 0; i < options.m_numThreads; ++i)
{
const std::size_t dataSetSizePerThread =
options.m_dataSetSize / options.m_numThreads;
for (std::uint16_t i = 0; i < options.m_numThreads; ++i) {
auto& info = allInfo[i];
std::size_t startIndex = i * dataSetSizePerThread;
@ -334,8 +298,8 @@ void ReadPerfTest(const CommandLineOptions& options)
? options.m_dataSetSize - startIndex
: dataSetSizePerThread;
info.m_thread = std::thread([=, &service, &dataGenerator, &info, &mutex, &cv, &isReady, &overallTimer]
{
info.m_thread = std::thread([=, &service, &dataGenerator, &info, &mutex,
&cv, &isReady, &overallTimer] {
{
std::unique_lock<std::mutex> lock(mutex);
cv.wait(lock, [&] { return isReady == true; });
@ -349,19 +313,18 @@ void ReadPerfTest(const CommandLineOptions& options)
std::size_t iteration = 0;
bool isDone = false;
while (!isDone)
{
while (!isDone) {
auto context = service.GetContext();
auto& hashTable = context[hashTableIndex];
for (std::uint32_t j = 0; !isDone && j < options.m_numIterationsPerGetContext; ++j)
{
for (std::uint32_t j = 0;
!isDone && j < options.m_numIterationsPerGetContext; ++j) {
auto key = dataGenerator->GetKey(startIndex + iteration);
L4::IReadOnlyHashTable::Value val;
if (!hashTable.Get(key, val) && !isCachingModule)
{
throw std::runtime_error("Look up failure is not allowed in this test.");
if (!hashTable.Get(key, val) && !isCachingModule) {
throw std::runtime_error(
"Look up failure is not allowed in this test.");
}
isDone = (++iteration == info.m_dataSetSize);
@ -382,8 +345,7 @@ void ReadPerfTest(const CommandLineOptions& options)
// Now, start the benchmarking for all threads.
cv.notify_all();
for (auto& info : allInfo)
{
for (auto& info : allInfo) {
info.m_thread.join();
}
@ -394,56 +356,46 @@ void ReadPerfTest(const CommandLineOptions& options)
printf(" | micros/op | microseconds | DataSetSize |\n");
printf(" -----------------------------------------------------------\n");
for (std::size_t i = 0; i < allInfo.size(); ++i)
{
for (std::size_t i = 0; i < allInfo.size(); ++i) {
const auto& info = allInfo[i];
printf(" Thread #%llu | %11.3f | %14llu | %13llu |\n",
(i + 1),
printf(" Thread #%llu | %11.3f | %14llu | %13llu |\n", (i + 1),
static_cast<double>(info.m_totalTime.count()) / info.m_dataSetSize,
info.m_totalTime.count(),
info.m_dataSetSize);
info.m_totalTime.count(), info.m_dataSetSize);
}
printf(" -----------------------------------------------------------\n");
printf(" Overall | %11.3f | %14llu | %13llu |\n",
static_cast<double>(overallTimer.GetElapsedTime().count()) / options.m_dataSetSize,
overallTimer.GetElapsedTime().count(),
options.m_dataSetSize);
static_cast<double>(overallTimer.GetElapsedTime().count()) /
options.m_dataSetSize,
overallTimer.GetElapsedTime().count(), options.m_dataSetSize);
}
void WritePerfTest(const CommandLineOptions& options)
{
if (options.m_module == "overwrite-perf")
{
printf("Performing overwrite-perf (writing data with unique keys, then overwrite data with same keys):\n");
}
else
{
void WritePerfTest(const CommandLineOptions& options) {
if (options.m_module == "overwrite-perf") {
printf(
"Performing overwrite-perf (writing data with unique keys, then "
"overwrite data with same keys):\n");
} else {
printf("Performing write-perf (writing data with unique keys):\n");
}
PrintOptions(options);
auto dataGenerator = std::make_unique<DataGenerator>(
options.m_dataSetSize,
options.m_keySize,
options.m_valueSize,
options.m_dataSetSize, options.m_keySize, options.m_valueSize,
options.m_randomizeValueSize);
L4::LocalMemory::HashTableService service(CreateEpochManagerConfig(options));
const auto hashTableIndex = service.AddHashTable(CreateHashTableConfig(options));
const auto hashTableIndex =
service.AddHashTable(CreateHashTableConfig(options));
if (options.m_module == "overwrite-perf")
{
if (options.m_module == "overwrite-perf") {
std::vector<std::uint32_t> randomIndices(options.m_dataSetSize);
for (std::uint32_t i = 0U; i < options.m_dataSetSize; ++i)
{
for (std::uint32_t i = 0U; i < options.m_dataSetSize; ++i) {
randomIndices[i] = i;
}
if (options.m_numThreads > 0)
{
if (options.m_numThreads > 0) {
// Randomize index only if multiple threads are running
// not to skew the results.
std::random_shuffle(randomIndices.begin(), randomIndices.end());
@ -452,8 +404,7 @@ void WritePerfTest(const CommandLineOptions& options)
auto context = service.GetContext();
auto& hashTable = context[hashTableIndex];
for (int i = 0; i < options.m_dataSetSize; ++i)
{
for (int i = 0; i < options.m_dataSetSize; ++i) {
const auto index = randomIndices[i];
auto key = dataGenerator->GetKey(index);
auto val = dataGenerator->GetValue(index);
@ -470,9 +421,9 @@ void WritePerfTest(const CommandLineOptions& options)
std::condition_variable cv;
bool isReady = false;
const std::size_t dataSetSizePerThread = options.m_dataSetSize / options.m_numThreads;
for (std::uint16_t i = 0; i < options.m_numThreads; ++i)
{
const std::size_t dataSetSizePerThread =
options.m_dataSetSize / options.m_numThreads;
for (std::uint16_t i = 0; i < options.m_numThreads; ++i) {
auto& info = allInfo[i];
std::size_t startIndex = i * dataSetSizePerThread;
@ -480,8 +431,8 @@ void WritePerfTest(const CommandLineOptions& options)
? options.m_dataSetSize - startIndex
: dataSetSizePerThread;
info.m_thread = std::thread([=, &service, &dataGenerator, &info, &mutex, &cv, &isReady, &overallTimer]
{
info.m_thread = std::thread([=, &service, &dataGenerator, &info, &mutex,
&cv, &isReady, &overallTimer] {
{
std::unique_lock<std::mutex> lock(mutex);
cv.wait(lock, [&] { return isReady == true; });
@ -495,13 +446,12 @@ void WritePerfTest(const CommandLineOptions& options)
std::size_t iteration = 0;
bool isDone = false;
while (!isDone)
{
while (!isDone) {
auto context = service.GetContext();
auto& hashTable = context[hashTableIndex];
for (std::uint32_t j = 0; !isDone && j < options.m_numIterationsPerGetContext; ++j)
{
for (std::uint32_t j = 0;
!isDone && j < options.m_numIterationsPerGetContext; ++j) {
const auto index = startIndex + iteration;
auto key = dataGenerator->GetKey(index);
auto val = dataGenerator->GetValue(index);
@ -525,8 +475,7 @@ void WritePerfTest(const CommandLineOptions& options)
// Now, start the benchmarking for all threads.
cv.notify_all();
for (auto& info : allInfo)
{
for (auto& info : allInfo) {
info.m_thread.join();
}
@ -537,69 +486,94 @@ void WritePerfTest(const CommandLineOptions& options)
printf(" | micros/op | microseconds | DataSetSize |\n");
printf(" -----------------------------------------------------------\n");
for (std::size_t i = 0; i < allInfo.size(); ++i)
{
for (std::size_t i = 0; i < allInfo.size(); ++i) {
const auto& info = allInfo[i];
printf(" Thread #%llu | %11.3f | %14llu | %13llu |\n",
(i + 1),
printf(" Thread #%llu | %11.3f | %14llu | %13llu |\n", (i + 1),
static_cast<double>(info.m_totalTime.count()) / info.m_dataSetSize,
info.m_totalTime.count(),
info.m_dataSetSize);
info.m_totalTime.count(), info.m_dataSetSize);
}
printf(" -----------------------------------------------------------\n");
printf(" Overall | %11.3f | %14llu | %13llu |\n",
static_cast<double>(overallTimer.GetElapsedTime().count()) / options.m_dataSetSize,
overallTimer.GetElapsedTime().count(),
options.m_dataSetSize);
static_cast<double>(overallTimer.GetElapsedTime().count()) /
options.m_dataSetSize,
overallTimer.GetElapsedTime().count(), options.m_dataSetSize);
if (options.m_numThreads == 1)
{
if (options.m_numThreads == 1) {
auto& perfData = service.GetContext()[hashTableIndex].GetPerfData();
std::uint64_t totalBytes = perfData.Get(L4::HashTablePerfCounter::TotalKeySize)
+ perfData.Get(L4::HashTablePerfCounter::TotalValueSize);
std::uint64_t totalBytes =
perfData.Get(L4::HashTablePerfCounter::TotalKeySize) +
perfData.Get(L4::HashTablePerfCounter::TotalValueSize);
auto& info = allInfo[0];
double opsPerSec = static_cast<double>(info.m_dataSetSize) / info.m_totalTime.count() * 1000000.0;
double MBPerSec = static_cast<double>(totalBytes) / info.m_totalTime.count();
double opsPerSec = static_cast<double>(info.m_dataSetSize) /
info.m_totalTime.count() * 1000000.0;
double MBPerSec =
static_cast<double>(totalBytes) / info.m_totalTime.count();
printf(" %10.3f ops/sec %10.3f MB/sec\n", opsPerSec, MBPerSec);
}
}
CommandLineOptions Parse(int argc, char** argv)
{
CommandLineOptions Parse(int argc, char** argv) {
namespace po = boost::program_options;
po::options_description general("General options");
general.add_options()
("help", "produce a help message")
("help-module", po::value<std::string>(),
general.add_options()("help", "produce a help message")(
"help-module", po::value<std::string>(),
"produce a help for the following modules:\n"
" write-perf\n"
" overwrite-perf\n"
" read-perf\n"
" cache-read-perf\n"
" cache-write-perf\n")
("module", po::value<std::string>(),
" cache-write-perf\n")("module", po::value<std::string>(),
"Runs the given module");
po::options_description benchmarkOptions("Benchmark options.");
benchmarkOptions.add_options()
("dataSetSize", po::value<std::size_t>()->default_value(CommandLineOptions::c_defaultDataSetSize), "data set size")
("numBuckets", po::value<std::uint32_t>()->default_value(CommandLineOptions::c_defaultNumBuckets), "number of buckets")
("keySize", po::value<std::uint16_t>()->default_value(CommandLineOptions::c_defaultKeySize), "key size in bytes")
("valueSize", po::value<std::uint32_t>()->default_value(CommandLineOptions::c_defaultValueSize), "value size in bytes")
("randomizeValueSize", "randomize value size")
("numIterationsPerGetContext", po::value<std::uint32_t>()->default_value(CommandLineOptions::c_defaultNumIterationsPerGetContext), "number of iterations per GetContext()")
("numThreads", po::value<std::uint16_t>()->default_value(CommandLineOptions::c_defaultNumThreads), "number of threads to create")
("epochProcessingInterval", po::value<std::uint32_t>()->default_value(CommandLineOptions::c_defaultEpochProcessingIntervalInMilli), "epoch processing interval (ms)")
("numActionsQueue", po::value<std::uint8_t>()->default_value(CommandLineOptions::c_defaultNumActionsQueue), "number of actions queue")
("recordTimeToLive", po::value<std::uint32_t>()->default_value(CommandLineOptions::c_defaultRecordTimeToLiveInSeconds), "record time to live (s)")
("cacheSize", po::value<std::uint64_t>()->default_value(CommandLineOptions::c_defaultCacheSizeInBytes), "cache size in bytes")
("forceTimeBasedEviction", po::value<bool>()->default_value(CommandLineOptions::c_defaultForceTimeBasedEviction), "force time based eviction");
benchmarkOptions.add_options()("dataSetSize",
po::value<std::size_t>()->default_value(
CommandLineOptions::c_defaultDataSetSize),
"data set size")(
"numBuckets",
po::value<std::uint32_t>()->default_value(
CommandLineOptions::c_defaultNumBuckets),
"number of buckets")("keySize",
po::value<std::uint16_t>()->default_value(
CommandLineOptions::c_defaultKeySize),
"key size in bytes")(
"valueSize",
po::value<std::uint32_t>()->default_value(
CommandLineOptions::c_defaultValueSize),
"value size in bytes")("randomizeValueSize", "randomize value size")(
"numIterationsPerGetContext",
po::value<std::uint32_t>()->default_value(
CommandLineOptions::c_defaultNumIterationsPerGetContext),
"number of iterations per GetContext()")(
"numThreads",
po::value<std::uint16_t>()->default_value(
CommandLineOptions::c_defaultNumThreads),
"number of threads to create")(
"epochProcessingInterval",
po::value<std::uint32_t>()->default_value(
CommandLineOptions::c_defaultEpochProcessingIntervalInMilli),
"epoch processing interval (ms)")(
"numActionsQueue",
po::value<std::uint8_t>()->default_value(
CommandLineOptions::c_defaultNumActionsQueue),
"number of actions queue")(
"recordTimeToLive",
po::value<std::uint32_t>()->default_value(
CommandLineOptions::c_defaultRecordTimeToLiveInSeconds),
"record time to live (s)")(
"cacheSize",
po::value<std::uint64_t>()->default_value(
CommandLineOptions::c_defaultCacheSizeInBytes),
"cache size in bytes")(
"forceTimeBasedEviction",
po::value<bool>()->default_value(
CommandLineOptions::c_defaultForceTimeBasedEviction),
"force time based eviction");
po::options_description all("Allowed options");
all.add(general).add(benchmarkOptions);
@ -610,78 +584,62 @@ CommandLineOptions Parse(int argc, char** argv)
CommandLineOptions options;
if (vm.count("help"))
{
if (vm.count("help")) {
std::cout << all;
}
else if (vm.count("module"))
{
} else if (vm.count("module")) {
options.m_module = vm["module"].as<std::string>();
if (vm.count("dataSetSize"))
{
if (vm.count("dataSetSize")) {
options.m_dataSetSize = vm["dataSetSize"].as<std::size_t>();
}
if (vm.count("numBuckets"))
{
if (vm.count("numBuckets")) {
options.m_numBuckets = vm["numBuckets"].as<std::uint32_t>();
}
if (vm.count("keySize"))
{
if (vm.count("keySize")) {
options.m_keySize = vm["keySize"].as<std::uint16_t>();
}
if (vm.count("valueSize"))
{
if (vm.count("valueSize")) {
options.m_valueSize = vm["valueSize"].as<std::uint32_t>();
}
if (vm.count("randomizeValueSize"))
{
if (vm.count("randomizeValueSize")) {
options.m_randomizeValueSize = true;
}
if (vm.count("numIterationsPerGetContext"))
{
options.m_numIterationsPerGetContext = vm["numIterationsPerGetContext"].as<std::uint32_t>();
if (vm.count("numIterationsPerGetContext")) {
options.m_numIterationsPerGetContext =
vm["numIterationsPerGetContext"].as<std::uint32_t>();
}
if (vm.count("numThreads"))
{
if (vm.count("numThreads")) {
options.m_numThreads = vm["numThreads"].as<std::uint16_t>();
}
if (vm.count("epochProcessingInterval"))
{
options.m_epochProcessingIntervalInMilli = vm["epochProcessingInterval"].as<std::uint32_t>();
if (vm.count("epochProcessingInterval")) {
options.m_epochProcessingIntervalInMilli =
vm["epochProcessingInterval"].as<std::uint32_t>();
}
if (vm.count("numActionsQueue"))
{
if (vm.count("numActionsQueue")) {
options.m_numActionsQueue = vm["numActionsQueue"].as<std::uint8_t>();
}
if (vm.count("recordTimeToLive"))
{
options.m_recordTimeToLiveInSeconds = vm["recordTimeToLive"].as<std::uint32_t>();
if (vm.count("recordTimeToLive")) {
options.m_recordTimeToLiveInSeconds =
vm["recordTimeToLive"].as<std::uint32_t>();
}
if (vm.count("cacheSize"))
{
if (vm.count("cacheSize")) {
options.m_cacheSizeInBytes = vm["cacheSize"].as<std::uint64_t>();
}
if (vm.count("forceTimeBasedEviction"))
{
options.m_forceTimeBasedEviction = vm["forceTimeBasedEviction"].as<bool>();
if (vm.count("forceTimeBasedEviction")) {
options.m_forceTimeBasedEviction =
vm["forceTimeBasedEviction"].as<bool>();
}
}
else
{
} else {
std::cout << all;
}
return options;
}
int main(int argc, char** argv)
{
int main(int argc, char** argv) {
auto options = Parse(argc, argv);
if (options.m_module.empty())
{
if (options.m_module.empty()) {
return 0;
}
@ -689,22 +647,16 @@ int main(int argc, char** argv)
PrintHardwareInfo();
if (options.m_module == "write-perf"
|| options.m_module == "overwrite-perf"
|| options.m_module == "cache-write-perf")
{
if (options.m_module == "write-perf" ||
options.m_module == "overwrite-perf" ||
options.m_module == "cache-write-perf") {
WritePerfTest(options);
}
else if (options.m_module == "read-perf"
|| options.m_module == "cache-read-perf")
{
} else if (options.m_module == "read-perf" ||
options.m_module == "cache-read-perf") {
ReadPerfTest(options);
}
else
{
} else {
std::cout << "Unknown module: " << options.m_module << std::endl;
}
return 0;
}

37
Examples/main.cpp
Просмотреть файл

@ -6,21 +6,16 @@
using namespace L4;
void SimpleExample()
{
void SimpleExample() {
EpochManagerConfig epochConfig{1000, std::chrono::milliseconds(100), 1};
LocalMemory::HashTableService service{epochConfig};
auto hashTableIndex = service.AddHashTable(
HashTableConfig("Table1", HashTableConfig::Setting{1000000}));
std::vector<std::pair<std::string, std::string>> keyValuePairs =
{
{ "key1", "value1" },
{ "key2", "value2" },
{ "key3", "value3" },
{ "key4", "value4" },
{ "key5", "value5" },
std::vector<std::pair<std::string, std::string>> keyValuePairs = {
{"key1", "value1"}, {"key2", "value2"}, {"key3", "value3"},
{"key4", "value4"}, {"key5", "value5"},
};
// Write data.
@ -28,8 +23,7 @@ void SimpleExample()
auto context = service.GetContext();
auto& hashTable = context[hashTableIndex];
for (const auto& keyValuePair : keyValuePairs)
{
for (const auto& keyValuePair : keyValuePairs) {
const auto& keyStr = keyValuePair.first;
const auto& valStr = keyValuePair.second;
@ -53,8 +47,7 @@ void SimpleExample()
// operator[] on the context and Get() are lock-free.
auto& hashTable = context[hashTableIndex];
for (const auto& keyValuePair : keyValuePairs)
{
for (const auto& keyValuePair : keyValuePairs) {
const auto& keyStr = keyValuePair.first;
IWritableHashTable::Key key;
@ -64,13 +57,14 @@ void SimpleExample()
IWritableHashTable::Value val;
hashTable.Get(key, val);
std::cout << std::string(reinterpret_cast<const char*>(val.m_data), val.m_size) << std::endl;
std::cout << std::string(reinterpret_cast<const char*>(val.m_data),
val.m_size)
<< std::endl;
}
}
}
void CacheHashTableExample()
{
void CacheHashTableExample() {
LocalMemory::HashTableService service;
HashTableConfig::Cache cacheConfig{
@ -79,22 +73,17 @@ void CacheHashTableExample()
true // Remove any expired records during eviction.
};
auto hashTableIndex = service.AddHashTable(
HashTableConfig(
"Table1",
HashTableConfig::Setting{ 1000000 },
cacheConfig));
auto hashTableIndex = service.AddHashTable(HashTableConfig(
"Table1", HashTableConfig::Setting{1000000}, cacheConfig));
(void)hashTableIndex;
// Use hash table similar to SimpleExample().
}
int main()
{
int main() {
SimpleExample();
CacheHashTableExample();
return 0;
}

388
Unittests/CacheHashTableTest.cpp
Просмотреть файл

@ -1,38 +1,28 @@
#include <boost/test/unit_test.hpp>
#include <algorithm>
#include <boost/test/unit_test.hpp>
#include <sstream>
#include "Utils.h"
#include "Mocks.h"
#include "CheckedAllocator.h"
#include "L4/HashTable/Common/Record.h"
#include "L4/HashTable/Cache/Metadata.h"
#include "L4/HashTable/Cache/HashTable.h"
#include "L4/HashTable/Cache/Metadata.h"
#include "L4/HashTable/Common/Record.h"
#include "Mocks.h"
#include "Utils.h"
namespace L4
{
namespace UnitTests
{
namespace L4 {
namespace UnitTests {
using namespace HashTable::Cache;
using namespace std::chrono;
class MockClock
{
class MockClock {
public:
MockClock() = default;
seconds GetCurrentEpochTime() const
{
return s_currentEpochTime;
}
seconds GetCurrentEpochTime() const { return s_currentEpochTime; }
static void SetEpochTime(seconds time)
{
s_currentEpochTime = time;
}
static void SetEpochTime(seconds time) { s_currentEpochTime = time; }
static void IncrementEpochTime(seconds increment)
{
static void IncrementEpochTime(seconds increment) {
s_currentEpochTime += increment;
}
@ -42,9 +32,7 @@ private:
seconds MockClock::s_currentEpochTime{0U};
class CacheHashTableTestFixture
{
class CacheHashTableTestFixture {
public:
using Allocator = CheckedAllocator<>;
using CacheHashTable = WritableHashTable<Allocator, MockClock>;
@ -52,58 +40,59 @@ public:
using HashTable = CacheHashTable::HashTable;
CacheHashTableTestFixture()
: m_allocator{}
, m_hashTable { HashTable::Setting{ 100U }, m_allocator }
, m_epochManager{}
{
: m_allocator{},
m_hashTable{HashTable::Setting{100U}, m_allocator},
m_epochManager{} {
MockClock::SetEpochTime(seconds{0U});
}
CacheHashTableTestFixture(const CacheHashTableTestFixture&) = delete;
CacheHashTableTestFixture& operator=(const CacheHashTableTestFixture&) = delete;
CacheHashTableTestFixture& operator=(const CacheHashTableTestFixture&) =
delete;
protected:
template <typename TCacheHashTable>
bool Get(TCacheHashTable& hashTable, const std::string& key, IReadOnlyHashTable::Value& value)
{
bool Get(TCacheHashTable& hashTable,
const std::string& key,
IReadOnlyHashTable::Value& value) {
return hashTable.Get(
Utils::ConvertFromString<IReadOnlyHashTable::Key>(key.c_str()),
value);
Utils::ConvertFromString<IReadOnlyHashTable::Key>(key.c_str()), value);
}
void Add(CacheHashTable& hashTable, const std::string& key, const std::string& value)
{
void Add(CacheHashTable& hashTable,
const std::string& key,
const std::string& value) {
hashTable.Add(
Utils::ConvertFromString<IReadOnlyHashTable::Key>(key.c_str()),
Utils::ConvertFromString<IReadOnlyHashTable::Value>(value.c_str()));
}
void Remove(CacheHashTable& hashTable, const std::string& key)
{
hashTable.Remove(Utils::ConvertFromString<IReadOnlyHashTable::Key>(key.c_str()));
void Remove(CacheHashTable& hashTable, const std::string& key) {
hashTable.Remove(
Utils::ConvertFromString<IReadOnlyHashTable::Key>(key.c_str()));
}
template <typename TCacheHashTable>
bool CheckRecord(TCacheHashTable& hashTable, const std::string& key, const std::string& expectedValue)
{
bool CheckRecord(TCacheHashTable& hashTable,
const std::string& key,
const std::string& expectedValue) {
IReadOnlyHashTable::Value value;
return Get(hashTable, key, value) && AreTheSame(value, expectedValue);
}
bool AreTheSame(const IReadOnlyHashTable::Value& actual, const std::string& expected)
{
return (actual.m_size == expected.size())
&& !memcmp(actual.m_data, expected.c_str(), actual.m_size);
bool AreTheSame(const IReadOnlyHashTable::Value& actual,
const std::string& expected) {
return (actual.m_size == expected.size()) &&
!memcmp(actual.m_data, expected.c_str(), actual.m_size);
}
template <typename Blob>
bool Exist(const Blob& actual, const std::vector<std::string>& expectedSet)
{
const std::string actualStr(
reinterpret_cast<const char*>(actual.m_data),
bool Exist(const Blob& actual, const std::vector<std::string>& expectedSet) {
const std::string actualStr(reinterpret_cast<const char*>(actual.m_data),
actual.m_size);
return std::find(expectedSet.cbegin(), expectedSet.cend(), actualStr) != expectedSet.cend();
return std::find(expectedSet.cbegin(), expectedSet.cend(), actualStr) !=
expectedSet.cend();
}
Allocator m_allocator;
@ -112,18 +101,15 @@ protected:
MockClock m_clock;
};
BOOST_AUTO_TEST_SUITE(CacheHashTableTests)
BOOST_AUTO_TEST_CASE(MetadataTest)
{
BOOST_AUTO_TEST_CASE(MetadataTest) {
std::vector<std::uint8_t> buffer(20);
// The following will test with 1..8 byte alignments.
for (std::uint16_t i = 0U; i < 8U; ++i)
{
std::uint32_t* metadataBuffer = reinterpret_cast<std::uint32_t*>(buffer.data() + i);
for (std::uint16_t i = 0U; i < 8U; ++i) {
std::uint32_t* metadataBuffer =
reinterpret_cast<std::uint32_t*>(buffer.data() + i);
seconds currentEpochTime{0x7FABCDEF};
Metadata metadata{metadataBuffer, currentEpochTime};
@ -149,46 +135,33 @@ BOOST_AUTO_TEST_CASE(MetadataTest)
}
}
BOOST_FIXTURE_TEST_CASE(ExpirationTest, CacheHashTableTestFixture)
{
BOOST_FIXTURE_TEST_CASE(ExpirationTest, CacheHashTableTestFixture) {
// Don't care about evict in this test case, so make the cache size big.
constexpr std::uint64_t c_maxCacheSizeInBytes = 0xFFFFFFFF;
constexpr seconds c_recordTimeToLive{20U};
CacheHashTable hashTable(
m_hashTable,
m_epochManager,
c_maxCacheSizeInBytes,
c_recordTimeToLive,
false);
CacheHashTable hashTable(m_hashTable, m_epochManager, c_maxCacheSizeInBytes,
c_recordTimeToLive, false);
const std::vector<std::pair<std::string, std::string>> c_keyValuePairs =
{
const std::vector<std::pair<std::string, std::string>> c_keyValuePairs = {
{"key1", "value1"},
{"key2", "value2"},
{"key3", "value3"},
{"key4", "value4"},
{ "key5", "value5" }
};
{"key5", "value5"}};
// Add 5 records at a different epoch time (10 seconds increment).
for (const auto& pair : c_keyValuePairs)
{
for (const auto& pair : c_keyValuePairs) {
MockClock::IncrementEpochTime(seconds{10});
Add(hashTable, pair.first, pair.second);
// Make sure the records can be retrieved right away. The record has not been
// expired since the clock hasn't moved yet.
// Make sure the records can be retrieved right away. The record has not
// been expired since the clock hasn't moved yet.
BOOST_CHECK(CheckRecord(hashTable, pair.first, pair.second));
}
const auto& perfData = hashTable.GetPerfData();
Utils::ValidateCounters(
perfData,
{
{ HashTablePerfCounter::CacheHitCount, 5 }
});
Utils::ValidateCounters(perfData, {{HashTablePerfCounter::CacheHitCount, 5}});
// Now we have the following data sets:
// | Key | Value | Creation time |
@ -200,64 +173,48 @@ BOOST_FIXTURE_TEST_CASE(ExpirationTest, CacheHashTableTestFixture)
// And the current clock is at 50.
// Do look ups and check expired records.
for (const auto& pair : c_keyValuePairs)
{
for (const auto& pair : c_keyValuePairs) {
IReadOnlyHashTable::Value value;
// Our time to live value is 20, so key0 and key0 records should be expired.
if (pair.first == "key1" || pair.first == "key2")
{
if (pair.first == "key1" || pair.first == "key2") {
BOOST_CHECK(!Get(hashTable, pair.first, value));
}
else
{
} else {
BOOST_CHECK(CheckRecord(hashTable, pair.first, pair.second));
}
}
Utils::ValidateCounters(
perfData,
{
{ HashTablePerfCounter::CacheHitCount, 8 },
{ HashTablePerfCounter::CacheMissCount, 2 }
});
Utils::ValidateCounters(perfData,
{{HashTablePerfCounter::CacheHitCount, 8},
{HashTablePerfCounter::CacheMissCount, 2}});
MockClock::IncrementEpochTime(seconds{100});
// All the records should be expired now.
for (const auto& pair : c_keyValuePairs)
{
for (const auto& pair : c_keyValuePairs) {
IReadOnlyHashTable::Value value;
BOOST_CHECK(!Get(hashTable, pair.first, value));
}
Utils::ValidateCounters(
perfData,
{
{ HashTablePerfCounter::CacheHitCount, 8 },
{ HashTablePerfCounter::CacheMissCount, 7 }
});
Utils::ValidateCounters(perfData,
{{HashTablePerfCounter::CacheHitCount, 8},
{HashTablePerfCounter::CacheMissCount, 7}});
}
BOOST_FIXTURE_TEST_CASE(CacheHashTableIteratorTest, CacheHashTableTestFixture)
{
BOOST_FIXTURE_TEST_CASE(CacheHashTableIteratorTest, CacheHashTableTestFixture) {
// Don't care about evict in this test case, so make the cache size big.
constexpr std::uint64_t c_maxCacheSizeInBytes = 0xFFFFFFFF;
constexpr seconds c_recordTimeToLive{20U};
CacheHashTable hashTable(
m_hashTable,
m_epochManager,
c_maxCacheSizeInBytes,
c_recordTimeToLive,
false);
CacheHashTable hashTable(m_hashTable, m_epochManager, c_maxCacheSizeInBytes,
c_recordTimeToLive, false);
const std::vector<std::string> c_keys = { "key1", "key2", "key3", "key4", "key5" };
const std::vector<std::string> c_vals = { "val1", "val2", "val3", "val4", "val5" };
const std::vector<std::string> c_keys = {"key1", "key2", "key3", "key4",
"key5"};
const std::vector<std::string> c_vals = {"val1", "val2", "val3", "val4",
"val5"};
// Add 5 records at a different epoch time (3 seconds increment).
for (std::size_t i = 0; i < c_keys.size(); ++i)
{
for (std::size_t i = 0; i < c_keys.size(); ++i) {
MockClock::IncrementEpochTime(seconds{3});
Add(hashTable, c_keys[i], c_vals[i]);
}
@ -273,8 +230,7 @@ BOOST_FIXTURE_TEST_CASE(CacheHashTableIteratorTest, CacheHashTableTestFixture)
auto iterator = hashTable.GetIterator();
std::uint16_t numRecords = 0;
while (iterator->MoveNext())
{
while (iterator->MoveNext()) {
++numRecords;
BOOST_CHECK(Exist(iterator->GetKey(), c_keys));
BOOST_CHECK(Exist(iterator->GetValue(), c_vals));
@ -287,16 +243,13 @@ BOOST_FIXTURE_TEST_CASE(CacheHashTableIteratorTest, CacheHashTableTestFixture)
iterator = hashTable.GetIterator();
numRecords = 0;
while (iterator->MoveNext())
{
while (iterator->MoveNext()) {
++numRecords;
BOOST_CHECK(
Exist(
iterator->GetKey(),
Exist(iterator->GetKey(),
std::vector<std::string>{c_keys.cbegin() + 2, c_keys.cend()}));
BOOST_CHECK(
Exist(
iterator->GetValue(),
Exist(iterator->GetValue(),
std::vector<std::string>{c_vals.cbegin() + 2, c_vals.cend()}));
}
@ -306,46 +259,36 @@ BOOST_FIXTURE_TEST_CASE(CacheHashTableIteratorTest, CacheHashTableTestFixture)
MockClock::IncrementEpochTime(seconds{10});
iterator = hashTable.GetIterator();
while (iterator->MoveNext())
{
while (iterator->MoveNext()) {
BOOST_CHECK(false);
}
}
BOOST_FIXTURE_TEST_CASE(TimeBasedEvictionTest, CacheHashTableTestFixture)
{
// We only care about time-based eviction in this test, so make the cache size big.
BOOST_FIXTURE_TEST_CASE(TimeBasedEvictionTest, CacheHashTableTestFixture) {
// We only care about time-based eviction in this test, so make the cache size
// big.
constexpr std::uint64_t c_maxCacheSizeInBytes = 0xFFFFFFFF;
constexpr seconds c_recordTimeToLive{10U};
// Hash table with one bucket makes testing the time-based eviction easy.
HashTable internalHashTable{HashTable::Setting{1}, m_allocator};
CacheHashTable hashTable(
internalHashTable,
m_epochManager,
c_maxCacheSizeInBytes,
c_recordTimeToLive,
true);
CacheHashTable hashTable(internalHashTable, m_epochManager,
c_maxCacheSizeInBytes, c_recordTimeToLive, true);
const std::vector<std::pair<std::string, std::string>> c_keyValuePairs =
{
const std::vector<std::pair<std::string, std::string>> c_keyValuePairs = {
{"key1", "value1"},
{"key2", "value2"},
{"key3", "value3"},
{"key4", "value4"},
{ "key5", "value5" }
};
{"key5", "value5"}};
for (const auto& pair : c_keyValuePairs)
{
for (const auto& pair : c_keyValuePairs) {
Add(hashTable, pair.first, pair.second);
BOOST_CHECK(CheckRecord(hashTable, pair.first, pair.second));
}
const auto& perfData = hashTable.GetPerfData();
Utils::ValidateCounters(
perfData,
Utils::ValidateCounters(perfData,
{
{HashTablePerfCounter::CacheHitCount, 5},
{HashTablePerfCounter::RecordsCount, 5},
@ -355,14 +298,12 @@ BOOST_FIXTURE_TEST_CASE(TimeBasedEvictionTest, CacheHashTableTestFixture)
MockClock::IncrementEpochTime(seconds{20});
// All the records should be expired now.
for (const auto& pair : c_keyValuePairs)
{
for (const auto& pair : c_keyValuePairs) {
IReadOnlyHashTable::Value value;
BOOST_CHECK(!Get(hashTable, pair.first, value));
}
Utils::ValidateCounters(
perfData,
Utils::ValidateCounters(perfData,
{
{HashTablePerfCounter::CacheHitCount, 5},
{HashTablePerfCounter::CacheMissCount, 5},
@ -374,78 +315,70 @@ BOOST_FIXTURE_TEST_CASE(TimeBasedEvictionTest, CacheHashTableTestFixture)
const auto& keyValuePair = c_keyValuePairs[0];
Add(hashTable, keyValuePair.first, keyValuePair.second);
Utils::ValidateCounters(
perfData,
Utils::ValidateCounters(perfData,
{
{HashTablePerfCounter::RecordsCount, 1},
{HashTablePerfCounter::EvictedRecordsCount, 5},
});
}
BOOST_FIXTURE_TEST_CASE(EvcitAllRecordsTest, CacheHashTableTestFixture)
{
BOOST_FIXTURE_TEST_CASE(EvcitAllRecordsTest, CacheHashTableTestFixture) {
const auto& perfData = m_hashTable.m_perfData;
const auto initialTotalIndexSize = perfData.Get(HashTablePerfCounter::TotalIndexSize);
const auto initialTotalIndexSize =
perfData.Get(HashTablePerfCounter::TotalIndexSize);
const std::uint64_t c_maxCacheSizeInBytes = 500 + initialTotalIndexSize;
constexpr seconds c_recordTimeToLive{5};
CacheHashTable hashTable{
m_hashTable,
m_epochManager,
c_maxCacheSizeInBytes,
c_recordTimeToLive,
false };
CacheHashTable hashTable{m_hashTable, m_epochManager, c_maxCacheSizeInBytes,
c_recordTimeToLive, false};
Utils::ValidateCounters(
perfData,
Utils::ValidateCounters(perfData,
{
{HashTablePerfCounter::EvictedRecordsCount, 0},
});
const std::vector<std::pair<std::string, std::string>> c_keyValuePairs =
{
const std::vector<std::pair<std::string, std::string>> c_keyValuePairs = {
{"key1", "value1"},
{"key2", "value2"},
{"key3", "value3"},
{"key4", "value4"},
{ "key5", "value5" }
};
{"key5", "value5"}};
for (const auto& pair : c_keyValuePairs)
{
for (const auto& pair : c_keyValuePairs) {
Add(hashTable, pair.first, pair.second);
}
using L4::HashTable::RecordSerializer;
// Variable key/value sizes.
const auto recordOverhead = RecordSerializer{ 0U, 0U }.CalculateRecordOverhead();
const auto recordOverhead =
RecordSerializer{0U, 0U}.CalculateRecordOverhead();
Utils::ValidateCounters(
perfData,
{
{HashTablePerfCounter::RecordsCount, c_keyValuePairs.size()},
{ HashTablePerfCounter::TotalIndexSize, initialTotalIndexSize + (c_keyValuePairs.size() * recordOverhead) },
{HashTablePerfCounter::TotalIndexSize,
initialTotalIndexSize + (c_keyValuePairs.size() * recordOverhead)},
{HashTablePerfCounter::EvictedRecordsCount, 0},
});
// Make sure all data records added are present and update the access status for each
// record in order to test that accessed records are deleted when it's under memory constraint.
for (const auto& pair : c_keyValuePairs)
{
// Make sure all data records added are present and update the access status
// for each record in order to test that accessed records are deleted when
// it's under memory constraint.
for (const auto& pair : c_keyValuePairs) {
BOOST_CHECK(CheckRecord(hashTable, pair.first, pair.second));
}
// Now insert a record that will force all the records to be evicted due to size.
// Now insert a record that will force all the records to be evicted due to
// size.
std::string bigRecordKeyStr(10, 'k');
std::string bigRecordValStr(500, 'v');
Add(hashTable, bigRecordKeyStr, bigRecordValStr);
// Make sure all the previously inserted records are evicted.
for (const auto& pair : c_keyValuePairs)
{
for (const auto& pair : c_keyValuePairs) {
IReadOnlyHashTable::Value value;
BOOST_CHECK(!Get(hashTable, pair.first, value));
}
@ -457,36 +390,31 @@ BOOST_FIXTURE_TEST_CASE(EvcitAllRecordsTest, CacheHashTableTestFixture)
perfData,
{
{HashTablePerfCounter::RecordsCount, 1},
{ HashTablePerfCounter::TotalIndexSize, initialTotalIndexSize + (1 * recordOverhead) },
{HashTablePerfCounter::TotalIndexSize,
initialTotalIndexSize + (1 * recordOverhead)},
{HashTablePerfCounter::EvictedRecordsCount, c_keyValuePairs.size()},
});
}
BOOST_FIXTURE_TEST_CASE(EvcitRecordsBasedOnAccessStatusTest, CacheHashTableTestFixture)
{
const std::uint64_t c_maxCacheSizeInBytes
= 2000 + m_hashTable.m_perfData.Get(HashTablePerfCounter::TotalIndexSize);
BOOST_FIXTURE_TEST_CASE(EvcitRecordsBasedOnAccessStatusTest,
CacheHashTableTestFixture) {
const std::uint64_t c_maxCacheSizeInBytes =
2000 + m_hashTable.m_perfData.Get(HashTablePerfCounter::TotalIndexSize);
const seconds c_recordTimeToLive{5};
CacheHashTable hashTable(
m_hashTable,
m_epochManager,
c_maxCacheSizeInBytes,
c_recordTimeToLive,
false);
CacheHashTable hashTable(m_hashTable, m_epochManager, c_maxCacheSizeInBytes,
c_recordTimeToLive, false);
constexpr std::uint32_t c_valueSize = 100;
const std::string c_valStr(c_valueSize, 'v');
const auto& perfData = hashTable.GetPerfData();
std::uint16_t key = 1;
while ((static_cast<std::uint64_t>(perfData.Get(HashTablePerfCounter::TotalIndexSize))
+ perfData.Get(HashTablePerfCounter::TotalKeySize)
+ perfData.Get(HashTablePerfCounter::TotalValueSize)
+ c_valueSize)
< c_maxCacheSizeInBytes)
{
while ((static_cast<std::uint64_t>(
perfData.Get(HashTablePerfCounter::TotalIndexSize)) +
perfData.Get(HashTablePerfCounter::TotalKeySize) +
perfData.Get(HashTablePerfCounter::TotalValueSize) + c_valueSize) <
c_maxCacheSizeInBytes) {
std::stringstream ss;
ss << "key" << key;
Add(hashTable, ss.str(), c_valStr);
@ -499,7 +427,8 @@ BOOST_FIXTURE_TEST_CASE(EvcitRecordsBasedOnAccessStatusTest, CacheHashTableTestF
// Look up with the "key1" key to update the access state.
BOOST_CHECK(CheckRecord(hashTable, "key1", c_valStr));
// Now add a new key, which triggers an eviction, but deletes other records than the "key1" record.
// Now add a new key, which triggers an eviction, but deletes other records
// than the "key1" record.
Add(hashTable, "newkey", c_valStr);
// Now, eviction should have happened.
@ -512,30 +441,22 @@ BOOST_FIXTURE_TEST_CASE(EvcitRecordsBasedOnAccessStatusTest, CacheHashTableTestF
BOOST_CHECK(CheckRecord(hashTable, "newkey", c_valStr));
}
// This is similar to the one in ReadWriteHashTableTest, but necessary since cache store adds the meta values.
BOOST_FIXTURE_TEST_CASE(FixedKeyValueHashTableTest, CacheHashTableTestFixture)
{
// This is similar to the one in ReadWriteHashTableTest, but necessary since
// cache store adds the meta values.
BOOST_FIXTURE_TEST_CASE(FixedKeyValueHashTableTest, CacheHashTableTestFixture) {
// Fixed 4 byte keys and 6 byte values.
std::vector<HashTable::Setting> settings =
{
HashTable::Setting{ 100, 200, 4, 0 },
HashTable::Setting{ 100, 200, 0, 6 },
HashTable::Setting{ 100, 200, 4, 6 }
};
std::vector<HashTable::Setting> settings = {
HashTable::Setting{100, 200, 4, 0}, HashTable::Setting{100, 200, 0, 6},
HashTable::Setting{100, 200, 4, 6}};
for (const auto& setting : settings)
{
for (const auto& setting : settings) {
// Don't care about evict in this test case, so make the cache size big.
constexpr std::uint64_t c_maxCacheSizeInBytes = 0xFFFFFFFF;
constexpr seconds c_recordTimeToLive{20U};
HashTable hashTable{setting, m_allocator};
CacheHashTable writableHashTable{
hashTable,
m_epochManager,
c_maxCacheSizeInBytes,
c_recordTimeToLive,
CacheHashTable writableHashTable{hashTable, m_epochManager,
c_maxCacheSizeInBytes, c_recordTimeToLive,
false};
ReadOnlyCacheHashTable readOnlyHashTable{hashTable, c_recordTimeToLive};
@ -543,56 +464,46 @@ BOOST_FIXTURE_TEST_CASE(FixedKeyValueHashTableTest, CacheHashTableTestFixture)
constexpr std::uint8_t c_numRecords = 10;
// Add records.
for (std::uint8_t i = 0; i < c_numRecords; ++i)
{
Add(writableHashTable, "key" + std::to_string(i), "value" + std::to_string(i));
for (std::uint8_t i = 0; i < c_numRecords; ++i) {
Add(writableHashTable, "key" + std::to_string(i),
"value" + std::to_string(i));
}
Utils::ValidateCounters(
writableHashTable.GetPerfData(),
{
{ HashTablePerfCounter::RecordsCount, 10 },
Utils::ValidateCounters(writableHashTable.GetPerfData(),
{{HashTablePerfCounter::RecordsCount, 10},
{HashTablePerfCounter::BucketsCount, 100},
{HashTablePerfCounter::TotalKeySize, 40},
{HashTablePerfCounter::TotalValueSize, 100},
{HashTablePerfCounter::MinKeySize, 4},
{HashTablePerfCounter::MaxKeySize, 4},
{HashTablePerfCounter::MinValueSize, 10},
{ HashTablePerfCounter::MaxValueSize, 10 }
});
{HashTablePerfCounter::MaxValueSize, 10}});
// Validate all the records added.
for (std::uint8_t i = 0; i < c_numRecords; ++i)
{
CheckRecord(readOnlyHashTable, "key" + std::to_string(i), "value" + std::to_string(i));
for (std::uint8_t i = 0; i < c_numRecords; ++i) {
CheckRecord(readOnlyHashTable, "key" + std::to_string(i),
"value" + std::to_string(i));
}
// Remove first half of the records.
for (std::uint8_t i = 0; i < c_numRecords / 2; ++i)
{
for (std::uint8_t i = 0; i < c_numRecords / 2; ++i) {
Remove(writableHashTable, "key" + std::to_string(i));
}
Utils::ValidateCounters(
writableHashTable.GetPerfData(),
{
{ HashTablePerfCounter::RecordsCount, 5 },
Utils::ValidateCounters(writableHashTable.GetPerfData(),
{{HashTablePerfCounter::RecordsCount, 5},
{HashTablePerfCounter::BucketsCount, 100},
{HashTablePerfCounter::TotalKeySize, 20},
{ HashTablePerfCounter::TotalValueSize, 50 }
});
{HashTablePerfCounter::TotalValueSize, 50}});
// Verify the records.
for (std::uint8_t i = 0; i < c_numRecords; ++i)
{
if (i < (c_numRecords / 2))
{
for (std::uint8_t i = 0; i < c_numRecords; ++i) {
if (i < (c_numRecords / 2)) {
IReadOnlyHashTable::Value value;
BOOST_CHECK(!Get(readOnlyHashTable, "key" + std::to_string(i), value));
}
else
{
CheckRecord(readOnlyHashTable, "key" + std::to_string(i), "value" + std::to_string(i));
} else {
CheckRecord(readOnlyHashTable, "key" + std::to_string(i),
"value" + std::to_string(i));
}
}
@ -600,8 +511,7 @@ BOOST_FIXTURE_TEST_CASE(FixedKeyValueHashTableTest, CacheHashTableTestFixture)
MockClock::IncrementEpochTime(seconds{100});
// Verify the records.
for (std::uint8_t i = 0; i < c_numRecords; ++i)
{
for (std::uint8_t i = 0; i < c_numRecords; ++i) {
IReadOnlyHashTable::Value value;
BOOST_CHECK(!Get(readOnlyHashTable, "key" + std::to_string(i), value));
}

38
Unittests/CheckedAllocator.h
Просмотреть файл

@ -1,62 +1,50 @@
#pragma once
#include <boost/test/unit_test.hpp>
#include <memory>
#include <set>
#include <boost/test/unit_test.hpp>
namespace L4
{
namespace UnitTests
{
namespace L4 {
namespace UnitTests {
struct AllocationAddressHolder : public std::set<void*>
{
~AllocationAddressHolder()
{
BOOST_REQUIRE(empty());
}
struct AllocationAddressHolder : public std::set<void*> {
~AllocationAddressHolder() { BOOST_REQUIRE(empty()); }
};
template <typename T = void>
class CheckedAllocator : public std::allocator<T>
{
class CheckedAllocator : public std::allocator<T> {
public:
using Base = std::allocator<T>;
using pointer = typename Base::pointer;
template <class U>
struct rebind
{
struct rebind {
typedef CheckedAllocator<U> other;
};
CheckedAllocator()
: m_allocationAddresses{ std::make_shared<AllocationAddressHolder>() }
{}
: m_allocationAddresses{std::make_shared<AllocationAddressHolder>()} {}
CheckedAllocator(const CheckedAllocator<T>&) = default;
template <class U>
CheckedAllocator(const CheckedAllocator<U>& other)
: m_allocationAddresses{ other.m_allocationAddresses }
{}
: m_allocationAddresses{other.m_allocationAddresses} {}
template <class U>
CheckedAllocator<T>& operator=(const CheckedAllocator<U>& other)
{
CheckedAllocator<T>& operator=(const CheckedAllocator<U>& other) {
m_allocationAddresses = other.m_allocationAddresses;
return (*this);
}
pointer allocate(std::size_t count, std::allocator<void>::const_pointer hint = 0)
{
pointer allocate(std::size_t count,
std::allocator<void>::const_pointer hint = 0) {
auto address = Base::allocate(count, hint);
BOOST_REQUIRE(m_allocationAddresses->insert(address).second);
return address;
}
void deallocate(pointer ptr, std::size_t count)
{
void deallocate(pointer ptr, std::size_t count) {
BOOST_REQUIRE(m_allocationAddresses->erase(ptr) == 1);
Base::deallocate(ptr, count);
}

36
Unittests/ConnectionMonitorTest.cpp
Просмотреть файл

@ -1,47 +1,48 @@
#include <boost/test/unit_test.hpp>
#include <mutex>
#include <condition_variable>
#include "Utils.h"
#include <mutex>
#include "L4/Interprocess/Connection/ConnectionMonitor.h"
#include "L4/Interprocess/Connection/EndPointInfoUtils.h"
#include "Utils.h"
namespace L4
{
namespace UnitTests
{
namespace L4 {
namespace UnitTests {
BOOST_AUTO_TEST_SUITE(ConnectionMonitorTests)
BOOST_AUTO_TEST_CASE(ConnectionMonitorTest)
{
BOOST_AUTO_TEST_CASE(ConnectionMonitorTest) {
std::vector<Interprocess::Connection::EndPointInfo> endPointsDisconnected;
std::mutex lock;
std::condition_variable cv;
auto server = std::make_shared<Interprocess::Connection::ConnectionMonitor>();
auto noOpCallback = [](const auto&) { throw std::runtime_error("This will not be called."); };
auto callback = [&](const auto& endPoint)
{
auto noOpCallback = [](const auto&) {
throw std::runtime_error("This will not be called.");
};
auto callback = [&](const auto& endPoint) {
std::unique_lock<std::mutex> guard{lock};
endPointsDisconnected.emplace_back(endPoint);
cv.notify_one();
};
auto client1 = std::make_shared<Interprocess::Connection::ConnectionMonitor>();
auto client1 =
std::make_shared<Interprocess::Connection::ConnectionMonitor>();
client1->Register(server->GetLocalEndPointInfo(), noOpCallback);
server->Register(client1->GetLocalEndPointInfo(), callback);
// Registering the same end point is not allowed.
CHECK_EXCEPTION_THROWN_WITH_MESSAGE(
server->Register(client1->GetLocalEndPointInfo(), noOpCallback); ,
"Duplicate end point found.");
server->Register(client1->GetLocalEndPointInfo(), noOpCallback);
, "Duplicate end point found.");
auto client2 = std::make_shared<Interprocess::Connection::ConnectionMonitor>();
auto client2 =
std::make_shared<Interprocess::Connection::ConnectionMonitor>();
client2->Register(server->GetLocalEndPointInfo(), callback);
server->Register(client2->GetLocalEndPointInfo(), noOpCallback);
auto client3 = std::make_shared<Interprocess::Connection::ConnectionMonitor>();
auto client3 =
std::make_shared<Interprocess::Connection::ConnectionMonitor>();
client3->Register(server->GetLocalEndPointInfo(), callback);
server->Register(client3->GetLocalEndPointInfo(), noOpCallback);
@ -59,7 +60,8 @@ BOOST_AUTO_TEST_CASE(ConnectionMonitorTest)
BOOST_CHECK_EQUAL(server->GetRemoteConnectionsCount(), 2U);
}
// Now kill server and check if both callbacks in client2 and client3 are called.
// Now kill server and check if both callbacks in client2 and client3 are
// called.
auto serverEndPointInfo = server->GetLocalEndPointInfo();
server.reset();
{

101
Unittests/EpochManagerTest.cpp
Просмотреть файл

@ -1,26 +1,23 @@
#include <atomic>
#include <boost/test/unit_test.hpp>
#include "Utils.h"
#include "L4/Epoch/EpochQueue.h"
#include "L4/Epoch/EpochActionManager.h"
#include "L4/Epoch/EpochQueue.h"
#include "L4/LocalMemory/EpochManager.h"
#include "L4/Log/PerfCounter.h"
#include "L4/Utils/Lock.h"
#include "Utils.h"
namespace L4
{
namespace UnitTests
{
namespace L4 {
namespace UnitTests {
BOOST_AUTO_TEST_SUITE(EpochManagerTests)
BOOST_AUTO_TEST_CASE(EpochRefManagerTest)
{
BOOST_AUTO_TEST_CASE(EpochRefManagerTest) {
std::uint64_t currentEpochCounter = 5U;
const std::uint32_t c_epochQueueSize = 100U;
using EpochQueue = EpochQueue<
boost::shared_lock_guard<L4::Utils::ReaderWriterLockSlim>,
using EpochQueue =
EpochQueue<boost::shared_lock_guard<L4::Utils::ReaderWriterLockSlim>,
std::lock_guard<L4::Utils::ReaderWriterLockSlim>>;
EpochQueue epochQueue(currentEpochCounter, c_epochQueueSize);
@ -32,7 +29,8 @@ BOOST_AUTO_TEST_CASE(EpochRefManagerTest)
BOOST_CHECK_EQUAL(epochManager.AddRef(), currentEpochCounter);
// Validate that a reference count is incremented at the current epoch counter.
// Validate that a reference count is incremented at the current epoch
// counter.
BOOST_CHECK_EQUAL(epochQueue.m_refCounts[currentEpochCounter], 1U);
epochManager.RemoveRef(currentEpochCounter);
@ -40,29 +38,29 @@ BOOST_AUTO_TEST_CASE(EpochRefManagerTest)
// Validate that a reference count is back to 0.
BOOST_CHECK_EQUAL(epochQueue.m_refCounts[currentEpochCounter], 0U);
// Decrementing a reference counter when it is already 0 will result in an exception.
// Decrementing a reference counter when it is already 0 will result in an
// exception.
CHECK_EXCEPTION_THROWN_WITH_MESSAGE(
epochManager.RemoveRef(currentEpochCounter);,
"Reference counter is invalid.");
epochManager.RemoveRef(currentEpochCounter);
, "Reference counter is invalid.");
}
BOOST_AUTO_TEST_CASE(EpochCounterManagerTest)
{
BOOST_AUTO_TEST_CASE(EpochCounterManagerTest) {
std::uint64_t currentEpochCounter = 0U;
const std::uint32_t c_epochQueueSize = 100U;
using EpochQueue = EpochQueue<
boost::shared_lock_guard<L4::Utils::ReaderWriterLockSlim>,
using EpochQueue =
EpochQueue<boost::shared_lock_guard<L4::Utils::ReaderWriterLockSlim>,
std::lock_guard<L4::Utils::ReaderWriterLockSlim>>;
EpochQueue epochQueue(currentEpochCounter, c_epochQueueSize);
EpochCounterManager<EpochQueue> epochCounterManager(epochQueue);
// If RemoveUnreferenceEpochCounters() is called when m_fonrtIndex and m_backIndex are
// the same, it will just return either value.
BOOST_CHECK_EQUAL(epochCounterManager.RemoveUnreferenceEpochCounters(), currentEpochCounter);
// If RemoveUnreferenceEpochCounters() is called when m_fonrtIndex and
// m_backIndex are the same, it will just return either value.
BOOST_CHECK_EQUAL(epochCounterManager.RemoveUnreferenceEpochCounters(),
currentEpochCounter);
// Add two epoch counts.
++currentEpochCounter;
@ -76,7 +74,8 @@ BOOST_AUTO_TEST_CASE(EpochCounterManagerTest)
// Since the m_frontIndex's reference count was zero, it will be incremented
// all the way to currentEpochCounter.
BOOST_CHECK_EQUAL(epochCounterManager.RemoveUnreferenceEpochCounters(), currentEpochCounter);
BOOST_CHECK_EQUAL(epochCounterManager.RemoveUnreferenceEpochCounters(),
currentEpochCounter);
BOOST_CHECK_EQUAL(epochQueue.m_frontIndex, currentEpochCounter);
BOOST_CHECK_EQUAL(epochQueue.m_backIndex, currentEpochCounter);
@ -86,9 +85,11 @@ BOOST_AUTO_TEST_CASE(EpochCounterManagerTest)
const auto epochCounterReferenced = epochRefManager.AddRef();
BOOST_CHECK_EQUAL(epochCounterReferenced, currentEpochCounter);
// Calling RemoveUnreferenceEpochCounters() should just return currentEpochCounter
// since m_frontIndex and m_backIndex is the same. (Not affected by adding a reference yet).
BOOST_CHECK_EQUAL(epochCounterManager.RemoveUnreferenceEpochCounters(), currentEpochCounter);
// Calling RemoveUnreferenceEpochCounters() should just return
// currentEpochCounter since m_frontIndex and m_backIndex is the same. (Not
// affected by adding a reference yet).
BOOST_CHECK_EQUAL(epochCounterManager.RemoveUnreferenceEpochCounters(),
currentEpochCounter);
BOOST_CHECK_EQUAL(epochQueue.m_frontIndex, currentEpochCounter);
BOOST_CHECK_EQUAL(epochQueue.m_backIndex, currentEpochCounter);
@ -96,25 +97,25 @@ BOOST_AUTO_TEST_CASE(EpochCounterManagerTest)
++currentEpochCounter;
epochCounterManager.AddNewEpoch();
// Now RemoveUnreferenceEpochCounters() should return epochCounterReferenced because
// of the reference count.
BOOST_CHECK_EQUAL(epochCounterManager.RemoveUnreferenceEpochCounters(), epochCounterReferenced);
// Now RemoveUnreferenceEpochCounters() should return epochCounterReferenced
// because of the reference count.
BOOST_CHECK_EQUAL(epochCounterManager.RemoveUnreferenceEpochCounters(),
epochCounterReferenced);
BOOST_CHECK_EQUAL(epochQueue.m_frontIndex, epochCounterReferenced);
BOOST_CHECK_EQUAL(epochQueue.m_backIndex, currentEpochCounter);
// Remove the reference.
epochRefManager.RemoveRef(epochCounterReferenced);
// Now RemoveUnreferenceEpochCounters() should return currentEpochCounter and m_frontIndex
// should be in sync with m_backIndex.
BOOST_CHECK_EQUAL(epochCounterManager.RemoveUnreferenceEpochCounters(), currentEpochCounter);
// Now RemoveUnreferenceEpochCounters() should return currentEpochCounter and
// m_frontIndex should be in sync with m_backIndex.
BOOST_CHECK_EQUAL(epochCounterManager.RemoveUnreferenceEpochCounters(),
currentEpochCounter);
BOOST_CHECK_EQUAL(epochQueue.m_frontIndex, currentEpochCounter);
BOOST_CHECK_EQUAL(epochQueue.m_backIndex, currentEpochCounter);
}
BOOST_AUTO_TEST_CASE(EpochActionManagerTest)
{
BOOST_AUTO_TEST_CASE(EpochActionManagerTest) {
EpochActionManager actionManager(2U);
bool isAction1Called = false;
@ -142,13 +143,10 @@ BOOST_AUTO_TEST_CASE(EpochActionManagerTest)
BOOST_CHECK(isAction1Called && isAction2Called);
}
BOOST_AUTO_TEST_CASE(EpochManagerTest)
{
BOOST_AUTO_TEST_CASE(EpochManagerTest) {
ServerPerfData perfData;
LocalMemory::EpochManager epochManager(
EpochManagerConfig(100000U, std::chrono::milliseconds(5U), 1U),
perfData);
EpochManagerConfig(100000U, std::chrono::milliseconds(5U), 1U), perfData);
std::atomic<bool> isActionCalled{false};
auto action = [&]() { isActionCalled = true; };
@ -158,13 +156,16 @@ BOOST_AUTO_TEST_CASE(EpochManagerTest)
epochManager.RegisterAction(action);
// Justification for using sleep_for in unit tests:
// - EpochManager already uses an internal thread which wakes up and perform a task
// in a given interval and when the class is destroyed, there is a mechanism for
// waiting for the thread anyway. It's more crucial to test the end to end scenario this way.
// - EpochManager already uses an internal thread which wakes up and perform a
// task in a given interval and when the class is destroyed, there is a
// mechanism for waiting for the thread anyway. It's more crucial to test the
// end to end scenario this way.
// - The overall execution time for this test is less than 50 milliseconds.
auto initialEpochCounter = perfData.Get(ServerPerfCounter::LatestEpochCounterInQueue);
while (perfData.Get(ServerPerfCounter::LatestEpochCounterInQueue) - initialEpochCounter < 2)
{
auto initialEpochCounter =
perfData.Get(ServerPerfCounter::LatestEpochCounterInQueue);
while (perfData.Get(ServerPerfCounter::LatestEpochCounterInQueue) -
initialEpochCounter <
2) {
std::this_thread::sleep_for(std::chrono::milliseconds(5));
}
@ -172,9 +173,11 @@ BOOST_AUTO_TEST_CASE(EpochManagerTest)
epochManager.GetEpochRefManager().RemoveRef(epochCounterReferenced);
initialEpochCounter = perfData.Get(ServerPerfCounter::LatestEpochCounterInQueue);
while (perfData.Get(ServerPerfCounter::LatestEpochCounterInQueue) - initialEpochCounter < 2)
{
initialEpochCounter =
perfData.Get(ServerPerfCounter::LatestEpochCounterInQueue);
while (perfData.Get(ServerPerfCounter::LatestEpochCounterInQueue) -
initialEpochCounter <
2) {
std::this_thread::sleep_for(std::chrono::milliseconds(5));
}

75
Unittests/HashTableManagerTest.cpp
Просмотреть файл

@ -1,29 +1,28 @@
#include <boost/test/unit_test.hpp>
#include "Utils.h"
#include "Mocks.h"
#include "L4/HashTable/Config.h"
#include "L4/HashTable/IHashTable.h"
#include "L4/LocalMemory/HashTableManager.h"
#include "Mocks.h"
#include "Utils.h"
namespace L4
{
namespace UnitTests
{
namespace L4 {
namespace UnitTests {
class HashTableManagerTestsFixture
{
class HashTableManagerTestsFixture {
protected:
template <typename Store>
void ValidateRecord(
const Store& store,
void ValidateRecord(const Store& store,
const char* expectedKeyStr,
const char* expectedValueStr)
{
const char* expectedValueStr) {
IReadOnlyHashTable::Value actualValue;
auto expectedValue = Utils::ConvertFromString<IReadOnlyHashTable::Value>(expectedValueStr);
BOOST_CHECK(store.Get(Utils::ConvertFromString<IReadOnlyHashTable::Key>(expectedKeyStr), actualValue));
auto expectedValue =
Utils::ConvertFromString<IReadOnlyHashTable::Value>(expectedValueStr);
BOOST_CHECK(store.Get(
Utils::ConvertFromString<IReadOnlyHashTable::Key>(expectedKeyStr),
actualValue));
BOOST_CHECK(actualValue.m_size == expectedValue.m_size);
BOOST_CHECK(!memcmp(actualValue.m_data, expectedValue.m_data, expectedValue.m_size));
BOOST_CHECK(!memcmp(actualValue.m_data, expectedValue.m_data,
expectedValue.m_size));
}
MockEpochManager m_epochManager;
@ -32,17 +31,14 @@ protected:
BOOST_FIXTURE_TEST_SUITE(HashTableManagerTests, HashTableManagerTestsFixture)
BOOST_AUTO_TEST_CASE(HashTableManagerTest)
{
BOOST_AUTO_TEST_CASE(HashTableManagerTest) {
LocalMemory::HashTableManager htManager;
const auto ht1Index = htManager.Add(
HashTableConfig("HashTable1", HashTableConfig::Setting(100U)),
m_epochManager,
m_allocator);
m_epochManager, m_allocator);
const auto ht2Index = htManager.Add(
HashTableConfig("HashTable2", HashTableConfig::Setting(200U)),
m_epochManager,
m_allocator);
m_epochManager, m_allocator);
{
auto& hashTable1 = htManager.GetHashTable("HashTable1");
@ -56,29 +52,20 @@ BOOST_AUTO_TEST_CASE(HashTableManagerTest)
Utils::ConvertFromString<IReadOnlyHashTable::Value>("HashTable2Value"));
}
ValidateRecord(
htManager.GetHashTable(ht1Index),
"HashTable1Key",
ValidateRecord(htManager.GetHashTable(ht1Index), "HashTable1Key",
"HashTable1Value");
ValidateRecord(
htManager.GetHashTable(ht2Index),
"HashTable2Key",
ValidateRecord(htManager.GetHashTable(ht2Index), "HashTable2Key",
"HashTable2Value");
}
BOOST_AUTO_TEST_CASE(HashTableManagerTestForSerialzation)
{
BOOST_AUTO_TEST_CASE(HashTableManagerTestForSerialzation) {
HashTableConfig htConfig{"HashTable1", HashTableConfig::Setting(100U)};
std::ostringstream outStream;
std::vector<std::pair<std::string, std::string>> testData;
for (std::int32_t i = 0; i < 10; ++i)
{
testData.emplace_back(
"key" + std::to_string(i),
"val" + std::to_string(i));
for (std::int32_t i = 0; i < 10; ++i) {
testData.emplace_back("key" + std::to_string(i), "val" + std::to_string(i));
}
// Serialize a hash table.
@ -88,11 +75,11 @@ BOOST_AUTO_TEST_CASE(HashTableManagerTestForSerialzation)
auto& hashTable1 = htManager.GetHashTable("HashTable1");
for (const auto& kvPair : testData)
{
hashTable1.Add(
Utils::ConvertFromString<IReadOnlyHashTable::Key>(kvPair.first.c_str()),
Utils::ConvertFromString<IReadOnlyHashTable::Value>(kvPair.second.c_str()));
for (const auto& kvPair : testData) {
hashTable1.Add(Utils::ConvertFromString<IReadOnlyHashTable::Key>(
kvPair.first.c_str()),
Utils::ConvertFromString<IReadOnlyHashTable::Value>(
kvPair.second.c_str()));
}
auto serializer = hashTable1.GetSerializer();
@ -112,12 +99,8 @@ BOOST_AUTO_TEST_CASE(HashTableManagerTestForSerialzation)
hashTable1.GetPerfData().Get(HashTablePerfCounter::RecordsCount),
testData.size());
for (const auto& kvPair : testData)
{
ValidateRecord(
hashTable1,
kvPair.first.c_str(),
kvPair.second.c_str());
for (const auto& kvPair : testData) {
ValidateRecord(hashTable1, kvPair.first.c_str(), kvPair.second.c_str());
}
}
}

116
Unittests/HashTableRecordTest.cpp
Просмотреть файл

@ -1,58 +1,60 @@
#include <boost/test/unit_test.hpp>
#include <boost/optional.hpp>
#include <boost/test/unit_test.hpp>
#include <string>
#include <vector>
#include "L4/HashTable/Common/Record.h"
#include "Utils.h"
namespace L4
{
namespace UnitTests
{
namespace L4 {
namespace UnitTests {
using namespace HashTable;
class HashTableRecordTestFixture
{
class HashTableRecordTestFixture {
protected:
void Run(bool isFixedKey, bool isFixedValue, bool useMetaValue)
{
BOOST_TEST_MESSAGE(
"Running with isFixedKey=" << isFixedKey
<< ", isFixedValue=" << isFixedValue
void Run(bool isFixedKey, bool isFixedValue, bool useMetaValue) {
BOOST_TEST_MESSAGE("Running with isFixedKey="
<< isFixedKey << ", isFixedValue=" << isFixedValue
<< ", useMetatValue=" << useMetaValue);
const std::string key = "TestKey";
const std::string value = "TestValue";
const std::string metaValue = "TestMetavalue";
const auto recordOverhead = (isFixedKey ? 0U : c_keyTypeSize) + (isFixedValue ? 0U : c_valueTypeSize);
const auto recordOverhead = (isFixedKey ? 0U : c_keyTypeSize) +
(isFixedValue ? 0U : c_valueTypeSize);
Validate(
RecordSerializer{
isFixedKey ? static_cast<RecordSerializer::KeySize>(key.size()) : std::uint16_t(0),
isFixedValue ? static_cast<RecordSerializer::ValueSize>(value.size()) : 0U,
useMetaValue ? static_cast<RecordSerializer::ValueSize>(metaValue.size()) : 0U },
key,
value,
recordOverhead + key.size() + value.size() + (useMetaValue ? metaValue.size() : 0U),
isFixedKey ? static_cast<RecordSerializer::KeySize>(key.size())
: std::uint16_t(0),
isFixedValue
? static_cast<RecordSerializer::ValueSize>(value.size())
: 0U,
useMetaValue
? static_cast<RecordSerializer::ValueSize>(metaValue.size())
: 0U},
key, value,
recordOverhead + key.size() + value.size() +
(useMetaValue ? metaValue.size() : 0U),
recordOverhead,
useMetaValue ? boost::optional<const std::string&>{ metaValue } : boost::none);
useMetaValue ? boost::optional<const std::string&>{metaValue}
: boost::none);
}
private:
void Validate(
const RecordSerializer& serializer,
void Validate(const RecordSerializer& serializer,
const std::string& keyStr,
const std::string& valueStr,
std::size_t expectedBufferSize,
std::size_t expectedRecordOverheadSize,
boost::optional<const std::string&> metadataStr = boost::none)
{
BOOST_CHECK_EQUAL(serializer.CalculateRecordOverhead(), expectedRecordOverheadSize);
boost::optional<const std::string&> metadataStr = boost::none) {
BOOST_CHECK_EQUAL(serializer.CalculateRecordOverhead(),
expectedRecordOverheadSize);
const auto key = Utils::ConvertFromString<Record::Key>(keyStr.c_str());
const auto value = Utils::ConvertFromString<Record::Value>(valueStr.c_str());
const auto value =
Utils::ConvertFromString<Record::Value>(valueStr.c_str());
const auto bufferSize = serializer.CalculateBufferSize(key, value);
@ -61,14 +63,14 @@ private:
RecordBuffer* recordBuffer = nullptr;
if (metadataStr)
{
auto metaValue = Utils::ConvertFromString<Record::Value>(metadataStr->c_str());
recordBuffer = serializer.Serialize(key, value, metaValue, buffer.data(), bufferSize);
}
else
{
recordBuffer = serializer.Serialize(key, value, buffer.data(), bufferSize);
if (metadataStr) {
auto metaValue =
Utils::ConvertFromString<Record::Value>(metadataStr->c_str());
recordBuffer = serializer.Serialize(key, value, metaValue, buffer.data(),
bufferSize);
} else {
recordBuffer =
serializer.Serialize(key, value, buffer.data(), bufferSize);
}
const auto record = serializer.Deserialize(*recordBuffer);
@ -78,39 +80,31 @@ private:
BOOST_CHECK(record.m_value.m_data != value.m_data);
BOOST_CHECK(record.m_key == key);
if (metadataStr)
{
if (metadataStr) {
const std::string newValueStr = *metadataStr + valueStr;
const auto newValue = Utils::ConvertFromString<Record::Value>(newValueStr.c_str());
const auto newValue =
Utils::ConvertFromString<Record::Value>(newValueStr.c_str());
BOOST_CHECK(record.m_value == newValue);
}
else
{
} else {
BOOST_CHECK(record.m_value == value);
}
}
static constexpr std::size_t c_keyTypeSize = sizeof(Record::Key::size_type);
static constexpr std::size_t c_valueTypeSize = sizeof(Record::Value::size_type);
static constexpr std::size_t c_valueTypeSize =
sizeof(Record::Value::size_type);
};
BOOST_FIXTURE_TEST_SUITE(HashTableRecordTests, HashTableRecordTestFixture)
BOOST_AUTO_TEST_CASE(RunAll)
{
BOOST_AUTO_TEST_CASE(RunAll) {
// Run all permutations for Run(), which takes three booleans.
for (int i = 0; i < 8; ++i)
{
Run(
!!((i >> 2) & 1),
!!((i >> 1) & 1),
!!((i) & 1));
for (int i = 0; i < 8; ++i) {
Run(!!((i >> 2) & 1), !!((i >> 1) & 1), !!((i)&1));
}
}
BOOST_AUTO_TEST_CASE(InvalidSizeTest)
{
BOOST_AUTO_TEST_CASE(InvalidSizeTest) {
std::vector<std::uint8_t> buffer(100U);
RecordSerializer serializer{4, 5};
@ -122,8 +116,10 @@ BOOST_AUTO_TEST_CASE(InvalidSizeTest)
const auto key = Utils::ConvertFromString<Record::Key>(keyStr.c_str());
const auto value = Utils::ConvertFromString<Record::Value>(valueStr.c_str());
const auto invalidKey = Utils::ConvertFromString<Record::Key>(invalidStr.c_str());
const auto invalidValue = Utils::ConvertFromString<Record::Value>(invalidStr.c_str());
const auto invalidKey =
Utils::ConvertFromString<Record::Key>(invalidStr.c_str());
const auto invalidValue =
Utils::ConvertFromString<Record::Value>(invalidStr.c_str());
CHECK_EXCEPTION_THROWN_WITH_MESSAGE(
serializer.Serialize(invalidKey, value, buffer.data(), buffer.size()),
@ -134,7 +130,8 @@ BOOST_AUTO_TEST_CASE(InvalidSizeTest)
"Invalid key or value sizes are given.");
CHECK_EXCEPTION_THROWN_WITH_MESSAGE(
serializer.Serialize(invalidKey, invalidValue, buffer.data(), buffer.size()),
serializer.Serialize(invalidKey, invalidValue, buffer.data(),
buffer.size()),
"Invalid key or value sizes are given.");
// Normal case shouldn't thrown an exception.
@ -143,17 +140,18 @@ BOOST_AUTO_TEST_CASE(InvalidSizeTest)
RecordSerializer serializerWithMetaValue{4, 5, 2};
std::uint16_t metadata = 0;
Record::Value metaValue{
reinterpret_cast<std::uint8_t*>(&metadata),
Record::Value metaValue{reinterpret_cast<std::uint8_t*>(&metadata),
sizeof(metadata)};
// Normal case shouldn't thrown an exception.
serializerWithMetaValue.Serialize(key, value, metaValue, buffer.data(), buffer.size());
serializerWithMetaValue.Serialize(key, value, metaValue, buffer.data(),
buffer.size());
// Mismatching size is given.
metaValue.m_size = 1;
CHECK_EXCEPTION_THROWN_WITH_MESSAGE(
serializerWithMetaValue.Serialize(key, value, metaValue, buffer.data(), buffer.size()),
serializerWithMetaValue.Serialize(key, value, metaValue, buffer.data(),
buffer.size()),
"Invalid meta value size is given.");
}

32
Unittests/HashTableServiceTest.cpp
Просмотреть файл

@ -1,44 +1,38 @@
#include <boost/test/unit_test.hpp>
#include <utility>
#include <vector>
#include "L4/LocalMemory/HashTableService.h"
#include "Mocks.h"
#include "Utils.h"
#include "L4/LocalMemory/HashTableService.h"
namespace L4
{
namespace UnitTests
{
namespace L4 {
namespace UnitTests {
BOOST_AUTO_TEST_CASE(HashTableServiceTest)
{
BOOST_AUTO_TEST_CASE(HashTableServiceTest) {
std::vector<std::pair<std::string, std::string>> dataSet;
for (std::uint16_t i = 0U; i < 100; ++i)
{
dataSet.emplace_back("key" + std::to_string(i), "value" + std::to_string(i));
for (std::uint16_t i = 0U; i < 100; ++i) {
dataSet.emplace_back("key" + std::to_string(i),
"value" + std::to_string(i));
}
LocalMemory::HashTableService htService;
htService.AddHashTable(
HashTableConfig("Table1", HashTableConfig::Setting{100U}));
htService.AddHashTable(
HashTableConfig(
"Table2",
HashTableConfig::Setting{ 1000U },
htService.AddHashTable(HashTableConfig(
"Table2", HashTableConfig::Setting{1000U},
HashTableConfig::Cache{1024, std::chrono::seconds{1U}, false}));
for (const auto& data : dataSet)
{
for (const auto& data : dataSet) {
htService.GetContext()["Table1"].Add(
Utils::ConvertFromString<IReadOnlyHashTable::Key>(data.first.c_str()),
Utils::ConvertFromString<IReadOnlyHashTable::Value>(data.second.c_str()));
Utils::ConvertFromString<IReadOnlyHashTable::Value>(
data.second.c_str()));
}
// Smoke tests for looking up the data .
{
auto context = htService.GetContext();
for (const auto& data : dataSet)
{
for (const auto& data : dataSet) {
IReadOnlyHashTable::Value val;
BOOST_CHECK(context["Table1"].Get(
Utils::ConvertFromString<IReadOnlyHashTable::Key>(data.first.c_str()),

25
Unittests/Mocks.h
Просмотреть файл

@ -3,28 +3,17 @@
#include "L4/Epoch/IEpochActionManager.h"
#include "L4/Log/PerfLogger.h"
namespace L4
{
namespace UnitTests
{
namespace L4 {
namespace UnitTests {
class MockPerfLogger : public IPerfLogger
{
virtual void Log(const IData& data) override
{
(void)data;
}
class MockPerfLogger : public IPerfLogger {
virtual void Log(const IData& data) override { (void)data; }
};
struct MockEpochManager : public IEpochActionManager
{
MockEpochManager()
: m_numRegisterActionsCalled(0)
{
}
struct MockEpochManager : public IEpochActionManager {
MockEpochManager() : m_numRegisterActionsCalled(0) {}
virtual void RegisterAction(Action&& action) override
{
virtual void RegisterAction(Action&& action) override {
++m_numRegisterActionsCalled;
action();
};

34
Unittests/PerfInfoTest.cpp
Просмотреть файл

@ -2,26 +2,19 @@
#include <limits>
#include "L4/Log/PerfLogger.h"
namespace L4
{
namespace UnitTests
{
namespace L4 {
namespace UnitTests {
void CheckMinCounters(const HashTablePerfData& htPerfData)
{
void CheckMinCounters(const HashTablePerfData& htPerfData) {
const auto maxValue = (std::numeric_limits<std::int64_t>::max)();
/// Check if the min counter values are correctly initialized to max value.
BOOST_CHECK_EQUAL(htPerfData.Get(HashTablePerfCounter::MinValueSize), maxValue);
BOOST_CHECK_EQUAL(htPerfData.Get(HashTablePerfCounter::MinValueSize),
maxValue);
BOOST_CHECK_EQUAL(htPerfData.Get(HashTablePerfCounter::MinKeySize), maxValue);
}
BOOST_AUTO_TEST_CASE(PerfCountersTest)
{
enum class TestCounter
{
Counter = 0,
Count
};
BOOST_AUTO_TEST_CASE(PerfCountersTest) {
enum class TestCounter { Counter = 0, Count };
PerfCounters<TestCounter> perfCounters;
@ -55,9 +48,7 @@ BOOST_AUTO_TEST_CASE(PerfCountersTest)
BOOST_CHECK_EQUAL(perfCounters.Get(TestCounter::Counter), 1);
}
BOOST_AUTO_TEST_CASE(PerfDataTest)
{
BOOST_AUTO_TEST_CASE(PerfDataTest) {
PerfData testPerfData;
BOOST_CHECK(testPerfData.GetHashTablesPerfData().empty());
@ -86,17 +77,20 @@ BOOST_AUTO_TEST_CASE(PerfDataTest)
{
auto htPerfDataIt = hashTablesPerfData.find("HT1");
BOOST_REQUIRE(htPerfDataIt != hashTablesPerfData.end());
BOOST_CHECK_EQUAL(htPerfDataIt->second.get().Get(HashTablePerfCounter::TotalKeySize), 10);
BOOST_CHECK_EQUAL(
htPerfDataIt->second.get().Get(HashTablePerfCounter::TotalKeySize), 10);
}
{
auto htPerfDataIt = hashTablesPerfData.find("HT2");
BOOST_REQUIRE(htPerfDataIt != hashTablesPerfData.end());
BOOST_CHECK_EQUAL(htPerfDataIt->second.get().Get(HashTablePerfCounter::TotalKeySize), 20);
BOOST_CHECK_EQUAL(
htPerfDataIt->second.get().Get(HashTablePerfCounter::TotalKeySize), 20);
}
{
auto htPerfDataIt = hashTablesPerfData.find("HT3");
BOOST_REQUIRE(htPerfDataIt != hashTablesPerfData.end());
BOOST_CHECK_EQUAL(htPerfDataIt->second.get().Get(HashTablePerfCounter::TotalKeySize), 30);
BOOST_CHECK_EQUAL(
htPerfDataIt->second.get().Get(HashTablePerfCounter::TotalKeySize), 30);
}
}

123
Unittests/ReadWriteHashTableSerializerTest.cpp
Просмотреть файл

@ -1,18 +1,16 @@
#include <boost/test/unit_test.hpp>
#include <string>
#include <sstream>
#include <string>
#include <vector>
#include "Utils.h"
#include "Mocks.h"
#include "L4/HashTable/ReadWrite/HashTable.h"
#include "L4/HashTable/ReadWrite/Serializer.h"
#include "L4/Log/PerfCounter.h"
#include "L4/LocalMemory/Memory.h"
#include "L4/Log/PerfCounter.h"
#include "Mocks.h"
#include "Utils.h"
namespace L4
{
namespace UnitTests
{
namespace L4 {
namespace UnitTests {
using namespace HashTable::ReadWrite;
@ -32,23 +30,24 @@ void ValidateSerializer(
const KeyValuePairs& keyValuePairs,
const Utils::ExpectedCounterValues& expectedCounterValuesAfterLoad,
const Utils::ExpectedCounterValues& expectedCounterValuesAfterSerialization,
const Utils::ExpectedCounterValues& expectedCounterValuesAfterDeserialization)
{
const Utils::ExpectedCounterValues&
expectedCounterValuesAfterDeserialization) {
Memory memory;
MockEpochManager epochManager;
auto hashTableHolder{
memory.MakeUnique<HashTable>(
HashTable::Setting{ 5 }, memory.GetAllocator()) };
auto hashTableHolder{memory.MakeUnique<HashTable>(HashTable::Setting{5},
memory.GetAllocator())};
BOOST_CHECK(hashTableHolder != nullptr);
WritableHashTable<Allocator> writableHashTable(*hashTableHolder, epochManager);
WritableHashTable<Allocator> writableHashTable(*hashTableHolder,
epochManager);
// Insert the given key/value pairs to the hash table.
for (const auto& pair : keyValuePairs)
{
auto key = Utils::ConvertFromString<IReadOnlyHashTable::Key>(pair.first.c_str());
auto val = Utils::ConvertFromString<IReadOnlyHashTable::Value>(pair.second.c_str());
for (const auto& pair : keyValuePairs) {
auto key =
Utils::ConvertFromString<IReadOnlyHashTable::Key>(pair.first.c_str());
auto val = Utils::ConvertFromString<IReadOnlyHashTable::Value>(
pair.second.c_str());
writableHashTable.Add(key, val);
}
@ -65,112 +64,90 @@ void ValidateSerializer(
// Read in the hash table from the stream and validate it.
std::istringstream inStream(outStream.str());
// version == 0 means that it's run through the HashTableSerializer, thus the following can be skipped.
if (serializerVersion != 0)
{
// version == 0 means that it's run through the HashTableSerializer, thus the
// following can be skipped.
if (serializerVersion != 0) {
std::uint8_t actualSerializerVersion = 0;
DeserializerHelper(inStream).Deserialize(actualSerializerVersion);
BOOST_CHECK(actualSerializerVersion == serializerVersion);
}
else
{
BOOST_REQUIRE(typeid(L4::HashTable::ReadWrite::Serializer<HashTable, ReadOnlyHashTable>) == typeid(Serializer));
} else {
BOOST_REQUIRE(typeid(L4::HashTable::ReadWrite::Serializer<
HashTable, ReadOnlyHashTable>) == typeid(Serializer));
}
auto newHashTableHolder = deserializer.Deserialize(memory, inStream);
BOOST_CHECK(newHashTableHolder != nullptr);
WritableHashTable<Allocator> newWritableHashTable(*newHashTableHolder, epochManager);
WritableHashTable<Allocator> newWritableHashTable(*newHashTableHolder,
epochManager);
const auto& newPerfData = newWritableHashTable.GetPerfData();
Utils::ValidateCounters(newPerfData, expectedCounterValuesAfterDeserialization);
Utils::ValidateCounters(newPerfData,
expectedCounterValuesAfterDeserialization);
// Make sure all the key/value pairs exist after deserialization.
for (const auto& pair : keyValuePairs)
{
auto key = Utils::ConvertFromString<IReadOnlyHashTable::Key>(pair.first.c_str());
for (const auto& pair : keyValuePairs) {
auto key =
Utils::ConvertFromString<IReadOnlyHashTable::Key>(pair.first.c_str());
IReadOnlyHashTable::Value val;
BOOST_CHECK(newWritableHashTable.Get(key, val));
BOOST_CHECK(Utils::ConvertToString(val) == pair.second);
}
}
BOOST_AUTO_TEST_CASE(CurrentSerializerTest)
{
BOOST_AUTO_TEST_CASE(CurrentSerializerTest) {
ValidateSerializer(
Current::Serializer<HashTable, ReadOnlyHashTable>{},
Current::Deserializer<Memory, HashTable, WritableHashTable>{ L4::Utils::Properties{} },
Current::Deserializer<Memory, HashTable, WritableHashTable>{
L4::Utils::Properties{}},
Current::c_version,
{
{ "hello1", " world1" },
{ "hello2", " world2" },
{ "hello3", " world3" }
},
{
{ HashTablePerfCounter::RecordsCount, 3 },
{{"hello1", " world1"}, {"hello2", " world2"}, {"hello3", " world3"}},
{{HashTablePerfCounter::RecordsCount, 3},
{HashTablePerfCounter::BucketsCount, 5},
{HashTablePerfCounter::TotalKeySize, 18},
{HashTablePerfCounter::TotalValueSize, 21},
{HashTablePerfCounter::RecordsCountLoadedFromSerializer, 0},
{ HashTablePerfCounter::RecordsCountSavedFromSerializer, 0 }
},
{
{ HashTablePerfCounter::RecordsCount, 3 },
{HashTablePerfCounter::RecordsCountSavedFromSerializer, 0}},
{{HashTablePerfCounter::RecordsCount, 3},
{HashTablePerfCounter::BucketsCount, 5},
{HashTablePerfCounter::TotalKeySize, 18},
{HashTablePerfCounter::TotalValueSize, 21},
{HashTablePerfCounter::RecordsCountLoadedFromSerializer, 0},
{ HashTablePerfCounter::RecordsCountSavedFromSerializer, 3 }
},
{
{ HashTablePerfCounter::RecordsCount, 3 },
{HashTablePerfCounter::RecordsCountSavedFromSerializer, 3}},
{{HashTablePerfCounter::RecordsCount, 3},
{HashTablePerfCounter::BucketsCount, 5},
{HashTablePerfCounter::TotalKeySize, 18},
{HashTablePerfCounter::TotalValueSize, 21},
{HashTablePerfCounter::RecordsCountLoadedFromSerializer, 3},
{ HashTablePerfCounter::RecordsCountSavedFromSerializer, 0 }
});
{HashTablePerfCounter::RecordsCountSavedFromSerializer, 0}});
}
BOOST_AUTO_TEST_CASE(HashTableSerializeTest)
{
BOOST_AUTO_TEST_CASE(HashTableSerializeTest) {
// This test case tests end to end scenario using the HashTableSerializer.
ValidateSerializer(
Serializer<HashTable, ReadOnlyHashTable>{},
Deserializer<Memory, HashTable, WritableHashTable>{ L4::Utils::Properties{} },
0U,
{
{ "hello1", " world1" },
{ "hello2", " world2" },
{ "hello3", " world3" }
},
{
{ HashTablePerfCounter::RecordsCount, 3 },
Deserializer<Memory, HashTable, WritableHashTable>{
L4::Utils::Properties{}},
0U, {{"hello1", " world1"}, {"hello2", " world2"}, {"hello3", " world3"}},
{{HashTablePerfCounter::RecordsCount, 3},
{HashTablePerfCounter::BucketsCount, 5},
{HashTablePerfCounter::TotalKeySize, 18},
{HashTablePerfCounter::TotalValueSize, 21},
{HashTablePerfCounter::RecordsCountLoadedFromSerializer, 0},
{ HashTablePerfCounter::RecordsCountSavedFromSerializer, 0 }
},
{
{ HashTablePerfCounter::RecordsCount, 3 },
{HashTablePerfCounter::RecordsCountSavedFromSerializer, 0}},
{{HashTablePerfCounter::RecordsCount, 3},
{HashTablePerfCounter::BucketsCount, 5},
{HashTablePerfCounter::TotalKeySize, 18},
{HashTablePerfCounter::TotalValueSize, 21},
{HashTablePerfCounter::RecordsCountLoadedFromSerializer, 0},
{ HashTablePerfCounter::RecordsCountSavedFromSerializer, 3 }
},
{
{ HashTablePerfCounter::RecordsCount, 3 },
{HashTablePerfCounter::RecordsCountSavedFromSerializer, 3}},
{{HashTablePerfCounter::RecordsCount, 3},
{HashTablePerfCounter::BucketsCount, 5},
{HashTablePerfCounter::TotalKeySize, 18},
{HashTablePerfCounter::TotalValueSize, 21},
{HashTablePerfCounter::RecordsCountLoadedFromSerializer, 3},
{ HashTablePerfCounter::RecordsCountSavedFromSerializer, 0 }
});
{HashTablePerfCounter::RecordsCountSavedFromSerializer, 0}});
}
BOOST_AUTO_TEST_SUITE_END()

340
Unittests/ReadWriteHashTableTest.cpp
Просмотреть файл

@ -1,38 +1,29 @@
#include <boost/test/unit_test.hpp>
#include "Utils.h"
#include "Mocks.h"
#include "CheckedAllocator.h"
#include "L4/Log/PerfCounter.h"
#include "L4/HashTable/ReadWrite/HashTable.h"
#include "L4/Log/PerfCounter.h"
#include "Mocks.h"
#include "Utils.h"
namespace L4
{
namespace UnitTests
{
namespace L4 {
namespace UnitTests {
using namespace HashTable::ReadWrite;
class ReadWriteHashTableTestFixture
{
class ReadWriteHashTableTestFixture {
protected:
using Allocator = CheckedAllocator<>;
using HashTable = WritableHashTable<Allocator>::HashTable;
ReadWriteHashTableTestFixture()
: m_allocator{}
, m_epochManager{}
{}
ReadWriteHashTableTestFixture() : m_allocator{}, m_epochManager{} {}
Allocator m_allocator;
MockEpochManager m_epochManager;
};
BOOST_FIXTURE_TEST_SUITE(ReadWriteHashTableTests, ReadWriteHashTableTestFixture)
BOOST_AUTO_TEST_CASE(HashTableTest)
{
BOOST_AUTO_TEST_CASE(HashTableTest) {
HashTable hashTable{HashTable::Setting{100, 5}, m_allocator};
WritableHashTable<Allocator> writableHashTable(hashTable, m_epochManager);
ReadOnlyHashTable<Allocator> readOnlyHashTable(hashTable);
@ -43,16 +34,16 @@ BOOST_AUTO_TEST_CASE(HashTableTest)
// Check empty data.
std::string keyStr = "hello";
auto key = Utils::ConvertFromString<IReadOnlyHashTable::Key>(keyStr.c_str());
auto key =
Utils::ConvertFromString<IReadOnlyHashTable::Key>(keyStr.c_str());
IReadOnlyHashTable::Value data;
BOOST_CHECK(!readOnlyHashTable.Get(key, data));
const auto c_counterMaxValue = (std::numeric_limits<HashTablePerfData::TValue>::max)();
const auto c_counterMaxValue =
(std::numeric_limits<HashTablePerfData::TValue>::max)();
Utils::ValidateCounters(
perfData,
{
{ HashTablePerfCounter::RecordsCount, 0 },
perfData, {{HashTablePerfCounter::RecordsCount, 0},
{HashTablePerfCounter::BucketsCount, 100},
{HashTablePerfCounter::ChainingEntriesCount, 0},
{HashTablePerfCounter::TotalKeySize, 0},
@ -60,18 +51,18 @@ BOOST_AUTO_TEST_CASE(HashTableTest)
{HashTablePerfCounter::MinKeySize, c_counterMaxValue},
{HashTablePerfCounter::MaxKeySize, 0},
{HashTablePerfCounter::MinValueSize, c_counterMaxValue},
{ HashTablePerfCounter::MaxValueSize, 0 }
});
{HashTablePerfCounter::MaxValueSize, 0}});
}
{
// First record added.
std::string keyStr = "hello";
std::string valStr = "world";
auto key = Utils::ConvertFromString<IReadOnlyHashTable::Key>(keyStr.c_str());
auto val = Utils::ConvertFromString<IReadOnlyHashTable::Value>(valStr.c_str());
auto key =
Utils::ConvertFromString<IReadOnlyHashTable::Key>(keyStr.c_str());
auto val =
Utils::ConvertFromString<IReadOnlyHashTable::Value>(valStr.c_str());
writableHashTable.Add(key, val);
@ -80,10 +71,8 @@ BOOST_AUTO_TEST_CASE(HashTableTest)
BOOST_CHECK(value.m_size == valStr.size());
BOOST_CHECK(!memcmp(value.m_data, valStr.c_str(), valStr.size()));
Utils::ValidateCounters(
perfData,
{
{ HashTablePerfCounter::RecordsCount, 1 },
Utils::ValidateCounters(perfData,
{{HashTablePerfCounter::RecordsCount, 1},
{HashTablePerfCounter::BucketsCount, 100},
{HashTablePerfCounter::ChainingEntriesCount, 0},
{HashTablePerfCounter::TotalKeySize, 5},
@ -91,8 +80,7 @@ BOOST_AUTO_TEST_CASE(HashTableTest)
{HashTablePerfCounter::MinKeySize, 5},
{HashTablePerfCounter::MaxKeySize, 5},
{HashTablePerfCounter::MinValueSize, 5},
{ HashTablePerfCounter::MaxValueSize, 5 }
});
{HashTablePerfCounter::MaxValueSize, 5}});
}
{
@ -100,8 +88,10 @@ BOOST_AUTO_TEST_CASE(HashTableTest)
std::string keyStr = "hello2";
std::string valStr = "world2";
auto key = Utils::ConvertFromString<IReadOnlyHashTable::Key>(keyStr.c_str());
auto val = Utils::ConvertFromString<IReadOnlyHashTable::Value>(valStr.c_str());
auto key =
Utils::ConvertFromString<IReadOnlyHashTable::Key>(keyStr.c_str());
auto val =
Utils::ConvertFromString<IReadOnlyHashTable::Value>(valStr.c_str());
writableHashTable.Add(key, val);
@ -110,10 +100,8 @@ BOOST_AUTO_TEST_CASE(HashTableTest)
BOOST_CHECK(value.m_size == valStr.size());
BOOST_CHECK(!memcmp(value.m_data, valStr.c_str(), valStr.size()));
Utils::ValidateCounters(
perfData,
{
{ HashTablePerfCounter::RecordsCount, 2 },
Utils::ValidateCounters(perfData,
{{HashTablePerfCounter::RecordsCount, 2},
{HashTablePerfCounter::BucketsCount, 100},
{HashTablePerfCounter::ChainingEntriesCount, 0},
{HashTablePerfCounter::TotalKeySize, 11},
@ -121,8 +109,7 @@ BOOST_AUTO_TEST_CASE(HashTableTest)
{HashTablePerfCounter::MinKeySize, 5},
{HashTablePerfCounter::MaxKeySize, 6},
{HashTablePerfCounter::MinValueSize, 5},
{ HashTablePerfCounter::MaxValueSize, 6 }
});
{HashTablePerfCounter::MaxValueSize, 6}});
}
{
@ -130,8 +117,10 @@ BOOST_AUTO_TEST_CASE(HashTableTest)
std::string keyStr = "hello";
std::string valStr = "world long string";
auto key = Utils::ConvertFromString<IReadOnlyHashTable::Key>(keyStr.c_str());
auto val = Utils::ConvertFromString<IReadOnlyHashTable::Value>(valStr.c_str());
auto key =
Utils::ConvertFromString<IReadOnlyHashTable::Key>(keyStr.c_str());
auto val =
Utils::ConvertFromString<IReadOnlyHashTable::Value>(valStr.c_str());
writableHashTable.Add(key, val);
@ -141,10 +130,8 @@ BOOST_AUTO_TEST_CASE(HashTableTest)
BOOST_CHECK(!memcmp(value.m_data, valStr.c_str(), valStr.size()));
BOOST_CHECK(m_epochManager.m_numRegisterActionsCalled == 1);
Utils::ValidateCounters(
perfData,
{
{ HashTablePerfCounter::RecordsCount, 2 },
Utils::ValidateCounters(perfData,
{{HashTablePerfCounter::RecordsCount, 2},
{HashTablePerfCounter::BucketsCount, 100},
{HashTablePerfCounter::ChainingEntriesCount, 0},
{HashTablePerfCounter::TotalKeySize, 11},
@ -152,8 +139,7 @@ BOOST_AUTO_TEST_CASE(HashTableTest)
{HashTablePerfCounter::MinKeySize, 5},
{HashTablePerfCounter::MaxKeySize, 6},
{HashTablePerfCounter::MinValueSize, 5},
{ HashTablePerfCounter::MaxValueSize, 17 }
});
{HashTablePerfCounter::MaxValueSize, 17}});
}
{
@ -161,8 +147,10 @@ BOOST_AUTO_TEST_CASE(HashTableTest)
std::string keyStr = "hello2";
std::string valStr = "wo";
auto key = Utils::ConvertFromString<IReadOnlyHashTable::Key>(keyStr.c_str());
auto val = Utils::ConvertFromString<IReadOnlyHashTable::Value>(valStr.c_str());
auto key =
Utils::ConvertFromString<IReadOnlyHashTable::Key>(keyStr.c_str());
auto val =
Utils::ConvertFromString<IReadOnlyHashTable::Value>(valStr.c_str());
writableHashTable.Add(key, val);
@ -172,10 +160,8 @@ BOOST_AUTO_TEST_CASE(HashTableTest)
BOOST_CHECK(!memcmp(value.m_data, valStr.c_str(), valStr.size()));
BOOST_CHECK(m_epochManager.m_numRegisterActionsCalled == 2);
Utils::ValidateCounters(
perfData,
{
{ HashTablePerfCounter::RecordsCount, 2 },
Utils::ValidateCounters(perfData,
{{HashTablePerfCounter::RecordsCount, 2},
{HashTablePerfCounter::BucketsCount, 100},
{HashTablePerfCounter::ChainingEntriesCount, 0},
{HashTablePerfCounter::TotalKeySize, 11},
@ -183,8 +169,7 @@ BOOST_AUTO_TEST_CASE(HashTableTest)
{HashTablePerfCounter::MinKeySize, 5},
{HashTablePerfCounter::MaxKeySize, 6},
{HashTablePerfCounter::MinValueSize, 2},
{ HashTablePerfCounter::MaxValueSize, 17 }
});
{HashTablePerfCounter::MaxValueSize, 17}});
}
{
@ -192,17 +177,17 @@ BOOST_AUTO_TEST_CASE(HashTableTest)
std::string keyStr = "hello";
std::string valStr = "";
auto key = Utils::ConvertFromString<IReadOnlyHashTable::Key>(keyStr.c_str());
auto val = Utils::ConvertFromString<IReadOnlyHashTable::Value>(valStr.c_str());
auto key =
Utils::ConvertFromString<IReadOnlyHashTable::Key>(keyStr.c_str());
auto val =
Utils::ConvertFromString<IReadOnlyHashTable::Value>(valStr.c_str());
BOOST_CHECK(writableHashTable.Remove(key));
BOOST_CHECK(m_epochManager.m_numRegisterActionsCalled == 3);
// Note that the Remove() doesn't change Min/Max counters by design.
Utils::ValidateCounters(
perfData,
{
{ HashTablePerfCounter::RecordsCount, 1 },
Utils::ValidateCounters(perfData,
{{HashTablePerfCounter::RecordsCount, 1},
{HashTablePerfCounter::BucketsCount, 100},
{HashTablePerfCounter::ChainingEntriesCount, 0},
{HashTablePerfCounter::TotalKeySize, 6},
@ -210,8 +195,7 @@ BOOST_AUTO_TEST_CASE(HashTableTest)
{HashTablePerfCounter::MinKeySize, 5},
{HashTablePerfCounter::MaxKeySize, 6},
{HashTablePerfCounter::MinValueSize, 2},
{ HashTablePerfCounter::MaxValueSize, 17 }
});
{HashTablePerfCounter::MaxValueSize, 17}});
// Remove the second key.
keyStr = "hello2";
@ -220,10 +204,8 @@ BOOST_AUTO_TEST_CASE(HashTableTest)
BOOST_CHECK(writableHashTable.Remove(key));
BOOST_CHECK(m_epochManager.m_numRegisterActionsCalled == 4);
Utils::ValidateCounters(
perfData,
{
{ HashTablePerfCounter::RecordsCount, 0 },
Utils::ValidateCounters(perfData,
{{HashTablePerfCounter::RecordsCount, 0},
{HashTablePerfCounter::BucketsCount, 100},
{HashTablePerfCounter::ChainingEntriesCount, 0},
{HashTablePerfCounter::TotalKeySize, 0},
@ -231,15 +213,12 @@ BOOST_AUTO_TEST_CASE(HashTableTest)
{HashTablePerfCounter::MinKeySize, 5},
{HashTablePerfCounter::MaxKeySize, 6},
{HashTablePerfCounter::MinValueSize, 2},
{ HashTablePerfCounter::MaxValueSize, 17 }
});
{HashTablePerfCounter::MaxValueSize, 17}});
// Removing the key that doesn't exist.
BOOST_CHECK(!writableHashTable.Remove(key));
Utils::ValidateCounters(
perfData,
{
{ HashTablePerfCounter::RecordsCount, 0 },
Utils::ValidateCounters(perfData,
{{HashTablePerfCounter::RecordsCount, 0},
{HashTablePerfCounter::BucketsCount, 100},
{HashTablePerfCounter::ChainingEntriesCount, 0},
{HashTablePerfCounter::TotalKeySize, 0},
@ -247,14 +226,11 @@ BOOST_AUTO_TEST_CASE(HashTableTest)
{HashTablePerfCounter::MinKeySize, 5},
{HashTablePerfCounter::MaxKeySize, 6},
{HashTablePerfCounter::MinValueSize, 2},
{ HashTablePerfCounter::MaxValueSize, 17 }
});
{HashTablePerfCounter::MaxValueSize, 17}});
}
}
BOOST_AUTO_TEST_CASE(HashTableWithOneBucketTest)
{
BOOST_AUTO_TEST_CASE(HashTableWithOneBucketTest) {
Allocator allocator;
HashTable hashTable{HashTable::Setting{1}, allocator};
WritableHashTable<Allocator> writableHashTable(hashTable, m_epochManager);
@ -262,16 +238,17 @@ BOOST_AUTO_TEST_CASE(HashTableWithOneBucketTest)
const auto& perfData = writableHashTable.GetPerfData();
Utils::ValidateCounters(perfData, { { HashTablePerfCounter::ChainingEntriesCount, 0 } });
Utils::ValidateCounters(perfData,
{{HashTablePerfCounter::ChainingEntriesCount, 0}});
const auto initialTotalIndexSize = perfData.Get(HashTablePerfCounter::TotalIndexSize);
const auto initialTotalIndexSize =
perfData.Get(HashTablePerfCounter::TotalIndexSize);
const std::size_t c_dataSetSize = HashTable::Entry::c_numDataPerEntry + 5U;
std::size_t expectedTotalKeySize = 0U;
std::size_t expectedTotalValueSize = 0U;
for (auto i = 0U; i < c_dataSetSize; ++i)
{
for (auto i = 0U; i < c_dataSetSize; ++i) {
std::stringstream keyStream;
keyStream << "key" << i;
@ -281,8 +258,10 @@ BOOST_AUTO_TEST_CASE(HashTableWithOneBucketTest)
std::string keyStr = keyStream.str();
std::string valStr = valStream.str();
auto key = Utils::ConvertFromString<IReadOnlyHashTable::Key>(keyStr.c_str());
auto val = Utils::ConvertFromString<IReadOnlyHashTable::Value>(valStr.c_str());
auto key =
Utils::ConvertFromString<IReadOnlyHashTable::Key>(keyStr.c_str());
auto val =
Utils::ConvertFromString<IReadOnlyHashTable::Value>(valStr.c_str());
expectedTotalKeySize += key.m_size;
expectedTotalValueSize += val.m_size;
@ -298,28 +277,24 @@ BOOST_AUTO_TEST_CASE(HashTableWithOneBucketTest)
using L4::HashTable::RecordSerializer;
// Variable key/value sizes.
const auto recordOverhead = RecordSerializer{ 0U, 0U }.CalculateRecordOverhead();
const auto recordOverhead =
RecordSerializer{0U, 0U}.CalculateRecordOverhead();
Utils::ValidateCounters(
perfData,
{
{ HashTablePerfCounter::RecordsCount, c_dataSetSize },
perfData, {{HashTablePerfCounter::RecordsCount, c_dataSetSize},
{HashTablePerfCounter::BucketsCount, 1},
{HashTablePerfCounter::MaxBucketChainLength, 2},
{HashTablePerfCounter::ChainingEntriesCount, 1},
{HashTablePerfCounter::TotalKeySize, expectedTotalKeySize},
{HashTablePerfCounter::TotalValueSize, expectedTotalValueSize},
{
HashTablePerfCounter::TotalIndexSize,
initialTotalIndexSize + sizeof(HashTable::Entry) + (c_dataSetSize * recordOverhead)
}
});
{HashTablePerfCounter::TotalIndexSize,
initialTotalIndexSize + sizeof(HashTable::Entry) +
(c_dataSetSize * recordOverhead)}});
// Now replace with new values.
expectedTotalValueSize = 0U;
for (auto i = 0U; i < c_dataSetSize; ++i)
{
for (auto i = 0U; i < c_dataSetSize; ++i) {
std::stringstream keyStream;
keyStream << "key" << i;
@ -329,8 +304,10 @@ BOOST_AUTO_TEST_CASE(HashTableWithOneBucketTest)
std::string keyStr = keyStream.str();
std::string valStr = valStream.str();
auto key = Utils::ConvertFromString<IReadOnlyHashTable::Key>(keyStr.c_str());
auto val = Utils::ConvertFromString<IReadOnlyHashTable::Value>(valStr.c_str());
auto key =
Utils::ConvertFromString<IReadOnlyHashTable::Key>(keyStr.c_str());
auto val =
Utils::ConvertFromString<IReadOnlyHashTable::Value>(valStr.c_str());
expectedTotalValueSize += val.m_size;
@ -343,28 +320,24 @@ BOOST_AUTO_TEST_CASE(HashTableWithOneBucketTest)
}
Utils::ValidateCounters(
perfData,
{
{ HashTablePerfCounter::RecordsCount, c_dataSetSize },
perfData, {{HashTablePerfCounter::RecordsCount, c_dataSetSize},
{HashTablePerfCounter::BucketsCount, 1},
{HashTablePerfCounter::MaxBucketChainLength, 2},
{HashTablePerfCounter::ChainingEntriesCount, 1},
{HashTablePerfCounter::TotalKeySize, expectedTotalKeySize},
{HashTablePerfCounter::TotalValueSize, expectedTotalValueSize},
{
HashTablePerfCounter::TotalIndexSize,
initialTotalIndexSize + sizeof(HashTable::Entry) + (c_dataSetSize * recordOverhead)
}
});
{HashTablePerfCounter::TotalIndexSize,
initialTotalIndexSize + sizeof(HashTable::Entry) +
(c_dataSetSize * recordOverhead)}});
// Now remove all key-value.
for (auto i = 0U; i < c_dataSetSize; ++i)
{
for (auto i = 0U; i < c_dataSetSize; ++i) {
std::stringstream keyStream;
keyStream << "key" << i;
std::string keyStr = keyStream.str();
auto key = Utils::ConvertFromString<IReadOnlyHashTable::Key>(keyStr.c_str());
auto key =
Utils::ConvertFromString<IReadOnlyHashTable::Key>(keyStr.c_str());
BOOST_CHECK(writableHashTable.Remove(key));
@ -372,27 +345,21 @@ BOOST_AUTO_TEST_CASE(HashTableWithOneBucketTest)
BOOST_CHECK(!readOnlyHashTable.Get(key, value));
}
Utils::ValidateCounters(
perfData,
{
{ HashTablePerfCounter::RecordsCount, 0 },
Utils::ValidateCounters(perfData,
{{HashTablePerfCounter::RecordsCount, 0},
{HashTablePerfCounter::BucketsCount, 1},
{HashTablePerfCounter::MaxBucketChainLength, 2},
{HashTablePerfCounter::ChainingEntriesCount, 1},
{HashTablePerfCounter::TotalKeySize, 0},
{HashTablePerfCounter::TotalValueSize, 0},
{
HashTablePerfCounter::TotalIndexSize,
initialTotalIndexSize + sizeof(HashTable::Entry)
}
});
{HashTablePerfCounter::TotalIndexSize,
initialTotalIndexSize + sizeof(HashTable::Entry)}});
// Try to add back to the same bucket (reusing existing entries)
expectedTotalKeySize = 0U;
expectedTotalValueSize = 0U;
for (auto i = 0U; i < c_dataSetSize; ++i)
{
for (auto i = 0U; i < c_dataSetSize; ++i) {
std::stringstream keyStream;
keyStream << "key" << i;
@ -402,8 +369,10 @@ BOOST_AUTO_TEST_CASE(HashTableWithOneBucketTest)
std::string keyStr = keyStream.str();
std::string valStr = valStream.str();
auto key = Utils::ConvertFromString<IReadOnlyHashTable::Key>(keyStr.c_str());
auto val = Utils::ConvertFromString<IReadOnlyHashTable::Value>(valStr.c_str());
auto key =
Utils::ConvertFromString<IReadOnlyHashTable::Key>(keyStr.c_str());
auto val =
Utils::ConvertFromString<IReadOnlyHashTable::Value>(valStr.c_str());
expectedTotalKeySize += key.m_size;
expectedTotalValueSize += val.m_size;
@ -417,24 +386,18 @@ BOOST_AUTO_TEST_CASE(HashTableWithOneBucketTest)
}
Utils::ValidateCounters(
perfData,
{
{ HashTablePerfCounter::RecordsCount, c_dataSetSize },
perfData, {{HashTablePerfCounter::RecordsCount, c_dataSetSize},
{HashTablePerfCounter::BucketsCount, 1},
{HashTablePerfCounter::MaxBucketChainLength, 2},
{HashTablePerfCounter::ChainingEntriesCount, 1},
{HashTablePerfCounter::TotalKeySize, expectedTotalKeySize},
{HashTablePerfCounter::TotalValueSize, expectedTotalValueSize},
{
HashTablePerfCounter::TotalIndexSize,
initialTotalIndexSize + sizeof(HashTable::Entry) + (c_dataSetSize * recordOverhead)
}
});
{HashTablePerfCounter::TotalIndexSize,
initialTotalIndexSize + sizeof(HashTable::Entry) +
(c_dataSetSize * recordOverhead)}});
}
BOOST_AUTO_TEST_CASE(AddRemoveSameKeyTest)
{
BOOST_AUTO_TEST_CASE(AddRemoveSameKeyTest) {
HashTable hashTable{HashTable::Setting{100, 5}, m_allocator};
WritableHashTable<Allocator> writableHashTable(hashTable, m_epochManager);
ReadOnlyHashTable<Allocator> readOnlyHashTable(hashTable);
@ -459,13 +422,15 @@ BOOST_AUTO_TEST_CASE(AddRemoveSameKeyTest)
const auto& perfData = writableHashTable.GetPerfData();
// Now remove the first record with key = "key1", which is at the head of the chain.
// Now remove the first record with key = "key1", which is at the head of the
// chain.
BOOST_CHECK(writableHashTable.Remove(key1));
BOOST_CHECK(!readOnlyHashTable.Get(key1, valueRetrieved));
Utils::ValidateCounter(perfData, HashTablePerfCounter::RecordsCount, 1);
// Now try update the record with key = "key2". This should correctly update the existing record
// instead of using the empty slot created by removing the record with key = "key1".
// Now try update the record with key = "key2". This should correctly update
// the existing record instead of using the empty slot created by removing the
// record with key = "key1".
auto newVal2 = Utils::ConvertFromString<IReadOnlyHashTable::Value>("newVal2");
writableHashTable.Add(key2, newVal2);
@ -480,53 +445,44 @@ BOOST_AUTO_TEST_CASE(AddRemoveSameKeyTest)
Utils::ValidateCounter(perfData, HashTablePerfCounter::RecordsCount, 0);
}
BOOST_AUTO_TEST_CASE(FixedKeyValueHashTableTest)
{
BOOST_AUTO_TEST_CASE(FixedKeyValueHashTableTest) {
// Fixed 4 byte keys and 6 byte values.
std::vector<HashTable::Setting> settings =
{
HashTable::Setting{ 100, 200, 4, 0 },
HashTable::Setting{ 100, 200, 0, 6 },
HashTable::Setting{ 100, 200, 4, 6 }
};
std::vector<HashTable::Setting> settings = {
HashTable::Setting{100, 200, 4, 0}, HashTable::Setting{100, 200, 0, 6},
HashTable::Setting{100, 200, 4, 6}};
for (const auto& setting : settings)
{
for (const auto& setting : settings) {
HashTable hashTable{setting, m_allocator};
WritableHashTable<Allocator> writableHashTable(hashTable, m_epochManager);
ReadOnlyHashTable<Allocator> readOnlyHashTable(hashTable);
constexpr std::uint8_t c_numRecords = 10;
for (std::uint8_t i = 0; i < c_numRecords; ++i)
{
for (std::uint8_t i = 0; i < c_numRecords; ++i) {
const std::string keyStr = "key" + std::to_string(i);
const std::string valueStr = "value" + std::to_string(i);
writableHashTable.Add(
Utils::ConvertFromString<IReadOnlyHashTable::Key>(keyStr.c_str()),
Utils::ConvertFromString<IReadOnlyHashTable::Value>(valueStr.c_str()));
Utils::ConvertFromString<IReadOnlyHashTable::Value>(
valueStr.c_str()));
}
Utils::ValidateCounters(
writableHashTable.GetPerfData(),
{
{ HashTablePerfCounter::RecordsCount, 10 },
Utils::ValidateCounters(writableHashTable.GetPerfData(),
{{HashTablePerfCounter::RecordsCount, 10},
{HashTablePerfCounter::BucketsCount, 100},
{HashTablePerfCounter::TotalKeySize, 40},
{HashTablePerfCounter::TotalValueSize, 60},
{HashTablePerfCounter::MinKeySize, 4},
{HashTablePerfCounter::MaxKeySize, 4},
{HashTablePerfCounter::MinValueSize, 6},
{ HashTablePerfCounter::MaxValueSize, 6 }
});
{HashTablePerfCounter::MaxValueSize, 6}});
for (std::uint8_t i = 0; i < c_numRecords; ++i)
{
for (std::uint8_t i = 0; i < c_numRecords; ++i) {
const std::string keyStr = "key" + std::to_string(i);
const std::string valueStr = "value" + std::to_string(i);
const auto expectedValue = Utils::ConvertFromString<IReadOnlyHashTable::Value>(valueStr.c_str());
const auto expectedValue =
Utils::ConvertFromString<IReadOnlyHashTable::Value>(valueStr.c_str());
IReadOnlyHashTable::Value actualValue;
BOOST_CHECK(readOnlyHashTable.Get(
@ -535,27 +491,21 @@ BOOST_AUTO_TEST_CASE(FixedKeyValueHashTableTest)
BOOST_CHECK(expectedValue == actualValue);
}
for (std::uint8_t i = 0; i < c_numRecords; ++i)
{
for (std::uint8_t i = 0; i < c_numRecords; ++i) {
const std::string keyStr = "key" + std::to_string(i);
writableHashTable.Remove(
Utils::ConvertFromString<IReadOnlyHashTable::Key>(keyStr.c_str()));
}
Utils::ValidateCounters(
writableHashTable.GetPerfData(),
{
{ HashTablePerfCounter::RecordsCount, 0 },
Utils::ValidateCounters(writableHashTable.GetPerfData(),
{{HashTablePerfCounter::RecordsCount, 0},
{HashTablePerfCounter::BucketsCount, 100},
{HashTablePerfCounter::TotalKeySize, 0},
{ HashTablePerfCounter::TotalValueSize, 0 }
});
{HashTablePerfCounter::TotalValueSize, 0}});
}
}
BOOST_AUTO_TEST_CASE(HashTableIteratorTest)
{
BOOST_AUTO_TEST_CASE(HashTableIteratorTest) {
Allocator allocator;
constexpr std::uint32_t c_numBuckets = 10;
HashTable hashTable{HashTable::Setting{c_numBuckets}, allocator};
@ -567,12 +517,10 @@ BOOST_AUTO_TEST_CASE(HashTableIteratorTest)
BOOST_CHECK(!iter->MoveNext());
CHECK_EXCEPTION_THROWN_WITH_MESSAGE(
iter->GetKey(),
"HashTableIterator is not correctly used.");
iter->GetKey(), "HashTableIterator is not correctly used.");
CHECK_EXCEPTION_THROWN_WITH_MESSAGE(
iter->GetValue(),
"HashTableIterator is not correctly used.");
iter->GetValue(), "HashTableIterator is not correctly used.");
}
using Buffer = std::vector<std::uint8_t>;
@ -581,11 +529,12 @@ BOOST_AUTO_TEST_CASE(HashTableIteratorTest)
BufferMap keyValueMap;
// The number of records should be such that it will create chained entries
// for at least one bucket. So it should be greater than HashTable::Entry::c_numDataPerEntry * number of buckets.
constexpr std::uint32_t c_numRecords = (HashTable::Entry::c_numDataPerEntry * c_numBuckets) + 1;
// for at least one bucket. So it should be greater than
// HashTable::Entry::c_numDataPerEntry * number of buckets.
constexpr std::uint32_t c_numRecords =
(HashTable::Entry::c_numDataPerEntry * c_numBuckets) + 1;
for (auto i = 0U; i < c_numRecords; ++i)
{
for (auto i = 0U; i < c_numRecords; ++i) {
std::stringstream keyStream;
keyStream << "key" << i;
@ -595,15 +544,19 @@ BOOST_AUTO_TEST_CASE(HashTableIteratorTest)
std::string keyStr = keyStream.str();
std::string valStr = valStream.str();
auto key = Utils::ConvertFromString<IReadOnlyHashTable::Key>(keyStr.c_str());
auto val = Utils::ConvertFromString<IReadOnlyHashTable::Value>(valStr.c_str());
auto key =
Utils::ConvertFromString<IReadOnlyHashTable::Key>(keyStr.c_str());
auto val =
Utils::ConvertFromString<IReadOnlyHashTable::Value>(valStr.c_str());
writableHashTable.Add(key, val);
keyValueMap[Buffer(key.m_data, key.m_data + key.m_size)] = Buffer(val.m_data, val.m_data + val.m_size);
keyValueMap[Buffer(key.m_data, key.m_data + key.m_size)] =
Buffer(val.m_data, val.m_data + val.m_size);
}
BOOST_REQUIRE(writableHashTable.GetPerfData().Get(HashTablePerfCounter::MaxBucketChainLength) >= 2);
BOOST_REQUIRE(writableHashTable.GetPerfData().Get(
HashTablePerfCounter::MaxBucketChainLength) >= 2);
BOOST_CHECK_EQUAL(keyValueMap.size(), c_numRecords);
{
@ -611,37 +564,35 @@ BOOST_AUTO_TEST_CASE(HashTableIteratorTest)
// Validate the data using the iterator.
auto iter = writableHashTable.GetIterator();
for (auto i = 0U; i < c_numRecords; ++i)
{
for (auto i = 0U; i < c_numRecords; ++i) {
BOOST_CHECK(iter->MoveNext());
const auto& key = iter->GetKey();
const auto& val = iter->GetValue();
keyValueMapFromIterator[Buffer(key.m_data, key.m_data + key.m_size)] = Buffer(val.m_data, val.m_data + val.m_size);
keyValueMapFromIterator[Buffer(key.m_data, key.m_data + key.m_size)] =
Buffer(val.m_data, val.m_data + val.m_size);
}
BOOST_CHECK(!iter->MoveNext());
BOOST_CHECK(keyValueMap == keyValueMapFromIterator);
// Reset should move the iterator to the beginning.
iter->Reset();
for (auto i = 0U; i < c_numRecords; ++i)
{
for (auto i = 0U; i < c_numRecords; ++i) {
BOOST_CHECK(iter->MoveNext());
}
BOOST_CHECK(!iter->MoveNext());
}
// Remove half of the key.
for (auto i = 0U; i < c_numRecords; ++i)
{
if (i % 2 == 0U)
{
for (auto i = 0U; i < c_numRecords; ++i) {
if (i % 2 == 0U) {
std::stringstream keyStream;
keyStream << "key" << i;
std::string keyStr = keyStream.str();
auto key = Utils::ConvertFromString<IReadOnlyHashTable::Key>(keyStr.c_str());
auto key =
Utils::ConvertFromString<IReadOnlyHashTable::Key>(keyStr.c_str());
BOOST_CHECK(writableHashTable.Remove(key));
@ -655,8 +606,7 @@ BOOST_AUTO_TEST_CASE(HashTableIteratorTest)
{
BufferMap keyValueMapFromIterator;
auto iter = writableHashTable.GetIterator();
for (auto i = 0U; i < c_numRecords / 2U; ++i)
{
for (auto i = 0U; i < c_numRecords / 2U; ++i) {
BOOST_CHECK(iter->MoveNext());
const auto& key = iter->GetKey();

20
Unittests/SettingAdapterTest.cpp
Просмотреть файл

@ -1,19 +1,17 @@
#include <boost/test/unit_test.hpp>
#include "L4/HashTable/Common/SettingAdapter.h"
#include "L4/HashTable/Common/Record.h"
#include "CheckedAllocator.h"
#include "L4/HashTable/Common/Record.h"
#include "L4/HashTable/Common/SettingAdapter.h"
namespace L4
{
namespace UnitTests
{
namespace L4 {
namespace UnitTests {
using SharedHashTable = HashTable::SharedHashTable<HashTable::RecordBuffer, CheckedAllocator<>>;
using SharedHashTable =
HashTable::SharedHashTable<HashTable::RecordBuffer, CheckedAllocator<>>;
BOOST_AUTO_TEST_SUITE(SettingAdapterTests)
BOOST_AUTO_TEST_CASE(SettingAdapterTestWithDefaultValues)
{
BOOST_AUTO_TEST_CASE(SettingAdapterTestWithDefaultValues) {
HashTableConfig::Setting from{100U};
const auto to = HashTable::SettingAdapter{}.Convert<SharedHashTable>(from);
@ -23,9 +21,7 @@ BOOST_AUTO_TEST_CASE(SettingAdapterTestWithDefaultValues)
BOOST_CHECK_EQUAL(to.m_fixedValueSize, 0U);
}
BOOST_AUTO_TEST_CASE(SettingAdapterTestWithNonDefaultValues)
{
BOOST_AUTO_TEST_CASE(SettingAdapterTestWithNonDefaultValues) {
HashTableConfig::Setting from{100U, 10U, 5U, 20U};
const auto to = HashTable::SettingAdapter{}.Convert<SharedHashTable>(from);

30
Unittests/Utils.cpp
Просмотреть файл

@ -1,33 +1,23 @@
#include <boost/test/unit_test.hpp>
#include "Utils.h"
#include <boost/test/unit_test.hpp>
namespace L4
{
namespace UnitTests
{
namespace Utils
{
namespace L4 {
namespace UnitTests {
namespace Utils {
void ValidateCounter(
const HashTablePerfData& actual,
void ValidateCounter(const HashTablePerfData& actual,
HashTablePerfCounter perfCounter,
PerfCounters<HashTablePerfCounter>::TValue expectedValue)
{
PerfCounters<HashTablePerfCounter>::TValue expectedValue) {
BOOST_CHECK_MESSAGE(
actual.Get(perfCounter) == expectedValue,
c_hashTablePerfCounterNames[static_cast<std::size_t>(perfCounter)]
<< " counter: "
<< actual.Get(perfCounter)
<< " counter: " << actual.Get(perfCounter)
<< " (actual) != " << expectedValue << " (expected).");
}
void ValidateCounters(
const HashTablePerfData& actual,
const ExpectedCounterValues& expected)
{
for (const auto& expectedCounter : expected)
{
void ValidateCounters(const HashTablePerfData& actual,
const ExpectedCounterValues& expected) {
for (const auto& expectedCounter : expected) {
ValidateCounter(actual, expectedCounter.first, expectedCounter.second);
}
}

57
Unittests/Utils.h
Просмотреть файл

@ -1,45 +1,36 @@
#pragma once
#include <string.h>
#include <array>
#include <cstdint>
#include <string>
#include <string.h>
#include <vector>
#include "L4/Log/PerfCounter.h"
#include "L4/Utils/Exception.h"
namespace L4
{
namespace UnitTests
{
namespace L4 {
namespace UnitTests {
// Macro CHECK_EXCEPTION_THROWN
#define CHECK_EXCEPTION_THROWN(statement) \
do { \
bool isExceptionThrown = false; \
try \
{ \
try { \
statement; \
} \
catch (const RuntimeException&) \
{ \
} catch (const RuntimeException&) { \
isExceptionThrown = true; \
} \
BOOST_CHECK(isExceptionThrown); \
} while (0)
#define CHECK_EXCEPTION_THROWN_WITH_MESSAGE(statement, message) \
do { \
bool isExceptionThrown = false; \
std::string exceptionMsg; \
try \
{ \
try { \
statement; \
} \
catch (const RuntimeException& ex) \
{ \
} catch (const RuntimeException& ex) { \
isExceptionThrown = true; \
exceptionMsg = ex.what(); \
BOOST_TEST_MESSAGE("Exception Message: " << exceptionMsg); \
@ -48,18 +39,14 @@ do { \
BOOST_CHECK(strcmp((message), exceptionMsg.c_str()) == 0); \
} while (0)
// This will validate the given message is a prefix of the exception message.
#define CHECK_EXCEPTION_THROWN_WITH_PREFIX_MESSAGE(statement, message) \
do { \
bool isExceptionThrown = false; \
std::string exceptionMsg; \
try \
{ \
try { \
statement; \
} \
catch (const RuntimeException& ex) \
{ \
} catch (const RuntimeException& ex) { \
isExceptionThrown = true; \
exceptionMsg = ex.what(); \
BOOST_TEST_MESSAGE("Exception Message: " << exceptionMsg); \
@ -68,42 +55,32 @@ do { \
BOOST_CHECK(exceptionMsg.compare(0, strlen(message), message) == 0); \
} while (0)
namespace Utils
{
namespace Utils {
template <typename T>
T ConvertFromString(const char* str)
{
return T(
reinterpret_cast<const std::uint8_t*>(str),
T ConvertFromString(const char* str) {
return T(reinterpret_cast<const std::uint8_t*>(str),
static_cast<typename T::size_type>(strlen(str)));
}
template <typename T>
std::string ConvertToString(const T& t)
{
std::string ConvertToString(const T& t) {
return std::string(reinterpret_cast<const char*>(t.m_data), t.m_size);
}
// Counter related validation util function.
using ExpectedCounterValues
= std::vector<
std::pair<
HashTablePerfCounter,
using ExpectedCounterValues =
std::vector<std::pair<HashTablePerfCounter,
typename PerfCounters<HashTablePerfCounter>::TValue>>;
// Validate the given perfData against the expected counter value.
void ValidateCounter(
const HashTablePerfData& actual,
void ValidateCounter(const HashTablePerfData& actual,
HashTablePerfCounter perfCounter,
PerfCounters<HashTablePerfCounter>::TValue expectedValue);
// Validate the given perfData against the expected counter values.
void ValidateCounters(
const HashTablePerfData& actual,
void ValidateCounters(const HashTablePerfData& actual,
const ExpectedCounterValues& expected);
} // namespace Utils

27
Unittests/UtilsTest.cpp
Просмотреть файл

@ -1,16 +1,13 @@
#include <boost/test/unit_test.hpp>
#include <array>
#include <boost/test/unit_test.hpp>
#include "L4/Utils/Math.h"
namespace L4
{
namespace UnitTests
{
namespace L4 {
namespace UnitTests {
using namespace Utils;
BOOST_AUTO_TEST_CASE(MathTest)
{
BOOST_AUTO_TEST_CASE(MathTest) {
// RoundUp tests.
BOOST_CHECK_EQUAL(Math::RoundUp(5, 10), 10);
BOOST_CHECK_EQUAL(Math::RoundUp(10, 10), 10);
@ -39,15 +36,17 @@ BOOST_AUTO_TEST_CASE(MathTest)
BOOST_CHECK_EQUAL(Math::NextHighestPowerOfTwo(200), 256U);
}
BOOST_AUTO_TEST_CASE(PointerArithmeticTest)
{
BOOST_AUTO_TEST_CASE(PointerArithmeticTest) {
std::array<int, 3> elements;
BOOST_CHECK(reinterpret_cast<int*>(Math::PointerArithmetic::Add(&elements[0], sizeof(int))) == &elements[1]);
BOOST_CHECK(reinterpret_cast<int*>(Math::PointerArithmetic::Subtract(&elements[1], sizeof(int))) == &elements[0]);
BOOST_CHECK(Math::PointerArithmetic::Distance(&elements[2], &elements[0]) == sizeof(int) * 2U);
BOOST_CHECK(Math::PointerArithmetic::Distance(&elements[0], &elements[2]) == sizeof(int) * 2U);
BOOST_CHECK(reinterpret_cast<int*>(Math::PointerArithmetic::Add(
&elements[0], sizeof(int))) == &elements[1]);
BOOST_CHECK(reinterpret_cast<int*>(Math::PointerArithmetic::Subtract(
&elements[1], sizeof(int))) == &elements[0]);
BOOST_CHECK(Math::PointerArithmetic::Distance(&elements[2], &elements[0]) ==
sizeof(int) * 2U);
BOOST_CHECK(Math::PointerArithmetic::Distance(&elements[0], &elements[2]) ==
sizeof(int) * 2U);
}
} // namespace UnitTests

30
inc/L4/Epoch/Config.h
Просмотреть файл

@ -1,28 +1,26 @@
#pragma once
#include <cstdint>
#include <chrono>
#include <cstdint>
namespace L4
{
namespace L4 {
// EpochManagerConfig struct.
struct EpochManagerConfig
{
// "numActionQueues" indicates how many action containers there will be in order to
// increase the throughput of registering an action.
// "performActionsInParallelThreshold" indicates the threshold value above which
// the actions are performed in parallel.
// "maxNumThreadsToPerformActions" indicates how many threads will be used when
// performing an action in parallel.
struct EpochManagerConfig {
// "numActionQueues" indicates how many action containers there will be in
// order to increase the throughput of registering an action.
// "performActionsInParallelThreshold" indicates the threshold value above
// which the actions are performed in parallel.
// "maxNumThreadsToPerformActions" indicates how many threads will be used
// when performing an action in parallel.
explicit EpochManagerConfig(
std::uint32_t epochQueueSize = 1000,
std::chrono::milliseconds epochProcessingInterval = std::chrono::milliseconds{ 1000 },
std::chrono::milliseconds epochProcessingInterval =
std::chrono::milliseconds{1000},
std::uint8_t numActionQueues = 1)
: m_epochQueueSize{ epochQueueSize }
, m_epochProcessingInterval{ epochProcessingInterval }
, m_numActionQueues{ numActionQueues }
{}
: m_epochQueueSize{epochQueueSize},
m_epochProcessingInterval{epochProcessingInterval},
m_numActionQueues{numActionQueues} {}
std::uint32_t m_epochQueueSize;
std::chrono::milliseconds m_epochProcessingInterval;

26
inc/L4/Epoch/EpochActionManager.h
Просмотреть файл

@ -11,24 +11,22 @@
#include "IEpochActionManager.h"
#include "Utils/Lock.h"
namespace L4
{
namespace L4 {
// EpochActionManager provides functionalities to add actions at an epoch and to perform
// actions up to the given epoch.
class EpochActionManager
{
// EpochActionManager provides functionalities to add actions at an epoch and to
// perform actions up to the given epoch.
class EpochActionManager {
public:
// "numActionQueues" indicates how many action containers there will be in order to
// increase the throughput of registering an action. This will be re-calculated to
// the next highest power of two so that the "&" operator can be used for accessing
// the next queue.
// "numActionQueues" indicates how many action containers there will be in
// order to increase the throughput of registering an action. This will be
// re-calculated to the next highest power of two so that the "&" operator can
// be used for accessing the next queue.
explicit EpochActionManager(std::uint8_t numActionQueues);
// Adds an action at a given epoch counter.
// This function is thread-safe.
void RegisterAction(std::uint64_t epochCounter, IEpochActionManager::Action&& action);
void RegisterAction(std::uint64_t epochCounter,
IEpochActionManager::Action&& action);
// Perform actions whose associated epoch counter value is less than
// the given epoch counter value, and returns the number of actions performed.
@ -47,7 +45,8 @@ private:
// If the performance of using std::map becomes an issue, we can revisit this.
using EpochToActions = std::map<std::uint64_t, Actions>;
using EpochToActionsWithLock = std::tuple<std::unique_ptr<Mutex>, EpochToActions>;
using EpochToActionsWithLock =
std::tuple<std::unique_ptr<Mutex>, EpochToActions>;
// Run actions based on the configuration.
void ApplyActions(Actions& actions);
@ -59,5 +58,4 @@ private:
std::atomic<std::uint32_t> m_counter;
};
} // namespace L4

101
inc/L4/Epoch/EpochQueue.h
Просмотреть файл

@ -7,35 +7,30 @@
#include "Utils/Exception.h"
#include "Utils/Lock.h"
namespace L4
{
namespace L4 {
// EpochQueue struct represents reference counts for each epoch.
// Each value of the queue (fixed-size array) is the reference counts at an index,
// where an index represents an epoch (time).
template <
typename TSharableLock,
// Each value of the queue (fixed-size array) is the reference counts at an
// index, where an index represents an epoch (time).
template <typename TSharableLock,
typename TExclusiveLock,
typename Allocator = std::allocator<void>
>
struct EpochQueue
{
static_assert(
std::is_same<typename TSharableLock::mutex_type, typename TExclusiveLock::mutex_type>::value,
typename Allocator = std::allocator<void> >
struct EpochQueue {
static_assert(std::is_same<typename TSharableLock::mutex_type,
typename TExclusiveLock::mutex_type>::value,
"mutex type should be the same");
public:
EpochQueue(
std::uint64_t epochCounter,
EpochQueue(std::uint64_t epochCounter,
std::uint32_t queueSize,
Allocator allocator = Allocator())
: m_frontIndex{ epochCounter }
, m_backIndex{ epochCounter }
, m_mutexForBackIndex{}
, m_refCounts{ queueSize, typename Allocator::template rebind<RefCount>::other(allocator) }
{
if (queueSize == 0U)
{
: m_frontIndex{epochCounter},
m_backIndex{epochCounter},
m_mutexForBackIndex{},
m_refCounts{
queueSize,
typename Allocator::template rebind<RefCount>::other(allocator)} {
if (queueSize == 0U) {
throw RuntimeException("Zero queue size is not allowed.");
}
}
@ -43,9 +38,8 @@ public:
using SharableLock = TSharableLock;
using ExclusiveLock = TExclusiveLock;
using RefCount = std::atomic<std::uint32_t>;
using RefCounts = Interprocess::Container::Vector<
RefCount,
typename Allocator::template rebind<RefCount>::other>;
using RefCounts = Interprocess::Container::
Vector<RefCount, typename Allocator::template rebind<RefCount>::other>;
// The followings (m_frontIndex and m_backIndex) are
// accessed/updated only by the owner thread (only one thread), thus
@ -61,42 +55,38 @@ public:
typename SharableLock::mutex_type m_mutexForBackIndex;
// Reference counts per epoch count.
// The index represents the epoch counter value and the value represents the reference counts.
// The index represents the epoch counter value and the value represents the
// reference counts.
RefCounts m_refCounts;
};
// EpochRefManager provides functionality of adding/removing references
// to the epoch counter.
template <typename EpochQueue>
class EpochRefManager
{
class EpochRefManager {
public:
explicit EpochRefManager(EpochQueue& epochQueue)
: m_epochQueue(epochQueue)
{}
explicit EpochRefManager(EpochQueue& epochQueue) : m_epochQueue(epochQueue) {}
// Increment a reference to the current epoch counter.
// This function is thread-safe.
std::uint64_t AddRef()
{
std::uint64_t AddRef() {
// The synchronization is needed for EpochCounterManager::AddNewEpoch().
typename EpochQueue::SharableLock lock(m_epochQueue.m_mutexForBackIndex);
++m_epochQueue.m_refCounts[m_epochQueue.m_backIndex % m_epochQueue.m_refCounts.size()];
++m_epochQueue.m_refCounts[m_epochQueue.m_backIndex %
m_epochQueue.m_refCounts.size()];
return m_epochQueue.m_backIndex;
}
// Decrement a reference count for the given epoch counter.
// This function is thread-safe.
void RemoveRef(std::uint64_t epochCounter)
{
auto& refCounter = m_epochQueue.m_refCounts[epochCounter % m_epochQueue.m_refCounts.size()];
void RemoveRef(std::uint64_t epochCounter) {
auto& refCounter =
m_epochQueue
.m_refCounts[epochCounter % m_epochQueue.m_refCounts.size()];
if (refCounter == 0)
{
if (refCounter == 0) {
throw RuntimeException("Reference counter is invalid.");
}
@ -110,21 +100,17 @@ private:
EpochQueue& m_epochQueue;
};
// EpochCounterManager provides functionality of updating the current epoch counter
// and getting the latest unreferenced epoch counter.
// EpochCounterManager provides functionality of updating the current epoch
// counter and getting the latest unreferenced epoch counter.
template <typename EpochQueue>
class EpochCounterManager
{
class EpochCounterManager {
public:
explicit EpochCounterManager(EpochQueue& epochQueue)
: m_epochQueue(epochQueue)
{}
: m_epochQueue(epochQueue) {}
// Increments the current epoch count by one.
// This function is thread-safe.
void AddNewEpoch()
{
void AddNewEpoch() {
// The synchronization is needed for EpochRefManager::AddRef().
typename EpochQueue::ExclusiveLock lock(m_epochQueue.m_mutexForBackIndex);
@ -137,17 +123,14 @@ public:
// count such that all other epoch counts' references are zeros.
// Note that this function is NOT thread safe, and should be run on the
// same thread as the one that calls AddNewEpoch().
std::uint64_t RemoveUnreferenceEpochCounters()
{
while (m_epochQueue.m_backIndex > m_epochQueue.m_frontIndex)
{
if (m_epochQueue.m_refCounts[m_epochQueue.m_frontIndex % m_epochQueue.m_refCounts.size()] == 0U)
{
std::uint64_t RemoveUnreferenceEpochCounters() {
while (m_epochQueue.m_backIndex > m_epochQueue.m_frontIndex) {
if (m_epochQueue.m_refCounts[m_epochQueue.m_frontIndex %
m_epochQueue.m_refCounts.size()] == 0U) {
++m_epochQueue.m_frontIndex;
}
else
{
// There are references to the front of the queue and will return this front index.
} else {
// There are references to the front of the queue and will return this
// front index.
break;
}
}

27
inc/L4/Epoch/EpochRefPolicy.h
Просмотреть файл

@ -1,32 +1,27 @@
#pragma once
#include <cstdint>
#include <boost/integer_traits.hpp>
#include <cstdint>
namespace L4
{
namespace L4 {
// EpochRefPolicy class
template <typename EpochRefManager>
class EpochRefPolicy
{
class EpochRefPolicy {
public:
explicit EpochRefPolicy(EpochRefManager& epochRefManager)
: m_epochRefManager{ epochRefManager }
, m_epochCounter{ m_epochRefManager.AddRef() }
{}
: m_epochRefManager{epochRefManager},
m_epochCounter{m_epochRefManager.AddRef()} {}
EpochRefPolicy(EpochRefPolicy&& epochRefPolicy)
: m_epochRefManager{ epochRefPolicy.m_epochRefManager }
, m_epochCounter{ epochRefPolicy.m_epochCounter }
{
epochRefPolicy.m_epochCounter = boost::integer_traits<std::uint64_t>::const_max;
: m_epochRefManager{epochRefPolicy.m_epochRefManager},
m_epochCounter{epochRefPolicy.m_epochCounter} {
epochRefPolicy.m_epochCounter =
boost::integer_traits<std::uint64_t>::const_max;
}
~EpochRefPolicy()
{
if (m_epochCounter != boost::integer_traits<std::uint64_t>::const_max)
{
~EpochRefPolicy() {
if (m_epochCounter != boost::integer_traits<std::uint64_t>::const_max) {
m_epochRefManager.RemoveRef(m_epochCounter);
}
}

8
inc/L4/Epoch/IEpochActionManager.h
Просмотреть файл

@ -2,13 +2,10 @@
#include <functional>
namespace L4
{
namespace L4 {
// IEpochActionManager interface exposes an API for registering an Action.
struct IEpochActionManager
{
struct IEpochActionManager {
using Action = std::function<void()>;
virtual ~IEpochActionManager(){};
@ -18,5 +15,4 @@ struct IEpochActionManager
virtual void RegisterAction(Action&& action) = 0;
};
} // namespace L4

274
inc/L4/HashTable/Cache/HashTable.h
Просмотреть файл

@ -4,27 +4,23 @@
#include <cstdint>
#include <mutex>
#include <stdexcept>
#include "detail/ToRawPointer.h"
#include "Epoch/IEpochActionManager.h"
#include "HashTable/Cache/Metadata.h"
#include "HashTable/IHashTable.h"
#include "HashTable/ReadWrite/HashTable.h"
#include "HashTable/Cache/Metadata.h"
#include "Utils/Clock.h"
#include "detail/ToRawPointer.h"
namespace L4
{
namespace HashTable
{
namespace Cache
{
namespace L4 {
namespace HashTable {
namespace Cache {
// ReadOnlyHashTable class implements IReadOnlyHashTable interface and provides
// the functionality to read data given a key.
template <typename Allocator, typename Clock = Utils::EpochClock>
class ReadOnlyHashTable
: public virtual ReadWrite::ReadOnlyHashTable<Allocator>
, protected Clock
{
: public virtual ReadWrite::ReadOnlyHashTable<Allocator>,
protected Clock {
public:
using Base = ReadWrite::ReadOnlyHashTable<Allocator>;
using HashTable = typename Base::HashTable;
@ -35,37 +31,28 @@ public:
class Iterator;
ReadOnlyHashTable(
HashTable& hashTable,
std::chrono::seconds recordTimeToLive)
: Base(
hashTable,
RecordSerializer{
hashTable.m_setting.m_fixedKeySize,
ReadOnlyHashTable(HashTable& hashTable, std::chrono::seconds recordTimeToLive)
: Base(hashTable,
RecordSerializer{hashTable.m_setting.m_fixedKeySize,
hashTable.m_setting.m_fixedValueSize,
Metadata::c_metaDataSize })
, m_recordTimeToLive{ recordTimeToLive }
{}
Metadata::c_metaDataSize}),
m_recordTimeToLive{recordTimeToLive} {}
virtual bool Get(const Key& key, Value& value) const override
{
virtual bool Get(const Key& key, Value& value) const override {
const auto status = GetInternal(key, value);
// Note that the following const_cast is safe and necessary to update cache hit information.
const_cast<HashTablePerfData&>(this->GetPerfData()).Increment(
status
? HashTablePerfCounter::CacheHitCount
// Note that the following const_cast is safe and necessary to update cache
// hit information.
const_cast<HashTablePerfData&>(this->GetPerfData())
.Increment(status ? HashTablePerfCounter::CacheHitCount
: HashTablePerfCounter::CacheMissCount);
return status;
}
virtual IIteratorPtr GetIterator() const override
{
virtual IIteratorPtr GetIterator() const override {
return std::make_unique<Iterator>(
this->m_hashTable,
this->m_recordSerializer,
m_recordTimeToLive,
this->m_hashTable, this->m_recordSerializer, m_recordTimeToLive,
this->GetCurrentEpochTime());
}
@ -73,20 +60,19 @@ public:
ReadOnlyHashTable& operator=(const ReadOnlyHashTable&) = delete;
protected:
bool GetInternal(const Key& key, Value& value) const
{
if (!Base::Get(key, value))
{
bool GetInternal(const Key& key, Value& value) const {
if (!Base::Get(key, value)) {
return false;
}
assert(value.m_size > Metadata::c_metaDataSize);
// If the record with the given key is found, check if the record is expired or not.
// Note that the following const_cast is safe and necessary to update the access status.
Metadata metaData{ const_cast<std::uint32_t*>(reinterpret_cast<const std::uint32_t*>(value.m_data)) };
if (metaData.IsExpired(this->GetCurrentEpochTime(), m_recordTimeToLive))
{
// If the record with the given key is found, check if the record is expired
// or not. Note that the following const_cast is safe and necessary to
// update the access status.
Metadata metaData{const_cast<std::uint32_t*>(
reinterpret_cast<const std::uint32_t*>(value.m_data))};
if (metaData.IsExpired(this->GetCurrentEpochTime(), m_recordTimeToLive)) {
return false;
}
@ -101,45 +87,35 @@ protected:
std::chrono::seconds m_recordTimeToLive;
};
template <typename Allocator, typename Clock>
class ReadOnlyHashTable<Allocator, Clock>::Iterator : public Base::Iterator
{
class ReadOnlyHashTable<Allocator, Clock>::Iterator : public Base::Iterator {
public:
using BaseIterator = typename Base::Iterator;
Iterator(
const HashTable& hashTable,
Iterator(const HashTable& hashTable,
const RecordSerializer& recordDeserializer,
std::chrono::seconds recordTimeToLive,
std::chrono::seconds currentEpochTime)
: BaseIterator(hashTable, recordDeserializer)
, m_recordTimeToLive{ recordTimeToLive }
, m_currentEpochTime{ currentEpochTime }
{}
: BaseIterator(hashTable, recordDeserializer),
m_recordTimeToLive{recordTimeToLive},
m_currentEpochTime{currentEpochTime} {}
Iterator(Iterator&& other)
: BaseIterator(std::move(other))
, m_recordTimeToLive{ std::move(other.m_recordTimeToLive) }
, m_currentEpochTime{ std::move(other.m_currentEpochTime) }
{}
: BaseIterator(std::move(other)),
m_recordTimeToLive{std::move(other.m_recordTimeToLive)},
m_currentEpochTime{std::move(other.m_currentEpochTime)} {}
bool MoveNext() override
{
if (!BaseIterator::MoveNext())
{
bool MoveNext() override {
if (!BaseIterator::MoveNext()) {
return false;
}
do
{
do {
const Metadata metaData{
const_cast<std::uint32_t*>(
reinterpret_cast<const std::uint32_t*>(
const_cast<std::uint32_t*>(reinterpret_cast<const std::uint32_t*>(
BaseIterator::GetValue().m_data))};
if (!metaData.IsExpired(m_currentEpochTime, m_recordTimeToLive))
{
if (!metaData.IsExpired(m_currentEpochTime, m_recordTimeToLive)) {
return true;
}
} while (BaseIterator::MoveNext());
@ -147,8 +123,7 @@ public:
return false;
}
Value GetValue() const override
{
Value GetValue() const override {
auto value = BaseIterator::GetValue();
value.m_data += Metadata::c_metaDataSize;
value.m_size -= Metadata::c_metaDataSize;
@ -161,19 +136,16 @@ private:
std::chrono::seconds m_currentEpochTime;
};
// The following warning is from the virtual inheritance and safe to disable in this case.
// https://msdn.microsoft.com/en-us/library/6b3sy7ae.aspx
// The following warning is from the virtual inheritance and safe to disable in
// this case. https://msdn.microsoft.com/en-us/library/6b3sy7ae.aspx
#pragma warning(push)
#pragma warning(disable : 4250)
// WritableHashTable class implements IWritableHashTable interface and also provides
// the read only access (Get()) to the hash table.
// WritableHashTable class implements IWritableHashTable interface and also
// provides the read only access (Get()) to the hash table.
template <typename Allocator, typename Clock = Utils::EpochClock>
class WritableHashTable
: public ReadOnlyHashTable<Allocator, Clock>
, public ReadWrite::WritableHashTable<Allocator>
{
class WritableHashTable : public ReadOnlyHashTable<Allocator, Clock>,
public ReadWrite::WritableHashTable<Allocator> {
public:
using ReadOnlyBase = ReadOnlyHashTable<Allocator, Clock>;
using WritableBase = typename ReadWrite::WritableHashTable<Allocator>;
@ -183,32 +155,27 @@ public:
using Value = typename ReadOnlyBase::Value;
using ISerializerPtr = typename WritableBase::ISerializerPtr;
WritableHashTable(
HashTable& hashTable,
WritableHashTable(HashTable& hashTable,
IEpochActionManager& epochManager,
std::uint64_t maxCacheSizeInBytes,
std::chrono::seconds recordTimeToLive,
bool forceTimeBasedEviction)
: ReadOnlyBase::Base(
hashTable,
RecordSerializer{
hashTable.m_setting.m_fixedKeySize,
RecordSerializer{hashTable.m_setting.m_fixedKeySize,
hashTable.m_setting.m_fixedValueSize,
Metadata::c_metaDataSize })
, ReadOnlyBase(hashTable, recordTimeToLive)
, WritableBase(hashTable, epochManager)
, m_maxCacheSizeInBytes{ maxCacheSizeInBytes }
, m_forceTimeBasedEviction{ forceTimeBasedEviction }
, m_currentEvictBucketIndex{ 0U }
{}
Metadata::c_metaDataSize}),
ReadOnlyBase(hashTable, recordTimeToLive),
WritableBase(hashTable, epochManager),
m_maxCacheSizeInBytes{maxCacheSizeInBytes},
m_forceTimeBasedEviction{forceTimeBasedEviction},
m_currentEvictBucketIndex{0U} {}
using ReadOnlyBase::Get;
using ReadOnlyBase::GetPerfData;
virtual void Add(const Key& key, const Value& value) override
{
if (m_forceTimeBasedEviction)
{
virtual void Add(const Key& key, const Value& value) override {
if (m_forceTimeBasedEviction) {
EvictBasedOnTime(key);
}
@ -217,8 +184,7 @@ public:
WritableBase::Add(CreateRecordBuffer(key, value));
}
virtual ISerializerPtr GetSerializer() const override
{
virtual ISerializerPtr GetSerializer() const override {
throw std::runtime_error("Not implemented yet.");
}
@ -226,8 +192,7 @@ private:
using Mutex = std::mutex;
using Lock = std::lock_guard<Mutex>;
void EvictBasedOnTime(const Key& key)
{
void EvictBasedOnTime(const Key& key) {
const auto bucketIndex = this->GetBucketInfo(key).first;
auto* entry = &(this->m_hashTable.m_buckets[bucketIndex]);
@ -236,23 +201,19 @@ private:
typename HashTable::Lock lock{this->m_hashTable.GetMutex(bucketIndex)};
while (entry != nullptr)
{
for (std::uint8_t i = 0; i < HashTable::Entry::c_numDataPerEntry; ++i)
{
while (entry != nullptr) {
for (std::uint8_t i = 0; i < HashTable::Entry::c_numDataPerEntry; ++i) {
const auto data = entry->m_dataList[i].Load(std::memory_order_relaxed);
if (data != nullptr)
{
if (data != nullptr) {
const Metadata metadata{
const_cast<std::uint32_t*>(
reinterpret_cast<const std::uint32_t*>(
const_cast<std::uint32_t*>(reinterpret_cast<const std::uint32_t*>(
this->m_recordSerializer.Deserialize(*data).m_value.m_data))};
if (metadata.IsExpired(curEpochTime, this->m_recordTimeToLive))
{
if (metadata.IsExpired(curEpochTime, this->m_recordTimeToLive)) {
WritableBase::Remove(*entry, i);
this->m_hashTable.m_perfData.Increment(HashTablePerfCounter::EvictedRecordsCount);
this->m_hashTable.m_perfData.Increment(
HashTablePerfCounter::EvictedRecordsCount);
}
}
}
@ -261,72 +222,73 @@ private:
}
}
// Evict uses CLOCK algorithm to evict records based on expiration and access status
// until the number of bytes freed match the given number of bytes needed.
void Evict(std::uint64_t bytesNeeded)
{
// Evict uses CLOCK algorithm to evict records based on expiration and access
// status until the number of bytes freed match the given number of bytes
// needed.
void Evict(std::uint64_t bytesNeeded) {
std::uint64_t numBytesToFree = CalculateNumBytesToFree(bytesNeeded);
if (numBytesToFree == 0U)
{
if (numBytesToFree == 0U) {
return;
}
// Start evicting records with a lock.
Lock evictLock{m_evictMutex};
// Recalculate the number of bytes to free since other thread may have already evicted.
// Recalculate the number of bytes to free since other thread may have
// already evicted.
numBytesToFree = CalculateNumBytesToFree(bytesNeeded);
if (numBytesToFree == 0U)
{
if (numBytesToFree == 0U) {
return;
}
const auto curEpochTime = this->GetCurrentEpochTime();
// The max number of iterations we are going through per eviction is twice the number
// of buckets so that it can clear the access status. Note that this is the worst
// case scenario and the eviction process should exit much quicker in a normal case.
// The max number of iterations we are going through per eviction is twice
// the number of buckets so that it can clear the access status. Note that
// this is the worst case scenario and the eviction process should exit much
// quicker in a normal case.
auto& buckets = this->m_hashTable.m_buckets;
std::uint64_t numIterationsRemaining = buckets.size() * 2U;
while (numBytesToFree > 0U && numIterationsRemaining-- > 0U)
{
const auto currentBucketIndex = m_currentEvictBucketIndex++ % buckets.size();
while (numBytesToFree > 0U && numIterationsRemaining-- > 0U) {
const auto currentBucketIndex =
m_currentEvictBucketIndex++ % buckets.size();
auto& bucket = buckets[currentBucketIndex];
// Lock the bucket since another thread can bypass Evict() since TotalDataSize can
// be updated before the lock on m_evictMutex is released.
typename HashTable::UniqueLock lock{ this->m_hashTable.GetMutex(currentBucketIndex) };
// Lock the bucket since another thread can bypass Evict() since
// TotalDataSize can be updated before the lock on m_evictMutex is
// released.
typename HashTable::UniqueLock lock{
this->m_hashTable.GetMutex(currentBucketIndex)};
typename HashTable::Entry* entry = &bucket;
while (entry != nullptr)
{
for (std::uint8_t i = 0; i < HashTable::Entry::c_numDataPerEntry; ++i)
{
const auto data = entry->m_dataList[i].Load(std::memory_order_relaxed);
while (entry != nullptr) {
for (std::uint8_t i = 0; i < HashTable::Entry::c_numDataPerEntry; ++i) {
const auto data =
entry->m_dataList[i].Load(std::memory_order_relaxed);
if (data != nullptr)
{
if (data != nullptr) {
const auto record = this->m_recordSerializer.Deserialize(*data);
const auto& value = record.m_value;
Metadata metadata{
const_cast<std::uint32_t*>(
reinterpret_cast<const std::uint32_t*>(
value.m_data)) };
Metadata metadata{const_cast<std::uint32_t*>(
reinterpret_cast<const std::uint32_t*>(value.m_data))};
// Evict this record if
// 1: the record is expired, or
// 2: the entry is not recently accessed (and unset the access bit if set).
if (metadata.IsExpired(curEpochTime, this->m_recordTimeToLive)
|| !metadata.UpdateAccessStatus(false))
{
// 2: the entry is not recently accessed (and unset the access bit
// if set).
if (metadata.IsExpired(curEpochTime, this->m_recordTimeToLive) ||
!metadata.UpdateAccessStatus(false)) {
const auto numBytesFreed = record.m_key.m_size + value.m_size;
numBytesToFree = (numBytesFreed >= numBytesToFree) ? 0U : numBytesToFree - numBytesFreed;
numBytesToFree = (numBytesFreed >= numBytesToFree)
? 0U
: numBytesToFree - numBytesFreed;
WritableBase::Remove(*entry, i);
this->m_hashTable.m_perfData.Increment(HashTablePerfCounter::EvictedRecordsCount);
this->m_hashTable.m_perfData.Increment(
HashTablePerfCounter::EvictedRecordsCount);
}
}
}
@ -338,18 +300,16 @@ private:
// Given the number of bytes needed, it calculates the number of bytes
// to free based on the max cache size.
std::uint64_t CalculateNumBytesToFree(std::uint64_t bytesNeeded) const
{
std::uint64_t CalculateNumBytesToFree(std::uint64_t bytesNeeded) const {
const auto& perfData = GetPerfData();
const std::uint64_t totalDataSize =
perfData.Get(HashTablePerfCounter::TotalKeySize)
+ perfData.Get(HashTablePerfCounter::TotalValueSize)
+ perfData.Get(HashTablePerfCounter::TotalIndexSize);
perfData.Get(HashTablePerfCounter::TotalKeySize) +
perfData.Get(HashTablePerfCounter::TotalValueSize) +
perfData.Get(HashTablePerfCounter::TotalIndexSize);
if ((bytesNeeded < m_maxCacheSizeInBytes)
&& (totalDataSize + bytesNeeded <= m_maxCacheSizeInBytes))
{
if ((bytesNeeded < m_maxCacheSizeInBytes) &&
(totalDataSize + bytesNeeded <= m_maxCacheSizeInBytes)) {
// There are enough free bytes.
return 0U;
}
@ -364,22 +324,22 @@ private:
: bytesNeeded;
}
RecordBuffer* CreateRecordBuffer(const Key& key, const Value& value)
{
const auto bufferSize = this->m_recordSerializer.CalculateBufferSize(key, value);
RecordBuffer* CreateRecordBuffer(const Key& key, const Value& value) {
const auto bufferSize =
this->m_recordSerializer.CalculateBufferSize(key, value);
auto buffer = Detail::to_raw_pointer(
this->m_hashTable.template GetAllocator<std::uint8_t>().allocate(bufferSize));
this->m_hashTable.template GetAllocator<std::uint8_t>().allocate(
bufferSize));
std::uint32_t metaDataBuffer;
Metadata{&metaDataBuffer, this->GetCurrentEpochTime()};
// 4-byte Metadata is inserted between key and value buffer.
return this->m_recordSerializer.Serialize(
key,
value,
Value{ reinterpret_cast<std::uint8_t*>(&metaDataBuffer), sizeof(metaDataBuffer) },
buffer,
bufferSize);
key, value,
Value{reinterpret_cast<std::uint8_t*>(&metaDataBuffer),
sizeof(metaDataBuffer)},
buffer, bufferSize);
}
Mutex m_evictMutex;

60
inc/L4/HashTable/Cache/Metadata.h
Просмотреть файл

@ -4,37 +4,28 @@
#include <chrono>
#include <cstdint>
namespace L4
{
namespace HashTable
{
namespace Cache
{
namespace L4 {
namespace HashTable {
namespace Cache {
// Metadata class that stores caching related data.
// It stores access bit to indicate whether a record is recently accessed
// as well as the epoch time when a record is created.
// Note that this works regardless of the alignment of the metadata passed in.
class Metadata
{
class Metadata {
public:
// Constructs Metadata with the current epoch time.
Metadata(std::uint32_t* metadata, std::chrono::seconds curEpochTime)
: Metadata{ metadata }
{
: Metadata{metadata} {
*m_metadata = curEpochTime.count() & s_epochTimeMask;
}
explicit Metadata(std::uint32_t* metadata)
: m_metadata{ metadata }
{
explicit Metadata(std::uint32_t* metadata) : m_metadata{metadata} {
assert(m_metadata != nullptr);
}
// Returns the stored epoch time.
std::chrono::seconds GetEpochTime() const
{
std::chrono::seconds GetEpochTime() const {
// *m_metadata even on the not-aligned memory should be fine since
// only the byte that contains the access bit is modified, and
// byte read is atomic.
@ -43,36 +34,26 @@ public:
// Returns true if the stored epoch time is expired based
// on the given current epoch time and time-to-live value.
bool IsExpired(
std::chrono::seconds curEpochTime,
std::chrono::seconds timeToLive) const
{
bool IsExpired(std::chrono::seconds curEpochTime,
std::chrono::seconds timeToLive) const {
assert(curEpochTime >= GetEpochTime());
return (curEpochTime - GetEpochTime()) > timeToLive;
}
// Returns true if the access status is on.
bool IsAccessed() const
{
return !!(GetAccessByte() & s_accessSetMask);
}
bool IsAccessed() const { return !!(GetAccessByte() & s_accessSetMask); }
// If "set" is true, turn on the access bit in the given metadata and store it.
// If "set" is false, turn off the access bit.
// Returns true if the given metadata's access bit was originally on.
bool UpdateAccessStatus(bool set)
{
// If "set" is true, turn on the access bit in the given metadata and store
// it. If "set" is false, turn off the access bit. Returns true if the given
// metadata's access bit was originally on.
bool UpdateAccessStatus(bool set) {
const auto isAccessBitOn = IsAccessed();
// Set the bit only if the bit is not set, and vice versa.
if (set != isAccessBitOn)
{
if (set)
{
if (set != isAccessBitOn) {
if (set) {
GetAccessByte() |= s_accessSetMask;
}
else
{
} else {
GetAccessByte() &= s_accessUnsetMask;
}
}
@ -83,13 +64,11 @@ public:
static constexpr std::uint16_t c_metaDataSize = sizeof(std::uint32_t);
private:
std::uint8_t GetAccessByte() const
{
std::uint8_t GetAccessByte() const {
return reinterpret_cast<std::uint8_t*>(m_metadata)[s_accessBitByte];
}
std::uint8_t& GetAccessByte()
{
std::uint8_t& GetAccessByte() {
return reinterpret_cast<std::uint8_t*>(m_metadata)[s_accessBitByte];
}
@ -110,7 +89,6 @@ private:
std::uint32_t* m_metadata = nullptr;
};
} // namespace Cache
} // namespace HashTable
} // namespace L4

131
inc/L4/HashTable/Common/Record.h
Просмотреть файл

@ -4,88 +4,68 @@
#include "HashTable/IHashTable.h"
#include "Utils/Exception.h"
namespace L4
{
namespace HashTable
{
namespace L4 {
namespace HashTable {
// Record struct consists of key and value pair.
struct Record
{
struct Record {
using Key = IReadOnlyHashTable::Key;
using Value = IReadOnlyHashTable::Value;
Record() = default;
Record(
const Key& key,
const Value& value)
: m_key{ key }
, m_value{ value }
{}
Record(const Key& key, const Value& value) : m_key{key}, m_value{value} {}
Key m_key;
Value m_value;
};
// RecordBuffer is a thin wrapper struct around a raw buffer array (pointer).
struct RecordBuffer
{
struct RecordBuffer {
std::uint8_t m_buffer[1];
};
static_assert(
sizeof(RecordBuffer) == 1,
static_assert(sizeof(RecordBuffer) == 1,
"RecordBuffer size should be 1 to be a thin wrapper.");
// RecordSerializer provides a functionality to serialize/deserialize a record information.
class RecordSerializer
{
// RecordSerializer provides a functionality to serialize/deserialize a record
// information.
class RecordSerializer {
public:
using Key = Record::Key;
using Value = Record::Value;
using KeySize = Key::size_type;
using ValueSize = Value::size_type;
RecordSerializer(
KeySize fixedKeySize,
RecordSerializer(KeySize fixedKeySize,
ValueSize fixedValueSize,
ValueSize metadataSize = 0U)
: m_fixedKeySize{ fixedKeySize }
, m_fixedValueSize{ fixedValueSize }
, m_metadataSize{ metadataSize }
{}
: m_fixedKeySize{fixedKeySize},
m_fixedValueSize{fixedValueSize},
m_metadataSize{metadataSize} {}
// Returns the number of bytes needed for serializing the given key and value.
std::size_t CalculateBufferSize(const Key& key, const Value& value) const
{
return
((m_fixedKeySize != 0)
? m_fixedKeySize
: (key.m_size + sizeof(KeySize)))
+ ((m_fixedValueSize != 0)
std::size_t CalculateBufferSize(const Key& key, const Value& value) const {
return ((m_fixedKeySize != 0) ? m_fixedKeySize
: (key.m_size + sizeof(KeySize))) +
((m_fixedValueSize != 0)
? m_fixedValueSize + m_metadataSize
: (value.m_size + sizeof(ValueSize) + m_metadataSize));
}
// Returns the number bytes used for key and value sizes.
std::size_t CalculateRecordOverhead() const
{
return
(m_fixedKeySize != 0 ? 0U : sizeof(KeySize))
+ (m_fixedValueSize != 0 ? 0U : sizeof(ValueSize));
std::size_t CalculateRecordOverhead() const {
return (m_fixedKeySize != 0 ? 0U : sizeof(KeySize)) +
(m_fixedValueSize != 0 ? 0U : sizeof(ValueSize));
}
// Serializes the given key and value to the given buffer.
// Note that the buffer size is at least as big as the number of bytes
// returned by CalculateBufferSize().
RecordBuffer* Serialize(
const Key& key,
RecordBuffer* Serialize(const Key& key,
const Value& value,
std::uint8_t* const buffer,
std::size_t bufferSize) const
{
std::size_t bufferSize) const {
Validate(key, value);
assert(CalculateBufferSize(key, value) <= bufferSize);
@ -95,7 +75,8 @@ public:
#if defined(_MSC_VER)
memcpy_s(buffer + start, key.m_size, key.m_data, key.m_size);
memcpy_s(buffer + start + key.m_size, value.m_size, value.m_data, value.m_size);
memcpy_s(buffer + start + key.m_size, value.m_size, value.m_data,
value.m_size);
#else
memcpy(buffer + start, key.m_data, key.m_size);
memcpy(buffer + start + key.m_size, value.m_data, value.m_size);
@ -107,57 +88,52 @@ public:
// The meta value is serialized between key and value.
// Note that the buffer size is at least as big as the number of bytes
// returned by CalculateBufferSize().
RecordBuffer* Serialize(
const Key& key,
RecordBuffer* Serialize(const Key& key,
const Value& value,
const Value& metaValue,
std::uint8_t* const buffer,
std::size_t bufferSize) const
{
std::size_t bufferSize) const {
Validate(key, value, metaValue);
assert(CalculateBufferSize(key, value) <= bufferSize);
(void)bufferSize;
const auto start = SerializeSizes(buffer, key.m_size, value.m_size + metaValue.m_size);
const auto start =
SerializeSizes(buffer, key.m_size, value.m_size + metaValue.m_size);
#if defined(_MSC_VER)
memcpy_s(buffer + start, key.m_size, key.m_data, key.m_size);
memcpy_s(buffer + start + key.m_size, metaValue.m_size, metaValue.m_data, metaValue.m_size);
memcpy_s(buffer + start + key.m_size + metaValue.m_size, value.m_size, value.m_data, value.m_size);
memcpy_s(buffer + start + key.m_size, metaValue.m_size, metaValue.m_data,
metaValue.m_size);
memcpy_s(buffer + start + key.m_size + metaValue.m_size, value.m_size,
value.m_data, value.m_size);
#else
memcpy(buffer + start, key.m_data, key.m_size);
memcpy(buffer + start + key.m_size, metaValue.m_data, metaValue.m_size);
memcpy(buffer + start + key.m_size + metaValue.m_size, value.m_data, value.m_size);
memcpy(buffer + start + key.m_size + metaValue.m_size, value.m_data,
value.m_size);
#endif
return reinterpret_cast<RecordBuffer*>(buffer);
}
// Deserializes the given buffer and returns a Record object.
Record Deserialize(const RecordBuffer& buffer) const
{
Record Deserialize(const RecordBuffer& buffer) const {
Record record;
const auto* dataBuffer = buffer.m_buffer;
auto& key = record.m_key;
if (m_fixedKeySize != 0)
{
if (m_fixedKeySize != 0) {
key.m_size = m_fixedKeySize;
}
else
{
} else {
key.m_size = *reinterpret_cast<const KeySize*>(dataBuffer);
dataBuffer += sizeof(KeySize);
}
auto& value = record.m_value;
if (m_fixedValueSize != 0)
{
if (m_fixedValueSize != 0) {
value.m_size = m_fixedValueSize + m_metadataSize;
}
else
{
} else {
value.m_size = *reinterpret_cast<const ValueSize*>(dataBuffer);
dataBuffer += sizeof(ValueSize);
}
@ -171,42 +147,36 @@ public:
private:
// Validates key and value sizes when fixed sizes are set.
// Throws an exception if invalid sizes are used.
void Validate(const Key& key, const Value& value) const
{
if ((m_fixedKeySize != 0 && key.m_size != m_fixedKeySize)
|| (m_fixedValueSize != 0 && value.m_size != m_fixedValueSize))
{
void Validate(const Key& key, const Value& value) const {
if ((m_fixedKeySize != 0 && key.m_size != m_fixedKeySize) ||
(m_fixedValueSize != 0 && value.m_size != m_fixedValueSize)) {
throw RuntimeException("Invalid key or value sizes are given.");
}
}
// Validates against the given meta value.
void Validate(const Key& key, const Value& value, const Value& metaValue) const
{
void Validate(const Key& key,
const Value& value,
const Value& metaValue) const {
Validate(key, value);
if (m_metadataSize != metaValue.m_size)
{
if (m_metadataSize != metaValue.m_size) {
throw RuntimeException("Invalid meta value size is given.");
}
}
// Serializes size information to the given buffer.
// It assumes that buffer has enough size for serialization.
std::size_t SerializeSizes(
std::uint8_t* const buffer,
std::size_t SerializeSizes(std::uint8_t* const buffer,
KeySize keySize,
ValueSize valueSize) const
{
ValueSize valueSize) const {
auto curBuffer = buffer;
if (m_fixedKeySize == 0)
{
if (m_fixedKeySize == 0) {
*reinterpret_cast<KeySize*>(curBuffer) = keySize;
curBuffer += sizeof(keySize);
}
if (m_fixedValueSize == 0)
{
if (m_fixedValueSize == 0) {
*reinterpret_cast<ValueSize*>(curBuffer) = valueSize;
curBuffer += sizeof(valueSize);
}
@ -219,6 +189,5 @@ private:
const ValueSize m_metadataSize;
};
} // namespace HashTable
} // namespace L4

20
inc/L4/HashTable/Common/SettingAdapter.h
Просмотреть файл

@ -4,23 +4,21 @@
#include "HashTable/Common/SharedHashTable.h"
#include "HashTable/Config.h"
namespace L4
{
namespace HashTable
{
namespace L4 {
namespace HashTable {
// SettingAdapter class provides a functionality to convert a HashTableConfig::Setting object
// to a SharedHashTable::Setting object.
class SettingAdapter
{
// SettingAdapter class provides a functionality to convert a
// HashTableConfig::Setting object to a SharedHashTable::Setting object.
class SettingAdapter {
public:
template <typename SharedHashTable>
typename SharedHashTable::Setting Convert(const HashTableConfig::Setting& from) const
{
typename SharedHashTable::Setting Convert(
const HashTableConfig::Setting& from) const {
typename SharedHashTable::Setting to;
to.m_numBuckets = from.m_numBuckets;
to.m_numBucketsPerMutex = (std::max)(from.m_numBucketsPerMutex.get_value_or(1U), 1U);
to.m_numBucketsPerMutex =
(std::max)(from.m_numBucketsPerMutex.get_value_or(1U), 1U);
to.m_fixedKeySize = from.m_fixedKeySize.get_value_or(0U);
to.m_fixedValueSize = from.m_fixedValueSize.get_value_or(0U);

139
inc/L4/HashTable/Common/SharedHashTable.h
Просмотреть файл

@ -10,15 +10,12 @@
#include "Utils/Exception.h"
#include "Utils/Lock.h"
namespace L4
{
namespace HashTable
{
namespace L4 {
namespace HashTable {
// SharedHashTable struct represents the hash table structure.
template <typename TData, typename TAllocator>
struct SharedHashTable
{
struct SharedHashTable {
using Data = TData;
using Allocator = TAllocator;
@ -45,65 +42,66 @@ struct SharedHashTable
// | Data16 pointer | 18
// | Entry pointer to the next Entry | 19
// <----------------------8 bytes ---------------------------------->
// , where tag1 is a tag for Data1, tag2 for Data2, and so on. A tag value can be looked up
// first before going to the corresponding Data for a quick check.
// Also note that a byte read is atomic in modern processors so that tag is just
// std::uint8_t instead of being atomic. Even in the case where the tag value read is a garbage ,
// this is acceptable because of the followings:
// 1) if the garbage value was a hit where it should have been a miss: the actual key comparison will fail,
// 2) if the garbage value was a miss where it should have been a hit: the key value must
// have been changed since the tag was changed, so it will be looked up correctly
// after the tag value written is visible correctly. Note that we don't need to guarantee the timing of
// writing and reading (meaning the value written should be visible to the reader right away).
// , where tag1 is a tag for Data1, tag2 for Data2, and so on. A tag value can
// be looked up first before going to the corresponding Data for a quick
// check. Also note that a byte read is atomic in modern processors so that
// tag is just std::uint8_t instead of being atomic. Even in the case where
// the tag value read is a garbage , this is acceptable because of the
// followings:
// 1) if the garbage value was a hit where it should have been a miss: the
// actual key comparison will fail, 2) if the garbage value was a miss
// where it should have been a hit: the key value must
// have been changed since the tag was changed, so it will be looked up
// correctly after the tag value written is visible correctly. Note that
// we don't need to guarantee the timing of writing and reading (meaning
// the value written should be visible to the reader right away).
//
// Note about the CPU cache. In previous implementation, the Entry was 64 bytes to fit in the CPU cache.
// However, this resulted in lots of wasted space. For example, when the ratio of the number of expected records
// to the number of buckets was 2:1, only 85% buckets were occupied. After experiments, if you have 10:1 ratio,
// you will have 99.98% utilization of buckets. This required having more data per Entry, and the ideal number
// (after experiments) turned out to be 16 records per Entry. Also, because of how CPU fetches contiguous memory,
// this didn't have any impact on micro-benchmarking.
struct Entry
{
// Note about the CPU cache. In previous implementation, the Entry was 64
// bytes to fit in the CPU cache. However, this resulted in lots of wasted
// space. For example, when the ratio of the number of expected records to the
// number of buckets was 2:1, only 85% buckets were occupied. After
// experiments, if you have 10:1 ratio, you will have 99.98% utilization of
// buckets. This required having more data per Entry, and the ideal number
// (after experiments) turned out to be 16 records per Entry. Also, because of
// how CPU fetches contiguous memory, this didn't have any impact on
// micro-benchmarking.
struct Entry {
Entry() = default;
// Releases deallocates all the memories of the chained entries including
// the data list in the current Entry.
void Release(Allocator allocator)
{
auto dataDeleter = [allocator](auto& data)
{
void Release(Allocator allocator) {
auto dataDeleter = [allocator](auto& data) {
auto dataToDelete = data.Load();
if (dataToDelete != nullptr)
{
if (dataToDelete != nullptr) {
dataToDelete->~Data();
typename Allocator::template rebind<Data>::other(allocator).deallocate(dataToDelete, 1U);
typename Allocator::template rebind<Data>::other(allocator)
.deallocate(dataToDelete, 1U);
}
};
// Delete all the chained entries, not including itself.
auto curEntry = m_next.Load();
while (curEntry != nullptr)
{
while (curEntry != nullptr) {
auto entryToDelete = curEntry;
// Copy m_next for the next iteration.
curEntry = entryToDelete->m_next.Load();
// Delete all the data within this entry.
for (auto& data : entryToDelete->m_dataList)
{
for (auto& data : entryToDelete->m_dataList) {
dataDeleter(data);
}
// Clean the current entry itself.
entryToDelete->~Entry();
typename Allocator::template rebind<Entry>::other(allocator).deallocate(entryToDelete, 1U);
typename Allocator::template rebind<Entry>::other(allocator).deallocate(
entryToDelete, 1U);
}
// Delete all the data from the head of chained entries.
for (auto& data : m_dataList)
{
for (auto& data : m_dataList) {
dataDeleter(data);
}
}
@ -119,23 +117,20 @@ struct SharedHashTable
static_assert(sizeof(Entry) == 152, "Entry should be 152 bytes.");
struct Setting
{
struct Setting {
using KeySize = IReadOnlyHashTable::Key::size_type;
using ValueSize = IReadOnlyHashTable::Value::size_type;
Setting() = default;
explicit Setting(
std::uint32_t numBuckets,
explicit Setting(std::uint32_t numBuckets,
std::uint32_t numBucketsPerMutex = 1U,
KeySize fixedKeySize = 0U,
ValueSize fixedValueSize = 0U)
: m_numBuckets{ numBuckets }
, m_numBucketsPerMutex{ numBucketsPerMutex }
, m_fixedKeySize{ fixedKeySize }
, m_fixedValueSize{ fixedValueSize }
{}
: m_numBuckets{numBuckets},
m_numBucketsPerMutex{numBucketsPerMutex},
m_fixedKeySize{fixedKeySize},
m_fixedValueSize{fixedValueSize} {}
std::uint32_t m_numBuckets = 1U;
std::uint32_t m_numBucketsPerMutex = 1U;
@ -143,29 +138,27 @@ struct SharedHashTable
ValueSize m_fixedValueSize = 0U;
};
SharedHashTable(
const Setting& setting,
Allocator allocator)
: m_allocator{ allocator }
, m_setting{ setting }
, m_buckets{ setting.m_numBuckets, typename Allocator::template rebind<Entry>::other(m_allocator) }
, m_mutexes{
(std::max)(setting.m_numBuckets / (std::max)(setting.m_numBucketsPerMutex, 1U), 1U),
typename Allocator::template rebind<Mutex>::other(m_allocator) }
, m_perfData{}
{
SharedHashTable(const Setting& setting, Allocator allocator)
: m_allocator{allocator},
m_setting{setting},
m_buckets{
setting.m_numBuckets,
typename Allocator::template rebind<Entry>::other(m_allocator)},
m_mutexes{
(std::max)(setting.m_numBuckets /
(std::max)(setting.m_numBucketsPerMutex, 1U),
1U),
typename Allocator::template rebind<Mutex>::other(m_allocator)},
m_perfData{} {
m_perfData.Set(HashTablePerfCounter::BucketsCount, m_buckets.size());
m_perfData.Set(
HashTablePerfCounter::TotalIndexSize,
(m_buckets.size() * sizeof(Entry))
+ (m_mutexes.size() * sizeof(Mutex))
+ sizeof(SharedHashTable));
m_perfData.Set(HashTablePerfCounter::TotalIndexSize,
(m_buckets.size() * sizeof(Entry)) +
(m_mutexes.size() * sizeof(Mutex)) +
sizeof(SharedHashTable));
}
~SharedHashTable()
{
for (auto& bucket : m_buckets)
{
~SharedHashTable() {
for (auto& bucket : m_buckets) {
bucket.Release(m_allocator);
}
}
@ -174,17 +167,17 @@ struct SharedHashTable
using Lock = std::lock_guard<Mutex>;
using UniqueLock = std::unique_lock<Mutex>;
using Buckets = Interprocess::Container::Vector<Entry, typename Allocator::template rebind<Entry>::other>;
using Mutexes = Interprocess::Container::Vector<Mutex, typename Allocator::template rebind<Mutex>::other>;
using Buckets = Interprocess::Container::
Vector<Entry, typename Allocator::template rebind<Entry>::other>;
using Mutexes = Interprocess::Container::
Vector<Mutex, typename Allocator::template rebind<Mutex>::other>;
template <typename T>
auto GetAllocator() const
{
auto GetAllocator() const {
return typename Allocator::template rebind<T>::other(m_allocator);
}
Mutex& GetMutex(std::size_t index)
{
Mutex& GetMutex(std::size_t index) {
return m_mutexes[index % m_mutexes.size()];
}

62
inc/L4/HashTable/Config.h
Просмотреть файл

@ -2,33 +2,28 @@
#include <boost/optional.hpp>
#include <cassert>
#include <cstdint>
#include <chrono>
#include <cstdint>
#include <memory>
#include "HashTable/IHashTable.h"
#include "Utils/Properties.h"
namespace L4
{
namespace L4 {
// HashTableConfig struct.
struct HashTableConfig
{
struct Setting
{
struct HashTableConfig {
struct Setting {
using KeySize = IReadOnlyHashTable::Key::size_type;
using ValueSize = IReadOnlyHashTable::Value::size_type;
explicit Setting(
std::uint32_t numBuckets,
explicit Setting(std::uint32_t numBuckets,
boost::optional<std::uint32_t> numBucketsPerMutex = {},
boost::optional<KeySize> fixedKeySize = {},
boost::optional<ValueSize> fixedValueSize = {})
: m_numBuckets{ numBuckets }
, m_numBucketsPerMutex{ numBucketsPerMutex }
, m_fixedKeySize{ fixedKeySize }
, m_fixedValueSize{ fixedValueSize }
{}
: m_numBuckets{numBuckets},
m_numBucketsPerMutex{numBucketsPerMutex},
m_fixedKeySize{fixedKeySize},
m_fixedValueSize{fixedValueSize} {}
std::uint32_t m_numBuckets;
boost::optional<std::uint32_t> m_numBucketsPerMutex;
@ -36,49 +31,40 @@ struct HashTableConfig
boost::optional<ValueSize> m_fixedValueSize;
};
struct Cache
{
Cache(
std::uint64_t maxCacheSizeInBytes,
struct Cache {
Cache(std::uint64_t maxCacheSizeInBytes,
std::chrono::seconds recordTimeToLive,
bool forceTimeBasedEviction)
: m_maxCacheSizeInBytes{ maxCacheSizeInBytes }
, m_recordTimeToLive{ recordTimeToLive }
, m_forceTimeBasedEviction{ forceTimeBasedEviction }
{}
: m_maxCacheSizeInBytes{maxCacheSizeInBytes},
m_recordTimeToLive{recordTimeToLive},
m_forceTimeBasedEviction{forceTimeBasedEviction} {}
std::uint64_t m_maxCacheSizeInBytes;
std::chrono::seconds m_recordTimeToLive;
bool m_forceTimeBasedEviction;
};
struct Serializer
{
struct Serializer {
using Properties = Utils::Properties;
Serializer(
std::shared_ptr<std::istream> stream = {},
Serializer(std::shared_ptr<std::istream> stream = {},
boost::optional<Properties> properties = {})
: m_stream{ stream }
, m_properties{ properties }
{}
: m_stream{stream}, m_properties{properties} {}
std::shared_ptr<std::istream> m_stream;
boost::optional<Properties> m_properties;
};
HashTableConfig(
std::string name,
HashTableConfig(std::string name,
Setting setting,
boost::optional<Cache> cache = {},
boost::optional<Serializer> serializer = {})
: m_name{ std::move(name) }
, m_setting{ std::move(setting) }
, m_cache{ cache }
, m_serializer{ serializer }
{
assert(m_setting.m_numBuckets > 0U
|| (m_serializer && (serializer->m_stream != nullptr)));
: m_name{std::move(name)},
m_setting{std::move(setting)},
m_cache{cache},
m_serializer{serializer} {
assert(m_setting.m_numBuckets > 0U ||
(m_serializer && (serializer->m_stream != nullptr)));
}
std::string m_name;

39
inc/L4/HashTable/IHashTable.h
Просмотреть файл

@ -5,35 +5,26 @@
#include "Log/PerfCounter.h"
#include "Utils/Properties.h"
namespace L4
{
namespace L4 {
// IReadOnlyHashTable interface for read-only access to the hash table.
struct IReadOnlyHashTable
{
struct IReadOnlyHashTable {
// Blob struct that represents a memory blob.
template <typename TSize>
struct Blob
{
struct Blob {
using size_type = TSize;
explicit Blob(const std::uint8_t* data = nullptr, size_type size = 0U)
: m_data{ data }
, m_size{ size }
{
static_assert(std::numeric_limits<size_type>::is_integer, "size_type is not an integer.");
: m_data{data}, m_size{size} {
static_assert(std::numeric_limits<size_type>::is_integer,
"size_type is not an integer.");
}
bool operator==(const Blob& other) const
{
return (m_size == other.m_size)
&& !memcmp(m_data, other.m_data, m_size);
bool operator==(const Blob& other) const {
return (m_size == other.m_size) && !memcmp(m_data, other.m_data, m_size);
}
bool operator!=(const Blob& other) const
{
return !(*this == other);
}
bool operator!=(const Blob& other) const { return !(*this == other); }
const std::uint8_t* m_data;
size_type m_size;
@ -56,8 +47,7 @@ struct IReadOnlyHashTable
};
// IReadOnlyHashTable::IIterator interface for the hash table iterator.
struct IReadOnlyHashTable::IIterator
{
struct IReadOnlyHashTable::IIterator {
virtual ~IIterator() = default;
virtual void Reset() = 0;
@ -70,8 +60,7 @@ struct IReadOnlyHashTable::IIterator
};
// IWritableHashTable interface for write access to the hash table.
struct IWritableHashTable : public virtual IReadOnlyHashTable
{
struct IWritableHashTable : public virtual IReadOnlyHashTable {
struct ISerializer;
using ISerializerPtr = std::unique_ptr<ISerializer>;
@ -84,12 +73,10 @@ struct IWritableHashTable : public virtual IReadOnlyHashTable
};
// IWritableHashTable::ISerializer interface for serializing hash table.
struct IWritableHashTable::ISerializer
{
struct IWritableHashTable::ISerializer {
virtual ~ISerializer() = default;
virtual void Serialize(
std::ostream& stream,
virtual void Serialize(std::ostream& stream,
const Utils::Properties& properties) = 0;
};

406
inc/L4/HashTable/ReadWrite/HashTable.h
Просмотреть файл

@ -3,31 +3,28 @@
#include <boost/optional.hpp>
#include <cstdint>
#include <mutex>
#include "detail/ToRawPointer.h"
#include "Epoch/IEpochActionManager.h"
#include "HashTable/Common/SharedHashTable.h"
#include "HashTable/Common/Record.h"
#include "HashTable/Common/SharedHashTable.h"
#include "HashTable/IHashTable.h"
#include "HashTable/ReadWrite/Serializer.h"
#include "Log/PerfCounter.h"
#include "Utils/Exception.h"
#include "Utils/MurmurHash3.h"
#include "Utils/Properties.h"
#include "detail/ToRawPointer.h"
namespace L4
{
namespace L4 {
// ReadWriteHashTable is a general purpose hash table where the look up is look free.
namespace HashTable
{
namespace ReadWrite
{
// ReadWriteHashTable is a general purpose hash table where the look up is look
// free.
namespace HashTable {
namespace ReadWrite {
// ReadOnlyHashTable class implements IReadOnlyHashTable interface and provides
// the functionality to read data given a key.
template <typename Allocator>
class ReadOnlyHashTable : public virtual IReadOnlyHashTable
{
class ReadOnlyHashTable : public virtual IReadOnlyHashTable {
public:
using HashTable = SharedHashTable<RecordBuffer, Allocator>;
@ -36,36 +33,30 @@ public:
explicit ReadOnlyHashTable(
HashTable& hashTable,
boost::optional<RecordSerializer> recordSerializer = boost::none)
: m_hashTable{ hashTable }
, m_recordSerializer{
: m_hashTable{hashTable},
m_recordSerializer{
recordSerializer
? *recordSerializer
: RecordSerializer{
m_hashTable.m_setting.m_fixedKeySize,
m_hashTable.m_setting.m_fixedValueSize } }
{}
: RecordSerializer{m_hashTable.m_setting.m_fixedKeySize,
m_hashTable.m_setting.m_fixedValueSize}} {}
virtual bool Get(const Key& key, Value& value) const override
{
virtual bool Get(const Key& key, Value& value) const override {
const auto bucketInfo = GetBucketInfo(key);
const auto* entry = &m_hashTable.m_buckets[bucketInfo.first];
while (entry != nullptr)
{
for (std::uint8_t i = 0; i < HashTable::Entry::c_numDataPerEntry; ++i)
{
if (bucketInfo.second == entry->m_tags[i])
{
// There could be a race condition where m_dataList[i] is updated during access.
// Therefore, load it once and save it (it's safe to store it b/c the memory
// will not be deleted until ref count becomes 0).
const auto data = entry->m_dataList[i].Load(std::memory_order_acquire);
while (entry != nullptr) {
for (std::uint8_t i = 0; i < HashTable::Entry::c_numDataPerEntry; ++i) {
if (bucketInfo.second == entry->m_tags[i]) {
// There could be a race condition where m_dataList[i] is updated
// during access. Therefore, load it once and save it (it's safe to
// store it b/c the memory will not be deleted until ref count becomes
// 0).
const auto data =
entry->m_dataList[i].Load(std::memory_order_acquire);
if (data != nullptr)
{
if (data != nullptr) {
const auto record = m_recordSerializer.Deserialize(*data);
if (record.m_key == key)
{
if (record.m_key == key) {
value = record.m_value;
return true;
}
@ -79,15 +70,14 @@ public:
return false;
}
virtual IIteratorPtr GetIterator() const override
{
virtual IIteratorPtr GetIterator() const override {
return std::make_unique<Iterator>(m_hashTable, m_recordSerializer);
}
virtual const HashTablePerfData& GetPerfData() const override
{
virtual const HashTablePerfData& GetPerfData() const override {
// Synchronizes with any std::memory_order_release if there exists, so that
// HashTablePerfData has the latest values at the moment when GetPerfData() is called.
// HashTablePerfData has the latest values at the moment when GetPerfData()
// is called.
std::atomic_thread_fence(std::memory_order_acquire);
return m_hashTable.m_perfData;
}
@ -98,18 +88,17 @@ public:
protected:
// GetBucketInfo returns a pair, where the first is the index to the bucket
// and the second is the tag value for the given key.
// In this hash table, we treat tag value of 0 as empty (see WritableHashTable::Remove()),
// so in the worst case scenario, where an entry has an empty data list and the tag
// value returned for the key is 0, the look up cost is up to 6 checks. We can do something
// smarter by using the unused two bytes per Entry, but since an Entry object fits into
// CPU cache, the extra overhead should be minimal.
std::pair<std::uint32_t, std::uint8_t> GetBucketInfo(const Key& key) const
{
// In this hash table, we treat tag value of 0 as empty (see
// WritableHashTable::Remove()), so in the worst case scenario, where an entry
// has an empty data list and the tag value returned for the key is 0, the
// look up cost is up to 6 checks. We can do something smarter by using the
// unused two bytes per Entry, but since an Entry object fits into CPU cache,
// the extra overhead should be minimal.
std::pair<std::uint32_t, std::uint8_t> GetBucketInfo(const Key& key) const {
std::array<std::uint64_t, 2> hash;
MurmurHash3_x64_128(key.m_data, key.m_size, 0U, hash.data());
return {
static_cast<std::uint32_t>(hash[0] % m_hashTable.m_buckets.size()),
return {static_cast<std::uint32_t>(hash[0] % m_hashTable.m_buckets.size()),
static_cast<std::uint8_t>(hash[1])};
}
@ -118,69 +107,57 @@ protected:
RecordSerializer m_recordSerializer;
};
// ReadOnlyHashTable::Iterator class implements IIterator interface and provides
// read-only iterator for the ReadOnlyHashTable.
template <typename Allocator>
class ReadOnlyHashTable<Allocator>::Iterator : public IIterator
{
class ReadOnlyHashTable<Allocator>::Iterator : public IIterator {
public:
Iterator(
const HashTable& hashTable,
Iterator(const HashTable& hashTable,
const RecordSerializer& recordDeserializer)
: m_hashTable{ hashTable }
, m_recordSerializer{ recordDeserializer }
, m_currentBucketIndex{ -1 }
, m_currentRecordIndex{ 0U }
, m_currentEntry{ nullptr }
{}
: m_hashTable{hashTable},
m_recordSerializer{recordDeserializer},
m_currentBucketIndex{-1},
m_currentRecordIndex{0U},
m_currentEntry{nullptr} {}
Iterator(Iterator&& iterator)
: m_hashTable{ std::move(iterator.m_hashTable) }
, m_recordSerializer{ std::move(iterator.recordDeserializer) }
, m_currentBucketIndex{ std::move(iterator.m_currentBucketIndex) }
, m_currentRecordIndex{ std::move(iterator.m_currentRecordIndex) }
, m_currentEntry{ std::move(iterator.m_currentEntry) }
{}
: m_hashTable{std::move(iterator.m_hashTable)},
m_recordSerializer{std::move(iterator.recordDeserializer)},
m_currentBucketIndex{std::move(iterator.m_currentBucketIndex)},
m_currentRecordIndex{std::move(iterator.m_currentRecordIndex)},
m_currentEntry{std::move(iterator.m_currentEntry)} {}
void Reset() override
{
void Reset() override {
m_currentBucketIndex = -1;
m_currentRecordIndex = 0U;
m_currentEntry = nullptr;
}
bool MoveNext() override
{
if (IsEnd())
{
bool MoveNext() override {
if (IsEnd()) {
return false;
}
if (m_currentEntry != nullptr)
{
if (m_currentEntry != nullptr) {
MoveToNextData();
}
assert(m_currentRecordIndex < HashTable::Entry::c_numDataPerEntry);
while ((m_currentEntry == nullptr)
|| (m_currentRecord = m_currentEntry->m_dataList[m_currentRecordIndex].Load()) == nullptr)
{
if (m_currentEntry == nullptr)
{
while ((m_currentEntry == nullptr) ||
(m_currentRecord =
m_currentEntry->m_dataList[m_currentRecordIndex].Load()) ==
nullptr) {
if (m_currentEntry == nullptr) {
++m_currentBucketIndex;
m_currentRecordIndex = 0U;
if (IsEnd())
{
if (IsEnd()) {
return false;
}
m_currentEntry = &m_hashTable.m_buckets[m_currentBucketIndex];
}
else
{
} else {
MoveToNextData();
}
}
@ -191,20 +168,16 @@ public:
return true;
}
Key GetKey() const override
{
if (!IsValid())
{
Key GetKey() const override {
if (!IsValid()) {
throw RuntimeException("HashTableIterator is not correctly used.");
}
return m_recordSerializer.Deserialize(*m_currentRecord).m_key;
}
Value GetValue() const override
{
if (!IsValid())
{
Value GetValue() const override {
if (!IsValid()) {
throw RuntimeException("HashTableIterator is not correctly used.");
}
@ -215,22 +188,18 @@ public:
Iterator& operator=(const Iterator&) = delete;
private:
bool IsValid() const
{
return !IsEnd()
&& (m_currentEntry != nullptr)
&& (m_currentRecord != nullptr);
bool IsValid() const {
return !IsEnd() && (m_currentEntry != nullptr) &&
(m_currentRecord != nullptr);
}
bool IsEnd() const
{
return m_currentBucketIndex == static_cast<std::int64_t>(m_hashTable.m_buckets.size());
bool IsEnd() const {
return m_currentBucketIndex ==
static_cast<std::int64_t>(m_hashTable.m_buckets.size());
}
void MoveToNextData()
{
if (++m_currentRecordIndex >= HashTable::Entry::c_numDataPerEntry)
{
void MoveToNextData() {
if (++m_currentRecordIndex >= HashTable::Entry::c_numDataPerEntry) {
m_currentRecordIndex = 0U;
m_currentEntry = m_currentEntry->m_next.Load();
}
@ -246,60 +215,48 @@ private:
const RecordBuffer* m_currentRecord;
};
// The following warning is from the virtual inheritance and safe to disable in this case.
// https://msdn.microsoft.com/en-us/library/6b3sy7ae.aspx
// The following warning is from the virtual inheritance and safe to disable in
// this case. https://msdn.microsoft.com/en-us/library/6b3sy7ae.aspx
#pragma warning(push)
#pragma warning(disable : 4250)
// WritableHashTable class implements IWritableHashTable interface and also provides
// the read only access (Get()) to the hash table.
// Note the virtual inheritance on ReadOnlyHashTable<Allocator> so that any derived class
// can have only one ReadOnlyHashTable base class instance.
// WritableHashTable class implements IWritableHashTable interface and also
// provides the read only access (Get()) to the hash table. Note the virtual
// inheritance on ReadOnlyHashTable<Allocator> so that any derived class can
// have only one ReadOnlyHashTable base class instance.
template <typename Allocator>
class WritableHashTable
: public virtual ReadOnlyHashTable<Allocator>
, public IWritableHashTable
{
class WritableHashTable : public virtual ReadOnlyHashTable<Allocator>,
public IWritableHashTable {
public:
using Base = ReadOnlyHashTable<Allocator>;
using HashTable = typename Base::HashTable;
WritableHashTable(
HashTable& hashTable,
IEpochActionManager& epochManager)
: Base(hashTable)
, m_epochManager{ epochManager }
{}
WritableHashTable(HashTable& hashTable, IEpochActionManager& epochManager)
: Base(hashTable), m_epochManager{epochManager} {}
virtual void Add(const Key& key, const Value& value) override
{
virtual void Add(const Key& key, const Value& value) override {
Add(CreateRecordBuffer(key, value));
}
virtual bool Remove(const Key& key) override
{
virtual bool Remove(const Key& key) override {
const auto bucketInfo = this->GetBucketInfo(key);
auto* entry = &(this->m_hashTable.m_buckets[bucketInfo.first]);
typename HashTable::Lock lock{this->m_hashTable.GetMutex(bucketInfo.first)};
// Note that similar to Add(), the following block is performed inside a critical section,
// therefore, it is safe to do "Load"s with memory_order_relaxed.
while (entry != nullptr)
{
for (std::uint8_t i = 0; i < HashTable::Entry::c_numDataPerEntry; ++i)
{
if (bucketInfo.second == entry->m_tags[i])
{
const auto data = entry->m_dataList[i].Load(std::memory_order_relaxed);
// Note that similar to Add(), the following block is performed inside a
// critical section, therefore, it is safe to do "Load"s with
// memory_order_relaxed.
while (entry != nullptr) {
for (std::uint8_t i = 0; i < HashTable::Entry::c_numDataPerEntry; ++i) {
if (bucketInfo.second == entry->m_tags[i]) {
const auto data =
entry->m_dataList[i].Load(std::memory_order_relaxed);
if (data != nullptr)
{
if (data != nullptr) {
const auto record = this->m_recordSerializer.Deserialize(*data);
if (record.m_key == key)
{
if (record.m_key == key) {
Remove(*entry, i);
return true;
}
@ -313,14 +270,12 @@ public:
return false;
}
virtual ISerializerPtr GetSerializer() const override
{
virtual ISerializerPtr GetSerializer() const override {
return std::make_unique<WritableHashTable::Serializer>(this->m_hashTable);
}
protected:
void Add(RecordBuffer* recordToAdd)
{
void Add(RecordBuffer* recordToAdd) {
assert(recordToAdd != nullptr);
const auto newRecord = this->m_recordSerializer.Deserialize(*recordToAdd);
@ -336,33 +291,28 @@ protected:
typename HashTable::Entry* entryToUpdate = nullptr;
std::uint8_t curDataIndex = 0U;
typename HashTable::UniqueLock lock{ this->m_hashTable.GetMutex(bucketInfo.first) };
typename HashTable::UniqueLock lock{
this->m_hashTable.GetMutex(bucketInfo.first)};
// Note that the following block is performed inside a critical section, therefore,
// it is safe to do "Load"s with memory_order_relaxed.
while (curEntry != nullptr)
{
// Note that the following block is performed inside a critical section,
// therefore, it is safe to do "Load"s with memory_order_relaxed.
while (curEntry != nullptr) {
++stat.m_chainIndex;
for (std::uint8_t i = 0; i < HashTable::Entry::c_numDataPerEntry; ++i)
{
const auto data = curEntry->m_dataList[i].Load(std::memory_order_relaxed);
for (std::uint8_t i = 0; i < HashTable::Entry::c_numDataPerEntry; ++i) {
const auto data =
curEntry->m_dataList[i].Load(std::memory_order_relaxed);
if (data == nullptr)
{
if (entryToUpdate == nullptr)
{
// Found an entry with no data set, but still need to go through the end of
// the list to see if an entry with the given key exists.
if (data == nullptr) {
if (entryToUpdate == nullptr) {
// Found an entry with no data set, but still need to go through the
// end of the list to see if an entry with the given key exists.
entryToUpdate = curEntry;
curDataIndex = i;
}
}
else if (curEntry->m_tags[i] == bucketInfo.second)
{
} else if (curEntry->m_tags[i] == bucketInfo.second) {
const auto oldRecord = this->m_recordSerializer.Deserialize(*data);
if (newKey == oldRecord.m_key)
{
if (newKey == oldRecord.m_key) {
// Will overwrite this entry data.
entryToUpdate = curEntry;
curDataIndex = i;
@ -373,19 +323,19 @@ protected:
}
// Found the entry data to replaces.
if (stat.m_oldValueSize != 0U)
{
if (stat.m_oldValueSize != 0U) {
break;
}
// Check if this is the end of the chaining. If so, create a new entry if we haven't found
// any entry to update along the way.
if (entryToUpdate == nullptr && curEntry->m_next.Load(std::memory_order_relaxed) == nullptr)
{
// Check if this is the end of the chaining. If so, create a new entry if
// we haven't found any entry to update along the way.
if (entryToUpdate == nullptr &&
curEntry->m_next.Load(std::memory_order_relaxed) == nullptr) {
curEntry->m_next.Store(
new (Detail::to_raw_pointer(
this->m_hashTable.template GetAllocator<typename HashTable::Entry>().allocate(1U)))
typename HashTable::Entry(),
this->m_hashTable
.template GetAllocator<typename HashTable::Entry>()
.allocate(1U))) typename HashTable::Entry(),
std::memory_order_release);
stat.m_isNewEntryAdded = true;
@ -396,7 +346,8 @@ protected:
assert(entryToUpdate != nullptr);
auto recordToDelete = UpdateRecord(*entryToUpdate, curDataIndex, recordToAdd, bucketInfo.second);
auto recordToDelete = UpdateRecord(*entryToUpdate, curDataIndex,
recordToAdd, bucketInfo.second);
lock.unlock();
@ -405,10 +356,9 @@ protected:
ReleaseRecord(recordToDelete);
}
// The chainIndex is the 1-based index for the given entry in the chained bucket list.
// It is assumed that this function is called under a lock.
void Remove(typename HashTable::Entry& entry, std::uint8_t index)
{
// The chainIndex is the 1-based index for the given entry in the chained
// bucket list. It is assumed that this function is called under a lock.
void Remove(typename HashTable::Entry& entry, std::uint8_t index) {
auto recordToDelete = UpdateRecord(entry, index, nullptr, 0U);
assert(recordToDelete != nullptr);
@ -416,11 +366,7 @@ protected:
const auto record = this->m_recordSerializer.Deserialize(*recordToDelete);
UpdatePerfDataForRemove(
Stat{
record.m_key.m_size,
record.m_value.m_size,
0U
});
Stat{record.m_key.m_size, record.m_value.m_size, 0U});
ReleaseRecord(recordToDelete);
}
@ -430,22 +376,22 @@ private:
class Serializer;
RecordBuffer* CreateRecordBuffer(const Key& key, const Value& value)
{
const auto bufferSize = this->m_recordSerializer.CalculateBufferSize(key, value);
RecordBuffer* CreateRecordBuffer(const Key& key, const Value& value) {
const auto bufferSize =
this->m_recordSerializer.CalculateBufferSize(key, value);
auto buffer = Detail::to_raw_pointer(
this->m_hashTable.template GetAllocator<std::uint8_t>().allocate(bufferSize));
this->m_hashTable.template GetAllocator<std::uint8_t>().allocate(
bufferSize));
return this->m_recordSerializer.Serialize(key, value, buffer, bufferSize);
}
RecordBuffer* UpdateRecord(
typename HashTable::Entry& entry,
RecordBuffer* UpdateRecord(typename HashTable::Entry& entry,
std::uint8_t index,
RecordBuffer* newRecord,
std::uint8_t newTag)
{
// This function should be called under a lock, so calling with memory_order_relaxed for Load() is safe.
std::uint8_t newTag) {
// This function should be called under a lock, so calling with
// memory_order_relaxed for Load() is safe.
auto& recordHolder = entry.m_dataList[index];
auto oldRecord = recordHolder.Load(std::memory_order_relaxed);
@ -455,54 +401,49 @@ private:
return oldRecord;
}
void ReleaseRecord(RecordBuffer* record)
{
if (record == nullptr)
{
void ReleaseRecord(RecordBuffer* record) {
if (record == nullptr) {
return;
}
m_epochManager.RegisterAction(
[this, record]()
{
m_epochManager.RegisterAction([this, record]() {
record->~RecordBuffer();
this->m_hashTable.template GetAllocator<RecordBuffer>().deallocate(record, 1U);
this->m_hashTable.template GetAllocator<RecordBuffer>().deallocate(record,
1U);
});
}
void UpdatePerfDataForAdd(const Stat& stat)
{
void UpdatePerfDataForAdd(const Stat& stat) {
auto& perfData = this->m_hashTable.m_perfData;
if (stat.m_oldValueSize != 0U)
{
if (stat.m_oldValueSize != 0U) {
// Updating the existing record. Therefore, no change in the key size.
perfData.Add(HashTablePerfCounter::TotalValueSize,
static_cast<HashTablePerfData::TValue>(stat.m_valueSize) - stat.m_oldValueSize);
}
else
{
static_cast<HashTablePerfData::TValue>(stat.m_valueSize) -
stat.m_oldValueSize);
} else {
// We are adding a new data instead of replacing.
perfData.Add(HashTablePerfCounter::TotalKeySize, stat.m_keySize);
perfData.Add(HashTablePerfCounter::TotalValueSize, stat.m_valueSize);
perfData.Add(HashTablePerfCounter::TotalIndexSize,
perfData.Add(
HashTablePerfCounter::TotalIndexSize,
// Record overhead.
this->m_recordSerializer.CalculateRecordOverhead()
// Entry overhead if created.
+ (stat.m_isNewEntryAdded ? sizeof(typename HashTable::Entry) : 0U));
+ (stat.m_isNewEntryAdded ? sizeof(typename HashTable::Entry)
: 0U));
perfData.Min(HashTablePerfCounter::MinKeySize, stat.m_keySize);
perfData.Max(HashTablePerfCounter::MaxKeySize, stat.m_keySize);
perfData.Increment(HashTablePerfCounter::RecordsCount);
if (stat.m_isNewEntryAdded)
{
if (stat.m_isNewEntryAdded) {
perfData.Increment(HashTablePerfCounter::ChainingEntriesCount);
if (stat.m_chainIndex > 1U)
{
perfData.Max(HashTablePerfCounter::MaxBucketChainLength, stat.m_chainIndex);
if (stat.m_chainIndex > 1U) {
perfData.Max(HashTablePerfCounter::MaxBucketChainLength,
stat.m_chainIndex);
}
}
}
@ -511,14 +452,14 @@ private:
perfData.Max(HashTablePerfCounter::MaxValueSize, stat.m_valueSize);
}
void UpdatePerfDataForRemove(const Stat& stat)
{
void UpdatePerfDataForRemove(const Stat& stat) {
auto& perfData = this->m_hashTable.m_perfData;
perfData.Decrement(HashTablePerfCounter::RecordsCount);
perfData.Subtract(HashTablePerfCounter::TotalKeySize, stat.m_keySize);
perfData.Subtract(HashTablePerfCounter::TotalValueSize, stat.m_valueSize);
perfData.Subtract(HashTablePerfCounter::TotalIndexSize, this->m_recordSerializer.CalculateRecordOverhead());
perfData.Subtract(HashTablePerfCounter::TotalIndexSize,
this->m_recordSerializer.CalculateRecordOverhead());
}
IEpochActionManager& m_epochManager;
@ -526,26 +467,22 @@ private:
#pragma warning(pop)
// WritableHashTable::Stat struct encapsulates stats for Add()/Remove().
template <typename Allocator>
struct WritableHashTable<Allocator>::Stat
{
struct WritableHashTable<Allocator>::Stat {
using KeySize = Key::size_type;
using ValueSize = Value::size_type;
explicit Stat(
KeySize keySize = 0U,
explicit Stat(KeySize keySize = 0U,
ValueSize valueSize = 0U,
ValueSize oldValueSize = 0U,
std::uint32_t chainIndex = 0U,
bool isNewEntryAdded = false)
: m_keySize{ keySize }
, m_valueSize{ valueSize }
, m_oldValueSize{ oldValueSize }
, m_chainIndex{ chainIndex }
, m_isNewEntryAdded{ isNewEntryAdded }
{}
: m_keySize{keySize},
m_valueSize{valueSize},
m_oldValueSize{oldValueSize},
m_chainIndex{chainIndex},
m_isNewEntryAdded{isNewEntryAdded} {}
KeySize m_keySize;
ValueSize m_valueSize;
@ -554,26 +491,21 @@ struct WritableHashTable<Allocator>::Stat
bool m_isNewEntryAdded;
};
// WritableHashTable::Serializer class that implements ISerializer, which provides
// the functionality to serialize the WritableHashTable.
// WritableHashTable::Serializer class that implements ISerializer, which
// provides the functionality to serialize the WritableHashTable.
template <typename Allocator>
class WritableHashTable<Allocator>::Serializer : public IWritableHashTable::ISerializer
{
class WritableHashTable<Allocator>::Serializer
: public IWritableHashTable::ISerializer {
public:
explicit Serializer(HashTable& hashTable)
: m_hashTable{ hashTable }
{}
explicit Serializer(HashTable& hashTable) : m_hashTable{hashTable} {}
Serializer(const Serializer&) = delete;
Serializer& operator=(const Serializer&) = delete;
void Serialize(
std::ostream& stream,
const Utils::Properties& /* properties */) override
{
ReadWrite::Serializer<
HashTable, ReadWrite::ReadOnlyHashTable>{}.Serialize(m_hashTable, stream);
void Serialize(std::ostream& stream,
const Utils::Properties& /* properties */) override {
ReadWrite::Serializer<HashTable, ReadWrite::ReadOnlyHashTable>{}.Serialize(
m_hashTable, stream);
}
private:

132
inc/L4/HashTable/ReadWrite/Serializer.h
Просмотреть файл

@ -1,7 +1,7 @@
#pragma once
#include <cstdint>
#include <boost/format.hpp>
#include <cstdint>
#include <iosfwd>
#include "Epoch/IEpochActionManager.h"
#include "Log/PerfCounter.h"
@ -9,27 +9,21 @@
#include "Utils/Exception.h"
#include "Utils/Properties.h"
namespace L4
{
namespace HashTable
{
namespace ReadWrite
{
namespace L4 {
namespace HashTable {
namespace ReadWrite {
// Note that the HashTable template parameter in this file is
// HashTable::ReadWrite::ReadOnlyHashTable<Allocator>::HashTable.
// However, due to the cyclic dependency, it needs to be passed as a template type.
// However, due to the cyclic dependency, it needs to be passed as a template
// type.
// All the deprecated (previous versions) serializer should be put inside the
// Deprecated namespace. Removing any of the Deprecated serializers from the
// source code will require the major package version change.
namespace Deprecated {} // namespace Deprecated
// All the deprecated (previous versions) serializer should be put inside the Deprecated namespace.
// Removing any of the Deprecated serializers from the source code will require the major package version change.
namespace Deprecated
{
} // namespace Deprecated
namespace Current
{
namespace Current {
constexpr std::uint8_t c_version = 1U;
@ -40,18 +34,14 @@ constexpr std::uint8_t c_version = 1U;
// <Key size> <Key bytes> <Value size> <Value bytes>
// Otherwise, end of the records.
template <typename HashTable, template <typename> class ReadOnlyHashTable>
class Serializer
{
class Serializer {
public:
Serializer() = default;
Serializer(const Serializer&) = delete;
Serializer& operator=(const Serializer&) = delete;
void Serialize(
HashTable& hashTable,
std::ostream& stream) const
{
void Serialize(HashTable& hashTable, std::ostream& stream) const {
auto& perfData = hashTable.m_perfData;
perfData.Set(HashTablePerfCounter::RecordsCountSavedFromSerializer, 0);
@ -61,11 +51,11 @@ public:
helper.Serialize(&hashTable.m_setting, sizeof(hashTable.m_setting));
ReadOnlyHashTable<typename HashTable::Allocator> readOnlyHashTable(hashTable);
ReadOnlyHashTable<typename HashTable::Allocator> readOnlyHashTable(
hashTable);
auto iterator = readOnlyHashTable.GetIterator();
while (iterator->MoveNext())
{
while (iterator->MoveNext()) {
helper.Serialize(true); // Indicates record exists.
const auto key = iterator->GetKey();
const auto value = iterator->GetValue();
@ -81,40 +71,39 @@ public:
helper.Serialize(false); // Indicates the end of records.
// Flush perf counter so that the values are up to date when GetPerfData() is called.
// Flush perf counter so that the values are up to date when GetPerfData()
// is called.
std::atomic_thread_fence(std::memory_order_release);
}
};
// Current Deserializer used for deserializing hash tables.
template <typename Memory, typename HashTable, template <typename> class WritableHashTable>
class Deserializer
{
template <typename Memory,
typename HashTable,
template <typename>
class WritableHashTable>
class Deserializer {
public:
explicit Deserializer(const Utils::Properties& /* properties */)
{}
explicit Deserializer(const Utils::Properties& /* properties */) {}
Deserializer(const Deserializer&) = delete;
Deserializer& operator=(const Deserializer&) = delete;
typename Memory::template UniquePtr<HashTable> Deserialize(
Memory& memory,
std::istream& stream) const
{
std::istream& stream) const {
DeserializerHelper helper(stream);
typename HashTable::Setting setting;
helper.Deserialize(setting);
auto hashTable{ memory.template MakeUnique<HashTable>(
setting,
memory.GetAllocator()) };
auto hashTable{
memory.template MakeUnique<HashTable>(setting, memory.GetAllocator())};
EpochActionManager epochActionManager;
WritableHashTable<typename HashTable::Allocator> writableHashTable(
*hashTable,
epochActionManager);
*hashTable, epochActionManager);
auto& perfData = hashTable->m_perfData;
@ -124,8 +113,7 @@ public:
bool hasMoreData = false;
helper.Deserialize(hasMoreData);
while (hasMoreData)
{
while (hasMoreData) {
IReadOnlyHashTable::Key key;
IReadOnlyHashTable::Value value;
@ -143,74 +131,77 @@ public:
helper.Deserialize(hasMoreData);
perfData.Increment(HashTablePerfCounter::RecordsCountLoadedFromSerializer);
perfData.Increment(
HashTablePerfCounter::RecordsCountLoadedFromSerializer);
}
// Flush perf counter so that the values are up to date when GetPerfData() is called.
// Flush perf counter so that the values are up to date when GetPerfData()
// is called.
std::atomic_thread_fence(std::memory_order_release);
return hashTable;
}
private:
// Deserializer internally uses WritableHashTable for deserialization, therefore
// an implementation of IEpochActionManager is needed. Since all the keys in the hash table
// are expected to be unique, no RegisterAction() should be called.
class EpochActionManager : public IEpochActionManager
{
// Deserializer internally uses WritableHashTable for deserialization,
// therefore an implementation of IEpochActionManager is needed. Since all the
// keys in the hash table are expected to be unique, no RegisterAction()
// should be called.
class EpochActionManager : public IEpochActionManager {
public:
void RegisterAction(Action&& /* action */) override
{
// Since it is assumed that the serializer is loading from the stream generated by the same serializer,
// it is guaranteed that all the keys are unique (a property of a hash table). Therefore, RegisterAction()
void RegisterAction(Action&& /* action */) override {
// Since it is assumed that the serializer is loading from the stream
// generated by the same serializer, it is guaranteed that all the keys
// are unique (a property of a hash table). Therefore, RegisterAction()
// should not be called by the WritableHashTable.
throw RuntimeException("RegisterAction() should not be called from the serializer.");
throw RuntimeException(
"RegisterAction() should not be called from the serializer.");
}
};
};
} // namespace Current
// Serializer is the main driver for serializing a hash table.
// It always uses the Current::Serializer for serializing a hash table.
template <typename HashTable, template <typename> class ReadOnlyHashTable>
class Serializer
{
class Serializer {
public:
Serializer() = default;
Serializer(const Serializer&) = delete;
Serializer& operator=(const Serializer&) = delete;
void Serialize(HashTable& hashTable, std::ostream& stream) const
{
Current::Serializer<HashTable, ReadOnlyHashTable>{}.Serialize(hashTable, stream);
void Serialize(HashTable& hashTable, std::ostream& stream) const {
Current::Serializer<HashTable, ReadOnlyHashTable>{}.Serialize(hashTable,
stream);
}
};
// Deserializer is the main driver for deserializing the input stream to create a hash table.
template <typename Memory, typename HashTable, template <typename> class WritableHashTable>
class Deserializer
{
// Deserializer is the main driver for deserializing the input stream to create
// a hash table.
template <typename Memory,
typename HashTable,
template <typename>
class WritableHashTable>
class Deserializer {
public:
explicit Deserializer(const Utils::Properties& properties)
: m_properties(properties)
{}
: m_properties(properties) {}
Deserializer(const Deserializer&) = delete;
Deserializer& operator=(const Deserializer&) = delete;
typename Memory::template UniquePtr<HashTable> Deserialize(
Memory& memory,
std::istream& stream) const
{
std::istream& stream) const {
std::uint8_t version = 0U;
DeserializerHelper(stream).Deserialize(version);
switch (version)
{
switch (version) {
case Current::c_version:
return Current::Deserializer<Memory, HashTable, WritableHashTable>{ m_properties }.Deserialize(memory, stream);
return Current::Deserializer<Memory, HashTable, WritableHashTable>{
m_properties}
.Deserialize(memory, stream);
default:
boost::format err("Unsupported version '%1%' is given.");
err % version;
@ -225,4 +216,3 @@ private:
} // namespace ReadWrite
} // namespace HashTable
} // namespace L4

31
inc/L4/Interprocess/Connection/ConnectionMonitor.h
Просмотреть файл

@ -1,6 +1,7 @@
#pragma once
#include <cstdint>
#include <functional>
#include <map>
#include <memory>
#include <mutex>
@ -8,12 +9,9 @@
#include "Interprocess/Connection/EndPointInfo.h"
#include "Interprocess/Utils/Handle.h"
namespace L4
{
namespace Interprocess
{
namespace Connection
{
namespace L4 {
namespace Interprocess {
namespace Connection {
// ConnectionMonitor monitors any registered end points.
// ConnectionMonitor creates a kernel event for local end point,
@ -22,8 +20,7 @@ namespace Connection
// is closed, the callback registered is triggered and the remote endpoint
// is removed from the ConnectionMonitor after the callback is finished..
class ConnectionMonitor
: public std::enable_shared_from_this<ConnectionMonitor>
{
: public std::enable_shared_from_this<ConnectionMonitor> {
public:
using Callback = std::function<void(const EndPointInfo&)>;
@ -51,7 +48,8 @@ private:
Utils::Handle m_localEvent;
mutable std::map<EndPointInfo, std::unique_ptr<HandleMonitor>> m_remoteMonitors;
mutable std::map<EndPointInfo, std::unique_ptr<HandleMonitor>>
m_remoteMonitors;
mutable std::mutex m_mutexOnRemoteMonitors;
@ -60,15 +58,11 @@ private:
mutable std::mutex m_mutexOnUnregisteredEndPoints;
};
// ConnectionMonitor::HandleMonitor opens the given endpoint's process
// and event handles and waits for any event triggers.
class ConnectionMonitor::HandleMonitor
{
class ConnectionMonitor::HandleMonitor {
public:
HandleMonitor(
const EndPointInfo& remoteEndPoint,
Callback callback);
HandleMonitor(const EndPointInfo& remoteEndPoint, Callback callback);
HandleMonitor(const HandleMonitor&) = delete;
HandleMonitor& operator=(const HandleMonitor&) = delete;
@ -80,11 +74,9 @@ private:
std::unique_ptr<Waiter> m_processWaiter;
};
// ConnectionMonitor::HandleMonitor::Waiter waits on the given handle and calls
// the given callback when an event is triggered on the handle.
class ConnectionMonitor::HandleMonitor::Waiter
{
class ConnectionMonitor::HandleMonitor::Waiter {
public:
using Callback = std::function<void()>;
@ -96,8 +88,7 @@ public:
Waiter& operator=(const Waiter&) = delete;
private:
static VOID CALLBACK OnEvent(
PTP_CALLBACK_INSTANCE instance,
static VOID CALLBACK OnEvent(PTP_CALLBACK_INSTANCE instance,
PVOID context,
PTP_WAIT wait,
TP_WAIT_RESULT waitResult);

30
inc/L4/Interprocess/Connection/EndPointInfo.h
Просмотреть файл

@ -1,34 +1,24 @@
#pragma once
#include <cstdint>
#include <boost/uuid/uuid.hpp>
#include <cstdint>
namespace L4
{
namespace Interprocess
{
namespace Connection
{
namespace L4 {
namespace Interprocess {
namespace Connection {
// EndPointInfo struct encapsulates the connection end point
// information across process boundaries.
struct EndPointInfo
{
explicit EndPointInfo(
std::uint32_t pid = 0U,
struct EndPointInfo {
explicit EndPointInfo(std::uint32_t pid = 0U,
const boost::uuids::uuid& uuid = {})
: m_pid{ pid }
, m_uuid{ uuid }
{}
: m_pid{pid}, m_uuid{uuid} {}
bool operator==(const EndPointInfo& other) const
{
return (m_pid == other.m_pid)
&& (m_uuid == other.m_uuid);
bool operator==(const EndPointInfo& other) const {
return (m_pid == other.m_pid) && (m_uuid == other.m_uuid);
}
bool operator<(const EndPointInfo& other) const
{
bool operator<(const EndPointInfo& other) const {
return m_uuid < other.m_uuid;
}

16
inc/L4/Interprocess/Connection/EndPointInfoUtils.h
Просмотреть файл

@ -3,25 +3,19 @@
#include <string>
#include "Interprocess/Connection/EndPointInfo.h"
namespace L4
{
namespace Interprocess
{
namespace Connection
{
namespace L4 {
namespace Interprocess {
namespace Connection {
// EndPointInfoFactory creates an EndPointInfo object with the current
// process id and a random uuid.
class EndPointInfoFactory
{
class EndPointInfoFactory {
public:
EndPointInfo Create() const;
};
// StringConverter provides a functionality to convert EndPointInfo to a string.
class StringConverter
{
class StringConverter {
public:
std::string operator()(const EndPointInfo& endPoint) const;
};

11
inc/L4/Interprocess/Container/List.h
Просмотреть файл

@ -2,18 +2,13 @@
#include <boost/interprocess/containers/list.hpp>
namespace L4
{
namespace Interprocess
{
namespace Container
{
namespace L4 {
namespace Interprocess {
namespace Container {
template <typename T, typename Allocator>
using List = boost::interprocess::list<T, Allocator>;
} // namespace Container
} // namespace Interprocess
} // namespace L4

14
inc/L4/Interprocess/Container/String.h
Просмотреть файл

@ -2,17 +2,13 @@
#include <boost/interprocess/containers/string.hpp>
namespace L4
{
namespace Interprocess
{
namespace Container
{
namespace L4 {
namespace Interprocess {
namespace Container {
template <typename Allocator>
using String = boost::interprocess::basic_string<char, std::char_traits<char>, Allocator>;
using String =
boost::interprocess::basic_string<char, std::char_traits<char>, Allocator>;
} // namespace Container
} // namespace Interprocess

11
inc/L4/Interprocess/Container/Vector.h
Просмотреть файл

@ -2,18 +2,13 @@
#include <boost/interprocess/containers/vector.hpp>
namespace L4
{
namespace Interprocess
{
namespace Container
{
namespace L4 {
namespace Interprocess {
namespace Container {
template <typename T, typename Allocator>
using Vector = boost::interprocess::vector<T, Allocator>;
} // namespace Container
} // namespace Interprocess
} // namespace L4

15
inc/L4/Interprocess/Utils/Handle.h
Просмотреть файл

@ -4,16 +4,12 @@
#include <type_traits>
#include "Utils/Windows.h"
namespace L4
{
namespace Interprocess
{
namespace Utils
{
namespace L4 {
namespace Interprocess {
namespace Utils {
// Handle is a RAII class that manages the life time of the given HANDLE.
class Handle
{
class Handle {
public:
// If verifyHandle is true, it checks whether a given handle is valid.
explicit Handle(HANDLE handle, bool verifyHandle = false);
@ -29,7 +25,8 @@ public:
private:
HANDLE Verify(HANDLE handle, bool verifyHandle) const;
std::unique_ptr<std::remove_pointer_t<HANDLE>, decltype(&::CloseHandle)> m_handle;
std::unique_ptr<std::remove_pointer_t<HANDLE>, decltype(&::CloseHandle)>
m_handle;
};
} // namespace Utils

34
inc/L4/LocalMemory/Context.h
Просмотреть файл

@ -4,43 +4,33 @@
#include "EpochManager.h"
#include "HashTableManager.h"
namespace L4
{
namespace LocalMemory
{
namespace L4 {
namespace LocalMemory {
class Context : private EpochRefPolicy<EpochManager::TheEpochRefManager>
{
class Context : private EpochRefPolicy<EpochManager::TheEpochRefManager> {
public:
Context(
HashTableManager& hashTableManager,
Context(HashTableManager& hashTableManager,
EpochManager::TheEpochRefManager& epochRefManager)
: EpochRefPolicy<EpochManager::TheEpochRefManager>(epochRefManager)
, m_hashTableManager{ hashTableManager }
{}
: EpochRefPolicy<EpochManager::TheEpochRefManager>(epochRefManager),
m_hashTableManager{hashTableManager} {}
Context(Context&& context)
: EpochRefPolicy<EpochManager::TheEpochRefManager>(std::move(context))
, m_hashTableManager{ context.m_hashTableManager }
{}
: EpochRefPolicy<EpochManager::TheEpochRefManager>(std::move(context)),
m_hashTableManager{context.m_hashTableManager} {}
const IReadOnlyHashTable& operator[](const char* name) const
{
const IReadOnlyHashTable& operator[](const char* name) const {
return m_hashTableManager.GetHashTable(name);
}
IWritableHashTable& operator[](const char* name)
{
IWritableHashTable& operator[](const char* name) {
return m_hashTableManager.GetHashTable(name);
}
const IReadOnlyHashTable& operator[](std::size_t index) const
{
const IReadOnlyHashTable& operator[](std::size_t index) const {
return m_hashTableManager.GetHashTable(index);
}
IWritableHashTable& operator[](std::size_t index)
{
IWritableHashTable& operator[](std::size_t index) {
return m_hashTableManager.GetHashTable(index);
}

94
inc/L4/LocalMemory/EpochManager.h
Просмотреть файл

@ -10,51 +10,38 @@
#include "Utils/Lock.h"
#include "Utils/RunningThread.h"
namespace L4
{
namespace LocalMemory
{
namespace L4 {
namespace LocalMemory {
// EpochManager aggregates epoch-related functionalities such as adding/removing
// client epoch queues, registering/performing actions, and updating the epoch counters.
class EpochManager : public IEpochActionManager
{
// client epoch queues, registering/performing actions, and updating the epoch
// counters.
class EpochManager : public IEpochActionManager {
public:
using TheEpochQueue = EpochQueue<
boost::shared_lock_guard<Utils::ReaderWriterLockSlim>,
using TheEpochQueue =
EpochQueue<boost::shared_lock_guard<Utils::ReaderWriterLockSlim>,
std::lock_guard<Utils::ReaderWriterLockSlim>>;
using TheEpochRefManager = EpochRefManager<TheEpochQueue>;
EpochManager(
const EpochManagerConfig& config,
ServerPerfData& perfData)
: m_perfData{ perfData }
, m_config{ config }
, m_currentEpochCounter{ 0U }
, m_epochQueue{
m_currentEpochCounter,
m_config.m_epochQueueSize }
, m_epochRefManager{ m_epochQueue }
, m_epochCounterManager{ m_epochQueue }
, m_epochActionManager{ config.m_numActionQueues }
, m_processingThread{
m_config.m_epochProcessingInterval,
[this]
{
EpochManager(const EpochManagerConfig& config, ServerPerfData& perfData)
: m_perfData{perfData},
m_config{config},
m_currentEpochCounter{0U},
m_epochQueue{m_currentEpochCounter, m_config.m_epochQueueSize},
m_epochRefManager{m_epochQueue},
m_epochCounterManager{m_epochQueue},
m_epochActionManager{config.m_numActionQueues},
m_processingThread{m_config.m_epochProcessingInterval, [this] {
this->Remove();
this->Add();
}}
{}
}} {}
TheEpochRefManager& GetEpochRefManager()
{
return m_epochRefManager;
}
TheEpochRefManager& GetEpochRefManager() { return m_epochRefManager; }
void RegisterAction(Action&& action) override
{
m_epochActionManager.RegisterAction(m_currentEpochCounter, std::move(action));
void RegisterAction(Action&& action) override {
m_epochActionManager.RegisterAction(m_currentEpochCounter,
std::move(action));
m_perfData.Increment(ServerPerfCounter::PendingActionsCount);
}
@ -68,29 +55,35 @@ private:
// Enqueues a new epoch whose counter value is last counter + 1.
// This is called from the server side.
void Add()
{
void Add() {
// Incrementing the global epoch counter before incrementing per-connection
// epoch counter is safe (not so the other way around). If the server process is
// registering an action at the m_currentEpochCounter in RegisterAction(),
// it is happening in the "future," and this means that if the client is referencing
// the memory to be deleted in the "future," it will be safe.
// epoch counter is safe (not so the other way around). If the server
// process is registering an action at the m_currentEpochCounter in
// RegisterAction(), it is happening in the "future," and this means that if
// the client is referencing the memory to be deleted in the "future," it
// will be safe.
++m_currentEpochCounter;
m_epochCounterManager.AddNewEpoch();
}
// Dequeues any epochs whose ref counter is 0, meaning there is no reference at that time.
void Remove()
{
const auto oldestEpochCounter = m_epochCounterManager.RemoveUnreferenceEpochCounters();
// Dequeues any epochs whose ref counter is 0, meaning there is no reference
// at that time.
void Remove() {
const auto oldestEpochCounter =
m_epochCounterManager.RemoveUnreferenceEpochCounters();
const auto numActionsPerformed = m_epochActionManager.PerformActions(oldestEpochCounter);
const auto numActionsPerformed =
m_epochActionManager.PerformActions(oldestEpochCounter);
m_perfData.Subtract(ServerPerfCounter::PendingActionsCount, numActionsPerformed);
m_perfData.Set(ServerPerfCounter::LastPerformedActionsCount, numActionsPerformed);
m_perfData.Set(ServerPerfCounter::OldestEpochCounterInQueue, oldestEpochCounter);
m_perfData.Set(ServerPerfCounter::LatestEpochCounterInQueue, m_currentEpochCounter);
m_perfData.Subtract(ServerPerfCounter::PendingActionsCount,
numActionsPerformed);
m_perfData.Set(ServerPerfCounter::LastPerformedActionsCount,
numActionsPerformed);
m_perfData.Set(ServerPerfCounter::OldestEpochCounterInQueue,
oldestEpochCounter);
m_perfData.Set(ServerPerfCounter::LatestEpochCounterInQueue,
m_currentEpochCounter);
}
// Reference to the performance data.
@ -112,7 +105,8 @@ private:
// Handles adding/decrementing ref counts.
TheEpochRefManager m_epochRefManager;
// Handles adding new epoch and finding the epoch counts that have zero ref counts.
// Handles adding new epoch and finding the epoch counts that have zero ref
// counts.
TheEpochCounterManager m_epochCounterManager;
// Handles registering/performing actions.

62
inc/L4/LocalMemory/HashTableManager.h
Просмотреть файл

@ -3,75 +3,71 @@
#include <boost/any.hpp>
#include <memory>
#include <vector>
#include "LocalMemory/Memory.h"
#include "Epoch/IEpochActionManager.h"
#include "HashTable/Cache/HashTable.h"
#include "HashTable/Config.h"
#include "HashTable/ReadWrite/HashTable.h"
#include "HashTable/ReadWrite/Serializer.h"
#include "HashTable/Cache/HashTable.h"
#include "LocalMemory/Memory.h"
#include "Utils/Containers.h"
#include "Utils/Exception.h"
namespace L4
{
namespace LocalMemory
{
namespace L4 {
namespace LocalMemory {
class HashTableManager
{
class HashTableManager {
public:
template <typename Allocator>
std::size_t Add(
const HashTableConfig& config,
std::size_t Add(const HashTableConfig& config,
IEpochActionManager& epochActionManager,
Allocator allocator)
{
if (m_hashTableNameToIndex.find(config.m_name) != m_hashTableNameToIndex.end())
{
Allocator allocator) {
if (m_hashTableNameToIndex.find(config.m_name) !=
m_hashTableNameToIndex.end()) {
throw RuntimeException("Same hash table name already exists.");
}
const auto& cacheConfig = config.m_cache;
const auto& serializerConfig = config.m_serializer;
if (cacheConfig && serializerConfig)
{
if (cacheConfig && serializerConfig) {
throw RuntimeException(
"Constructing cache hash table via serializer is not supported.");
}
using namespace HashTable;
using InternalHashTable = typename ReadWrite::WritableHashTable<Allocator>::HashTable;
using InternalHashTable =
typename ReadWrite::WritableHashTable<Allocator>::HashTable;
using Memory = typename LocalMemory::Memory<Allocator>;
Memory memory{allocator};
std::shared_ptr<InternalHashTable> internalHashTable = (serializerConfig && serializerConfig->m_stream != nullptr)
? ReadWrite::Deserializer<Memory, InternalHashTable, ReadWrite::WritableHashTable>(
serializerConfig->m_properties.get_value_or(HashTableConfig::Serializer::Properties())).
Deserialize(
memory,
*(serializerConfig->m_stream))
std::shared_ptr<InternalHashTable> internalHashTable =
(serializerConfig && serializerConfig->m_stream != nullptr)
? ReadWrite::Deserializer<Memory, InternalHashTable,
ReadWrite::WritableHashTable>(
serializerConfig->m_properties.get_value_or(
HashTableConfig::Serializer::Properties()))
.Deserialize(memory, *(serializerConfig->m_stream))
: memory.template MakeUnique<InternalHashTable>(
typename InternalHashTable::Setting{
config.m_setting.m_numBuckets,
(std::max)(config.m_setting.m_numBucketsPerMutex.get_value_or(1U), 1U),
(std::max)(
config.m_setting.m_numBucketsPerMutex.get_value_or(
1U),
1U),
config.m_setting.m_fixedKeySize.get_value_or(0U),
config.m_setting.m_fixedValueSize.get_value_or(0U)},
memory.GetAllocator());
auto hashTable =
cacheConfig
? std::make_unique<Cache::WritableHashTable<Allocator>>(
*internalHashTable,
epochActionManager,
cacheConfig ? std::make_unique<Cache::WritableHashTable<Allocator>>(
*internalHashTable, epochActionManager,
cacheConfig->m_maxCacheSizeInBytes,
cacheConfig->m_recordTimeToLive,
cacheConfig->m_forceTimeBasedEviction)
: std::make_unique<ReadWrite::WritableHashTable<Allocator>>(
*internalHashTable,
epochActionManager);
*internalHashTable, epochActionManager);
m_internalHashTables.emplace_back(std::move(internalHashTable));
m_hashTables.emplace_back(std::move(hashTable));
@ -83,14 +79,12 @@ public:
return newIndex;
}
IWritableHashTable& GetHashTable(const char* name)
{
IWritableHashTable& GetHashTable(const char* name) {
assert(m_hashTableNameToIndex.find(name) != m_hashTableNameToIndex.cend());
return GetHashTable(m_hashTableNameToIndex.find(name)->second);
}
IWritableHashTable& GetHashTable(std::size_t index)
{
IWritableHashTable& GetHashTable(std::size_t index) {
assert(index < m_hashTables.size());
return *m_hashTables[index];
}

21
inc/L4/LocalMemory/HashTableService.h
Просмотреть файл

@ -5,29 +5,22 @@
#include "HashTable/Config.h"
#include "Log/PerfCounter.h"
namespace L4
{
namespace LocalMemory
{
namespace L4 {
namespace LocalMemory {
class HashTableService
{
class HashTableService {
public:
explicit HashTableService(
const EpochManagerConfig& epochManagerConfig = EpochManagerConfig())
: m_epochManager{ epochManagerConfig, m_serverPerfData }
{}
: m_epochManager{epochManagerConfig, m_serverPerfData} {}
template <typename Allocator = std::allocator<void>>
std::size_t AddHashTable(
const HashTableConfig& config,
Allocator allocator = Allocator())
{
std::size_t AddHashTable(const HashTableConfig& config,
Allocator allocator = Allocator()) {
return m_hashTableManager.Add(config, m_epochManager, allocator);
}
Context GetContext()
{
Context GetContext() {
return Context(m_hashTableManager, m_epochManager.GetEpochRefManager());
}

24
inc/L4/LocalMemory/Memory.h
Просмотреть файл

@ -1,14 +1,11 @@
#pragma once
namespace L4
{
namespace LocalMemory
{
namespace L4 {
namespace LocalMemory {
// Simple local memory model that stores the given allocator object.
template <typename Alloc>
class Memory
{
class Memory {
public:
using Allocator = Alloc;
@ -18,24 +15,17 @@ public:
template <typename T>
using Deleter = typename std::default_delete<T>;
explicit Memory(Allocator allocator = Allocator())
: m_allocator{ allocator }
{}
explicit Memory(Allocator allocator = Allocator()) : m_allocator{allocator} {}
template <typename T, typename... Args>
auto MakeUnique(Args&&... args)
{
auto MakeUnique(Args&&... args) {
return std::make_unique<T>(std::forward<Args>(args)...);
}
Allocator GetAllocator()
{
return Allocator(m_allocator);
}
Allocator GetAllocator() { return Allocator(m_allocator); }
template <typename T>
auto GetDeleter()
{
auto GetDeleter() {
return Deleter<T>();
}

23
inc/L4/Log/IPerfLogger.h
Просмотреть файл

@ -3,14 +3,10 @@
#include <map>
#include "PerfCounter.h"
namespace L4
{
namespace L4 {
// IPerfLogger interface.
struct IPerfLogger
{
struct IPerfLogger {
struct IData;
virtual ~IPerfLogger() = default;
@ -18,14 +14,12 @@ struct IPerfLogger
virtual void Log(const IData& data) = 0;
};
// IPerfLogger::IData interface that provides access to ServerPerfData and the aggregated HashTablePerfData.
// Note that the user of IPerfLogger only needs to implement IPerfLogger since IPerfLogger::IData is
// implemented internally.
struct IPerfLogger::IData
{
using HashTablesPerfData = std::map<
std::string,
std::reference_wrapper<const HashTablePerfData>>;
// IPerfLogger::IData interface that provides access to ServerPerfData and the
// aggregated HashTablePerfData. Note that the user of IPerfLogger only needs to
// implement IPerfLogger since IPerfLogger::IData is implemented internally.
struct IPerfLogger::IData {
using HashTablesPerfData =
std::map<std::string, std::reference_wrapper<const HashTablePerfData>>;
virtual ~IData() = default;
@ -34,5 +28,4 @@ struct IPerfLogger::IData
virtual const HashTablesPerfData& GetHashTablesPerfData() const = 0;
};
} // namespace L4

144
inc/L4/Log/PerfCounter.h
Просмотреть файл

@ -1,16 +1,14 @@
#pragma once
#include <cstdint>
#include <algorithm>
#include <array>
#include <limits>
#include <atomic>
#include <cstdint>
#include <limits>
namespace L4
{
namespace L4 {
enum class ServerPerfCounter : std::uint16_t
{
enum class ServerPerfCounter : std::uint16_t {
// Connection Manager
ClientConnectionsCount = 0U,
@ -23,22 +21,17 @@ enum class ServerPerfCounter : std::uint16_t
Count
};
const std::array<
const char*,
static_cast<std::uint16_t>(ServerPerfCounter::Count)> c_serverPerfCounterNames =
{
const std::array<const char*,
static_cast<std::uint16_t>(ServerPerfCounter::Count)>
c_serverPerfCounterNames = {
// Connection Manager
"ClientConnectionsCount",
// EpochManager
"OldestEpochCounterInQueue",
"LatestEpochCounterInQueue",
"PendingActionsCount",
"LastPerformedActionsCount"
};
"OldestEpochCounterInQueue", "LatestEpochCounterInQueue",
"PendingActionsCount", "LastPerformedActionsCount"};
enum class HashTablePerfCounter : std::uint16_t
{
enum class HashTablePerfCounter : std::uint16_t {
RecordsCount = 0U,
BucketsCount,
TotalKeySize,
@ -65,11 +58,9 @@ enum class HashTablePerfCounter : std::uint16_t
Count
};
const std::array<
const char*,
static_cast<std::uint16_t>(HashTablePerfCounter::Count)> c_hashTablePerfCounterNames =
{
"RecordsCount",
const std::array<const char*,
static_cast<std::uint16_t>(HashTablePerfCounter::Count)>
c_hashTablePerfCounterNames = {"RecordsCount",
"BucketsCount",
"TotalKeySize",
"TotalValueSize",
@ -84,109 +75,87 @@ const std::array<
"RecordsCountSavedFromSerializer",
"CacheHitCount",
"CacheMissCount",
"EvictedRecordsCount"
};
"EvictedRecordsCount"};
template <typename TCounterEnum>
class PerfCounters
{
class PerfCounters {
public:
typedef std::int64_t TValue;
typedef std::atomic<TValue> TCounter;
PerfCounters()
{
std::for_each(
std::begin(m_counters),
std::end(m_counters),
[] (TCounter& counter)
{
counter = 0;
});
PerfCounters() {
std::for_each(std::begin(m_counters), std::end(m_counters),
[](TCounter& counter) { counter = 0; });
}
// Note that since the ordering doesn't matter when the counter is updated, memory_order_relaxed
// is used for all perf counter updates.
// More from http://en.cppreference.com/w/cpp/atomic/memory_order:
// Typical use for relaxed memory ordering is updating counters, such as the reference counters
// of std::shared_ptr, since this only requires atomicity, but not ordering or synchronization.
TValue Get(TCounterEnum counterEnum) const
{
return m_counters[static_cast<std::uint16_t>(counterEnum)].load(std::memory_order_relaxed);
// Note that since the ordering doesn't matter when the counter is updated,
// memory_order_relaxed is used for all perf counter updates. More from
// http://en.cppreference.com/w/cpp/atomic/memory_order: Typical use for
// relaxed memory ordering is updating counters, such as the reference
// counters of std::shared_ptr, since this only requires atomicity, but not
// ordering or synchronization.
TValue Get(TCounterEnum counterEnum) const {
return m_counters[static_cast<std::uint16_t>(counterEnum)].load(
std::memory_order_relaxed);
}
void Set(TCounterEnum counterEnum, TValue value)
{
m_counters[static_cast<std::uint16_t>(counterEnum)].store(value, std::memory_order_relaxed);
void Set(TCounterEnum counterEnum, TValue value) {
m_counters[static_cast<std::uint16_t>(counterEnum)].store(
value, std::memory_order_relaxed);
}
void Increment(TCounterEnum counterEnum)
{
m_counters[static_cast<std::uint16_t>(counterEnum)].fetch_add(1, std::memory_order_relaxed);
void Increment(TCounterEnum counterEnum) {
m_counters[static_cast<std::uint16_t>(counterEnum)].fetch_add(
1, std::memory_order_relaxed);
}
void Decrement(TCounterEnum counterEnum)
{
m_counters[static_cast<std::uint16_t>(counterEnum)].fetch_sub(1, std::memory_order_relaxed);
void Decrement(TCounterEnum counterEnum) {
m_counters[static_cast<std::uint16_t>(counterEnum)].fetch_sub(
1, std::memory_order_relaxed);
}
void Add(TCounterEnum counterEnum, TValue value)
{
if (value != 0)
{
m_counters[static_cast<std::uint16_t>(counterEnum)].fetch_add(value, std::memory_order_relaxed);
void Add(TCounterEnum counterEnum, TValue value) {
if (value != 0) {
m_counters[static_cast<std::uint16_t>(counterEnum)].fetch_add(
value, std::memory_order_relaxed);
}
}
void Subtract(TCounterEnum counterEnum, TValue value)
{
if (value != 0)
{
m_counters[static_cast<std::uint16_t>(counterEnum)].fetch_sub(value, std::memory_order_relaxed);
void Subtract(TCounterEnum counterEnum, TValue value) {
if (value != 0) {
m_counters[static_cast<std::uint16_t>(counterEnum)].fetch_sub(
value, std::memory_order_relaxed);
}
}
void Max(TCounterEnum counterEnum, TValue value)
{
void Max(TCounterEnum counterEnum, TValue value) {
auto& counter = m_counters[static_cast<std::uint16_t>(counterEnum)];
TValue startValue = counter.load(std::memory_order_acquire);
do
{
do {
// "load()" from counter is needed only once since the value of Max is
// monotonically increasing. If startValue is changed by other threads,
// compare_exchange_strong will return false and startValue will be
// written to the latest value, thus returning to this code path.
if (startValue > value)
{
if (startValue > value) {
return;
}
}
while (!counter.compare_exchange_strong(
startValue,
value,
} while (!counter.compare_exchange_strong(startValue, value,
std::memory_order_release,
std::memory_order_acquire));
}
void Min(TCounterEnum counterEnum, TValue value)
{
void Min(TCounterEnum counterEnum, TValue value) {
auto& counter = m_counters[static_cast<std::uint16_t>(counterEnum)];
TValue startValue = counter.load(std::memory_order_acquire);
do
{
do {
// Check the comment in Max() and Min() is monotonically decreasing.
if (startValue < value)
{
if (startValue < value) {
return;
}
}
while (!counter.compare_exchange_strong(
startValue,
value,
} while (!counter.compare_exchange_strong(startValue, value,
std::memory_order_release,
std::memory_order_acquire));
}
@ -204,12 +173,11 @@ private:
typedef PerfCounters<ServerPerfCounter> ServerPerfData;
struct HashTablePerfData : public PerfCounters<HashTablePerfCounter>
{
HashTablePerfData()
{
struct HashTablePerfData : public PerfCounters<HashTablePerfCounter> {
HashTablePerfData() {
// Initialize any min counters to the max value.
const auto maxValue = (std::numeric_limits<HashTablePerfData::TValue>::max)();
const auto maxValue =
(std::numeric_limits<HashTablePerfData::TValue>::max)();
Set(HashTablePerfCounter::MinValueSize, maxValue);
Set(HashTablePerfCounter::MinKeySize, maxValue);

29
inc/L4/Log/PerfLogger.h
Просмотреть файл

@ -2,19 +2,15 @@
#include "IPerfLogger.h"
namespace L4
{
namespace L4 {
struct PerfLoggerManagerConfig;
// PerfData class, which holds the ServerPerfData and HashTablePerfData for each
// hash table. Note that PerfData owns the ServerPerfData but has only the const
// references to HashTablePerfData, which is owned by the HashTable.
// PerfData class, which holds the ServerPerfData and HashTablePerfData for each hash table.
// Note that PerfData owns the ServerPerfData but has only the const references to HashTablePerfData,
// which is owned by the HashTable.
class PerfData : public IPerfLogger::IData
{
class PerfData : public IPerfLogger::IData {
public:
PerfData() = default;
@ -24,7 +20,8 @@ public:
const HashTablesPerfData& GetHashTablesPerfData() const override;
void AddHashTablePerfData(const char* hashTableName, const HashTablePerfData& perfData);
void AddHashTablePerfData(const char* hashTableName,
const HashTablePerfData& perfData);
PerfData(const PerfData&) = delete;
PerfData& operator=(const PerfData&) = delete;
@ -34,23 +31,19 @@ private:
HashTablesPerfData m_hashTablesPerfData;
};
// PerfData inline implementations.
inline ServerPerfData& PerfData::GetServerPerfData()
{
inline ServerPerfData& PerfData::GetServerPerfData() {
return m_serverPerfData;
}
inline const ServerPerfData& PerfData::GetServerPerfData() const
{
inline const ServerPerfData& PerfData::GetServerPerfData() const {
return m_serverPerfData;
}
inline const PerfData::HashTablesPerfData& PerfData::GetHashTablesPerfData() const
{
inline const PerfData::HashTablesPerfData& PerfData::GetHashTablesPerfData()
const {
return m_hashTablesPerfData;
}
} // namespace L4

32
inc/L4/Serialization/SerializerHelper.h
Просмотреть файл

@ -3,28 +3,22 @@
#include <cstdint>
#include <iosfwd>
namespace L4
{
namespace L4 {
// SerializerHelper provides help functions to write to IStreamWriter.
class SerializerHelper
{
class SerializerHelper {
public:
SerializerHelper(std::ostream& stream)
: m_stream{ stream }
{}
SerializerHelper(std::ostream& stream) : m_stream{stream} {}
SerializerHelper(const SerializerHelper&) = delete;
SerializerHelper& operator=(const SerializerHelper&) = delete;
template <typename T>
void Serialize(const T& obj)
{
void Serialize(const T& obj) {
m_stream.write(reinterpret_cast<const char*>(&obj), sizeof(obj));
}
void Serialize(const void* data, std::uint32_t dataSize)
{
void Serialize(const void* data, std::uint32_t dataSize) {
m_stream.write(static_cast<const char*>(data), dataSize);
}
@ -32,26 +26,20 @@ private:
std::ostream& m_stream;
};
// DeserializerHelper provides help functions to read from IStreamReader.
class DeserializerHelper
{
class DeserializerHelper {
public:
DeserializerHelper(std::istream& stream)
: m_stream{ stream }
{}
DeserializerHelper(std::istream& stream) : m_stream{stream} {}
DeserializerHelper(const DeserializerHelper&) = delete;
DeserializerHelper& operator=(const DeserializerHelper&) = delete;
template <typename T>
void Deserialize(T& obj)
{
void Deserialize(T& obj) {
m_stream.read(reinterpret_cast<char*>(&obj), sizeof(obj));
}
void Deserialize(void* data, std::uint32_t dataSize)
{
void Deserialize(void* data, std::uint32_t dataSize) {
m_stream.read(static_cast<char*>(data), dataSize);
}
@ -59,6 +47,4 @@ private:
std::istream& m_stream;
};
} // namespace L4

52
inc/L4/Utils/AtomicOffsetPtr.h
Просмотреть файл

@ -1,49 +1,46 @@
#pragma once
#include <atomic>
#include <cstdint>
#include <boost/version.hpp>
#include <boost/interprocess/offset_ptr.hpp>
#include <boost/version.hpp>
#include <cstdint>
namespace L4
{
namespace Utils
{
namespace L4 {
namespace Utils {
// AtomicOffsetPtr provides a way to atomically update the offset pointer.
// The current boost::interprocess::offset_ptr cannot be used with std::atomic<> because
// the class is not trivially copyable. AtomicOffsetPtr borrows the same concept to calculate
// the pointer address based on the offset (boost::interprocess::ipcdetail::offset_ptr_to* functions
// are reused).
// Note that ->, *, copy/assignment operators are not implemented intentionally so that
// the user (inside this library) is aware of what he is intended to do without accidentally
// incurring any performance hits.
// The current boost::interprocess::offset_ptr cannot be used with std::atomic<>
// because the class is not trivially copyable. AtomicOffsetPtr borrows the same
// concept to calculate the pointer address based on the offset
// (boost::interprocess::ipcdetail::offset_ptr_to* functions are reused). Note
// that ->, *, copy/assignment operators are not implemented intentionally so
// that the user (inside this library) is aware of what he is intended to do
// without accidentally incurring any performance hits.
template <typename T>
class AtomicOffsetPtr
{
class AtomicOffsetPtr {
public:
AtomicOffsetPtr()
: m_offset(1)
{}
AtomicOffsetPtr() : m_offset(1) {}
AtomicOffsetPtr(const AtomicOffsetPtr&) = delete;
AtomicOffsetPtr& operator=(const AtomicOffsetPtr&) = delete;
T* Load(std::memory_order memoryOrder = std::memory_order_seq_cst) const
{
T* Load(std::memory_order memoryOrder = std::memory_order_seq_cst) const {
return static_cast<T*>(
boost::interprocess::ipcdetail::offset_ptr_to_raw_pointer(
this,
m_offset.load(memoryOrder)));
this, m_offset.load(memoryOrder)));
}
void Store(T* ptr, std::memory_order memoryOrder = std::memory_order_seq_cst)
{
void Store(T* ptr,
std::memory_order memoryOrder = std::memory_order_seq_cst) {
#if defined(_MSC_VER)
m_offset.store(boost::interprocess::ipcdetail::offset_ptr_to_offset(ptr, this), memoryOrder);
m_offset.store(
boost::interprocess::ipcdetail::offset_ptr_to_offset(ptr, this),
memoryOrder);
#else
m_offset.store(boost::interprocess::ipcdetail::offset_ptr_to_offset<std::uintptr_t>(ptr, this), memoryOrder);
m_offset.store(
boost::interprocess::ipcdetail::offset_ptr_to_offset<std::uintptr_t>(
ptr, this),
memoryOrder);
#endif
}
@ -55,6 +52,5 @@ private:
#endif
};
} // namespace Utils
} // namespace L4

15
inc/L4/Utils/Clock.h
Просмотреть файл

@ -2,23 +2,16 @@
#include <chrono>
namespace L4 {
namespace Utils {
namespace L4
{
namespace Utils
{
class EpochClock
{
class EpochClock {
public:
std::chrono::seconds GetCurrentEpochTime() const
{
std::chrono::seconds GetCurrentEpochTime() const {
return std::chrono::duration_cast<std::chrono::seconds>(
std::chrono::high_resolution_clock::now().time_since_epoch());
}
};
} // namespace Utils
} // namespace L4

52
inc/L4/Utils/ComparerHasher.h
Просмотреть файл

@ -1,47 +1,40 @@
#pragma once
#include <boost/functional/hash.hpp>
#include <cctype>
#include <cstdint>
#include <string>
#include <boost/functional/hash.hpp>
#if defined(__GNUC__)
#define _stricmp strcasecmp
#endif
namespace L4
{
namespace Utils
{
namespace L4 {
namespace Utils {
// CaseInsensitiveStdStringComparer is a STL-compatible case-insensitive ANSI std::string comparer.
struct CaseInsensitiveStdStringComparer
{
bool operator()(const std::string& str1, const std::string& str2) const
{
// CaseInsensitiveStdStringComparer is a STL-compatible case-insensitive ANSI
// std::string comparer.
struct CaseInsensitiveStdStringComparer {
bool operator()(const std::string& str1, const std::string& str2) const {
return _stricmp(str1.c_str(), str2.c_str()) == 0;
}
};
// CaseInsensitiveStringComparer is a STL-compatible case-insensitive ANSI string comparer.
struct CaseInsensitiveStringComparer
{
bool operator()(const char* const str1, const char* const str2) const
{
// CaseInsensitiveStringComparer is a STL-compatible case-insensitive ANSI
// string comparer.
struct CaseInsensitiveStringComparer {
bool operator()(const char* const str1, const char* const str2) const {
return _stricmp(str1, str2) == 0;
}
};
// CaseInsensitiveStringHasher is a STL-compatible case-insensitive ANSI std::string hasher.
struct CaseInsensitiveStdStringHasher
{
std::size_t operator()(const std::string& str) const
{
// CaseInsensitiveStringHasher is a STL-compatible case-insensitive ANSI
// std::string hasher.
struct CaseInsensitiveStdStringHasher {
std::size_t operator()(const std::string& str) const {
std::size_t seed = 0;
for (auto c : str)
{
for (auto c : str) {
boost::hash_combine(seed, std::toupper(c));
}
@ -49,17 +42,15 @@ struct CaseInsensitiveStdStringHasher
}
};
// CaseInsensitiveStringHasher is a STL-compatible case-insensitive ANSI string hasher.
struct CaseInsensitiveStringHasher
{
std::size_t operator()(const char* str) const
{
// CaseInsensitiveStringHasher is a STL-compatible case-insensitive ANSI string
// hasher.
struct CaseInsensitiveStringHasher {
std::size_t operator()(const char* str) const {
assert(str != nullptr);
std::size_t seed = 0;
while (*str)
{
while (*str) {
boost::hash_combine(seed, std::toupper(*str++));
}
@ -67,6 +58,5 @@ struct CaseInsensitiveStringHasher
}
};
} // namespace Utils
} // namespace L4

30
inc/L4/Utils/Containers.h
Просмотреть файл

@ -1,23 +1,20 @@
#pragma once
#include <boost/functional/hash.hpp>
#include <cstdint>
#include <string>
#include <unordered_map>
#include <boost/functional/hash.hpp>
#include "Utils/ComparerHasher.h"
namespace L4 {
namespace Utils {
namespace L4
{
namespace Utils
{
// StdStringKeyMap is an unordered_map where the key is std::string. It is slower than
// StringKeyMap above, but it owns the memory of the string, so it's easier to use.
// StdStringKeyMap is an unordered_map where the key is std::string. It is
// slower than StringKeyMap above, but it owns the memory of the string, so it's
// easier to use.
template <typename TValue>
using StdStringKeyMap = std::unordered_map<
std::string,
using StdStringKeyMap =
std::unordered_map<std::string,
TValue,
Utils::CaseInsensitiveStdStringHasher,
Utils::CaseInsensitiveStdStringComparer>;
@ -26,20 +23,15 @@ using StdStringKeyMap = std::unordered_map<
// The memory of the key is not owned by StringKeyMap,
// but it is faster (than StdStringKeyMap below) for look up.
template <typename TValue>
using StringKeyMap = std::unordered_map<
const char*,
using StringKeyMap = std::unordered_map<const char*,
TValue,
Utils::CaseInsensitiveStringHasher,
Utils::CaseInsensitiveStringComparer>;
// IntegerKeyMap using boost::hash and std::equal_to comparer and hasher.
template <typename TKey, typename TValue>
using IntegerKeyMap = std::unordered_map<
TKey,
TValue,
boost::hash<TKey>,
std::equal_to<TKey>>;
using IntegerKeyMap =
std::unordered_map<TKey, TValue, boost::hash<TKey>, std::equal_to<TKey>>;
} // namespace Utils
} // namespace L4

14
inc/L4/Utils/Exception.h
Просмотреть файл

@ -1,22 +1,18 @@
#pragma once
#include <string>
#include <stdexcept>
#include <string>
namespace L4
{
namespace L4 {
// RuntimeException class used across L4 library.
class RuntimeException : public std::runtime_error
{
class RuntimeException : public std::runtime_error {
public:
explicit RuntimeException(const std::string& message)
: std::runtime_error(message.c_str())
{}
: std::runtime_error(message.c_str()) {}
explicit RuntimeException(const char* message)
: std::runtime_error(message)
{}
: std::runtime_error(message) {}
};
} // namespace L4

98
inc/L4/Utils/Lock.h
Просмотреть файл

@ -12,82 +12,50 @@
#endif
#endif
namespace L4
{
namespace Utils
{
namespace L4 {
namespace Utils {
#if defined(_MSC_VER)
// Represents a RAII wrapper for Win32 CRITICAL_SECTION.
class CriticalSection : protected ::CRITICAL_SECTION
{
class CriticalSection : protected ::CRITICAL_SECTION {
public:
// Constructs and initializes the critical section.
CriticalSection()
{
::InitializeCriticalSection(this);
}
CriticalSection() { ::InitializeCriticalSection(this); }
CriticalSection(const CriticalSection& other) = delete;
CriticalSection& operator=(const CriticalSection& other) = delete;
// Destructs the critical section.
~CriticalSection()
{
::DeleteCriticalSection(this);
}
~CriticalSection() { ::DeleteCriticalSection(this); }
// Waits for ownership of the critical section.
void lock()
{
::EnterCriticalSection(this);
}
void lock() { ::EnterCriticalSection(this); }
// Releases ownership of the critical section.
void unlock()
{
::LeaveCriticalSection(this);
}
void unlock() { ::LeaveCriticalSection(this); }
};
// Represents a RAII wrapper for Win32 SRW lock.
class ReaderWriterLockSlim
{
class ReaderWriterLockSlim {
public:
// Constructs and initializes an SRW lock.
ReaderWriterLockSlim()
{
::InitializeSRWLock(&m_lock);
}
ReaderWriterLockSlim() { ::InitializeSRWLock(&m_lock); }
ReaderWriterLockSlim(const ReaderWriterLockSlim& other) = delete;
ReaderWriterLockSlim& operator=(const ReaderWriterLockSlim& other) = delete;
// Acquires an SRW lock in shared mode.
void lock_shared()
{
::AcquireSRWLockShared(&m_lock);
}
void lock_shared() { ::AcquireSRWLockShared(&m_lock); }
// Acquires an SRW lock in exclusive mode.
void lock()
{
::AcquireSRWLockExclusive(&m_lock);
}
void lock() { ::AcquireSRWLockExclusive(&m_lock); }
// Releases an SRW lock that was opened in shared mode.
void unlock_shared()
{
::ReleaseSRWLockShared(&m_lock);
}
void unlock_shared() { ::ReleaseSRWLockShared(&m_lock); }
// Releases an SRW lock that was opened in exclusive mode.
void unlock()
{
::ReleaseSRWLockExclusive(&m_lock);
}
void unlock() { ::ReleaseSRWLockExclusive(&m_lock); }
private:
// Stores the Win32 SRW lock.
@ -97,58 +65,36 @@ private:
#else
#if defined(__GNUC__)
class CriticalSection
{
class CriticalSection {
public:
CriticalSection()
: m_mutex{}
{}
CriticalSection() : m_mutex{} {}
CriticalSection(const CriticalSection& other) = delete;
CriticalSection& operator=(const CriticalSection& other) = delete;
~CriticalSection() = default;
void lock()
{
pthread_mutex_lock(&m_mutex);
}
void lock() { pthread_mutex_lock(&m_mutex); }
void unlock()
{
pthread_mutex_unlock(&m_mutex);
}
void unlock() { pthread_mutex_unlock(&m_mutex); }
private:
pthread_mutex_t m_mutex;
};
class ReaderWriterLockSlim
{
class ReaderWriterLockSlim {
public:
ReaderWriterLockSlim() = default;
ReaderWriterLockSlim(const ReaderWriterLockSlim& other) = delete;
ReaderWriterLockSlim& operator=(const ReaderWriterLockSlim& other) = delete;
void lock_shared()
{
pthread_rwlock_rdlock(&m_lock);
}
void lock_shared() { pthread_rwlock_rdlock(&m_lock); }
void lock()
{
pthread_rwlock_wrlock(&m_lock);
}
void lock() { pthread_rwlock_wrlock(&m_lock); }
void unlock_shared()
{
pthread_rwlock_unlock(&m_lock);
}
void unlock_shared() { pthread_rwlock_unlock(&m_lock); }
void unlock()
{
unlock_shared();
}
void unlock() { unlock_shared(); }
private:
pthread_rwlock_t m_lock = PTHREAD_RWLOCK_INITIALIZER;

49
inc/L4/Utils/Math.h
Просмотреть файл

@ -1,40 +1,31 @@
#pragma once
#include <cstdint>
#include <cstddef>
#include <complex>
#include <cstddef>
#include <cstdint>
namespace L4
{
namespace Utils
{
namespace Math
{
namespace L4 {
namespace Utils {
namespace Math {
// Rounds up the number to the nearest multiple of base.
inline std::uint64_t RoundUp(std::uint64_t number, std::uint64_t base)
{
inline std::uint64_t RoundUp(std::uint64_t number, std::uint64_t base) {
return base ? (((number + base - 1) / base) * base) : number;
}
// Rounds down the number to the nearest multiple of base.
inline std::uint64_t RoundDown(std::uint64_t number, std::uint64_t base)
{
inline std::uint64_t RoundDown(std::uint64_t number, std::uint64_t base) {
return base ? ((number / base) * base) : number;
}
// Returns true if the given number is a power of 2.
inline bool IsPowerOfTwo(std::uint64_t number)
{
inline bool IsPowerOfTwo(std::uint64_t number) {
return number && ((number & (number - 1)) == 0);
}
// Returns the next highest power of two from the given value.
// http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2.
inline std::uint32_t NextHighestPowerOfTwo(std::uint32_t val)
{
inline std::uint32_t NextHighestPowerOfTwo(std::uint32_t val) {
--val;
val |= val >> 1;
val |= val >> 2;
@ -44,36 +35,30 @@ inline std::uint32_t NextHighestPowerOfTwo(std::uint32_t val)
return ++val;
}
// Provides utility functions doing pointer related arithmetics.
namespace PointerArithmetic
{
namespace PointerArithmetic {
// Returns a new pointer after adding an offset.
template <typename T>
inline T* Add(T* ptr, std::size_t offset)
{
inline T* Add(T* ptr, std::size_t offset) {
return reinterpret_cast<T*>(reinterpret_cast<std::uintptr_t>(ptr) + offset);
}
// Returns a new pointer after subtracting an offset.
template <typename T>
inline T* Subtract(T* ptr, std::size_t offset)
{
inline T* Subtract(T* ptr, std::size_t offset) {
return reinterpret_cast<T*>(reinterpret_cast<std::uintptr_t>(ptr) - offset);
}
// Returns the absolute value of difference in the number of bytes between two pointers.
inline std::size_t Distance(const void* lhs, const void* rhs)
{
return std::abs(reinterpret_cast<std::ptrdiff_t>(lhs) - reinterpret_cast<std::ptrdiff_t>(rhs));
// Returns the absolute value of difference in the number of bytes between two
// pointers.
inline std::size_t Distance(const void* lhs, const void* rhs) {
return std::abs(reinterpret_cast<std::ptrdiff_t>(lhs) -
reinterpret_cast<std::ptrdiff_t>(rhs));
}
} // namespace PointerArithmetic
} // namespace Math
} // namespace Utils
} // namespace L4

30
inc/L4/Utils/Properties.h
Просмотреть файл

@ -4,17 +4,12 @@
#include <boost/lexical_cast.hpp>
namespace L4
{
namespace Utils
{
namespace L4 {
namespace Utils {
// Properties class represents a string to string map (case insensitive).
// It can be used where the configurations should be generic.
class Properties : public StdStringKeyMap<std::string>
{
class Properties : public StdStringKeyMap<std::string> {
public:
using Base = Utils::StdStringKeyMap<std::string>;
using Value = Base::value_type;
@ -22,26 +17,20 @@ public:
Properties() = default;
// Expose a constructor with initializer_list for convenience.
Properties(std::initializer_list<Value> values)
: Base(values)
{
}
Properties(std::initializer_list<Value> values) : Base(values) {}
// Returns true if the given key exists and the value associated with
// the key can be converted to the TValue type. If the conversion fails, the value
// of the given val is guaranteed to remain the same.
// the key can be converted to the TValue type. If the conversion fails, the
// value of the given val is guaranteed to remain the same.
template <typename TValue>
bool TryGet(const std::string& key, TValue& val) const
{
bool TryGet(const std::string& key, TValue& val) const {
const auto it = find(key);
if (it == end())
{
if (it == end()) {
return false;
}
TValue tmp;
if (!boost::conversion::try_lexical_convert(it->second, tmp))
{
if (!boost::conversion::try_lexical_convert(it->second, tmp)) {
return false;
}
@ -51,6 +40,5 @@ public:
}
};
} // namespace Utils
} // namespace L4

49
inc/L4/Utils/RunningThread.h
Просмотреть файл

@ -1,49 +1,34 @@
#pragma once
#include <atomic>
#include <chrono>
#include <cstdint>
#include <thread>
#include <atomic>
namespace L4
{
namespace Utils
{
namespace L4 {
namespace Utils {
// NoOp is a function object that doesn't do anything.
struct NoOp
{
struct NoOp {
void operator()(...) {}
};
// RunningThread wraps around std::thread and repeatedly runs a given function after yielding
// for the given interval. Note that the destructor waits for the thread to stop.
// RunningThread wraps around std::thread and repeatedly runs a given function
// after yielding for the given interval. Note that the destructor waits for the
// thread to stop.
template <typename CoreFunc, typename PrepFunc = NoOp>
class RunningThread
{
class RunningThread {
public:
RunningThread(
std::chrono::milliseconds interval,
RunningThread(std::chrono::milliseconds interval,
CoreFunc coreFunc,
PrepFunc prepFunc = PrepFunc())
: m_isRunning(),
m_thread(
&RunningThread::Start,
this,
interval,
coreFunc,
prepFunc)
{
}
m_thread(&RunningThread::Start, this, interval, coreFunc, prepFunc) {}
~RunningThread()
{
~RunningThread() {
m_isRunning.store(false);
if (m_thread.joinable())
{
if (m_thread.joinable()) {
m_thread.join();
}
}
@ -52,17 +37,14 @@ public:
RunningThread& operator=(const RunningThread&) = delete;
private:
void Start(
std::chrono::milliseconds interval,
void Start(std::chrono::milliseconds interval,
CoreFunc coreFunc,
PrepFunc prepFunc)
{
PrepFunc prepFunc) {
m_isRunning.store(true);
prepFunc();
while (m_isRunning.load())
{
while (m_isRunning.load()) {
coreFunc();
std::this_thread::sleep_for(interval);
@ -74,6 +56,5 @@ private:
std::thread m_thread;
};
} // namespace Utils
} // namespace L4

9
inc/L4/Utils/Windows.h
Просмотреть файл

@ -44,14 +44,15 @@
#define NODEFERWINDOWPOS // - DeferWindowPos routines
#define NOMCX // - Modem Configuration Extensions
// Enabling STRICT redefines certain data types so that the compiler does not permit assignment from one type to another without an explicit cast.
// Enabling STRICT redefines certain data types so that the compiler does not
// permit assignment from one type to another without an explicit cast.
#define STRICT
// Define WIN32_LEAN_AND_MEAN to exclude APIs such as Cryptography, DDE, RPC, Shell, and Windows Sockets.
// Cryptography is needed due to <boost/uuids/random_generator.hpp>
// Define WIN32_LEAN_AND_MEAN to exclude APIs such as Cryptography, DDE, RPC,
// Shell, and Windows Sockets. Cryptography is needed due to
// <boost/uuids/random_generator.hpp>
//#define WIN32_LEAN_AND_MEAN
#pragma warning(pop)
#include <Windows.h>

8
inc/L4/detail/ToRawPointer.h
Просмотреть файл

@ -2,14 +2,10 @@
#include <boost/interprocess/detail/utilities.hpp>
namespace L4
{
namespace Detail
{
namespace L4 {
namespace Detail {
using boost::interprocess::ipcdetail::to_raw_pointer;
} // namespace Detail
} // namespace L4

50
src/EpochActionManager.cpp
Просмотреть файл

@ -5,36 +5,33 @@
#include <memory>
#include <thread>
namespace L4
{
namespace L4 {
// EpochActionManager class implementation.
EpochActionManager::EpochActionManager(std::uint8_t numActionQueues)
: m_epochToActionsList{}
, m_counter{}
{
: m_epochToActionsList{}, m_counter{} {
// Calculate numActionQueues as the next highest power of two.
std::uint16_t newNumActionQueues = numActionQueues;
if (numActionQueues == 0U)
{
newNumActionQueues = static_cast<std::uint16_t>(std::thread::hardware_concurrency());
if (numActionQueues == 0U) {
newNumActionQueues =
static_cast<std::uint16_t>(std::thread::hardware_concurrency());
}
newNumActionQueues = static_cast<std::uint16_t>(Utils::Math::NextHighestPowerOfTwo(newNumActionQueues));
newNumActionQueues = static_cast<std::uint16_t>(
Utils::Math::NextHighestPowerOfTwo(newNumActionQueues));
assert(newNumActionQueues != 0U && Utils::Math::IsPowerOfTwo(newNumActionQueues));
assert(newNumActionQueues != 0U &&
Utils::Math::IsPowerOfTwo(newNumActionQueues));
// Initialize m_epochToActionsList.
m_epochToActionsList.resize(newNumActionQueues);
for (auto& epochToActions : m_epochToActionsList)
{
for (auto& epochToActions : m_epochToActionsList) {
std::get<0>(epochToActions) = std::make_unique<Mutex>();
}
}
void EpochActionManager::RegisterAction(std::uint64_t epochCounter, IEpochActionManager::Action&& action)
{
void EpochActionManager::RegisterAction(std::uint64_t epochCounter,
IEpochActionManager::Action&& action) {
std::uint32_t index = ++m_counter & (m_epochToActionsList.size() - 1);
auto& epochToActions = m_epochToActionsList[index];
@ -42,14 +39,11 @@ void EpochActionManager::RegisterAction(std::uint64_t epochCounter, IEpochAction
std::get<1>(epochToActions)[epochCounter].emplace_back(std::move(action));
}
std::uint64_t EpochActionManager::PerformActions(std::uint64_t epochCounter)
{
std::uint64_t EpochActionManager::PerformActions(std::uint64_t epochCounter) {
// Actions will be moved here and performed without a lock.
Actions actionsToPerform;
for (auto& epochToActionsWithLock : m_epochToActionsList)
{
for (auto& epochToActionsWithLock : m_epochToActionsList) {
Lock lock(*std::get<0>(epochToActionsWithLock));
// lower_bound() so that it is deleted up to but not including epochCounter.
@ -58,14 +52,13 @@ std::uint64_t EpochActionManager::PerformActions(std::uint64_t epochCounter)
auto it = epochToActions.begin();
while (it != endIt)
{
actionsToPerform.insert(
actionsToPerform.end(),
while (it != endIt) {
actionsToPerform.insert(actionsToPerform.end(),
std::make_move_iterator(it->second.begin()),
std::make_move_iterator(it->second.end()));
// The following post increment is intentional to avoid iterator invalidation issue.
// The following post increment is intentional to avoid iterator
// invalidation issue.
epochToActions.erase(it++);
}
}
@ -75,11 +68,8 @@ std::uint64_t EpochActionManager::PerformActions(std::uint64_t epochCounter)
return actionsToPerform.size();
}
void EpochActionManager::ApplyActions(Actions& actions)
{
for (auto& action : actions)
{
void EpochActionManager::ApplyActions(Actions& actions) {
for (auto& action : actions) {
action();
}
}

128
src/Interprocess/Connection/ConnectionMonitor.cpp
Просмотреть файл

@ -1,53 +1,41 @@
#include "Interprocess/Connection/ConnectionMonitor.h"
#include <atomic>
#include "Interprocess/Connection/EndPointInfoUtils.h"
#include "Utils/Exception.h"
#include "Utils/Windows.h"
#include <atomic>
namespace L4
{
namespace Interprocess
{
namespace Connection
{
namespace L4 {
namespace Interprocess {
namespace Connection {
// ConnectionMonitor class implementation.
ConnectionMonitor::ConnectionMonitor()
: m_localEndPoint{ EndPointInfoFactory().Create() }
, m_localEvent{
::CreateEvent(
: m_localEndPoint{EndPointInfoFactory().Create()},
m_localEvent{::CreateEvent(
NULL,
TRUE, // Manual reset in order to notify all end points registered.
FALSE,
StringConverter()(m_localEndPoint).c_str()) }
{}
StringConverter()(m_localEndPoint).c_str())} {}
ConnectionMonitor::~ConnectionMonitor()
{
ConnectionMonitor::~ConnectionMonitor() {
// Notify the remote endpoints.
::SetEvent(static_cast<HANDLE>(m_localEvent));
}
const EndPointInfo& ConnectionMonitor::GetLocalEndPointInfo() const
{
const EndPointInfo& ConnectionMonitor::GetLocalEndPointInfo() const {
return m_localEndPoint;
}
std::size_t ConnectionMonitor::GetRemoteConnectionsCount() const
{
std::size_t ConnectionMonitor::GetRemoteConnectionsCount() const {
UnRegister();
std::lock_guard<std::mutex> lock(m_mutexOnRemoteMonitors);
return m_remoteMonitors.size();
}
void ConnectionMonitor::Register(const EndPointInfo& remoteEndPoint, Callback callback)
{
void ConnectionMonitor::Register(const EndPointInfo& remoteEndPoint,
Callback callback) {
UnRegister();
// The following is needed to prevent the case where the callback is trying
@ -62,110 +50,96 @@ void ConnectionMonitor::Register(const EndPointInfo& remoteEndPoint, Callback ca
// Note that the following call may throw since opening handles may fail, but
// it is exception safe (std::map::emplace has a strong guarantee on it).
if (!m_remoteMonitors.emplace(
remoteEndPoint,
if (!m_remoteMonitors
.emplace(remoteEndPoint,
std::make_unique<HandleMonitor>(
remoteEndPoint,
[thisWeakPtr, callback, isCalled](const auto& remoteEndPoint)
{
if (isCalled->exchange(true))
{
[thisWeakPtr, callback,
isCalled](const auto& remoteEndPoint) {
if (isCalled->exchange(true)) {
return;
}
callback(remoteEndPoint);
auto connectionMonitor = thisWeakPtr.lock();
if (connectionMonitor != nullptr)
{
// Cannot call UnRegister() because it will self-destruct.
// Instead, call the UnRegister(const EndPointInfo&) and queue up the end point
// that will be removed from m_remoteEvents at a later time.
if (connectionMonitor != nullptr) {
// Cannot call UnRegister() because it will
// self-destruct. Instead, call the UnRegister(const
// EndPointInfo&) and queue up the end point that
// will be removed from m_remoteEvents at a later
// time.
connectionMonitor->UnRegister(remoteEndPoint);
}
})).second)
{
}))
.second) {
throw RuntimeException("Duplicate end point found.");
}
}
void ConnectionMonitor::UnRegister(const EndPointInfo& remoteEndPoint)
{
void ConnectionMonitor::UnRegister(const EndPointInfo& remoteEndPoint) {
std::lock_guard<std::mutex> lock(m_mutexOnUnregisteredEndPoints);
m_unregisteredEndPoints.emplace_back(remoteEndPoint);
}
void ConnectionMonitor::UnRegister() const
{
void ConnectionMonitor::UnRegister() const {
std::vector<EndPointInfo> unregisteredEndPoints;
{
// It is possible that the erase() in the following block can
// wait for the callback to finish (::WaitForThreadpoolWaitCallbacks).
// Since the callback calls the UnRegister(const EndPointinfo&), it can deadlock
// if this function holds the lock while calling the erase().
// Thus, copy the m_unregisteredEndPoints and release the lock before calling erase() below.
// Since the callback calls the UnRegister(const EndPointinfo&), it can
// deadlock if this function holds the lock while calling the erase(). Thus,
// copy the m_unregisteredEndPoints and release the lock before calling
// erase() below.
std::lock_guard<std::mutex> lock(m_mutexOnUnregisteredEndPoints);
unregisteredEndPoints.swap(m_unregisteredEndPoints);
}
std::lock_guard<std::mutex> lock(m_mutexOnRemoteMonitors);
for (const auto& endPoint : unregisteredEndPoints)
{
for (const auto& endPoint : unregisteredEndPoints) {
m_remoteMonitors.erase(endPoint);
}
}
// ConnectionMonitor::HandleMonitor::HandleMonitor class implementation.
ConnectionMonitor::HandleMonitor::HandleMonitor(
const EndPointInfo& remoteEndPoint,
Callback callback)
: m_eventWaiter{
std::make_unique<Waiter>(
Utils::Handle{ ::OpenEvent(SYNCHRONIZE, FALSE, StringConverter()(remoteEndPoint).c_str()) },
[callback, endPoint = remoteEndPoint] { callback(endPoint); }) }
, m_processWaiter{
std::make_unique<Waiter>(
Utils::Handle{ ::OpenProcess(SYNCHRONIZE, FALSE, remoteEndPoint.m_pid) },
[callback, endPoint = remoteEndPoint] { callback(endPoint); }) }
{}
: m_eventWaiter{std::make_unique<Waiter>(
Utils::Handle{::OpenEvent(SYNCHRONIZE,
FALSE,
StringConverter()(remoteEndPoint).c_str())},
[callback, endPoint = remoteEndPoint] { callback(endPoint); })},
m_processWaiter{std::make_unique<Waiter>(
Utils::Handle{
::OpenProcess(SYNCHRONIZE, FALSE, remoteEndPoint.m_pid)},
[callback, endPoint = remoteEndPoint] { callback(endPoint); })} {}
// ConnectionMonitor::HandleMonitor::Waiter class implementation.
ConnectionMonitor::HandleMonitor::Waiter::Waiter(Utils::Handle handle, Callback callback)
: m_handle{ std::move(handle) }
, m_callback{ callback }
, m_wait{
::CreateThreadpoolWait(OnEvent, this, NULL),
::CloseThreadpoolWait }
{
ConnectionMonitor::HandleMonitor::Waiter::Waiter(Utils::Handle handle,
Callback callback)
: m_handle{std::move(handle)},
m_callback{callback},
m_wait{::CreateThreadpoolWait(OnEvent, this, NULL),
::CloseThreadpoolWait} {
::SetThreadpoolWait(m_wait.get(), static_cast<HANDLE>(m_handle), NULL);
}
ConnectionMonitor::HandleMonitor::Waiter::~Waiter()
{
ConnectionMonitor::HandleMonitor::Waiter::~Waiter() {
::SetThreadpoolWait(m_wait.get(), NULL, NULL);
::WaitForThreadpoolWaitCallbacks(m_wait.get(), TRUE);
}
VOID CALLBACK ConnectionMonitor::HandleMonitor::Waiter::OnEvent(
PTP_CALLBACK_INSTANCE /*instance*/,
PVOID context,
PTP_WAIT /*wait*/,
TP_WAIT_RESULT waitResult)
{
if (waitResult == WAIT_OBJECT_0)
{
TP_WAIT_RESULT waitResult) {
if (waitResult == WAIT_OBJECT_0) {
static_cast<Waiter*>(context)->m_callback();
}
else
{
} else {
throw std::runtime_error{"Unexpected wait result is received."};
}
}

29
src/Interprocess/Connection/EndPointInfoUtils.cpp
Просмотреть файл

@ -1,33 +1,24 @@
#include "Interprocess/Connection/EndPointInfoUtils.h"
#include "Utils/Windows.h"
#include <boost/uuid/random_generator.hpp>
#include <boost/uuid/uuid_io.hpp>
#include "Utils/Windows.h"
namespace L4
{
namespace Interprocess
{
namespace Connection
{
namespace L4 {
namespace Interprocess {
namespace Connection {
// EndPointInfoFactory class implementation.
EndPointInfo EndPointInfoFactory::Create() const
{
return EndPointInfo{ GetCurrentProcessId(), boost::uuids::random_generator()() };
EndPointInfo EndPointInfoFactory::Create() const {
return EndPointInfo{GetCurrentProcessId(),
boost::uuids::random_generator()()};
}
// StringConverter class implementation.
std::string StringConverter::operator()(const EndPointInfo& endPoint) const
{
return "[pid:"
+ std::to_string(endPoint.m_pid)
+ ","
+ "uuid:"
+ boost::uuids::to_string(endPoint.m_uuid)
+ "]";
std::string StringConverter::operator()(const EndPointInfo& endPoint) const {
return "[pid:" + std::to_string(endPoint.m_pid) + "," +
"uuid:" + boost::uuids::to_string(endPoint.m_uuid) + "]";
}
} // namespace Connection

33
src/Interprocess/Utils/Handle.cpp
Просмотреть файл

@ -1,39 +1,26 @@
#include "Interprocess/Utils/Handle.h"
#include "Utils/Exception.h"
#include <boost/format.hpp>
#include "Utils/Exception.h"
namespace L4
{
namespace Interprocess
{
namespace Utils
{
namespace L4 {
namespace Interprocess {
namespace Utils {
// Handle class implementation.
Handle::Handle(HANDLE handle, bool verifyHandle)
: m_handle{ Verify(handle, verifyHandle), ::CloseHandle }
{}
: m_handle{Verify(handle, verifyHandle), ::CloseHandle} {}
Handle::Handle(Handle&& other) : m_handle{std::move(other.m_handle)} {}
Handle::Handle(Handle&& other)
: m_handle{ std::move(other.m_handle) }
{}
Handle::operator HANDLE() const
{
Handle::operator HANDLE() const {
return m_handle.get();
}
HANDLE Handle::Verify(HANDLE handle, bool verifyHandle) const
{
if (handle == NULL || handle == INVALID_HANDLE_VALUE || verifyHandle)
{
HANDLE Handle::Verify(HANDLE handle, bool verifyHandle) const {
if (handle == NULL || handle == INVALID_HANDLE_VALUE || verifyHandle) {
auto error = ::GetLastError();
if (error != ERROR_SUCCESS)
{
if (error != ERROR_SUCCESS) {
boost::format err("Invalid handle: %1%.");
err % error;
throw RuntimeException(err.str());

16
src/PerfLogger.cpp
Просмотреть файл

@ -1,21 +1,17 @@
#include "Log/PerfLogger.h"
#include "Utils/Exception.h"
#include <boost/format.hpp>
#include "Utils/Exception.h"
namespace L4
{
namespace L4 {
// PerfData class implementation.
void PerfData::AddHashTablePerfData(const char* hashTableName, const HashTablePerfData& perfData)
{
void PerfData::AddHashTablePerfData(const char* hashTableName,
const HashTablePerfData& perfData) {
auto result = m_hashTablesPerfData.insert(
std::make_pair(
hashTableName,
HashTablesPerfData::mapped_type(perfData)));
std::make_pair(hashTableName, HashTablesPerfData::mapped_type(perfData)));
if (!result.second)
{
if (!result.second) {
boost::format err("Duplicate hash table name found: '%1%'.");
err % hashTableName;
throw RuntimeException(err.str());