Use rayon thread local values instead of TLS_TCX and fix a deadlock

Author: Zoxc

src/Cargo.lock

@@ -16,7 +16,7 @@ graphviz = { path = "../libgraphviz" }
 jobserver = "0.1"
 log = "0.3"
 rayon = { git = "https://github.com/Zoxc/rayon.git", branch = "fiber" }
-rayon-core = { git = "https://github.com/Zoxc/rayon.git", branch = "fiber", features=["debug"] }
+rayon-core = { git = "https://github.com/Zoxc/rayon.git", branch = "fiber", features=["debug", "tlv"] }
 scoped-tls = { git = "https://github.com/Zoxc/scoped-tls.git", features=["nightly"] }
 owning_ref = { git = "https://github.com/Zoxc/owning-ref-rs.git" }
 rustc_back = { path = "../librustc_back" }

src/librustc/Cargo.toml

@@ -1364,7 +1364,12 @@ impl<'gcx: 'tcx, 'tcx> GlobalCtxt<'gcx> {
         where F: for<'a> FnOnce(TyCtxt<'a, 'gcx, 'tcx>) -> R
     {
         let interners = CtxtInterners::new(arena);
-        tls::enter(self, &interners, query, f)
+        let tcx = TyCtxt {
+            gcx: self,
+            interners: &interners,
+            query,
+        };
+        tls::enter(tcx, f)
     }
 }
 
@@ -1511,26 +1516,13 @@ impl<'a, 'tcx> Lift<'tcx> for &'a Slice<Predicate<'a>> {
 }
 
 pub mod tls {
-    use super::{CtxtInterners, GlobalCtxt, TyCtxt};
+    use super::{GlobalCtxt, TyCtxt};
 
-    use std::cell::Cell;
     use std::fmt;
     use syntax_pos;
     use ty::maps;
     use errors::{Diagnostic, TRACK_DIAGNOSTICS};
-
-    /// Marker types used for the scoped TLS slot.
-    /// The type context cannot be used directly because the scoped TLS
-    /// in libstd doesn't allow types generic over lifetimes.
-    enum ThreadLocalGlobalCtxt {}
-    enum ThreadLocalInterners {}
-    enum ThreadLocalQuery {}
-
-    thread_local! {
-        static TLS_TCX: Cell<Option<(*const ThreadLocalGlobalCtxt,
-                                     *const ThreadLocalInterners,
-                                     *const ThreadLocalQuery)>> = Cell::new(None)
-    }
+    use rayon_core;
 
     fn span_debug(span: syntax_pos::Span, f: &mut fmt::Formatter) -> fmt::Result {
         with(|tcx| {
@@ -1558,7 +1550,12 @@ pub mod tls {
                 current.set(track_diagnostic);
 
                 let global_query = maps::QueryJob::new(Vec::new(), false, false);
-                let result = enter(&gcx, &gcx.global_interners, &global_query, f);
+                let tcx = TyCtxt {
+                    gcx,
+                    interners: &gcx.global_interners,
+                    query: &global_query,
+                };
+                let result = enter(tcx, f);
                 current.set(original);
                 result
             });
@@ -1568,52 +1565,31 @@ pub mod tls {
         })
     }
 
-    pub fn enter<'a, 'gcx: 'tcx, 'tcx, F, R>(gcx: &'a GlobalCtxt<'gcx>,
-                                             interners: &'a CtxtInterners<'tcx>,
-                                             query: &'a maps::QueryJob<'gcx>,
+    pub fn enter<'a, 'gcx: 'tcx, 'tcx, F, R>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
                                              f: F) -> R
         where F: FnOnce(TyCtxt<'a, 'gcx, 'tcx>) -> R
     {
-        let tls_query = maps::QueryJob::new(Vec::new(), false, true);
-        let gcx_ptr = gcx as *const _ as *const ThreadLocalGlobalCtxt;
-        let interners_ptr = interners as *const _ as *const ThreadLocalInterners;
-        let query_ptr = &tls_query as *const _ as *const ThreadLocalQuery;
-        TLS_TCX.with(|tls| {
-            let prev = tls.get();
-            tls.set(Some((gcx_ptr, interners_ptr, query_ptr)));
-            let ret = f(TyCtxt {
-                gcx,
-                interners,
-                query,
-            });
-            tls.set(prev);
-            ret
+        rayon_core::fiber::tlv::set(&tcx as *const _ as usize, || {
+            f(tcx)
         })
     }
 
     pub fn with<F, R>(f: F) -> R
         where F: for<'a, 'gcx, 'tcx> FnOnce(TyCtxt<'a, 'gcx, 'tcx>) -> R
     {
-        TLS_TCX.with(|tcx| {
-            let (gcx, interners, query) = tcx.get().unwrap();
-            let gcx = unsafe { &*(gcx as *const GlobalCtxt) };
-            let interners = unsafe { &*(interners as *const CtxtInterners) };
-            let query = unsafe { &*(query as *const maps::QueryJob) };
-            f(TyCtxt {
-                gcx,
-                interners,
-                query,
-            })
-        })
+        let tcx = rayon_core::fiber::tlv::get();
+        assert!(tcx != 0);
+        unsafe { f(*(tcx as *const TyCtxt)) }
     }
 
     pub fn with_opt<F, R>(f: F) -> R
         where F: for<'a, 'gcx, 'tcx> FnOnce(Option<TyCtxt<'a, 'gcx, 'tcx>>) -> R
     {
-        if TLS_TCX.with(|tcx| tcx.get().is_some()) {
-            with(|v| f(Some(v)))
-        } else {
+        let tcx = rayon_core::fiber::tlv::get();
+        if tcx == 0 {
             f(None)
+        } else {
+            unsafe { f(Some(*(tcx as *const TyCtxt))) }
         }
     }
 }

src/librustc/ty/context.rs

@@ -98,6 +98,19 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         })
     }
 
+    pub(super) fn cycle_check(self, span: Span, query: &Query<'gcx>) -> Result<(), CycleError<'gcx>>
+    {
+        if let Some((i, _)) = self.query().stack.iter().enumerate().rev()
+                                 .find(|&(_, &(_, ref q))| q == query) {
+            Err(CycleError {
+                span,
+                cycle: self.query().stack[i..].iter().cloned().collect(),
+            })
+        } else {
+            Ok(())
+        }
+    }
+
     /// Try to read a node index for the node dep_node.
     /// A node will have an index, when it's already been marked green, or when we can mark it
     /// green. This function will mark the current task as a reader of the specified node, when
@@ -167,8 +180,8 @@ macro_rules! define_maps {
         use rustc_data_structures::sync::{Lock, LockGuard};
         use std::iter;
         use errors::Diagnostic;
-        use std::sync::atomic::Ordering;
         use ty::maps::plumbing::QUERY_DEPTH;
+        use std::sync::atomic::Ordering;
 
         define_map_struct! {
             tcx: $tcx,
@@ -258,7 +271,7 @@ macro_rules! define_maps {
                         QueryMsg::$name(profq_key!(tcx, key))
                     )
                 );
-/*
+
                 loop {
                     let job = if let Some(value) = tcx.maps.$name.borrow().map.get(&key) {
                         match *value {
@@ -272,10 +285,25 @@ macro_rules! define_maps {
                     } else {
                         break
                     };
-                    assert!(!tcx.query().tls);
-                    job.await();
-                }*/
+                    lazy_static! {
+                        static ref LOG: bool = ::std::env::var("QUERY_LOG").is_ok();
+                    }
+
+                    if *LOG {
+                        println!("({}) waiting on query {:?} latch {:x}",
+                        QUERY_DEPTH.load(Ordering::SeqCst),
+                        Query::$name(Clone::clone(&key)), &job.latch as *const _ as usize);
+                        for i in tcx.query().stack.iter() {
+                            println!("    query stack entry {:?}", i);
 
+                        }
+                    }
+                    // If there is a cycle, waiting will never complete
+                    tcx.cycle_check(span, &Query::$name(Clone::clone(&key)))?;
+                    job.await();
+                }
+/*
+                use std::sync::atomic::Ordering;
                 #[allow(warnings)]
                 loop {
                     let job = if let Some(value) = tcx.maps.$name.borrow().map.get(&key) {
@@ -304,7 +332,7 @@ macro_rules! define_maps {
                     };
                     //job.await();
                 }
-
+*/
                 // FIXME(eddyb) Get more valid Span's on queries.
                 // def_span guard is necessary to prevent a recursive loop,
                 // default_span calls def_span query internally.
@@ -403,24 +431,14 @@ macro_rules! define_maps {
                 -> Result<((R, Vec<Diagnostic>), Lrc<QueryJob<$tcx>>), CycleError<$tcx>>
                 where F: for<'b> FnOnce(TyCtxt<'b, $tcx, 'lcx>) -> R
             {
-                assert!(!tcx.query().tls);
-
                 let query = Query::$name(Clone::clone(&key));
 
-                if let Some((i, _)) = tcx.query().stack.iter().enumerate().rev()
-                                        .find(|&(_, &(_, ref q))| *q == query) {
-                    return Err(CycleError {
-                        span,
-                        cycle: tcx.query().stack.iter().step_by(i).cloned().collect(),
-                    });
-                }
+                tcx.cycle_check(span, &query)?;
 
                 lazy_static! {
                     static ref LOG: bool = ::std::env::var("QUERY_LOG").is_ok();
                 }
 
-                use std::sync::atomic::Ordering;
-
                 let entry = (span, query);
                 let stack = tcx.query().stack.iter().cloned().chain(iter::once(entry)).collect();
                 let job = Lrc::new(QueryJob::new(stack, true, false));
@@ -447,7 +465,9 @@ macro_rules! define_maps {
                        .or_insert(QueryResult::Started(job.clone()));
                 }
 
-                let r = compute(tcx.with_query(&*job));
+                let r = ty::tls::enter(tcx.with_query(&*job), |new_tcx| {
+                    compute(new_tcx)
+                });
 
                 if *LOG {
                     println!("ending query {:?}", query.clone());