Struct TwcsPicker 

pub struct TwcsPicker {
    pub trigger_file_num: usize,
    pub active_window_l1_merge_trigger: usize,
    pub inactive_window_trigger_file_num: usize,
    pub inactive_window_l1_merge_trigger: usize,
    pub time_window_seconds: Option<i64>,
    pub max_output_file_size: Option<u64>,
    pub append_mode: bool,
    pub(crate) merge_mode: MergeMode,
    pub max_background_tasks: Option<usize>,
    pub(crate) time_range: Option<TimestampRange>,
    pub(crate) all_windows_inactive: bool,
}

TwcsPicker picks files of which the max timestamp are in the same time window as compaction candidates.

Fields

trigger_file_num: usize

Minimum file num to trigger a compaction in the active window.

active_window_l1_merge_trigger: usize

Minimum L1 file num to allow a safety compaction in the active window.

inactive_window_trigger_file_num: usize

Minimum file num to trigger a compaction in an inactive window.

inactive_window_l1_merge_trigger: usize

Minimum L1 file num to trigger a compaction in an inactive window.

time_window_seconds: Option<i64>

Compaction time window in seconds.

max_output_file_size: Option<u64>

Max allowed compaction output file size. The picker also uses it to predict output splits when scoring candidates.

append_mode: bool

Whether the target region is in append mode.

merge_mode: MergeMode

LastNonNull picks expand to an overlap closure, so cannot use partial small-file reductions that must leave large peers untouched.

max_background_tasks: Option<usize>

Max background compaction tasks.

time_range: Option<TimestampRange>

Optional time range that constrains candidate compaction windows.

all_windows_inactive: bool

Picks the active window like an inactive one. Manual compactions set it, so a window that stopped receiving writes still gets its overlaps resolved.

Implementations

impl TwcsPicker

async fn build_output( &self, region_id: RegionId, time_windows: BTreeMap<i64, Window>, context: WindowOutputContext, ) -> Result<Vec<CompactionOutput>>

Picks at most one compaction input per window and schedules them across windows by PickClass, newer windows first within a class.

fn pick_window( &self, region_id: RegionId, window: &Window, active_window: Option<i64>, time_window_size: Option<i64>, region_sequence: u64, mapper: &PrimaryKeyRangeMapper, ) -> Option<WindowPick>

Picks the compaction inputs of one window, or None if it needs none.

fn pick_active_window( &self, l0_files: Vec<FileHandle>, l1_files: Vec<FileHandle>, mapper: &PrimaryKeyRangeMapper, ) -> Option<WindowPick>

The active window keeps receiving writes, so every pick must reduce its file count:

1. Merge L0 files once they reach the trigger.
2. Otherwise, merge L1 files once they reach the L1 safety trigger. L1 files are merged separately from L0 files to avoid chained rewrites.

Overlaps are left for the window to resolve once it becomes inactive: resolving them while data keeps arriving rewrites the window repeatedly, and leaves a dominant run that blocks the inactive-window merge.

fn pick_inactive_window( &self, l0_files: Vec<FileHandle>, l1_files: Vec<FileHandle>, mapper: &PrimaryKeyRangeMapper, settling: bool, quiet: bool, ) -> Option<WindowPick>

An inactive window should converge at a bounded rewrite cost:

1. Absorb L0 files (late data), see pick_inactive_l0.
2. Otherwise, merge a closed group of files that resolves overlaps or removes files, see units::pick_closed_merge. Pure file reduction waits for the L1 trigger; overlap resolution does not.

A settling window is the one right before the active window. Late data still lands there, and any rewrite of its overlapping files would be repeated once more late data arrives. It only merges L0 files among themselves and conflict-free files, and leaves overlaps for when the window is older.

Late data can also land in older windows. Resolving such an overlap rewrites a dominant sorted run for a small peer, which would repeat for every late flush, so it waits until the window is quiet: the region has written a window’s worth of rows elsewhere since the window last received data. Each quiet period then pays for at most one such rewrite. A manual compaction is a one-off request to resolve overlaps, so it does not wait.

Without new writes each pick consumes an L0 file or makes progress on the closed merge’s termination measure, so the window stops compacting.

fn pick_limits(&self) -> PickLimits

fn closed_merge_limits(&self) -> PickLimits

impl TwcsPicker

pub(crate) async fn pick_with_output_limit( &self, compaction_region: &CompactionRegion, max_outputs: Option<usize>, ) -> Result<Option<PickerOutput>>

Trait Implementations

impl Clone for TwcsPicker

fn clone(&self) -> TwcsPicker

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TwcsPicker

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Picker for TwcsPicker

fn pick<'life0, 'life1, 'async_trait>( &'life0 self, compaction_region: &'life1 CompactionRegion, ) -> Pin<Box<dyn Future<Output = Result<Option<PickerOutput>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Picks input SST files for compaction.