@@ -162,10 +162,30 @@ impl std::fmt::Display for JobId {
162162 }
163163}
164164
165+ /// A `JobState` is constructed by `JobQueue::run` and passed to `Job::run`. It includes everything
166+ /// necessary to communicate between the main thread and the execution of the job.
167+ ///
168+ /// The job may execute on either a dedicated thread or the main thread. If the job executes on the
169+ /// main thread, the `output` field must be set to prevent a deadlock.
165170pub struct JobState < ' a > {
166171 /// Channel back to the main thread to coordinate messages and such.
172+ ///
173+ /// When the `output` field is `Some`, care must be taken to avoid calling `push_bounded` on
174+ /// the message queue to prevent a deadlock.
167175messages : Arc < Queue < Message > > ,
168176
177+ /// Normally output is sent to the job queue with backpressure. When the job is fresh
178+ /// however we need to immediately display the output to prevent a deadlock as the
179+ /// output messages are processed on the same thread as they are sent from. `output`
180+ /// defines where to output in this case.
181+ ///
182+ /// Currently the `Shell` inside `Config` is wrapped in a `RefCell` and thus can't be passed
183+ /// between threads. This means that it isn't possible for multiple output messages to be
184+ /// interleaved. In the future, it may be wrapped in a `Mutex` instead. In this case
185+ /// interleaving is still prevented as the lock would be held for the whole printing of an
186+ /// output message.
187+ output : Option < & ' a Config > ,
188+
169189 /// The job id that this state is associated with, used when sending
170190/// messages back to the main thread.
171191id : JobId ,
@@ -231,12 +251,24 @@ impl<'a> JobState<'a> {
231251 . push ( Message :: BuildPlanMsg ( module_name, cmd, filenames) ) ;
232252 }
233253
234- pub fn stdout ( & self , stdout : String ) {
235- self . messages . push_bounded ( Message :: Stdout ( stdout) ) ;
254+ pub fn stdout ( & self , stdout : String ) -> CargoResult < ( ) > {
255+ if let Some ( config) = self . output {
256+ writeln ! ( config. shell( ) . out( ) , "{}" , stdout) ?;
257+ } else {
258+ self . messages . push_bounded ( Message :: Stdout ( stdout) ) ;
259+ }
260+ Ok ( ( ) )
236261 }
237262
238- pub fn stderr ( & self , stderr : String ) {
239- self . messages . push_bounded ( Message :: Stderr ( stderr) ) ;
263+ pub fn stderr ( & self , stderr : String ) -> CargoResult < ( ) > {
264+ if let Some ( config) = self . output {
265+ let mut shell = config. shell ( ) ;
266+ shell. print_ansi ( stderr. as_bytes ( ) ) ?;
267+ shell. err ( ) . write_all ( b"\n " ) ?;
268+ } else {
269+ self . messages . push_bounded ( Message :: Stderr ( stderr) ) ;
270+ }
271+ Ok ( ( ) )
240272 }
241273
242274 /// A method used to signal to the coordinator thread that the rmeta file
@@ -826,16 +858,9 @@ impl<'cfg> DrainState<'cfg> {
826858 self . note_working_on ( cx. bcx . config , unit, fresh) ?;
827859 }
828860
829- let doit = move || {
830- let state = JobState {
831- id,
832- messages : messages. clone ( ) ,
833- rmeta_required : Cell :: new ( rmeta_required) ,
834- _marker : marker:: PhantomData ,
835- } ;
836-
861+ let doit = move |state : JobState < ' _ > | {
837862 let mut sender = FinishOnDrop {
838- messages : & messages,
863+ messages : & state . messages ,
839864 id,
840865 result : None ,
841866 } ;
@@ -854,7 +879,9 @@ impl<'cfg> DrainState<'cfg> {
854879 // we need to make sure that the metadata is flagged as produced so
855880 // send a synthetic message here.
856881 if state. rmeta_required . get ( ) && sender. result . as_ref ( ) . unwrap ( ) . is_ok ( ) {
857- messages. push ( Message :: Finish ( id, Artifact :: Metadata , Ok ( ( ) ) ) ) ;
882+ state
883+ . messages
884+ . push ( Message :: Finish ( state. id , Artifact :: Metadata , Ok ( ( ) ) ) ) ;
858885 }
859886
860887 // Use a helper struct with a `Drop` implementation to guarantee
@@ -880,10 +907,31 @@ impl<'cfg> DrainState<'cfg> {
880907 } ;
881908
882909 match fresh {
883- Freshness :: Fresh => self . timings . add_fresh ( ) ,
884- Freshness :: Dirty => self . timings . add_dirty ( ) ,
910+ Freshness :: Fresh => {
911+ self . timings . add_fresh ( ) ;
912+ // Running a fresh job on the same thread is often much faster than spawning a new
913+ // thread to run the job.
914+ doit ( JobState {
915+ id,
916+ messages : messages. clone ( ) ,
917+ output : Some ( cx. bcx . config ) ,
918+ rmeta_required : Cell :: new ( rmeta_required) ,
919+ _marker : marker:: PhantomData ,
920+ } ) ;
921+ }
922+ Freshness :: Dirty => {
923+ self . timings . add_dirty ( ) ;
924+ scope. spawn ( move |_| {
925+ doit ( JobState {
926+ id,
927+ messages : messages. clone ( ) ,
928+ output : None ,
929+ rmeta_required : Cell :: new ( rmeta_required) ,
930+ _marker : marker:: PhantomData ,
931+ } )
932+ } ) ;
933+ }
885934 }
886- scope. spawn ( move |_| doit ( ) ) ;
887935
888936 Ok ( ( ) )
889937 }
0 commit comments