docs: def mp_check_impl(self, process_count):
          """
          a multiprocessing-enabled check implementation. Will create up to
          process_count helper processes and use them to perform the
          DistJarReport and DistClassReport actions.
          """
  
          from multiprocessing import Process, Queue
  
          options = self.reporter.options
  
          # this is the function that will be run in a separate process,
          # which will handle the tasks queue and feed into the results
          # queue
          func = _mp_run_check
  
          # normally this would happen lazily, but since we'll have
          # multiple processes all running reports at the same time, we
          # need to make sure the setup is done before-hand. This is
          # hackish, but in particular this keeps the HTML reports from
          # trying to perform the default data copy over and over.
          self.reporter.setup()
  
          # enqueue the sub-reports for multi-processing. Other types of
          # changes can happen sync.
          changes = list(self.collect_impl())
  
          task_count = 0
          tasks = Queue()
          results = Queue()
  
          try:
              # as soon as we start using the tasks queue, we need to be
              # catching the KeyboardInterrupt event so that we can
              # drain the queue and lets its underlying thread terminate
              # happily.
  
              # TODO: is there a better way to handle this shutdown
              # gracefully?
  
              # feed any sub-reports to the tasks queue
              for index in range(0, len(changes)):
                  change = changes[index]
                  if isinstance(change, (DistJarReport, DistClassReport)):
                      changes[index] = None
                      tasks.put((index, change))
                      task_count += 1
  
              # infrequent edge case, but don't bother starting more
              # helpers than we'll ever use
              process_count = min(process_count, task_count)
  
              # start the number of helper processes, and make sure
              # there are that many stop sentinels at the end of the
              # tasks queue
              for _i in range(0, process_count):
                  tasks.put(None)
                  process = Process(target=func, args=(tasks, results, options))
                  process.daemon = False
                  process.start()
  
              # while the helpers are running, perform our checks
              for change in changes:
                  if change:
                      change.check()
  
              # get all of the results and feed them back into our change
              for _i in range(0, task_count):
                  index, change = results.get()
                  changes[index] = change
  
          except KeyboardInterrupt:
              # drain the tasks queue so it will exit gracefully
              for _change in iter(tasks.get, None):
                  pass
              raise
  
          # complete the check by setting our internal collection of
          # child changes and returning our overall status
          c = False
          for change in changes:
              c = c or change.is_change()
          self.changes = changes
          return c, None