Realisation v1
This commit is contained in:
Efim Beshmenev
@@ -0,0 +1,732 @@
|
||||
#pragma once
|
||||
|
||||
#include "universal_container/tiered_storage.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
#include <array>
|
||||
#include <bit>
|
||||
#include <cmath>
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <limits>
|
||||
#include <optional>
|
||||
#include <utility>
|
||||
|
||||
namespace uc {
|
||||
|
||||
enum class StorageMode : std::uint8_t {
|
||||
vector,
|
||||
tiered
|
||||
};
|
||||
|
||||
enum class ResidencyMode : std::uint8_t {
|
||||
automatic,
|
||||
forced_vector,
|
||||
forced_tiered
|
||||
};
|
||||
|
||||
// Deferred is the safe default: reads collect statistics, but a representation
|
||||
// change is performed only at a mutation boundary or by adapt_now(). Eager is
|
||||
// retained as an explicitly unsafe experiment for non-const reads.
|
||||
enum class ReadAdaptationMode : std::uint8_t {
|
||||
deferred,
|
||||
eager_nonconst
|
||||
};
|
||||
|
||||
enum class OperationKind : std::uint8_t {
|
||||
random_read,
|
||||
sequential_read,
|
||||
append,
|
||||
insert,
|
||||
erase,
|
||||
set
|
||||
};
|
||||
|
||||
struct OperationSample {
|
||||
OperationKind kind = OperationKind::random_read;
|
||||
std::size_t size = 0;
|
||||
std::size_t position = 0;
|
||||
std::size_t count = 1;
|
||||
std::size_t element_bytes = 4;
|
||||
};
|
||||
|
||||
struct AdaptationDecision {
|
||||
StorageMode target = StorageMode::vector;
|
||||
TieredConfig tiered_config{};
|
||||
double expected_saving = 0.0;
|
||||
};
|
||||
|
||||
struct AdaptationConfig {
|
||||
// Selected by the paired aggressive/moderate/balanced benchmark: this
|
||||
// reacts early in a sustained edit phase but leaves a 128-edit negative
|
||||
// control in vector mode.
|
||||
std::size_t evaluation_interval = 256;
|
||||
std::size_t minimum_observations = 2048;
|
||||
std::size_t edit_evaluation_interval = 32;
|
||||
std::size_t minimum_edit_observations = 128;
|
||||
std::size_t minimum_tiered_size = 8 * 1024;
|
||||
// The forecast is deliberately bounded by both evidence accumulated in
|
||||
// the current residency and this hard ceiling. Treating the ceiling as a
|
||||
// guaranteed future phase length makes short edit bursts look much more
|
||||
// profitable than they really are.
|
||||
std::size_t forecast_operations = 128 * 1024;
|
||||
std::size_t minimum_forecast_operations = 256;
|
||||
double forecast_growth_factor = 8.0;
|
||||
// A sampled read carries `count = read_sample_rate`, so the statistical
|
||||
// weight is preserved while the hot operator[] path pays the full policy
|
||||
// update only once per cache-line-sized batch of accesses.
|
||||
std::size_t read_sample_rate = 256;
|
||||
// Structural samples retain their aggregate weight. Sampling every edit
|
||||
// made the replaceable policy itself a visible part of edit latency.
|
||||
std::size_t edit_sample_rate = 4;
|
||||
std::size_t minimum_residency_operations = 256;
|
||||
// Storage-mode hysteresis uses the edit share of the workload EWMA. The
|
||||
// wider entry threshold and narrower exit threshold form a Schmitt trigger:
|
||||
// a tiered sequence is not converted back to vector while edits are still
|
||||
// a material part of the current phase.
|
||||
double tiered_entry_edit_fraction = 0.05;
|
||||
double tiered_exit_edit_fraction = 0.01;
|
||||
std::size_t required_confirmation_windows = 2;
|
||||
// Shape changes are independent from storage-mode changes. They need a
|
||||
// longer residency and an edit-heavy phase because changing leaf capacity
|
||||
// is itself a full O(N) rebuild.
|
||||
std::size_t minimum_shape_residency_operations = 4 * 1024;
|
||||
double minimum_shape_edit_fraction = 0.10;
|
||||
std::size_t locality_radius_divisor = 50;
|
||||
std::size_t maximum_directory_levels = 4;
|
||||
double vector_to_tiered_safety = 1.50;
|
||||
double tiered_to_vector_safety = 2.00;
|
||||
double tiered_rebuild_safety = 2.50;
|
||||
// A leaf rebuild needs a material advantage over the incumbent, not merely
|
||||
// to win a noisy window. Directory-only changes still have their much
|
||||
// smaller rebuild cost, but use the same relative stability guard.
|
||||
double minimum_shape_improvement = 0.15;
|
||||
double ewma_alpha = 0.35;
|
||||
|
||||
// The search space is data, not a hard-coded branch in the container. A
|
||||
// different policy/config can replace it without touching storage code.
|
||||
std::array<std::size_t, 5> tiered_leaf_candidates{64, 128, 256, 512, 1024};
|
||||
|
||||
// Calibratable cost units. The leaf movement term grows with B, while the
|
||||
// directory/fragmentation term grows with N/B. Their intersection is why
|
||||
// the selected block size changes with both N and edit locality.
|
||||
double vector_read = 1.0;
|
||||
double tiered_read_base = 12.0;
|
||||
double tiered_read_per_level = 2.0;
|
||||
double tiered_lookup_per_log_top = 1.20;
|
||||
double vector_scan_element = 0.70;
|
||||
double tiered_scan_element = 0.92;
|
||||
double tiered_scan_boundary = 12.0;
|
||||
double vector_append = 2.0;
|
||||
double tiered_append = 2.8;
|
||||
double vector_edit_fixed = 6.0;
|
||||
double tiered_edit_fixed = 30.0;
|
||||
double vector_move_unit = 0.025;
|
||||
double tiered_move_unit = 4.0;
|
||||
double tiered_directory_unit = 0.65;
|
||||
double localized_directory_multiplier = 0.15;
|
||||
double conversion_unit_per_element = 1.0;
|
||||
double directory_rebuild_unit_per_leaf = 8.0;
|
||||
};
|
||||
|
||||
struct AdaptationTelemetry {
|
||||
std::uint64_t observed_operations = 0;
|
||||
std::uint64_t sampled_reads = 0;
|
||||
std::uint64_t evaluations = 0;
|
||||
std::uint64_t vector_to_tiered = 0;
|
||||
std::uint64_t tiered_to_vector = 0;
|
||||
std::uint64_t tiered_rebuilds = 0;
|
||||
std::uint64_t tiered_leaf_rebuilds = 0;
|
||||
std::uint64_t tiered_directory_rebuilds = 0;
|
||||
std::size_t last_recommended_leaf = 0;
|
||||
std::size_t last_recommended_levels = 0;
|
||||
double last_vector_cost_per_operation = 0.0;
|
||||
double last_tiered_cost_per_operation = 0.0;
|
||||
double last_current_cost_per_operation = 0.0;
|
||||
double last_expected_saving = 0.0;
|
||||
double last_conversion_cost = 0.0;
|
||||
double last_local_edit_fraction = 0.0;
|
||||
double last_edit_fraction = 0.0;
|
||||
std::size_t last_forecast_operations = 0;
|
||||
std::size_t last_evidence_windows = 0;
|
||||
};
|
||||
|
||||
class CostModelPolicy {
|
||||
public:
|
||||
static constexpr std::size_t candidate_count = 5;
|
||||
|
||||
explicit CostModelPolicy(AdaptationConfig config = {}, TieredConfig tiered = {})
|
||||
: config_(normalize(config)), active_tiered_(normalize_tiered(tiered)),
|
||||
search_fanout_(active_tiered_.directory_fanout),
|
||||
search_max_levels_(config_.maximum_directory_levels) {}
|
||||
|
||||
void set_tiered_config(TieredConfig tiered) noexcept {
|
||||
active_tiered_ = normalize_tiered(tiered);
|
||||
search_fanout_ = active_tiered_.directory_fanout;
|
||||
search_max_levels_ = config_.maximum_directory_levels;
|
||||
}
|
||||
|
||||
void observe(const OperationSample& sample) noexcept {
|
||||
const auto count = static_cast<double>(std::max<std::size_t>(1, sample.count));
|
||||
last_element_bytes_ = std::max<std::size_t>(1, sample.element_bytes);
|
||||
last_observed_size_ = sample.size;
|
||||
operations_since_transition_ += sample.count;
|
||||
operations_since_shape_transition_ += sample.count;
|
||||
telemetry_.observed_operations += sample.count;
|
||||
if (sample.kind == OperationKind::random_read) {
|
||||
++telemetry_.sampled_reads;
|
||||
}
|
||||
|
||||
const bool edit = is_edit(sample.kind);
|
||||
// In vector mode, reads/appends cannot make tiered storage preferable.
|
||||
// Before the first relevant edit (or below the measured small-size
|
||||
// threshold), avoid evaluating all five counterfactual shapes in the
|
||||
// hot path. Once edits exist, sampled reads are evaluated normally so
|
||||
// that a short burst can be rejected rather than converted later.
|
||||
if (active_mode_ == StorageMode::vector
|
||||
&& (sample.size < config_.minimum_tiered_size
|
||||
|| (!edit && total_edit_weight_ == 0.0
|
||||
&& window_edit_weight_ == 0.0
|
||||
&& !decision_ready_ && !pending_decision_))) {
|
||||
return;
|
||||
}
|
||||
|
||||
const bool localized = classify_edit_locality(sample);
|
||||
|
||||
window_vector_cost_ += estimate_vector(sample);
|
||||
window_active_tiered_cost_ += estimate_tiered(sample, active_tiered_, localized);
|
||||
for (std::size_t i = 0; i < candidate_count; ++i) {
|
||||
window_candidate_costs_[i] += estimate_tiered(
|
||||
sample, candidate_config(i, sample.size), localized);
|
||||
}
|
||||
window_weight_ += count;
|
||||
if (edit) {
|
||||
window_edit_weight_ += count;
|
||||
total_edit_weight_ += count;
|
||||
if (localized) {
|
||||
window_local_edit_weight_ += count;
|
||||
}
|
||||
}
|
||||
|
||||
if (window_weight_ >= static_cast<double>(config_.evaluation_interval)
|
||||
|| window_edit_weight_ >= static_cast<double>(
|
||||
config_.edit_evaluation_interval)) {
|
||||
close_window();
|
||||
}
|
||||
}
|
||||
|
||||
[[nodiscard]] bool decision_ready() const noexcept { return decision_ready_; }
|
||||
|
||||
[[nodiscard]] std::optional<AdaptationDecision>
|
||||
recommended_decision(StorageMode current,
|
||||
std::size_t size,
|
||||
TieredConfig current_config) noexcept {
|
||||
active_mode_ = current;
|
||||
if (!decision_ready_) {
|
||||
return std::nullopt;
|
||||
}
|
||||
const auto evidence_windows = closed_windows_since_decision_;
|
||||
decision_ready_ = false;
|
||||
closed_windows_since_decision_ = 0;
|
||||
++telemetry_.evaluations;
|
||||
telemetry_.last_evidence_windows = evidence_windows;
|
||||
const auto evaluation = evaluate_decision(current, size, current_config);
|
||||
telemetry_.last_vector_cost_per_operation = evaluation.vector_cost;
|
||||
telemetry_.last_tiered_cost_per_operation = evaluation.best_tiered_cost;
|
||||
telemetry_.last_current_cost_per_operation = evaluation.current_cost;
|
||||
telemetry_.last_recommended_leaf = evaluation.best_config.leaf_capacity;
|
||||
telemetry_.last_recommended_levels = evaluation.best_config.directory_levels;
|
||||
telemetry_.last_conversion_cost = evaluation.selected_rebuild_cost;
|
||||
telemetry_.last_expected_saving = evaluation.decision
|
||||
? evaluation.decision->expected_saving : 0.0;
|
||||
telemetry_.last_forecast_operations = evaluation.forecast_operations;
|
||||
telemetry_.last_edit_fraction = ewma_edit_fraction_;
|
||||
|
||||
return confirm(evaluation.decision);
|
||||
}
|
||||
|
||||
// Compatibility with simpler storage wrappers: this intentionally loses a
|
||||
// same-mode tiered shape recommendation.
|
||||
[[nodiscard]] std::optional<StorageMode>
|
||||
recommended_mode(StorageMode current, std::size_t size) noexcept {
|
||||
const auto decision = recommended_decision(current, size, active_tiered_);
|
||||
return decision ? std::optional<StorageMode>(decision->target) : std::nullopt;
|
||||
}
|
||||
|
||||
void on_transition(StorageMode from,
|
||||
StorageMode to,
|
||||
TieredConfig active_config) noexcept {
|
||||
if (from == StorageMode::vector && to == StorageMode::tiered) {
|
||||
++telemetry_.vector_to_tiered;
|
||||
} else if (from == StorageMode::tiered && to == StorageMode::vector) {
|
||||
++telemetry_.tiered_to_vector;
|
||||
} else if (from == StorageMode::tiered && to == StorageMode::tiered) {
|
||||
++telemetry_.tiered_rebuilds;
|
||||
if (normalize_tiered(active_config).leaf_capacity
|
||||
== active_tiered_.leaf_capacity) {
|
||||
++telemetry_.tiered_directory_rebuilds;
|
||||
} else {
|
||||
++telemetry_.tiered_leaf_rebuilds;
|
||||
}
|
||||
}
|
||||
const auto normalized_active = normalize_tiered(active_config);
|
||||
if (to == StorageMode::tiered) {
|
||||
synchronize_active_tiered_ewma(normalized_active);
|
||||
}
|
||||
active_tiered_ = normalized_active;
|
||||
active_mode_ = to;
|
||||
clear_transition_evidence();
|
||||
}
|
||||
|
||||
void on_transition(StorageMode from, StorageMode to) noexcept {
|
||||
on_transition(from, to, active_tiered_);
|
||||
}
|
||||
|
||||
void reset() noexcept {
|
||||
const auto active = active_tiered_;
|
||||
const auto mode = active_mode_;
|
||||
const auto fanout = search_fanout_;
|
||||
const auto levels = search_max_levels_;
|
||||
*this = CostModelPolicy(config_, active);
|
||||
active_mode_ = mode;
|
||||
search_fanout_ = fanout;
|
||||
search_max_levels_ = levels;
|
||||
}
|
||||
|
||||
[[nodiscard]] const AdaptationConfig& config() const noexcept { return config_; }
|
||||
[[nodiscard]] const AdaptationTelemetry& telemetry() const noexcept { return telemetry_; }
|
||||
|
||||
private:
|
||||
static bool is_edit(OperationKind kind) noexcept {
|
||||
return kind == OperationKind::insert || kind == OperationKind::erase;
|
||||
}
|
||||
|
||||
static TieredConfig normalize_tiered(TieredConfig config) noexcept {
|
||||
config.leaf_capacity = std::clamp<std::size_t>(config.leaf_capacity, 4, 1U << 20U);
|
||||
config.directory_fanout = std::clamp<std::size_t>(
|
||||
config.directory_fanout, 2, 1U << 16U);
|
||||
config.directory_levels = std::clamp<std::size_t>(config.directory_levels, 1, 8);
|
||||
return config;
|
||||
}
|
||||
|
||||
static AdaptationConfig normalize(AdaptationConfig config) noexcept {
|
||||
config.evaluation_interval = std::max<std::size_t>(16, config.evaluation_interval);
|
||||
config.minimum_observations = std::max(config.evaluation_interval,
|
||||
config.minimum_observations);
|
||||
config.edit_evaluation_interval = std::max<std::size_t>(8,
|
||||
config.edit_evaluation_interval);
|
||||
config.minimum_edit_observations = std::max(
|
||||
config.edit_evaluation_interval, config.minimum_edit_observations);
|
||||
config.forecast_operations = std::max<std::size_t>(1, config.forecast_operations);
|
||||
config.minimum_forecast_operations = std::clamp<std::size_t>(
|
||||
config.minimum_forecast_operations, 1, config.forecast_operations);
|
||||
config.forecast_growth_factor = std::max(1.0, config.forecast_growth_factor);
|
||||
config.read_sample_rate = std::max<std::size_t>(1, config.read_sample_rate);
|
||||
config.edit_sample_rate = std::max<std::size_t>(1, config.edit_sample_rate);
|
||||
config.tiered_entry_edit_fraction = std::clamp(
|
||||
config.tiered_entry_edit_fraction, 0.0, 1.0);
|
||||
config.tiered_exit_edit_fraction = std::clamp(
|
||||
config.tiered_exit_edit_fraction, 0.0,
|
||||
config.tiered_entry_edit_fraction);
|
||||
config.required_confirmation_windows = std::max<std::size_t>(
|
||||
1, config.required_confirmation_windows);
|
||||
config.minimum_shape_edit_fraction = std::clamp(
|
||||
config.minimum_shape_edit_fraction, 0.0, 1.0);
|
||||
config.locality_radius_divisor = std::max<std::size_t>(1,
|
||||
config.locality_radius_divisor);
|
||||
config.maximum_directory_levels = std::clamp<std::size_t>(
|
||||
config.maximum_directory_levels, 1, 8);
|
||||
config.minimum_shape_improvement = std::clamp(
|
||||
config.minimum_shape_improvement, 0.0, 1.0);
|
||||
config.ewma_alpha = std::clamp(config.ewma_alpha, 0.01, 1.0);
|
||||
for (auto& leaf : config.tiered_leaf_candidates) {
|
||||
leaf = std::clamp<std::size_t>(leaf, 4, 1U << 20U);
|
||||
}
|
||||
std::sort(config.tiered_leaf_candidates.begin(),
|
||||
config.tiered_leaf_candidates.end());
|
||||
return config;
|
||||
}
|
||||
|
||||
[[nodiscard]] std::size_t actual_levels(std::size_t size,
|
||||
std::size_t leaf,
|
||||
std::size_t fanout,
|
||||
std::size_t maximum) const noexcept {
|
||||
auto nodes = (size + leaf - 1) / leaf;
|
||||
std::size_t levels = 1;
|
||||
while (nodes > fanout && levels < maximum) {
|
||||
nodes = (nodes + fanout - 1) / fanout;
|
||||
++levels;
|
||||
}
|
||||
return levels;
|
||||
}
|
||||
|
||||
[[nodiscard]] TieredConfig candidate_config(std::size_t index,
|
||||
std::size_t size) const noexcept {
|
||||
const auto leaf = config_.tiered_leaf_candidates[index];
|
||||
return {leaf, search_fanout_,
|
||||
actual_levels(size, leaf, search_fanout_, search_max_levels_)};
|
||||
}
|
||||
|
||||
bool classify_edit_locality(const OperationSample& sample) noexcept {
|
||||
if (!is_edit(sample.kind)) {
|
||||
return false;
|
||||
}
|
||||
bool localized = false;
|
||||
if (has_last_edit_) {
|
||||
const auto distance = sample.position > last_edit_position_
|
||||
? sample.position - last_edit_position_
|
||||
: last_edit_position_ - sample.position;
|
||||
const auto radius = std::max<std::size_t>(
|
||||
32, sample.size / config_.locality_radius_divisor);
|
||||
localized = distance <= radius;
|
||||
}
|
||||
last_edit_position_ = sample.position;
|
||||
has_last_edit_ = true;
|
||||
return localized;
|
||||
}
|
||||
|
||||
[[nodiscard]] double estimate_vector(const OperationSample& sample) const noexcept {
|
||||
const auto count = static_cast<double>(std::max<std::size_t>(1, sample.count));
|
||||
switch (sample.kind) {
|
||||
case OperationKind::random_read:
|
||||
return config_.vector_read * count;
|
||||
case OperationKind::sequential_read:
|
||||
return config_.vector_scan_element * count;
|
||||
case OperationKind::append:
|
||||
return config_.vector_append * count;
|
||||
case OperationKind::set:
|
||||
return config_.vector_read * 1.3 * count;
|
||||
case OperationKind::insert:
|
||||
case OperationKind::erase: {
|
||||
const auto width_scale = std::max(1.0,
|
||||
static_cast<double>(sample.element_bytes) / sizeof(std::uint32_t));
|
||||
const auto tail = sample.position < sample.size
|
||||
? sample.size - sample.position : 0;
|
||||
return (config_.vector_edit_fixed
|
||||
+ config_.vector_move_unit * width_scale * static_cast<double>(tail))
|
||||
* count;
|
||||
}
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
[[nodiscard]] double estimate_tiered(const OperationSample& sample,
|
||||
TieredConfig tiered,
|
||||
bool localized) const noexcept {
|
||||
tiered = normalize_tiered(tiered);
|
||||
const auto count = static_cast<double>(std::max<std::size_t>(1, sample.count));
|
||||
const auto leaf_count = std::max<std::size_t>(
|
||||
1, (sample.size + tiered.leaf_capacity - 1) / tiered.leaf_capacity);
|
||||
const auto level_count = actual_levels(
|
||||
sample.size, tiered.leaf_capacity, tiered.directory_fanout,
|
||||
tiered.directory_levels);
|
||||
auto top_nodes = leaf_count;
|
||||
for (std::size_t level = 1; level < level_count; ++level) {
|
||||
top_nodes = (top_nodes + tiered.directory_fanout - 1)
|
||||
/ tiered.directory_fanout;
|
||||
}
|
||||
const auto levels = static_cast<double>(level_count);
|
||||
const auto top_log2 = top_nodes <= 1 ? 0.0 : static_cast<double>(
|
||||
std::bit_width(top_nodes) - 1U);
|
||||
const auto lookup = config_.tiered_read_base
|
||||
+ config_.tiered_read_per_level * levels
|
||||
+ config_.tiered_lookup_per_log_top * top_log2;
|
||||
switch (sample.kind) {
|
||||
case OperationKind::random_read:
|
||||
return lookup * count;
|
||||
case OperationKind::sequential_read:
|
||||
return (config_.tiered_scan_element
|
||||
+ config_.tiered_scan_boundary
|
||||
/ static_cast<double>(tiered.leaf_capacity)) * count;
|
||||
case OperationKind::append:
|
||||
return (config_.tiered_append
|
||||
+ 8.0 / static_cast<double>(tiered.leaf_capacity)) * count;
|
||||
case OperationKind::set:
|
||||
return lookup * 1.3 * count;
|
||||
case OperationKind::insert:
|
||||
case OperationKind::erase: {
|
||||
const auto width_scale = std::max(1.0,
|
||||
static_cast<double>(sample.element_bytes) / sizeof(std::uint32_t));
|
||||
const auto local = sample.position % tiered.leaf_capacity;
|
||||
const auto local_moves = std::min(local, tiered.leaf_capacity - local);
|
||||
const auto directory_multiplier = localized
|
||||
? config_.localized_directory_multiplier : 1.0;
|
||||
const auto directory_work = config_.tiered_directory_unit
|
||||
* directory_multiplier
|
||||
* static_cast<double>(leaf_count);
|
||||
return (config_.tiered_edit_fixed
|
||||
+ config_.tiered_move_unit * width_scale
|
||||
* static_cast<double>(local_moves)
|
||||
+ directory_work + lookup) * count;
|
||||
}
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
struct DecisionEvaluation {
|
||||
std::optional<AdaptationDecision> decision;
|
||||
TieredConfig best_config{};
|
||||
double vector_cost = 0.0;
|
||||
double best_tiered_cost = 0.0;
|
||||
double current_cost = 0.0;
|
||||
double selected_rebuild_cost = 0.0;
|
||||
std::size_t forecast_operations = 0;
|
||||
};
|
||||
|
||||
[[nodiscard]] DecisionEvaluation evaluate_decision(
|
||||
StorageMode current,
|
||||
std::size_t size,
|
||||
TieredConfig current_config) const noexcept {
|
||||
DecisionEvaluation evaluation;
|
||||
|
||||
std::size_t best_index = 0;
|
||||
for (std::size_t i = 1; i < candidate_count; ++i) {
|
||||
if (ewma_candidate_costs_[i] < ewma_candidate_costs_[best_index]) {
|
||||
best_index = i;
|
||||
}
|
||||
}
|
||||
evaluation.best_config = candidate_config(best_index, size);
|
||||
evaluation.vector_cost = ewma_vector_cost_;
|
||||
evaluation.best_tiered_cost = ewma_candidate_costs_[best_index];
|
||||
const auto current_tiered_cost = ewma_active_tiered_cost_;
|
||||
evaluation.current_cost = current == StorageMode::vector
|
||||
? evaluation.vector_cost : current_tiered_cost;
|
||||
|
||||
const auto width_scale = std::max(1.0,
|
||||
static_cast<double>(last_element_bytes_) / sizeof(std::uint32_t));
|
||||
const auto conversion_cost = static_cast<double>(size)
|
||||
* config_.conversion_unit_per_element * width_scale;
|
||||
evaluation.selected_rebuild_cost = conversion_cost;
|
||||
const auto evidence_forecast = static_cast<std::size_t>(std::ceil(
|
||||
total_weight_ * config_.forecast_growth_factor));
|
||||
evaluation.forecast_operations = std::clamp(
|
||||
evidence_forecast,
|
||||
config_.minimum_forecast_operations,
|
||||
config_.forecast_operations);
|
||||
|
||||
const bool enough_evidence =
|
||||
total_weight_ >= static_cast<double>(config_.minimum_observations)
|
||||
|| total_edit_weight_
|
||||
>= static_cast<double>(config_.minimum_edit_observations);
|
||||
if (!initialized_ || !enough_evidence
|
||||
|| operations_since_transition_ < config_.minimum_residency_operations) {
|
||||
return evaluation;
|
||||
}
|
||||
|
||||
const auto forecast = static_cast<double>(evaluation.forecast_operations);
|
||||
double best_net_saving = 0.0;
|
||||
|
||||
if (current == StorageMode::vector) {
|
||||
if (size >= config_.minimum_tiered_size
|
||||
&& ewma_edit_fraction_ >= config_.tiered_entry_edit_fraction
|
||||
&& evaluation.best_tiered_cost < evaluation.vector_cost) {
|
||||
const auto gross = (evaluation.vector_cost
|
||||
- evaluation.best_tiered_cost) * forecast;
|
||||
const auto threshold = conversion_cost
|
||||
* config_.vector_to_tiered_safety;
|
||||
if (gross > threshold) {
|
||||
evaluation.decision = AdaptationDecision{
|
||||
StorageMode::tiered, evaluation.best_config, gross};
|
||||
best_net_saving = gross - threshold;
|
||||
}
|
||||
}
|
||||
return evaluation;
|
||||
}
|
||||
|
||||
// A tiered sequence returns to vector only after the workload has
|
||||
// crossed the low (read-dominant) side of the phase hysteresis band.
|
||||
if (ewma_edit_fraction_ <= config_.tiered_exit_edit_fraction
|
||||
&& evaluation.vector_cost < current_tiered_cost) {
|
||||
const auto gross = (current_tiered_cost - evaluation.vector_cost) * forecast;
|
||||
const auto threshold = conversion_cost * config_.tiered_to_vector_safety;
|
||||
if (gross > threshold) {
|
||||
evaluation.decision = AdaptationDecision{
|
||||
StorageMode::vector, normalize_tiered(current_config), gross};
|
||||
best_net_saving = gross - threshold;
|
||||
}
|
||||
}
|
||||
|
||||
const auto normalized_current = normalize_tiered(current_config);
|
||||
const bool shape_differs = evaluation.best_config != normalized_current;
|
||||
const bool directory_only = evaluation.best_config.leaf_capacity
|
||||
== normalized_current.leaf_capacity;
|
||||
const auto shape_rebuild_cost = directory_only
|
||||
? static_cast<double>((size + evaluation.best_config.leaf_capacity - 1)
|
||||
/ evaluation.best_config.leaf_capacity)
|
||||
* config_.directory_rebuild_unit_per_leaf
|
||||
: conversion_cost;
|
||||
const auto relative_improvement = current_tiered_cost > 0.0
|
||||
? (current_tiered_cost - evaluation.best_tiered_cost)
|
||||
/ current_tiered_cost
|
||||
: 0.0;
|
||||
if (operations_since_shape_transition_
|
||||
>= config_.minimum_shape_residency_operations
|
||||
&& ewma_edit_fraction_ >= config_.minimum_shape_edit_fraction
|
||||
&& shape_differs
|
||||
&& evaluation.best_tiered_cost < current_tiered_cost
|
||||
&& relative_improvement >= config_.minimum_shape_improvement) {
|
||||
const auto gross = (current_tiered_cost
|
||||
- evaluation.best_tiered_cost) * forecast;
|
||||
const auto threshold = shape_rebuild_cost * config_.tiered_rebuild_safety;
|
||||
const auto net = gross - threshold;
|
||||
if (gross > threshold && net > best_net_saving) {
|
||||
evaluation.decision = AdaptationDecision{
|
||||
StorageMode::tiered, evaluation.best_config, gross};
|
||||
evaluation.selected_rebuild_cost = shape_rebuild_cost;
|
||||
}
|
||||
}
|
||||
return evaluation;
|
||||
}
|
||||
|
||||
void close_window() noexcept {
|
||||
const auto inverse_weight = 1.0 / window_weight_;
|
||||
const auto vector_per_operation = window_vector_cost_ * inverse_weight;
|
||||
const auto active_per_operation = window_active_tiered_cost_ * inverse_weight;
|
||||
const auto edit_fraction = window_edit_weight_ * inverse_weight;
|
||||
std::array<double, candidate_count> candidates{};
|
||||
for (std::size_t i = 0; i < candidate_count; ++i) {
|
||||
candidates[i] = window_candidate_costs_[i] * inverse_weight;
|
||||
}
|
||||
if (!initialized_) {
|
||||
ewma_vector_cost_ = vector_per_operation;
|
||||
ewma_active_tiered_cost_ = active_per_operation;
|
||||
ewma_candidate_costs_ = candidates;
|
||||
ewma_edit_fraction_ = edit_fraction;
|
||||
initialized_ = true;
|
||||
} else {
|
||||
const auto alpha = config_.ewma_alpha;
|
||||
ewma_vector_cost_ = alpha * vector_per_operation
|
||||
+ (1.0 - alpha) * ewma_vector_cost_;
|
||||
ewma_active_tiered_cost_ = alpha * active_per_operation
|
||||
+ (1.0 - alpha) * ewma_active_tiered_cost_;
|
||||
for (std::size_t i = 0; i < candidate_count; ++i) {
|
||||
ewma_candidate_costs_[i] = alpha * candidates[i]
|
||||
+ (1.0 - alpha) * ewma_candidate_costs_[i];
|
||||
}
|
||||
ewma_edit_fraction_ = alpha * edit_fraction
|
||||
+ (1.0 - alpha) * ewma_edit_fraction_;
|
||||
}
|
||||
if (window_edit_weight_ > 0.0) {
|
||||
telemetry_.last_local_edit_fraction =
|
||||
window_local_edit_weight_ / window_edit_weight_;
|
||||
}
|
||||
telemetry_.last_edit_fraction = ewma_edit_fraction_;
|
||||
total_weight_ += window_weight_;
|
||||
window_vector_cost_ = 0.0;
|
||||
window_active_tiered_cost_ = 0.0;
|
||||
window_candidate_costs_.fill(0.0);
|
||||
window_weight_ = 0.0;
|
||||
window_edit_weight_ = 0.0;
|
||||
window_local_edit_weight_ = 0.0;
|
||||
update_confirmation(evaluate_decision(
|
||||
active_mode_, last_observed_size_, active_tiered_).decision);
|
||||
decision_ready_ = true;
|
||||
if (closed_windows_since_decision_
|
||||
!= std::numeric_limits<std::size_t>::max()) {
|
||||
++closed_windows_since_decision_;
|
||||
}
|
||||
}
|
||||
|
||||
static bool same_decision(const AdaptationDecision& left,
|
||||
const AdaptationDecision& right) noexcept {
|
||||
return left.target == right.target
|
||||
&& left.tiered_config == right.tiered_config;
|
||||
}
|
||||
|
||||
void update_confirmation(
|
||||
const std::optional<AdaptationDecision>& decision) noexcept {
|
||||
if (!decision) {
|
||||
pending_decision_.reset();
|
||||
confirmation_count_ = 0;
|
||||
return;
|
||||
}
|
||||
if (pending_decision_ && same_decision(*pending_decision_, *decision)) {
|
||||
confirmation_count_ = std::min(
|
||||
config_.required_confirmation_windows,
|
||||
confirmation_count_ + 1);
|
||||
pending_decision_ = decision;
|
||||
} else {
|
||||
pending_decision_ = decision;
|
||||
confirmation_count_ = 1;
|
||||
}
|
||||
}
|
||||
|
||||
[[nodiscard]] std::optional<AdaptationDecision>
|
||||
confirm(const std::optional<AdaptationDecision>& decision) noexcept {
|
||||
if (!decision || !pending_decision_
|
||||
|| !same_decision(*pending_decision_, *decision)
|
||||
|| confirmation_count_ < config_.required_confirmation_windows) {
|
||||
return std::nullopt;
|
||||
}
|
||||
auto confirmed = decision;
|
||||
pending_decision_.reset();
|
||||
confirmation_count_ = 0;
|
||||
return confirmed;
|
||||
}
|
||||
|
||||
void synchronize_active_tiered_ewma(TieredConfig active) noexcept {
|
||||
if (!initialized_) {
|
||||
return;
|
||||
}
|
||||
for (std::size_t i = 0; i < candidate_count; ++i) {
|
||||
if (config_.tiered_leaf_candidates[i] == active.leaf_capacity) {
|
||||
ewma_active_tiered_cost_ = ewma_candidate_costs_[i];
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// A committed transition starts a new payback/residency epoch, but the
|
||||
// workload signal is deliberately retained. Throwing the EWMA away made
|
||||
// the policy relearn the same stationary phase from noisy short windows and
|
||||
// allowed vector<->tiered and leaf-shape ping-pong.
|
||||
void clear_transition_evidence() noexcept {
|
||||
operations_since_transition_ = 0;
|
||||
operations_since_shape_transition_ = 0;
|
||||
total_weight_ = 0.0;
|
||||
total_edit_weight_ = 0.0;
|
||||
window_weight_ = 0.0;
|
||||
window_vector_cost_ = 0.0;
|
||||
window_active_tiered_cost_ = 0.0;
|
||||
window_candidate_costs_.fill(0.0);
|
||||
window_edit_weight_ = 0.0;
|
||||
window_local_edit_weight_ = 0.0;
|
||||
pending_decision_.reset();
|
||||
confirmation_count_ = 0;
|
||||
has_last_edit_ = false;
|
||||
decision_ready_ = false;
|
||||
closed_windows_since_decision_ = 0;
|
||||
}
|
||||
|
||||
AdaptationConfig config_;
|
||||
TieredConfig active_tiered_;
|
||||
StorageMode active_mode_ = StorageMode::vector;
|
||||
std::size_t search_fanout_ = 64;
|
||||
std::size_t search_max_levels_ = 4;
|
||||
AdaptationTelemetry telemetry_;
|
||||
std::array<double, candidate_count> window_candidate_costs_{};
|
||||
std::array<double, candidate_count> ewma_candidate_costs_{};
|
||||
double window_vector_cost_ = 0.0;
|
||||
double window_active_tiered_cost_ = 0.0;
|
||||
double window_weight_ = 0.0;
|
||||
double window_edit_weight_ = 0.0;
|
||||
double window_local_edit_weight_ = 0.0;
|
||||
double total_weight_ = 0.0;
|
||||
double total_edit_weight_ = 0.0;
|
||||
double ewma_vector_cost_ = 0.0;
|
||||
double ewma_active_tiered_cost_ = 0.0;
|
||||
double ewma_edit_fraction_ = 0.0;
|
||||
std::size_t operations_since_transition_ = 0;
|
||||
std::size_t operations_since_shape_transition_ = 0;
|
||||
std::size_t last_edit_position_ = 0;
|
||||
std::size_t last_observed_size_ = 0;
|
||||
std::size_t last_element_bytes_ = sizeof(std::uint32_t);
|
||||
std::size_t confirmation_count_ = 0;
|
||||
std::optional<AdaptationDecision> pending_decision_;
|
||||
bool has_last_edit_ = false;
|
||||
bool initialized_ = false;
|
||||
bool decision_ready_ = false;
|
||||
std::size_t closed_windows_since_decision_ = 0;
|
||||
};
|
||||
|
||||
} // namespace uc
|
||||
Reference in New Issue
Block a user