Connection Pooling Strategy

[devfire]

Connection Pooling Strategy

Multiple QueryActor Instances

Objective: Eliminate single QueryActor bottleneck

Current Limitation: Single QueryActor processes all DNS resolutions
Solution: Create pool of QueryActor instances

struct QueryActorPool {
    actors: Vec<QueryActorHandle>,
    current: AtomicUsize,
    size: usize,
}

impl QueryActorPool {
    fn new(pool_size: usize, resolver: Resolver<TokioConnectionProvider>) -> Self {
        let actors = (0..pool_size)
            .map(|_| QueryActorHandle::new(resolver.clone()))
            .collect();
        
        Self {
            actors,
            current: AtomicUsize::new(0),
            size: pool_size,
        }
    }
    
    fn get_actor(&self) -> &QueryActorHandle {
        let index = self.current.fetch_add(1, Ordering::Relaxed) % self.size;
        &self.actors[index]
    }
}

Distribution Strategies

• Round-robin: Simple, even distribution
• Least-busy: More complex, better load balancing
• Recommended: Start with round-robin, optimize later

Pool Sizing

• Recommended: 10-50 actors depending on expected load
• Consideration: Each actor maintains resolver connection
• Tuning: Monitor connection pool utilization