wip

Author: Zoxc

src/librustc/Cargo.toml

@@ -15,6 +15,7 @@ fmt_macros = { path = "../libfmt_macros" }
 graphviz = { path = "../libgraphviz" }
 jobserver = "0.1"
 lazy_static = "1.0.0"
+scoped-tls = { version = "0.1.1", features = ["nightly"] }
 log = { version = "0.4", features = ["release_max_level_info", "std"] }
 proc_macro = { path = "../libproc_macro" }
 rustc-rayon-core = { git = "https://github.com/Zoxc/rayon.git", branch = "rustc" }

src/librustc/lib.rs

@@ -84,6 +84,7 @@ extern crate fmt_macros;
 extern crate getopts;
 extern crate graphviz;
 #[macro_use] extern crate lazy_static;
+#[macro_use] extern crate scoped_tls;
 #[cfg(windows)]
 extern crate libc;
 extern crate rustc_target;

src/librustc/ty/context.rs

@@ -1756,7 +1756,7 @@ pub mod tls {
     use rustc_data_structures::OnDrop;
     use rayon_core;
     use dep_graph::OpenTask;
-    use rustc_data_structures::sync::{self, Lrc};
+    use rustc_data_structures::sync::{self, Lrc, Lock};
 
     /// This is the implicit state of rustc. It contains the current
     /// TyCtxt and query. It is updated when creating a local interner or
@@ -1872,6 +1872,13 @@ pub mod tls {
         where F: for<'a> FnOnce(TyCtxt<'a, 'gcx, 'gcx>) -> R
     {
         with_thread_locals(|| {
+            GCX_PTR.with(|lock| {
+                *lock.lock() = gcx as *const _ as usize;
+            });
+            let _on_drop = OnDrop(move || {
+                GCX_PTR.with(|lock| *lock.lock() = 0);
+            });
+
             let tcx = TyCtxt {
                 gcx,
                 interners: &gcx.global_interners,
@@ -1888,6 +1895,25 @@ pub mod tls {
         })
     }
 
+    scoped_thread_local!(pub static GCX_PTR: Lock<usize>);
+
+    pub unsafe fn with_global<F, R>(f: F) -> R
+        where F: for<'a, 'gcx, 'tcx> FnOnce(TyCtxt<'a, 'gcx, 'tcx>) -> R
+    {
+        let gcx = &*(GCX_PTR.with(|lock| *lock.lock()) as *const GlobalCtxt<'_>);
+        let tcx = TyCtxt {
+            gcx,
+            interners: &gcx.global_interners,
+        };
+        let icx = ImplicitCtxt {
+            query: None,
+            tcx,
+            layout_depth: 0,
+            task: &OpenTask::Ignore,
+        };
+        enter_context(&icx, |_| f(tcx))
+    }
+
     /// Allows access to the current ImplicitCtxt in a closure if one is available
     pub fn with_context_opt<F, R>(f: F) -> R
         where F: for<'a, 'gcx, 'tcx> FnOnce(Option<&ImplicitCtxt<'a, 'gcx, 'tcx>>) -> R

src/librustc/ty/maps/job.rs

@@ -24,6 +24,7 @@ use std::fmt;
 use std::collections::HashSet;
 #[cfg(parallel_queries)]
 use {
+    rayon_core,
     parking_lot::{Mutex, Condvar},
     std::sync::atomic::Ordering,
     std::thread,
@@ -172,6 +173,7 @@ impl<'a, 'tcx> QueryWaiter<'a, 'tcx> {
             ::std::thread::current().id(),
             tcx.active_threads.load(Ordering::SeqCst),
             &self.condvar as *const _ as usize);
+        rayon_core::unblock();
         self.condvar.notify_one();
     }
 }
@@ -207,14 +209,17 @@ impl QueryLatch {
                 info.waiters.push(mem::transmute(waiter));
             }
             if tcx.active_threads.fetch_sub(1, Ordering::SeqCst) == 1 {
+                /*
                 // We are the last active thread, waiting here would cause a deadlock.
                 // Spawn a thread to handle the deadlock before we go to sleep
                 handle_deadlock(tcx);
+                */
             }
             eprintln!("[{:?}] (await) active threads: {} condvar: {:x}",
                 ::std::thread::current().id(),
                 tcx.active_threads.load(Ordering::SeqCst),
                 &waiter.condvar as *const _ as usize);
+            rayon_core::block();
             waiter.condvar.wait(&mut info);
         }
     }
@@ -442,25 +447,32 @@ fn remove_cycle<'tcx>(
 }
 
 #[cfg(parallel_queries)]
-fn handle_deadlock(tcx: TyCtxt<'_, '_, '_>) {
+pub fn handle_deadlock() {
     use syntax;
     use syntax_pos;
 
+    let gcx_ptr = tls::GCX_PTR.with(|gcx_ptr| {
+        gcx_ptr as *const _
+    });
+    let gcx_ptr = unsafe { &*gcx_ptr };
+
     let syntax_globals = syntax::GLOBALS.with(|syntax_globals| {
         syntax_globals as *const _
     });
     let syntax_globals = unsafe { &*syntax_globals };
+
     let syntax_pos_globals = syntax_pos::GLOBALS.with(|syntax_pos_globals| {
         syntax_pos_globals as *const _
     });
     let syntax_pos_globals = unsafe { &*syntax_pos_globals };
-    let tcx: TyCtxt<'static, 'static, 'static> = unsafe { mem::transmute(tcx) };
     thread::spawn(move || {
-        syntax::GLOBALS.set(syntax_globals, || {
+        tls::GCX_PTR.set(gcx_ptr, || {
             syntax_pos::GLOBALS.set(syntax_pos_globals, || {
-                tls::with_thread_locals(|| {
-                    tls::enter_global(&*tcx, |_| {
-                        deadlock(tcx)
+                syntax_pos::GLOBALS.set(syntax_pos_globals, || {
+                    tls::with_thread_locals(|| {
+                        unsafe {
+                            tls::with_global(|tcx| deadlock(tcx))
+                        }
                     })
                 })
             })

src/librustc/ty/maps/mod.rs

@@ -66,7 +66,7 @@ use self::plumbing::*;
 pub use self::plumbing::{force_from_dep_node, CycleError};
 
 mod job;
-pub use self::job::{QueryJob, QueryInfo};
+pub use self::job::{QueryJob, QueryInfo, handle_deadlock};
 
 mod keys;
 pub use self::keys::Key;

src/librustc_driver/driver.rs

@@ -49,7 +49,7 @@ use std::fs;
 use std::io::{self, Write};
 use std::iter;
 use std::path::{Path, PathBuf};
-use rustc_data_structures::sync::{self, Lrc};
+use rustc_data_structures::sync::{self, Lrc, Lock};
 use std::sync::mpsc;
 use syntax::{self, ast, attr, diagnostics, visit};
 use syntax::ext::base::ExtCtxt;
@@ -69,7 +69,9 @@ pub fn spawn_thread_pool<F: FnOnce(config::Options) -> R + sync::Send, R: sync::
     opts: config::Options,
     f: F
 ) -> R {
-    f(opts)
+    ty::tls::GCX_PTR.set(&Lock::new(0), || {
+        f(opts)
+    })
 }
 
 #[cfg(parallel_queries)]
@@ -81,7 +83,10 @@ pub fn spawn_thread_pool<F: FnOnce(config::Options) -> R + sync::Send, R: sync::
     use syntax_pos;
     use rayon::{ThreadPoolBuilder, ThreadPool};
 
+    let gcx_ptr = &Lock::new(0);
+
     let config = ThreadPoolBuilder::new().num_threads(Session::query_threads_from_opts(&opts))
+                                         .deadlock_handler(ty::maps::handle_deadlock)
                                          .stack_size(16 * 1024 * 1024);
 
     let with_pool = move |pool: &ThreadPool| {
@@ -98,7 +103,9 @@ pub fn spawn_thread_pool<F: FnOnce(config::Options) -> R + sync::Send, R: sync::
                 syntax::GLOBALS.set(syntax_globals, || {
                     syntax_pos::GLOBALS.set(syntax_pos_globals, || {
                         ty::tls::with_thread_locals(|| {
-                            worker()
+                            ty::tls::GCX_PTR.set(gcx_ptr, || {
+                                worker()
+                            })
                         })
                     })
                 })