code: def initialize(
      ip_config,
      max_queue_size=MAX_QUEUE_SIZE,
      net_type=None,
      num_worker_threads=1,
  ):
      """Initialize DGL's distributed module
  
      This function initializes DGL's distributed module. It acts differently in server
      or client modes. In the server mode, it runs the server code and never returns.
      In the client mode, it builds connections with servers for communication and
      creates worker processes for distributed sampling.
  
      Parameters
      ----------
      ip_config: str
          File path of ip_config file
      max_queue_size : int
          Maximal size (bytes) of client queue buffer (~20 GB on default).
  
          Note that the 20 GB is just an upper-bound and DGL uses zero-copy and
          it will not allocate 20GB memory at once.
      net_type : str, optional
          [Deprecated] Networking type, can be 'socket' only.
      num_worker_threads: int
          The number of OMP threads in each sampler process.
  
      Note
      ----
      Users have to invoke this API before any DGL's distributed API and framework-specific
      distributed API. For example, when used with Pytorch, users have to invoke this function
      before Pytorch's `pytorch.distributed.init_process_group`.
      """
      if net_type is not None:
          dgl_warning(
              "net_type is deprecated and will be removed in future release."
          )
      if os.environ.get("DGL_ROLE", "client") == "server":
          from .dist_graph import DistGraphServer
  
          assert (
              os.environ.get("DGL_SERVER_ID") is not None
          ), "Please define DGL_SERVER_ID to run DistGraph server"
          assert (
              os.environ.get("DGL_IP_CONFIG") is not None
          ), "Please define DGL_IP_CONFIG to run DistGraph server"
          assert (
              os.environ.get("DGL_NUM_SERVER") is not None
          ), "Please define DGL_NUM_SERVER to run DistGraph server"
          assert (
              os.environ.get("DGL_NUM_CLIENT") is not None
          ), "Please define DGL_NUM_CLIENT to run DistGraph server"
          assert (
              os.environ.get("DGL_CONF_PATH") is not None
          ), "Please define DGL_CONF_PATH to run DistGraph server"
          formats = os.environ.get("DGL_GRAPH_FORMAT", "csc").split(",")
          formats = [f.strip() for f in formats]
          rpc.reset()
          serv = DistGraphServer(
              int(os.environ.get("DGL_SERVER_ID")),
              os.environ.get("DGL_IP_CONFIG"),
              int(os.environ.get("DGL_NUM_SERVER")),
              int(os.environ.get("DGL_NUM_CLIENT")),
              os.environ.get("DGL_CONF_PATH"),
              graph_format=formats,
          )
          serv.start()
          sys.exit()
      else:
          num_workers = int(os.environ.get("DGL_NUM_SAMPLER", 0))
          num_servers = int(os.environ.get("DGL_NUM_SERVER", 1))
          group_id = int(os.environ.get("DGL_GROUP_ID", 0))
          rpc.reset()
          global SAMPLER_POOL
          global NUM_SAMPLER_WORKERS
          is_standalone = (
              os.environ.get("DGL_DIST_MODE", "standalone")
              == "standalone"
          )
          if num_workers > 0 and not is_standalone:
              SAMPLER_POOL = CustomPool(
                  num_workers,
                  (
                      ip_config,
                      num_servers,
                      max_queue_size,
                      "sampler",
                      num_worker_threads,
                      group_id,
                  ),
              )
          else:
              SAMPLER_POOL = None
          NUM_SAMPLER_WORKERS = num_workers
          if not is_standalone:
              assert (
                  num_servers is not None and num_servers > 0
              ), "The number of servers per machine must be specified with a positive number."
              connect_to_server(
                  ip_config,
                  num_servers,
                  max_queue_size,
                  group_id=group_id,
              )
          init_role("default")
          init_kvstore(ip_config, num_servers, "default")
  
imports: import atexit
  import gc
  import multiprocessing
  import os
  import queue
  import sys
  import time
  import traceback
  from enum import Enum
  from ..None import utils
  from ..base import dgl_warning, DGLError
  from .None import rpc
  from .constants import MAX_QUEUE_SIZE
  from .kvstore import close_kvstore, init_kvstore
  from .role import init_role
  from .rpc_client import connect_to_server
label_desc: Use image node_id 5 for calling a global function with example usage: initialize(ip_config, max_queue_size, net_type, num_worker_threads) without return types