use std::collections::VecDeque;
use std::fmt;
use std::sync::Arc;
use tokio::sync::{Mutex, OwnedSemaphorePermit, Semaphore};
use tracing::{debug, trace};
#[async_trait::async_trait]
pub trait DhtTask: Send + fmt::Debug {
async fn run(self: Box<Self>);
fn name(&self) -> &'static str;
}
pub type BoxedDhtTask = Box<dyn DhtTask>;
pub const DEFAULT_NUM_CONCURRENT: usize = 15;
pub struct DhtTaskExecutor {
inner: Arc<Mutex<DhtTaskExecutorInner>>,
semaphore: Arc<Semaphore>,
num_concurrent: usize,
}
struct DhtTaskExecutorInner {
queue: VecDeque<BoxedDhtTask>,
executing: usize,
}
impl DhtTaskExecutor {
pub fn new(num_concurrent: usize) -> Self {
Self {
inner: Arc::new(Mutex::new(DhtTaskExecutorInner {
queue: VecDeque::new(),
executing: 0,
})),
semaphore: Arc::new(Semaphore::new(num_concurrent)),
num_concurrent,
}
}
pub async fn add_task(&self, task: BoxedDhtTask) {
let task_name = task.name();
let mut inner = self.inner.lock().await;
inner.queue.push_back(task);
trace!(
task = task_name,
queue_len = inner.queue.len(),
executing = inner.executing,
"DHT task enqueued"
);
drop(inner);
self.dispatch_pending().await;
}
pub async fn executing_count(&self) -> usize {
self.inner.lock().await.executing
}
pub async fn queue_size(&self) -> usize {
self.inner.lock().await.queue.len()
}
async fn dispatch_pending(&self) {
let sem = Arc::clone(&self.semaphore);
loop {
let task = {
let mut inner = self.inner.lock().await;
if inner.queue.is_empty() {
break;
}
inner.queue.pop_front()
};
let Some(task) = task else { break };
let task_name = task.name();
match sem.clone().try_acquire_owned() {
Ok(permit) => {
let mut inner = self.inner.lock().await;
inner.executing += 1;
drop(inner);
debug!(task = task_name, "DHT task dispatched");
self.spawn_task(task, permit);
}
Err(_) => {
let mut inner = self.inner.lock().await;
inner.queue.push_front(task);
break;
}
}
}
}
fn spawn_task(&self, task: BoxedDhtTask, _permit: OwnedSemaphorePermit) {
let inner = Arc::clone(&self.inner);
let semaphore = Arc::clone(&self.semaphore);
let run_and_redispatch = async move {
let _held = _permit;
task.run().await;
{
let mut guard = inner.lock().await;
guard.executing = guard.executing.saturating_sub(1);
}
drop(_held);
loop {
let next_task = {
let mut guard = inner.lock().await;
guard.queue.pop_front()
};
let Some(next_task) = next_task else { break };
match semaphore.clone().try_acquire_owned() {
Ok(permit) => {
{
let mut guard = inner.lock().await;
guard.executing += 1;
}
debug!(
task = next_task.name(),
"DHT task dispatched (after completion)"
);
let _held2 = permit;
next_task.run().await;
{
let mut guard = inner.lock().await;
guard.executing = guard.executing.saturating_sub(1);
}
drop(_held2);
}
Err(_) => {
let mut guard = inner.lock().await;
guard.queue.push_front(next_task);
break;
}
}
}
};
tokio::spawn(run_and_redispatch);
}
}
impl fmt::Debug for DhtTaskExecutor {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("DhtTaskExecutor")
.field("num_concurrent", &self.num_concurrent)
.finish()
}
}
pub struct DhtTaskQueue {
periodic_executor_1: DhtTaskExecutor,
periodic_executor_2: DhtTaskExecutor,
immediate_executor: DhtTaskExecutor,
}
impl DhtTaskQueue {
pub fn new() -> Self {
Self::with_concurrency(DEFAULT_NUM_CONCURRENT)
}
pub fn with_concurrency(num_concurrent: usize) -> Self {
Self {
periodic_executor_1: DhtTaskExecutor::new(num_concurrent),
periodic_executor_2: DhtTaskExecutor::new(num_concurrent),
immediate_executor: DhtTaskExecutor::new(num_concurrent),
}
}
pub async fn add_periodic_task_1(&self, task: BoxedDhtTask) {
self.periodic_executor_1.add_task(task).await;
}
pub async fn add_periodic_task_2(&self, task: BoxedDhtTask) {
self.periodic_executor_2.add_task(task).await;
}
pub async fn add_immediate_task(&self, task: BoxedDhtTask) {
self.immediate_executor.add_task(task).await;
}
pub fn periodic_executor_1(&self) -> &DhtTaskExecutor {
&self.periodic_executor_1
}
pub fn periodic_executor_2(&self) -> &DhtTaskExecutor {
&self.periodic_executor_2
}
pub fn immediate_executor(&self) -> &DhtTaskExecutor {
&self.immediate_executor
}
}
impl Default for DhtTaskQueue {
fn default() -> Self {
Self::new()
}
}
impl fmt::Debug for DhtTaskQueue {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("DhtTaskQueue").finish()
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, Ordering};
#[derive(Debug)]
struct CountTask {
counter: Arc<AtomicUsize>,
name: &'static str,
}
#[async_trait::async_trait]
impl DhtTask for CountTask {
async fn run(self: Box<Self>) {
self.counter.fetch_add(1, Ordering::SeqCst);
}
fn name(&self) -> &'static str {
self.name
}
}
#[tokio::test]
async fn test_executor_dispatches_task() {
let executor = DhtTaskExecutor::new(2);
let counter = Arc::new(AtomicUsize::new(0));
executor
.add_task(Box::new(CountTask {
counter: Arc::clone(&counter),
name: "test",
}))
.await;
tokio::time::sleep(std::time::Duration::from_millis(50)).await;
assert_eq!(counter.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn test_executor_concurrency_limit() {
let executor = DhtTaskExecutor::new(2);
let counter = Arc::new(AtomicUsize::new(0));
for _ in 0..5 {
executor
.add_task(Box::new(CountTask {
counter: Arc::clone(&counter),
name: "concurrent-test",
}))
.await;
}
tokio::time::sleep(std::time::Duration::from_millis(200)).await;
assert_eq!(counter.load(Ordering::SeqCst), 5);
assert_eq!(executor.executing_count().await, 0);
}
#[tokio::test]
async fn test_task_queue_three_lanes() {
let queue = DhtTaskQueue::new();
let c1 = Arc::new(AtomicUsize::new(0));
let c2 = Arc::new(AtomicUsize::new(0));
let c3 = Arc::new(AtomicUsize::new(0));
queue
.add_periodic_task_1(Box::new(CountTask {
counter: Arc::clone(&c1),
name: "p1",
}))
.await;
queue
.add_periodic_task_2(Box::new(CountTask {
counter: Arc::clone(&c2),
name: "p2",
}))
.await;
queue
.add_immediate_task(Box::new(CountTask {
counter: Arc::clone(&c3),
name: "imm",
}))
.await;
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
assert_eq!(c1.load(Ordering::SeqCst), 1);
assert_eq!(c2.load(Ordering::SeqCst), 1);
assert_eq!(c3.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn test_executor_queue_size() {
let executor = DhtTaskExecutor::new(1);
let counter = Arc::new(AtomicUsize::new(0));
#[derive(Debug)]
struct SlowTask {
counter: Arc<AtomicUsize>,
}
#[async_trait::async_trait]
impl DhtTask for SlowTask {
async fn run(self: Box<Self>) {
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
self.counter.fetch_add(1, Ordering::SeqCst);
}
fn name(&self) -> &'static str {
"slow"
}
}
executor
.add_task(Box::new(SlowTask {
counter: Arc::clone(&counter),
}))
.await;
for _ in 0..3 {
executor
.add_task(Box::new(CountTask {
counter: Arc::clone(&counter),
name: "queued",
}))
.await;
}
let executing = executor.executing_count().await;
let queued = executor.queue_size().await;
assert!(
executing + queued >= 3,
"executing={}, queued={}",
executing,
queued
);
tokio::time::sleep(std::time::Duration::from_millis(500)).await;
assert_eq!(counter.load(Ordering::SeqCst), 4);
}
}