Implement frontend parseable-output batch job quasi-PID assignment.

Starting at a crude -1000, each invocation primary input will get its own unique quasi-Pid.
Invocations with only one primary (non-batch) will get a real OS Pid.

The selection of the constant starting point matches what the driver does when outputting its parseable output.

Author: artemcm

include/swift/Basic/ParseableOutput.h

@@ -27,15 +27,23 @@ namespace swift {
 
 namespace parseable_output {
 
+/// Quasi-PIDs are _negative_ PID-like unique keys used to
+/// masquerade batch job constituents as (quasi)processes, when writing
+/// parseable output to consumers that don't understand the idea of a batch
+/// job. They are negative in order to avoid possibly colliding with real
+/// PIDs (which are always positive). We start at -1000 here as a crude but
+/// harmless hedge against colliding with an errno value that might slip
+/// into the stream of real PIDs (say, due to a TaskQueue bug).
+const int QUASI_PID_START = -1000;
+
 /// Emits a "began" message to the given stream, corresponding to a Driver Job.
 void emitBeganMessage(raw_ostream &os, const driver::Job &Cmd, int64_t Pid,
                       sys::TaskProcessInformation ProcInfo);
 
 /// Emits a "began" message to the given stream, corresponding to a given
 /// Frontend Compiler Invocation.
 void emitBeganMessage(raw_ostream &os, const CompilerInvocation &Invocation,
-                      ArrayRef<const char *> Args, int64_t Pid,
-                      sys::TaskProcessInformation ProcInfo);
+                      ArrayRef<const char *> Args, int64_t OSPid);
 
 /// Emits a "finished" message to the given stream.
 void emitFinishedMessage(raw_ostream &os, const driver::Job &Cmd, int64_t Pid,
@@ -45,10 +53,9 @@ void emitFinishedMessage(raw_ostream &os, const driver::Job &Cmd, int64_t Pid,
 /// Emits a "finished" message to the given stream corresponding to a given
 /// Frontend Compiler Invocation.
 void emitFinishedMessage(
-    raw_ostream &os, const CompilerInvocation &Invocation, int64_t Pid,
-    int ExitStatus,
+    raw_ostream &os, const CompilerInvocation &Invocation, int ExitStatus,
     const llvm::StringMap<std::vector<std::string>> &FileSpecificDiagnostics,
-    sys::TaskProcessInformation ProcInfo);
+    int64_t OSPid);
 
 /// Emits a "signalled" message to the given stream.
 void emitSignalledMessage(raw_ostream &os, const driver::Job &Cmd, int64_t Pid,

include/swift/Frontend/FrontendInputsAndOutputs.h

@@ -110,6 +110,11 @@ class FrontendInputsAndOutputs {
   bool
   forEachPrimaryInput(llvm::function_ref<bool(const InputFile &)> fn) const;
 
+  /// Iterates over primary inputs, exposing their unique ordered index
+  /// If \p fn returns true, exit early and return true.
+  bool forEachPrimaryInputWithIndex(
+      llvm::function_ref<bool(const InputFile &, unsigned index)> fn) const;
+
   /// If \p fn returns true, exit early and return true.
   bool
   forEachNonPrimaryInput(llvm::function_ref<bool(const InputFile &)> fn) const;

lib/Basic/ParseableOutput.cpp

@@ -420,11 +420,18 @@ void parseable_output::emitBeganMessage(raw_ostream &os, const driver::Job &Cmd,
 void parseable_output::emitBeganMessage(raw_ostream &os,
                                         const CompilerInvocation &Invocation,
                                         ArrayRef<const char *> Args,
-                                        int64_t Pid,
-                                        TaskProcessInformation ProcInfo) {
+                                        int64_t OSPid) {
   const auto &IO = Invocation.getFrontendOptions().InputsAndOutputs;
-  IO.forEachPrimaryInput([&](const InputFile &Input) -> bool {
-    BeganInvocationMessage msg(Invocation, Input, Args, Pid, ProcInfo);
+  const auto ProcInfo = sys::TaskProcessInformation(OSPid);
+
+  // Parseable output clients may not understand the idea of a batch
+  // compilation. We assign each primary in a batch job a quasi process id,
+  // making sure it cannot collide with a real PID (always positive). Non-batch
+  // compilation gets a real OS PID.
+  int64_t Pid = IO.hasUniquePrimaryInput() ? OSPid : QUASI_PID_START;
+  IO.forEachPrimaryInputWithIndex([&](const InputFile &Input,
+                                      unsigned idx) -> bool {
+    BeganInvocationMessage msg(Invocation, Input, Args, Pid - idx, ProcInfo);
     emitMessage(os, msg);
     return false;
   });
@@ -439,27 +446,33 @@ void parseable_output::emitFinishedMessage(raw_ostream &os,
 }
 
 void parseable_output::emitFinishedMessage(
-    raw_ostream &os, const CompilerInvocation &Invocation, int64_t Pid,
-    int ExitStatus,
+    raw_ostream &os, const CompilerInvocation &Invocation, int ExitStatus,
     const llvm::StringMap<std::vector<std::string>> &FileSpecificDiagnostics,
-    TaskProcessInformation ProcInfo) {
+    int64_t OSPid) {
   const auto &IO = Invocation.getFrontendOptions().InputsAndOutputs;
-  IO.forEachPrimaryInput([&](const InputFile &Input) -> bool {
-    assert(FileSpecificDiagnostics.count(Input.getFileName()) != 0 &&
-           "Expected diagnostic collection for input.");
-
-    // Join all diagnostics produced for this file into a single output.
-    auto PrimaryDiags = FileSpecificDiagnostics.lookup(Input.getFileName());
-    const char* const Delim = "\n";
-    std::ostringstream JoinedDiags;
-    std::copy(PrimaryDiags.begin(), PrimaryDiags.end(),
-              std::ostream_iterator<std::string>(JoinedDiags, Delim));
-    FinishedInvocationMessage msg(Invocation, Pid,
-                                  JoinedDiags.str(),
-                                  ExitStatus, ProcInfo);
-    emitMessage(os, msg);
-    return false;
-  });
+  const auto ProcInfo = sys::TaskProcessInformation(OSPid);
+
+  // Parseable output clients may not understand the idea of a batch
+  // compilation. We assign each primary in a batch job a quasi process id,
+  // making sure it cannot collide with a real PID (always positive). Non-batch
+  // compilation gets a real OS PID.
+  int64_t Pid = IO.hasUniquePrimaryInput() ? OSPid : QUASI_PID_START;
+  IO.forEachPrimaryInputWithIndex(
+      [&](const InputFile &Input, unsigned idx) -> bool {
+        assert(FileSpecificDiagnostics.count(Input.getFileName()) != 0 &&
+               "Expected diagnostic collection for input.");
+
+        // Join all diagnostics produced for this file into a single output.
+        auto PrimaryDiags = FileSpecificDiagnostics.lookup(Input.getFileName());
+        const char *const Delim = "\n";
+        std::ostringstream JoinedDiags;
+        std::copy(PrimaryDiags.begin(), PrimaryDiags.end(),
+                  std::ostream_iterator<std::string>(JoinedDiags, Delim));
+        FinishedInvocationMessage msg(Invocation, Pid - idx, JoinedDiags.str(),
+                                      ExitStatus, ProcInfo);
+        emitMessage(os, msg);
+        return false;
+      });
 }
 
 void parseable_output::emitSignalledMessage(

lib/Driver/Compilation.cpp

@@ -204,7 +204,7 @@ namespace driver {
     /// PIDs (which are always positive). We start at -1000 here as a crude but
     /// harmless hedge against colliding with an errno value that might slip
     /// into the stream of real PIDs (say, due to a TaskQueue bug).
-    int64_t NextBatchQuasiPID = -1000;
+    int64_t NextBatchQuasiPID = parseable_output::QUASI_PID_START;
 
     /// All jobs which have finished execution or which have been determined
     /// that they don't need to run.

lib/Frontend/FrontendInputsAndOutputs.cpp

@@ -101,6 +101,14 @@ bool FrontendInputsAndOutputs::forEachPrimaryInput(
   return false;
 }
 
+bool FrontendInputsAndOutputs::forEachPrimaryInputWithIndex(
+    llvm::function_ref<bool(const InputFile &, unsigned index)> fn) const {
+  for (unsigned i : PrimaryInputsInOrder)
+    if (fn(AllInputs[i], i))
+      return true;
+  return false;
+}
+
 bool FrontendInputsAndOutputs::forEachNonPrimaryInput(
     llvm::function_ref<bool(const InputFile &)> fn) const {
   return forEachInput([&](const InputFile &f) -> bool {

lib/FrontendTool/FrontendTool.cpp

@@ -2073,9 +2073,8 @@ int swift::performFrontend(ArrayRef<const char *> Args,
   }
 
   if (Invocation.getFrontendOptions().FrontendParseableOutput) {
-    parseable_output::emitBeganMessage(
-        llvm::errs(), Invocation, Args, llvm::sys::ProcessInfo::InvalidPid,
-        sys::TaskProcessInformation(getpid()));
+    parseable_output::emitBeganMessage(llvm::errs(), Invocation, Args,
+                                       getpid());
   }
 
   int ReturnValue = 0;
@@ -2097,9 +2096,8 @@ int swift::performFrontend(ArrayRef<const char *> Args,
     StatsReporter->noteCurrentProcessExitStatus(r);
 
   if (Invocation.getFrontendOptions().FrontendParseableOutput) {
-    parseable_output::emitFinishedMessage(
-        llvm::errs(), Invocation, llvm::sys::ProcessInfo::InvalidPid, r,
-        FileSpecificDiagnostics, sys::TaskProcessInformation(getpid()));
+    parseable_output::emitFinishedMessage(llvm::errs(), Invocation, r,
+                                          FileSpecificDiagnostics, getpid());
   }
 
   return r;