class_docstr: Initialize the Distributed Graph Server
  
  Args:
      root_dir: the graph data dir 
  
      node_types: the node type configs
  
      edge_types: the edge type configs.
  
      symmetry: whether the edges are symmetry
  
      slots: the node feature slot 
  
      token_slot: for erniesage token slot input
  
      slot_num_for_pull_feature: total slot feature number we should pull
  
      num_parts: the sharded parts of graph data
  
      metapath_split_opt: whether use metapath split optimization
docstr: Pull specific metapath's edges.
          
docstr_tok: ["Pull","specific","metapath","'s","edges","."]
code: def load_metapath_edges_nodes(self, metapath_dict, metapath, i):
      """Pull specific metapath's edges."""
      log.info(
          "Begin load_metapath_edges_nodes, metapath[%d]: %s"
          % (i, metapath)
      )
      first_node = metapath.split("2")[0]
      all_metapath_class_len = len(metapath_dict[first_node])
      cur_metapath_index = metapath_dict[first_node].index(metapath)
  
      sub_edges_list = metapath.split("-")
      edge_len = len(sub_edges_list)
      sub_etype2files, is_reverse_map = util.get_sub_path(
          self.etype2files, sub_edges_list, True
      )
      log.info(
          "metapath[%s] etype2files[%s] is_reverse_map[%s]",
          metapath,
          sub_etype2files,
          is_reverse_map,
      )
  
      metapath_cpuload_begin = time.time()
      self.graph.load_edge_file(
          sub_etype2files,
          self.root_dir,
          self.num_parts,
          False,
          is_reverse_map,
          self.use_weight,
      )
      metapath_cpuload_end = time.time()
      log.info(
          "metapath[%s] load edges[%s] to cpu, time: %s"
          % (
              metapath,
              sub_etype2files,
              metapath_cpuload_end - metapath_cpuload_begin,
          )
      )
  
      metapath_gpuload_begin = time.time()
      for j in range(0, len(sub_edges_list)):
          self.graph.upload_batch(
              0, len(get_cuda_places()), sub_edges_list[j]
          )
      metapath_gpuload_end = time.time()
      log.info(
          "metapath[%s] load edges[%s] to gpu, time: %s"
          % (
              metapath,
              sub_etype2files,
              metapath_gpuload_end - metapath_gpuload_begin,
          )
      )
  
      self.graph.release_graph_edge()
  
      sub_nodes_list = []
      for edge in sub_edges_list:
          sub_nodes_list.extend(edge.split("2"))
      sub_ntype2files, _ = util.get_sub_path(
          self.ntype2files, sub_nodes_list, False
      )
      log.info(
          "metapath[%s] ntype2files[%s]", metapath, sub_ntype2files
      )
      load_begin_time = time.time()
      ret = self.graph.load_node_file(
          sub_ntype2files, self.root_dir, self.num_parts
      )
      if ret != 0:
          log.info(
              "Fail to load node, ntype2files[%s] path[%s] num_part[%d]"
              % (sub_ntype2files, self.root_dir, self.num_parts)
          )
          self.graph.release_graph_node()
          return -1
      load_end_time = time.time()
      log.info(
          "metapath[%s] load nodes[%s] to cpu, time: %s"
          % (metapath, sub_ntype2files, load_end_time - load_begin_time)
      )
  
      load_begin_time = time.time()
      if self.slot_num_for_pull_feature > 0:
          self.graph.upload_batch(
              1, len(get_cuda_places()), self.slot_num_for_pull_feature
          )
      load_end_time = time.time()
      log.info(
          "metapath[%s] load nodes[%s] to gpu, time: %s"
          % (metapath, sub_ntype2files, load_end_time - load_begin_time)
      )
  
      self.graph.release_graph_node()
  
      self.graph.init_metapath(
          metapath, cur_metapath_index, all_metapath_class_len
      )
  
imports: import sys
  import time
  from paddle.fluid.core import GraphGpuWrapper
  from pgl.utils.logger import log
  import helper
  import util
  from place import get_cuda_places
label_desc: Use image node_id 6 for calling the DistGraph obj's underlying member method code with example usage: obj.load_metapath_edges_nodes(metapath_dict, metapath, i) and returns: unknown