code: def __call__(
      self,
      subgraph,
      x,
      norm=None,
      batch_size=None,
      n_id=None,
      offset=None,
      count=None,
      loader=None,
      **kwargs,
  ):
      # TODO(daisiming): Add forward_pre_hook like paddle.nn.Layer, etc.
  
      if loader is not None:
          return self.inference(loader, x, norm)
  
      self._async = (
          self.pool is not None
          and batch_size is not None
          and n_id is not None
          and offset is not None
          and count is not None
      )
  
      if self._async and batch_size < len(n_id):
          for history in self.histories:
              cpu_nid = n_id[batch_size:].cpu()
              empty = paddle.to_tensor(
                  np.array([]), place=paddle.CPUPlace()
              )
              self.pool.async_pull(history.emb, cpu_nid, empty, empty)
  
      out = self.forward(
          subgraph, x, norm, batch_size, n_id, offset, count, **kwargs
      )
  
      if self._async and batch_size < len(n_id):
          for history in self.histories:
              self.pool.sync_push()
  
      self._async = False
  
      return out
  
file_path: PGL/apps/GNNAutoScale/gnn_models/base_model.py
imports: import os
  import sys
  import numpy
  import paddle
  from pgl.utils.stream_pool import StreamPool, async_write
  from history import History
  from utils import process_batch_data, check_device
label_desc: Use image node_id 4 for calling the ScalableGNN obj's underlying member method code with example usage: obj.__call__(subgraph, x, norm, batch_size, n_id, offset, count, loader) and returns: out, self