Track whether to emit jobserver messages

This adds the -Zjobserver-token-requests debugging flag which Cargo will
pass down to us, but for now that flag doesn't do anything.

We don't really have a good way to deal with multiple initialize calls
so for now this implementation just ignores all but the first
construction's token requesting mode. It's plausible we should assert
that all calls have the same mode, but it's unclear whether that really
brings us any benefits (and it does have a cost of forcing people to
thread things through on their end).

Author: Mark-Simulacrum

src/librustc_jobserver/lib.rs

@@ -1,5 +1,6 @@
 use jobserver_crate::Client;
 use lazy_static::lazy_static;
+use std::sync::atomic::{Ordering, AtomicUsize};
 
 lazy_static! {
     // We can only call `from_env` once per process
@@ -35,10 +36,37 @@ lazy_static! {
 // That makes this function necessary unlike in the release case where everything is piped through
 // `release_thread`.
 fn notify_acquiring_token() {
-    // this function does nothing for now but will be wired up to send a message to Cargo
+    if should_notify() {
+        // FIXME: tell Cargo of our interest
+    }
+}
+
+const EMPTY: usize = 0;
+const CARGO_REQUESTED: usize = 1;
+const MAKE_REQUESTED: usize = 2;
+static TOKEN_REQUESTS: AtomicUsize = AtomicUsize::new(0);
+
+fn should_notify() -> bool {
+    let value = TOKEN_REQUESTS.load(Ordering::SeqCst);
+    assert_ne!(value, EMPTY, "jobserver must be initialized");
+    value == CARGO_REQUESTED
 }
 
-pub fn initialize() {
+/// This changes a global value to the new value of token_requests, which means
+/// that you probably don't want to be calling this more than once per process.
+/// Unfortunately the jobserver is inherently a global resource (we can't have
+/// more than one) so the token requesting strategy must likewise be global.
+///
+/// Usually this doesn't matter too much, as you're not wanting to set the token
+/// requests unless you're in the one-rustc-per-process model, and we help out
+/// here a bit by not resetting it once it's set (i.e., only the first init will
+/// change the value).
+pub fn initialize(token_requests: bool) {
+    TOKEN_REQUESTS.compare_and_swap(
+        EMPTY,
+        if token_requests { CARGO_REQUESTED } else { MAKE_REQUESTED },
+        Ordering::SeqCst,
+    );
     lazy_static::initialize(&GLOBAL_CLIENT)
 }
 

src/librustc_session/config.rs

@@ -1570,6 +1570,8 @@ options! {DebuggingOptions, DebuggingSetter, basic_debugging_options,
     insert_sideeffect: bool = (false, parse_bool, [TRACKED],
         "fix undefined behavior when a thread doesn't eventually make progress \
          (such as entering an empty infinite loop) by inserting llvm.sideeffect"),
+    jobserver_token_requests: bool = (false, parse_bool, [UNTRACKED],
+        "Coordinate with caller through JSON messages on acquiring/releasing jobserver tokens"),
 }
 
 pub const fn default_lib_output() -> CrateType {

src/librustc_session/session.rs

@@ -1126,7 +1126,20 @@ fn build_session_(
         CguReuseTracker::new_disabled()
     };
 
-    rustc_jobserver::initialize();
+    if sopts.debugging_opts.jobserver_token_requests {
+        if let config::ErrorOutputType::Json { .. } = sopts.error_format {
+            if is_diagnostic_output_raw {
+                panic!("Raw output format not supported with -Zjobserver-token-requests");
+            }
+        } else {
+            parse_sess.span_diagnostic
+                .fatal("-Zjobserver-token-requests can only be specified if \
+                        using JSON error output type")
+                .raise();
+        }
+    }
+
+    rustc_jobserver::initialize(sopts.debugging_opts.jobserver_token_requests);
 
     let sess = Session {
         target: target_cfg,