Note of performance improvement

[Xuanwo]

This note is used to track performance improvement.

Please let me know for any ideas.

Possible Ideas

• Readiness based API
  • Requires internal buffering(?), maybe worse on sequential read.
• Allowing creating a different hyper client for s3 instead of sharing the same one.

Not work

Self-maintained runtime

Idea based on #103

To spawn a new task on tokio runtime, we can't have reference:

fn spawn<T>(&self, future: T) -> JoinHandle<T::Output>
where
    T: Future + Send + 'static,
    T::Output: Send + 'static,
{
    match self {
        Executor::External => tokio::spawn(future),
        Executor::Global => GLOBAL_EXECUTOR.spawn(future),
        Executor::Internal() => unimplemented!(),
    }
}

So we have to take an owned buf like monoio and tokio-uring:

fn read(&self, path: &str, offset: u64, buf: Vec<u8>) -> JoinHandle<Result<(usize, Vec<u8>)>> {
    let (_, _, _) = (path, offset, buf);
    unimplemented!()
}

fn write(&self, path: &str, buf: Vec<u8>) -> JoinHandle<Result<()>> {
    let (_, _) = (path, buf);
    unimplemented!()
}

However, these API requires extra alloc and memory copy which drops 50% read performance.

Here is another try that keeps returning BoxedAsyncRead:

fn read(&self, path: &str, offset: u64, size: u64) -> JoinHandle<Result<BoxedAsyncRead>> {
    let (_, _, _) = (path, offset, size);
    unimplemented!()
}

There is no significant performance on regular benches, but we can find performance drops under parallel read benches.

[Xuanwo]

Usecase from databend: Read a small block (1,000,000 rows) from a file, around 141KiB to 288KiB.

We need to add benches to address this use case.