code: def multi_source_bfs(
      G, sources, components=None, depth_limit=None, offload=False
  ):
      """
      Find the breadth first traversal from multiple sources in a graph.
  
      Parameters
      ----------
      G : cugraph.Graph
          The adjacency list will be computed if not already present.
  
      sources :  cudf.Series
          Subset of vertices from which the traversals start. A BFS is run for
          each source in the Series.
          The size of the series should be at least one and cannot exceed the
          size of the graph.
  
      depth_limit : Integer, optional, default=None
          Limit the depth of the search. Terminates if no more vertices are
          reachable within the distance of depth_limit
  
      components : cudf.DataFrame, optional, default=None
          GPU Dataframe containing the component information.
          Passing this information may impact the return type.
          When no component information is passed BFS uses one component
          behavior settings.
  
          components['vertex'] : cudf.Series
              vertex IDs
          components['color'] : cudf.Series
              component IDs/color for vertices.
  
      offload : boolean, optional, default=False
          Indicates if output should be written to the disk.
          When not provided, the algorithms decides if offloading is needed
          based on the input parameters.
  
      Returns
      -------
      Return value type is decided based on the input parameters (size of
      sources, size of the graph, number of components and offload setting)
      If G is a cugraph.Graph, returns :
         cudf.DataFrame
            df['vertex'] vertex IDs
  
            df['distance_<source>'] path distance for each vertex from the
            starting vertex. One column per source.
  
            df['predecessor_<source>'] for each i'th position in the column,
            the vertex ID immediately preceding the vertex at position i in
            the 'vertex' column. One column per source.
  
      If G is a cugraph.Graph and component information is present returns :
          BFS_edge_lists : cudf.DataFrame
              GPU data frame containing all BFS edges
          source_offsets: cudf.Series
              Series containing the starting offset in the returned edge list
              for each source.
  
      If offload is True, or if the output does not fit in memory :
          Writes csv files containing BFS output to the disk.
      """
      raise NotImplementedError(
          "concurrent_bfs is coming soon! Please up vote the github issue 1465\
               to help us prioritize"
      )
      # if components is not None:
      #    null_check(components["vertex"])
      #    null_check(components["colors"])
      #
      # if depth_limit is not None:
      #    raise NotImplementedError(
      #        "depth limit implementation of BFS is not currently supported"
      #    )
  
      # if offload is True:
      #    raise NotImplementedError(
      #        "Offloading is coming soon! Please up vote the github issue 1461
      #         to help us prioritize"
      #    )
      if isinstance(sources, list):
          sources = cudf.Series(sources)
      if G.renumbered is True:
          sources = G.lookup_internal_vertex_id(cudf.Series(sources))
      if not G.adjlist:
          G.view_adj_list()
      # Memory footprint check
      footprint = _get_feasibility(
          G, sources, components=components, depth_limit=depth_limit
      )
      print(footprint)
  
imports: import numpy
  import cudf
  import warnings
label_desc: Use image node_id 3 for calling a global function with example usage: multi_source_bfs(G, sources, components, depth_limit, offload) without return types