Question about real write operation to socket.

[nomiuo]

Hello.

I am relatively new to using the Hyper library and have encountered some confusion while examining its source code. Specifically, I am uncertain about the timing of when data is actually written to the socket. Could you please provide some insight into what I might be misunderstanding?

Thank you.

Here is my understanding:

The hyper version: 1.3.1.

For now, I know all the core logic are located in src/proto/h1/dispatch.rs:163 below:

fn poll_loop(&mut self, cx: &mut Context<'_>) -> Poll<crate::Result<()>> {
        // ...
        for _ in 0..16 {
            let _ = self.poll_read(cx)?;
            let _ = self.poll_write(cx)?;
            let _ = self.poll_flush(cx)?;
       // ...

The poll_flush is responsible for flushing the data into the socket, and its inner implementation is here:

    // src/proto/h1/io.rs:325
    fn poll_flush_flattened(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
        loop {
            let n = ready!(Pin::new(&mut self.io).poll_write(cx, self.write_buf.headers.chunk()))?;
           // ...
    }

It calls poll_write to write the data into socket, but I can't find an implementation for it in RustRover with real logic. For example:

All the implementations are same that just call tokio::io::AsyncWrite::poll_write(【translate into Pin】, cx, buf) expect these implementations:

1. hyper_io: ffi implementation calls hyper_io_write_callback function.
2. H2Upgraded: send_stream data to somewhere.

But for other implementations, what is the real implementation?

Thanks very much!