replace mutex locking with lock-free atomics instead;

pull/128/head
Bryan Biedenkapp 3 months ago
parent dea6d400db
commit 5e75b6b9e1

@ -41,16 +41,14 @@ static const uint64_t NS_PER_DAY = 86400ULL * NS_PER_SECOND;
// Static Class Members
// ---------------------------------------------------------------------------
int32_t TrafficNetwork::MetricsLogging::s_totalActiveCalls = 0;
uint64_t TrafficNetwork::MetricsLogging::s_totalCallsProcessed = 0U;
uint64_t TrafficNetwork::MetricsLogging::s_totalCallCollisions = 0U;
std::atomic<int32_t> TrafficNetwork::MetricsLogging::s_totalActiveCalls {0};
std::atomic<uint64_t> TrafficNetwork::MetricsLogging::s_totalCallsProcessed {0U};
std::atomic<uint64_t> TrafficNetwork::MetricsLogging::s_totalCallCollisions {0U};
namespace {
static const char* SQLITE_COUNTER_CALLS_PROCESSED = "total_calls_processed";
static const char* SQLITE_COUNTER_CALL_COLLISIONS = "total_call_collisions";
static std::mutex g_totalsMutex;
/**
* @brief Get the current time in nanoseconds since the epoch.
* @return The current time in nanoseconds since the epoch.
@ -195,7 +193,7 @@ namespace {
};
static std::mutex g_sqliteWriterStatesMutex;
static std::unordered_map<TrafficNetwork*, std::unique_ptr<SQLiteWriterState>> g_sqliteWriterStates;
static std::unordered_map<TrafficNetwork*, std::shared_ptr<SQLiteWriterState>> g_sqliteWriterStates;
// ---------------------------------------------------------------------------
// Global Functions
@ -573,21 +571,46 @@ namespace {
if (network == nullptr)
return;
std::unique_lock<std::mutex> stateLock(g_sqliteWriterStatesMutex);
auto it = g_sqliteWriterStates.find(network);
if (it == g_sqliteWriterStates.end() || it->second == nullptr) {
std::shared_ptr<SQLiteWriterState> state;
{
std::unique_lock<std::mutex> stateLock(g_sqliteWriterStatesMutex, std::try_to_lock);
if (!stateLock.owns_lock()) {
return;
}
auto it = g_sqliteWriterStates.find(network);
if (it == g_sqliteWriterStates.end() || it->second == nullptr) {
return;
}
state = it->second;
}
size_t queueDepth = 0U;
uint64_t droppedCount = 0U;
bool emitDropWarning = false;
std::unique_lock<std::mutex> lock(state->mutex, std::try_to_lock);
if (!lock.owns_lock()) {
return;
}
SQLiteWriterState* state = it->second.get();
stateLock.unlock();
if (state->stopRequested) {
return;
}
std::unique_lock<std::mutex> lock(state->mutex);
if (state->queue.size() >= SQLITE_MAX_QUEUE_DEPTH) {
state->droppedCount++;
if ((state->droppedCount % 1000U) == 1U) {
queueDepth = state->queue.size();
droppedCount = state->droppedCount;
emitDropWarning = true;
}
lock.unlock();
if (emitDropWarning) {
LogWarning(LOG_MASTER, "SQLite metrics queue full (%zu), dropped %llu events",
state->queue.size(), (unsigned long long)state->droppedCount);
queueDepth, (unsigned long long)droppedCount);
}
return;
}
@ -767,7 +790,7 @@ void TrafficNetwork::MetricsLogging::initialize(TrafficNetwork* network)
std::unique_lock<std::mutex> lock(g_sqliteWriterStatesMutex);
auto it = g_sqliteWriterStates.find(network);
if (it == g_sqliteWriterStates.end()) {
auto state = std::unique_ptr<SQLiteWriterState>(new SQLiteWriterState());
auto state = std::make_shared<SQLiteWriterState>();
if (!prepareStatements(network->m_sqliteDB, state->statements)) {
LogError(LOG_MASTER, "Failed to prepare SQLite metrics statements: %s", sqlite3_errmsg(network->m_sqliteDB));
finalizeStatements(state->statements);
@ -806,7 +829,7 @@ void TrafficNetwork::MetricsLogging::finalize(TrafficNetwork* network)
if (network == nullptr)
return;
std::unique_ptr<SQLiteWriterState> state;
std::shared_ptr<SQLiteWriterState> state;
// scope is intentional
{
@ -854,8 +877,7 @@ void TrafficNetwork::MetricsLogging::incrementActiveCalls(TrafficNetwork* networ
{
(void)network;
std::lock_guard<std::mutex> lock(g_totalsMutex);
s_totalActiveCalls++;
s_totalActiveCalls.fetch_add(1, std::memory_order_relaxed);
}
/* Decrements the active call counter with floor at zero. */
@ -864,10 +886,11 @@ void TrafficNetwork::MetricsLogging::decrementActiveCalls(TrafficNetwork* networ
{
(void)network;
std::lock_guard<std::mutex> lock(g_totalsMutex);
s_totalActiveCalls--;
if (s_totalActiveCalls < 0) {
s_totalActiveCalls = 0;
int32_t expected = s_totalActiveCalls.load(std::memory_order_relaxed);
while (expected > 0) {
if (s_totalActiveCalls.compare_exchange_weak(expected, expected - 1, std::memory_order_relaxed)) {
return;
}
}
}
@ -875,20 +898,14 @@ void TrafficNetwork::MetricsLogging::decrementActiveCalls(TrafficNetwork* networ
void TrafficNetwork::MetricsLogging::resetActiveCalls()
{
std::lock_guard<std::mutex> lock(g_totalsMutex);
s_totalActiveCalls = 0;
s_totalActiveCalls.store(0, std::memory_order_relaxed);
}
/* Increments the total processed calls counter. */
void TrafficNetwork::MetricsLogging::incrementCallsProcessed(TrafficNetwork* network)
{
uint64_t value = 0U;
{
std::lock_guard<std::mutex> lock(g_totalsMutex);
s_totalCallsProcessed++;
value = s_totalCallsProcessed;
}
uint64_t value = s_totalCallsProcessed.fetch_add(1U, std::memory_order_relaxed) + 1U;
persistSQLiteCounter(network, SQLITE_COUNTER_CALLS_PROCESSED, value);
}
@ -897,12 +914,7 @@ void TrafficNetwork::MetricsLogging::incrementCallsProcessed(TrafficNetwork* net
void TrafficNetwork::MetricsLogging::incrementCallCollisions(TrafficNetwork* network)
{
uint64_t value = 0U;
{
std::lock_guard<std::mutex> lock(g_totalsMutex);
s_totalCallCollisions++;
value = s_totalCallCollisions;
}
uint64_t value = s_totalCallCollisions.fetch_add(1U, std::memory_order_relaxed) + 1U;
persistSQLiteCounter(network, SQLITE_COUNTER_CALL_COLLISIONS, value);
}
@ -911,10 +923,7 @@ void TrafficNetwork::MetricsLogging::incrementCallCollisions(TrafficNetwork* net
void TrafficNetwork::MetricsLogging::resetCallsProcessed(TrafficNetwork* network)
{
{
std::lock_guard<std::mutex> lock(g_totalsMutex);
s_totalCallsProcessed = 0U;
}
s_totalCallsProcessed.store(0U, std::memory_order_relaxed);
persistSQLiteCounter(network, SQLITE_COUNTER_CALLS_PROCESSED, 0U);
}
@ -923,10 +932,7 @@ void TrafficNetwork::MetricsLogging::resetCallsProcessed(TrafficNetwork* network
void TrafficNetwork::MetricsLogging::resetCallCollisions(TrafficNetwork* network)
{
{
std::lock_guard<std::mutex> lock(g_totalsMutex);
s_totalCallCollisions = 0U;
}
s_totalCallCollisions.store(0U, std::memory_order_relaxed);
persistSQLiteCounter(network, SQLITE_COUNTER_CALL_COLLISIONS, 0U);
}
@ -935,21 +941,21 @@ void TrafficNetwork::MetricsLogging::resetCallCollisions(TrafficNetwork* network
int32_t TrafficNetwork::MetricsLogging::getTotalActiveCalls()
{
return s_totalActiveCalls;
return s_totalActiveCalls.load(std::memory_order_relaxed);
}
/* Gets the total processed calls counter. */
uint64_t TrafficNetwork::MetricsLogging::getTotalCallsProcessed()
{
return s_totalCallsProcessed;
return s_totalCallsProcessed.load(std::memory_order_relaxed);
}
/* Gets the total call collisions counter. */
uint64_t TrafficNetwork::MetricsLogging::getTotalCallCollisions()
{
return s_totalCallCollisions;
return s_totalCallCollisions.load(std::memory_order_relaxed);
}
/* Logs a activity transfer event. */
@ -1433,12 +1439,11 @@ void TrafficNetwork::MetricsLogging::loadSQLiteCounters(TrafficNetwork* network)
sqlite3_finalize(stmt);
std::lock_guard<std::mutex> lock(g_totalsMutex);
if (hasProcessed) {
s_totalCallsProcessed = loadedProcessed;
s_totalCallsProcessed.store(loadedProcessed, std::memory_order_relaxed);
}
if (hasCollisions) {
s_totalCallCollisions = loadedCollisions;
s_totalCallCollisions.store(loadedCollisions, std::memory_order_relaxed);
}
}

@ -50,6 +50,7 @@
#include <unordered_map>
#include <memory>
#include <mutex>
#include <atomic>
#include <array>
// ---------------------------------------------------------------------------
@ -1150,9 +1151,9 @@ namespace network
static void logCSBKEvent(TrafficNetwork* network, uint32_t peerId, const std::string& lco, const std::string& csbk, const std::string& raw);
private:
static int32_t s_totalActiveCalls;
static uint64_t s_totalCallsProcessed;
static uint64_t s_totalCallCollisions;
static std::atomic<int32_t> s_totalActiveCalls;
static std::atomic<uint64_t> s_totalCallsProcessed;
static std::atomic<uint64_t> s_totalCallCollisions;
/**
* @brief Checks if the SQLite database for the specified TrafficNetwork instance is blank.

Loading…
Cancel
Save

Powered by TurnKey Linux.