Description

Before this change, the workers of pipe call with n_process != 1 were
stopped by calling terminate on the processes. However, terminating a
process can leave queues, pipes, and other concurrent data structures in
an invalid state.

With this change, we stop using terminate and take the following approach
instead:

• When the all documents are processed, the parent process puts a
  sentinel in the queue of each worker.
• The parent process then calls join on each worker process to
  let them finish up gracefully.
• Worker processes break from the queue processing loop when the
  sentinel is encountered, so that they exit.

We need special handling when one of the workers encounters an error and
the error handler is set to raise an exception. In this case, we cannot
rely on the sentinel to finish all workers -- the queue is a FIFO queue
and there may be other work queued up before the sentinel. We use the
following approach to handle error scenarios:

• The parent puts the end-of-work sentinel in the queue of each worker.
• The parent closes the reading-end of the channel of each worker.
• Then:
  • If the worker was waiting for work, it will encounter the sentinel
    and break from the processing loop.
  • If the worker was processing a batch, it will attempt to write
    results to the channel. This will fail because the channel was
    closed by the parent and the worker will break from the processing
    loop.

Types of change

Checklist

• I confirm that I have the right to submit this contribution under the project's MIT license.
• I ran the tests, and all new and existing tests passed.
• My changes don't require a change to the documentation, or if they do, I've added all required information.