Remove Eager read, write, accept (denoland#1959)

Removing this reduces tail latency in test/http_bench.ts by half.
Maxim-Mazurok · Mar 18, 2019 · 34a2aa4 · 34a2aa4
1 parent e98d339
commit 34a2aa4
Show file tree

Hide file tree

Showing 4 changed files with 4 additions and 185 deletions.
diff --git a/src/eager_unix.rs b/src/eager_unix.rs
diff --git a/src/main.rs b/src/main.rs
@@ -35,9 +35,6 @@ mod tokio_write;
 pub mod version;
 pub mod workers;
 
-#[cfg(unix)]
-mod eager_unix;
-
 use crate::cli::Cli;
 use crate::errors::RustOrJsError;
 use crate::isolate::Isolate;

diff --git a/src/ops.rs b/src/ops.rs
@@ -18,6 +18,7 @@ use crate::resources;
 use crate::resources::table_entries;
 use crate::resources::Resource;
 use crate::tokio_util;
+use crate::tokio_write;
 use crate::version;
 use deno_core::deno_buf;
 use deno_core::JSError;
@@ -918,7 +919,7 @@ fn op_read(
   match resources::lookup(rid) {
     None => odd_future(errors::bad_resource()),
     Some(resource) => {
-      let op = resources::eager_read(resource, data)
+      let op = tokio::io::read(resource, data)
         .map_err(DenoError::from)
         .and_then(move |(_resource, _buf, nread)| {
           let builder = &mut FlatBufferBuilder::new();
@@ -956,7 +957,7 @@ fn op_write(
   match resources::lookup(rid) {
     None => odd_future(errors::bad_resource()),
     Some(resource) => {
-      let op = resources::eager_write(resource, data)
+      let op = tokio_write::write(resource, data)
         .map_err(DenoError::from)
         .and_then(move |(_resource, _buf, nwritten)| {
           let builder = &mut FlatBufferBuilder::new();
@@ -1551,7 +1552,7 @@ fn op_accept(
   match resources::lookup(server_rid) {
     None => odd_future(errors::bad_resource()),
     Some(server_resource) => {
-      let op = resources::eager_accept(server_resource)
+      let op = tokio_util::accept(server_resource)
         .map_err(DenoError::from)
         .and_then(move |(tcp_stream, _socket_addr)| {
           new_conn(cmd_id, tcp_stream)

diff --git a/src/resources.rs b/src/resources.rs
@@ -9,20 +9,15 @@
 // handlers) look up resources by their integer id here.
 
 use crate::cli::Buf;
-#[cfg(unix)]
-use crate::eager_unix as eager;
 use crate::errors;
 use crate::errors::bad_resource;
 use crate::errors::DenoError;
 use crate::errors::DenoResult;
 use crate::http_body::HttpBody;
 use crate::isolate_state::WorkerChannels;
 use crate::repl::Repl;
-use crate::tokio_util;
-use crate::tokio_write;
 
 use futures;
-use futures::future::{Either, FutureResult};
 use futures::Future;
 use futures::Poll;
 use futures::Sink;
@@ -39,7 +34,6 @@ use std::sync::{Arc, Mutex};
 use tokio;
 use tokio::io::{AsyncRead, AsyncWrite};
 use tokio::net::TcpStream;
-use tokio_io;
 use tokio_process;
 
 pub type ResourceId = u32; // Sometimes referred to RID.
@@ -440,94 +434,6 @@ pub fn lookup(rid: ResourceId) -> Option<Resource> {
   table.get(&rid).map(|_| Resource { rid })
 }
 
-pub type EagerRead<R, T> =
-  Either<tokio_io::io::Read<R, T>, FutureResult<(R, T, usize), std::io::Error>>;
-
-pub type EagerWrite<R, T> =
-  Either<tokio_write::Write<R, T>, FutureResult<(R, T, usize), std::io::Error>>;
-
-pub type EagerAccept = Either<
-  tokio_util::Accept,
-  FutureResult<(tokio::net::TcpStream, std::net::SocketAddr), std::io::Error>,
->;
-
-#[cfg(not(unix))]
-#[allow(unused_mut)]
-pub fn eager_read<T: AsMut<[u8]>>(
-  resource: Resource,
-  mut buf: T,
-) -> EagerRead<Resource, T> {
-  Either::A(tokio_io::io::read(resource, buf))
-}
-
-#[cfg(not(unix))]
-pub fn eager_write<T: AsRef<[u8]>>(
-  resource: Resource,
-  buf: T,
-) -> EagerWrite<Resource, T> {
-  Either::A(tokio_write::write(resource, buf))
-}
-
-#[cfg(not(unix))]
-pub fn eager_accept(resource: Resource) -> EagerAccept {
-  Either::A(tokio_util::accept(resource))
-}
-
-// This is an optimization that Tokio should do.
-// Attempt to call read() on the main thread.
-#[cfg(unix)]
-pub fn eager_read<T: AsMut<[u8]>>(
-  resource: Resource,
-  buf: T,
-) -> EagerRead<Resource, T> {
-  let mut table = RESOURCE_TABLE.lock().unwrap();
-  let maybe_repr = table.get_mut(&resource.rid);
-  match maybe_repr {
-    None => panic!("bad rid"),
-    Some(repr) => match repr {
-      Repr::TcpStream(ref mut tcp_stream) => {
-        eager::tcp_read(tcp_stream, resource, buf)
-      }
-      _ => Either::A(tokio_io::io::read(resource, buf)),
-    },
-  }
-}
-
-// This is an optimization that Tokio should do.
-// Attempt to call write() on the main thread.
-#[cfg(unix)]
-pub fn eager_write<T: AsRef<[u8]>>(
-  resource: Resource,
-  buf: T,
-) -> EagerWrite<Resource, T> {
-  let mut table = RESOURCE_TABLE.lock().unwrap();
-  let maybe_repr = table.get_mut(&resource.rid);
-  match maybe_repr {
-    None => panic!("bad rid"),
-    Some(repr) => match repr {
-      Repr::TcpStream(ref mut tcp_stream) => {
-        eager::tcp_write(tcp_stream, resource, buf)
-      }
-      _ => Either::A(tokio_write::write(resource, buf)),
-    },
-  }
-}
-
-#[cfg(unix)]
-pub fn eager_accept(resource: Resource) -> EagerAccept {
-  let mut table = RESOURCE_TABLE.lock().unwrap();
-  let maybe_repr = table.get_mut(&resource.rid);
-  match maybe_repr {
-    None => panic!("bad rid"),
-    Some(repr) => match repr {
-      Repr::TcpListener(ref mut tcp_listener, _) => {
-        eager::tcp_accept(tcp_listener, resource)
-      }
-      _ => Either::A(tokio_util::accept(resource)),
-    },
-  }
-}
-
 // TODO(kevinkassimo): revamp this after the following lands:
 // https://github.com/tokio-rs/tokio/pull/785
 pub fn seek(