code: def send_1_to_1(n: int = None, cpu: bool = True):
      ctx = get_context()
      bands = [
          b
          for b in ctx.get_worker_bands()
          if (cpu and b[1].startswith("numa-"))
          or (not cpu and b[1].startswith("gpu-"))
      ]
  
      band_to_gen_data = {
          b: mr.spawn(
              _gen_data, kwargs=dict(n=n, band=b), expect_band=b
          )
          for i, b in enumerate(bands)
      }
      all_data = mars.execute(list(band_to_gen_data.values()))
      progress = 0.1
      ctx.set_progress(progress)
      infos = [
          d._fetch_infos(fields=["data_key", "store_size"])
          for d in all_data
      ]
      data_size = infos[0]["store_size"][0]
      band_to_data_keys = dict(
          zip(bands, [info["data_key"][0] for info in infos])
      )
  
      bands_to_durations = dict()
      size = len(bands) * (len(bands) - 1)
      for band1, band2 in itertools.permutations(bands, 2):
          fetch_data = mr.spawn(
              _fetch_data,
              args=(band_to_data_keys[band1],),
              kwargs=dict(band=band2),
              expect_band=band2,
          )
          fetch_time = fetch_data.execute().fetch()
          rate = readable_size(data_size / fetch_time)
          bands_to_durations[band1, band2] = (
              readable_size(data_size),
              f"{rate}B/s",
          )
          progress += 0.9 / size
          ctx.set_progress(min(progress, 1.0))
      return bands_to_durations
  
file_path: mars/benchmarks/asv_bench/benchmarks/storage.py
imports: import itertools
  import cloudpickle
  import numpy
  import pandas
  import mars
  import mars.remote
  from mars.core.context import get_context
  from mars.utils import Timer, readable_size
label_desc: Use image node_id 1 for calling a global function with example usage: send_1_to_1(n, cpu) and returns: bands_to_durations