Override poll_write_vectored?

[thomaseizinger]

At present, poll_write_vectored is not overridden:

• https://docs.rs/tokio-rustls/latest/src/tokio_rustls/client.rs.html#134-244
• https://docs.rs/tokio-rustls/latest/src/tokio_rustls/server.rs.html#94-129
• https://docs.rs/tokio-rustls/latest/src/tokio_rustls/lib.rs.html#522-553

• tokio-rustls/src/common/mod.rs

  Lines 290 to 324 in 6df177a

  	fn poll_write(
  	mut self: Pin<&mut Self>,
  	cx: &mut Context,
  	buf: &[u8],
  	) -> Poll<io::Result<usize>> {
  	let mut pos = 0;
  	while pos != buf.len() {
  	let mut would_block = false;
  	match self.session.writer().write(&buf[pos..]) {
  	Ok(n) => pos += n,
  	Err(err) => return Poll::Ready(Err(err)),
  	};
  	while self.session.wants_write() {
  	match self.write_io(cx) {
  	Poll::Ready(Ok(0)) | Poll::Pending => {
  	would_block = true;
  	break;
  	}
  	Poll::Ready(Ok(_)) => (),
  	Poll::Ready(Err(err)) => return Poll::Ready(Err(err)),
  	}
  	}
  	return match (pos, would_block) {
  	(0, true) => Poll::Pending,
  	(n, true) => Poll::Ready(Ok(n)),
  	(_, false) => continue,
  	};
  	}
  	Poll::Ready(Ok(pos))
  	}

I think it would make sense to do so though. At the moment, the implementation of poll_write will perform IO as soon as the buffer is written (which makes sense). However, if the application would have more data to send that sits in different buffers, performing IO after every poll_write might lead to multiple TCP packets being sent.

The only way around this (I think?) would be to re-design the upper layer to be able to provide a single byte buffer. That is not always feasible and/or desirable. Additionally, that is exactly what poll_write_vectored is for. A proper implementation of would send all packets down to the rustls session and only perform IO once that buffer is either full or we've written all buffers passed to us.

I've created a basic draft in #25.

[quininer]

I agree with impl write_vectored as the optimization over current situation.

Currently, rustls does not provide backpressure https://github.com/rustls/rustls/blob/v/0.21.8/rustls/src/conn.rs#L232 . If we want to impl buffer write without rustls support, we can treat rustls writer as an infinite buffer and set a reasonable buffer length ourselves.

But this is a huge behavior change. and if rustls hopes to provide a write-through API in future, it would be reasonable to keep current behavior. tokio-rs/tls#136 (comment)

cc @djc

[thomaseizinger]

I don't think I am following you there. Isn't that orthogonal to vectored writes? For poll_write_vectored to make sense, I think we simply need to first write all buffers and then ask the session wants_write.

The docs for poll_write_vectored state that it needs to behave as if poll_write was called with a concatenated buffer. How is internal buffering in rustls related to that?

[quininer]

Yes, they are orthogonal. the buffer writer is just a related discussion of this line.

A proper implementation of would send all packets down to the rustls session and only perform IO once that buffer is either full or we've written all buffers passed to us.

[djc]

The write-through API is currently being worked on. rustls/rustls#1420

[paolobarbolini]

With rustls/rustls#1640 this could make sense to have. I may find some time to look into it.