Struct GcScheduler 

pub struct GcScheduler {
    pub(crate) ctx: Arc<dyn SchedulerCtx>,
    pub(crate) receiver: Receiver<Event>,
    pub(crate) config: GcSchedulerOptions,
    pub(crate) region_gc_tracker: Arc<Mutex<HashMap<RegionId, RegionGcInfo>>>,
    pub(crate) last_tracker_cleanup: Arc<Mutex<Instant>>,
}

GcScheduler is used to periodically trigger garbage collection on datanodes.

Fields

ctx: Arc<dyn SchedulerCtx>

receiver: Receiver<Event>

The receiver of events.

config: GcSchedulerOptions

GC configuration.

region_gc_tracker: Arc<Mutex<HashMap<RegionId, RegionGcInfo>>>

Tracks the last GC time for regions.

last_tracker_cleanup: Arc<Mutex<Instant>>

Last time the tracker was cleaned up.

Implementations

impl GcScheduler

fn calculate_gc_score(&self, region_stat: &RegionStat) -> f64

Calculate GC priority score for a region based on various metrics.

pub(crate) async fn select_gc_candidates( &self, table_to_region_stats: &HashMap<TableId, Vec<RegionStat>>, ) -> Result<HashMap<TableId, Vec<GcCandidate>>>

Filter and score regions that are candidates for GC, grouped by table.

impl GcScheduler

pub(crate) async fn trigger_gc(&self) -> Result<GcJobReport>

Iterate through all region stats, find region that might need gc, and send gc instruction to the corresponding datanode with improved parallel processing and retry logic.

pub(crate) async fn find_related_regions( &self, candidate_region_ids: &[RegionId], ) -> Result<HashMap<RegionId, Vec<RegionId>>>

Find related regions that might share files with the candidate regions. Currently returns the same regions since repartition is not implemented yet. TODO(discord9): When repartition is implemented, this should also find src/dst regions that might share files with the candidate regions.

pub(crate) async fn aggregate_candidates_by_datanode( &self, per_table_candidates: HashMap<TableId, Vec<GcCandidate>>, ) -> Result<HashMap<Peer, Vec<(TableId, GcCandidate)>>>

Aggregate GC candidates by their corresponding datanode peer.

pub(crate) async fn parallel_process_datanodes( &self, datanode_to_candidates: HashMap<Peer, Vec<(TableId, GcCandidate)>>, ) -> GcJobReport

Process multiple datanodes concurrently with limited parallelism.

pub(crate) async fn process_datanode_gc( &self, peer: Peer, candidates: Vec<(TableId, GcCandidate)>, ) -> Result<GcReport>

Process GC for a single datanode with all its candidate regions. Returns the table reports for this datanode.

async fn discover_datanodes_for_regions( &self, regions: &[RegionId], ) -> Result<(HashMap<RegionId, (Peer, Vec<Peer>)>, HashMap<Peer, HashSet<RegionId>>)>

Discover datanodes for the given regions(and it’s related regions) by fetching table routes in batches. Returns mappings from region to peer(leader, Vec) and peer to regions.

fn get_table_regions_peer( &self, table_route: &PhysicalTableRouteValue, table_regions: &[RegionId], region_to_peer: &mut HashMap<RegionId, (Peer, Vec<Peer>)>, peer_to_regions: &mut HashMap<Peer, HashSet<RegionId>>, )

Process regions for a single table to find their current leader peers.

async fn batch_should_use_full_listing( &self, region_ids: &[RegionId], ) -> HashMap<RegionId, bool>

impl GcScheduler

pub(crate) fn new_with_config( table_metadata_manager: TableMetadataManagerRef, procedure_manager: ProcedureManagerRef, meta_peer_client: MetaPeerClientRef, mailbox: MailboxRef, server_addr: String, config: GcSchedulerOptions, ) -> Result<(Self, GcTicker)>

Creates a new GcScheduler with custom configuration.

pub(crate) fn channel() -> (Sender<Event>, Receiver<Event>)

pub fn try_start(self) -> Result<()>

Starts the gc trigger.

pub(crate) async fn run(&mut self)

pub(crate) async fn handle_tick(&self) -> Result<GcJobReport>

impl GcScheduler

pub(crate) async fn cleanup_tracker_if_needed(&self) -> Result<()>

Clean up stale entries from the region GC tracker if enough time has passed. This removes entries for regions that no longer exist in the current table routes.

pub(crate) async fn should_use_full_listing(&self, region_id: RegionId) -> bool

Determine if full file listing should be used for a region based on the last full listing time.

pub(crate) async fn update_full_listing_time( &self, region_id: RegionId, did_full_listing: bool, )