Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
7 changes: 7 additions & 0 deletions mooncake-common/include/environment_variables.h
Original file line number Diff line number Diff line change
Expand Up @@ -196,6 +196,13 @@ struct NoFRegisterEnvironmentVariables {
MC_DEFINE_ENV_VAR(std::string, MC_NOF_TRTYPE);
};

struct NoFDebugEnvironmentVariables {
// Preserve the legacy case-insensitive true tokens and strtol syntax;
// neither parser trims trailing whitespace.
MC_DEFINE_ENV_VAR(std::string, MC_NOF_DEBUG);
MC_DEFINE_ENV_VAR(std::string, MC_NOF_DEBUG_INTERVAL_MS);
};

struct SpdkControllerEnvironmentVariables {
MC_DEFINE_ENV_VAR(uint32_t, MC_NVME_NUM_IO_QUEUES);
MC_DEFINE_ENV_VAR(uint32_t, MC_NVME_IO_QUEUE_SIZE);
Expand Down
1 change: 1 addition & 0 deletions mooncake-store/src/CMakeLists.txt
Original file line number Diff line number Diff line change
Expand Up @@ -108,6 +108,7 @@ set(MOONCAKE_STORE_CLIENT_SOURCES
nvme_kv/key_conflict_policy.cpp
nvme_kv/object_layout.cpp
transfer_task.cpp
config/nof_debug_config.cpp
config/fileread_worker_pool_config.cpp
posix_file.cpp
client_buffer.cpp
Expand Down
53 changes: 53 additions & 0 deletions mooncake-store/src/config/nof_debug_config.cpp
Original file line number Diff line number Diff line change
@@ -0,0 +1,53 @@
#include "nof_debug_config.h"

#include <algorithm>
#include <cctype>
#include <cstdlib>
#include <string>

#include "environ.h"
#include "environment_variables.h"

namespace mooncake {

bool NoFDebugConfig::ReadEnabledFromEnvironment() {
const auto raw = Environ::Read(NoFDebugEnvironmentVariables::MC_NOF_DEBUG);
if (!raw) return false;

std::string normalized = *raw;
std::transform(
normalized.begin(), normalized.end(), normalized.begin(),
[](unsigned char c) { return static_cast<char>(std::tolower(c)); });
return normalized == "1" || normalized == "true" || normalized == "yes" ||
normalized == "on";
}

std::chrono::milliseconds NoFDebugConfig::ReadIntervalMsFromEnvironment() {
const auto raw =
Environ::Read(NoFDebugEnvironmentVariables::MC_NOF_DEBUG_INTERVAL_MS);
if (!raw) return std::chrono::milliseconds{1000};

char* end = nullptr;
const long parsed = std::strtol(raw->c_str(), &end, 10);
if (end == raw->c_str() || (end != nullptr && *end != '\0') ||
parsed <= 0) {
return std::chrono::milliseconds{1000};
}
return std::chrono::milliseconds{static_cast<int>(parsed)};
}

bool NoFDebugConfig::IsEnabledAtFirstUse() {
static const bool enabled = ReadEnabledFromEnvironment();
return enabled;
}

std::chrono::milliseconds NoFDebugConfig::IntervalMsAtFirstUse() {
static const auto interval_ms = ReadIntervalMsFromEnvironment();
return interval_ms;
}

NoFDebugConfig NoFDebugConfig::FromEnvironment() {
return {ReadEnabledFromEnvironment(), ReadIntervalMsFromEnvironment()};
}

} // namespace mooncake
20 changes: 20 additions & 0 deletions mooncake-store/src/config/nof_debug_config.h
Original file line number Diff line number Diff line change
@@ -0,0 +1,20 @@
#pragma once

#include <chrono>

namespace mooncake {

struct NoFDebugConfig {
bool enabled = false;
std::chrono::milliseconds interval_ms{1000};

static bool IsEnabledAtFirstUse();
static std::chrono::milliseconds IntervalMsAtFirstUse();
static NoFDebugConfig FromEnvironment();

private:
static bool ReadEnabledFromEnvironment();
static std::chrono::milliseconds ReadIntervalMsFromEnvironment();
};

} // namespace mooncake
35 changes: 5 additions & 30 deletions mooncake-store/src/transfer_task.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -13,6 +13,7 @@
#include <string>
#include <vector>
#include "config/transfer_submitter_config.h"
#include "config/nof_debug_config.h"
#include "config/fileread_worker_pool_config.h"
#include "device/accelerator_registry.h"
#include "transfer_engine.h"
Expand Down Expand Up @@ -42,38 +43,12 @@ static int GetPositiveEnvOrDefault(const char* name, int default_value) {
return static_cast<int>(parsed);
}

static bool IsTruthyEnv(const char* value) {
if (!value) {
return false;
}
std::string normalized(value);
std::transform(
normalized.begin(), normalized.end(), normalized.begin(),
[](unsigned char c) { return static_cast<char>(std::tolower(c)); });
return normalized == "1" || normalized == "true" || normalized == "yes" ||
normalized == "on";
}

static bool IsSpdkNofDebugEnabled() {
static const bool enabled = IsTruthyEnv(std::getenv("MC_NOF_DEBUG"));
return enabled;
return mooncake::NoFDebugConfig::IsEnabledAtFirstUse();
}

static int GetSpdkNofDebugIntervalMs() {
static const int interval_ms = []() {
const char* raw_value = std::getenv("MC_NOF_DEBUG_INTERVAL_MS");
if (!raw_value) {
return 1000;
}
char* end_ptr = nullptr;
long parsed = std::strtol(raw_value, &end_ptr, 10);
if (end_ptr == raw_value || (end_ptr != nullptr && *end_ptr != '\0') ||
parsed <= 0) {
return 1000;
}
return static_cast<int>(parsed);
}();
return interval_ms;
static std::chrono::milliseconds GetSpdkNofDebugIntervalMs() {
return mooncake::NoFDebugConfig::IntervalMsAtFirstUse();
}

static int GetSpdkNofSubmitChunkBytes() {
Expand Down Expand Up @@ -546,7 +521,7 @@ void SpdkNofWorkerPool::workerThread(int work_idx) {
auto elapsed =
std::chrono::duration_cast<std::chrono::milliseconds>(
now - last_debug_snapshot);
if (elapsed.count() >= GetSpdkNofDebugIntervalMs()) {
if (elapsed >= GetSpdkNofDebugIntervalMs()) {
for (const auto& [seg_handle, nof_qos] : seg_to_qos) {
LOG(INFO)
<< "nof_qos_state worker_idx=" << work_idx
Expand Down
1 change: 1 addition & 0 deletions mooncake-store/tests/CMakeLists.txt
Original file line number Diff line number Diff line change
Expand Up @@ -302,6 +302,7 @@ add_store_test(file_storage_test file_storage_test.cpp)
add_store_test(file_storage_config_test file_storage_config_test.cpp)
add_store_test(fileread_worker_pool_config_test
fileread_worker_pool_config_test.cpp)
add_store_test(nof_debug_config_test nof_debug_config_test.cpp)
add_store_test(fileread_worker_pool_test fileread_worker_pool_test.cpp)
if(MOONCAKE_OSS_ADAPTER_ENABLED)
target_compile_definitions(file_storage_test PRIVATE HAVE_OSS_ADAPTER)
Expand Down
112 changes: 112 additions & 0 deletions mooncake-store/tests/nof_debug_config_test.cpp
Original file line number Diff line number Diff line change
@@ -0,0 +1,112 @@
#include <gtest/gtest.h>

#include <cstdlib>
#include <chrono>
#include <optional>
#include <string>
#include <type_traits>
#include <utility>

#include "../src/config/nof_debug_config.h"

namespace mooncake {
namespace {

class ScopedEnvironment {
public:
explicit ScopedEnvironment(const char* name) : name_(name) {
if (const char* value = std::getenv(name)) original_ = value;
EXPECT_EQ(unsetenv(name), 0);
}
~ScopedEnvironment() {
if (original_) {
EXPECT_EQ(setenv(name_.c_str(), original_->c_str(), 1), 0);
} else {
EXPECT_EQ(unsetenv(name_.c_str()), 0);
}
}
void Set(const char* value) {
ASSERT_EQ(setenv(name_.c_str(), value, 1), 0);
}

private:
std::string name_;
std::optional<std::string> original_;
};

TEST(NoFDebugConfigTest, DefaultsWhenUnset) {
ScopedEnvironment enabled("MC_NOF_DEBUG");
ScopedEnvironment interval("MC_NOF_DEBUG_INTERVAL_MS");
const auto config = NoFDebugConfig::FromEnvironment();
EXPECT_FALSE(config.enabled);
EXPECT_EQ(config.interval_ms, std::chrono::milliseconds{1000});
}

TEST(NoFDebugConfigTest, ExposesTheIntervalAsMilliseconds) {
EXPECT_TRUE((std::is_same_v<decltype(NoFDebugConfig{}.interval_ms),
std::chrono::milliseconds>));
}

TEST(NoFDebugConfigTest, EachSettingKeepsItsOwnFirstUseSnapshot) {
ScopedEnvironment enabled("MC_NOF_DEBUG");
ScopedEnvironment interval("MC_NOF_DEBUG_INTERVAL_MS");
enabled.Set("yes");
interval.Set("2");
EXPECT_TRUE(NoFDebugConfig::IsEnabledAtFirstUse());
enabled.Set("off");
interval.Set("7");
EXPECT_EQ(NoFDebugConfig::IntervalMsAtFirstUse(),
std::chrono::milliseconds{7});
interval.Set("9");
EXPECT_TRUE(NoFDebugConfig::IsEnabledAtFirstUse());
EXPECT_EQ(NoFDebugConfig::IntervalMsAtFirstUse(),
std::chrono::milliseconds{7});
}

TEST(NoFDebugConfigTest, AcceptsOnlyLegacyTruthyTokens) {
ScopedEnvironment enabled("MC_NOF_DEBUG");
for (const char* value : {"1", "TRUE", "Yes", "On"}) {
enabled.Set(value);
EXPECT_TRUE(NoFDebugConfig::FromEnvironment().enabled) << value;
}
for (const char* value : {"", "0", " true ", "y", "off"}) {
enabled.Set(value);
EXPECT_FALSE(NoFDebugConfig::FromEnvironment().enabled) << value;
}
}

TEST(NoFDebugConfigTest, ParsesLegacyIntervalWithoutTrimming) {
ScopedEnvironment interval("MC_NOF_DEBUG_INTERVAL_MS");
for (const auto& [value, expected] :
{std::pair{"7", 7}, std::pair{"+7", 7}, std::pair{" 7", 7},
std::pair{"17", 17}}) {
interval.Set(value);
EXPECT_EQ(NoFDebugConfig::FromEnvironment().interval_ms,
std::chrono::milliseconds{expected})
<< value;
}
for (const char* value : {"", "0", "-2", "7 ", "7ms", "bad"}) {
interval.Set(value);
EXPECT_EQ(NoFDebugConfig::FromEnvironment().interval_ms,
std::chrono::milliseconds{1000})
<< value;
}
}

TEST(NoFDebugConfigTest, ReadsEachValueWhenRequested) {
ScopedEnvironment enabled("MC_NOF_DEBUG");
ScopedEnvironment interval("MC_NOF_DEBUG_INTERVAL_MS");
enabled.Set("1");
interval.Set("5");
const auto first = NoFDebugConfig::FromEnvironment();
EXPECT_TRUE(first.enabled);
EXPECT_EQ(first.interval_ms, std::chrono::milliseconds{5});
enabled.Set("0");
interval.Set("9");
const auto second = NoFDebugConfig::FromEnvironment();
EXPECT_FALSE(second.enabled);
EXPECT_EQ(second.interval_ms, std::chrono::milliseconds{9});
}

} // namespace
} // namespace mooncake
Loading