docs: def run_parallel(
          workflow, *, n_threads, registry, db_file, echo_log=True,
          always_cache=False):
      """Run a workflow in parallel threads, storing results in a Sqlite3
      database.
  
      :param workflow: Workflow or PromisedObject to evaluate.
      :param n_threads: number of threads to use (in addition to the scheduler).
      :param registry: serialization Registry function.
      :param db_file: filename of Sqlite3 database, give `':memory:'` to
          keep the database in memory only.
      :param echo_log: set log-level high enough
      :param always_cache: enable caching by schedule hint.
      :return: Evaluated result.
      """
      if echo_log:
          logging.getLogger('noodles').setLevel(logging.DEBUG)
          logging.debug("--- start log ---")
  
      with JobDB(db_file, registry) as db:
          job_queue = Queue()
          result_queue = Queue()
  
          job_logger = make_logger("worker", push_map, db)
          result_logger = make_logger("worker", pull_map, db)
  
          worker_pool = job_queue.source \
              >> pass_job(db, result_queue, always_cache) \
              >> thread_pool(*repeat(worker, n_threads), results=result_queue)
          job_front_end = job_logger >> job_queue.sink
          result_front_end = worker_pool \
              >> pass_result(db, always_cache) \
              >> result_logger
  
          scheduler = Scheduler(job_keeper=db)
          parallel_sqlite_worker = Connection(result_front_end, job_front_end)
  
          result = scheduler.run(parallel_sqlite_worker, get_workflow(workflow))
  
      return registry().dereference(result)