code: def init_role(role):
      """Initialize the role of the current process.
  
      Each process is associated with a role so that we can determine what
      function can be invoked in a process. For example, we do not allow some
      functions in sampler processes.
  
      The initialization includes registeration the role of the current process and
      get the roles of all client processes. It also computes the rank of all client
      processes in a deterministic way so that all clients will have the same rank for
      the same client process.
      """
      global CUR_ROLE
      CUR_ROLE = role
  
      global PER_ROLE_RANK
      global GLOBAL_RANK
      global IS_STANDALONE
  
      if os.environ.get("DGL_DIST_MODE", "standalone") == "standalone":
          if role == "default":
              GLOBAL_RANK[0] = 0
              PER_ROLE_RANK["default"] = {0: 0}
          IS_STANDALONE = True
          return
  
      PER_ROLE_RANK = {}
      GLOBAL_RANK = {}
  
      # Register the current role. This blocks until all clients register themselves.
      client_id = rpc.get_rank()
      machine_id = rpc.get_machine_id()
      request = RegisterRoleRequest(client_id, machine_id, role)
      rpc.send_request(0, request)
      response = rpc.recv_response()
      assert response.msg == REG_ROLE_MSG
  
      # Get all clients on all machines.
      request = GetRoleRequest()
      rpc.send_request(0, request)
      response = rpc.recv_response()
      assert response.msg == GET_ROLE_MSG
  
      # Here we want to compute a new rank for each client.
      # We compute the per-role rank as well as global rank.
      # For per-role rank, we ensure that all ranks within a machine is contiguous.
      # For global rank, we also ensure that all ranks within a machine are contiguous,
      # and all ranks within a role are contiguous.
      global_rank = 0
  
      # We want to ensure that the global rank of the trainer process starts from 0.
      role_names = ["default"]
      for role_name in response.role:
          if role_name not in role_names:
              role_names.append(role_name)
  
      for role_name in role_names:
          # Let's collect the ranks of this role in all machines.
          machines = {}
          for client_id, machine_id in response.role[role_name]:
              if machine_id not in machines:
                  machines[machine_id] = []
              machines[machine_id].append(client_id)
  
          num_machines = len(machines)
          PER_ROLE_RANK[role_name] = {}
          per_role_rank = 0
          for i in range(num_machines):
              clients = machines[i]
              clients = np.sort(clients)
              for client_id in clients:
                  GLOBAL_RANK[client_id] = global_rank
                  global_rank += 1
                  PER_ROLE_RANK[role_name][client_id] = per_role_rank
                  per_role_rank += 1
  
imports: import os
  import numpy
  from .None import rpc
label_desc: Use image node_id 1 for calling a global function with example usage: init_role(role) without return types