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 whole graph nodes from disk into cpu memory, then load into gpu.
  After that, release memory on cpu.
docstr_tok: ["Pull","whole","graph","nodes","from","disk","into","cpu","memory",",","then","load","into","gpu",".","After","that",",","release","memory","on","cpu","."]
code: def load_node(self):
      """Pull whole graph nodes from disk into cpu memory, then load into gpu.
      After that, release memory on cpu.
      """
      load_begin_time = time.time()
      ret = self.graph.load_node_file(
          self.node_types, self.root_dir, self.num_parts
      )
  
      if self.infer_nodes:
          log.info(
              "[INFER NODE] loading infer_nodes from [%s]"
              % self.infer_nodes
          )
  
          new_ntype2files = helper.generate_files_string(
              self.ntype_list, self.infer_nodes
          )
          log.info(
              "[INFER NODE] infer_node2files: %s" % new_ntype2files
          )
  
          ret = self.graph.load_node_file(
              new_ntype2files, self.root_dir, self.num_parts
          )
  
      if ret != 0:
          log.info(
              "Fail to load node, ntype2files[%s] path[%s] num_part[%d]"
              % (self.node_types, self.root_dir, self.num_parts)
          )
          self.graph.release_graph_node()
          return -1
  
      load_end_time = time.time()
      log.info(
          "STAGE [CPU LOAD NODE] finished, time cost: %f sec"
          % (load_end_time - load_begin_time)
      )
  
      if not self.metapath_split_opt:
          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(
              "STAGE [GPU LOAD NODE] finished, time cost: %f sec"
              % (load_end_time - load_begin_time)
          )
  
      release_begin_time = time.time()
      self.graph.release_graph_node()
      release_end_time = time.time()
      log.info(
          "STAGE [CPU RELEASE NODE] finished, time cost: %f sec"
          % (release_end_time - release_begin_time)
      )
  
      return 0
  
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 5 for calling the DistGraph obj's underlying member method code with example usage: obj.load_node() and returns: int, unknown