refactor: Use Tokio's single-threaded runtime (#3844)

This change simplifies how we execute V8. Previously V8 Isolates jumped
around threads every time they were woken up. This was overly complex and
potentially hurting performance in a myriad ways. Now isolates run on
their own dedicated thread and never move.

- blocking_json spawns a thread and does not use a thread pool
- op_host_poll_worker and op_host_resume_worker are non-operational
- removes Worker::get_message and Worker::post_message
- ThreadSafeState::workers table contains WorkerChannel entries instead
  of actual Worker instances.
- MainWorker and CompilerWorker are no longer Futures.
- The multi-threaded version of deno_core_http_bench was removed.
- AyncOps no longer need to be Send + Sync

This PR is very large and several tests were disabled to speed
integration:
- installer_test_local_module_run
- installer_test_remote_module_run
- _015_duplicate_parallel_import
- _026_workers

1 files changed, 11 insertions, 9 deletions

diff --git a/core/modules.rs b/core/modules.rs
index c02bd4cab..b2d057219 100644
--- a/core/modules.rs
+++ b/core/modules.rs
@@ -21,9 +21,9 @@ use std::task::Context;
 use std::task::Poll;
 
 pub type SourceCodeInfoFuture =
-  dyn Future<Output = Result<SourceCodeInfo, ErrBox>> + Send;
+  dyn Future<Output = Result<SourceCodeInfo, ErrBox>>;
 
-pub trait Loader: Send + Sync {
+pub trait Loader: Send {
   /// Returns an absolute URL.
   /// When implementing an spec-complaint VM, this should be exactly the
   /// algorithm described here:
@@ -148,7 +148,7 @@ impl RecursiveModuleLoad {
       _ => self
         .loader
         .load(&module_specifier, None, self.is_dynamic_import())
-        .boxed(),
+        .boxed_local(),
     };
 
     self.pending.push(load_fut);
@@ -167,7 +167,7 @@ impl RecursiveModuleLoad {
         self
           .loader
           .load(&specifier, Some(referrer), self.is_dynamic_import());
-      self.pending.push(fut.boxed());
+      self.pending.push(fut.boxed_local());
       self.is_pending.insert(specifier);
     }
   }
@@ -759,7 +759,7 @@ mod tests {
         ])
       );
     }
-    .boxed();
+    .boxed_local();
 
     futures::executor::block_on(fut);
   }
@@ -818,7 +818,7 @@ mod tests {
         Some(redirect3_id)
       );
     }
-    .boxed();
+    .boxed_local();
 
     futures::executor::block_on(fut);
   }
@@ -846,7 +846,8 @@ mod tests {
       let loads = loader.loads.clone();
       let mut isolate =
         EsIsolate::new(Box::new(loader), StartupData::None, false);
-      let mut recursive_load = isolate.load_module("/main.js", None).boxed();
+      let mut recursive_load =
+        isolate.load_module("/main.js", None).boxed_local();
 
       let result = recursive_load.poll_unpin(&mut cx);
       assert!(result.is_pending());
@@ -891,7 +892,8 @@ mod tests {
       let loader = MockLoader::new();
       let mut isolate =
         EsIsolate::new(Box::new(loader), StartupData::None, false);
-      let mut load_fut = isolate.load_module("/bad_import.js", None).boxed();
+      let mut load_fut =
+        isolate.load_module("/bad_import.js", None).boxed_local();
       let result = load_fut.poll_unpin(&mut cx);
       if let Poll::Ready(Err(err)) = result {
         assert_eq!(
@@ -924,7 +926,7 @@ mod tests {
     // The behavior should be very similar to /a.js.
     let main_id_fut = isolate
       .load_module("/main_with_code.js", Some(MAIN_WITH_CODE_SRC.to_owned()))
-      .boxed();
+      .boxed_local();
     let main_id =
       futures::executor::block_on(main_id_fut).expect("Failed to load");