Kitty Pool

Ready For Production

The short answer is NO. This crate is not ready for production use. This is my first crate and frankly the crate will change after async makes it into stable.

A number of open tasks exist for the crate:

• Is the API stable?
• Is the crate performant enough?
• Are there good examples?
• Is there good documentation?
• How does the crate interact with other useful libraries? I.E. can this crate effectively act as a single buffer for existing crates to avoid copies?

Purpose

The goal of this crate is to provide a safe and easy to use buffer pool in both a single-threaded and multi-threaded environment. The 'Kitty Pool' allows for requesting of 'Ranges', which act as owned slices into the buffer. The user of the 'Ranges' can then safely read and write to the owned parts of the buffer.

Example

use kitty_pool::*;

const POOL_SIZE: usize = 1024;
const BLOCK_SIZE: usize = 64;
const REQUEST_SIZE: usize = 256;

fn main() {
    let mut kitty_pool = KittyPool::new(POOL_SIZE, BLOCK_SIZE);
    let rand_string: String = thread_rng()
        .sample_iter(&Alphanumeric)
        .take(REQUEST_SIZE)
        .collect();
    let rand_bytes: Vec<u8> = Vec::from(rand_string.as_bytes());
    let mut buffer = vec![0; REQUEST_SIZE];
    let future = async {
        let mut token = kitty_pool.borrow(REQUEST_SIZE).await;
        assert!(token.is_ok());
        token = kitty_pool.write(&token.unwrap(), &rand_bytes).await;
        assert!(token.is_ok());
        token = kitty_pool.read(&token.unwrap(), &mut buffer).await;
        assert!(token.is_ok());
        assert_eq!(*buffer, *rand_bytes);
        assert!(kitty_pool.release(&token.unwrap()).is_ok());
    };
    block_on(future);
}

TODO

• Filter pattern, should allow for using arbitrary segments of the owned ranges
• Flag for contiguousness