code: def track_parallel_progress_multi_args(
      func,
      args,
      nproc,
      initializer=None,
      initargs=None,
      bar_width=50,
      chunksize=1,
      skip_first=False,
      file=sys.stdout,
  ):
      """Track the progress of parallel task execution with a progress bar.
  
      The built-in :mod:`multiprocessing` module is used for process pools and
      tasks are done with :func:`Pool.map` or :func:`Pool.imap_unordered`.
  
      Args:
          func (callable): The function to be applied to each task.
          tasks (tuple[Iterable]): A tuple of tasks.
          nproc (int): Process (worker) number.
          initializer (None or callable): Refer to :class:`multiprocessing.Pool`
              for details.
          initargs (None or tuple): Refer to :class:`multiprocessing.Pool` for
              details.
          chunksize (int): Refer to :class:`multiprocessing.Pool` for details.
          bar_width (int): Width of progress bar.
          skip_first (bool): Whether to skip the first sample for each worker
              when estimating fps, since the initialization step may takes
              longer.
          keep_order (bool): If True, :func:`Pool.imap` is used, otherwise
              :func:`Pool.imap_unordered` is used.
  
      Returns:
          list: The task results.
      """
      assert isinstance(args, tuple)
      for arg in args:
          assert isinstance(arg, Iterable)
      assert (
          len(set([len(arg) for arg in args])) == 1
      ), "args must have same length"
      task_num = len(args[0])
      tasks = zip(*args)
  
      pool = init_pool(nproc, initializer, initargs)
      start = not skip_first
      task_num -= nproc * chunksize * int(skip_first)
      prog_bar = ProgressBar(task_num, bar_width, start, file=file)
      results = []
      gen = pool.starmap(func, tasks, chunksize)
      for result in gen:
          results.append(result)
          if skip_first:
              if len(results) < nproc * chunksize:
                  continue
              elif len(results) == nproc * chunksize:
                  prog_bar.start()
                  continue
          prog_bar.update()
      prog_bar.file.write("\n")
      pool.close()
      pool.join()
      return results
  
imports: import sys
  from collections.abc import Iterable
  from mmengine.utils.progressbar import ProgressBar, init_pool
label_desc: Use image node_id 1 for calling a global function with example usage: track_parallel_progress_multi_args(func, args, nproc, initializer, initargs, bar_width, chunksize, skip_first, file) and returns: results