Skip to content
Open
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
6 changes: 6 additions & 0 deletions mooncake-common/include/environment_variables.h
Original file line number Diff line number Diff line change
Expand Up @@ -191,6 +191,12 @@ struct FilereadWorkerPoolEnvironmentVariables {
MC_DEFINE_ENV_VAR(std::string, MC_FILEREAD_WORKERS);
};

struct NoFQosEnvironmentVariables {
// Preserve invalid-value warnings with their original input.
MC_DEFINE_ENV_VAR(std::string, MC_NOF_SUBMIT_CHUNK_BYTES);
MC_DEFINE_ENV_VAR(std::string, MC_NOF_INFLIGHT_BYTES_LIMIT);
};

struct NoFRegisterEnvironmentVariables {
// Keep the raw string to preserve case normalization and warning behavior.
MC_DEFINE_ENV_VAR(std::string, MC_NOF_TRTYPE);
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 @@ -109,6 +109,7 @@ set(MOONCAKE_STORE_CLIENT_SOURCES
nvme_kv/object_layout.cpp
transfer_task.cpp
config/fileread_worker_pool_config.cpp
config/nof_qos_config.cpp
posix_file.cpp
client_buffer.cpp
aligned_client_buffer.cpp
Expand Down
46 changes: 46 additions & 0 deletions mooncake-store/src/config/nof_qos_config.cpp
Original file line number Diff line number Diff line change
@@ -0,0 +1,46 @@
#include "nof_qos_config.h"

#include <glog/logging.h>

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

namespace mooncake {
namespace {

int PositiveBytesOrDefault(const EnvironmentVariable<std::string>& variable,
int default_value) {
const auto raw = Environ::Read(variable);
if (!raw || raw->empty()) {
return default_value;
}

const auto value = TryParseEnvironmentValue<int>(*raw);
if (value && *value > 0) {
return *value;
}
LOG(WARNING) << "Invalid value for " << variable.name << ": " << *raw
<< ", using default " << default_value;
return default_value;
}

} // namespace

NoFQosConfig NoFQosConfig::FromEnvironment() {
NoFQosConfig config;
config.submit_chunk_bytes = PositiveBytesOrDefault(
NoFQosEnvironmentVariables::MC_NOF_SUBMIT_CHUNK_BYTES,
config.submit_chunk_bytes);
config.inflight_bytes_limit = PositiveBytesOrDefault(
NoFQosEnvironmentVariables::MC_NOF_INFLIGHT_BYTES_LIMIT,
config.inflight_bytes_limit);
return config;
}

const NoFQosConfig& NoFQosConfig::AtFirstUse() {
static const auto config = FromEnvironment();
return config;
}

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

namespace mooncake {

struct NoFQosConfig {
int submit_chunk_bytes = 1 << 17;
int inflight_bytes_limit = 1 << 25;

static NoFQosConfig FromEnvironment();
static const NoFQosConfig& AtFirstUse();
};

} // namespace mooncake
20 changes: 4 additions & 16 deletions mooncake-store/src/transfer_task.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -14,6 +14,7 @@
#include <vector>
#include "config/transfer_submitter_config.h"
#include "config/fileread_worker_pool_config.h"
#include "config/nof_qos_config.h"
#include "device/accelerator_registry.h"
#include "transfer_engine.h"
#include "transport/transport.h"
Expand Down Expand Up @@ -76,19 +77,6 @@ static int GetSpdkNofDebugIntervalMs() {
return interval_ms;
}

static int GetSpdkNofSubmitChunkBytes() {
static const int value = GetPositiveEnvOrDefault(
"MC_NOF_SUBMIT_CHUNK_BYTES", mooncake::kDefaultSpdkNofSubmitChunkBytes);
return value;
}

static int GetSpdkNofInflightBytesLimit() {
static const int value =
GetPositiveEnvOrDefault("MC_NOF_INFLIGHT_BYTES_LIMIT",
mooncake::kDefaultSpdkNofInflightBytesLimit);
return value;
}

static int GetSpdkNofWorkerCount() {
static const int value = GetPositiveEnvOrDefault(
"MC_NOF_WORKERS", mooncake::kDefaultSpdkNofWorkers);
Expand Down Expand Up @@ -156,15 +144,15 @@ namespace mooncake {

#ifdef USE_NOF
SpdkNofQos::SpdkNofQos(uint32_t block_size) {
const auto& config = NoFQosConfig::AtFirstUse();
int block_size_int = static_cast<int>(block_size);
if (block_size_int <= 0) {
block_size_int = 1;
}

blocks_per_chunk =
std::max(1, GetSpdkNofSubmitChunkBytes() / block_size_int);
blocks_per_chunk = std::max(1, config.submit_chunk_bytes / block_size_int);
inflight_blocks_limit =
std::max(1, GetSpdkNofInflightBytesLimit() / block_size_int);
std::max(1, config.inflight_bytes_limit / block_size_int);
for (int i = 0; i < kSpdkNofOpNum; ++i) {
inflight_blocks[i] = 0;
head[i] = nullptr;
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_qos_config_test nof_qos_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
156 changes: 156 additions & 0 deletions mooncake-store/tests/nof_qos_config_test.cpp
Original file line number Diff line number Diff line change
@@ -0,0 +1,156 @@
#include <glog/logging.h>
#include <gtest/gtest.h>

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

#include "../src/config/nof_qos_config.h"
#ifdef USE_NOF
#include "transfer_task.h"
#endif

namespace mooncake {
namespace {

class NoFQosConfigTest : public ::testing::Test {
protected:
void SetUp() override {
google::InitGoogleLogging("NoFQosConfigTest");
original_logtostderr_ = FLAGS_logtostderr;
FLAGS_logtostderr = true;
for (size_t i = 0; i < 2; ++i) {
if (const char* value = std::getenv(names_[i])) {
original_[i] = value;
}
ASSERT_EQ(unsetenv(names_[i]), 0);
}
}

void TearDown() override {
for (size_t i = 0; i < 2; ++i) {
if (original_[i]) {
EXPECT_EQ(setenv(names_[i], original_[i]->c_str(), 1), 0);
} else {
EXPECT_EQ(unsetenv(names_[i]), 0);
}
}
FLAGS_logtostderr = original_logtostderr_;
google::ShutdownGoogleLogging();
}

private:
const char* names_[2] = {"MC_NOF_SUBMIT_CHUNK_BYTES",
"MC_NOF_INFLIGHT_BYTES_LIMIT"};
std::optional<std::string> original_[2];
bool original_logtostderr_ = false;
};

TEST_F(NoFQosConfigTest, UnsetAndEmptyKeepDefaultsSilently) {
testing::internal::CaptureStderr();
auto config = NoFQosConfig::FromEnvironment();
EXPECT_EQ(config.submit_chunk_bytes, 131072);
EXPECT_EQ(config.inflight_bytes_limit, 33554432);
EXPECT_TRUE(testing::internal::GetCapturedStderr().empty());

ASSERT_EQ(setenv("MC_NOF_SUBMIT_CHUNK_BYTES", "", 1), 0);
ASSERT_EQ(setenv("MC_NOF_INFLIGHT_BYTES_LIMIT", "", 1), 0);
testing::internal::CaptureStderr();
config = NoFQosConfig::FromEnvironment();
EXPECT_EQ(config.submit_chunk_bytes, 131072);
EXPECT_EQ(config.inflight_bytes_limit, 33554432);
EXPECT_TRUE(testing::internal::GetCapturedStderr().empty());
}

TEST_F(NoFQosConfigTest, FieldsParseIndependentlyIncludingWhitespace) {
ASSERT_EQ(setenv("MC_NOF_SUBMIT_CHUNK_BYTES", " +2048 ", 1), 0);
ASSERT_EQ(setenv("MC_NOF_INFLIGHT_BYTES_LIMIT", "2147483647", 1), 0);
testing::internal::CaptureStderr();
const auto config = NoFQosConfig::FromEnvironment();
EXPECT_EQ(config.submit_chunk_bytes, 2048);
EXPECT_EQ(config.inflight_bytes_limit, 2147483647);
EXPECT_TRUE(testing::internal::GetCapturedStderr().empty());
}

TEST_F(NoFQosConfigTest, InvalidFieldsWarnInOriginalOrderAndFallBack) {
ASSERT_EQ(setenv("MC_NOF_SUBMIT_CHUNK_BYTES", "0", 1), 0);
ASSERT_EQ(setenv("MC_NOF_INFLIGHT_BYTES_LIMIT", "2147483648", 1), 0);
testing::internal::CaptureStderr();
auto config = NoFQosConfig::FromEnvironment();
const auto log = testing::internal::GetCapturedStderr();
EXPECT_EQ(config.submit_chunk_bytes, 131072);
EXPECT_EQ(config.inflight_bytes_limit, 33554432);
const auto chunk = log.find(
"Invalid value for MC_NOF_SUBMIT_CHUNK_BYTES: 0, using default 131072");
const auto inflight = log.find(
"Invalid value for MC_NOF_INFLIGHT_BYTES_LIMIT: 2147483648, using "
"default 33554432");
ASSERT_NE(chunk, std::string::npos);
ASSERT_NE(inflight, std::string::npos);
EXPECT_LT(chunk, inflight);

ASSERT_EQ(setenv("MC_NOF_SUBMIT_CHUNK_BYTES", "19x", 1), 0);
ASSERT_EQ(setenv("MC_NOF_INFLIGHT_BYTES_LIMIT", "-1", 1), 0);
config = NoFQosConfig::FromEnvironment();
EXPECT_EQ(config.submit_chunk_bytes, 131072);
EXPECT_EQ(config.inflight_bytes_limit, 33554432);
}

TEST_F(NoFQosConfigTest, OneInvalidFieldDoesNotOverrideTheOther) {
ASSERT_EQ(setenv("MC_NOF_SUBMIT_CHUNK_BYTES", "-1", 1), 0);
ASSERT_EQ(setenv("MC_NOF_INFLIGHT_BYTES_LIMIT", "4096", 1), 0);
testing::internal::CaptureStderr();
auto config = NoFQosConfig::FromEnvironment();
const auto chunk_log = testing::internal::GetCapturedStderr();
EXPECT_EQ(config.submit_chunk_bytes, 131072);
EXPECT_EQ(config.inflight_bytes_limit, 4096);
EXPECT_NE(chunk_log.find("Invalid value for MC_NOF_SUBMIT_CHUNK_BYTES: -1"),
std::string::npos);
EXPECT_EQ(chunk_log.find("Invalid value for MC_NOF_INFLIGHT_BYTES_LIMIT"),
std::string::npos);

ASSERT_EQ(setenv("MC_NOF_SUBMIT_CHUNK_BYTES", "2048", 1), 0);
ASSERT_EQ(setenv("MC_NOF_INFLIGHT_BYTES_LIMIT", "bad", 1), 0);
testing::internal::CaptureStderr();
config = NoFQosConfig::FromEnvironment();
const auto inflight_log = testing::internal::GetCapturedStderr();
EXPECT_EQ(config.submit_chunk_bytes, 2048);
EXPECT_EQ(config.inflight_bytes_limit, 33554432);
EXPECT_EQ(inflight_log.find("Invalid value for MC_NOF_SUBMIT_CHUNK_BYTES"),
std::string::npos);
EXPECT_NE(
inflight_log.find("Invalid value for MC_NOF_INFLIGHT_BYTES_LIMIT: bad"),
std::string::npos);
}

TEST_F(NoFQosConfigTest, FreshReadsSeeUpdatesButFirstUseCachesBothFields) {
ASSERT_EQ(setenv("MC_NOF_SUBMIT_CHUNK_BYTES", "1000", 1), 0);
ASSERT_EQ(setenv("MC_NOF_INFLIGHT_BYTES_LIMIT", "4000", 1), 0);
EXPECT_EQ(NoFQosConfig::AtFirstUse().submit_chunk_bytes, 1000);
ASSERT_EQ(setenv("MC_NOF_SUBMIT_CHUNK_BYTES", "2000", 1), 0);
ASSERT_EQ(setenv("MC_NOF_INFLIGHT_BYTES_LIMIT", "8000", 1), 0);
const auto fresh = NoFQosConfig::FromEnvironment();
EXPECT_EQ(fresh.submit_chunk_bytes, 2000);
EXPECT_EQ(fresh.inflight_bytes_limit, 8000);
EXPECT_EQ(NoFQosConfig::AtFirstUse().submit_chunk_bytes, 1000);
EXPECT_EQ(NoFQosConfig::AtFirstUse().inflight_bytes_limit, 4000);
}

#ifdef USE_NOF
TEST_F(NoFQosConfigTest, QosDerivesLimitsFromBytesAndLiveBlockSize) {
ASSERT_EQ(setenv("MC_NOF_SUBMIT_CHUNK_BYTES", "1000", 1), 0);
ASSERT_EQ(setenv("MC_NOF_INFLIGHT_BYTES_LIMIT", "4000", 1), 0);
const SpdkNofQos first(512);
EXPECT_EQ(first.blocks_per_chunk, 1);
EXPECT_EQ(first.inflight_blocks_limit, 7);
ASSERT_EQ(setenv("MC_NOF_SUBMIT_CHUNK_BYTES", "2000", 1), 0);
ASSERT_EQ(setenv("MC_NOF_INFLIGHT_BYTES_LIMIT", "8000", 1), 0);
const SpdkNofQos second(1000);
EXPECT_EQ(second.blocks_per_chunk, 1);
EXPECT_EQ(second.inflight_blocks_limit, 4);
}
#endif

} // namespace
} // namespace mooncake
Loading