code: def track_time(data):
      args = SimpleNamespace(
          num_hidden=16,
          fan_out="10,25",
          batch_size=1000,
          lr=0.003,
          dropout=0.5,
          num_layers=2,
          num_workers=4,
      )
  
      devices = [0, 1, 2, 3]
      n_gpus = len(devices)
      data = utils.process_data(data)
      g = data[0]
      n_classes = data.num_classes
      train_g = val_g = test_g = g
  
      # Create csr/coo/csc formats before launching training processes with multi-gpu.
      # This avoids creating certain formats in each sub-process, which saves momory and CPU.
      train_g.create_formats_()
      val_g.create_formats_()
      test_g.create_formats_()
      # Pack data
      data = n_classes, train_g, val_g, test_g
  
      ctx = mp.get_context("spawn")
      result_queue = ctx.Queue()
      procs = []
      for proc_id in range(n_gpus):
          p = ctx.Process(
              target=run,
              args=(result_queue, proc_id, n_gpus, args, devices, data),
          )
          p.start()
          procs.append(p)
      for p in procs:
          p.join()
      time_records = result_queue.get(block=False)
      num_exclude = 10  # exclude first 10 iterations
      if len(time_records) < 15:
          # exclude less if less records
          num_exclude = int(len(time_records) * 0.3)
      return np.mean(time_records[num_exclude:])
  
imports: import argparse
  import math
  import time
  from types import SimpleNamespace
  from typing import NamedTuple
  import dgl
  import dgl.nn.pytorch
  import numpy
  import torch
  import torch.multiprocessing
  import torch.nn
  import torch.nn.functional
  import torch.optim
  from torch.nn.parallel import DistributedDataParallel
  from ..None import utils
label_desc: Use image node_id 3 for calling a global function with example usage: track_time(data) and returns: np