code: def parallelize(
      fun, iter, meta=None, backend=None, backend_params=None
  ):
      """Parallelize loop over iter via backend.
  
      Executes ``fun(x, meta)`` in parallel for ``x`` in ``iter``,
      and returns the results as a list in the same order as ``iter``.
  
      Uses the iteration or parallelization backend specified by ``backend``.
  
      Parameters
      ----------
      fun : callable
          function to be executed in parallel
      iter : iterable
          iterable over which to parallelize
      meta : dict, optional
          variables to be passed to fun
      backend : str, optional
          backend to use for parallelization, one of
  
          - "None": executes loop sequentally, simple list comprehension
          - "loky", "multiprocessing" and "threading": uses ``joblib`` ``Parallel`` loops
          - "joblib": custom and 3rd party ``joblib`` backends, e.g., ``spark``
          - "dask": uses ``dask``, requires ``dask`` package in environment
          - "dask_lazy": same as ``"dask"``, but returns delayed object instead of list
  
      backend_params : dict, optional
          additional parameters passed to the backend as config.
          Valid keys depend on the value of ``backend``:
  
          - "None": no additional parameters, ``backend_params`` is ignored
          - "loky", "multiprocessing" and "threading": default ``joblib`` backends
            any valid keys for ``joblib.Parallel`` can be passed here, e.g., ``n_jobs``,
            with the exception of ``backend`` which is directly controlled by ``backend``.
            If ``n_jobs`` is not passed, it will default to ``-1``, other parameters
            will default to ``joblib`` defaults.
          - "joblib": custom and 3rd party ``joblib`` backends, e.g., ``spark``.
            any valid keys for ``joblib.Parallel`` can be passed here, e.g., ``n_jobs``,
            ``backend`` must be passed as a key of ``backend_params`` in this case.
            If ``n_jobs`` is not passed, it will default to ``-1``, other parameters
            will default to ``joblib`` defaults.
          - "dask": any valid keys for ``dask.compute`` can be passed, e.g., ``scheduler``
      """
      if meta is None:
          meta = {}
      if backend is None:
          backend = "None"
      if backend_params is None:
          backend_params = {}
  
      backend_name = backend_dict[backend]
      para_fun = para_dict[backend_name]
  
      ret = para_fun(
          fun=fun,
          iter=iter,
          meta=meta,
          backend=backend,
          backend_params=backend_params,
      )
      return ret
  
label_desc: Use image node_id 1 for calling a global function with example usage: parallelize(fun, iter, meta, backend, backend_params) and returns: ret