use std::collections::HashMap;
use std::sync::atomic::Ordering;
use std::sync::Arc;
use std::time::Duration;
use tokio::sync::mpsc;
use super::{AsyncDeleteBatch, GroupRuntime};
const XDEL_BATCH_SIZE: usize = 1_000;
const MAX_PENDING_IDS: usize = 100_000;
struct AsyncDeleteOwner {
rt: Arc<GroupRuntime>,
rx: mpsc::Receiver<AsyncDeleteBatch>,
}
impl Drop for AsyncDeleteOwner {
fn drop(&mut self) {
let mut counts = self
.rt
.async_delete_admission
.lock()
.expect("delete admission");
self.rx.close();
let retained = self.rt.async_delete_pending.swap(0, Ordering::AcqRel);
for (partition, count) in counts.iter_mut().enumerate() {
let domain = self
.rt
.core
.executions
.domain(&self.rt.layout.prefix, partition as u32);
self.rt.core.executions.domains[domain]
.delete_records
.fetch_sub(*count, Ordering::AcqRel);
*count = 0;
}
self.rt
.core
.async_delete_records
.fetch_sub(retained, Ordering::AcqRel);
self.rt
.core
.delete_retained_records
.fetch_add(retained as u64, Ordering::AcqRel);
self.rt.core.changed.notify_waiters();
}
}
pub(super) fn async_delete_loop(
rt: Arc<GroupRuntime>,
rx: mpsc::Receiver<AsyncDeleteBatch>,
) -> impl std::future::Future<Output = ()> {
run_async_delete(AsyncDeleteOwner { rt, rx })
}
async fn run_async_delete(mut owner: AsyncDeleteOwner) {
let rt = owner.rt.clone();
let rx = &mut owner.rx;
let period = rt.stream_cfg.async_del_record_period_ms;
if period == 0 {
return;
}
let mut tick = tokio::time::interval(Duration::from_millis(period));
tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
tick.tick().await;
let mut pending: HashMap<u32, Vec<String>> = HashMap::new();
let mut pending_count = 0usize;
loop {
tokio::select! {
biased;
_ = rt.async_delete_cancel.cancelled() => {
while let Ok(batch) = rx.try_recv() {
append_batch(&mut pending, &mut pending_count, batch);
}
flush_pending(&rt, &mut pending, &mut pending_count).await;
if pending_count > 0 {
tracing::warn!(
group = %rt.layout.prefix,
pending = pending_count,
auto_trim_enabled = rt.stream_cfg.auto_trim_rate_ms > 0,
"异步 XDEL 末次 flush 未清空;entry 保留在 stream,启用 autoTrim 时由保留窗继续回收"
);
}
return;
}
batch = rx.recv(), if pending_count < MAX_PENDING_IDS => {
match batch {
Some(batch) => append_batch(&mut pending, &mut pending_count, batch),
None => {
flush_pending(&rt, &mut pending, &mut pending_count).await;
return;
}
}
}
_ = tick.tick() => {
flush_pending(&rt, &mut pending, &mut pending_count).await;
}
_ = rt.async_delete_flush.notified() => {
while let Ok(batch) = rx.try_recv() {
append_batch(&mut pending, &mut pending_count, batch);
}
flush_pending(&rt, &mut pending, &mut pending_count).await;
if pending_count > 0 && rt.core.roots_closed.load(Ordering::Acquire) {
return;
}
}
}
}
}
fn append_batch(
pending: &mut HashMap<u32, Vec<String>>,
pending_count: &mut usize,
batch: AsyncDeleteBatch,
) {
*pending_count = pending_count.saturating_add(batch.ids.len());
pending
.entry(batch.partition)
.or_default()
.extend(batch.ids);
}
async fn flush_pending(
rt: &Arc<GroupRuntime>,
pending: &mut HashMap<u32, Vec<String>>,
pending_count: &mut usize,
) {
if *pending_count == 0 {
return;
}
let partitions: Vec<u32> = pending.keys().copied().collect();
for partition in partitions {
let Some(ids) = pending.get_mut(&partition) else {
continue;
};
let count_before_dedup = ids.len();
ids.sort_unstable();
ids.dedup();
decrement_gauge(rt, partition, count_before_dedup.saturating_sub(ids.len()));
let current = std::mem::take(ids);
let mut failed = Vec::new();
for chunk in current.chunks(XDEL_BATCH_SIZE) {
let mut command = redis::cmd("XDEL");
command.arg(rt.layout.stream(partition));
for id in chunk {
command.arg(id);
}
let result: std::result::Result<i64, redis::RedisError> =
command.query_async(&mut rt.client.conn()).await;
match result {
Ok(_) => decrement_gauge(rt, partition, chunk.len()),
Err(error) => {
tracing::warn!(
partition,
count = chunk.len(),
err = %error,
"异步 XDEL 失败,保留到下一周期"
);
failed.extend(chunk.iter().cloned());
}
}
}
*ids = failed;
}
pending.retain(|_, ids| !ids.is_empty());
*pending_count = pending.values().map(Vec::len).sum();
}
fn decrement_gauge(rt: &GroupRuntime, partition: u32, count: usize) {
if count == 0 {
return;
}
let mut counts = rt.async_delete_admission.lock().expect("delete admission");
let count = count.min(counts[partition as usize]);
counts[partition as usize] -= count;
let domain = rt.core.executions.domain(&rt.layout.prefix, partition);
rt.core.executions.domains[domain]
.delete_records
.fetch_sub(count, Ordering::AcqRel);
let _ = rt
.async_delete_pending
.fetch_update(Ordering::AcqRel, Ordering::Acquire, |current| {
Some(current.saturating_sub(count))
});
let _ =
rt.core
.async_delete_records
.fetch_update(Ordering::AcqRel, Ordering::Acquire, |current| {
Some(current.saturating_sub(count))
});
}