cuGraph C++ API documentation#

namespace cugraph#

Typedefs

template<typename T> using dataframe_buffer_type_t = typename dataframe_buffer_type<T>::type#

template<typename T> using dataframe_buffer_iterator_type_t = typename dataframe_buffer_iterator_type<T>::type#

template<typename T> using dataframe_buffer_const_iterator_type_t = typename dataframe_buffer_const_iterator_type<T>::type#

Enums

enum class cugraph_cc_t#

Values:

enumerator CUGRAPH_STRONG#

enumerator NUM_CONNECTIVITY_TYPES#

Strongly Connected Components

enum class k_core_degree_type_t#

Identify whether the core number computation should be based off incoming edges, outgoing edges or both.

Values:

enumerator IN#

enumerator OUT#

enumerator INOUT#

enum class sampling_strategy_t : int#

Values:

enumerator UNIFORM#

enumerator BIASED#

enumerator NODE2VEC#

enum class generator_distribution_t#

Values:

enumerator POWER_LAW#

enumerator UNIFORM#

enum class prior_sources_behavior_t#

Controls how we treat prior sources in sampling.

Param DEFAULT:: Add vertices encountered while sampling to the new frontier
Param CARRY_OVER:: In addition to newly encountered vertices, include vertices used as sources in any previous frontier in the new frontier
Param EXCLUDE:: Filter the new frontier to exclude any vertex that was used as a source in a previous frontier

Values:

enumerator DEFAULT#

enumerator CARRY_OVER#

enumerator EXCLUDE#

Functions

template rmm::device_uvector< float > betweenness_centrality (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< raft::device_span< int32_t const > > vertices, bool const normalized, bool const include_endpoints, bool do_expensive_check)

template rmm::device_uvector< double > betweenness_centrality (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< raft::device_span< int32_t const > > vertices, bool const normalized, bool const include_endpoints, bool do_expensive_check)

template edge_property_t< graph_view_t< int32_t, int32_t, false, true >, float > edge_betweenness_centrality (const raft::handle_t &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< raft::device_span< int32_t const > > vertices, bool const normalized, bool const do_expensive_check)

template edge_property_t< graph_view_t< int32_t, int32_t, false, true >, double > edge_betweenness_centrality (const raft::handle_t &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< raft::device_span< int32_t const > > vertices, bool const normalized, bool const do_expensive_check)

template rmm::device_uvector< float > betweenness_centrality (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< raft::device_span< int64_t const > > vertices, bool const normalized, bool const include_endpoints, bool do_expensive_check)

template rmm::device_uvector< double > betweenness_centrality (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< raft::device_span< int64_t const > > vertices, bool const normalized, bool const include_endpoints, bool do_expensive_check)

template edge_property_t< graph_view_t< int64_t, int64_t, false, true >, float > edge_betweenness_centrality (const raft::handle_t &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< raft::device_span< int64_t const > > vertices, bool const normalized, bool const do_expensive_check)

template edge_property_t< graph_view_t< int64_t, int64_t, false, true >, double > edge_betweenness_centrality (const raft::handle_t &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< raft::device_span< int64_t const > > vertices, bool const normalized, bool const do_expensive_check)

template rmm::device_uvector< float > betweenness_centrality (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< raft::device_span< int32_t const > > vertices, bool const normalized, bool const include_endpoints, bool do_expensive_check)

template rmm::device_uvector< double > betweenness_centrality (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< raft::device_span< int32_t const > > vertices, bool const normalized, bool const include_endpoints, bool do_expensive_check)

template edge_property_t< graph_view_t< int32_t, int32_t, false, false >, float > edge_betweenness_centrality (const raft::handle_t &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< raft::device_span< int32_t const > > vertices, bool const normalized, bool const do_expensive_check)

template edge_property_t< graph_view_t< int32_t, int32_t, false, false >, double > edge_betweenness_centrality (const raft::handle_t &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< raft::device_span< int32_t const > > vertices, bool const normalized, bool const do_expensive_check)

template rmm::device_uvector< float > betweenness_centrality (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< raft::device_span< int64_t const > > vertices, bool const normalized, bool const include_endpoints, bool do_expensive_check)

template rmm::device_uvector< double > betweenness_centrality (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< raft::device_span< int64_t const > > vertices, bool const normalized, bool const include_endpoints, bool do_expensive_check)

template edge_property_t< graph_view_t< int64_t, int64_t, false, false >, float > edge_betweenness_centrality (const raft::handle_t &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< raft::device_span< int64_t const > > vertices, bool const normalized, bool const do_expensive_check)

template edge_property_t< graph_view_t< int64_t, int64_t, false, false >, double > edge_betweenness_centrality (const raft::handle_t &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< raft::device_span< int64_t const > > vertices, bool const normalized, bool const do_expensive_check)

template rmm::device_uvector< float > eigenvector_centrality (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< raft::device_span< float const > > initial_centralities, float epsilon, size_t max_iterations, bool do_expensive_check)

template rmm::device_uvector< double > eigenvector_centrality (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< raft::device_span< double const > > initial_centralities, double epsilon, size_t max_iterations, bool do_expensive_check)

template rmm::device_uvector< float > eigenvector_centrality (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< raft::device_span< float const > > initial_centralities, float epsilon, size_t max_iterations, bool do_expensive_check)

template rmm::device_uvector< double > eigenvector_centrality (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< raft::device_span< double const > > initial_centralities, double epsilon, size_t max_iterations, bool do_expensive_check)

template rmm::device_uvector< float > eigenvector_centrality (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< raft::device_span< float const > > initial_centralities, float epsilon, size_t max_iterations, bool do_expensive_check)

template rmm::device_uvector< double > eigenvector_centrality (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< raft::device_span< double const > > initial_centralities, double epsilon, size_t max_iterations, bool do_expensive_check)

template rmm::device_uvector< float > eigenvector_centrality (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< raft::device_span< float const > > initial_centralities, float epsilon, size_t max_iterations, bool do_expensive_check)

template rmm::device_uvector< double > eigenvector_centrality (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< raft::device_span< double const > > initial_centralities, double epsilon, size_t max_iterations, bool do_expensive_check)

template void katz_centrality (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, float const *betas, float *katz_centralities, float alpha, float beta, float epsilon, size_t max_iterations, bool has_initial_guess, bool normalize, bool do_expensive_check)

template void katz_centrality (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, double const *betas, double *katz_centralities, double alpha, double beta, double epsilon, size_t max_iterations, bool has_initial_guess, bool normalize, bool do_expensive_check)

template void katz_centrality (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, float const *betas, float *katz_centralities, float alpha, float beta, float epsilon, size_t max_iterations, bool has_initial_guess, bool normalize, bool do_expensive_check)

template void katz_centrality (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, double const *betas, double *katz_centralities, double alpha, double beta, double epsilon, size_t max_iterations, bool has_initial_guess, bool normalize, bool do_expensive_check)

template void katz_centrality (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, float const *betas, float *katz_centralities, float alpha, float beta, float epsilon, size_t max_iterations, bool has_initial_guess, bool normalize, bool do_expensive_check)

template void katz_centrality (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, double const *betas, double *katz_centralities, double alpha, double beta, double epsilon, size_t max_iterations, bool has_initial_guess, bool normalize, bool do_expensive_check)

template void katz_centrality (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, float const *betas, float *katz_centralities, float alpha, float beta, float epsilon, size_t max_iterations, bool has_initial_guess, bool normalize, bool do_expensive_check)

template void katz_centrality (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, double const *betas, double *katz_centralities, double alpha, double beta, double epsilon, size_t max_iterations, bool has_initial_guess, bool normalize, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, float > approximate_weighted_matching (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, edge_property_view_t< int32_t, float const * > edge_weight_view)

template std::tuple< rmm::device_uvector< int32_t >, double > approximate_weighted_matching (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, edge_property_view_t< int32_t, double const * > edge_weight_view)

template std::tuple< rmm::device_uvector< int64_t >, float > approximate_weighted_matching (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, edge_property_view_t< int64_t, float const * > edge_weight_view)

template std::tuple< rmm::device_uvector< int64_t >, double > approximate_weighted_matching (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, edge_property_view_t< int64_t, double const * > edge_weight_view)

template std::tuple< rmm::device_uvector< int32_t >, float > approximate_weighted_matching (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, edge_property_view_t< int32_t, float const * > edge_weight_view)

template std::tuple< rmm::device_uvector< int32_t >, double > approximate_weighted_matching (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, edge_property_view_t< int32_t, double const * > edge_weight_view)

template std::tuple< rmm::device_uvector< int64_t >, float > approximate_weighted_matching (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, edge_property_view_t< int64_t, float const * > edge_weight_view)

template std::tuple< rmm::device_uvector< int64_t >, double > approximate_weighted_matching (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, edge_property_view_t< int64_t, double const * > edge_weight_view)

template std::tuple< rmm::device_uvector< int32_t >, size_t, float > ecg (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, float min_weight, size_t ensemble_size, size_t max_level, float threshold, float resolution)

template std::tuple< rmm::device_uvector< int32_t >, size_t, double > ecg (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, double min_weight, size_t ensemble_size, size_t max_level, double threshold, double resolution)

template std::tuple< rmm::device_uvector< int64_t >, size_t, float > ecg (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, float min_weight, size_t ensemble_size, size_t max_level, float threshold, float resolution)

template std::tuple< rmm::device_uvector< int64_t >, size_t, double > ecg (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, double min_weight, size_t ensemble_size, size_t max_level, double threshold, double resolution)

template std::tuple< rmm::device_uvector< int32_t >, size_t, float > ecg (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, float min_weight, size_t ensemble_size, size_t max_level, float threshold, float resolution)

template std::tuple< rmm::device_uvector< int32_t >, size_t, double > ecg (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, double min_weight, size_t ensemble_size, size_t max_level, double threshold, double resolution)

template std::tuple< rmm::device_uvector< int64_t >, size_t, float > ecg (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, float min_weight, size_t ensemble_size, size_t max_level, float threshold, float resolution)

template std::tuple< rmm::device_uvector< int64_t >, size_t, double > ecg (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, double min_weight, size_t ensemble_size, size_t max_level, double threshold, double resolution)

template edge_property_t< graph_view_t< int32_t, int32_t, false, true >, int32_t > edge_triangle_count (raft::handle_t const &handle, cugraph::graph_view_t< int32_t, int32_t, false, true > const &graph_view, bool do_expensive_check)

template edge_property_t< graph_view_t< int64_t, int64_t, false, true >, int64_t > edge_triangle_count (raft::handle_t const &handle, cugraph::graph_view_t< int64_t, int64_t, false, true > const &graph_view, bool do_expensive_check)

template edge_property_t< graph_view_t< int32_t, int32_t, false, false >, int32_t > edge_triangle_count (raft::handle_t const &handle, cugraph::graph_view_t< int32_t, int32_t, false, false > const &graph_view, bool do_expensive_check)

template edge_property_t< graph_view_t< int64_t, int64_t, false, false >, int64_t > edge_triangle_count (raft::handle_t const &handle, cugraph::graph_view_t< int64_t, int64_t, false, false > const &graph_view, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > >, rmm::device_uvector< size_t > > extract_ego (raft::handle_t const &, graph_view_t< int32_t, int32_t, false, true > const &, std::optional< edge_property_view_t< int32_t, float const * > >, int32_t *, int32_t, int32_t)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > >, rmm::device_uvector< size_t > > extract_ego (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > >, raft::device_span< int32_t const > source_vertex, int32_t radius, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > >, rmm::device_uvector< size_t > > extract_ego (raft::handle_t const &, graph_view_t< int32_t, int32_t, false, true > const &, std::optional< edge_property_view_t< int32_t, double const * > >, int32_t *, int32_t, int32_t)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > >, rmm::device_uvector< size_t > > extract_ego (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > >, raft::device_span< int32_t const > source_vertex, int32_t radius, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > >, rmm::device_uvector< size_t > > extract_ego (raft::handle_t const &, graph_view_t< int64_t, int64_t, false, true > const &, std::optional< edge_property_view_t< int64_t, float const * > >, int64_t *, int64_t, int64_t)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > >, rmm::device_uvector< size_t > > extract_ego (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > >, raft::device_span< int64_t const > source_vertex, int64_t radius, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > >, rmm::device_uvector< size_t > > extract_ego (raft::handle_t const &, graph_view_t< int64_t, int64_t, false, true > const &, std::optional< edge_property_view_t< int64_t, double const * > >, int64_t *, int64_t, int64_t)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > >, rmm::device_uvector< size_t > > extract_ego (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > >, raft::device_span< int64_t const > source_vertex, int64_t radius, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > >, rmm::device_uvector< size_t > > extract_ego (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > >, int32_t *source_vertex, int32_t n_subgraphs, int32_t radius)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > >, rmm::device_uvector< size_t > > extract_ego (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > >, raft::device_span< int32_t const > source_vertex, int32_t radius, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > >, rmm::device_uvector< size_t > > extract_ego (raft::handle_t const &, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > >, int32_t *source_vertex, int32_t n_subgraphs, int32_t radius)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > >, rmm::device_uvector< size_t > > extract_ego (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > >, raft::device_span< int32_t const > source_vertex, int32_t radius, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > >, rmm::device_uvector< size_t > > extract_ego (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > >, int64_t *source_vertex, int64_t n_subgraphs, int64_t radius)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > >, rmm::device_uvector< size_t > > extract_ego (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > >, raft::device_span< int64_t const > source_vertex, int64_t radius, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > >, rmm::device_uvector< size_t > > extract_ego (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > >, int64_t *source_vertex, int64_t n_subgraphs, int64_t radius)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > >, rmm::device_uvector< size_t > > extract_ego (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > >, raft::device_span< int64_t const > source_vertex, int64_t radius, bool do_expensive_check)

template<typename vertex_t, bool multi_gpu> void partition_at_level(raft::handle_t const &handle, Dendrogram<vertex_t> const &dendrogram, vertex_t const *d_vertex_ids, vertex_t *d_partition, size_t level)#

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > > > k_truss (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, int32_t k, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > > > k_truss (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, int32_t k, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > > > k_truss (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, int64_t k, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > > > k_truss (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, int64_t k, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > > > k_truss (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, int32_t k, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > > > k_truss (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, int32_t k, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > > > k_truss (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, int64_t k, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > > > k_truss (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, int64_t k, bool do_expensive_check)

template<typename vertex_t, typename edge_t, bool multi_gpu> void flatten_leiden_dendrogram(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, false, multi_gpu> const &graph_view, Dendrogram<vertex_t> const &dendrogram, vertex_t *clustering)#

template std::pair< std::unique_ptr< Dendrogram< int32_t > >, float > leiden (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, size_t max_level, float resolution, float theta)

template std::pair< std::unique_ptr< Dendrogram< int32_t > >, double > leiden (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, size_t max_level, double resolution, double theta)

template std::pair< size_t, float > leiden (raft::handle_t const &, raft::random::RngState &, graph_view_t< int32_t, int32_t, false, true > const &, std::optional< edge_property_view_t< int32_t, float const * > >, int32_t *, size_t, float, float)

template std::pair< size_t, double > leiden (raft::handle_t const &, raft::random::RngState &, graph_view_t< int32_t, int32_t, false, true > const &, std::optional< edge_property_view_t< int32_t, double const * > >, int32_t *, size_t, double, double)

template std::pair< std::unique_ptr< Dendrogram< int64_t > >, float > leiden (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, size_t max_level, float resolution, float theta)

template std::pair< std::unique_ptr< Dendrogram< int64_t > >, double > leiden (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, size_t max_level, double resolution, double theta)

template std::pair< size_t, float > leiden (raft::handle_t const &, raft::random::RngState &, graph_view_t< int64_t, int64_t, false, true > const &, std::optional< edge_property_view_t< int64_t, float const * > >, int64_t *, size_t, float, float)

template std::pair< size_t, double > leiden (raft::handle_t const &, raft::random::RngState &, graph_view_t< int64_t, int64_t, false, true > const &, std::optional< edge_property_view_t< int64_t, double const * > >, int64_t *, size_t, double, double)

template std::pair< std::unique_ptr< Dendrogram< int32_t > >, float > leiden (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, size_t max_level, float resolution, float theta)

template std::pair< std::unique_ptr< Dendrogram< int32_t > >, double > leiden (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, size_t max_level, double resolution, double theta)

template std::pair< size_t, float > leiden (raft::handle_t const &, raft::random::RngState &, graph_view_t< int32_t, int32_t, false, false > const &, std::optional< edge_property_view_t< int32_t, float const * > >, int32_t *, size_t, float, float)

template std::pair< size_t, double > leiden (raft::handle_t const &, raft::random::RngState &, graph_view_t< int32_t, int32_t, false, false > const &, std::optional< edge_property_view_t< int32_t, double const * > >, int32_t *, size_t, double, double)

template std::pair< std::unique_ptr< Dendrogram< int64_t > >, float > leiden (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, size_t max_level, float resolution, float theta)

template std::pair< std::unique_ptr< Dendrogram< int64_t > >, double > leiden (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, size_t max_level, double resolution, double theta)

template std::pair< size_t, float > leiden (raft::handle_t const &, raft::random::RngState &, graph_view_t< int64_t, int64_t, false, false > const &, std::optional< edge_property_view_t< int64_t, float const * > >, int64_t *, size_t, float, float)

template std::pair< size_t, double > leiden (raft::handle_t const &, raft::random::RngState &, graph_view_t< int64_t, int64_t, false, false > const &, std::optional< edge_property_view_t< int64_t, double const * > >, int64_t *, size_t, double, double)

template<typename vertex_t, typename edge_t, bool multi_gpu> void flatten_dendrogram(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, false, multi_gpu> const &graph_view, Dendrogram<vertex_t> const &dendrogram, vertex_t *clustering)#

template std::pair< std::unique_ptr< Dendrogram< int32_t > >, float > louvain (raft::handle_t const &, std::optional< std::reference_wrapper< raft::random::RngState > >, graph_view_t< int32_t, int32_t, false, true > const &, std::optional< edge_property_view_t< int32_t, float const * > >, size_t, float, float)

template std::pair< std::unique_ptr< Dendrogram< int32_t > >, double > louvain (raft::handle_t const &, std::optional< std::reference_wrapper< raft::random::RngState > >, graph_view_t< int32_t, int32_t, false, true > const &, std::optional< edge_property_view_t< int32_t, double const * > >, size_t, double, double)

template std::pair< size_t, float > louvain (raft::handle_t const &, std::optional< std::reference_wrapper< raft::random::RngState > >, graph_view_t< int32_t, int32_t, false, true > const &, std::optional< edge_property_view_t< int32_t, float const * > >, int32_t *, size_t, float, float)

template std::pair< size_t, double > louvain (raft::handle_t const &, std::optional< std::reference_wrapper< raft::random::RngState > >, graph_view_t< int32_t, int32_t, false, true > const &, std::optional< edge_property_view_t< int32_t, double const * > >, int32_t *, size_t, double, double)

template std::pair< std::unique_ptr< Dendrogram< int64_t > >, float > louvain (raft::handle_t const &, std::optional< std::reference_wrapper< raft::random::RngState > >, graph_view_t< int64_t, int64_t, false, true > const &, std::optional< edge_property_view_t< int64_t, float const * > >, size_t, float, float)

template std::pair< std::unique_ptr< Dendrogram< int64_t > >, double > louvain (raft::handle_t const &, std::optional< std::reference_wrapper< raft::random::RngState > >, graph_view_t< int64_t, int64_t, false, true > const &, std::optional< edge_property_view_t< int64_t, double const * > >, size_t, double, double)

template std::pair< size_t, float > louvain (raft::handle_t const &, std::optional< std::reference_wrapper< raft::random::RngState > >, graph_view_t< int64_t, int64_t, false, true > const &, std::optional< edge_property_view_t< int64_t, float const * > >, int64_t *, size_t, float, float)

template std::pair< size_t, double > louvain (raft::handle_t const &, std::optional< std::reference_wrapper< raft::random::RngState > >, graph_view_t< int64_t, int64_t, false, true > const &, std::optional< edge_property_view_t< int64_t, double const * > >, int64_t *, size_t, double, double)

template std::pair< std::unique_ptr< Dendrogram< int32_t > >, float > louvain (raft::handle_t const &, std::optional< std::reference_wrapper< raft::random::RngState > >, graph_view_t< int32_t, int32_t, false, false > const &, std::optional< edge_property_view_t< int32_t, float const * > >, size_t, float, float)

template std::pair< std::unique_ptr< Dendrogram< int32_t > >, double > louvain (raft::handle_t const &, std::optional< std::reference_wrapper< raft::random::RngState > >, graph_view_t< int32_t, int32_t, false, false > const &, std::optional< edge_property_view_t< int32_t, double const * > >, size_t, double, double)

template std::pair< size_t, float > louvain (raft::handle_t const &, std::optional< std::reference_wrapper< raft::random::RngState > >, graph_view_t< int32_t, int32_t, false, false > const &, std::optional< edge_property_view_t< int32_t, float const * > >, int32_t *, size_t, float, float)

template std::pair< size_t, double > louvain (raft::handle_t const &, std::optional< std::reference_wrapper< raft::random::RngState > >, graph_view_t< int32_t, int32_t, false, false > const &, std::optional< edge_property_view_t< int32_t, double const * > >, int32_t *, size_t, double, double)

template std::pair< std::unique_ptr< Dendrogram< int64_t > >, float > louvain (raft::handle_t const &, std::optional< std::reference_wrapper< raft::random::RngState > >, graph_view_t< int64_t, int64_t, false, false > const &, std::optional< edge_property_view_t< int64_t, float const * > >, size_t, float, float)

template std::pair< std::unique_ptr< Dendrogram< int64_t > >, double > louvain (raft::handle_t const &, std::optional< std::reference_wrapper< raft::random::RngState > >, graph_view_t< int64_t, int64_t, false, false > const &, std::optional< edge_property_view_t< int64_t, double const * > >, size_t, double, double)

template std::pair< size_t, float > louvain (raft::handle_t const &, std::optional< std::reference_wrapper< raft::random::RngState > >, graph_view_t< int64_t, int64_t, false, false > const &, std::optional< edge_property_view_t< int64_t, float const * > >, int64_t *, size_t, float, float)

template std::pair< size_t, double > louvain (raft::handle_t const &, std::optional< std::reference_wrapper< raft::random::RngState > >, graph_view_t< int64_t, int64_t, false, false > const &, std::optional< edge_property_view_t< int64_t, double const * > >, int64_t *, size_t, double, double)

template void triangle_count (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< raft::device_span< int32_t const > > vertices, raft::device_span< int32_t > counts, bool do_expensive_check)

template void triangle_count (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< raft::device_span< int64_t const > > vertices, raft::device_span< int64_t > counts, bool do_expensive_check)

template void triangle_count (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< raft::device_span< int32_t const > > vertices, raft::device_span< int32_t > counts, bool do_expensive_check)

template void triangle_count (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< raft::device_span< int64_t const > > vertices, raft::device_span< int64_t > counts, bool do_expensive_check)

template<typename VT, typename ET, typename WT> void connected_components(legacy::GraphCSRView<VT, ET, WT> const &graph, cugraph_cc_t connectivity_type, VT *labels)#

Compute connected components.

The weak version (for undirected graphs, only) was imported from cuML. This implementation comes from [1] and solves component labeling problem in parallel on CSR-indexes based upon the vertex degree and adjacency graph.

[1] Hawick, K.A et al, 2010. “Parallel graph component labelling with GPUs and CUDA”

The strong version (for directed or undirected graphs) is based on: [2] Gilbert, J. et al, 2011. “Graph Algorithms in the Language of Linear Algebra”

C = I | A | A^2 |…| A^k where matrix multiplication is via semi-ring: (combine, reduce) == (&, |) (bitwise ops) Then: X = C & transpose(C); and finally, apply get_labels(X);

Throws:

cugraph::logic_error – when an error occurs.

Template Parameters:

VT – Type of vertex identifiers. Supported value : int (signed, 32-bit)
ET – Type of edge identifiers. Supported value : int (signed, 32-bit)
WT – Type of edge weights. Supported values : float or double.

Parameters:

graph – [in] cuGraph graph descriptor, should contain the connectivity information as a CSR
connectivity_type – [in] STRONG or WEAK
labels – [out] Device array of component labels (labels[i] indicates the label associated with vertex id i.

template void connected_components< int32_t, int32_t, float > (legacy::GraphCSRView< int32_t, int32_t, float > const &, cugraph_cc_t, int32_t *)

template void connected_components< int64_t, int64_t, float > (legacy::GraphCSRView< int64_t, int64_t, float > const &, cugraph_cc_t, int64_t *)

template rmm::device_uvector< int32_t > maximal_independent_set (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, raft::random::RngState &rng_state)

template rmm::device_uvector< int64_t > maximal_independent_set (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, raft::random::RngState &rng_state)

template rmm::device_uvector< int32_t > maximal_independent_set (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, raft::random::RngState &rng_state)

template rmm::device_uvector< int64_t > maximal_independent_set (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, raft::random::RngState &rng_state)

template rmm::device_uvector< int32_t > vertex_coloring (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, raft::random::RngState &rng_state)

template rmm::device_uvector< int64_t > vertex_coloring (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, raft::random::RngState &rng_state)

template rmm::device_uvector< int32_t > vertex_coloring (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, raft::random::RngState &rng_state)

template rmm::device_uvector< int64_t > vertex_coloring (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, raft::random::RngState &rng_state)

template<typename vertex_t, typename edge_t, bool multi_gpu> void weakly_connected_components(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, false, multi_gpu> const &graph_view, vertex_t *components, bool do_expensive_check = false)#

Finds (weakly-connected-)component IDs of each vertices in the input graph.

The input graph must be symmetric. Component IDs can be arbitrary integers (they can be non-consecutive and are not ordered by component size or any other criterion).

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false) or multi-GPU (true).

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Graph view object.
components – Pointer to the output component ID array.
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

template void weakly_connected_components (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, int32_t *components, bool do_expensive_check)

template void weakly_connected_components (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, int64_t *components, bool do_expensive_check)

template void weakly_connected_components (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, int32_t *components, bool do_expensive_check)

template void weakly_connected_components (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, int64_t *components, bool do_expensive_check)

template std::unique_ptr< legacy::GraphCSR< uint32_t, uint32_t, float > > coo_to_csr< uint32_t, uint32_t, float > (legacy::GraphCOOView< uint32_t, uint32_t, float > const &graph, rmm::device_async_resource_ref)

template std::unique_ptr< legacy::GraphCSR< uint32_t, uint32_t, double > > coo_to_csr< uint32_t, uint32_t, double > (legacy::GraphCOOView< uint32_t, uint32_t, double > const &graph, rmm::device_async_resource_ref)

template std::unique_ptr< legacy::GraphCSR< int32_t, int32_t, float > > coo_to_csr< int32_t, int32_t, float > (legacy::GraphCOOView< int32_t, int32_t, float > const &graph, rmm::device_async_resource_ref)

template std::unique_ptr< legacy::GraphCSR< int32_t, int32_t, double > > coo_to_csr< int32_t, int32_t, double > (legacy::GraphCOOView< int32_t, int32_t, double > const &graph, rmm::device_async_resource_ref)

template std::unique_ptr< legacy::GraphCSR< int64_t, int64_t, float > > coo_to_csr< int64_t, int64_t, float > (legacy::GraphCOOView< int64_t, int64_t, float > const &graph, rmm::device_async_resource_ref)

template std::unique_ptr< legacy::GraphCSR< int64_t, int64_t, double > > coo_to_csr< int64_t, int64_t, double > (legacy::GraphCOOView< int64_t, int64_t, double > const &graph, rmm::device_async_resource_ref)

template void coo_to_csr_inplace< uint32_t, uint32_t, float > (legacy::GraphCOOView< uint32_t, uint32_t, float > &graph, legacy::GraphCSRView< uint32_t, uint32_t, float > &result)

template void coo_to_csr_inplace< uint32_t, uint32_t, double > (legacy::GraphCOOView< uint32_t, uint32_t, double > &graph, legacy::GraphCSRView< uint32_t, uint32_t, double > &result)

template void coo_to_csr_inplace< int32_t, int32_t, float > (legacy::GraphCOOView< int32_t, int32_t, float > &graph, legacy::GraphCSRView< int32_t, int32_t, float > &result)

template void coo_to_csr_inplace< int32_t, int32_t, double > (legacy::GraphCOOView< int32_t, int32_t, double > &graph, legacy::GraphCSRView< int32_t, int32_t, double > &result)

template void coo_to_csr_inplace< int64_t, int64_t, float > (legacy::GraphCOOView< int64_t, int64_t, float > &graph, legacy::GraphCSRView< int64_t, int64_t, float > &result)

template void coo_to_csr_inplace< int64_t, int64_t, double > (legacy::GraphCOOView< int64_t, int64_t, double > &graph, legacy::GraphCSRView< int64_t, int64_t, double > &result)

template<typename VT, typename ET, typename WT> std::unique_ptr<legacy::GraphCSR<VT, ET, WT>> coo_to_csr(legacy::GraphCOOView<VT, ET, WT> const &graph, rmm::device_async_resource_ref mr = rmm::mr::get_current_device_resource())#

Convert COO to CSR.

Takes a list of edges in COOrdinate format and generates a CSR format.

Throws:

cugraph::logic_error – when an error occurs.

Template Parameters:

VT – type of vertex index
ET – type of edge index
WT – type of the edge weight

Parameters:

graph – [in] cuGraph graph in coordinate format
mr – [in] Memory resource used to allocate the returned graph

Returns:

Unique pointer to generate Compressed Sparse Row graph

template<typename VT, typename ET, typename WT> void coo_to_csr_inplace(legacy::GraphCOOView<VT, ET, WT> &graph, legacy::GraphCSRView<VT, ET, WT> &result)#

template<typename vertex_t, typename edge_t, bool multi_gpu> void core_number(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, false, multi_gpu> const &graph_view, edge_t *core_numbers, k_core_degree_type_t degree_type, size_t k_first = 0, size_t k_last = std::numeric_limits<size_t>::max(), bool do_expensive_check = false)#

Compute core numbers of individual vertices from K-Core decomposition.

The input graph should not have self-loops nor multi-edges. Currently, only undirected graphs are supported.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false) or multi-GPU (true).

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Graph view object.
core_numbers – Pointer to the output core number array.
degree_type – Dictate whether to compute the K-Core decomposition based on in-degrees, out-degrees, or in-degrees + out_degrees.
k_first – Find K-Cores from K = k_first. Any vertices that do not belong to k_first-core will have core numbers of 0.
k_last – Find K-Cores to K = k_last. Any vertices that belong to (k_last)-core will have their core numbers set to their degrees on k_last-core.
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

template void core_number (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, int32_t *core_numbers, k_core_degree_type_t degree_type, size_t k_first, size_t k_last, bool do_expensive_check)

template void core_number (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, int64_t *core_numbers, k_core_degree_type_t degree_type, size_t k_first, size_t k_last, bool do_expensive_check)

template void core_number (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, int32_t *core_numbers, k_core_degree_type_t degree_type, size_t k_first, size_t k_last, bool do_expensive_check)

template void core_number (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, int64_t *core_numbers, k_core_degree_type_t degree_type, size_t k_first, size_t k_last, bool do_expensive_check)

template<typename vertex_t, typename edge_t, typename weight_t, bool multi_gpu> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<weight_t>>> k_core(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, false, multi_gpu> const &graph_view, std::optional<edge_property_view_t<edge_t, weight_t const*>> edge_weight_view, size_t k, std::optional<k_core_degree_type_t> degree_type, std::optional<raft::device_span<edge_t const>> core_numbers, bool do_expensive_check = false)#

Extract K-Core of a graph.

Throws:

cugraph::logic_error – when an error occurs.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
weight_t – Type of edge weights. Needs to be a floating point type.
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false)

Parameters:

graph_view – Graph view object.
edge_weight_view – Optional view object holding edge weights for graph_view.
k – Order of the core. This value must not be negative.
degree_type – Optional parameter to dictate whether to compute the K-Core decomposition based on in-degrees, out-degrees, or in-degrees + out_degrees. One of degree_type and core_numbers must be specified.
core_numbers – Optional output from core_number algorithm. If not specified then k_core will call core_number itself using degree_type
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

edge list for the graph

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > > > k_core (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, size_t k, std::optional< k_core_degree_type_t > degree_type, std::optional< raft::device_span< int32_t const > > core_numbers, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > > > k_core (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, size_t k, std::optional< k_core_degree_type_t > degree_type, std::optional< raft::device_span< int32_t const > > core_numbers, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > > > k_core (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, size_t k, std::optional< k_core_degree_type_t > degree_type, std::optional< raft::device_span< int64_t const > > core_numbers, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > > > k_core (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, size_t k, std::optional< k_core_degree_type_t > degree_type, std::optional< raft::device_span< int64_t const > > core_numbers, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > > > k_core (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, size_t k, std::optional< k_core_degree_type_t > degree_type, std::optional< raft::device_span< int32_t const > > core_numbers, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > > > k_core (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, size_t k, std::optional< k_core_degree_type_t > degree_type, std::optional< raft::device_span< int32_t const > > core_numbers, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > > > k_core (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, size_t k, std::optional< k_core_degree_type_t > degree_type, std::optional< raft::device_span< int64_t const > > core_numbers, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > > > k_core (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, size_t k, std::optional< k_core_degree_type_t > degree_type, std::optional< raft::device_span< int64_t const > > core_numbers, bool do_expensive_check)

template<typename vertex_t> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>> generate_erdos_renyi_graph_edgelist_gnp(raft::handle_t const &handle, vertex_t num_vertices, float p, vertex_t base_vertex_id, uint64_t seed = 0)#

generate an edge lists for an Erdos-Renyi graph

This API supports the G(n,p) model which requires O(n^2) work.

If executed in a multi-gpu context (handle comms has been initialized) each GPU will generate Erdos-Renyi edges for its portion of the 2D partitioning of the adjacency matrix.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
num_vertices – Number of vertices to use in the generated graph
p – Probability for edge creation
base_vertex_id – Starting vertex id for the generated graph
seed – Seed value for the random number generator.

Returns:

std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>> A tuple of rmm::device_uvector objects for edge source vertex IDs and edge destination vertex IDs.

template<typename vertex_t> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>> generate_erdos_renyi_graph_edgelist_gnm(raft::handle_t const &handle, vertex_t num_vertices, size_t m, vertex_t base_vertex_id, uint64_t seed = 0)#

generate an edge lists for an Erdos-Renyi graph

This API supports the G(n,m) model

If executed in a multi-gpu context (handle comms has been initialized) each GPU will generate Erdos-Renyi edges for its portion of the 2D partitioning of the adjacency matrix.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
num_vertices – Number of vertices to use in each complete graph
m – Number of edges to generate
base_vertex_id – Starting vertex id for the generated graph
seed – Seed value for the random number generator.

Returns:

std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>> A tuple of rmm::device_uvector objects for edge source vertex IDs and edge destination vertex IDs.

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t > > generate_erdos_renyi_graph_edgelist_gnp (raft::handle_t const &handle, int32_t num_vertices, float p, int32_t base_vertex_id, uint64_t seed)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t > > generate_erdos_renyi_graph_edgelist_gnm (raft::handle_t const &handle, int32_t num_vertices, size_t m, int32_t base_vertex_id, uint64_t seed)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t > > generate_erdos_renyi_graph_edgelist_gnp (raft::handle_t const &handle, int64_t num_vertices, float p, int64_t base_vertex_id, uint64_t seed)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t > > generate_erdos_renyi_graph_edgelist_gnm (raft::handle_t const &handle, int64_t num_vertices, size_t m, int64_t base_vertex_id, uint64_t seed)

template<typename vertex_t> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>> generate_bipartite_rmat_edgelist(raft::handle_t const &handle, raft::random::RngState &rng_state, size_t src_scale, size_t dst_scale, size_t num_edges, double a = 0.57, double b = 0.19, double c = 0.19)#

generate an edge list for a bipartite R-mat graph.

The source vertex IDs will be in the range of [0, 2^src_scale) and the destination vertex IDs will be in the range of [0, 2^dst_scale). This function allows multi-edges.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
rng_state – RAFT RNG state, updated with each call
src_scale – Scale factor to set the range of source vertex IDs (or the first vertex set) in the bipartite graph. Vertex IDs have values in [0, V_src), where V_src = 1 << src_scale.
dst_scale – Scale factor to set the range of destination vertex IDs (or the second vertex set) in the bipartite graph. Vertex IDs have values in [0, V_dst), where V_dst = 1 << dst_scale.
num_edges – Number of edges to generate.
a – a, b, c, d (= 1.0 - (a + b + c)) in the R-mat graph generator (vist https://graph500.org for additional details). a, b, c, d should be non-negative and a + b + c should be no larger than 1.0.
b – a, b, c, d (= 1.0 - (a + b + c)) in the R-mat graph generator (vist https://graph500.org for additional details). a, b, c, d should be non-negative and a + b + c should be no larger than 1.0.
c – a, b, c, d (= 1.0 - (a + b + c)) in the R-mat graph generator (vist https://graph500.org for additional details). a, b, c, d should be non-negative and a + b + c should be no larger than 1.0.

Returns:

std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>> A tuple of rmm::device_uvector objects for edge source vertex IDs and edge destination vertex IDs.

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t > > generate_bipartite_rmat_edgelist< int32_t > (raft::handle_t const &handle, raft::random::RngState &rng_state, size_t src_scale, size_t dst_scale, size_t num_edges, double a, double b, double c)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t > > generate_bipartite_rmat_edgelist< int64_t > (raft::handle_t const &handle, raft::random::RngState &rng_state, size_t src_scale, size_t dst_scale, size_t num_edges, double a, double b, double c)

template<typename vertex_t> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>> generate_rmat_edgelist(raft::handle_t const &handle, raft::random::RngState &rng_state, size_t scale, size_t num_edges, double a = 0.57, double b = 0.19, double c = 0.19, bool clip_and_flip = false, bool scramble_vertex_ids = false)#

generate an edge list for an R-mat graph.

This function allows multi-edges and self-loops similar to the Graph 500 reference implementation.

NOTE: The scramble_vertex_ids function needs to be called in order to generate a graph conforming to the Graph 500 specification (note that scrambling does not affect cuGraph’s graph construction performance, so this is generally unnecessary). If edge_factor is given (e.g. Graph 500), set num_edges to (size_t{1} << scale) * edge_factor. To generate an undirected graph, set b == c and clip_and_flip = true. All the resulting edges will be placed in the lower triangular part (including the diagonal) of the graph adjacency matrix.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
rng_state – RAFT RNG state, updated with each call
scale – Scale factor to set the number of vertices in the graph. Vertex IDs have values in [0, V), where V = 1 << scale.
num_edges – Number of edges to generate.
a – a, b, c, d (= 1.0 - (a + b + c)) in the R-mat graph generator (vist https://graph500.org for additional details). a, b, c, d should be non-negative and a + b + c should be no larger than 1.0.
b – a, b, c, d (= 1.0 - (a + b + c)) in the R-mat graph generator (vist https://graph500.org for additional details). a, b, c, d should be non-negative and a + b + c should be no larger than 1.0.
c – a, b, c, d (= 1.0 - (a + b + c)) in the R-mat graph generator (vist https://graph500.org for additional details). a, b, c, d should be non-negative and a + b + c should be no larger than 1.0.
clip_and_flip – Flag controlling whether to generate edges only in the lower triangular part (including the diagonal) of the graph adjacency matrix (if set to true) or not (if set to false).
scramble_vertex_ids – Flag controlling whether to scramble vertex ID bits (if set to true) or not (if set to false); scrambling vertex ID bits breaks correlation between vertex ID values and vertex degrees.

Returns:

std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>> A tuple of rmm::device_uvector objects for edge source vertex IDs and edge destination vertex IDs.

template<typename vertex_t> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>> generate_rmat_edgelist(raft::handle_t const &handle, size_t scale, size_t num_edges, double a = 0.57, double b = 0.19, double c = 0.19, uint64_t seed = 0, bool clip_and_flip = false, bool scramble_vertex_ids = false)#

generate an edge list for an R-mat graph.

Deprecated:: This function will be deprectated and should be replaced with the version that takes raft::random::RngState as a parameter

This function allows multi-edges and self-loops similar to the Graph 500 reference implementation.

For multi-GPU generation with P GPUs, seed should be set to different values in different GPUs to avoid every GPU generating the same set of edges. num_edges should be adjusted as well; e.g. assuming edge_factor is given, set num_edges = (size_t{1} << scale) * edge_factor / P + (rank < (((size_t{1} << scale) * edge_factor) % P) ? 1 : 0).

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
scale – Scale factor to set the number of verties in the graph. Vertex IDs have values in [0, V), where V = 1 << scale.
num_edges – Number of edges to generate.
a – a, b, c, d (= 1.0 - (a + b + c)) in the R-mat graph generator (vist https://graph500.org for additional details). a, b, c, d should be non-negative and a + b + c should be no larger than 1.0.
b – a, b, c, d (= 1.0 - (a + b + c)) in the R-mat graph generator (vist https://graph500.org for additional details). a, b, c, d should be non-negative and a + b + c should be no larger than 1.0.
c – a, b, c, d (= 1.0 - (a + b + c)) in the R-mat graph generator (vist https://graph500.org for additional details). a, b, c, d should be non-negative and a + b + c should be no larger than 1.0.
seed – Seed value for the random number generator.
clip_and_flip – Flag controlling whether to generate edges only in the lower triangular part (including the diagonal) of the graph adjacency matrix (if set to true) or not (if set to false).
scramble_vertex_ids – Flag controlling whether to scramble vertex ID bits (if set to true) or not (if set to false); scrambling vertex ID bits breaks correlation between vertex ID values and vertex degrees.

Returns:

std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>> A tuple of rmm::device_uvector objects for edge source vertex IDs and edge destination vertex IDs.

template<typename vertex_t> std::vector<std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>>> generate_rmat_edgelists(raft::handle_t const &handle, raft::random::RngState &rng_state, size_t n_edgelists, size_t min_scale, size_t max_scale, size_t edge_factor = 16, generator_distribution_t size_distribution = generator_distribution_t::POWER_LAW, generator_distribution_t edge_distribution = generator_distribution_t::POWER_LAW, bool clip_and_flip = false, bool scramble_vertex_ids = false)#

generate multiple edge lists using the R-mat graph generator.

This function allows multi-edges and self-loops similar to the Graph 500 reference implementation.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
rng_state – RAFT RNG state, updated with each call
n_edgelists – Number of edge lists (graphs) to generate
min_scale – Scale factor to set the minimum number of verties in the graph.
max_scale – Scale factor to set the maximum number of verties in the graph.
edge_factor – Average number of edges per vertex to generate.
size_distribution – Distribution of the graph sizes, impacts the scale parameter of the R-MAT generator
edge_distribution – Edges distribution for each graph, impacts how R-MAT parameters a,b,c,d, are set.
clip_and_flip – Flag controlling whether to generate edges only in the lower triangular part (including the diagonal) of the graph adjacency matrix (if set to true) or not (if set to false).
scramble_vertex_ids – Flag controlling whether to scramble vertex ID bits (if set to true) or not (if set to false); scrambling vertex ID bits breaks correlation between vertex ID values and vertex degrees.

Returns:

A vector of std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>> of size n_edgelists, each vector element being a tuple of rmm::device_uvector objects for edge source vertex IDs and edge destination vertex IDs.

template<typename vertex_t> std::vector<std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>>> generate_rmat_edgelists(raft::handle_t const &handle, size_t n_edgelists, size_t min_scale, size_t max_scale, size_t edge_factor = 16, generator_distribution_t size_distribution = generator_distribution_t::POWER_LAW, generator_distribution_t edge_distribution = generator_distribution_t::POWER_LAW, uint64_t seed = 0, bool clip_and_flip = false, bool scramble_vertex_ids = false)#

generate multiple edge lists using the R-mat graph generator.

Deprecated:: This function will be deprectated and should be replaced with the version that takes raft::random::RngState as a parameter

This function allows multi-edges and self-loops similar to the Graph 500 reference implementation.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
n_edgelists – Number of edge lists (graphs) to generate
min_scale – Scale factor to set the minimum number of verties in the graph.
max_scale – Scale factor to set the maximum number of verties in the graph.
edge_factor – Average number of edges per vertex to generate.
size_distribution – Distribution of the graph sizes, impacts the scale parameter of the R-MAT generator
edge_distribution – Edges distribution for each graph, impacts how R-MAT parameters a,b,c,d, are set.
seed – Seed value for the random number generator.
clip_and_flip – Flag controlling whether to generate edges only in the lower triangular part (including the diagonal) of the graph adjacency matrix (if set to true) or not (if set to false).
scramble_vertex_ids – Flag controlling whether to scramble vertex ID bits (if set to true) or not (if set to false); scrambling vertex ID bits breaks correlation between vertex ID values and vertex degrees.

Returns:

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t > > generate_rmat_edgelist< int32_t > (raft::handle_t const &handle, raft::random::RngState &rng_state, size_t scale, size_t num_edges, double a, double b, double c, bool clip_and_flip, bool scramble_vertex_ids)

template std::vector< std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t > > > generate_rmat_edgelists< int32_t > (raft::handle_t const &handle, raft::random::RngState &rng_state, size_t n_edgelists, size_t min_scale, size_t max_scale, size_t edge_factor, generator_distribution_t size_distribution, generator_distribution_t edge_distribution, bool clip_and_flip, bool scramble_vertex_ids)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t > > generate_rmat_edgelist< int32_t > (raft::handle_t const &handle, size_t scale, size_t num_edges, double a, double b, double c, uint64_t seed, bool clip_and_flip, bool scramble_vertex_ids)

template std::vector< std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t > > > generate_rmat_edgelists< int32_t > (raft::handle_t const &handle, size_t n_edgelists, size_t min_scale, size_t max_scale, size_t edge_factor, generator_distribution_t size_distribution, generator_distribution_t edge_distribution, uint64_t seed, bool clip_and_flip, bool scramble_vertex_ids)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t > > generate_rmat_edgelist< int64_t > (raft::handle_t const &handle, raft::random::RngState &rng_state, size_t scale, size_t num_edges, double a, double b, double c, bool clip_and_flip, bool scramble_vertex_ids)

template std::vector< std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t > > > generate_rmat_edgelists< int64_t > (raft::handle_t const &handle, raft::random::RngState &rng_state, size_t n_edgelists, size_t min_scale, size_t max_scale, size_t edge_factor, generator_distribution_t size_distribution, generator_distribution_t edge_distribution, bool clip_and_flip, bool scramble_vertex_ids)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t > > generate_rmat_edgelist< int64_t > (raft::handle_t const &handle, size_t scale, size_t num_edges, double a, double b, double c, uint64_t seed, bool clip_and_flip, bool scramble_vertex_ids)

template std::vector< std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t > > > generate_rmat_edgelists< int64_t > (raft::handle_t const &handle, size_t n_edgelists, size_t min_scale, size_t max_scale, size_t edge_factor, generator_distribution_t size_distribution, generator_distribution_t edge_distribution, uint64_t seed, bool clip_and_flip, bool scramble_vertex_ids)

template<typename vertex_t> rmm::device_uvector<vertex_t> scramble_vertex_ids(raft::handle_t const &handle, rmm::device_uvector<vertex_t> &&vertices, size_t lgN)#

scramble vertex IDs in a graph

Given a vertex list for a graph, scramble the input vertex IDs.

The scramble code here follows the algorithm in the Graph 500 reference implementation version 3.0.0.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
vertices – Vector of input vertices
lgN – The input & output (scrambled) vertex IDs are assumed to be in [0, 2^lgN).

Returns:

rmm::device_uvector object storing scrambled vertex IDs.

template<typename vertex_t> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>> scramble_vertex_ids(raft::handle_t const &handle, rmm::device_uvector<vertex_t> &&srcs, rmm::device_uvector<vertex_t> &&dsts, size_t lgN)#

scramble vertex ids in a graph

Given an edge list for a graph, scramble the input vertex IDs.

The scramble code here follows the algorithm in the Graph 500 reference implementation version 3.0.0.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
d_src_v – Vector of input source vertices
d_dst_v – Vector of input destination vertices
lgN – The input & output (scrambled) vertex IDs are assumed to be in [0, 2^lgN).

Returns:

Tuple of two rmm::device_uvector objects storing scrambled source & destination vertex IDs, respectively.

template<typename vertex_t, typename weight_t> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<weight_t>>> combine_edgelists(raft::handle_t const &handle, std::vector<rmm::device_uvector<vertex_t>> &&d_sources, std::vector<rmm::device_uvector<vertex_t>> &&d_dests, std::optional<std::vector<rmm::device_uvector<weight_t>>> &&optional_d_weights, bool remove_multi_edges = true)#

Combine edgelists from multiple sources into a single edgelist.

If executed in a multi-gpu context (handle comms has been initialized) each GPU will operate only on its subset of data. Any shuffling to get edges onto the same GPU should be done prior to calling this function.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
sources – The source vertex ids to combine
dests – The destination vertex ids to combine
weights – Optional vector of weights to combine
remove_multi_edges – If true (the default) then remove multi edges, if false leave them in

Returns:

std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>, rmm::device_uvector<weight_t>> A tuple of rmm::device_uvector objects for edge source vertex IDs and edge destination vertex IDs and edge weights.

template<typename vertex_t, typename weight_t> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<weight_t>>> symmetrize_edgelist_from_triangular(raft::handle_t const &handle, rmm::device_uvector<vertex_t> &&d_src_v, rmm::device_uvector<vertex_t> &&d_dst_v, std::optional<rmm::device_uvector<weight_t>> &&optional_d_weights_v, bool check_diagonal = false)#

symmetrize an edgelist from the edges in the lower (or upper but not both) triangular part of a graph adjacency matrix

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
weight_t – Type of weights.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
d_src_v – Vector of source vertices
d_dst_v – Vector of destination vertices
d_weights_v – Optional vector of edge weights
check_diagonal – Flag indicating whether to check for diagonal edges or not. If set to true, symmetrize only the edges with source != destination (to avoid duplicating every self-loops).

Returns:

std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>> A tuple of rmm::device_uvector objects for edge source vertex IDs and edge destination vertex IDs.

template rmm::device_uvector< int32_t > scramble_vertex_ids (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&vertices, size_t lgN)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t > > scramble_vertex_ids (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&srcs, rmm::device_uvector< int32_t > &&dsts, size_t lgN)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > > > combine_edgelists (raft::handle_t const &handle, std::vector< rmm::device_uvector< int32_t > > &&sources, std::vector< rmm::device_uvector< int32_t > > &&dests, std::optional< std::vector< rmm::device_uvector< float > > > &&optional_d_weights, bool remove_multi_edges)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > > > combine_edgelists (raft::handle_t const &handle, std::vector< rmm::device_uvector< int32_t > > &&sources, std::vector< rmm::device_uvector< int32_t > > &&dests, std::optional< std::vector< rmm::device_uvector< double > > > &&optional_d_weights, bool remove_multi_edges)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > > > symmetrize_edgelist_from_triangular (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&d_src_v, rmm::device_uvector< int32_t > &&d_dst_v, std::optional< rmm::device_uvector< float > > &&optional_d_weights_v, bool check_diagonal)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > > > symmetrize_edgelist_from_triangular (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&d_src_v, rmm::device_uvector< int32_t > &&d_dst_v, std::optional< rmm::device_uvector< double > > &&optional_d_weights_v, bool check_diagonal)

template rmm::device_uvector< int64_t > scramble_vertex_ids (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&vertices, size_t lgN)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t > > scramble_vertex_ids (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&srcs, rmm::device_uvector< int64_t > &&dsts, size_t lgN)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > > > combine_edgelists (raft::handle_t const &handle, std::vector< rmm::device_uvector< int64_t > > &&sources, std::vector< rmm::device_uvector< int64_t > > &&dests, std::optional< std::vector< rmm::device_uvector< float > > > &&optional_d_weights, bool remove_multi_edges)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > > > combine_edgelists (raft::handle_t const &handle, std::vector< rmm::device_uvector< int64_t > > &&sources, std::vector< rmm::device_uvector< int64_t > > &&dests, std::optional< std::vector< rmm::device_uvector< double > > > &&optional_d_weights, bool remove_multi_edges)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > > > symmetrize_edgelist_from_triangular (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&d_src_v, rmm::device_uvector< int64_t > &&d_dst_v, std::optional< rmm::device_uvector< float > > &&optional_d_weights_v, bool check_diagonal)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > > > symmetrize_edgelist_from_triangular (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&d_src_v, rmm::device_uvector< int64_t > &&d_dst_v, std::optional< rmm::device_uvector< double > > &&optional_d_weights_v, bool check_diagonal)

template<typename vertex_t> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>> generate_path_graph_edgelist(raft::handle_t const &handle, std::vector<std::tuple<vertex_t, vertex_t>> const &component_parameters_v)#

generate an edge list for path graph

A path graph of size n connects the vertices from 0 to (n - 1) in a single long path: ((0,1), (1,2), …, (n - 2, n - 1)

If executed in a multi-gpu context (handle comms has been initialized) the path will span all GPUs including an edge from the last vertex on GPU i to the first vertex on GPU (i+1)

This function will generate a collection of path graphs. component_parameters_v defines the parameters for generating each component. Each element of component_parameters_v defines a tuple consisting of the number of vertices and the base vertex id for the component.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
component_parameters_v – A vector containing tuples consisting of the number of vertices and base vertex id for each component to generate.

Returns:

std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>> A tuple of rmm::device_uvector objects for edge source vertex IDs and edge destination vertex IDs.

template<typename vertex_t> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>> generate_2d_mesh_graph_edgelist(raft::handle_t const &handle, std::vector<std::tuple<vertex_t, vertex_t, vertex_t>> const &component_parameters_v)#

generate an edge list for a 2D Mesh Graph

A sequence of 2D mesh graphs will be constructed according to the component specifications. Each 2D mesh graph is configured with a tuple containing (x, y, base_vertex_id). component_parameters_v will contain a tuple for each component.

If executed in a multi-gpu context (handle comms has been initialized) each GPU will generate disjoint 2D mesh constructs of equal size.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
component_parameters_v – Vector containing tuple defining the configuration of each component

Returns:

std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>> A tuple of rmm::device_uvector objects for edge source vertex IDs and edge destination vertex IDs.

template<typename vertex_t> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>> generate_3d_mesh_graph_edgelist(raft::handle_t const &handle, std::vector<std::tuple<vertex_t, vertex_t, vertex_t, vertex_t>> const &component_parameters_v)#

generate an edge list for a 3D Mesh Graph

A sequence of 3D mesh graphs will be constructed according to the component specifications. Each 3D mesh graph is configured with a tuple containing (x, y, z, base_vertex_id). component_parameters_v will contain a tuple for each component.

If executed in a multi-gpu context (handle comms has been initialized) each GPU will generate disjoint 3D mesh constructs of equal size.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
component_parameters_v – Vector containing tuple defining the configuration of each component

Returns:

std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>> A tuple of rmm::device_uvector objects for edge source vertex IDs and edge destination vertex IDs.

template<typename vertex_t> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>> generate_complete_graph_edgelist(raft::handle_t const &handle, std::vector<std::tuple<vertex_t, vertex_t>> const &component_parameters_v)#

generate an edge lists for some complete graphs

A sequence of complete graphs will be constructed according to the component specifications. Each complete graph is configured with a tuple containing (n, base_vertex_id). component_parameters_v will contain a tuple for each component.

If executed in a multi-gpu context (handle comms has been initialized) each GPU will generate disjoint complete graph constructs of equal size.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
component_parameters_v – Vector containing tuple defining the configuration of each component

Returns:

std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>> A tuple of rmm::device_uvector objects for edge source vertex IDs and edge destination vertex IDs.

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t > > generate_path_graph_edgelist (raft::handle_t const &handle, std::vector< std::tuple< int32_t, int32_t > > const &component_parms_v)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t > > generate_2d_mesh_graph_edgelist (raft::handle_t const &handle, std::vector< std::tuple< int32_t, int32_t, int32_t > > const &component_parms_v)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t > > generate_3d_mesh_graph_edgelist (raft::handle_t const &handle, std::vector< std::tuple< int32_t, int32_t, int32_t, int32_t > > const &component_parms_v)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t > > generate_complete_graph_edgelist (raft::handle_t const &handle, std::vector< std::tuple< int32_t, int32_t > > const &component_parms_v)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t > > generate_path_graph_edgelist (raft::handle_t const &handle, std::vector< std::tuple< int64_t, int64_t > > const &component_parms_v)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t > > generate_2d_mesh_graph_edgelist (raft::handle_t const &handle, std::vector< std::tuple< int64_t, int64_t, int64_t > > const &component_parms_v)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t > > generate_3d_mesh_graph_edgelist (raft::handle_t const &handle, std::vector< std::tuple< int64_t, int64_t, int64_t, int64_t > > const &component_parms_v)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t > > generate_complete_graph_edgelist (raft::handle_t const &handle, std::vector< std::tuple< int64_t, int64_t > > const &component_parms_v)

template void force_atlas2< int, int, float > (raft::handle_t const &handle, legacy::GraphCOOView< int, int, float > &graph, float *pos, const int max_iter, float *x_start, float *y_start, bool outbound_attraction_distribution, bool lin_log_mode, bool prevent_overlapping, const float edge_weight_influence, const float jitter_tolerance, bool barnes_hut_optimize, const float barnes_hut_theta, const float scaling_ratio, bool strong_gravity_mode, const float gravity, bool verbose, internals::GraphBasedDimRedCallback *callback)

template void force_atlas2< int, int, double > (raft::handle_t const &handle, legacy::GraphCOOView< int, int, double > &graph, float *pos, const int max_iter, float *x_start, float *y_start, bool outbound_attraction_distribution, bool lin_log_mode, bool prevent_overlapping, const float edge_weight_influence, const float jitter_tolerance, bool barnes_hut_optimize, const float barnes_hut_theta, const float scaling_ratio, bool strong_gravity_mode, const float gravity, bool verbose, internals::GraphBasedDimRedCallback *callback)

template int32_t hungarian< int32_t, int32_t, int32_t > (raft::handle_t const &, legacy::GraphCOOView< int32_t, int32_t, int32_t > const &, int32_t, int32_t const *, int32_t *, int32_t)

template float hungarian< int32_t, int32_t, float > (raft::handle_t const &, legacy::GraphCOOView< int32_t, int32_t, float > const &, int32_t, int32_t const *, int32_t *, float)

template double hungarian< int32_t, int32_t, double > (raft::handle_t const &, legacy::GraphCOOView< int32_t, int32_t, double > const &, int32_t, int32_t const *, int32_t *, double)

template int32_t hungarian< int32_t, int32_t, int32_t > (raft::handle_t const &, legacy::GraphCOOView< int32_t, int32_t, int32_t > const &, int32_t, int32_t const *, int32_t *)

template float hungarian< int32_t, int32_t, float > (raft::handle_t const &, legacy::GraphCOOView< int32_t, int32_t, float > const &, int32_t, int32_t const *, int32_t *)

template double hungarian< int32_t, int32_t, double > (raft::handle_t const &, legacy::GraphCOOView< int32_t, int32_t, double > const &, int32_t, int32_t const *, int32_t *)

template std::tuple< float, size_t > hits (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, true > const &graph_view, float *const hubs, float *const authorities, float epsilon, size_t max_iterations, bool has_initial_hubs_guess, bool normalize, bool do_expensive_check)

template std::tuple< double, size_t > hits (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, true > const &graph_view, double *const hubs, double *const authorities, double epsilon, size_t max_iterations, bool has_initial_hubs_guess, bool normalize, bool do_expensive_check)

template std::tuple< float, size_t > hits (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, true > const &graph_view, float *const hubs, float *const authorities, float epsilon, size_t max_iterations, bool has_initial_hubs_guess, bool normalize, bool do_expensive_check)

template std::tuple< double, size_t > hits (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, true > const &graph_view, double *const hubs, double *const authorities, double epsilon, size_t max_iterations, bool has_initial_hubs_guess, bool normalize, bool do_expensive_check)

template std::tuple< float, size_t > hits (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, false > const &graph_view, float *const hubs, float *const authorities, float epsilon, size_t max_iterations, bool has_initial_hubs_guess, bool normalize, bool do_expensive_check)

template std::tuple< double, size_t > hits (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, false > const &graph_view, double *const hubs, double *const authorities, double epsilon, size_t max_iterations, bool has_initial_hubs_guess, bool normalize, bool do_expensive_check)

template std::tuple< float, size_t > hits (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, false > const &graph_view, float *const hubs, float *const authorities, float epsilon, size_t max_iterations, bool has_initial_hubs_guess, bool normalize, bool do_expensive_check)

template std::tuple< double, size_t > hits (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, false > const &graph_view, double *const hubs, double *const authorities, double epsilon, size_t max_iterations, bool has_initial_hubs_guess, bool normalize, bool do_expensive_check)

template void pagerank (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< float const * > precomputed_vertex_out_weight_sums, std::optional< int32_t const * > personalization_vertices, std::optional< float const * > personalization_values, std::optional< int32_t > personalization_vector_size, float *pageranks, float alpha, float epsilon, size_t max_iterations, bool has_initial_guess, bool do_expensive_check)

template void pagerank (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< double const * > precomputed_vertex_out_weight_sums, std::optional< int32_t const * > personalization_vertices, std::optional< double const * > personalization_values, std::optional< int32_t > personalization_vector_size, double *pageranks, double alpha, double epsilon, size_t max_iterations, bool has_initial_guess, bool do_expensive_check)

template std::tuple< rmm::device_uvector< float >, centrality_algorithm_metadata_t > pagerank (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< raft::device_span< float const > > precomputed_vertex_out_weight_sums, std::optional< std::tuple< raft::device_span< int32_t const >, raft::device_span< float const > > > personalization, std::optional< raft::device_span< float const > > initial_pageranks, float alpha, float epsilon, size_t max_iterations, bool do_expensive_check)

template std::tuple< rmm::device_uvector< double >, centrality_algorithm_metadata_t > pagerank (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< raft::device_span< double const > > precomputed_vertex_out_weight_sums, std::optional< std::tuple< raft::device_span< int32_t const >, raft::device_span< double const > > > personalization, std::optional< raft::device_span< double const > > initial_pageranks, double alpha, double epsilon, size_t max_iterations, bool do_expensive_check)

template void pagerank (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< float const * > precomputed_vertex_out_weight_sums, std::optional< int64_t const * > personalization_vertices, std::optional< float const * > personalization_values, std::optional< int64_t > personalization_vector_size, float *pageranks, float alpha, float epsilon, size_t max_iterations, bool has_initial_guess, bool do_expensive_check)

template void pagerank (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< double const * > precomputed_vertex_out_weight_sums, std::optional< int64_t const * > personalization_vertices, std::optional< double const * > personalization_values, std::optional< int64_t > personalization_vector_size, double *pageranks, double alpha, double epsilon, size_t max_iterations, bool has_initial_guess, bool do_expensive_check)

template std::tuple< rmm::device_uvector< float >, centrality_algorithm_metadata_t > pagerank (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< raft::device_span< float const > > precomputed_vertex_out_weight_sums, std::optional< std::tuple< raft::device_span< int64_t const >, raft::device_span< float const > > > personalization, std::optional< raft::device_span< float const > > initial_pageranks, float alpha, float epsilon, size_t max_iterations, bool do_expensive_check)

template std::tuple< rmm::device_uvector< double >, centrality_algorithm_metadata_t > pagerank (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< raft::device_span< double const > > precomputed_vertex_out_weight_sums, std::optional< std::tuple< raft::device_span< int64_t const >, raft::device_span< double const > > > personalization, std::optional< raft::device_span< double const > > initial_pageranks, double alpha, double epsilon, size_t max_iterations, bool do_expensive_check)

template void pagerank (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< float const * > precomputed_vertex_out_weight_sums, std::optional< int32_t const * > personalization_vertices, std::optional< float const * > personalization_values, std::optional< int32_t > personalization_vector_size, float *pageranks, float alpha, float epsilon, size_t max_iterations, bool has_initial_guess, bool do_expensive_check)

template void pagerank (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< double const * > precomputed_vertex_out_weight_sums, std::optional< int32_t const * > personalization_vertices, std::optional< double const * > personalization_values, std::optional< int32_t > personalization_vector_size, double *pageranks, double alpha, double epsilon, size_t max_iterations, bool has_initial_guess, bool do_expensive_check)

template std::tuple< rmm::device_uvector< float >, centrality_algorithm_metadata_t > pagerank (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< raft::device_span< float const > > precomputed_vertex_out_weight_sums, std::optional< std::tuple< raft::device_span< int32_t const >, raft::device_span< float const > > > personalization, std::optional< raft::device_span< float const > > initial_pageranks, float alpha, float epsilon, size_t max_iterations, bool do_expensive_check)

template std::tuple< rmm::device_uvector< double >, centrality_algorithm_metadata_t > pagerank (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< raft::device_span< double const > > precomputed_vertex_out_weight_sums, std::optional< std::tuple< raft::device_span< int32_t const >, raft::device_span< double const > > > personalization, std::optional< raft::device_span< double const > > initial_pageranks, double alpha, double epsilon, size_t max_iterations, bool do_expensive_check)

template void pagerank (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< float const * > precomputed_vertex_out_weight_sums, std::optional< int64_t const * > personalization_vertices, std::optional< float const * > personalization_values, std::optional< int64_t > personalization_vector_size, float *pageranks, float alpha, float epsilon, size_t max_iterations, bool has_initial_guess, bool do_expensive_check)

template void pagerank (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< double const * > precomputed_vertex_out_weight_sums, std::optional< int64_t const * > personalization_vertices, std::optional< double const * > personalization_values, std::optional< int64_t > personalization_vector_size, double *pageranks, double alpha, double epsilon, size_t max_iterations, bool has_initial_guess, bool do_expensive_check)

template std::tuple< rmm::device_uvector< float >, centrality_algorithm_metadata_t > pagerank (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< raft::device_span< float const > > precomputed_vertex_out_weight_sums, std::optional< std::tuple< raft::device_span< int64_t const >, raft::device_span< float const > > > personalization, std::optional< raft::device_span< float const > > initial_pageranks, float alpha, float epsilon, size_t max_iterations, bool do_expensive_check)

template std::tuple< rmm::device_uvector< double >, centrality_algorithm_metadata_t > pagerank (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< raft::device_span< double const > > precomputed_vertex_out_weight_sums, std::optional< std::tuple< raft::device_span< int64_t const >, raft::device_span< double const > > > personalization, std::optional< raft::device_span< double const > > initial_pageranks, double alpha, double epsilon, size_t max_iterations, bool do_expensive_check)

template rmm::device_uvector< float > cosine_similarity_coefficients (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::tuple< raft::device_span< int32_t const >, raft::device_span< int32_t const > > vertex_pairs, bool do_expensive_check)

template rmm::device_uvector< double > cosine_similarity_coefficients (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::tuple< raft::device_span< int32_t const >, raft::device_span< int32_t const > > vertex_pairs, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, rmm::device_uvector< float > > cosine_similarity_all_pairs_coefficients (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< raft::device_span< int32_t const > > vertices, std::optional< size_t > topk, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, rmm::device_uvector< double > > cosine_similarity_all_pairs_coefficients (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< raft::device_span< int32_t const > > vertices, std::optional< size_t > topk, bool do_expensive_check)

template rmm::device_uvector< float > cosine_similarity_coefficients (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::tuple< raft::device_span< int64_t const >, raft::device_span< int64_t const > > vertex_pairs, bool do_expensive_check)

template rmm::device_uvector< double > cosine_similarity_coefficients (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::tuple< raft::device_span< int64_t const >, raft::device_span< int64_t const > > vertex_pairs, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, rmm::device_uvector< float > > cosine_similarity_all_pairs_coefficients (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< raft::device_span< int64_t const > > vertices, std::optional< size_t > topk, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, rmm::device_uvector< double > > cosine_similarity_all_pairs_coefficients (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< raft::device_span< int64_t const > > vertices, std::optional< size_t > topk, bool do_expensive_check)

template rmm::device_uvector< float > cosine_similarity_coefficients (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::tuple< raft::device_span< int32_t const >, raft::device_span< int32_t const > > vertex_pairs, bool do_expensive_check)

template rmm::device_uvector< double > cosine_similarity_coefficients (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::tuple< raft::device_span< int32_t const >, raft::device_span< int32_t const > > vertex_pairs, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, rmm::device_uvector< float > > cosine_similarity_all_pairs_coefficients (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< raft::device_span< int32_t const > > vertices, std::optional< size_t > topk, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, rmm::device_uvector< double > > cosine_similarity_all_pairs_coefficients (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< raft::device_span< int32_t const > > vertices, std::optional< size_t > topk, bool do_expensive_check)

template rmm::device_uvector< float > cosine_similarity_coefficients (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::tuple< raft::device_span< int64_t const >, raft::device_span< int64_t const > > vertex_pairs, bool do_expensive_check)

template rmm::device_uvector< double > cosine_similarity_coefficients (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::tuple< raft::device_span< int64_t const >, raft::device_span< int64_t const > > vertex_pairs, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, rmm::device_uvector< float > > cosine_similarity_all_pairs_coefficients (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< raft::device_span< int64_t const > > vertices, std::optional< size_t > topk, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, rmm::device_uvector< double > > cosine_similarity_all_pairs_coefficients (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< raft::device_span< int64_t const > > vertices, std::optional< size_t > topk, bool do_expensive_check)

template rmm::device_uvector< float > jaccard_coefficients (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::tuple< raft::device_span< int32_t const >, raft::device_span< int32_t const > > vertex_pairs, bool do_expensive_check)

template rmm::device_uvector< double > jaccard_coefficients (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::tuple< raft::device_span< int32_t const >, raft::device_span< int32_t const > > vertex_pairs, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, rmm::device_uvector< float > > jaccard_all_pairs_coefficients (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< raft::device_span< int32_t const > > vertices, std::optional< size_t > topk, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, rmm::device_uvector< double > > jaccard_all_pairs_coefficients (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< raft::device_span< int32_t const > > vertices, std::optional< size_t > topk, bool do_expensive_check)

template rmm::device_uvector< float > jaccard_coefficients (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::tuple< raft::device_span< int64_t const >, raft::device_span< int64_t const > > vertex_pairs, bool do_expensive_check)

template rmm::device_uvector< double > jaccard_coefficients (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::tuple< raft::device_span< int64_t const >, raft::device_span< int64_t const > > vertex_pairs, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, rmm::device_uvector< float > > jaccard_all_pairs_coefficients (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< raft::device_span< int64_t const > > vertices, std::optional< size_t > topk, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, rmm::device_uvector< double > > jaccard_all_pairs_coefficients (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< raft::device_span< int64_t const > > vertices, std::optional< size_t > topk, bool do_expensive_check)

template rmm::device_uvector< float > jaccard_coefficients (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::tuple< raft::device_span< int32_t const >, raft::device_span< int32_t const > > vertex_pairs, bool do_expensive_check)

template rmm::device_uvector< double > jaccard_coefficients (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::tuple< raft::device_span< int32_t const >, raft::device_span< int32_t const > > vertex_pairs, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, rmm::device_uvector< float > > jaccard_all_pairs_coefficients (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< raft::device_span< int32_t const > > vertices, std::optional< size_t > topk, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, rmm::device_uvector< double > > jaccard_all_pairs_coefficients (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< raft::device_span< int32_t const > > vertices, std::optional< size_t > topk, bool do_expensive_check)

template rmm::device_uvector< float > jaccard_coefficients (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::tuple< raft::device_span< int64_t const >, raft::device_span< int64_t const > > vertex_pairs, bool do_expensive_check)

template rmm::device_uvector< double > jaccard_coefficients (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::tuple< raft::device_span< int64_t const >, raft::device_span< int64_t const > > vertex_pairs, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, rmm::device_uvector< float > > jaccard_all_pairs_coefficients (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< raft::device_span< int64_t const > > vertices, std::optional< size_t > topk, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, rmm::device_uvector< double > > jaccard_all_pairs_coefficients (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< raft::device_span< int64_t const > > vertices, std::optional< size_t > topk, bool do_expensive_check)

template rmm::device_uvector< float > overlap_coefficients (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::tuple< raft::device_span< int32_t const >, raft::device_span< int32_t const > > vertex_pairs, bool do_expensive_check)

template rmm::device_uvector< double > overlap_coefficients (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::tuple< raft::device_span< int32_t const >, raft::device_span< int32_t const > > vertex_pairs, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, rmm::device_uvector< float > > overlap_all_pairs_coefficients (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< raft::device_span< int32_t const > > vertices, std::optional< size_t > topk, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, rmm::device_uvector< double > > overlap_all_pairs_coefficients (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< raft::device_span< int32_t const > > vertices, std::optional< size_t > topk, bool do_expensive_check)

template rmm::device_uvector< float > overlap_coefficients (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::tuple< raft::device_span< int64_t const >, raft::device_span< int64_t const > > vertex_pairs, bool do_expensive_check)

template rmm::device_uvector< double > overlap_coefficients (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::tuple< raft::device_span< int64_t const >, raft::device_span< int64_t const > > vertex_pairs, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, rmm::device_uvector< float > > overlap_all_pairs_coefficients (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< raft::device_span< int64_t const > > vertices, std::optional< size_t > topk, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, rmm::device_uvector< double > > overlap_all_pairs_coefficients (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< raft::device_span< int64_t const > > vertices, std::optional< size_t > topk, bool do_expensive_check)

template rmm::device_uvector< float > overlap_coefficients (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::tuple< raft::device_span< int32_t const >, raft::device_span< int32_t const > > vertex_pairs, bool do_expensive_check)

template rmm::device_uvector< double > overlap_coefficients (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::tuple< raft::device_span< int32_t const >, raft::device_span< int32_t const > > vertex_pairs, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, rmm::device_uvector< float > > overlap_all_pairs_coefficients (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< raft::device_span< int32_t const > > vertices, std::optional< size_t > topk, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, rmm::device_uvector< double > > overlap_all_pairs_coefficients (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< raft::device_span< int32_t const > > vertices, std::optional< size_t > topk, bool do_expensive_check)

template rmm::device_uvector< float > overlap_coefficients (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::tuple< raft::device_span< int64_t const >, raft::device_span< int64_t const > > vertex_pairs, bool do_expensive_check)

template rmm::device_uvector< double > overlap_coefficients (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::tuple< raft::device_span< int64_t const >, raft::device_span< int64_t const > > vertex_pairs, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, rmm::device_uvector< float > > overlap_all_pairs_coefficients (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< raft::device_span< int64_t const > > vertices, std::optional< size_t > topk, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, rmm::device_uvector< double > > overlap_all_pairs_coefficients (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< raft::device_span< int64_t const > > vertices, std::optional< size_t > topk, bool do_expensive_check)

template rmm::device_uvector< float > sorensen_coefficients (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::tuple< raft::device_span< int32_t const >, raft::device_span< int32_t const > > vertex_pairs, bool do_expensive_check)

template rmm::device_uvector< double > sorensen_coefficients (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::tuple< raft::device_span< int32_t const >, raft::device_span< int32_t const > > vertex_pairs, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, rmm::device_uvector< float > > sorensen_all_pairs_coefficients (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< raft::device_span< int32_t const > > vertices, std::optional< size_t > topk, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, rmm::device_uvector< double > > sorensen_all_pairs_coefficients (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< raft::device_span< int32_t const > > vertices, std::optional< size_t > topk, bool do_expensive_check)

template rmm::device_uvector< float > sorensen_coefficients (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::tuple< raft::device_span< int64_t const >, raft::device_span< int64_t const > > vertex_pairs, bool do_expensive_check)

template rmm::device_uvector< double > sorensen_coefficients (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::tuple< raft::device_span< int64_t const >, raft::device_span< int64_t const > > vertex_pairs, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, rmm::device_uvector< float > > sorensen_all_pairs_coefficients (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< raft::device_span< int64_t const > > vertices, std::optional< size_t > topk, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, rmm::device_uvector< double > > sorensen_all_pairs_coefficients (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< raft::device_span< int64_t const > > vertices, std::optional< size_t > topk, bool do_expensive_check)

template rmm::device_uvector< float > sorensen_coefficients (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::tuple< raft::device_span< int32_t const >, raft::device_span< int32_t const > > vertex_pairs, bool do_expensive_check)

template rmm::device_uvector< double > sorensen_coefficients (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::tuple< raft::device_span< int32_t const >, raft::device_span< int32_t const > > vertex_pairs, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, rmm::device_uvector< float > > sorensen_all_pairs_coefficients (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< raft::device_span< int32_t const > > vertices, std::optional< size_t > topk, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, rmm::device_uvector< double > > sorensen_all_pairs_coefficients (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< raft::device_span< int32_t const > > vertices, std::optional< size_t > topk, bool do_expensive_check)

template rmm::device_uvector< float > sorensen_coefficients (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::tuple< raft::device_span< int64_t const >, raft::device_span< int64_t const > > vertex_pairs, bool do_expensive_check)

template rmm::device_uvector< double > sorensen_coefficients (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::tuple< raft::device_span< int64_t const >, raft::device_span< int64_t const > > vertex_pairs, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, rmm::device_uvector< float > > sorensen_all_pairs_coefficients (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< raft::device_span< int64_t const > > vertices, std::optional< size_t > topk, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, rmm::device_uvector< double > > sorensen_all_pairs_coefficients (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< raft::device_span< int64_t const > > vertices, std::optional< size_t > topk, bool do_expensive_check)

template<typename vertex_t, typename edge_id_t, typename edge_type_t, bool multi_gpu> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>> lookup_endpoints_from_edge_ids_and_single_type(raft::handle_t const &handle, lookup_container_t<edge_id_t, edge_type_t, vertex_t> const &search_container, raft::device_span<edge_id_t const> edge_ids_to_lookup, edge_type_t edge_type_to_lookup)#

template<typename vertex_t, typename edge_id_t, typename edge_type_t, bool multi_gpu> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>> lookup_endpoints_from_edge_ids_and_types(raft::handle_t const &handle, lookup_container_t<edge_id_t, edge_type_t, vertex_t> const &search_container, raft::device_span<edge_id_t const> edge_ids_to_lookup, raft::device_span<edge_type_t const> edge_types_to_lookup)#

template<typename vertex_t, typename edge_t, typename edge_type_t, bool multi_gpu> lookup_container_t<edge_t, edge_type_t, vertex_t> build_edge_id_and_type_to_src_dst_lookup_map(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, false, multi_gpu> const &graph_view, edge_property_view_t<edge_t, edge_t const*> edge_id_view, edge_property_view_t<edge_t, edge_type_t const*> edge_type_view)#

template lookup_container_t< int32_t, int32_t, int32_t > build_edge_id_and_type_to_src_dst_lookup_map (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, edge_property_view_t< int32_t, int32_t const * > edge_id_view, edge_property_view_t< int32_t, int32_t const * > edge_type_view)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t > > lookup_endpoints_from_edge_ids_and_single_type< int32_t, int32_t, int32_t, true > (raft::handle_t const &handle, lookup_container_t< int32_t, int32_t, int32_t > const &search_container, raft::device_span< int32_t const > edge_ids_to_lookup, int32_t edge_type_to_lookup)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t > > lookup_endpoints_from_edge_ids_and_types< int32_t, int32_t, int32_t, true > (raft::handle_t const &handle, lookup_container_t< int32_t, int32_t, int32_t > const &search_container, raft::device_span< int32_t const > edge_ids_to_lookup, raft::device_span< int32_t const > edge_types_to_lookup)

template lookup_container_t< int64_t, int32_t, int32_t > build_edge_id_and_type_to_src_dst_lookup_map (raft::handle_t const &handle, graph_view_t< int32_t, int64_t, false, true > const &graph_view, edge_property_view_t< int64_t, int64_t const * > edge_id_view, edge_property_view_t< int64_t, int32_t const * > edge_type_view)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t > > lookup_endpoints_from_edge_ids_and_single_type< int32_t, int64_t, int32_t, true > (raft::handle_t const &handle, lookup_container_t< int64_t, int32_t, int32_t > const &search_container, raft::device_span< int64_t const > edge_ids_to_lookup, int32_t edge_type_to_lookup)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t > > lookup_endpoints_from_edge_ids_and_types< int32_t, int64_t, int32_t, true > (raft::handle_t const &handle, lookup_container_t< int64_t, int32_t, int32_t > const &search_container, raft::device_span< int64_t const > edge_ids_to_lookup, raft::device_span< int32_t const > edge_types_to_lookup)

template lookup_container_t< int64_t, int32_t, int64_t > build_edge_id_and_type_to_src_dst_lookup_map (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, edge_property_view_t< int64_t, int64_t const * > edge_id_view, edge_property_view_t< int64_t, int32_t const * > edge_type_view)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t > > lookup_endpoints_from_edge_ids_and_single_type< int64_t, int64_t, int32_t, true > (raft::handle_t const &handle, lookup_container_t< int64_t, int32_t, int64_t > const &search_container, raft::device_span< int64_t const > edge_ids_to_lookup, int32_t edge_type_to_lookup)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t > > lookup_endpoints_from_edge_ids_and_types< int64_t, int64_t, int32_t, true > (raft::handle_t const &handle, lookup_container_t< int64_t, int32_t, int64_t > const &search_container, raft::device_span< int64_t const > edge_ids_to_lookup, raft::device_span< int32_t const > edge_types_to_lookup)

template lookup_container_t< int32_t, int32_t, int32_t > build_edge_id_and_type_to_src_dst_lookup_map (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, edge_property_view_t< int32_t, int32_t const * > edge_id_view, edge_property_view_t< int32_t, int32_t const * > edge_type_view)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t > > lookup_endpoints_from_edge_ids_and_single_type< int32_t, int32_t, int32_t, false > (raft::handle_t const &handle, lookup_container_t< int32_t, int32_t, int32_t > const &search_container, raft::device_span< int32_t const > edge_ids_to_lookup, int32_t const edge_type_to_lookup)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t > > lookup_endpoints_from_edge_ids_and_types< int32_t, int32_t, int32_t, false > (raft::handle_t const &handle, lookup_container_t< int32_t, int32_t, int32_t > const &search_container, raft::device_span< int32_t const > edge_ids_to_lookup, raft::device_span< int32_t const > edge_types_to_lookup)

template lookup_container_t< int64_t, int32_t, int32_t > build_edge_id_and_type_to_src_dst_lookup_map (raft::handle_t const &handle, graph_view_t< int32_t, int64_t, false, false > const &graph_view, edge_property_view_t< int64_t, int64_t const * > edge_id_view, edge_property_view_t< int64_t, int32_t const * > edge_type_view)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t > > lookup_endpoints_from_edge_ids_and_single_type< int32_t, int64_t, int32_t, false > (raft::handle_t const &handle, lookup_container_t< int64_t, int32_t, int32_t > const &search_container, raft::device_span< int64_t const > edge_ids_to_lookup, int32_t edge_type_to_lookup)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t > > lookup_endpoints_from_edge_ids_and_types< int32_t, int64_t, int32_t, false > (raft::handle_t const &handle, lookup_container_t< int64_t, int32_t, int32_t > const &search_container, raft::device_span< int64_t const > edge_ids_to_lookup, raft::device_span< int32_t const > edge_types_to_lookup)

template lookup_container_t< int64_t, int32_t, int64_t > build_edge_id_and_type_to_src_dst_lookup_map (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, edge_property_view_t< int64_t, int64_t const * > edge_id_view, edge_property_view_t< int64_t, int32_t const * > edge_type_view)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t > > lookup_endpoints_from_edge_ids_and_single_type< int64_t, int64_t, int32_t, false > (raft::handle_t const &handle, lookup_container_t< int64_t, int32_t, int64_t > const &search_container, raft::device_span< int64_t const > edge_ids_to_lookup, int32_t edge_type_to_lookup)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t > > lookup_endpoints_from_edge_ids_and_types< int64_t, int64_t, int32_t, false > (raft::handle_t const &handle, lookup_container_t< int64_t, int32_t, int64_t > const &search_container, raft::device_span< int64_t const > edge_ids_to_lookup, raft::device_span< int32_t const > edge_types_to_lookup)

template<typename GraphViewType, typename EdgeSrcValueInputWrapper, typename EdgeDstValueInputWrapper, typename EdgeValueInputWrapper, typename EdgeOp> GraphViewType::edge_type count_if_e(raft::handle_t const &handle, GraphViewType const &graph_view, EdgeSrcValueInputWrapper edge_src_value_input, EdgeDstValueInputWrapper edge_dst_value_input, EdgeValueInputWrapper edge_value_input, EdgeOp e_op, bool do_expensive_check = false)#

Count the number of edges that satisfies the given predicate.

This function is inspired by thrust::count_if().

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
EdgeSrcValueInputWrapper – Type of the wrapper for edge source property values.
EdgeDstValueInputWrapper – Type of the wrapper for edge destination property values.
EdgeValueInputWrapper – Type of the wrapper for edge property values.
EdgeOp – Type of the quinary edge operator.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
edge_src_value_input – Wrapper used to access source input property values (for the edge sources assigned to this process in multi-GPU). Use either cugraph::edge_src_property_t::view() (if e_op needs to access source property values) or cugraph::edge_src_dummy_property_t::view() (if e_op does not access source property values). Use update_edge_src_property to fill the wrapper.
edge_dst_value_input – Wrapper used to access destination input property values (for the edge destinations assigned to this process in multi-GPU). Use either cugraph::edge_dst_property_t::view() (if e_op needs to access destination property values) or cugraph::edge_dst_dummy_property_t::view() (if e_op does not access destination property values). Use update_edge_dst_property to fill the wrapper.
edge_value_input – Wrapper used to access edge input property values (for the edges assigned to this process in multi-GPU). Use either cugraph::edge_property_t::view() (if e_op needs to access edge property values) or cugraph::edge_dummy_property_t::view() (if e_op does not access edge property values).
e_op – Quinary operator takes edge source, edge destination, property values for the source, destination, and edge and returns true if this edge should be included in the returned count.
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

GraphViewType::edge_type Number of times e_op returned true.

template<typename GraphViewType, typename VertexValueInputIterator, typename VertexOp> GraphViewType::vertex_type count_if_v(raft::handle_t const &handle, GraphViewType const &graph_view, VertexValueInputIterator vertex_value_input_first, VertexOp v_op, bool do_expensive_check = false)#

Count the number of vertices that satisfies the given predicate.

This version iterates over the entire set of graph vertices. This function is inspired by thrust::count_if().

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
VertexValueInputIterator – Type of the iterator for vertex property values.
VertexOp – Type of the unary predicate operator.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
vertex_value_input_first – Iterator pointing to the vertex property values for the first (inclusive) vertex (assigned to this process in multi-GPU). vertex_value_input_last (exclusive) is deduced as vertex_value_input_first + graph_view.local_vertex_partition_range_size().
v_op – Binary operator takes vertex ID and *(vertex_value_input_first + i) (where i is [0, graph_view.local_vertex_partition_range_size())) and returns true if this vertex should be included in the returned count.
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

GraphViewType::vertex_type Number of times v_op returned true.

template<typename GraphViewType, typename EdgeSrcValueInputWrapper, typename EdgeDstValueInputWrapper, typename EdgeValueInputWrapper, typename EdgeOp> decltype(allocate_dataframe_buffer<typename detail::edge_op_result_type<typename GraphViewType::vertex_type, typename GraphViewType::vertex_type, typename EdgeSrcValueInputWrapper::value_type, typename EdgeDstValueInputWrapper::value_type, typename EdgeValueInputWrapper::value_type, EdgeOp>::type::value_type>(size_t{0}, rmm::cuda_stream_view{})) extract_transform_e(raft::handle_t const &handle, GraphViewType const &graph_view, EdgeSrcValueInputWrapper edge_src_value_input, EdgeDstValueInputWrapper edge_dst_value_input, EdgeValueInputWrapper edge_value_input, EdgeOp e_op, bool do_expensive_check = false)#

Iterate over the entire set of edges and extract the valid edge functor outputs.

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
EdgeSrcValueInputWrapper – Type of the wrapper for edge source property values.
EdgeDstValueInputWrapper – Type of the wrapper for edge destination property values.
EdgeValueInputWrapper – Type of the wrapper for edge property values.
EdgeOp – Type of the quinary edge operator.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
edge_src_value_input – Wrapper used to access source input property values (for the edge sources assigned to this process in multi-GPU). Use either cugraph::edge_src_property_t::view() (if e_op needs to access source property values) or cugraph::edge_src_dummy_property_t::view() (if e_op does not access source property values). Use update_edge_src_property to fill the wrapper.
edge_dst_value_input – Wrapper used to access destination input property values (for the edge destinations assigned to this process in multi-GPU). Use either cugraph::edge_dst_property_t::view() (if e_op needs to access destination property values) or cugraph::edge_dst_dummy_property_t::view() (if e_op does not access destination property values). Use update_edge_dst_property to fill the wrapper.
edge_value_input – Wrapper used to access edge input property values (for the edges assigned to this process in multi-GPU). Use either cugraph::edge_property_t::view() (if e_op needs to access edge property values) or cugraph::edge_dummy_property_t::view() (if e_op does not access edge property values).
e_op – Quinary operator takes edge source, edge destination, property values for the source, property values for the destination, and property values for the edge and returns thrust::nullopt (if the return value is to be discarded) or a valid e_op output to be extracted and accumulated.
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

Dataframe buffer object storing extracted and accumulated valid e_op return values.

template<typename GraphViewType, typename KeyBucketType, typename EdgeSrcValueInputWrapper, typename EdgeDstValueInputWrapper, typename EdgeValueInputWrapper, typename EdgeOp> decltype(allocate_dataframe_buffer<typename detail::edge_op_result_type<typename KeyBucketType::key_type, typename GraphViewType::vertex_type, typename EdgeSrcValueInputWrapper::value_type, typename EdgeDstValueInputWrapper::value_type, typename EdgeValueInputWrapper::value_type, EdgeOp>::type::value_type>(size_t{0}, rmm::cuda_stream_view{})) extract_transform_v_frontier_outgoing_e(raft::handle_t const &handle, GraphViewType const &graph_view, KeyBucketType const &frontier, EdgeSrcValueInputWrapper edge_src_value_input, EdgeDstValueInputWrapper edge_dst_value_input, EdgeValueInputWrapper edge_value_input, EdgeOp e_op, bool do_expensive_check = false)#

Iterate over outgoing_edges from the current vertex frontier and extract the valid edge functor outputs.

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
EdgeSrcValueInputWrapper – Type of the wrapper for edge source property values.
EdgeDstValueInputWrapper – Type of the wrapper for edge destination property values.
EdgeValueInputWrapper – Type of the wrapper for edge property values.
EdgeOp – Type of the quinary edge operator.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
edge_src_value_input – Wrapper used to access source input property values (for the edge sources assigned to this process in multi-GPU). Use either cugraph::edge_src_property_t::view() (if e_op needs to access source property values) or cugraph::edge_src_dummy_property_t::view() (if e_op does not access source property values). Use update_edge_src_property to fill the wrapper.
edge_dst_value_input – Wrapper used to access destination input property values (for the edge destinations assigned to this process in multi-GPU). Use either cugraph::edge_dst_property_t::view() (if e_op needs to access destination property values) or cugraph::edge_dst_dummy_property_t::view() (if e_op does not access destination property values). Use update_edge_dst_property to fill the wrapper.
edge_value_input – Wrapper used to access edge input property values (for the edges assigned to this process in multi-GPU). Use either cugraph::edge_property_t::view() (if e_op needs to access edge property values) or cugraph::edge_dummy_property_t::view() (if e_op does not access edge property values).
e_op – Quinary operator takes edge source, edge destination, property values for the source, property values for the destination, and property values for the edge and returns thrust::nullopt (if the return value is to be discarded) or a valid e_op output to be extracted and accumulated.
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

Dataframe buffer object storing extracted and accumulated valid e_op return values.

template<typename GraphViewType, typename EdgeValueOutputWrapper, typename T> void fill_edge_property(raft::handle_t const &handle, GraphViewType const &graph_view, EdgeValueOutputWrapper edge_property_output, T input, bool do_expensive_check = false)#

Fill graph edge property values to the input value.

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
EdgeValueOutputWrapper – Type of the wrapper for output edge property values.
T – Type of the edge property values.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
edge_property_output – edge_property_view_t class object to store edge property values (for the edges assigned to this process in multi-GPU).
input – Edge property values will be set to input.
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

template<typename GraphViewType, typename EdgeSrcValueOutputWrapper, typename T> void fill_edge_src_property(raft::handle_t const &handle, GraphViewType const &graph_view, EdgeSrcValueOutputWrapper edge_src_property_output, T input, bool do_expensive_check = false)#

Fill graph edge source property values to the input value.

This version fills graph edge source property values for the entire edge source ranges (assigned to this process in multi-GPU).

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
EdgeSrcValueOutputWrapper – Type of the wrapper for output edge source property values.
T – Type of the edge source property values.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
edge_src_property_output – edge_src_property_view_t class object to store source property values (for the edge source assigned to this process in multi-GPU).
input – Edge source property values will be set to input.
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

template<typename GraphViewType, typename VertexIterator, typename EdgeSrcValueOutputWrapper, typename T> void fill_edge_src_property(raft::handle_t const &handle, GraphViewType const &graph_view, VertexIterator sorted_unique_vertex_first, VertexIterator sorted_unique_vertex_last, EdgeSrcValueOutputWrapper edge_src_property_output, T input, bool do_expensive_check = false)#

Fill graph edge source property values to the input value.

This version fills only a subset of graph edge source property values. [sorted_unique_vertex_first, sorted_unique_vertex_last) specifies the vertices to be filled.

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
VertexIterator – Type of the iterator for vertex identifiers.
EdgeSrcValueOutputWrapper – Type of the wrapper for output edge source property values.
T – Type of the edge source property values.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
sorted_unique_vertex_first – Iterator pointing to the first (inclusive) vertex with a value to be filled. v in [vertex_first, sorted_unique_vertex_last) should be sorted & distinct (and should belong to the vertex partition assigned to this process in multi-GPU), otherwise undefined behavior.
sorted_unique_vertex_last – Iterator pointing to the last (exclusive) vertex with a value to be filled.
edge_src_property_output – edge_src_property_view_t class object to store source property values (for the edge source assigned to this process in multi-GPU).
input – Edge source property values will be set to input.
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

template<typename GraphViewType, typename EdgeDstValueOutputWrapper, typename T> void fill_edge_dst_property(raft::handle_t const &handle, GraphViewType const &graph_view, EdgeDstValueOutputWrapper edge_dst_property_output, T input, bool do_expensive_check = false)#

Fill graph edge destination property values to the input value.

This version fills graph edge destination property values for the entire edge destination ranges (assigned to this process in multi-GPU).

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
EdgeDstValueOutputWrapper – Type of the wrapper for output edge destination property values.
T – Type of the edge destination property values.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
edge_dst_property_output – edge_dst_property_view_t class object to store destination property values (for the edge destinations assigned to this process in multi-GPU).
input – Edge destination property values will be set to input.
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

template<typename GraphViewType, typename VertexIterator, typename EdgeDstValueOutputWrapper, typename T> void fill_edge_dst_property(raft::handle_t const &handle, GraphViewType const &graph_view, VertexIterator sorted_unique_vertex_first, VertexIterator sorted_unique_vertex_last, EdgeDstValueOutputWrapper edge_dst_property_output, T input, bool do_expensive_check = false)#

Fill graph edge destination property values to the input value.

This version fills only a subset of graph edge destination property values. [sorted_unique_vertex_first, sorted_unique_vertex_last) specifies the vertices to be filled.

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
VertexIterator – Type of the iterator for vertex identifiers.
EdgeDstValueOutputWrapper – Type of the wrapper for output edge destination property values.
T – Type of the edge destination property values.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
sorted_unique_vertex_first – Iterator pointing to the first (inclusive) vertex with a value to be filled. v in [sorted_unique_vertex_first, sorted_unique_vertex_last) should be sorted & distinct (and should belong to the vertex partition assigned to this process in multi-GPU), otherwise undefined behavior.
sorted_unique_vertex_last – Iterator pointing to the last (exclusive) vertex with a value to be filled.
edge_dst_property_output – edge_dst_property_view_t class object to store destination property values (for the edge destinations assigned to this process in multi-GPU).
input – Edge destination property values will be set to input.
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

template<typename GraphViewType, typename VertexPairIterator> std::tuple<rmm::device_uvector<size_t>, rmm::device_uvector<typename GraphViewType::vertex_type>> per_v_pair_dst_nbr_intersection(raft::handle_t const &handle, GraphViewType const &graph_view, VertexPairIterator vertex_pair_first, VertexPairIterator vertex_pair_last, bool do_expensive_check = false)#

Iterate over each input vertex pair and returns the common destination neighbor list pair in a CSR-like format.

Iterate over every vertex pair; intersect destination neighbor lists of the two vertices in the pair and store the result in a CSR-like format

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
VertexPairIterator – Type of the iterator for input vertex pairs.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
vertex_pair_first – Iterator pointing to the first (inclusive) input vertex pair.
vertex_pair_last – Iterator pointing to the last (exclusive) input vertex pair.
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

std::tuple Tuple of intersection offsets and indices.

template<typename GraphViewType, typename VertexPairIterator, typename VertexValueInputIterator, typename EdgeValueInputIterator, typename IntersectionOp, typename VertexPairValueOutputIterator> void per_v_pair_transform_dst_nbr_intersection(raft::handle_t const &handle, GraphViewType const &graph_view, EdgeValueInputIterator edge_value_input, VertexPairIterator vertex_pair_first, VertexPairIterator vertex_pair_last, VertexValueInputIterator vertex_value_input_first, IntersectionOp intersection_op, VertexPairValueOutputIterator vertex_pair_value_output_first, bool do_expensive_check = false)#

Iterate over each input vertex pair and apply a functor to the common destination neighbor list of the pair.

Iterate over every vertex pair; intersect destination neighbor lists of the two vertices in the pair; invoke a user-provided functor, and store the functor output.

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
VertexPairIterator – Type of the iterator for input vertex pairs.
VertexValueInputIterator – Type of the iterator for vertex property values.
EdgeValueInputIterator – Type of the iterator for edge property values.
IntersectionOp – Type of the quinary per intersection operator.
VertexPairValueOutputIterator – Type of the iterator for vertex pair output property variables.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
vertex_pair_first – Iterator pointing to the first (inclusive) input vertex pair.
vertex_pair_last – Iterator pointing to the last (exclusive) input vertex pair.
vertex_src_value_input – Wrapper used to access vertex input property values (for the vertices assigned to this process in multi-GPU).
edge_value_input – Wrapper used to access edge input property values (for the edges assigned to this process in multi-GPU). Use either cugraph::edge_property_t::view() (if intersection_op needs to access edge property values) or cugraph::edge_dummy_property_t::view() (if intersection_op does not access edge property values).
intersection_op – quinary operator takes first vertex of the pair, second vertex of the pair, property values for the first vertex, property values for the second vertex, and a list of vertices in the intersection of the first & second vertices’ destination neighbors and returns an output value for the input pair.
vertex_pair_value_output_first – Iterator pointing to the vertex pair property variables for the first vertex pair (inclusive). vertex_pair_value_output_last (exclusive) is deduced as vertex_pair_value_output_first + thrust::distance(vertex_pair_first, vertex_pair_last).
A – flag to run expensive checks for input arguments (if set to true).

template<typename GraphViewType, typename KeyBucketType, typename EdgeBiasSrcValueInputWrapper, typename EdgeBiasDstValueInputWrapper, typename EdgeBiasValueInputWrapper, typename EdgeBiasOp, typename EdgeSrcValueInputWrapper, typename EdgeDstValueInputWrapper, typename EdgeValueInputWrapper, typename EdgeOp, typename T> std::tuple<std::optional<rmm::device_uvector<size_t>>, decltype(allocate_dataframe_buffer<T>(size_t{0}, rmm::cuda_stream_view{}))> per_v_random_select_transform_outgoing_e(raft::handle_t const &handle, GraphViewType const &graph_view, KeyBucketType const &key_list, EdgeBiasSrcValueInputWrapper edge_bias_src_value_input, EdgeBiasDstValueInputWrapper edge_bias_dst_value_input, EdgeBiasValueInputWrapper edge_bias_value_input, EdgeBiasOp e_bias_op, EdgeSrcValueInputWrapper edge_src_value_input, EdgeDstValueInputWrapper edge_dst_value_input, EdgeValueInputWrapper edge_value_input, EdgeOp e_op, raft::random::RngState &rng_state, size_t K, bool with_replacement, std::optional<T> invalid_value, bool do_expensive_check = false)#

Randomly select and transform the input (tagged-)vertices’ outgoing edges with biases.

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
KeyBucketType – Type of the key bucket class which abstracts the current (tagged-)vertex list.
EdgeSrcValueInputWrapper – Type of the wrapper for edge source property values.
EdgeDstValueInputWrapper – Type of the wrapper for edge destination property values.
EdgeValueInputWrapper – Type of the wrapper for edge property values.
EdgeBiasOp – Type of the quinary edge operator to set-up selection bias values.
EdgeOp – Type of the quinary edge operator.
T – Type of the selected and transformed edge output values.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
key_list – KeyBucketType class object to store the (tagged-)vertex list to sample outgoing edges.
edge_src_value_input – Wrapper used to access source input property values (for the edge sources assigned to this process in multi-GPU). Use either cugraph::edge_src_property_t::view() (if e_op needs to access source property values) or cugraph::edge_src_dummy_property_t::view() (if e_op does not access source property values). Use update_edge_src_property to fill the wrapper.
edge_dst_value_input – Wrapper used to access destination input property values (for the edge destinations assigned to this process in multi-GPU). Use either cugraph::edge_dst_property_t::view() (if e_op needs to access destination property values) or cugraph::edge_dst_dummy_property_t::view() (if e_op does not access destination property values). Use update_edge_dst_property to fill the wrapper.
edge_value_input – Wrapper used to access edge input property values (for the edges assigned to this process in multi-GPU). Use either cugraph::edge_property_t::view() (if e_op needs to access edge property values) or cugraph::edge_dummy_property_t::view() (if e_op does not access edge property values).
e_bias_op – Quinary operator takes (tagged-)edge source, edge destination, property values for the source, destination, and edge and returns a floating point bias value to be used in biased random selection. The return value should be non-negative. The bias value of 0 indicates that the corresponding edge cannot be selected. Assuming that the return value type is bias_t, the sum of the bias values for any seed vertex should not exceed std::numeric_limits<bias_t>::max().
e_op – Quinary operator takes (tagged-)edge source, edge destination, property values for the source, destination, and edge and returns a value to be collected in the output. This function is called only for the selected edges.
K – Number of outgoing edges to select per (tagged-)vertex.
with_replacement – A flag to specify whether a single outgoing edge can be selected multiple times (if with_replacement = true) or can be selected only once (if with_replacement = false).
invalid_value – If invalid_value.has_value() is true, this value is used to fill the output vector for the zero out-degree vertices (if with_replacement = true) or the vertices with their out-degrees smaller than K (if with_replacement = false). If invalid_value.has_value() is false, fewer than K values can be returned for the vertices with fewer than K selected edges. See the return value section for additional details.
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

std::tuple Tuple of an optional offset vector of type std::optional<rmm::device_uvector<size_t>> and a dataframe buffer storing the output values of type T from the selected edges. If invalid_value is std::nullopt, the offset vector is valid and has the size of key_list.size() + 1. If invalid_value.has_value() is true, std::nullopt is returned (the dataframe buffer will store key_list.size() * K elements).

template<typename GraphViewType, typename KeyBucketType, typename EdgeSrcValueInputWrapper, typename EdgeDstValueInputWrapper, typename EdgeValueInputWrapper, typename EdgeOp, typename T> std::tuple<std::optional<rmm::device_uvector<size_t>>, decltype(allocate_dataframe_buffer<T>(size_t{0}, rmm::cuda_stream_view{}))> per_v_random_select_transform_outgoing_e(raft::handle_t const &handle, GraphViewType const &graph_view, KeyBucketType const &key_list, EdgeSrcValueInputWrapper edge_src_value_input, EdgeDstValueInputWrapper edge_dst_value_input, EdgeValueInputWrapper edge_value_input, EdgeOp e_op, raft::random::RngState &rng_state, size_t K, bool with_replacement, std::optional<T> invalid_value, bool do_expensive_check = false)#

Randomly select and transform the input (tagged-)vertices’ outgoing edges.

This function assumes that every outgoing edge of a given vertex has the same odd to be selected (uniform neighbor sampling).

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
KeyBucketType – Type of the key bucket class which abstracts the current (tagged-)vertex list.
EdgeSrcValueInputWrapper – Type of the wrapper for edge source property values.
EdgeDstValueInputWrapper – Type of the wrapper for edge destination property values.
EdgeValueInputWrapper – Type of the wrapper for edge property values.
EdgeOp – Type of the quinary edge operator.
T – Type of the selected and transformed edge output values.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
key_list – KeyBucketType class object to store the (tagged-)vertex list to sample outgoing edges.
edge_src_value_input – Wrapper used to access source input property values (for the edge sources assigned to this process in multi-GPU). Use either cugraph::edge_src_property_t::view() (if e_op needs to access source property values) or cugraph::edge_src_dummy_property_t::view() (if e_op does not access source property values). Use update_edge_src_property to fill the wrapper.
edge_dst_value_input – Wrapper used to access destination input property values (for the edge destinations assigned to this process in multi-GPU). Use either cugraph::edge_dst_property_t::view() (if e_op needs to access destination property values) or cugraph::edge_dst_dummy_property_t::view() (if e_op does not access destination property values). Use update_edge_dst_property to fill the wrapper.
edge_value_input – Wrapper used to access edge input property values (for the edges assigned to this process in multi-GPU). Use either cugraph::edge_property_t::view() (if e_op needs to access edge property values) or cugraph::edge_dummy_property_t::view() (if e_op does not access edge property values).
e_op – Quinary operator takes (tagged-)edge source, edge destination, property values for the source, destination, and edge and returns a value to be collected in the output. This function is called only for the selected edges.
K – Number of outgoing edges to select per (tagged-)vertex.
with_replacement – A flag to specify whether a single outgoing edge can be selected multiple times (if with_replacement = true) or can be selected only once (if with_replacement = false).
invalid_value – If invalid_value.has_value() is true, this value is used to fill the output vector for the zero out-degree vertices (if with_replacement = true) or the vertices with their out-degrees smaller than K (if with_replacement = false). If invalid_value.has_value() is false, fewer than K values can be returned for the vertices with fewer than K selected edges. See the return value section for additional details.
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

template<typename GraphViewType, typename EdgeSrcValueInputWrapper, typename EdgeValueInputWrapper, typename EdgeDstKeyInputWrapper, typename KVStoreViewType, typename KeyAggregatedEdgeOp, typename ReduceOp, typename T, typename VertexValueOutputIterator> void per_v_transform_reduce_dst_key_aggregated_outgoing_e(raft::handle_t const &handle, GraphViewType const &graph_view, EdgeSrcValueInputWrapper edge_src_value_input, EdgeValueInputWrapper edge_value_input, EdgeDstKeyInputWrapper edge_dst_key_input, KVStoreViewType kv_store_view, KeyAggregatedEdgeOp key_aggregated_e_op, T init, ReduceOp reduce_op, VertexValueOutputIterator vertex_value_output_first, bool do_expensive_check = false)#

Iterate over every vertex’s destination key-aggregated outgoing edges to update vertex property values.

This function is inspired by thrust::transform_reduce(). Unlike per_v_transform_reduce_outgoing_e, this function first aggregates outgoing edges by destination keys to support two level reduction for every vertex.

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
EdgeSrcValueInputWrapper – Type of the wrapper for edge source property values.
EdgeValueInputWrapper – Type of the wrapper for edge property values.
EdgeDstKeyInputWrapper – Type of the wrapper for edge destination key values.
KVStoreViewType – Type of the (key, value) store. Key type should coincide with vertex type.
KeyAggregatedEdgeOp – Type of the quinary key-aggregated edge operator.
ReduceOp – Type of the binary reduction operator.
T – Type of the initial value for per-vertex reduction.
VertexValueOutputIterator – Type of the iterator for vertex output property variables.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
edge_src_value_input – Wrapper used to access source input property values (for the edge sources assigned to this process in multi-GPU). Use either cugraph::edge_src_property_t::view() (if e_op needs to access source property values) or cugraph::edge_src_dummy_property_t::view() (if e_op does not access source property values). Use update_edge_src_property to fill the wrapper.
edge_value_input – Wrapper used to access edge input property values (for the edges assigned to this process in multi-GPU). Use either cugraph::edge_property_t::view() (if e_op needs to access edge property values) or cugraph::edge_dummy_property_t::view() (if e_op does not access edge property values).
edge_dst_key_input – Wrapper used to access destination input key values (for the edge destinations assigned to this process in multi-GPU). Use cugraph::edge_dst_property_t::view(). Use update_edge_dst_property to fill the wrapper.
kv_store_view – view object of the (key, value) store (for the keys assigned to this process in multi-GPU). cugraph::detail::compute_gpu_id_from_ext_vertex_t is used to map keys to processes). (Key, value) pairs may be provided by transform_reduce_e_by_src_key() or transform_reduce_e_by_dst_key().
key_aggregated_e_op – Quinary operator takes 1) edge source, 2) key, 3) *(edge_partition_src_value_input_first + i), 4) value for the key stored in the input (key, value) pairs provided by map_unique_key_first, map_unique_key_last, and map_value_first (aggregated over the entire set of processes in multi-GPU), and 5) aggregated edge value.
init – Initial value to be reduced with the reduced value for each vertex.
reduce_op – Binary operator that takes two input arguments and reduce the two values to one. There are pre-defined reduction operators in src/prims/reduce_op.cuh. It is recommended to use the pre-defined reduction operators whenever possible as the current (and future) implementations of graph primitives may check whether ReduceOp is a known type (or has known member variables) to take a more optimized code path. See the documentation in the reduce_op.cuh file for instructions on writing custom reduction operators.
vertex_value_output_first – Iterator pointing to the vertex property variables for the first (inclusive) vertex (assigned to this process in multi-GPU). vertex_value_output_last (exclusive) is deduced as vertex_value_output_first + graph_view.local_vertex_partition_range_size().
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

template<typename GraphViewType, typename EdgeSrcValueInputWrapper, typename EdgeDstValueInputWrapper, typename EdgeValueInputWrapper, typename EdgeOp, typename ReduceOp, typename PredOp, typename T, typename VertexValueOutputIterator> void per_v_transform_reduce_if_incoming_e(raft::handle_t const &handle, GraphViewType const &graph_view, EdgeSrcValueInputWrapper edge_src_value_input, EdgeDstValueInputWrapper edge_dst_value_input, EdgeValueInputWrapper edge_value_input, EdgeOp e_op, T init, ReduceOp reduce_op, PredOp pred_op, VertexValueOutputIterator vertex_value_output_first, bool do_expensive_check = false)#

Iterate over every vertex’s incoming edges to update vertex properties.

This function is inspired by thrust::transform_reduce. In addition, this function excludes the edges that return false when the predicate pred_op is applied.

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
EdgeSrcValueInputWrapper – Type of the wrapper for edge source property values.
EdgeDstValueInputWrapper – Type of the wrapper for edge destination property values.
EdgeValueInputWrapper – Type of the wrapper for edge property values.
EdgeOp – Type of the quinary edge operator.
ReduceOp – Type of the binary reduction operator.
PredOp – Type of the quinary predicate operator.
T – Type of the initial value for per-vertex reduction.
VertexValueOutputIterator – Type of the iterator for vertex output property variables.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
edge_src_value_input – Wrapper used to access source input property values (for the edge sources assigned to this process in multi-GPU). Use either cugraph::edge_src_property_t::view() (if e_op needs to access source property values) or cugraph::edge_src_dummy_property_t::view() (if e_op does not access source property values). Use update_edge_src_property to fill the wrapper.
edge_dst_value_input – Wrapper used to access destination input property values (for the edge destinations assigned to this process in multi-GPU). Use either cugraph::edge_dst_property_t::view() (if e_op needs to access destination property values) or cugraph::edge_dst_dummy_property_t::view() (if e_op does not access destination property values). Use update_edge_dst_property to fill the wrapper.
edge_value_input – Wrapper used to access edge input property values (for the edges assigned to this process in multi-GPU). Use either cugraph::edge_property_t::view() (if e_op needs to access edge property values) or cugraph::edge_dummy_property_t::view() (if e_op does not access edge property values).
e_op – Quinary operator takes edge source, edge destination, property values for the source, destination, and edge and returns a value to be reduced.
init – Initial value to be added to the reduced e_op return values for each vertex. If reduce_op is cugraph::reduce_op::any, init value is never selected except for the (tagged-)vertices with 0 outgoing edges.
reduce_op – Binary operator that takes two input arguments and reduce the two values to one. There are pre-defined reduction operators in src/prims/reduce_op.cuh. It is recommended to use the pre-defined reduction operators whenever possible as the current (and future) implementations of graph primitives may check whether ReduceOp is a known type (or has known member variables) to take a more optimized code path. See the documentation in the reduce_op.cuh file for instructions on writing custom reduction operators.
pred_op – Quinary operator takes edge source, edge destination, property values for the source, destination, and edge and returns whether this edge should be included (if true is returned) or excluded.
vertex_value_output_first – Iterator pointing to the vertex property variables for the first (inclusive) vertex (assigned to this process in multi-GPU). vertex_value_output_last (exclusive) is deduced as vertex_value_output_first + graph_view.local_vertex_partition_range_size().
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

template<typename GraphViewType, typename KeyBucketType, typename EdgeSrcValueInputWrapper, typename EdgeDstValueInputWrapper, typename EdgeValueInputWrapper, typename EdgeOp, typename ReduceOp, typename PredOp, typename T, typename VertexValueOutputIterator> void per_v_transform_reduce_if_incoming_e(raft::handle_t const &handle, GraphViewType const &graph_view, KeyBucketType const &key_list, EdgeSrcValueInputWrapper edge_src_value_input, EdgeDstValueInputWrapper edge_dst_value_input, EdgeValueInputWrapper edge_value_input, EdgeOp e_op, T init, ReduceOp reduce_op, PredOp pred_op, VertexValueOutputIterator vertex_value_output_first, bool do_expensive_check = false)#

For each (tagged-)vertex in the input (tagged-)vertex list, iterate over the incoming edges to update (tagged-)vertex properties.

This function is inspired by thrust::transform_reduce(). In addition, this function excludes the edges that return false when the predicate pred_op is applied.

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
KeyBucketType – Type of the key bucket class which abstracts the current (tagged-)vertex list.
EdgeSrcValueInputWrapper – Type of the wrapper for edge source property values.
EdgeDstValueInputWrapper – Type of the wrapper for edge destination property values.
EdgeValueInputWrapper – Type of the wrapper for edge property values.
EdgeOp – Type of the quinary edge operator.
ReduceOp – Type of the binary reduction operator.
PredOp – Type of the quinary predicate operator.
T – Type of the initial value for per-vertex reduction.
VertexValueOutputIterator – Type of the iterator for vertex output property variables.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
key_list – KeyBucketType class object to store the (tagged-)vertex list to update (tagged-)vertex properties.
edge_src_value_input – Wrapper used to access source input property values (for the edge sources assigned to this process in multi-GPU). Use either cugraph::edge_src_property_t::view() (if e_op needs to access source property values) or cugraph::edge_src_dummy_property_t::view() (if e_op does not access source property values). Use update_edge_src_property to fill the wrapper.
edge_dst_value_input – Wrapper used to access destination input property values (for the edge destinations assigned to this process in multi-GPU). Use either cugraph::edge_dst_property_t::view() (if e_op needs to access destination property values) or cugraph::edge_dst_dummy_property_t::view() (if e_op does not access destination property values). Use update_edge_dst_property to fill the wrapper.
edge_value_input – Wrapper used to access edge input property values (for the edges assigned to this process in multi-GPU). Use either cugraph::edge_property_t::view() (if e_op needs to access edge property values) or cugraph::edge_dummy_property_t::view() (if e_op does not access edge property values).
e_op – Quinary operator takes edge source, edge destination, property values for the source, destination, and edge and returns a value to be reduced.
init – Initial value to be reduced with the reduced e_op return values for each vertex. If reduce_op is cugraph::reduce_op::any, init value is never selected except for the (tagged-)vertices with 0 incoming edges.
reduce_op – Binary operator that takes two input arguments and reduce the two values to one. There are pre-defined reduction operators in src/prims/reduce_op.cuh. It is recommended to use the pre-defined reduction operators whenever possible as the current (and future) implementations of graph primitives may check whether ReduceOp is a known type (or has known member variables) to take a more optimized code path. See the documentation in the reduce_op.cuh file for instructions on writing custom reduction operators.
pred_op – Quinary operator takes edge source, edge destination, property values for the source, destination, and edge and returns whether this edge should be included (if true is returned) or excluded.
vertex_value_output_first – Iterator pointing to the (tagged-)vertex property variables for the first (inclusive) (tagged-)vertex in key_list. vertex_value_output_last (exclusive) is deduced as vertex_value_output_first + key_list.size().
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

template<typename GraphViewType, typename EdgeSrcValueInputWrapper, typename EdgeDstValueInputWrapper, typename EdgeValueInputWrapper, typename EdgeOp, typename ReduceOp, typename PredOp, typename T, typename VertexValueOutputIterator> void per_v_transform_reduce_if_outgoing_e(raft::handle_t const &handle, GraphViewType const &graph_view, EdgeSrcValueInputWrapper edge_src_value_input, EdgeDstValueInputWrapper edge_dst_value_input, EdgeValueInputWrapper edge_value_input, EdgeOp e_op, T init, ReduceOp reduce_op, PredOp pred_op, VertexValueOutputIterator vertex_value_output_first, bool do_expensive_check = false)#

Iterate over every vertex’s outgoing edges to update vertex properties.

This function is inspired by thrust::transform_reduce(). In addition, this function excludes the edges that return false when the predicate pred_op is applied.

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
EdgeSrcValueInputWrapper – Type of the wrapper for edge source property values.
EdgeDstValueInputWrapper – Type of the wrapper for edge destination property values.
EdgeValueInputWrapper – Type of the wrapper for edge property values.
EdgeOp – Type of the quinary edge operator.
ReduceOp – Type of the binary reduction operator.
PredOp – Type of the quinary predicate operator.
T – Type of the initial value for per-vertex reduction.
VertexValueOutputIterator – Type of the iterator for vertex output property variables.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
edge_src_value_input – Wrapper used to access source input property values (for the edge sources assigned to this process in multi-GPU). Use either cugraph::edge_src_property_t::view() (if e_op needs to access source property values) or cugraph::edge_src_dummy_property_t::view() (if e_op does not access source property values). Use update_edge_src_property to fill the wrapper.
edge_dst_value_input – Wrapper used to access destination input property values (for the edge destinations assigned to this process in multi-GPU). Use either cugraph::edge_dst_property_t::view() (if e_op needs to access destination property values) or cugraph::edge_dst_dummy_property_t::view() (if e_op does not access destination property values). Use update_edge_dst_property to fill the wrapper.
edge_value_input – Wrapper used to access edge input property values (for the edges assigned to this process in multi-GPU). Use either cugraph::edge_property_t::view() (if e_op needs to access edge property values) or cugraph::edge_dummy_property_t::view() (if e_op does not access edge property values).
e_op – Quinary operator takes edge source, edge destination, property values for the source, destination, and edge and returns a value to be reduced.
init – Initial value to be added to the reduced e_op return values for each vertex. If reduce_op is cugraph::reduce_op::any, init value is never selected except for the (tagged-)vertices with 0 outgoing edges.
reduce_op – Binary operator that takes two input arguments and reduce the two values to one. There are pre-defined reduction operators in src/prims/reduce_op.cuh. It is recommended to use the pre-defined reduction operators whenever possible as the current (and future) implementations of graph primitives may check whether ReduceOp is a known type (or has known member variables) to take a more optimized code path. See the documentation in the reduce_op.cuh file for instructions on writing custom reduction operators.
pred_op – Quinary operator takes edge source, edge destination, property values for the source, destination, and edge and returns whether this edge should be included (if true is returned) or excluded.
vertex_value_output_first – Iterator pointing to the vertex property variables for the first (inclusive) vertex (assigned to this process in multi-GPU). vertex_value_output_last (exclusive) is deduced as vertex_value_output_first + graph_view.local_vertex_partition_range_size().
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

template<typename GraphViewType, typename KeyBucketType, typename EdgeSrcValueInputWrapper, typename EdgeDstValueInputWrapper, typename EdgeValueInputWrapper, typename EdgeOp, typename ReduceOp, typename PredOp, typename T, typename VertexValueOutputIterator> void per_v_transform_reduce_if_outgoing_e(raft::handle_t const &handle, GraphViewType const &graph_view, KeyBucketType const &key_list, EdgeSrcValueInputWrapper edge_src_value_input, EdgeDstValueInputWrapper edge_dst_value_input, EdgeValueInputWrapper edge_value_input, EdgeOp e_op, T init, ReduceOp reduce_op, PredOp pred_op, VertexValueOutputIterator vertex_value_output_first, bool do_expensive_check = false)#

For each (tagged-)vertex in the input (tagged-)vertex list, iterate over the outgoing edges to update (tagged-)vertex properties.

This function is inspired by thrust::transform_reduce(). In addition, this function excludes the edges that return false when the predicate pred_op is applied.

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
KeyBucketType – Type of the key bucket class which abstracts the current (tagged-)vertex list.
EdgeSrcValueInputWrapper – Type of the wrapper for edge source property values.
EdgeDstValueInputWrapper – Type of the wrapper for edge destination property values.
EdgeValueInputWrapper – Type of the wrapper for edge property values.
EdgeOp – Type of the quinary edge operator.
ReduceOp – Type of the binary reduction operator.
PredOp – Type of the quinary predicate operator.
T – Type of the initial value for per-vertex reduction.
VertexValueOutputIterator – Type of the iterator for vertex output property variables.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
key_list – KeyBucketType class object to store the (tagged-)vertex list to update (tagged-)vertex properties.
edge_src_value_input – Wrapper used to access source input property values (for the edge sources assigned to this process in multi-GPU). Use either cugraph::edge_src_property_t::view() (if e_op needs to access source property values) or cugraph::edge_src_dummy_property_t::view() (if e_op does not access source property values). Use update_edge_src_property to fill the wrapper.
edge_dst_value_input – Wrapper used to access destination input property values (for the edge destinations assigned to this process in multi-GPU). Use either cugraph::edge_dst_property_t::view() (if e_op needs to access destination property values) or cugraph::edge_dst_dummy_property_t::view() (if e_op does not access destination property values). Use update_edge_dst_property to fill the wrapper.
edge_value_input – Wrapper used to access edge input property values (for the edges assigned to this process in multi-GPU). Use either cugraph::edge_property_t::view() (if e_op needs to access edge property values) or cugraph::edge_dummy_property_t::view() (if e_op does not access edge property values).
e_op – Quinary operator takes edge source, edge destination, property values for the source, destination, and edge and returns a value to be reduced.
init – Initial value to be reduced with the reduced e_op return values for each vertex. If reduce_op is cugraph::reduce_op::any, init value is never selected except for the (tagged-)vertices with 0 outgoing edges.
reduce_op – Binary operator that takes two input arguments and reduce the two values to one. There are pre-defined reduction operators in src/prims/reduce_op.cuh. It is recommended to use the pre-defined reduction operators whenever possible as the current (and future) implementations of graph primitives may check whether ReduceOp is a known type (or has known member variables) to take a more optimized code path. See the documentation in the reduce_op.cuh file for instructions on writing custom reduction operators.
pred_op – Quinary operator takes edge source, edge destination, property values for the source, destination, and edge and returns whether this edge should be included (if true is returned) or excluded.
vertex_value_output_first – Iterator pointing to the (tagged-)vertex property variables for the first (inclusive) (tagged-)vertex in key_list. vertex_value_output_last (exclusive) is deduced as vertex_value_output_first + key_list.size().
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

template<typename GraphViewType, typename EdgeSrcValueInputWrapper, typename EdgeDstValueInputWrapper, typename EdgeValueInputWrapper, typename EdgeOp, typename ReduceOp, typename T, typename VertexValueOutputIterator> void per_v_transform_reduce_incoming_e(raft::handle_t const &handle, GraphViewType const &graph_view, EdgeSrcValueInputWrapper edge_src_value_input, EdgeDstValueInputWrapper edge_dst_value_input, EdgeValueInputWrapper edge_value_input, EdgeOp e_op, T init, ReduceOp reduce_op, VertexValueOutputIterator vertex_value_output_first, bool do_expensive_check = false)#

Iterate over every vertex’s incoming edges to update vertex properties.

This function is inspired by thrust::transform_reduce.

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
EdgeSrcValueInputWrapper – Type of the wrapper for edge source property values.
EdgeDstValueInputWrapper – Type of the wrapper for edge destination property values.
EdgeValueInputWrapper – Type of the wrapper for edge property values.
EdgeOp – Type of the quinary edge operator.
ReduceOp – Type of the binary reduction operator.
T – Type of the initial value for per-vertex reduction.
VertexValueOutputIterator – Type of the iterator for vertex output property variables.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
edge_src_value_input – Wrapper used to access source input property values (for the edge sources assigned to this process in multi-GPU). Use either cugraph::edge_src_property_t::view() (if e_op needs to access source property values) or cugraph::edge_src_dummy_property_t::view() (if e_op does not access source property values). Use update_edge_src_property to fill the wrapper.
edge_dst_value_input – Wrapper used to access destination input property values (for the edge destinations assigned to this process in multi-GPU). Use either cugraph::edge_dst_property_t::view() (if e_op needs to access destination property values) or cugraph::edge_dst_dummy_property_t::view() (if e_op does not access destination property values). Use update_edge_dst_property to fill the wrapper.
edge_value_input – Wrapper used to access edge input property values (for the edges assigned to this process in multi-GPU). Use either cugraph::edge_property_t::view() (if e_op needs to access edge property values) or cugraph::edge_dummy_property_t::view() (if e_op does not access edge property values).
e_op – Quinary operator takes edge source, edge destination, property values for the source, destination, and edge and returns a value to be reduced.
init – Initial value to be added to the reduced e_op return values for each vertex. If reduce_op is cugraph::reduce_op::any, init value is never selected except for the (tagged-)vertices with 0 outgoing edges.
reduce_op – Binary operator that takes two input arguments and reduce the two values to one. There are pre-defined reduction operators in src/prims/reduce_op.cuh. It is recommended to use the pre-defined reduction operators whenever possible as the current (and future) implementations of graph primitives may check whether ReduceOp is a known type (or has known member variables) to take a more optimized code path. See the documentation in the reduce_op.cuh file for instructions on writing custom reduction operators.
vertex_value_output_first – Iterator pointing to the vertex property variables for the first (inclusive) vertex (assigned to this process in multi-GPU). vertex_value_output_last (exclusive) is deduced as vertex_value_output_first + graph_view.local_vertex_partition_range_size().
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

template<typename GraphViewType, typename KeyBucketType, typename EdgeSrcValueInputWrapper, typename EdgeDstValueInputWrapper, typename EdgeValueInputWrapper, typename EdgeOp, typename ReduceOp, typename T, typename VertexValueOutputIterator> void per_v_transform_reduce_incoming_e(raft::handle_t const &handle, GraphViewType const &graph_view, KeyBucketType const &key_list, EdgeSrcValueInputWrapper edge_src_value_input, EdgeDstValueInputWrapper edge_dst_value_input, EdgeValueInputWrapper edge_value_input, EdgeOp e_op, T init, ReduceOp reduce_op, VertexValueOutputIterator vertex_value_output_first, bool do_expensive_check = false)#

For each (tagged-)vertex in the input (tagged-)vertex list, iterate over the incoming edges to update (tagged-)vertex properties.

This function is inspired by thrust::transform_reduce().

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
KeyBucketType – Type of the key bucket class which abstracts the current (tagged-)vertex list.
EdgeSrcValueInputWrapper – Type of the wrapper for edge source property values.
EdgeDstValueInputWrapper – Type of the wrapper for edge destination property values.
EdgeValueInputWrapper – Type of the wrapper for edge property values.
EdgeOp – Type of the quinary edge operator.
ReduceOp – Type of the binary reduction operator.
T – Type of the initial value for per-vertex reduction.
VertexValueOutputIterator – Type of the iterator for vertex output property variables.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
key_list – KeyBucketType class object to store the (tagged-)vertex list to update (tagged-)vertex properties.
edge_src_value_input – Wrapper used to access source input property values (for the edge sources assigned to this process in multi-GPU). Use either cugraph::edge_src_property_t::view() (if e_op needs to access source property values) or cugraph::edge_src_dummy_property_t::view() (if e_op does not access source property values). Use update_edge_src_property to fill the wrapper.
edge_dst_value_input – Wrapper used to access destination input property values (for the edge destinations assigned to this process in multi-GPU). Use either cugraph::edge_dst_property_t::view() (if e_op needs to access destination property values) or cugraph::edge_dst_dummy_property_t::view() (if e_op does not access destination property values). Use update_edge_dst_property to fill the wrapper.
edge_value_input – Wrapper used to access edge input property values (for the edges assigned to this process in multi-GPU). Use either cugraph::edge_property_t::view() (if e_op needs to access edge property values) or cugraph::edge_dummy_property_t::view() (if e_op does not access edge property values).
e_op – Quinary operator takes edge source, edge destination, property values for the source, destination, and edge and returns a value to be reduced.
init – Initial value to be reduced with the reduced e_op return values for each vertex. If reduce_op is cugraph::reduce_op::any, init value is never selected except for the (tagged-)vertices with 0 incoming edges.
reduce_op – Binary operator that takes two input arguments and reduce the two values to one. There are pre-defined reduction operators in src/prims/reduce_op.cuh. It is recommended to use the pre-defined reduction operators whenever possible as the current (and future) implementations of graph primitives may check whether ReduceOp is a known type (or has known member variables) to take a more optimized code path. See the documentation in the reduce_op.cuh file for instructions on writing custom reduction operators.
vertex_value_output_first – Iterator pointing to the (tagged-)vertex property variables for the first (inclusive) (tagged-)vertex in key_list. vertex_value_output_last (exclusive) is deduced as vertex_value_output_first + key_list.size().
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

template<typename GraphViewType, typename EdgeSrcValueInputWrapper, typename EdgeDstValueInputWrapper, typename EdgeValueInputWrapper, typename EdgeOp, typename ReduceOp, typename T, typename VertexValueOutputIterator> void per_v_transform_reduce_outgoing_e(raft::handle_t const &handle, GraphViewType const &graph_view, EdgeSrcValueInputWrapper edge_src_value_input, EdgeDstValueInputWrapper edge_dst_value_input, EdgeValueInputWrapper edge_value_input, EdgeOp e_op, T init, ReduceOp reduce_op, VertexValueOutputIterator vertex_value_output_first, bool do_expensive_check = false)#

Iterate over every vertex’s outgoing edges to update vertex properties.

This function is inspired by thrust::transform_reduce().

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
EdgeSrcValueInputWrapper – Type of the wrapper for edge source property values.
EdgeDstValueInputWrapper – Type of the wrapper for edge destination property values.
EdgeValueInputWrapper – Type of the wrapper for edge property values.
EdgeOp – Type of the quinary edge operator.
ReduceOp – Type of the binary reduction operator.
T – Type of the initial value for per-vertex reduction.
VertexValueOutputIterator – Type of the iterator for vertex output property variables.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
edge_src_value_input – Wrapper used to access source input property values (for the edge sources assigned to this process in multi-GPU). Use either cugraph::edge_src_property_t::view() (if e_op needs to access source property values) or cugraph::edge_src_dummy_property_t::view() (if e_op does not access source property values). Use update_edge_src_property to fill the wrapper.
edge_dst_value_input – Wrapper used to access destination input property values (for the edge destinations assigned to this process in multi-GPU). Use either cugraph::edge_dst_property_t::view() (if e_op needs to access destination property values) or cugraph::edge_dst_dummy_property_t::view() (if e_op does not access destination property values). Use update_edge_dst_property to fill the wrapper.
edge_value_input – Wrapper used to access edge input property values (for the edges assigned to this process in multi-GPU). Use either cugraph::edge_property_t::view() (if e_op needs to access edge property values) or cugraph::edge_dummy_property_t::view() (if e_op does not access edge property values).
e_op – Quinary operator takes edge source, edge destination, property values for the source, destination, and edge and returns a value to be reduced.
init – Initial value to be added to the reduced e_op return values for each vertex. If reduce_op is cugraph::reduce_op::any, init value is never selected except for the (tagged-)vertices with 0 outgoing edges.
reduce_op – Binary operator that takes two input arguments and reduce the two values to one. There are pre-defined reduction operators in src/prims/reduce_op.cuh. It is recommended to use the pre-defined reduction operators whenever possible as the current (and future) implementations of graph primitives may check whether ReduceOp is a known type (or has known member variables) to take a more optimized code path. See the documentation in the reduce_op.cuh file for instructions on writing custom reduction operators.
vertex_value_output_first – Iterator pointing to the vertex property variables for the first (inclusive) vertex (assigned to this process in multi-GPU). vertex_value_output_last (exclusive) is deduced as vertex_value_output_first + graph_view.local_vertex_partition_range_size().
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

template<typename GraphViewType, typename KeyBucketType, typename EdgeSrcValueInputWrapper, typename EdgeDstValueInputWrapper, typename EdgeValueInputWrapper, typename EdgeOp, typename ReduceOp, typename T, typename VertexValueOutputIterator> void per_v_transform_reduce_outgoing_e(raft::handle_t const &handle, GraphViewType const &graph_view, KeyBucketType const &key_list, EdgeSrcValueInputWrapper edge_src_value_input, EdgeDstValueInputWrapper edge_dst_value_input, EdgeValueInputWrapper edge_value_input, EdgeOp e_op, T init, ReduceOp reduce_op, VertexValueOutputIterator vertex_value_output_first, bool do_expensive_check = false)#

For each (tagged-)vertex in the input (tagged-)vertex list, iterate over the outgoing edges to update (tagged-)vertex properties.

This function is inspired by thrust::transform_reduce().

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
KeyBucketType – Type of the key bucket class which abstracts the current (tagged-)vertex list.
EdgeSrcValueInputWrapper – Type of the wrapper for edge source property values.
EdgeDstValueInputWrapper – Type of the wrapper for edge destination property values.
EdgeValueInputWrapper – Type of the wrapper for edge property values.
EdgeOp – Type of the quinary edge operator.
ReduceOp – Type of the binary reduction operator.
T – Type of the initial value for per-vertex reduction.
VertexValueOutputIterator – Type of the iterator for vertex output property variables.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
key_list – KeyBucketType class object to store the (tagged-)vertex list to update (tagged-)vertex properties.
edge_src_value_input – Wrapper used to access source input property values (for the edge sources assigned to this process in multi-GPU). Use either cugraph::edge_src_property_t::view() (if e_op needs to access source property values) or cugraph::edge_src_dummy_property_t::view() (if e_op does not access source property values). Use update_edge_src_property to fill the wrapper.
edge_dst_value_input – Wrapper used to access destination input property values (for the edge destinations assigned to this process in multi-GPU). Use either cugraph::edge_dst_property_t::view() (if e_op needs to access destination property values) or cugraph::edge_dst_dummy_property_t::view() (if e_op does not access destination property values). Use update_edge_dst_property to fill the wrapper.
edge_value_input – Wrapper used to access edge input property values (for the edges assigned to this process in multi-GPU). Use either cugraph::edge_property_t::view() (if e_op needs to access edge property values) or cugraph::edge_dummy_property_t::view() (if e_op does not access edge property values).
e_op – Quinary operator takes edge source, edge destination, property values for the source, destination, and edge and returns a value to be reduced.
init – Initial value to be reduced with the reduced e_op return values for each vertex. If reduce_op is cugraph::reduce_op::any, init value is never selected except for the (tagged-)vertices with 0 outgoing edges.
reduce_op – Binary operator that takes two input arguments and reduce the two values to one. There are pre-defined reduction operators in src/prims/reduce_op.cuh. It is recommended to use the pre-defined reduction operators whenever possible as the current (and future) implementations of graph primitives may check whether ReduceOp is a known type (or has known member variables) to take a more optimized code path. See the documentation in the reduce_op.cuh file for instructions on writing custom reduction operators.
vertex_value_output_first – Iterator pointing to the (tagged-)vertex property variables for the first (inclusive) (tagged-)vertex in key_list. vertex_value_output_last (exclusive) is deduced as vertex_value_output_first + key_list.size().
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

template<typename T> std::enable_if_t<is_thrust_tuple_of_arithmetic<T>::value, T> min_identity_element()#

template<typename T> std::enable_if_t<std::is_arithmetic<T>::value, T> min_identity_element()#

template<typename T> std::enable_if_t<is_thrust_tuple_of_arithmetic<T>::value, T> max_identity_element()#

template<typename T> std::enable_if_t<std::is_arithmetic<T>::value, T> max_identity_element()#

template<typename GraphViewType, typename ReduceOp, typename VertexValueInputIterator, typename T> T reduce_v(raft::handle_t const &handle, GraphViewType const &graph_view, VertexValueInputIterator vertex_value_input_first, T init, ReduceOp reduce_op, bool do_expensive_check = false)#

Reduce the input vertex property values.

This function is inspired by thrust::reduce().

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
ReduceOp – Type of the binary reduction operator.
VertexValueInputIterator – Type of the iterator for vertex property values.
T – Type of the initial value. T should be an arithmetic type or thrust::tuple of arithmetic types.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
vertex_value_input_first – Iterator pointing to the vertex property values for the first (inclusive) vertex (assigned to this process in multi-GPU). vertex_value_input_last (exclusive) is deduced as vertex_value_input_first + graph_view.local_vertex_partition_range_size().
init – Initial value to be reduced with the reduced input vertex property values.
reduce_op – Binary operator that takes two input arguments and reduce the two values to one. There are pre-defined reduction operators in include/cugraph/prims/reduce_op.cuh. It is recommended to use the pre-defined reduction operators whenever possible as the current (and future) implementations of graph primitives may check whether ReduceOp is a known type (or has known member variables) to take a more optimized code path. See the documentation in the reduce_op.cuh file for instructions on writing custom reduction operators.
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

T Reduced input vertex property values.

template<typename GraphViewType, typename VertexValueInputIterator, typename T> T reduce_v(raft::handle_t const &handle, GraphViewType const &graph_view, VertexValueInputIterator vertex_value_input_first, T init, bool do_expensive_check = false)#

Reduce the input vertex property values.

This function is inspired by thrust::reduce().

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
ReduceOp – Type of the binary reduction operator.
VertexValueInputIterator – Type of the iterator for vertex property values.
T – Type of the initial value. T should be an arithmetic type or thrust::tuple of arithmetic types.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
vertex_value_input_first – Iterator pointing to the vertex property values for the first (inclusive) vertex (assigned to this process in multi-GPU). vertex_value_input_last (exclusive) is deduced as vertex_value_input_first + graph_view.local_vertex_partition_range_size().
init – Initial value to be added to the reduced input vertex property values.
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

T Reduced input vertex property values.

template<typename GraphViewType, typename VertexValueInputIterator> auto reduce_v(raft::handle_t const &handle, GraphViewType const &graph_view, VertexValueInputIterator vertex_value_input_first, bool do_expensive_check = false)#

Reduce the input vertex property values.

This function is inspired by thrust::reduce().

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
VertexValueInputIterator – Type of the iterator for vertex property values.
T – Type of the initial value. T should be an arithmetic type or thrust::tuple of arithmetic types.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
vertex_value_input_first – Iterator pointing to the vertex property values for the first (inclusive) vertex (assigned to this process in multi-GPU). vertex_value_input_last (exclusive) is deduced as vertex_value_input_first + graph_view.local_vertex_partition_range_size().
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

Reduced input vertex property values.

template<typename GraphViewType, typename EdgeSrcValueInputWrapper, typename EdgeDstValueInputWrapper, typename EdgeValueInputWrapper, typename EdgeOp, typename EdgeValueOutputWrapper> void transform_e(raft::handle_t const &handle, GraphViewType const &graph_view, EdgeSrcValueInputWrapper edge_src_value_input, EdgeDstValueInputWrapper edge_dst_value_input, EdgeValueInputWrapper edge_value_input, EdgeOp e_op, EdgeValueOutputWrapper edge_value_output, bool do_expensive_check = false)#

Iterate over the entire set of edges and update edge property values.

This function is inspired by thrust::transform().

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
EdgeSrcValueInputWrapper – Type of the wrapper for input edge source property values.
EdgeDstValueInputWrapper – Type of the wrapper for input edge destination property values.
EdgeValueInputWrapper – Type of the wrapper for input edge property values.
EdgeOp – Type of the quinary edge operator.
EdgeValueOutputWrapper – Type of the wrapper for output edge property values.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
edge_src_value_input – Wrapper used to access source input property values (for the edge sources assigned to this process in multi-GPU). Use either cugraph::edge_src_property_t::view() (if e_op needs to access source property values) or cugraph::edge_src_dummy_property_t::view() (if e_op does not access source property values). Use update_edge_src_property to fill the wrapper.
edge_dst_value_input – Wrapper used to access destination input property values (for the edge destinations assigned to this process in multi-GPU). Use either cugraph::edge_dst_property_t::view() (if e_op needs to access destination property values) or cugraph::edge_dst_dummy_property_t::view() (if e_op does not access destination property values). Use update_edge_dst_property to fill the wrapper.
edge_value_input – Wrapper used to access edge input property values (for the edges assigned to this process in multi-GPU). Use either cugraph::edge_property_t::view() (if e_op needs to access edge property values) or cugraph::edge_dummy_property_t::view() (if e_op does not access edge property values).
e_op – Quinary operator takes edge source, edge destination, property values for the source, destination, and edge and returns a value to be reduced.
edge_value_output – Wrapper used to store edge output property values (for the edges assigned to this process in multi-GPU). Use cugraph::edge_property_t::mutable_view().
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

template<typename GraphViewType, typename EdgeBucketType, typename EdgeSrcValueInputWrapper, typename EdgeDstValueInputWrapper, typename EdgeValueInputWrapper, typename EdgeOp, typename EdgeValueOutputWrapper> void transform_e(raft::handle_t const &handle, GraphViewType const &graph_view, EdgeBucketType const &edge_list, EdgeSrcValueInputWrapper edge_src_value_input, EdgeDstValueInputWrapper edge_dst_value_input, EdgeValueInputWrapper edge_value_input, EdgeOp e_op, EdgeValueOutputWrapper edge_value_output, bool do_expensive_check = false)#

Iterate over the edges in the input edge list and update edge property values.

This function is inspired by thrust::transform().

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
EdgeBucketType – Type of the edge bucket class which stores the edge list.
EdgeSrcValueInputWrapper – Type of the wrapper for input edge source property values.
EdgeDstValueInputWrapper – Type of the wrapper for input edge destination property values.
EdgeValueInputWrapper – Type of the wrapper for input edge property values.
EdgeOp – Type of the quinary edge operator.
EdgeValueOutputWrapper – Type of the wrapper for output edge property values.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
edge_list – EdgeBucketType class object storing the edge list to update edge property values.
edge_src_value_input – Wrapper used to access source input property values (for the edge sources assigned to this process in multi-GPU). Use either cugraph::edge_src_property_t::view() (if e_op needs to access source property values) or cugraph::edge_src_dummy_property_t::view() (if e_op does not access source property values). Use update_edge_src_property to fill the wrapper.
edge_dst_value_input – Wrapper used to access destination input property values (for the edge destinations assigned to this process in multi-GPU). Use either cugraph::edge_dst_property_t::view() (if e_op needs to access destination property values) or cugraph::edge_dst_dummy_property_t::view() (if e_op does not access destination property values). Use update_edge_dst_property to fill the wrapper.
edge_value_input – Wrapper used to access edge input property values (for the edges assigned to this process in multi-GPU). Use either cugraph::edge_property_t::view() (if e_op needs to access edge property values) or cugraph::edge_dummy_property_t::view() (if e_op does not access edge property values).
e_op – Quinary operator takes edge source, edge destination, property values for the source, destination, and edge and returns a value to be reduced.
edge_value_output – Wrapper used to store edge output property values (for the edges assigned to this process in multi-GPU). Use cugraph::edge_property_t::mutable_view().
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

template<typename GraphViewType, typename EdgeSrcValueInputWrapper, typename EdgeDstValueInputWrapper, typename IntersectionOp, typename T, typename VertexValueOutputIterator> void transform_reduce_dst_nbr_intersection_of_e_endpoints_by_v(raft::handle_t const &handle, GraphViewType const &graph_view, EdgeSrcValueInputWrapper edge_src_value_input, EdgeDstValueInputWrapper edge_dst_value_input, IntersectionOp intersection_op, T init, VertexValueOutputIterator vertex_value_output_first, bool do_expensive_check = false)#

Iterate over each edge and apply a functor to the common destination neighbor list of the edge endpoints, reduce the functor output values per-vertex.

Iterate over every edge; intersect destination neighbor lists of source vertex & destination vertex; invoke a user-provided functor per intersection, and reduce the functor output values (thrust::tuple of three values having the same type: one for source, one for destination, and one for every vertex in the intersection) per-vertex. We may add transform_reduce_triplet_of_dst_nbr_intersection_of_e_endpoints_by_v in the future to allow emitting different values for different vertices in the intersection of edge endpoints. This function is inspired by thrust::transform_reduce().

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
EdgeSrcValueInputWrapper – Type of the wrapper for edge source property values.
EdgeDstValueInputWrapper – Type of the wrapper for edge destination property values.
IntersectionOp – Type of the quinary per intersection operator.
T – Type of the initial value for per-vertex reduction.
VertexValueOutputIterator – Type of the iterator for vertex output property variables.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
edge_src_value_input – Wrapper used to access source input property values (for the edge sources assigned to this process in multi-GPU). Use either cugraph::edge_src_property_t::view() (if intersection_op needs to access source property values) or cugraph::edge_src_dummy_property_t::view() (if intersection_op does not access source property values). Use update_edge_src_property to fill the wrapper.
edge_dst_value_input – Wrapper used to access destination input property values (for the edge destinations assigned to this process in multi-GPU). Use either cugraph::edge_dst_property_t::view() (if intersection_op needs to access destination property values) or cugraph::edge_dst_dummy_property_t::view() (if intersection_op does not access destination property values). Use update_edge_dst_property to fill the wrapper.
intersection_op – quinary operator takes edge source, edge destination, property values for the source, property values for the destination, and a list of vertices in the intersection of edge source & destination vertices’ destination neighbors and returns a thrust::tuple of three values: one value per source vertex, one value for destination vertex, and one value for every vertex in the intersection.
init – Initial value to be added to the reduced intersection_op return values for each vertex.
vertex_value_output_first – Iterator pointing to the vertex property variables for the first (inclusive) vertex (assigned to this process in multi-GPU). vertex_value_output_last (exclusive) is deduced as vertex_value_output_first + graph_view.local_vertex_partition_range_size().
A – flag to run expensive checks for input arguments (if set to true).

template<typename GraphViewType, typename EdgeSrcValueInputWrapper, typename EdgeDstValueInputWrapper, typename EdgeValueInputWrapper, typename EdgeOp, typename T> T transform_reduce_e(raft::handle_t const &handle, GraphViewType const &graph_view, EdgeSrcValueInputWrapper edge_src_value_input, EdgeDstValueInputWrapper edge_dst_value_input, EdgeValueInputWrapper edge_value_input, EdgeOp e_op, T init, bool do_expensive_check = false)#

Iterate over the entire set of edges and reduce edge_op outputs.

This function is inspired by thrust::transform_reduce().

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
EdgeSrcValueInputWrapper – Type of the wrapper for edge source property values.
EdgeDstValueInputWrapper – Type of the wrapper for edge destination property values.
EdgeValueInputWrapper – Type of the wrapper for edge property values.
EdgeOp – Type of the quinary edge operator.
T – Type of the initial value.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
edge_src_value_input – Wrapper used to access source input property values (for the edge sources assigned to this process in multi-GPU). Use either cugraph::edge_src_property_t::view() (if e_op needs to access source property values) or cugraph::edge_src_dummy_property_t::view() (if e_op does not access source property values). Use update_edge_src_property to fill the wrapper.
edge_dst_value_input – Wrapper used to access destination input property values (for the edge destinations assigned to this process in multi-GPU). Use either cugraph::edge_dst_property_t::view() (if e_op needs to access destination property values) or cugraph::edge_dst_dummy_property_t::view() (if e_op does not access destination property values). Use update_edge_dst_property to fill the wrapper.
edge_value_input – Wrapper used to access edge input property values (for the edges assigned to this process in multi-GPU). Use either cugraph::edge_property_t::view() (if e_op needs to access edge property values) or cugraph::edge_dummy_property_t::view() (if e_op does not access edge property values).
e_op – Quinary operator takes edge source, edge destination, property values for the source, destination, and edge and returns a value to be reduced.
init – Initial value to be added to the reduced edge_op outputs.
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

T Transform-reduced edge_op outputs.

template<typename GraphViewType, typename EdgeSrcValueInputWrapper, typename EdgeDstValueInputWrapper, typename EdgeValueInputWrapper, typename EdgeOp> auto transform_reduce_e(raft::handle_t const &handle, GraphViewType const &graph_view, EdgeSrcValueInputWrapper edge_src_value_input, EdgeDstValueInputWrapper edge_dst_value_input, EdgeValueInputWrapper edge_value_input, EdgeOp e_op, bool do_expensive_check = false)#

Iterate over the entire set of edges and reduce edge_op outputs.

This function is inspired by thrust::transform_reduce().

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
EdgeSrcValueInputWrapper – Type of the wrapper for edge source property values.
EdgeDstValueInputWrapper – Type of the wrapper for edge destination property values.
EdgeValueInputWrapper – Type of the wrapper for edge property values.
EdgeOp – Type of the quinary edge operator.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
edge_src_value_input – Wrapper used to access source input property values (for the edge sources assigned to this process in multi-GPU). Use either cugraph::edge_src_property_t::view() (if e_op needs to access source property values) or cugraph::edge_src_dummy_property_t::view() (if e_op does not access source property values). Use update_edge_src_property to fill the wrapper.
edge_dst_value_input – Wrapper used to access destination input property values (for the edge destinations assigned to this process in multi-GPU). Use either cugraph::edge_dst_property_t::view() (if e_op needs to access destination property values) or cugraph::edge_dst_dummy_property_t::view() (if e_op does not access destination property values). Use update_edge_dst_property to fill the wrapper.
edge_value_input – Wrapper used to access edge input property values (for the edges assigned to this process in multi-GPU). Use either cugraph::edge_property_t::view() (if e_op needs to access edge property values) or cugraph::edge_dummy_property_t::view() (if e_op does not access edge property values).
e_op – Quinary operator takes edge source, edge destination, property values for the source, destination, and edge and returns a value to be reduced.
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

Transform-reduced edge_op outputs.

template<typename GraphViewType, typename EdgeSrcValueInputWrapper, typename EdgeDstValueInputWrapper, typename EdgeValueInputWrapper, typename EdgeSrcKeyInputWrapper, typename EdgeOp, typename ReduceOp, typename T> auto transform_reduce_e_by_src_key(raft::handle_t const &handle, GraphViewType const &graph_view, EdgeSrcValueInputWrapper edge_src_value_input, EdgeDstValueInputWrapper edge_dst_value_input, EdgeValueInputWrapper edge_value_input, EdgeSrcKeyInputWrapper edge_src_key_input, EdgeOp e_op, T init, ReduceOp reduce_op, bool do_expensive_check = false)#

Iterate over the entire set of edges and reduce edge_op outputs to (key, value) pairs.

This function is inspired by thrust::transform_reduce() and thrust::reduce_by_key(). Keys for edges are determined by the edge sources.

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
EdgeSrcValueInputWrapper – Type of the wrapper for edge source property values.
EdgeDstValueInputWrapper – Type of the wrapper for edge destination property values.
EdgeSrcKeyInputWrapper – Type of the wrapper for edge source key values.
EdgeValueInputWrapper – Type of the wrapper for edge property values.
EdgeOp – Type of the quinary edge operator.
T – Type of the values in (key, value) pairs.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
edge_src_value_input – Wrapper used to access source input property values (for the edge sources assigned to this process in multi-GPU). Use either cugraph::edge_src_property_t::view() (if e_op needs to access source property values) or cugraph::edge_src_dummy_property_t::view() (if e_op does not access source property values). Use update_edge_src_property to fill the wrapper.
edge_dst_value_input – Wrapper used to access destination input property values (for the edge destinations assigned to this process in multi-GPU). Use either cugraph::edge_dst_property_t::view() (if e_op needs to access destination property values) or cugraph::edge_dst_dummy_property_t::view() (if e_op does not access destination property values). Use update_edge_dst_property to fill the wrapper.
edge_src_key_input – Wrapper used to access source input ke values (for the edge sources assigned to this process in multi-GPU). Use cugraph::edge_src_property_t::view(). Use update_edge_src_property to fill the wrapper.
edge_value_input – Wrapper used to access edge input property values (for the edges assigned to this process in multi-GPU). Use either cugraph::edge_property_t::view() (if e_op needs to access edge property values) or cugraph::edge_dummy_property_t::view() (if e_op does not access edge property values).
e_op – Quinary operator takes edge source, edge destination, property values for the source, destination, and edge and returns a value to be reduced to (source key, value) pairs.
init – Initial value to be added to the value in each transform-reduced (source key, value) pair.
reduce_op – Binary operator that takes two input arguments and reduce the two values to one. There are pre-defined reduction operators in src/prims/reduce_op.cuh. It is recommended to use the pre-defined reduction operators whenever possible as the current (and future) implementations of graph primitives may check whether ReduceOp is a known type (or has known member variables) to take a more optimized code path. See the documentation in the reduce_op.cuh file for instructions on writing custom reduction operators.
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

std::tuple Tuple of rmm::device_uvector<typename GraphView::vertex_type> and rmm::device_uvector<T> (if T is arithmetic scalar) or a tuple of rmm::device_uvector objects (if T is a thrust::tuple type of arithmetic scalar types, one rmm::device_uvector object per scalar type).

template<typename GraphViewType, typename EdgeSrcValueInputWrapper, typename EdgeDstValueInputWrapper, typename EdgeValueInputWrapper, typename EdgeDstKeyInputWrapper, typename EdgeOp, typename ReduceOp, typename T> auto transform_reduce_e_by_dst_key(raft::handle_t const &handle, GraphViewType const &graph_view, EdgeSrcValueInputWrapper edge_src_value_input, EdgeDstValueInputWrapper edge_dst_value_input, EdgeValueInputWrapper edge_value_input, EdgeDstKeyInputWrapper edge_dst_key_input, EdgeOp e_op, T init, ReduceOp reduce_op, bool do_expensive_check = false)#

Iterate over the entire set of edges and reduce edge_op outputs to (key, value) pairs.

This function is inspired by thrust::transform_reduce() and thrust::reduce_by_key(). Keys for edges are determined by the edge destinations.

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
EdgeSrcValueInputWrapper – Type of the wrapper for edge source property values.
EdgeDstValueInputWrapper – Type of the wrapper for edge destination property values.
EdgeDstKeyInputWrapper – Type of the wrapper for edge destination key values.
EdgeValueInputWrapper – Type of the wrapper for edge property values.
EdgeOp – Type of the quinary edge operator.
T – Type of the values in (key, value) pairs.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
edge_src_value_input – Wrapper used to access source input property values (for the edge sources assigned to this process in multi-GPU). Use either cugraph::edge_src_property_t::view() (if e_op needs to access source property values) or cugraph::edge_src_dummy_property_t::view() (if e_op does not access source property values). Use update_edge_src_property to fill the wrapper.
edge_dst_value_input – Wrapper used to access destination input property values (for the edge destinations assigned to this process in multi-GPU). Use either cugraph::edge_dst_property_t::view() (if e_op needs to access destination property values) or cugraph::edge_dst_dummy_property_t::view() (if e_op does not access destination property values). Use update_edge_dst_property to fill the wrapper.
edge_partition_dst_key_input – Wrapper used to access destination input key values (for the edge destinations assigned to this process in multi-GPU). Use cugraph::edge_dst_property_t::view(). Use update_edge_dst_property to fill the wrapper.
edge_value_input – Wrapper used to access edge input property values (for the edges assigned to this process in multi-GPU). Use either cugraph::edge_property_t::view() (if e_op needs to access edge property values) or cugraph::edge_dummy_property_t::view() (if e_op does not access edge property values).
e_op – Quinary operator takes edge source, edge destination, property values for the source, destination, and edge and returns a value to be reduced to (destination key, value) pairs.
init – Initial value to be added to the value in each transform-reduced (destination key, value) pair.
reduce_op – Binary operator that takes two input arguments and reduce the two values to one. There are pre-defined reduction operators in src/prims/reduce_op.cuh. It is recommended to use the pre-defined reduction operators whenever possible as the current (and future) implementations of graph primitives may check whether ReduceOp is a known type (or has known member variables) to take a more optimized code path. See the documentation in the reduce_op.cuh file for instructions on writing custom reduction operators.
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

template<typename GraphViewType, typename ReduceOp, typename VertexValueInputIterator, typename VertexOp, typename T> T transform_reduce_v(raft::handle_t const &handle, GraphViewType const &graph_view, VertexValueInputIterator vertex_value_input_first, VertexOp v_op, T init, ReduceOp reduce_op, bool do_expensive_check = false)#

Reduce the transformed input vertex property values.

This function is inspired by thrust::transform_reduce().

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
ReduceOp – Type of the binary reduction operator.
VertexValueInputIterator – Type of the iterator for vertex property values.
VertexOp – Type of the unary vertex operator.
T – Type of the initial value.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
vertex_value_input_first – Iterator pointing to the vertex property values for the first (inclusive) vertex (assigned to this process in multi-GPU). vertex_value_input_last (exclusive) is deduced as vertex_value_input_first + graph_view.local_vertex_partition_range_size().
v_op – Binary operator takes vertex ID and *(vertex_value_input_first + i) (where i is [0, graph_view.local_vertex_partition_range_size())) and returns a transformed value to be reduced.
init – Initial value to be reduced with the transform-reduced input vertex property values.
reduce_op – Binary operator that takes two input arguments and reduce the two values to one. There are pre-defined reduction operators in include/cugraph/prims/reduce_op.cuh. It is recommended to use the pre-defined reduction operators whenever possible as the current (and future) implementations of graph primitives may check whether ReduceOp is a known type (or has known member variables) to take a more optimized code path. See the documentation in the reduce_op.cuh file for instructions on writing custom reduction operators.
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

T Transformed and reduced input vertex property values.

template<typename GraphViewType, typename VertexValueInputIterator, typename VertexOp, typename T> T transform_reduce_v(raft::handle_t const &handle, GraphViewType const &graph_view, VertexValueInputIterator vertex_value_input_first, VertexOp v_op, T init, bool do_expensive_check = false)#

Reduce the transformed input vertex property values.

This function is inspired by thrust::transform_reduce().

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
VertexValueInputIterator – Type of the iterator for vertex property values.
VertexOp – Type of the unary vertex operator.
T – Type of the initial value.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
vertex_value_input_first – Iterator pointing to the vertex property values for the first (inclusive) vertex (assigned to this process in multi-GPU). vertex_value_input_last (exclusive) is deduced as vertex_value_input_first + graph_view.local_vertex_partition_range_size().
v_op – Binary operator takes vertex ID and *(vertex_value_input_first + i) (where i is [0, graph_view.local_vertex_partition_range_size())) and returns a transformed value to be reduced.
init – Initial value to be added to the transform-reduced input vertex property values.
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

T Transformed and reduced input vertex property values.

template<typename GraphViewType, typename VertexValueInputIterator, typename VertexOp> auto transform_reduce_v(raft::handle_t const &handle, GraphViewType const &graph_view, VertexValueInputIterator vertex_value_input_first, VertexOp v_op, bool do_expensive_check = false)#

Reduce the transformed input vertex property values.

This function is inspired by thrust::transform_reduce().

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
VertexValueInputIterator – Type of the iterator for vertex property values.
VertexOp – Type of the unary vertex operator.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
vertex_value_input_first – Iterator pointing to the vertex property values for the first (inclusive) vertex (assigned to this process in multi-GPU). vertex_value_input_last (exclusive) is deduced as vertex_value_input_first + graph_view.local_vertex_partition_range_size().
v_op – Binary operator takes vertex ID and *(vertex_value_input_first + i) (where i is [0, graph_view.local_vertex_partition_range_size())) and returns a transformed value to be reduced.
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

Transformed and reduced input vertex property values.

template<typename GraphViewType, typename KeyBucketType> size_t compute_num_out_nbrs_from_frontier(raft::handle_t const &handle, GraphViewType const &graph_view, KeyBucketType const &frontier)#

decltype(allocate_dataframe_buffer<typename KeyBucketType::key_type>(0, rmm::cuda_stream_view{})) transform_reduce_v_frontier_outgoing_e_by_dst(raft::handle_t const &handle, GraphViewType const &graph_view, KeyBucketType const &frontier, EdgeSrcValueInputWrapper edge_src_value_input, EdgeDstValueInputWrapper edge_dst_value_input, EdgeValueInputWrapper edge_value_input, EdgeOp e_op, ReduceOp reduce_op, bool do_expensive_check = false)#

template<typename GraphViewType, typename VertexPropertyInputIterator, typename EdgeSrcValueOutputWrapper> void update_edge_src_property(raft::handle_t const &handle, GraphViewType const &graph_view, VertexPropertyInputIterator vertex_property_input_first, EdgeSrcValueOutputWrapper edge_src_property_output, bool do_expensive_check = false)#

Update graph edge source property values from the input vertex property values.

This version updates graph edge source property values for the entire edge source ranges (assigned to this process in multi-GPU).

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
VertexPropertyInputIterator – Type of the iterator for vertex property values.
EdgeSrcValueOutputWrapper – Type of the wrapper for output edge source property values.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
vertex_property_input_first – Iterator pointing to the vertex property value for the first (inclusive) vertex (of the vertex partition assigned to this process in multi-GPU). vertex_property_input_last (exclusive) is deduced as vertex_property_input_first + graph_view.local_vertex_partition_range_size().
edge_partition_src_property_output – edge_src_property_view_t class object to store source property values (for the edge sources assigned to this process in multi-GPU).
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

template<typename GraphViewType, typename VertexIterator, typename VertexPropertyInputIterator, typename EdgeSrcValueOutputWrapper> void update_edge_src_property(raft::handle_t const &handle, GraphViewType const &graph_view, VertexIterator sorted_unique_vertex_first, VertexIterator sorted_unique_vertex_last, VertexPropertyInputIterator vertex_property_input_first, EdgeSrcValueOutputWrapper edge_src_property_output, bool do_expensive_check = false)#

Update graph edge source property values from the input vertex property values.

This version updates only a subset of graph edge source property values. [sorted_unique_vertex_first, sorted_unique_vertex_last) specifies the vertices with new property values to be updated.

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
VertexIterator – Type of the iterator for vertex identifiers.
VertexPropertyInputIterator – Type of the iterator for vertex property values.
EdgeSrcValueOutputWrapper – Type of the wrapper for output edge source property values.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
sorted_unique_vertex_first – Iterator pointing to the first (inclusive) vertex with a new value to be updated. v in [sorted_unique_vertex_first, sorted_unique_vertex_last) should be sorted & distinct (and should belong to the vertex partition assigned to this process in multi-GPU), otherwise undefined behavior.
sorted_unique_vertex_last – Iterator pointing to the last (exclusive) vertex with a new value.
vertex_property_input_first – Iterator pointing to the vertex property value for the first (inclusive) vertex (of the vertex partition assigned to this process in multi-GPU). vertex_property_input_last (exclusive) is deduced as vertex_property_input_first + graph_view.local_vertex_partition_range_size().
edge_partition_src_property_output – edge_src_property_view_t class object to store source property values (for the edge sources assigned to this process in multi-GPU).
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

template<typename GraphViewType, typename VertexPropertyInputIterator, typename EdgeDstValueOutputWrapper> void update_edge_dst_property(raft::handle_t const &handle, GraphViewType const &graph_view, VertexPropertyInputIterator vertex_property_input_first, EdgeDstValueOutputWrapper edge_dst_property_output, bool do_expensive_check = false)#

Update graph edge destination property values from the input vertex property values.

This version updates graph edge destination property values for the entire edge destination ranges (assigned to this process in multi-GPU).

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
VertexPropertyInputIterator – Type of the iterator for vertex property values.
EdgeDstValueOutputWrapper – Type of the wrapper for output edge destination property values.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
vertex_property_input_first – Iterator pointing to the vertex property value for the first (inclusive) vertex (of the vertex partition assigned to this process in multi-GPU). vertex_property_input_last (exclusive) is deduced as vertex_property_input_first + graph_view.local_vertex_partition_range_size().
edge_partition_dst_property_output – edge_dst_property_view_t class object to store destination property values (for the edge destinations assigned to this process in multi-GPU).
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

template<typename GraphViewType, typename VertexIterator, typename VertexPropertyInputIterator, typename EdgeDstValueOutputWrapper> void update_edge_dst_property(raft::handle_t const &handle, GraphViewType const &graph_view, VertexIterator sorted_unique_vertex_first, VertexIterator sorted_unique_vertex_last, VertexPropertyInputIterator vertex_property_input_first, EdgeDstValueOutputWrapper edge_dst_property_output, bool do_expensive_check = false)#

Update graph edge destination property values from the input vertex property values.

This version updates only a subset of graph edge destination property values. [sorted_unique_vertex_first, sorted_unique_vertex_last) specifies the vertices with new property values to be updated.

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
VertexIterator – Type of the iterator for vertex identifiers.
VertexPropertyInputIterator – Type of the iterator for vertex property values.
EdgeDstValueOutputWrapper – Type of the wrapper for output edge destination property values.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
sorted_unique_vertex_first – Iterator pointing to the first (inclusive) vertex with a new value to be updated. v in [sorted_unique_vertex_first, sorted_unique_vertex_last) should be sorted & distinct (and should belong to the vertex partition assigned to this process in multi-GPU), otherwise undefined behavior.
sorted_unique_vertex_last – Iterator pointing to the last (exclusive) vertex with a new value.
vertex_property_input_first – Iterator pointing to the vertex property value for the first (inclusive) vertex (of the vertex partition assigned to this process in multi-GPU). vertex_property_input_last (exclusive) is deduced as vertex_property_input_first + graph_view.local_vertex_partition_range_size().
edge_partition_dst_property_output – edge_dst_property_view_t class object to store destination property values (for the edge destinations assigned to this process in multi-GPU).
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

template<typename GraphViewType, typename KeyBuffer, typename PayloadBuffer, typename VertexFrontierType, typename VertexValueInputIterator, typename VertexValueOutputIterator, typename VertexOp> void update_v_frontier(raft::handle_t const &handle, GraphViewType const &graph_view, KeyBuffer &&key_buffer, PayloadBuffer &&payload_buffer, VertexFrontierType &frontier, std::vector<size_t> const &next_frontier_bucket_indices, VertexValueInputIterator vertex_value_input_first, VertexValueOutputIterator vertex_value_output_first, VertexOp v_op, bool do_expensive_check = false)#

Insert (tagged-)vertices to the vertex frontier and update vertex property values of the newly inserted vertices .

This primitive often works in pair with transform_reduce_v_frontier_outgoing_e_by_dst. This version of update_v_frontier takes payload_buffer and @v_op takes a payload value in addition to a (tagged-)vertex and a vertex property value as input arguments.

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
KeyBuffer – Type of the buffer storing (tagged-)vertices.
PayloadBuffer – Type of the buffer storing payload values.
VertexFrontierType – Type of the vertex frontier class which abstracts vertex frontier managements.
VertexValueInputIterator – Type of the iterator for input vertex property values.
VertexValueOutputIterator – Type of the iterator for output vertex property variables.
VertexOp – Type of the ternary vertex operator.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
key_buffer – buffer object storing (tagged-)vertices to insert.
payload_buffer – buffer object storing payload values for each (tagged-)vertices in the key_buffer.
frontier – VertexFrontierType class object for vertex frontier managements. This object includes multiple bucket objects.
next_frontier_bucket_indices – Indices of the vertex frontier buckets to store new frontier (tagged-)vertices.
vertex_value_input_first – Iterator pointing to the vertex property values for the first (inclusive) vertex (assigned to this process in multi-GPU). vertex_value_input_last (exclusive) is deduced as vertex_value_input_first + graph_view.local_vertex_partition_range_size().
vertex_value_output_first – Iterator pointing to the vertex property variables for the first (inclusive) vertex (assigned to this process in multi-GPU). vertex_value_output_last (exclusive) is deduced as vertex_value_output_first + graph_view.local_vertex_partition_range_size().
v_op – Ternary operator that takes (tagged-)vertex ID, *(vertex_value_input_first + i) (where i is [0, graph_view.local_vertex_partition_range_size())) and the payload value for the (tagged-)vertex ID and returns a tuple of 1) a thrust::optional object optionally storing a bucket index and 2) a thrust::optional object optionally storing a new vertex property value. If the first element of the returned tuple is thrust::nullopt, this (tagged-)vertex won’t be inserted to the vertex frontier. If the second element is thrust::nullopt, the vertex property value for this vertex won’t be updated. Note that it is currently undefined behavior if there are multiple tagged-vertices with the same vertex ID (but with different tags) AND v_op results on the tagged-vertices with the same vertex ID have more than one valid new vertex property values.

template<typename GraphViewType, typename KeyBuffer, typename VertexFrontierType, typename VertexValueInputIterator, typename VertexValueOutputIterator, typename VertexOp> void update_v_frontier(raft::handle_t const &handle, GraphViewType const &graph_view, KeyBuffer &&key_buffer, VertexFrontierType &frontier, std::vector<size_t> const &next_frontier_bucket_indices, VertexValueInputIterator vertex_value_input_first, VertexValueOutputIterator vertex_value_output_first, VertexOp v_op, bool do_expensive_check = false)#

Insert (tagged-)vertices to the vertex frontier and update vertex property values of the newly inserted vertices .

This primitive often works in pair with transform_reduce_v_frontier_outgoing_e_by_dst. This version of update_v_frontier does not take payload_buffer and @v_op takes a (tagged-)vertex and a vertex property value as input arguments (no payload value in the input parameter list).

Template Parameters:

GraphViewType – Type of the passed non-owning graph object.
KeyBuffer – Type of the buffer storing (tagged-)vertices.
VertexFrontierType – Type of the vertex frontier class which abstracts vertex frontier managements.
VertexValueInputIterator – Type of the iterator for input vertex property values.
VertexValueOutputIterator – Type of the iterator for output vertex property variables.
VertexOp – Type of the binary vertex operator.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Non-owning graph object.
key_buffer – buffer object storing (tagged-)vertices to insert.
frontier – VertexFrontierType class object for vertex frontier managements. This object includes multiple bucket objects.
next_frontier_bucket_indices – Indices of the vertex frontier buckets to store new frontier (tagged-)vertices.
vertex_value_input_first – Iterator pointing to the vertex property values for the first (inclusive) vertex (assigned to this process in multi-GPU). vertex_value_input_last (exclusive) is deduced as vertex_value_input_first + graph_view.local_vertex_partition_range_size().
vertex_value_output_first – Iterator pointing to the vertex property variables for the first (inclusive) vertex (assigned to this process in multi-GPU). vertex_value_output_last (exclusive) is deduced as vertex_value_output_first + graph_view.local_vertex_partition_range_size().
v_op – Binary operator that takes (tagged-)vertex ID, and *(vertex_value_input_first + i) (where i is [0, graph_view.local_vertex_partition_range_size())) and returns a tuple of 1) a thrust::optional object optionally storing a bucket index and 2) a thrust::optional object optionally storing a new vertex property value. If the first element of the returned tuple is thrust::nullopt, this (tagged-)vertex won’t be inserted to the vertex frontier. If the second element is thrust::nullopt, the vertex property value for this vertex won’t be updated. Note that it is currently undefined behavior if there are multiple tagged-vertices with the same vertex ID (but with different tags) AND v_op results on the tagged-vertices with the same vertex ID have more than one valid new vertex property values.

template<typename vertex_t, typename KeyIterator> KeyIterator compute_key_lower_bound(KeyIterator sorted_unique_key_first, KeyIterator sorted_unique_key_last, vertex_t v_threshold, rmm::cuda_stream_view stream_view)#

template<typename vertex_t, typename KeyIterator> std::vector<size_t> compute_key_segment_offsets(KeyIterator sorted_key_first, KeyIterator sorted_key_last, raft::host_span<vertex_t const> segment_offsets, vertex_t vertex_range_first, rmm::cuda_stream_view stream_view)#

template<typename VertexIterator> rmm::device_uvector<uint32_t> compute_vertex_list_bitmap_info(VertexIterator sorted_unique_vertex_first, VertexIterator sorted_unique_vertex_last, typename thrust::iterator_traits<VertexIterator>::value_type vertex_range_first, typename thrust::iterator_traits<VertexIterator>::value_type vertex_range_last, rmm::cuda_stream_view stream_view)#

template<typename InputVertexIterator, typename OutputVertexIterator> void device_bcast_vertex_list(raft::comms::comms_t const &comm, std::variant<raft::device_span<uint32_t const>, InputVertexIterator> v_list, OutputVertexIterator output_v_first, typename thrust::iterator_traits<InputVertexIterator>::value_type vertex_range_first, typename thrust::iterator_traits<InputVertexIterator>::value_type vertex_range_last, size_t v_list_size, int root, rmm::cuda_stream_view stream_view)#

template<typename OutputVertexIterator> void retrieve_vertex_list_from_bitmap(raft::device_span<uint32_t const> bitmap, OutputVertexIterator output_v_first, raft::device_span<size_t> count, typename thrust::iterator_traits<OutputVertexIterator>::value_type vertex_range_first, typename thrust::iterator_traits<OutputVertexIterator>::value_type vertex_range_last, rmm::cuda_stream_view stream_view)#

template<typename vertex_t, typename edge_t, typename weight_t, bool store_transposed, bool multi_gpu> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>> negative_sampling(raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu> const &graph_view, std::optional<raft::device_span<weight_t const>> src_biases, std::optional<raft::device_span<weight_t const>> dst_biases, size_t num_samples, bool remove_duplicates, bool remove_existing_edges, bool exact_number_of_samples, bool do_expensive_check)#

Negative Sampling.

This function generates negative samples for graph.

Negative sampling is done by generating a random graph according to the specified parameters and optionally removing samples that represent actual edges in the graph

Sampling occurs by creating a list of source vertex ids from biased samping of the source vertex space, and destination vertex ids from biased sampling of the destination vertex space, and using this as the putative list of edges. We then can optionally remove duplicates and remove actual edges in the graph to generate the final list. If necessary we will repeat the process to end with a resulting edge list of the appropriate size.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
store_transposed – Flag indicating whether sources (if false) or destinations (if true) are major indices
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false)

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Graph View object to generate NBR Sampling for
rng_state – RNG state
src_biases – Optional bias for randomly selecting source vertices. If std::nullopt vertices will be selected uniformly. In multi-GPU environment the biases should be partitioned based on the vertex partitions.
dst_biases – Optional bias for randomly selecting destination vertices. If std::nullopt vertices will be selected uniformly. In multi-GPU environment the biases should be partitioned based on the vertex partitions.
num_samples – Number of negative samples to generate
remove_duplicates – If true, remove duplicate samples
remove_existing_edges – If true, remove samples that are actually edges in the graph
exact_number_of_samples – If true, repeat generation until we get the exact number of negative samples
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

tuple containing source vertex ids and destination vertex ids for the negative samples

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t > > negative_sampling (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< raft::device_span< float const > > src_bias, std::optional< raft::device_span< float const > > dst_bias, size_t num_samples, bool remove_duplicates, bool remove_existing_edges, bool exact_number_of_samples, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t > > negative_sampling (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< raft::device_span< double const > > src_bias, std::optional< raft::device_span< double const > > dst_bias, size_t num_samples, bool remove_duplicates, bool remove_existing_edges, bool exact_number_of_samples, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t > > negative_sampling (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< raft::device_span< float const > > src_bias, std::optional< raft::device_span< float const > > dst_bias, size_t num_samples, bool remove_duplicates, bool remove_existing_edges, bool exact_number_of_samples, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t > > negative_sampling (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< raft::device_span< double const > > src_bias, std::optional< raft::device_span< double const > > dst_bias, size_t num_samples, bool remove_duplicates, bool remove_existing_edges, bool exact_number_of_samples, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t > > negative_sampling (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< raft::device_span< float const > > src_bias, std::optional< raft::device_span< float const > > dst_bias, size_t num_samples, bool remove_duplicates, bool remove_existing_edges, bool exact_number_of_samples, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t > > negative_sampling (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< raft::device_span< double const > > src_bias, std::optional< raft::device_span< double const > > dst_bias, size_t num_samples, bool remove_duplicates, bool remove_existing_edges, bool exact_number_of_samples, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t > > negative_sampling (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< raft::device_span< float const > > src_bias, std::optional< raft::device_span< float const > > dst_bias, size_t num_samples, bool remove_duplicates, bool remove_existing_edges, bool exact_number_of_samples, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t > > negative_sampling (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< raft::device_span< double const > > src_bias, std::optional< raft::device_span< double const > > dst_bias, size_t num_samples, bool remove_duplicates, bool remove_existing_edges, bool exact_number_of_samples, bool do_expensive_check)

template<typename vertex_t, typename edge_t, typename weight_t, typename edge_type_t, typename label_t, bool store_transposed, bool multi_gpu> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<weight_t>>, std::optional<rmm::device_uvector<edge_t>>, std::optional<rmm::device_uvector<edge_type_t>>, std::optional<rmm::device_uvector<int32_t>>, std::optional<rmm::device_uvector<label_t>>, std::optional<rmm::device_uvector<size_t>>> uniform_neighbor_sample(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu> const &graph_view, std::optional<edge_property_view_t<edge_t, weight_t const*>> edge_weight_view, std::optional<edge_property_view_t<edge_t, edge_t const*>> edge_id_view, std::optional<edge_property_view_t<edge_t, edge_type_t const*>> edge_type_view, raft::device_span<vertex_t const> starting_vertices, std::optional<raft::device_span<label_t const>> starting_vertex_label_offsets, std::optional<std::tuple<raft::device_span<label_t const>, raft::device_span<int32_t const>>> label_to_output_comm_rank, raft::host_span<int32_t const> fan_out, raft::random::RngState &rng_state, bool return_hops, bool with_replacement = true, prior_sources_behavior_t prior_sources_behavior = prior_sources_behavior_t::DEFAULT, bool dedupe_sources = false, bool do_expensive_check = false)#

Uniform Neighborhood Sampling.

Deprecated:: Replaced with homogeneous_uniform_neighbor_sample

This function traverses from a set of starting vertices, traversing outgoing edges and randomly selects from these outgoing neighbors to extract a subgraph.

Output from this function is a tuple of vectors (src, dst, weight, edge_id, edge_type, hop, label, offsets), identifying the randomly selected edges. src is the source vertex, dst is the destination vertex, weight (optional) is the edge weight, edge_id (optional) identifies the edge id, edge_type (optional) identifies the edge type, hop identifies which hop the edge was encountered in. The label output (optional) identifes the vertex label. The offsets array (optional) will be described below and is dependent upon the input parameters.

If starting_vertex_label_offsets is not specified then no organization is applied to the output, the label and offsets values in the return set will be std::nullopt.

If starting_vertex_label_offsets is specified and label_to_output_comm_rank is not specified then the label output has values. This will also result in the output being sorted by vertex label. The offsets array in the return will be a CSR-style offsets array to identify the beginning of each label range in the data. labels.size() == (offsets.size() - 1).

If starting_vertex_label_offsets is specified and label_to_output_comm_rank is specified then the label output has values. This will also result in the output being sorted by vertex label. The offsets array in the return will be a CSR-style offsets array to identify the beginning of each label range in the data. labels.size() == (offsets.size() - 1). Additionally, the data will be shuffled so that all data with a particular label will be on the specified rank.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
weight_t – Type of edge weights. Needs to be a floating point type.
edge_type_t – Type of edge type. Needs to be an integral type.
label_t – Type of label. Needs to be an integral type.
store_transposed – Flag indicating whether sources (if false) or destinations (if true) are major indices
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false)

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Graph View object to generate NBR Sampling on.
edge_weight_view – Optional view object holding edge weights for graph_view.
edge_id_view – Optional view object holding edge ids for graph_view.
edge_type_view – Optional view object holding edge types for graph_view.
starting_vertices – Device span of starting vertex IDs for the sampling. In a multi-gpu context the starting vertices should be local to this GPU.
starting_vertex_label_offsets – Optional device span of labels associated with each starting vertex for the sampling.
label_to_output_comm_rank – Optional tuple of device spans mapping label to a particular output rank. Element 0 of the tuple identifes the label, Element 1 of the tuple identifies the output rank. The label span must be sorted in ascending order.
fan_out – Host span defining branching out (fan-out) degree per source vertex for each level
rng_state – A pre-initialized raft::RngState object for generating random numbers
return_hops – boolean flag specifying if the hop information should be returned
prior_sources_behavior – Enum type defining how to handle prior sources, (defaults to DEFAULT)
dedupe_sources – boolean flag, if true then if a vertex v appears as a destination in hop X multiple times with the same label, it will only be passed once (for each label) as a source for the next hop. Default is false.
with_replacement – boolean flag specifying if random sampling is done with replacement (true); or, without replacement (false); default = true;
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

tuple device vectors (vertex_t source_vertex, vertex_t destination_vertex, optional weight_t weight, optional edge_t edge id, optional edge_type_t edge type, optional int32_t hop, optional label_t label, optional size_t offsets)

template<typename vertex_t, typename edge_t, typename weight_t, typename edge_type_t, typename bias_t, typename label_t, bool store_transposed, bool multi_gpu> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<weight_t>>, std::optional<rmm::device_uvector<edge_t>>, std::optional<rmm::device_uvector<edge_type_t>>, std::optional<rmm::device_uvector<int32_t>>, std::optional<rmm::device_uvector<label_t>>, std::optional<rmm::device_uvector<size_t>>> biased_neighbor_sample(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu> const &graph_view, std::optional<edge_property_view_t<edge_t, weight_t const*>> edge_weight_view, std::optional<edge_property_view_t<edge_t, edge_t const*>> edge_id_view, std::optional<edge_property_view_t<edge_t, edge_type_t const*>> edge_type_view, edge_property_view_t<edge_t, bias_t const*> edge_bias_view, raft::device_span<vertex_t const> starting_vertices, std::optional<raft::device_span<label_t const>> starting_vertex_label_offsets, std::optional<std::tuple<raft::device_span<label_t const>, raft::device_span<int32_t const>>> label_to_output_comm_rank, raft::host_span<int32_t const> fan_out, raft::random::RngState &rng_state, bool return_hops, bool with_replacement = true, prior_sources_behavior_t prior_sources_behavior = prior_sources_behavior_t::DEFAULT, bool dedupe_sources = false, bool do_expensive_check = false)#

Biased Neighborhood Sampling.

Deprecated:: Replaced with homogeneous_biased_neighbor_sample

This function traverses from a set of starting vertices, traversing outgoing edges and randomly selects (with edge biases) from these outgoing neighbors to extract a subgraph.

If starting_vertex_label_offsets is not specified then no organization is applied to the output, the label and offsets values in the return set will be std::nullopt.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
weight_t – Type of edge weights. Needs to be a floating point type.
edge_type_t – Type of edge type. Needs to be an integral type.
bias_t – Type of bias. Needs to be an integral type.
label_t – Type of label. Needs to be an integral type.
store_transposed – Flag indicating whether sources (if false) or destinations (if true) are major indices
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false)

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Graph View object to generate NBR Sampling on.
edge_weight_view – Optional view object holding edge weights for graph_view.
edge_id_view – Optional view object holding edge ids for graph_view.
edge_type_view – Optional view object holding edge types for graph_view.
edge_bias_view – View object holding edge biases (to be used in biased sampling) for graph_view. Bias values should be non-negative and the sum of edge bias values from any vertex should not exceed std::numeric_limits<bias_t>::max(). 0 bias value indicates that the corresponding edge can never be selected.
starting_vertices – Device span of starting vertex IDs for the sampling. In a multi-gpu context the starting vertices should be local to this GPU.
starting_vertex_label_offsets – Optional device span of labels associated with each starting vertex for the sampling.
label_to_output_comm_rank – Optional tuple of device spans mapping label to a particular output rank. Element 0 of the tuple identifes the label, Element 1 of the tuple identifies the output rank. The label span must be sorted in ascending order.
fan_out – Host span defining branching out (fan-out) degree per source vertex for each level
rng_state – A pre-initialized raft::RngState object for generating random numbers
return_hops – boolean flag specifying if the hop information should be returned
prior_sources_behavior – Enum type defining how to handle prior sources, (defaults to DEFAULT)
dedupe_sources – boolean flag, if true then if a vertex v appears as a destination in hop X multiple times with the same label, it will only be passed once (for each label) as a source for the next hop. Default is false.
with_replacement – boolean flag specifying if random sampling is done with replacement (true); or, without replacement (false); default = true;
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

template<typename vertex_t, typename edge_t, typename weight_t, typename edge_type_t, bool store_transposed, bool multi_gpu> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<weight_t>>, std::optional<rmm::device_uvector<edge_t>>, std::optional<rmm::device_uvector<edge_type_t>>, std::optional<rmm::device_uvector<int32_t>>, std::optional<rmm::device_uvector<size_t>>> heterogeneous_uniform_neighbor_sample(raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu> const &graph_view, std::optional<edge_property_view_t<edge_t, weight_t const*>> edge_weight_view, std::optional<edge_property_view_t<edge_t, edge_t const*>> edge_id_view, std::optional<edge_property_view_t<edge_t, edge_type_t const*>> edge_type_view, raft::device_span<vertex_t const> starting_vertices, std::optional<raft::device_span<int32_t const>> starting_vertex_labels, std::optional<raft::device_span<int32_t const>> label_to_output_comm_rank, raft::host_span<int32_t const> fan_out, edge_type_t num_edge_types, sampling_flags_t sampling_flags, bool do_expensive_check = false)#

Heterogeneous Uniform Neighborhood Sampling.

This function traverses from a set of starting vertices, traversing outgoing edges and randomly selects (uniformly) from these outgoing neighbors to extract a subgraph. The branching out to select outgoing neighbors is performed with heterogeneous fanouts where the number of edge types is bigger than 1.

Output from this function is a tuple of vectors (src, dst, weight, edge_id, edge_type, hop, offsets), identifying the randomly selected edges where the size of src, dst, weight, edge_id, edge_type and hop is the number of sampled edges while the size of the offsets vector is the number of labels + 1. src is the source vertex, dst is the destination vertex, weight (optional) is the edge weight, edge_id (optional) identifies the edge id, edge_type (optional) identifies the edge type, hop identifies which hop the edge was encountered in. The offsets array (optional) identifies the offset for each label.

If label_to_output_comm_rank is specified then the data will be shuffled so that all entries for a particular label are returned on the specified rank.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
weight_t – Type of edge weights. Needs to be a floating point type.
edge_type_t – Type of edge type. Needs to be an integral type.
store_transposed – Flag indicating whether sources (if false) or destinations (if true) are major indices
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false)

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
rng_state – A pre-initialized raft::RngState object for generating random numbers
graph_view – Graph View object to generate NBR Sampling on.
edge_weight_view – Optional view object holding edge weights for graph_view.
edge_id_view – Optional view object holding edge ids for graph_view.
edge_type_view – Optional view object holding edge types for graph_view.
starting_vertices – Device span of starting vertex IDs for the sampling. In a multi-gpu context the starting vertices should be local to this GPU.
starting_vertex_labels – Optional device span of labels associated with each starting vertex for the sampling.
label_to_output_comm_rank – Optional device span identifying which rank should get sampling outputs of each vertex label. This should be the same on each rank.
fan_out – Host span defining branching out (fan-out) degree per source vertex for each level. The fanout value at hop x is given by the expression ‘fanout[x*num_edge_types + edge_type_id]’
num_edge_types – Number of edge types where a value of 1 translates to homogeneous neighbor sample whereas a value greater than 1 translates to heterogeneous neighbor sample.
flags – A set of flags indicating which sampling features should be used.
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

template<typename vertex_t, typename edge_t, typename weight_t, typename edge_type_t, typename bias_t, bool store_transposed, bool multi_gpu> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<weight_t>>, std::optional<rmm::device_uvector<edge_t>>, std::optional<rmm::device_uvector<edge_type_t>>, std::optional<rmm::device_uvector<int32_t>>, std::optional<rmm::device_uvector<size_t>>> heterogeneous_biased_neighbor_sample(raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu> const &graph_view, std::optional<edge_property_view_t<edge_t, weight_t const*>> edge_weight_view, std::optional<edge_property_view_t<edge_t, edge_t const*>> edge_id_view, std::optional<edge_property_view_t<edge_t, edge_type_t const*>> edge_type_view, edge_property_view_t<edge_t, bias_t const*> edge_bias_view, raft::device_span<vertex_t const> starting_vertices, std::optional<raft::device_span<int32_t const>> starting_vertex_labels, std::optional<raft::device_span<int32_t const>> label_to_output_comm_rank, raft::host_span<int32_t const> fan_out, edge_type_t num_edge_types, sampling_flags_t sampling_flags, bool do_expensive_check = false)#

Heterogeneous Biased Neighborhood Sampling.

This function traverses from a set of starting vertices, traversing outgoing edges and randomly selects (with edge biases) from these outgoing neighbors to extract a subgraph. The branching out to select outgoing neighbors is performed with heterogeneous fanouts where the number of edge types is bigger than 1.

If label_to_output_comm_rank is specified then the data will be shuffled so that all entries for a particular label are returned on the specified rank.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
weight_t – Type of edge weights. Needs to be a floating point type.
edge_type_t – Type of edge type. Needs to be an integral type.
bias_t – Type of bias. Needs to be an integral type.
store_transposed – Flag indicating whether sources (if false) or destinations (if true) are major indices
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false)

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
rng_state – A pre-initialized raft::RngState object for generating random numbers
graph_view – Graph View object to generate NBR Sampling on.
edge_weight_view – Optional view object holding edge weights for graph_view.
edge_id_view – Optional view object holding edge ids for graph_view.
edge_type_view – Optional view object holding edge types for graph_view.
edge_bias_view – View object holding edge biases (to be used in biased sampling) for graph_view. Bias values should be non-negative and the sum of edge bias values from any vertex should not exceed std::numeric_limits<bias_t>::max(). 0 bias value indicates that the corresponding edge can never be selected.
starting_vertices – Device span of starting vertex IDs for the sampling. In a multi-gpu context the starting vertices should be local to this GPU.
starting_vertex_labels – Optional device span of labels associated with each starting vertex for the sampling.
label_to_output_comm_rank – Optional device span identifying which rank should get sampling outputs of each vertex label. This should be the same on each rank.
fan_out – Host span defining branching out (fan-out) degree per source vertex for each level. The fanout value at hop x is given by the expression ‘fanout[x*num_edge_types + edge_type_id]’
num_edge_types – Number of edge types where a value of 1 translates to homogeneous neighbor sample whereas a value greater than 1 translates to heterogeneous neighbor sample.
flags – A set of flags indicating which sampling features should be used.
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

template<typename vertex_t, typename edge_t, typename weight_t, typename edge_type_t, bool store_transposed, bool multi_gpu> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<weight_t>>, std::optional<rmm::device_uvector<edge_t>>, std::optional<rmm::device_uvector<edge_type_t>>, std::optional<rmm::device_uvector<int32_t>>, std::optional<rmm::device_uvector<size_t>>> homogeneous_uniform_neighbor_sample(raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu> const &graph_view, std::optional<edge_property_view_t<edge_t, weight_t const*>> edge_weight_view, std::optional<edge_property_view_t<edge_t, edge_t const*>> edge_id_view, std::optional<edge_property_view_t<edge_t, edge_type_t const*>> edge_type_view, raft::device_span<vertex_t const> starting_vertices, std::optional<raft::device_span<int32_t const>> starting_vertex_labels, std::optional<raft::device_span<int32_t const>> label_to_output_comm_rank, raft::host_span<int32_t const> fan_out, sampling_flags_t sampling_flags, bool do_expensive_check = false)#

Homogeneous Uniform Neighborhood Sampling.

If label_to_output_comm_rank is specified then the data will be shuffled so that all entries for a particular label are returned on the specified rank.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
weight_t – Type of edge weights. Needs to be a floating point type.
edge_type_t – Type of edge type. Needs to be an integral type.
store_transposed – Flag indicating whether sources (if false) or destinations (if true) are major indices
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false)

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
rng_state – A pre-initialized raft::RngState object for generating random numbers
graph_view – Graph View object to generate NBR Sampling on.
edge_weight_view – Optional view object holding edge weights for graph_view.
edge_id_view – Optional view object holding edge ids for graph_view.
edge_type_view – Optional view object holding edge types for graph_view.
starting_vertices – Device span of starting vertex IDs for the sampling. In a multi-gpu context the starting vertices should be local to this GPU.
starting_vertex_labels – Optional device span of labels associated with each starting vertex for the sampling.
label_to_output_comm_rank – Optional device span identifying which rank should get sampling outputs of each vertex label. This should be the same on each rank.
fan_out – Host span defining branching out (fan-out) degree per source vertex for each level.
flags – A set of flags indicating which sampling features should be used.
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

template<typename vertex_t, typename edge_t, typename weight_t, typename edge_type_t, typename bias_t, bool store_transposed, bool multi_gpu> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<weight_t>>, std::optional<rmm::device_uvector<edge_t>>, std::optional<rmm::device_uvector<edge_type_t>>, std::optional<rmm::device_uvector<int32_t>>, std::optional<rmm::device_uvector<size_t>>> homogeneous_biased_neighbor_sample(raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu> const &graph_view, std::optional<edge_property_view_t<edge_t, weight_t const*>> edge_weight_view, std::optional<edge_property_view_t<edge_t, edge_t const*>> edge_id_view, std::optional<edge_property_view_t<edge_t, edge_type_t const*>> edge_type_view, edge_property_view_t<edge_t, bias_t const*> edge_bias_view, raft::device_span<vertex_t const> starting_vertices, std::optional<raft::device_span<int32_t const>> starting_vertex_labels, std::optional<raft::device_span<int32_t const>> label_to_output_comm_rank, raft::host_span<int32_t const> fan_out, sampling_flags_t sampling_flags, bool do_expensive_check = false)#

Homogeneous Biased Neighborhood Sampling.

If label_to_output_comm_rank is specified then the data will be shuffled so that all entries for a particular label are returned on the specified rank.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
weight_t – Type of edge weights. Needs to be a floating point type.
edge_type_t – Type of edge type. Needs to be an integral type.
bias_t – Type of bias. Needs to be an integral type.
store_transposed – Flag indicating whether sources (if false) or destinations (if true) are major indices
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false)

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
rng_state – A pre-initialized raft::RngState object for generating random numbers
graph_view – Graph View object to generate NBR Sampling on.
edge_weight_view – Optional view object holding edge weights for graph_view.
edge_id_view – Optional view object holding edge ids for graph_view.
edge_type_view – Optional view object holding edge types for graph_view.
edge_bias_view – View object holding edge biases (to be used in biased sampling) for graph_view. Bias values should be non-negative and the sum of edge bias values from any vertex should not exceed std::numeric_limits<bias_t>::max(). 0 bias value indicates that the corresponding edge can never be selected.
starting_vertices – Device span of starting vertex IDs for the sampling. In a multi-gpu context the starting vertices should be local to this GPU.
starting_vertex_labels – Optional device span of labels associated with each starting vertex for the sampling.
label_to_output_comm_rank – Optional device span identifying which rank should get sampling outputs of each vertex label. This should be the same on each rank.
fan_out – Host span defining branching out (fan-out) degree per source vertex for each level.
flags – A set of flags indicating which sampling features should be used.
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > uniform_neighbor_sample (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_type_view, raft::device_span< int32_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< std::tuple< raft::device_span< int32_t const >, raft::device_span< int32_t const > > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, raft::random::RngState &rng_state, bool return_hops, bool with_replacement, prior_sources_behavior_t prior_sources_behavior, bool dedupe_sources, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > uniform_neighbor_sample (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_type_view, raft::device_span< int32_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< std::tuple< raft::device_span< int32_t const >, raft::device_span< int32_t const > > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, raft::random::RngState &rng_state, bool return_hops, bool with_replacement, prior_sources_behavior_t prior_sources_behavior, bool dedupe_sources, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > biased_neighbor_sample (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_type_view, edge_property_view_t< int32_t, float const * > edge_bias_view, raft::device_span< int32_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< std::tuple< raft::device_span< int32_t const >, raft::device_span< int32_t const > > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, raft::random::RngState &rng_state, bool return_hops, bool with_replacement, prior_sources_behavior_t prior_sources_behavior, bool dedupe_sources, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > biased_neighbor_sample (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_type_view, edge_property_view_t< int32_t, double const * > edge_bias_view, raft::device_span< int32_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< std::tuple< raft::device_span< int32_t const >, raft::device_span< int32_t const > > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, raft::random::RngState &rng_state, bool return_hops, bool with_replacement, prior_sources_behavior_t prior_sources_behavior, bool dedupe_sources, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > heterogeneous_uniform_neighbor_sample (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_type_view, raft::device_span< int32_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< raft::device_span< int32_t const > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, int32_t num_edge_types, sampling_flags_t sampling_flags, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > heterogeneous_uniform_neighbor_sample (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_type_view, raft::device_span< int32_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< raft::device_span< int32_t const > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, int32_t num_edge_types, sampling_flags_t sampling_flags, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > heterogeneous_biased_neighbor_sample (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_type_view, edge_property_view_t< int32_t, double const * > edge_bias_view, raft::device_span< int32_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< raft::device_span< int32_t const > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, int32_t num_edge_types, sampling_flags_t sampling_flags, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > heterogeneous_biased_neighbor_sample (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_type_view, edge_property_view_t< int32_t, float const * > edge_bias_view, raft::device_span< int32_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< raft::device_span< int32_t const > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, int32_t num_edge_types, sampling_flags_t sampling_flags, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > homogeneous_uniform_neighbor_sample (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_type_view, raft::device_span< int32_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< raft::device_span< int32_t const > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, sampling_flags_t sampling_flags, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > homogeneous_uniform_neighbor_sample (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_type_view, raft::device_span< int32_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< raft::device_span< int32_t const > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, sampling_flags_t sampling_flags, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > homogeneous_biased_neighbor_sample (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_type_view, edge_property_view_t< int32_t, double const * > edge_bias_view, raft::device_span< int32_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< raft::device_span< int32_t const > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, sampling_flags_t sampling_flags, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > homogeneous_biased_neighbor_sample (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_type_view, edge_property_view_t< int32_t, float const * > edge_bias_view, raft::device_span< int32_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< raft::device_span< int32_t const > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, sampling_flags_t sampling_flags, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > uniform_neighbor_sample (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_type_view, raft::device_span< int64_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< std::tuple< raft::device_span< int32_t const >, raft::device_span< int32_t const > > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, raft::random::RngState &rng_state, bool return_hops, bool with_replacement, prior_sources_behavior_t prior_sources_behavior, bool dedupe_sources, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > uniform_neighbor_sample (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_type_view, raft::device_span< int64_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< std::tuple< raft::device_span< int32_t const >, raft::device_span< int32_t const > > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, raft::random::RngState &rng_state, bool return_hops, bool with_replacement, prior_sources_behavior_t prior_sources_behavior, bool dedupe_sources, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > biased_neighbor_sample (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_type_view, edge_property_view_t< int64_t, float const * > edge_bias_view, raft::device_span< int64_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< std::tuple< raft::device_span< int32_t const >, raft::device_span< int32_t const > > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, raft::random::RngState &rng_state, bool return_hops, bool with_replacement, prior_sources_behavior_t prior_sources_behavior, bool dedupe_sources, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > biased_neighbor_sample (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_type_view, edge_property_view_t< int64_t, double const * > edge_bias_view, raft::device_span< int64_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< std::tuple< raft::device_span< int32_t const >, raft::device_span< int32_t const > > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, raft::random::RngState &rng_state, bool return_hops, bool with_replacement, prior_sources_behavior_t prior_sources_behavior, bool dedupe_sources, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > heterogeneous_uniform_neighbor_sample (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_type_view, raft::device_span< int64_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< raft::device_span< int32_t const > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, int32_t num_edge_types, sampling_flags_t sampling_flags, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > heterogeneous_uniform_neighbor_sample (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_type_view, raft::device_span< int64_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< raft::device_span< int32_t const > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, int32_t num_edge_types, sampling_flags_t sampling_flags, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > heterogeneous_biased_neighbor_sample (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_type_view, edge_property_view_t< int64_t, double const * > edge_bias_view, raft::device_span< int64_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< raft::device_span< int32_t const > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, int32_t num_edge_types, sampling_flags_t sampling_flags, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > heterogeneous_biased_neighbor_sample (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_type_view, edge_property_view_t< int64_t, float const * > edge_bias_view, raft::device_span< int64_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< raft::device_span< int32_t const > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, int32_t num_edge_types, sampling_flags_t sampling_flags, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > homogeneous_uniform_neighbor_sample (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_type_view, raft::device_span< int64_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< raft::device_span< int32_t const > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, sampling_flags_t sampling_flags, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > homogeneous_uniform_neighbor_sample (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_type_view, raft::device_span< int64_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< raft::device_span< int32_t const > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, sampling_flags_t sampling_flags, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > homogeneous_biased_neighbor_sample (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_type_view, edge_property_view_t< int64_t, double const * > edge_bias_view, raft::device_span< int64_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< raft::device_span< int32_t const > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, sampling_flags_t sampling_flags, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > homogeneous_biased_neighbor_sample (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_type_view, edge_property_view_t< int64_t, float const * > edge_bias_view, raft::device_span< int64_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< raft::device_span< int32_t const > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, sampling_flags_t sampling_flags, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > uniform_neighbor_sample (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_type_view, raft::device_span< int32_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< std::tuple< raft::device_span< int32_t const >, raft::device_span< int32_t const > > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, raft::random::RngState &rng_state, bool return_hops, bool with_replacement, prior_sources_behavior_t prior_sources_behavior, bool dedupe_sources, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > uniform_neighbor_sample (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_type_view, raft::device_span< int32_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< std::tuple< raft::device_span< int32_t const >, raft::device_span< int32_t const > > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, raft::random::RngState &rng_state, bool return_hops, bool with_replacement, prior_sources_behavior_t prior_sources_behavior, bool dedupe_sources, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > biased_neighbor_sample (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_type_view, edge_property_view_t< int32_t, float const * > edge_bias_view, raft::device_span< int32_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< std::tuple< raft::device_span< int32_t const >, raft::device_span< int32_t const > > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, raft::random::RngState &rng_state, bool return_hops, bool with_replacement, prior_sources_behavior_t prior_sources_behavior, bool dedupe_sources, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > biased_neighbor_sample (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_type_view, edge_property_view_t< int32_t, double const * > edge_bias_view, raft::device_span< int32_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< std::tuple< raft::device_span< int32_t const >, raft::device_span< int32_t const > > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, raft::random::RngState &rng_state, bool return_hops, bool with_replacement, prior_sources_behavior_t prior_sources_behavior, bool dedupe_sources, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > heterogeneous_uniform_neighbor_sample (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_type_view, raft::device_span< int32_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< raft::device_span< int32_t const > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, int32_t num_edge_types, sampling_flags_t sampling_flags, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > heterogeneous_uniform_neighbor_sample (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_type_view, raft::device_span< int32_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< raft::device_span< int32_t const > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, int32_t num_edge_types, sampling_flags_t sampling_flags, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > heterogeneous_biased_neighbor_sample (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_type_view, edge_property_view_t< int32_t, double const * > edge_bias_view, raft::device_span< int32_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< raft::device_span< int32_t const > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, int32_t num_edge_types, sampling_flags_t sampling_flags, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > heterogeneous_biased_neighbor_sample (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_type_view, edge_property_view_t< int32_t, float const * > edge_bias_view, raft::device_span< int32_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< raft::device_span< int32_t const > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, int32_t num_edge_types, sampling_flags_t sampling_flags, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > homogeneous_uniform_neighbor_sample (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_type_view, raft::device_span< int32_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< raft::device_span< int32_t const > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, sampling_flags_t sampling_flags, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > homogeneous_uniform_neighbor_sample (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_type_view, raft::device_span< int32_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< raft::device_span< int32_t const > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, sampling_flags_t sampling_flags, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > homogeneous_biased_neighbor_sample (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_type_view, edge_property_view_t< int32_t, double const * > edge_bias_view, raft::device_span< int32_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< raft::device_span< int32_t const > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, sampling_flags_t sampling_flags, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > homogeneous_biased_neighbor_sample (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_type_view, edge_property_view_t< int32_t, float const * > edge_bias_view, raft::device_span< int32_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< raft::device_span< int32_t const > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, sampling_flags_t sampling_flags, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > uniform_neighbor_sample (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_type_view, raft::device_span< int64_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< std::tuple< raft::device_span< int32_t const >, raft::device_span< int32_t const > > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, raft::random::RngState &rng_state, bool return_hops, bool with_replacement, prior_sources_behavior_t prior_sources_behavior, bool dedupe_sources, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > uniform_neighbor_sample (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_type_view, raft::device_span< int64_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< std::tuple< raft::device_span< int32_t const >, raft::device_span< int32_t const > > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, raft::random::RngState &rng_state, bool return_hops, bool with_replacement, prior_sources_behavior_t prior_sources_behavior, bool dedupe_sources, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > biased_neighbor_sample (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_type_view, edge_property_view_t< int64_t, float const * > edge_bias_view, raft::device_span< int64_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< std::tuple< raft::device_span< int32_t const >, raft::device_span< int32_t const > > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, raft::random::RngState &rng_state, bool return_hops, bool with_replacement, prior_sources_behavior_t prior_sources_behavior, bool dedupe_sources, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > biased_neighbor_sample (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_type_view, edge_property_view_t< int64_t, double const * > edge_bias_view, raft::device_span< int64_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< std::tuple< raft::device_span< int32_t const >, raft::device_span< int32_t const > > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, raft::random::RngState &rng_state, bool return_hops, bool with_replacement, prior_sources_behavior_t prior_sources_behavior, bool dedupe_sources, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > heterogeneous_uniform_neighbor_sample (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_type_view, raft::device_span< int64_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< raft::device_span< int32_t const > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, int32_t num_edge_types, sampling_flags_t sampling_flags, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > heterogeneous_uniform_neighbor_sample (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_type_view, raft::device_span< int64_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< raft::device_span< int32_t const > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, int32_t num_edge_types, sampling_flags_t sampling_flags, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > heterogeneous_biased_neighbor_sample (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_type_view, edge_property_view_t< int64_t, double const * > edge_bias_view, raft::device_span< int64_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< raft::device_span< int32_t const > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, int32_t num_edge_types, sampling_flags_t sampling_flags, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > heterogeneous_biased_neighbor_sample (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_type_view, edge_property_view_t< int64_t, float const * > edge_bias_view, raft::device_span< int64_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< raft::device_span< int32_t const > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, int32_t num_edge_types, sampling_flags_t sampling_flags, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > homogeneous_uniform_neighbor_sample (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_type_view, raft::device_span< int64_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< raft::device_span< int32_t const > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, sampling_flags_t sampling_flags, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > homogeneous_uniform_neighbor_sample (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_type_view, raft::device_span< int64_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< raft::device_span< int32_t const > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, sampling_flags_t sampling_flags, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > homogeneous_biased_neighbor_sample (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_type_view, edge_property_view_t< int64_t, double const * > edge_bias_view, raft::device_span< int64_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< raft::device_span< int32_t const > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, sampling_flags_t sampling_flags, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > homogeneous_biased_neighbor_sample (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_type_view, edge_property_view_t< int64_t, float const * > edge_bias_view, raft::device_span< int64_t const > starting_vertices, std::optional< raft::device_span< int32_t const > > starting_vertex_labels, std::optional< raft::device_span< int32_t const > > label_to_output_comm_rank, raft::host_span< int32_t const > fan_out, sampling_flags_t sampling_flags, bool do_expensive_check)

template<typename vertex_t, typename index_t> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>, rmm::device_uvector<index_t>> convert_paths_to_coo(raft::handle_t const &handle, index_t coalesced_sz_v, index_t num_paths, rmm::device_buffer &&d_coalesced_v, rmm::device_buffer &&d_sizes)#

returns the COO format (src_vector, dst_vector) from the random walks (RW) paths.

Template Parameters:

vertex_t – Type of vertex indices.
index_t – Type used to store indexing and sizes.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
coalesced_sz_v – coalesced vertex vector size.
num_paths – number of paths.
d_coalesced_v – coalesced vertex buffer.
d_sizes – paths size buffer.

Returns:

tuple of (src_vertex_vector, dst_Vertex_vector, path_offsets), where path_offsets are the offsets where the COO set of each path starts.

template<typename index_t> std::tuple<rmm::device_uvector<index_t>, rmm::device_uvector<index_t>, rmm::device_uvector<index_t>> query_rw_sizes_offsets(raft::handle_t const &handle, index_t num_paths, index_t const *ptr_d_sizes)#

returns additional RW information on vertex paths offsets and weight path sizes and offsets, for the coalesced case (the padded case does not need or provide this information)

Template Parameters:

index_t – Type used to store indexing and sizes.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
num_paths – number of paths.
ptr_d_sizes – sizes of vertex paths.

Returns:

tuple of (vertex_path_offsets, weight_path_sizes, weight_path_offsets), where offsets are exclusive scan of corresponding sizes.

template std::tuple< rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > > > uniform_random_walks (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, raft::device_span< int32_t const > start_vertices, size_t max_length)

template std::tuple< rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > > > uniform_random_walks (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, raft::device_span< int32_t const > start_vertices, size_t max_length)

template std::tuple< rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > > > biased_random_walks (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, true > const &graph_view, edge_property_view_t< int32_t, float const * > edge_weight_view, raft::device_span< int32_t const > start_vertices, size_t max_length)

template std::tuple< rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > > > biased_random_walks (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, true > const &graph_view, edge_property_view_t< int32_t, double const * > edge_weight_view, raft::device_span< int32_t const > start_vertices, size_t max_length)

template std::tuple< rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > > > node2vec_random_walks (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, raft::device_span< int32_t const > start_vertices, size_t max_length, float p, float q)

template std::tuple< rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > > > node2vec_random_walks (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, raft::device_span< int32_t const > start_vertices, size_t max_length, double p, double q)

template std::tuple< rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > > > uniform_random_walks (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, raft::device_span< int64_t const > start_vertices, size_t max_length)

template std::tuple< rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > > > uniform_random_walks (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, raft::device_span< int64_t const > start_vertices, size_t max_length)

template std::tuple< rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > > > biased_random_walks (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, true > const &graph_view, edge_property_view_t< int64_t, float const * > edge_weight_view, raft::device_span< int64_t const > start_vertices, size_t max_length)

template std::tuple< rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > > > biased_random_walks (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, true > const &graph_view, edge_property_view_t< int64_t, double const * > edge_weight_view, raft::device_span< int64_t const > start_vertices, size_t max_length)

template std::tuple< rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > > > node2vec_random_walks (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, raft::device_span< int64_t const > start_vertices, size_t max_length, float p, float q)

template std::tuple< rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > > > node2vec_random_walks (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, raft::device_span< int64_t const > start_vertices, size_t max_length, double p, double q)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< float >, rmm::device_uvector< int32_t > > random_walks (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &gview, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, int32_t const *ptr_d_start, int32_t num_paths, int32_t max_depth, bool use_padding, std::unique_ptr< sampling_params_t > sampling_strategy)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< float >, rmm::device_uvector< int64_t > > random_walks (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &gview, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, int64_t const *ptr_d_start, int64_t num_paths, int64_t max_depth, bool use_padding, std::unique_ptr< sampling_params_t > sampling_strategy)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< double >, rmm::device_uvector< int32_t > > random_walks (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &gview, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, int32_t const *ptr_d_start, int32_t num_paths, int32_t max_depth, bool use_padding, std::unique_ptr< sampling_params_t > sampling_strategy)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< double >, rmm::device_uvector< int64_t > > random_walks (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &gview, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, int64_t const *ptr_d_start, int64_t num_paths, int64_t max_depth, bool use_padding, std::unique_ptr< sampling_params_t > sampling_strategy)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t > > convert_paths_to_coo (raft::handle_t const &handle, int32_t coalesced_sz_v, int32_t num_paths, rmm::device_buffer &&d_coalesced_v, rmm::device_buffer &&d_sizes)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, rmm::device_uvector< int64_t > > convert_paths_to_coo (raft::handle_t const &handle, int64_t coalesced_sz_v, int64_t num_paths, rmm::device_buffer &&d_coalesced_v, rmm::device_buffer &&d_sizes)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t > > query_rw_sizes_offsets (raft::handle_t const &handle, int32_t num_paths, int32_t const *ptr_d_sizes)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t > > query_rw_sizes_offsets (raft::handle_t const &handle, int64_t num_paths, int64_t const *ptr_d_sizes)

template std::tuple< rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > > > uniform_random_walks (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, raft::device_span< int32_t const > start_vertices, size_t max_length)

template std::tuple< rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > > > uniform_random_walks (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, raft::device_span< int32_t const > start_vertices, size_t max_length)

template std::tuple< rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > > > biased_random_walks (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, false > const &graph_view, edge_property_view_t< int32_t, float const * > edge_weight_view, raft::device_span< int32_t const > start_vertices, size_t max_length)

template std::tuple< rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > > > biased_random_walks (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, false > const &graph_view, edge_property_view_t< int32_t, double const * > edge_weight_view, raft::device_span< int32_t const > start_vertices, size_t max_length)

template std::tuple< rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > > > node2vec_random_walks (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, raft::device_span< int32_t const > start_vertices, size_t max_length, float p, float q)

template std::tuple< rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > > > node2vec_random_walks (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, raft::device_span< int32_t const > start_vertices, size_t max_length, double p, double q)

template std::tuple< rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > > > uniform_random_walks (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, raft::device_span< int64_t const > start_vertices, size_t max_length)

template std::tuple< rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > > > uniform_random_walks (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, raft::device_span< int64_t const > start_vertices, size_t max_length)

template std::tuple< rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > > > biased_random_walks (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, false > const &graph_view, edge_property_view_t< int64_t, float const * > edge_weight_view, raft::device_span< int64_t const > start_vertices, size_t max_length)

template std::tuple< rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > > > biased_random_walks (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, false > const &graph_view, edge_property_view_t< int64_t, double const * > edge_weight_view, raft::device_span< int64_t const > start_vertices, size_t max_length)

template std::tuple< rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > > > node2vec_random_walks (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, raft::device_span< int64_t const > start_vertices, size_t max_length, float p, float q)

template std::tuple< rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > > > node2vec_random_walks (raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, raft::device_span< int64_t const > start_vertices, size_t max_length, double p, double q)

template<typename vertex_t, typename weight_t, typename edge_id_t, typename edge_type_t> std::tuple<std::optional<rmm::device_uvector<vertex_t>>, rmm::device_uvector<size_t>, rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<weight_t>>, std::optional<rmm::device_uvector<edge_id_t>>, std::optional<rmm::device_uvector<edge_type_t>>, std::optional<rmm::device_uvector<size_t>>, rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<size_t>>> renumber_and_compress_sampled_edgelist(raft::handle_t const &handle, rmm::device_uvector<vertex_t> &&edgelist_srcs, rmm::device_uvector<vertex_t> &&edgelist_dsts, std::optional<rmm::device_uvector<weight_t>> &&edgelist_weights, std::optional<rmm::device_uvector<edge_id_t>> &&edgelist_edge_ids, std::optional<rmm::device_uvector<edge_type_t>> &&edgelist_edge_types, std::optional<rmm::device_uvector<int32_t>> &&edgelist_hops, std::optional<raft::device_span<vertex_t const>> seed_vertices, std::optional<raft::device_span<size_t const>> seed_vertex_label_offsets, std::optional<raft::device_span<size_t const>> edgelist_label_offsets, size_t num_labels, size_t num_hops, bool src_is_major, bool compress_per_hop, bool doubly_compress, bool do_expensive_check)#

template<typename vertex_t, typename weight_t, typename edge_id_t, typename edge_type_t> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<weight_t>>, std::optional<rmm::device_uvector<edge_id_t>>, std::optional<rmm::device_uvector<edge_type_t>>, std::optional<rmm::device_uvector<size_t>>, rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<size_t>>> renumber_and_sort_sampled_edgelist(raft::handle_t const &handle, rmm::device_uvector<vertex_t> &&edgelist_srcs, rmm::device_uvector<vertex_t> &&edgelist_dsts, std::optional<rmm::device_uvector<weight_t>> &&edgelist_weights, std::optional<rmm::device_uvector<edge_id_t>> &&edgelist_edge_ids, std::optional<rmm::device_uvector<edge_type_t>> &&edgelist_edge_types, std::optional<rmm::device_uvector<int32_t>> &&edgelist_hops, std::optional<raft::device_span<vertex_t const>> seed_vertices, std::optional<raft::device_span<size_t const>> seed_vertex_label_offsets, std::optional<raft::device_span<size_t const>> edgelist_label_offsets, size_t num_labels, size_t num_hops, bool src_is_major, bool do_expensive_check)#

template<typename vertex_t, typename weight_t, typename edge_id_t, typename edge_type_t> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<weight_t>>, std::optional<rmm::device_uvector<edge_id_t>>, std::optional<rmm::device_uvector<size_t>>, rmm::device_uvector<vertex_t>, rmm::device_uvector<size_t>, std::optional<rmm::device_uvector<edge_id_t>>, std::optional<rmm::device_uvector<size_t>>> heterogeneous_renumber_and_sort_sampled_edgelist(raft::handle_t const &handle, rmm::device_uvector<vertex_t> &&edgelist_srcs, rmm::device_uvector<vertex_t> &&edgelist_dsts, std::optional<rmm::device_uvector<weight_t>> &&edgelist_weights, std::optional<rmm::device_uvector<edge_id_t>> &&edgelist_edge_ids, std::optional<rmm::device_uvector<edge_type_t>> &&edgelist_edge_types, std::optional<rmm::device_uvector<int32_t>> &&edgelist_hops, std::optional<raft::device_span<vertex_t const>> seed_vertices, std::optional<raft::device_span<size_t const>> seed_vertex_label_offsets, std::optional<raft::device_span<size_t const>> edgelist_label_offsets, raft::device_span<vertex_t const> vertex_type_offsets, size_t num_labels, size_t num_hops, size_t num_vertex_types, size_t num_edge_types, bool src_is_major, bool do_expensive_check)#

template<typename vertex_t, typename weight_t, typename edge_id_t, typename edge_type_t> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<weight_t>>, std::optional<rmm::device_uvector<edge_id_t>>, std::optional<rmm::device_uvector<edge_type_t>>, std::optional<rmm::device_uvector<size_t>>> sort_sampled_edgelist(raft::handle_t const &handle, rmm::device_uvector<vertex_t> &&edgelist_srcs, rmm::device_uvector<vertex_t> &&edgelist_dsts, std::optional<rmm::device_uvector<weight_t>> &&edgelist_weights, std::optional<rmm::device_uvector<edge_id_t>> &&edgelist_edge_ids, std::optional<rmm::device_uvector<edge_type_t>> &&edgelist_edge_types, std::optional<rmm::device_uvector<int32_t>> &&edgelist_hops, std::optional<raft::device_span<size_t const>> edgelist_label_offsets, size_t num_labels, size_t num_hops, bool src_is_major, bool do_expensive_check)#

template std::tuple< std::optional< rmm::device_uvector< int32_t > >, rmm::device_uvector< size_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< size_t > > > renumber_and_compress_sampled_edgelist (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&edgelist_srcs, rmm::device_uvector< int32_t > &&edgelist_dsts, std::optional< rmm::device_uvector< float > > &&edgelist_weights, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types, std::optional< rmm::device_uvector< int32_t > > &&edgelist_hops, std::optional< raft::device_span< int32_t const > > seed_vertices, std::optional< raft::device_span< size_t const > > seed_vertex_label_offsets, std::optional< raft::device_span< size_t const > > edgelist_label_offsets, size_t num_labels, size_t num_hops, bool src_is_major, bool compress_per_hop, bool doubly_compress, bool do_expensive_check)

template std::tuple< std::optional< rmm::device_uvector< int32_t > >, rmm::device_uvector< size_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< size_t > > > renumber_and_compress_sampled_edgelist (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&edgelist_srcs, rmm::device_uvector< int32_t > &&edgelist_dsts, std::optional< rmm::device_uvector< double > > &&edgelist_weights, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types, std::optional< rmm::device_uvector< int32_t > > &&edgelist_hops, std::optional< raft::device_span< int32_t const > > seed_vertices, std::optional< raft::device_span< size_t const > > seed_vertex_label_offsets, std::optional< raft::device_span< size_t const > > edgelist_label_offsets, size_t num_labels, size_t num_hops, bool src_is_major, bool compress_per_hop, bool doubly_compress, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< size_t > > > renumber_and_sort_sampled_edgelist (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&edgelist_srcs, rmm::device_uvector< int32_t > &&edgelist_dsts, std::optional< rmm::device_uvector< float > > &&edgelist_weights, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types, std::optional< rmm::device_uvector< int32_t > > &&edgelist_hops, std::optional< raft::device_span< int32_t const > > seed_vertices, std::optional< raft::device_span< size_t const > > seed_vertex_label_offsets, std::optional< raft::device_span< size_t const > > edgelist_label_offsets, size_t num_labels, size_t num_hops, bool src_is_major, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< size_t > > > renumber_and_sort_sampled_edgelist (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&edgelist_srcs, rmm::device_uvector< int32_t > &&edgelist_dsts, std::optional< rmm::device_uvector< double > > &&edgelist_weights, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types, std::optional< rmm::device_uvector< int32_t > > &&edgelist_hops, std::optional< raft::device_span< int32_t const > > seed_vertices, std::optional< raft::device_span< size_t const > > seed_vertex_label_offsets, std::optional< raft::device_span< size_t const > > edgelist_label_offsets, size_t num_labels, size_t num_hops, bool src_is_major, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > >, rmm::device_uvector< int32_t >, rmm::device_uvector< size_t >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > heterogeneous_renumber_and_sort_sampled_edgelist (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&edgelist_srcs, rmm::device_uvector< int32_t > &&edgelist_dsts, std::optional< rmm::device_uvector< float > > &&edgelist_weights, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types, std::optional< rmm::device_uvector< int32_t > > &&edgelist_hops, std::optional< raft::device_span< int32_t const > > seed_vertices, std::optional< raft::device_span< size_t const > > seed_vertex_label_offsets, std::optional< raft::device_span< size_t const > > edgelist_label_offsets, raft::device_span< int32_t const > vertex_type_offsets, size_t num_labels, size_t num_hops, size_t num_vertex_types, size_t num_edge_types, bool src_is_major, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > >, rmm::device_uvector< int32_t >, rmm::device_uvector< size_t >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > heterogeneous_renumber_and_sort_sampled_edgelist (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&edgelist_srcs, rmm::device_uvector< int32_t > &&edgelist_dsts, std::optional< rmm::device_uvector< double > > &&edgelist_weights, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types, std::optional< rmm::device_uvector< int32_t > > &&edgelist_hops, std::optional< raft::device_span< int32_t const > > seed_vertices, std::optional< raft::device_span< size_t const > > seed_vertex_label_offsets, std::optional< raft::device_span< size_t const > > edgelist_label_offsets, raft::device_span< int32_t const > vertex_type_offsets, size_t num_labels, size_t num_hops, size_t num_vertex_types, size_t num_edge_types, bool src_is_major, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > sort_sampled_edgelist (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&edgelist_srcs, rmm::device_uvector< int32_t > &&edgelist_dsts, std::optional< rmm::device_uvector< float > > &&edgelist_weights, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types, std::optional< rmm::device_uvector< int32_t > > &&edgelist_hops, std::optional< raft::device_span< size_t const > > edgelist_label_offsets, size_t num_labels, size_t num_hops, bool src_is_major, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > sort_sampled_edgelist (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&edgelist_srcs, rmm::device_uvector< int32_t > &&edgelist_dsts, std::optional< rmm::device_uvector< double > > &&edgelist_weights, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types, std::optional< rmm::device_uvector< int32_t > > &&edgelist_hops, std::optional< raft::device_span< size_t const > > edgelist_label_offsets, size_t num_labels, size_t num_hops, bool src_is_major, bool do_expensive_check)

template std::tuple< std::optional< rmm::device_uvector< int64_t > >, rmm::device_uvector< size_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< size_t > > > renumber_and_compress_sampled_edgelist (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&edgelist_srcs, rmm::device_uvector< int64_t > &&edgelist_dsts, std::optional< rmm::device_uvector< float > > &&edgelist_weights, std::optional< rmm::device_uvector< int64_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types, std::optional< rmm::device_uvector< int32_t > > &&edgelist_hops, std::optional< raft::device_span< int64_t const > > seed_vertices, std::optional< raft::device_span< size_t const > > seed_vertex_label_offsets, std::optional< raft::device_span< size_t const > > edgelist_label_offsets, size_t num_labels, size_t num_hops, bool src_is_major, bool compress_per_hop, bool doubly_compress, bool do_expensive_check)

template std::tuple< std::optional< rmm::device_uvector< int64_t > >, rmm::device_uvector< size_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< size_t > > > renumber_and_compress_sampled_edgelist (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&edgelist_srcs, rmm::device_uvector< int64_t > &&edgelist_dsts, std::optional< rmm::device_uvector< double > > &&edgelist_weights, std::optional< rmm::device_uvector< int64_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types, std::optional< rmm::device_uvector< int32_t > > &&edgelist_hops, std::optional< raft::device_span< int64_t const > > seed_vertices, std::optional< raft::device_span< size_t const > > seed_vertex_label_offsets, std::optional< raft::device_span< size_t const > > edgelist_label_offsets, size_t num_labels, size_t num_hops, bool src_is_major, bool compress_per_hop, bool doubly_compress, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< size_t > > > renumber_and_sort_sampled_edgelist (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&edgelist_srcs, rmm::device_uvector< int64_t > &&edgelist_dsts, std::optional< rmm::device_uvector< float > > &&edgelist_weights, std::optional< rmm::device_uvector< int64_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types, std::optional< rmm::device_uvector< int32_t > > &&edgelist_hops, std::optional< raft::device_span< int64_t const > > seed_vertices, std::optional< raft::device_span< size_t const > > seed_vertex_label_offsets, std::optional< raft::device_span< size_t const > > edgelist_label_offsets, size_t num_labels, size_t num_hops, bool src_is_major, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< size_t > > > renumber_and_sort_sampled_edgelist (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&edgelist_srcs, rmm::device_uvector< int64_t > &&edgelist_dsts, std::optional< rmm::device_uvector< double > > &&edgelist_weights, std::optional< rmm::device_uvector< int64_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types, std::optional< rmm::device_uvector< int32_t > > &&edgelist_hops, std::optional< raft::device_span< int64_t const > > seed_vertices, std::optional< raft::device_span< size_t const > > seed_vertex_label_offsets, std::optional< raft::device_span< size_t const > > edgelist_label_offsets, size_t num_labels, size_t num_hops, bool src_is_major, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< size_t > >, rmm::device_uvector< int64_t >, rmm::device_uvector< size_t >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< size_t > > > heterogeneous_renumber_and_sort_sampled_edgelist (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&edgelist_srcs, rmm::device_uvector< int64_t > &&edgelist_dsts, std::optional< rmm::device_uvector< float > > &&edgelist_weights, std::optional< rmm::device_uvector< int64_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types, std::optional< rmm::device_uvector< int32_t > > &&edgelist_hops, std::optional< raft::device_span< int64_t const > > seed_vertices, std::optional< raft::device_span< size_t const > > seed_vertex_label_offsets, std::optional< raft::device_span< size_t const > > edgelist_label_offsets, raft::device_span< int64_t const > vertex_type_offsets, size_t num_labels, size_t num_hops, size_t num_vertex_types, size_t num_edge_types, bool src_is_major, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< size_t > >, rmm::device_uvector< int64_t >, rmm::device_uvector< size_t >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< size_t > > > heterogeneous_renumber_and_sort_sampled_edgelist (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&edgelist_srcs, rmm::device_uvector< int64_t > &&edgelist_dsts, std::optional< rmm::device_uvector< double > > &&edgelist_weights, std::optional< rmm::device_uvector< int64_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types, std::optional< rmm::device_uvector< int32_t > > &&edgelist_hops, std::optional< raft::device_span< int64_t const > > seed_vertices, std::optional< raft::device_span< size_t const > > seed_vertex_label_offsets, std::optional< raft::device_span< size_t const > > edgelist_label_offsets, raft::device_span< int64_t const > vertex_type_offsets, size_t num_labels, size_t num_hops, size_t num_vertex_types, size_t num_edge_types, bool src_is_major, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > sort_sampled_edgelist (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&edgelist_srcs, rmm::device_uvector< int64_t > &&edgelist_dsts, std::optional< rmm::device_uvector< float > > &&edgelist_weights, std::optional< rmm::device_uvector< int64_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types, std::optional< rmm::device_uvector< int32_t > > &&edgelist_hops, std::optional< raft::device_span< size_t const > > edgelist_label_offsets, size_t num_labels, size_t num_hops, bool src_is_major, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > sort_sampled_edgelist (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&edgelist_srcs, rmm::device_uvector< int64_t > &&edgelist_dsts, std::optional< rmm::device_uvector< double > > &&edgelist_weights, std::optional< rmm::device_uvector< int64_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types, std::optional< rmm::device_uvector< int32_t > > &&edgelist_hops, std::optional< raft::device_span< size_t const > > edgelist_label_offsets, size_t num_labels, size_t num_hops, bool src_is_major, bool do_expensive_check)

template<typename vertex_t, typename edge_t, typename weight_t, bool store_transposed, bool multi_gpu> std::tuple<graph_t<vertex_t, edge_t, store_transposed, multi_gpu>, std::optional<edge_property_t<graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu>, weight_t>>, std::optional<rmm::device_uvector<vertex_t>>> coarsen_graph(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu> const &graph_view, std::optional<edge_property_view_t<edge_t, weight_t const*>> edge_weight_view, vertex_t const *labels, bool renumber, bool do_expensive_check = false)#

Compute the coarsened graph.

Aggregates the vertices with the same label to a new vertex in the output coarsened graph. Multi-edges in the coarsened graph are collapsed to a single edge with its weight equal to the sum of multi-edge weights.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
weight_t – Type of edge weights. Needs to be a floating point type.
store_transposed – Flag indicating whether to use sources (if false) or destinations (if true) as major indices in storing edges using a 2D sparse matrix.
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false) or multi-GPU (true).

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Graph view object of the input graph to be coarsened.
edge_weight_view – Optional view object holding edge weights for graph_view.
labels – Vertex labels (assigned to this process in multi-GPU) to be used in coarsening.
renumber – Flag indicating whether to renumber vertices or not (must be true if multi_gpu is true). Setting renumber to false is highly discouraged except for testing as this negatively affects the performance and memory footprint. If renumber is set to true, labels should have only non-negative integers and the number of vertices is assumed to be the maximum element in labels (reduced over the entire set of GPUs in multi-GPU) + 1. This may produce many isolated vertices if the number of unique elements (over the entire set of GPUs in multi-GPU) in labels is much smaller than the assumed number of vertices.
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

Tuple of the coarsened graph, coarsened graph edge weights (if edge_weight_view.has_value() is true) and the renumber map (if renumber is true).

template std::tuple< graph_t< int32_t, int32_t, true, true >, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, true, true >, float > >, std::optional< rmm::device_uvector< int32_t > > > coarsen_graph (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, int32_t const *labels, bool renumber, bool do_expensive_check)

template std::tuple< graph_t< int32_t, int32_t, false, true >, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, false, true >, float > >, std::optional< rmm::device_uvector< int32_t > > > coarsen_graph (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, int32_t const *labels, bool renumber, bool do_expensive_check)

template std::tuple< graph_t< int32_t, int32_t, true, true >, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, true, true >, double > >, std::optional< rmm::device_uvector< int32_t > > > coarsen_graph (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, int32_t const *labels, bool renumber, bool do_expensive_check)

template std::tuple< graph_t< int32_t, int32_t, false, true >, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, false, true >, double > >, std::optional< rmm::device_uvector< int32_t > > > coarsen_graph (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, int32_t const *labels, bool renumber, bool do_expensive_check)

template std::tuple< graph_t< int64_t, int64_t, true, true >, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, true, true >, float > >, std::optional< rmm::device_uvector< int64_t > > > coarsen_graph (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, int64_t const *labels, bool renumber, bool do_expensive_check)

template std::tuple< graph_t< int64_t, int64_t, false, true >, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, false, true >, float > >, std::optional< rmm::device_uvector< int64_t > > > coarsen_graph (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, int64_t const *labels, bool renumber, bool do_expensive_check)

template std::tuple< graph_t< int64_t, int64_t, true, true >, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, true, true >, double > >, std::optional< rmm::device_uvector< int64_t > > > coarsen_graph (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, int64_t const *labels, bool renumber, bool do_expensive_check)

template std::tuple< graph_t< int64_t, int64_t, false, true >, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, false, true >, double > >, std::optional< rmm::device_uvector< int64_t > > > coarsen_graph (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, int64_t const *labels, bool renumber, bool do_expensive_check)

template std::tuple< graph_t< int32_t, int32_t, true, false >, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, true, false >, float > >, std::optional< rmm::device_uvector< int32_t > > > coarsen_graph (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, int32_t const *labels, bool renumber, bool do_expensive_check)

template std::tuple< graph_t< int32_t, int32_t, false, false >, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, false, false >, float > >, std::optional< rmm::device_uvector< int32_t > > > coarsen_graph (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, int32_t const *labels, bool renumber, bool do_expensive_check)

template std::tuple< graph_t< int32_t, int32_t, true, false >, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, true, false >, double > >, std::optional< rmm::device_uvector< int32_t > > > coarsen_graph (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, int32_t const *labels, bool renumber, bool do_expensive_check)

template std::tuple< graph_t< int32_t, int32_t, false, false >, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, false, false >, double > >, std::optional< rmm::device_uvector< int32_t > > > coarsen_graph (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, int32_t const *labels, bool renumber, bool do_expensive_check)

template std::tuple< graph_t< int64_t, int64_t, true, false >, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, true, false >, float > >, std::optional< rmm::device_uvector< int64_t > > > coarsen_graph (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, int64_t const *labels, bool renumber, bool do_expensive_check)

template std::tuple< graph_t< int64_t, int64_t, false, false >, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, false, false >, float > >, std::optional< rmm::device_uvector< int64_t > > > coarsen_graph (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, int64_t const *labels, bool renumber, bool do_expensive_check)

template std::tuple< graph_t< int64_t, int64_t, true, false >, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, true, false >, double > >, std::optional< rmm::device_uvector< int64_t > > > coarsen_graph (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, int64_t const *labels, bool renumber, bool do_expensive_check)

template std::tuple< graph_t< int64_t, int64_t, false, false >, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, false, false >, double > >, std::optional< rmm::device_uvector< int64_t > > > coarsen_graph (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, int64_t const *labels, bool renumber, bool do_expensive_check)

template<typename vertex_t, typename edge_t, typename weight_t, typename edge_id_t, typename edge_type_t, bool store_transposed, bool multi_gpu> std::tuple<cugraph::graph_t<vertex_t, edge_t, store_transposed, multi_gpu>, std::optional<edge_property_t<graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu>, weight_t>>, std::optional<edge_property_t<graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu>, edge_id_t>>, std::optional<edge_property_t<graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu>, edge_type_t>>, std::optional<rmm::device_uvector<vertex_t>>> create_graph_from_edgelist(raft::handle_t const &handle, std::optional<rmm::device_uvector<vertex_t>> &&vertices, rmm::device_uvector<vertex_t> &&edgelist_srcs, rmm::device_uvector<vertex_t> &&edgelist_dsts, std::optional<rmm::device_uvector<weight_t>> &&edgelist_weights, std::optional<rmm::device_uvector<edge_id_t>> &&edgelist_edge_ids, std::optional<rmm::device_uvector<edge_type_t>> &&edgelist_edge_types, graph_properties_t graph_properties, bool renumber, bool do_expensive_check)#

create a graph from (the optional vertex list and) the given edge list (with optional edge IDs and types).

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
weight_t – Type of edge weight. Needs to be floating point type
edge_id_t – Type of edge id. Needs to be an integral type
edge_type_t – Type of edge type. Needs to be an integral type, currently only int32_t is supported
store_transposed – Flag indicating whether to use sources (if false) or destinations (if true) as major indices in storing edges using a 2D sparse matrix.
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false) or multi-GPU (true).

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
vertices – If valid, part of the entire set of vertices in the graph to be renumbered. This parameter can be used to include isolated vertices. If renumber is false and vertices is valid, vertices elements should be consecutive integers starting from 0. If multi-GPU, applying the compute_gpu_id_from_vertex_t to every vertex should return the local GPU ID for this function to work (vertices should be pre-shuffled).
edgelist_srcs – Vector of edge source vertex IDs. If multi-GPU, applying the compute_gpu_id_from_ext_edge_endpoints_t to every edge should return the local GPU ID for this function to work (edges should be pre-shuffled).
edgelist_dsts – Vector of edge destination vertex IDs.
edgelist_weights – Vector of weight values for edges
edgelist_edge_ids – Vector of edge_id values for edges
edgelist_edge_types – Vector of edge_type values for edges
graph_properties – Properties of the graph represented by the input (optional vertex list and) edge list.
renumber – Flag indicating whether to renumber vertices or not (must be true if multi_gpu is true).
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

Tuple of the generated graph and optional edge_property_t objects storing the provided edge properties and a renumber map (if renumber is true).

template<typename vertex_t, typename edge_t, typename weight_t, typename edge_id_t, typename edge_type_t, bool store_transposed, bool multi_gpu> std::tuple<cugraph::graph_t<vertex_t, edge_t, store_transposed, multi_gpu>, std::optional<edge_property_t<graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu>, weight_t>>, std::optional<edge_property_t<graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu>, edge_id_t>>, std::optional<edge_property_t<graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu>, edge_type_t>>, std::optional<rmm::device_uvector<vertex_t>>> create_graph_from_edgelist(raft::handle_t const &handle, std::optional<rmm::device_uvector<vertex_t>> &&vertices, std::vector<rmm::device_uvector<vertex_t>> &&edgelist_srcs, std::vector<rmm::device_uvector<vertex_t>> &&edgelist_dsts, std::optional<std::vector<rmm::device_uvector<weight_t>>> &&edgelist_weights, std::optional<std::vector<rmm::device_uvector<edge_id_t>>> &&edgelist_edge_ids, std::optional<std::vector<rmm::device_uvector<edge_type_t>>> &&edgelist_edge_types, graph_properties_t graph_properties, bool renumber, bool do_expensive_check)#

create a graph from (the optional vertex list and) the given edge list (with optional edge IDs and types).

This version takes edge list in multiple chunks (e.g. edge data from multiple files).

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
weight_t – Type of edge weight. Needs to be floating point type
edge_id_t – Type of edge id. Needs to be an integral type
edge_type_t – Type of edge type. Needs to be an integral type, currently only int32_t is supported
store_transposed – Flag indicating whether to use sources (if false) or destinations (if true) as major indices in storing edges using a 2D sparse matrix.
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false) or multi-GPU (true).

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
vertices – If valid, part of the entire set of vertices in the graph to be renumbered. This parameter can be used to include isolated vertices. If renumber is false and vertices is valid, vertices elements should be consecutive integers starting from 0. If multi-GPU, applying the compute_gpu_id_from_vertex_t to every vertex should return the local GPU ID for this function to work (vertices should be pre-shuffled).
edgelist_srcs – Vectors of edge source vertex IDs. If multi-GPU, applying the compute_gpu_id_from_ext_edge_endpoints_t to every edge should return the local GPU ID for this function to work (edges should be pre-shuffled).
edgelist_dsts – Vectors of edge destination vertex IDs.
edgelist_weights – Vectors of weight values for edges
edgelist_edge_ids – Vectors of edge_id values for edges
edgelist_edge_types – Vectors of edge_type values for edges
graph_properties – Properties of the graph represented by the input (optional vertex list and) edge list.
renumber – Flag indicating whether to renumber vertices or not (must be true if multi_gpu is true).
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

Tuple of the generated graph and optional edge_property_t objects storing the provided edge properties and a renumber map (if renumber is true).

template std::tuple< cugraph::graph_t< int32_t, int32_t, false, true >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, false, true >, float > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, false, true >, int32_t > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, false, true >, int32_t > >, std::optional< rmm::device_uvector< int32_t > > > create_graph_from_edgelist< int32_t, int32_t, float, int32_t, int32_t, false, true > (raft::handle_t const &handle, std::optional< rmm::device_uvector< int32_t > > &&vertices, rmm::device_uvector< int32_t > &&edgelist_srcs, rmm::device_uvector< int32_t > &&edgelist_dsts, std::optional< rmm::device_uvector< float > > &&edgelist_weights, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types, graph_properties_t graph_properties, bool renumber, bool do_expensive_check)

template std::tuple< cugraph::graph_t< int32_t, int32_t, true, true >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, true, true >, float > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, true, true >, int32_t > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, true, true >, int32_t > >, std::optional< rmm::device_uvector< int32_t > > > create_graph_from_edgelist< int32_t, int32_t, float, int32_t, int32_t, true, true > (raft::handle_t const &handle, std::optional< rmm::device_uvector< int32_t > > &&vertices, rmm::device_uvector< int32_t > &&edgelist_srcs, rmm::device_uvector< int32_t > &&edgelist_dsts, std::optional< rmm::device_uvector< float > > &&edgelist_weights, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types, graph_properties_t graph_properties, bool renumber, bool do_expensive_check)

template std::tuple< cugraph::graph_t< int32_t, int32_t, false, true >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, false, true >, double > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, false, true >, int32_t > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, false, true >, int32_t > >, std::optional< rmm::device_uvector< int32_t > > > create_graph_from_edgelist< int32_t, int32_t, double, int32_t, int32_t, false, true > (raft::handle_t const &handle, std::optional< rmm::device_uvector< int32_t > > &&vertices, rmm::device_uvector< int32_t > &&edgelist_srcs, rmm::device_uvector< int32_t > &&edgelist_dsts, std::optional< rmm::device_uvector< double > > &&edgelist_weights, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types, graph_properties_t graph_properties, bool renumber, bool do_expensive_check)

template std::tuple< cugraph::graph_t< int32_t, int32_t, true, true >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, true, true >, double > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, true, true >, int32_t > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, true, true >, int32_t > >, std::optional< rmm::device_uvector< int32_t > > > create_graph_from_edgelist< int32_t, int32_t, double, int32_t, int32_t, true, true > (raft::handle_t const &handle, std::optional< rmm::device_uvector< int32_t > > &&vertices, rmm::device_uvector< int32_t > &&edgelist_srcs, rmm::device_uvector< int32_t > &&edgelist_dsts, std::optional< rmm::device_uvector< double > > &&edgelist_weights, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types, graph_properties_t graph_properties, bool renumber, bool do_expensive_check)

template std::tuple< cugraph::graph_t< int32_t, int32_t, false, true >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, false, true >, float > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, false, true >, int32_t > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, false, true >, int32_t > >, std::optional< rmm::device_uvector< int32_t > > > create_graph_from_edgelist< int32_t, int32_t, float, int32_t, int32_t, false, true > (raft::handle_t const &handle, std::optional< rmm::device_uvector< int32_t > > &&vertices, std::vector< rmm::device_uvector< int32_t > > &&edgelist_srcs, std::vector< rmm::device_uvector< int32_t > > &&edgelist_dsts, std::optional< std::vector< rmm::device_uvector< float > > > &&edgelist_weights, std::optional< std::vector< rmm::device_uvector< int32_t > > > &&edgelist_edge_ids, std::optional< std::vector< rmm::device_uvector< int32_t > > > &&edgelist_edge_types, graph_properties_t graph_properties, bool renumber, bool do_expensive_check)

template std::tuple< cugraph::graph_t< int32_t, int32_t, true, true >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, true, true >, float > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, true, true >, int32_t > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, true, true >, int32_t > >, std::optional< rmm::device_uvector< int32_t > > > create_graph_from_edgelist< int32_t, int32_t, float, int32_t, int32_t, true, true > (raft::handle_t const &handle, std::optional< rmm::device_uvector< int32_t > > &&vertices, std::vector< rmm::device_uvector< int32_t > > &&edgelist_srcs, std::vector< rmm::device_uvector< int32_t > > &&edgelist_dsts, std::optional< std::vector< rmm::device_uvector< float > > > &&edgelist_weights, std::optional< std::vector< rmm::device_uvector< int32_t > > > &&edgelist_edge_ids, std::optional< std::vector< rmm::device_uvector< int32_t > > > &&edgelist_edge_types, graph_properties_t graph_properties, bool renumber, bool do_expensive_check)

template std::tuple< cugraph::graph_t< int32_t, int32_t, false, true >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, false, true >, double > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, false, true >, int32_t > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, false, true >, int32_t > >, std::optional< rmm::device_uvector< int32_t > > > create_graph_from_edgelist< int32_t, int32_t, double, int32_t, int32_t, false, true > (raft::handle_t const &handle, std::optional< rmm::device_uvector< int32_t > > &&vertices, std::vector< rmm::device_uvector< int32_t > > &&edgelist_srcs, std::vector< rmm::device_uvector< int32_t > > &&edgelist_dsts, std::optional< std::vector< rmm::device_uvector< double > > > &&edgelist_weights, std::optional< std::vector< rmm::device_uvector< int32_t > > > &&edgelist_edge_ids, std::optional< std::vector< rmm::device_uvector< int32_t > > > &&edgelist_edge_types, graph_properties_t graph_properties, bool renumber, bool do_expensive_check)

template std::tuple< cugraph::graph_t< int32_t, int32_t, true, true >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, true, true >, double > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, true, true >, int32_t > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, true, true >, int32_t > >, std::optional< rmm::device_uvector< int32_t > > > create_graph_from_edgelist< int32_t, int32_t, double, int32_t, int32_t, true, true > (raft::handle_t const &handle, std::optional< rmm::device_uvector< int32_t > > &&vertices, std::vector< rmm::device_uvector< int32_t > > &&edgelist_srcs, std::vector< rmm::device_uvector< int32_t > > &&edgelist_dsts, std::optional< std::vector< rmm::device_uvector< double > > > &&edgelist_weights, std::optional< std::vector< rmm::device_uvector< int32_t > > > &&edgelist_edge_ids, std::optional< std::vector< rmm::device_uvector< int32_t > > > &&edgelist_edge_types, graph_properties_t graph_properties, bool renumber, bool do_expensive_check)

template std::tuple< cugraph::graph_t< int64_t, int64_t, false, true >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, false, true >, float > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, false, true >, int64_t > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, false, true >, int32_t > >, std::optional< rmm::device_uvector< int64_t > > > create_graph_from_edgelist< int64_t, int64_t, float, int64_t, int32_t, false, true > (raft::handle_t const &handle, std::optional< rmm::device_uvector< int64_t > > &&vertices, rmm::device_uvector< int64_t > &&edgelist_srcs, rmm::device_uvector< int64_t > &&edgelist_dsts, std::optional< rmm::device_uvector< float > > &&edgelist_weights, std::optional< rmm::device_uvector< int64_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types, graph_properties_t graph_properties, bool renumber, bool do_expensive_check)

template std::tuple< cugraph::graph_t< int64_t, int64_t, true, true >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, true, true >, float > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, true, true >, int64_t > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, true, true >, int32_t > >, std::optional< rmm::device_uvector< int64_t > > > create_graph_from_edgelist< int64_t, int64_t, float, int64_t, int32_t, true, true > (raft::handle_t const &handle, std::optional< rmm::device_uvector< int64_t > > &&vertices, rmm::device_uvector< int64_t > &&edgelist_srcs, rmm::device_uvector< int64_t > &&edgelist_dsts, std::optional< rmm::device_uvector< float > > &&edgelist_weights, std::optional< rmm::device_uvector< int64_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types, graph_properties_t graph_properties, bool renumber, bool do_expensive_check)

template std::tuple< cugraph::graph_t< int64_t, int64_t, false, true >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, false, true >, double > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, false, true >, int64_t > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, false, true >, int32_t > >, std::optional< rmm::device_uvector< int64_t > > > create_graph_from_edgelist< int64_t, int64_t, double, int64_t, int32_t, false, true > (raft::handle_t const &handle, std::optional< rmm::device_uvector< int64_t > > &&vertices, rmm::device_uvector< int64_t > &&edgelist_srcs, rmm::device_uvector< int64_t > &&edgelist_dsts, std::optional< rmm::device_uvector< double > > &&edgelist_weights, std::optional< rmm::device_uvector< int64_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types, graph_properties_t graph_properties, bool renumber, bool do_expensive_check)

template std::tuple< cugraph::graph_t< int64_t, int64_t, true, true >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, true, true >, double > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, true, true >, int64_t > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, true, true >, int32_t > >, std::optional< rmm::device_uvector< int64_t > > > create_graph_from_edgelist< int64_t, int64_t, double, int64_t, int32_t, true, true > (raft::handle_t const &handle, std::optional< rmm::device_uvector< int64_t > > &&vertices, rmm::device_uvector< int64_t > &&edgelist_srcs, rmm::device_uvector< int64_t > &&edgelist_dsts, std::optional< rmm::device_uvector< double > > &&edgelist_weights, std::optional< rmm::device_uvector< int64_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types, graph_properties_t graph_properties, bool renumber, bool do_expensive_check)

template std::tuple< cugraph::graph_t< int64_t, int64_t, false, true >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, false, true >, float > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, false, true >, int64_t > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, false, true >, int32_t > >, std::optional< rmm::device_uvector< int64_t > > > create_graph_from_edgelist< int64_t, int64_t, float, int64_t, int32_t, false, true > (raft::handle_t const &handle, std::optional< rmm::device_uvector< int64_t > > &&vertices, std::vector< rmm::device_uvector< int64_t > > &&edgelist_srcs, std::vector< rmm::device_uvector< int64_t > > &&edgelist_dsts, std::optional< std::vector< rmm::device_uvector< float > > > &&edgelist_weights, std::optional< std::vector< rmm::device_uvector< int64_t > > > &&edgelist_edge_ids, std::optional< std::vector< rmm::device_uvector< int32_t > > > &&edgelist_edge_types, graph_properties_t graph_properties, bool renumber, bool do_expensive_check)

template std::tuple< cugraph::graph_t< int64_t, int64_t, true, true >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, true, true >, float > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, true, true >, int64_t > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, true, true >, int32_t > >, std::optional< rmm::device_uvector< int64_t > > > create_graph_from_edgelist< int64_t, int64_t, float, int64_t, int32_t, true, true > (raft::handle_t const &handle, std::optional< rmm::device_uvector< int64_t > > &&vertices, std::vector< rmm::device_uvector< int64_t > > &&edgelist_srcs, std::vector< rmm::device_uvector< int64_t > > &&edgelist_dsts, std::optional< std::vector< rmm::device_uvector< float > > > &&edgelist_weights, std::optional< std::vector< rmm::device_uvector< int64_t > > > &&edgelist_edge_ids, std::optional< std::vector< rmm::device_uvector< int32_t > > > &&edgelist_edge_types, graph_properties_t graph_properties, bool renumber, bool do_expensive_check)

template std::tuple< cugraph::graph_t< int64_t, int64_t, false, true >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, false, true >, double > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, false, true >, int64_t > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, false, true >, int32_t > >, std::optional< rmm::device_uvector< int64_t > > > create_graph_from_edgelist< int64_t, int64_t, double, int64_t, int32_t, false, true > (raft::handle_t const &handle, std::optional< rmm::device_uvector< int64_t > > &&vertices, std::vector< rmm::device_uvector< int64_t > > &&edgelist_srcs, std::vector< rmm::device_uvector< int64_t > > &&edgelist_dsts, std::optional< std::vector< rmm::device_uvector< double > > > &&edgelist_weights, std::optional< std::vector< rmm::device_uvector< int64_t > > > &&edgelist_edge_ids, std::optional< std::vector< rmm::device_uvector< int32_t > > > &&edgelist_edge_types, graph_properties_t graph_properties, bool renumber, bool do_expensive_check)

template std::tuple< cugraph::graph_t< int64_t, int64_t, true, true >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, true, true >, double > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, true, true >, int64_t > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, true, true >, int32_t > >, std::optional< rmm::device_uvector< int64_t > > > create_graph_from_edgelist< int64_t, int64_t, double, int64_t, int32_t, true, true > (raft::handle_t const &handle, std::optional< rmm::device_uvector< int64_t > > &&vertices, std::vector< rmm::device_uvector< int64_t > > &&edgelist_srcs, std::vector< rmm::device_uvector< int64_t > > &&edgelist_dsts, std::optional< std::vector< rmm::device_uvector< double > > > &&edgelist_weights, std::optional< std::vector< rmm::device_uvector< int64_t > > > &&edgelist_edge_ids, std::optional< std::vector< rmm::device_uvector< int32_t > > > &&edgelist_edge_types, graph_properties_t graph_properties, bool renumber, bool do_expensive_check)

template std::tuple< cugraph::graph_t< int32_t, int32_t, false, false >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, false, false >, float > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, false, false >, int32_t > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, false, false >, int32_t > >, std::optional< rmm::device_uvector< int32_t > > > create_graph_from_edgelist< int32_t, int32_t, float, int32_t, int32_t, false, false > (raft::handle_t const &handle, std::optional< rmm::device_uvector< int32_t > > &&vertices, rmm::device_uvector< int32_t > &&edgelist_srcs, rmm::device_uvector< int32_t > &&edgelist_dsts, std::optional< rmm::device_uvector< float > > &&edgelist_weights, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types, graph_properties_t graph_properties, bool renumber, bool do_expensive_check)

template std::tuple< cugraph::graph_t< int32_t, int32_t, true, false >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, true, false >, float > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, true, false >, int32_t > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, true, false >, int32_t > >, std::optional< rmm::device_uvector< int32_t > > > create_graph_from_edgelist< int32_t, int32_t, float, int32_t, int32_t, true, false > (raft::handle_t const &handle, std::optional< rmm::device_uvector< int32_t > > &&vertices, rmm::device_uvector< int32_t > &&edgelist_srcs, rmm::device_uvector< int32_t > &&edgelist_dsts, std::optional< rmm::device_uvector< float > > &&edgelist_weights, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types, graph_properties_t graph_properties, bool renumber, bool do_expensive_check)

template std::tuple< cugraph::graph_t< int32_t, int32_t, false, false >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, false, false >, double > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, false, false >, int32_t > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, false, false >, int32_t > >, std::optional< rmm::device_uvector< int32_t > > > create_graph_from_edgelist< int32_t, int32_t, double, int32_t, int32_t, false, false > (raft::handle_t const &handle, std::optional< rmm::device_uvector< int32_t > > &&vertices, rmm::device_uvector< int32_t > &&edgelist_srcs, rmm::device_uvector< int32_t > &&edgelist_dsts, std::optional< rmm::device_uvector< double > > &&edgelist_weights, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types, graph_properties_t graph_properties, bool renumber, bool do_expensive_check)

template std::tuple< cugraph::graph_t< int32_t, int32_t, true, false >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, true, false >, double > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, true, false >, int32_t > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, true, false >, int32_t > >, std::optional< rmm::device_uvector< int32_t > > > create_graph_from_edgelist< int32_t, int32_t, double, int32_t, int32_t, true, false > (raft::handle_t const &handle, std::optional< rmm::device_uvector< int32_t > > &&vertices, rmm::device_uvector< int32_t > &&edgelist_srcs, rmm::device_uvector< int32_t > &&edgelist_dsts, std::optional< rmm::device_uvector< double > > &&edgelist_weights, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types, graph_properties_t graph_properties, bool renumber, bool do_expensive_check)

template std::tuple< cugraph::graph_t< int32_t, int32_t, false, false >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, false, false >, float > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, false, false >, int32_t > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, false, false >, int32_t > >, std::optional< rmm::device_uvector< int32_t > > > create_graph_from_edgelist< int32_t, int32_t, float, int32_t, int32_t, false, false > (raft::handle_t const &handle, std::optional< rmm::device_uvector< int32_t > > &&vertices, std::vector< rmm::device_uvector< int32_t > > &&edgelist_srcs, std::vector< rmm::device_uvector< int32_t > > &&edgelist_dsts, std::optional< std::vector< rmm::device_uvector< float > > > &&edgelist_weights, std::optional< std::vector< rmm::device_uvector< int32_t > > > &&edgelist_edge_ids, std::optional< std::vector< rmm::device_uvector< int32_t > > > &&edgelist_edge_types, graph_properties_t graph_properties, bool renumber, bool do_expensive_check)

template std::tuple< cugraph::graph_t< int32_t, int32_t, true, false >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, true, false >, float > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, true, false >, int32_t > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, true, false >, int32_t > >, std::optional< rmm::device_uvector< int32_t > > > create_graph_from_edgelist< int32_t, int32_t, float, int32_t, int32_t, true, false > (raft::handle_t const &handle, std::optional< rmm::device_uvector< int32_t > > &&vertices, std::vector< rmm::device_uvector< int32_t > > &&edgelist_srcs, std::vector< rmm::device_uvector< int32_t > > &&edgelist_dsts, std::optional< std::vector< rmm::device_uvector< float > > > &&edgelist_weights, std::optional< std::vector< rmm::device_uvector< int32_t > > > &&edgelist_edge_ids, std::optional< std::vector< rmm::device_uvector< int32_t > > > &&edgelist_edge_types, graph_properties_t graph_properties, bool renumber, bool do_expensive_check)

template std::tuple< cugraph::graph_t< int32_t, int32_t, false, false >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, false, false >, double > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, false, false >, int32_t > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, false, false >, int32_t > >, std::optional< rmm::device_uvector< int32_t > > > create_graph_from_edgelist< int32_t, int32_t, double, int32_t, int32_t, false, false > (raft::handle_t const &handle, std::optional< rmm::device_uvector< int32_t > > &&vertices, std::vector< rmm::device_uvector< int32_t > > &&edgelist_srcs, std::vector< rmm::device_uvector< int32_t > > &&edgelist_dsts, std::optional< std::vector< rmm::device_uvector< double > > > &&edgelist_weights, std::optional< std::vector< rmm::device_uvector< int32_t > > > &&edgelist_edge_ids, std::optional< std::vector< rmm::device_uvector< int32_t > > > &&edgelist_edge_types, graph_properties_t graph_properties, bool renumber, bool do_expensive_check)

template std::tuple< cugraph::graph_t< int32_t, int32_t, true, false >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, true, false >, double > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, true, false >, int32_t > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int32_t, int32_t, true, false >, int32_t > >, std::optional< rmm::device_uvector< int32_t > > > create_graph_from_edgelist< int32_t, int32_t, double, int32_t, int32_t, true, false > (raft::handle_t const &handle, std::optional< rmm::device_uvector< int32_t > > &&vertices, std::vector< rmm::device_uvector< int32_t > > &&edgelist_srcs, std::vector< rmm::device_uvector< int32_t > > &&edgelist_dsts, std::optional< std::vector< rmm::device_uvector< double > > > &&edgelist_weights, std::optional< std::vector< rmm::device_uvector< int32_t > > > &&edgelist_edge_ids, std::optional< std::vector< rmm::device_uvector< int32_t > > > &&edgelist_edge_types, graph_properties_t graph_properties, bool renumber, bool do_expensive_check)

template std::tuple< cugraph::graph_t< int64_t, int64_t, false, false >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, false, false >, float > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, false, false >, int64_t > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, false, false >, int32_t > >, std::optional< rmm::device_uvector< int64_t > > > create_graph_from_edgelist< int64_t, int64_t, float, int64_t, int32_t, false, false > (raft::handle_t const &handle, std::optional< rmm::device_uvector< int64_t > > &&vertices, rmm::device_uvector< int64_t > &&edgelist_srcs, rmm::device_uvector< int64_t > &&edgelist_dsts, std::optional< rmm::device_uvector< float > > &&edgelist_weights, std::optional< rmm::device_uvector< int64_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types, graph_properties_t graph_properties, bool renumber, bool do_expensive_check)

template std::tuple< cugraph::graph_t< int64_t, int64_t, true, false >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, true, false >, float > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, true, false >, int64_t > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, true, false >, int32_t > >, std::optional< rmm::device_uvector< int64_t > > > create_graph_from_edgelist< int64_t, int64_t, float, int64_t, int32_t, true, false > (raft::handle_t const &handle, std::optional< rmm::device_uvector< int64_t > > &&vertices, rmm::device_uvector< int64_t > &&edgelist_srcs, rmm::device_uvector< int64_t > &&edgelist_dsts, std::optional< rmm::device_uvector< float > > &&edgelist_weights, std::optional< rmm::device_uvector< int64_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types, graph_properties_t graph_properties, bool renumber, bool do_expensive_check)

template std::tuple< cugraph::graph_t< int64_t, int64_t, false, false >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, false, false >, double > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, false, false >, int64_t > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, false, false >, int32_t > >, std::optional< rmm::device_uvector< int64_t > > > create_graph_from_edgelist< int64_t, int64_t, double, int64_t, int32_t, false, false > (raft::handle_t const &handle, std::optional< rmm::device_uvector< int64_t > > &&vertices, rmm::device_uvector< int64_t > &&edgelist_srcs, rmm::device_uvector< int64_t > &&edgelist_dsts, std::optional< rmm::device_uvector< double > > &&edgelist_weights, std::optional< rmm::device_uvector< int64_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types, graph_properties_t graph_properties, bool renumber, bool do_expensive_check)

template std::tuple< cugraph::graph_t< int64_t, int64_t, true, false >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, true, false >, double > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, true, false >, int64_t > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, true, false >, int32_t > >, std::optional< rmm::device_uvector< int64_t > > > create_graph_from_edgelist< int64_t, int64_t, double, int64_t, int32_t, true, false > (raft::handle_t const &handle, std::optional< rmm::device_uvector< int64_t > > &&vertices, rmm::device_uvector< int64_t > &&edgelist_srcs, rmm::device_uvector< int64_t > &&edgelist_dsts, std::optional< rmm::device_uvector< double > > &&edgelist_weights, std::optional< rmm::device_uvector< int64_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types, graph_properties_t graph_properties, bool renumber, bool do_expensive_check)

template std::tuple< cugraph::graph_t< int64_t, int64_t, false, false >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, false, false >, float > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, false, false >, int64_t > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, false, false >, int32_t > >, std::optional< rmm::device_uvector< int64_t > > > create_graph_from_edgelist< int64_t, int64_t, float, int64_t, int32_t, false, false > (raft::handle_t const &handle, std::optional< rmm::device_uvector< int64_t > > &&vertices, std::vector< rmm::device_uvector< int64_t > > &&edgelist_srcs, std::vector< rmm::device_uvector< int64_t > > &&edgelist_dsts, std::optional< std::vector< rmm::device_uvector< float > > > &&edgelist_weights, std::optional< std::vector< rmm::device_uvector< int64_t > > > &&edgelist_edge_ids, std::optional< std::vector< rmm::device_uvector< int32_t > > > &&edgelist_edge_types, graph_properties_t graph_properties, bool renumber, bool do_expensive_check)

template std::tuple< cugraph::graph_t< int64_t, int64_t, true, false >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, true, false >, float > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, true, false >, int64_t > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, true, false >, int32_t > >, std::optional< rmm::device_uvector< int64_t > > > create_graph_from_edgelist< int64_t, int64_t, float, int64_t, int32_t, true, false > (raft::handle_t const &handle, std::optional< rmm::device_uvector< int64_t > > &&vertices, std::vector< rmm::device_uvector< int64_t > > &&edgelist_srcs, std::vector< rmm::device_uvector< int64_t > > &&edgelist_dsts, std::optional< std::vector< rmm::device_uvector< float > > > &&edgelist_weights, std::optional< std::vector< rmm::device_uvector< int64_t > > > &&edgelist_edge_ids, std::optional< std::vector< rmm::device_uvector< int32_t > > > &&edgelist_edge_types, graph_properties_t graph_properties, bool renumber, bool do_expensive_check)

template std::tuple< cugraph::graph_t< int64_t, int64_t, false, false >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, false, false >, double > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, false, false >, int64_t > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, false, false >, int32_t > >, std::optional< rmm::device_uvector< int64_t > > > create_graph_from_edgelist< int64_t, int64_t, double, int64_t, int32_t, false, false > (raft::handle_t const &handle, std::optional< rmm::device_uvector< int64_t > > &&vertices, std::vector< rmm::device_uvector< int64_t > > &&edgelist_srcs, std::vector< rmm::device_uvector< int64_t > > &&edgelist_dsts, std::optional< std::vector< rmm::device_uvector< double > > > &&edgelist_weights, std::optional< std::vector< rmm::device_uvector< int64_t > > > &&edgelist_edge_ids, std::optional< std::vector< rmm::device_uvector< int32_t > > > &&edgelist_edge_types, graph_properties_t graph_properties, bool renumber, bool do_expensive_check)

template std::tuple< cugraph::graph_t< int64_t, int64_t, true, false >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, true, false >, double > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, true, false >, int64_t > >, std::optional< cugraph::edge_property_t< cugraph::graph_view_t< int64_t, int64_t, true, false >, int32_t > >, std::optional< rmm::device_uvector< int64_t > > > create_graph_from_edgelist< int64_t, int64_t, double, int64_t, int32_t, true, false > (raft::handle_t const &handle, std::optional< rmm::device_uvector< int64_t > > &&vertices, std::vector< rmm::device_uvector< int64_t > > &&edgelist_srcs, std::vector< rmm::device_uvector< int64_t > > &&edgelist_dsts, std::optional< std::vector< rmm::device_uvector< double > > > &&edgelist_weights, std::optional< std::vector< rmm::device_uvector< int64_t > > > &&edgelist_edge_ids, std::optional< std::vector< rmm::device_uvector< int32_t > > > &&edgelist_edge_types, graph_properties_t graph_properties, bool renumber, bool do_expensive_check)

Construct the edge list from the graph view object.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
weight_t – Type of edge weights. Needs to be a floating point type.
edge_type_t – Type of edge types. Needs to be an integral type.
store_transposed – Flag indicating whether to use sources (if false) or destinations (if true) as major indices in storing edges using a 2D sparse matrix.
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false) or multi-GPU (true).

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Graph view object of the graph to be decompressed.
edge_weight_view – Optional view object holding edge weights for graph_view.
edge_id_view – Optional view object holding edge ids for graph_view.
edge_type_view – Optional view object holding edge types for graph_view.
renumber_map – If valid, return the renumbered edge list based on the provided renumber_map
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

Tuple of edge sources, destinations, (optional) edge weights (if edge_weight_view.has_value() is true) and (optional) edge ids (if edge_id_view.has_value() is true).

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > > > decompress_to_edgelist< int32_t, int32_t, float, int32_t, false, true > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_type_view, std::optional< raft::device_span< int32_t const > > renumber_map, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > > > decompress_to_edgelist< int32_t, int32_t, float, int32_t, true, true > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_type_view, std::optional< raft::device_span< int32_t const > > renumber_map, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > > > decompress_to_edgelist< int32_t, int32_t, double, int32_t, false, true > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_type_view, std::optional< raft::device_span< int32_t const > > renumber_map, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > > > decompress_to_edgelist< int32_t, int32_t, double, int32_t, true, true > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_type_view, std::optional< raft::device_span< int32_t const > > renumber_map, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > > > decompress_to_edgelist< int64_t, int64_t, float, int32_t, false, true > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_type_view, std::optional< raft::device_span< int64_t const > > renumber_map, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > > > decompress_to_edgelist< int64_t, int64_t, float, int32_t, true, true > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_type_view, std::optional< raft::device_span< int64_t const > > renumber_map, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > > > decompress_to_edgelist< int64_t, int64_t, double, int32_t, false, true > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_type_view, std::optional< raft::device_span< int64_t const > > renumber_map, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > > > decompress_to_edgelist< int64_t, int64_t, double, int32_t, true, true > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_type_view, std::optional< raft::device_span< int64_t const > > renumber_map, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > > > decompress_to_edgelist< int32_t, int32_t, float, int32_t, false, false > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_type_view, std::optional< raft::device_span< int32_t const > > renumber_map, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > > > decompress_to_edgelist< int32_t, int32_t, float, int32_t, true, false > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_type_view, std::optional< raft::device_span< int32_t const > > renumber_map, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > > > decompress_to_edgelist< int32_t, int32_t, double, int32_t, false, false > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_type_view, std::optional< raft::device_span< int32_t const > > renumber_map, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > > > decompress_to_edgelist< int32_t, int32_t, double, int32_t, true, false > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_type_view, std::optional< raft::device_span< int32_t const > > renumber_map, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > > > decompress_to_edgelist< int64_t, int64_t, float, int32_t, false, false > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_type_view, std::optional< raft::device_span< int64_t const > > renumber_map, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > > > decompress_to_edgelist< int64_t, int64_t, float, int32_t, true, false > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_type_view, std::optional< raft::device_span< int64_t const > > renumber_map, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > > > decompress_to_edgelist< int64_t, int64_t, double, int32_t, false, false > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_type_view, std::optional< raft::device_span< int64_t const > > renumber_map, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > > > decompress_to_edgelist< int64_t, int64_t, double, int32_t, true, false > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_type_view, std::optional< raft::device_span< int64_t const > > renumber_map, bool do_expensive_check)

template<typename vertex_t, typename edge_t, typename weight_t, bool store_transposed, bool multi_gpu> rmm::device_uvector<weight_t> compute_in_weight_sums(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu> const &graph_view, edge_property_view_t<edge_t, weight_t const*> edge_weight_view)#

Compute per-vertex incoming edge weight sums.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
weight_t – Type of edge weights. Needs to be a floating point type.
store_transposed – Flag indicating whether to use sources (if false) or destinations (if true) as major indices in storing edges using a 2D sparse matrix.
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false) or multi-GPU (true).

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Graph view object of the input graph to compute per-vertex incoming edge weight sums.
edge_weight_view – View object holding edge weights for graph_view.

Returns:

Incoming edge weight sums for each vertex.

template<typename vertex_t, typename edge_t, typename weight_t, bool store_transposed, bool multi_gpu> rmm::device_uvector<weight_t> compute_out_weight_sums(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu> const &graph_view, edge_property_view_t<edge_t, weight_t const*> edge_weight_view)#

Compute per-vertex outgoing edge weight sums.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
weight_t – Type of edge weights. Needs to be a floating point type.
store_transposed – Flag indicating whether to use sources (if false) or destinations (if true) as major indices in storing edges using a 2D sparse matrix.
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false) or multi-GPU (true).

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Graph view object of the input graph to compute per-vertex outgoing edge weight sums.
edge_weight_view – View object holding edge weights for graph_view.

Returns:

Outgoing edge weight sums for each vertex.

template<typename vertex_t, typename edge_t, typename weight_t, bool store_transposed, bool multi_gpu> weight_t compute_max_in_weight_sum(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu> const &graph_view, edge_property_view_t<edge_t, weight_t const*> edge_weight_view)#

Compute maximum per-vertex incoming edge weight sums.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
weight_t – Type of edge weights. Needs to be a floating point type.
store_transposed – Flag indicating whether to use sources (if false) or destinations (if true) as major indices in storing edges using a 2D sparse matrix.
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false) or multi-GPU (true).

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Graph view object of the input graph to compute the maximum per-vertex incoming edge weight sums.
edge_weight_view – View object holding edge weights for graph_view.

Returns:

Maximum per-vertex incoming edge weight sums.

template<typename vertex_t, typename edge_t, typename weight_t, bool store_transposed, bool multi_gpu> weight_t compute_max_out_weight_sum(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu> const &graph_view, edge_property_view_t<edge_t, weight_t const*> edge_weight_view)#

Compute maximum per-vertex outgoing edge weight sums.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
weight_t – Type of edge weights. Needs to be a floating point type.
store_transposed – Flag indicating whether to use sources (if false) or destinations (if true) as major indices in storing edges using a 2D sparse matrix.
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false) or multi-GPU (true).

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Graph view object of the input graph to compute the maximum per-vertex outgoing edge weight sums.
edge_weight_view – View object holding edge weights for graph_view.

Returns:

Maximum per-vertex outgoing edge weight sums.

template<typename vertex_t, typename edge_t, typename weight_t, bool store_transposed, bool multi_gpu> weight_t compute_total_edge_weight(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu> const &graph_view, edge_property_view_t<edge_t, weight_t const*> edge_weight_view)#

Sum the weights of the entire set of edges.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
weight_t – Type of edge weights. Needs to be a floating point type.
store_transposed – Flag indicating whether to use sources (if false) or destinations (if true) as major indices in storing edges using a 2D sparse matrix.
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false) or multi-GPU (true).

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Graph view object of the input graph to sum the edge weights.
edge_weight_view – View object holding edge weights for graph_view.

Returns:

Sum of the weights of the entire set of edges.

template rmm::device_uvector< float > compute_in_weight_sums< int32_t, int32_t, float, false, true > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, edge_property_view_t< int32_t, float const * > edge_weight_view)

template rmm::device_uvector< float > compute_in_weight_sums< int32_t, int32_t, float, true, true > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, true > const &graph_view, edge_property_view_t< int32_t, float const * > edge_weight_view)

template rmm::device_uvector< double > compute_in_weight_sums< int32_t, int32_t, double, false, true > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, edge_property_view_t< int32_t, double const * > edge_weight_view)

template rmm::device_uvector< double > compute_in_weight_sums< int32_t, int32_t, double, true, true > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, true > const &graph_view, edge_property_view_t< int32_t, double const * > edge_weight_view)

template rmm::device_uvector< float > compute_out_weight_sums< int32_t, int32_t, float, false, true > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, edge_property_view_t< int32_t, float const * > edge_weight_view)

template rmm::device_uvector< float > compute_out_weight_sums< int32_t, int32_t, float, true, true > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, true > const &graph_view, edge_property_view_t< int32_t, float const * > edge_weight_view)

template rmm::device_uvector< double > compute_out_weight_sums< int32_t, int32_t, double, false, true > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, edge_property_view_t< int32_t, double const * > edge_weight_view)

template rmm::device_uvector< double > compute_out_weight_sums< int32_t, int32_t, double, true, true > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, true > const &graph_view, edge_property_view_t< int32_t, double const * > edge_weight_view)

template float compute_max_in_weight_sum< int32_t, int32_t, float, false, true > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, edge_property_view_t< int32_t, float const * > edge_weight_view)

template float compute_max_in_weight_sum< int32_t, int32_t, float, true, true > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, true > const &graph_view, edge_property_view_t< int32_t, float const * > edge_weight_view)

template double compute_max_in_weight_sum< int32_t, int32_t, double, false, true > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, edge_property_view_t< int32_t, double const * > edge_weight_view)

template double compute_max_in_weight_sum< int32_t, int32_t, double, true, true > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, true > const &graph_view, edge_property_view_t< int32_t, double const * > edge_weight_view)

template float compute_max_out_weight_sum< int32_t, int32_t, float, false, true > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, edge_property_view_t< int32_t, float const * > edge_weight_view)

template float compute_max_out_weight_sum< int32_t, int32_t, float, true, true > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, true > const &graph_view, edge_property_view_t< int32_t, float const * > edge_weight_view)

template double compute_max_out_weight_sum< int32_t, int32_t, double, false, true > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, edge_property_view_t< int32_t, double const * > edge_weight_view)

template double compute_max_out_weight_sum< int32_t, int32_t, double, true, true > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, true > const &graph_view, edge_property_view_t< int32_t, double const * > edge_weight_view)

template float compute_total_edge_weight< int32_t, int32_t, float, false, true > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, edge_property_view_t< int32_t, float const * > edge_weight_view)

template float compute_total_edge_weight< int32_t, int32_t, float, true, true > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, true > const &graph_view, edge_property_view_t< int32_t, float const * > edge_weight_view)

template double compute_total_edge_weight< int32_t, int32_t, double, false, true > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, edge_property_view_t< int32_t, double const * > edge_weight_view)

template double compute_total_edge_weight< int32_t, int32_t, double, true, true > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, true > const &graph_view, edge_property_view_t< int32_t, double const * > edge_weight_view)

template rmm::device_uvector< float > compute_in_weight_sums< int64_t, int64_t, float, false, true > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, edge_property_view_t< int64_t, float const * > edge_weight_view)

template rmm::device_uvector< float > compute_in_weight_sums< int64_t, int64_t, float, true, true > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, true > const &graph_view, edge_property_view_t< int64_t, float const * > edge_weight_view)

template rmm::device_uvector< double > compute_in_weight_sums< int64_t, int64_t, double, false, true > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, edge_property_view_t< int64_t, double const * > edge_weight_view)

template rmm::device_uvector< double > compute_in_weight_sums< int64_t, int64_t, double, true, true > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, true > const &graph_view, edge_property_view_t< int64_t, double const * > edge_weight_view)

template rmm::device_uvector< float > compute_out_weight_sums< int64_t, int64_t, float, false, true > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, edge_property_view_t< int64_t, float const * > edge_weight_view)

template rmm::device_uvector< float > compute_out_weight_sums< int64_t, int64_t, float, true, true > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, true > const &graph_view, edge_property_view_t< int64_t, float const * > edge_weight_view)

template rmm::device_uvector< double > compute_out_weight_sums< int64_t, int64_t, double, false, true > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, edge_property_view_t< int64_t, double const * > edge_weight_view)

template rmm::device_uvector< double > compute_out_weight_sums< int64_t, int64_t, double, true, true > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, true > const &graph_view, edge_property_view_t< int64_t, double const * > edge_weight_view)

template float compute_max_in_weight_sum< int64_t, int64_t, float, false, true > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, edge_property_view_t< int64_t, float const * > edge_weight_view)

template float compute_max_in_weight_sum< int64_t, int64_t, float, true, true > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, true > const &graph_view, edge_property_view_t< int64_t, float const * > edge_weight_view)

template double compute_max_in_weight_sum< int64_t, int64_t, double, false, true > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, edge_property_view_t< int64_t, double const * > edge_weight_view)

template double compute_max_in_weight_sum< int64_t, int64_t, double, true, true > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, true > const &graph_view, edge_property_view_t< int64_t, double const * > edge_weight_view)

template float compute_max_out_weight_sum< int64_t, int64_t, float, false, true > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, edge_property_view_t< int64_t, float const * > edge_weight_view)

template float compute_max_out_weight_sum< int64_t, int64_t, float, true, true > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, true > const &graph_view, edge_property_view_t< int64_t, float const * > edge_weight_view)

template double compute_max_out_weight_sum< int64_t, int64_t, double, false, true > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, edge_property_view_t< int64_t, double const * > edge_weight_view)

template double compute_max_out_weight_sum< int64_t, int64_t, double, true, true > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, true > const &graph_view, edge_property_view_t< int64_t, double const * > edge_weight_view)

template float compute_total_edge_weight< int64_t, int64_t, float, false, true > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, edge_property_view_t< int64_t, float const * > edge_weight_view)

template float compute_total_edge_weight< int64_t, int64_t, float, true, true > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, true > const &graph_view, edge_property_view_t< int64_t, float const * > edge_weight_view)

template double compute_total_edge_weight< int64_t, int64_t, double, false, true > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, edge_property_view_t< int64_t, double const * > edge_weight_view)

template double compute_total_edge_weight< int64_t, int64_t, double, true, true > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, true > const &graph_view, edge_property_view_t< int64_t, double const * > edge_weight_view)

template rmm::device_uvector< float > compute_in_weight_sums< int32_t, int32_t, float, false, false > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, edge_property_view_t< int32_t, float const * > edge_weight_view)

template rmm::device_uvector< float > compute_in_weight_sums< int32_t, int32_t, float, true, false > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, false > const &graph_view, edge_property_view_t< int32_t, float const * > edge_weight_view)

template rmm::device_uvector< double > compute_in_weight_sums< int32_t, int32_t, double, false, false > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, edge_property_view_t< int32_t, double const * > edge_weight_view)

template rmm::device_uvector< double > compute_in_weight_sums< int32_t, int32_t, double, true, false > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, false > const &graph_view, edge_property_view_t< int32_t, double const * > edge_weight_view)

template rmm::device_uvector< float > compute_out_weight_sums< int32_t, int32_t, float, false, false > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, edge_property_view_t< int32_t, float const * > edge_weight_view)

template rmm::device_uvector< float > compute_out_weight_sums< int32_t, int32_t, float, true, false > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, false > const &graph_view, edge_property_view_t< int32_t, float const * > edge_weight_view)

template rmm::device_uvector< double > compute_out_weight_sums< int32_t, int32_t, double, false, false > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, edge_property_view_t< int32_t, double const * > edge_weight_view)

template rmm::device_uvector< double > compute_out_weight_sums< int32_t, int32_t, double, true, false > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, false > const &graph_view, edge_property_view_t< int32_t, double const * > edge_weight_view)

template float compute_max_in_weight_sum< int32_t, int32_t, float, false, false > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, edge_property_view_t< int32_t, float const * > edge_weight_view)

template float compute_max_in_weight_sum< int32_t, int32_t, float, true, false > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, false > const &graph_view, edge_property_view_t< int32_t, float const * > edge_weight_view)

template double compute_max_in_weight_sum< int32_t, int32_t, double, false, false > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, edge_property_view_t< int32_t, double const * > edge_weight_view)

template double compute_max_in_weight_sum< int32_t, int32_t, double, true, false > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, false > const &graph_view, edge_property_view_t< int32_t, double const * > edge_weight_view)

template float compute_max_out_weight_sum< int32_t, int32_t, float, false, false > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, edge_property_view_t< int32_t, float const * > edge_weight_view)

template float compute_max_out_weight_sum< int32_t, int32_t, float, true, false > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, false > const &graph_view, edge_property_view_t< int32_t, float const * > edge_weight_view)

template double compute_max_out_weight_sum< int32_t, int32_t, double, false, false > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, edge_property_view_t< int32_t, double const * > edge_weight_view)

template double compute_max_out_weight_sum< int32_t, int32_t, double, true, false > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, false > const &graph_view, edge_property_view_t< int32_t, double const * > edge_weight_view)

template float compute_total_edge_weight< int32_t, int32_t, float, false, false > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, edge_property_view_t< int32_t, float const * > edge_weight_view)

template float compute_total_edge_weight< int32_t, int32_t, float, true, false > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, false > const &graph_view, edge_property_view_t< int32_t, float const * > edge_weight_view)

template double compute_total_edge_weight< int32_t, int32_t, double, false, false > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, edge_property_view_t< int32_t, double const * > edge_weight_view)

template double compute_total_edge_weight< int32_t, int32_t, double, true, false > (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, false > const &graph_view, edge_property_view_t< int32_t, double const * > edge_weight_view)

template rmm::device_uvector< float > compute_in_weight_sums< int64_t, int64_t, float, false, false > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, edge_property_view_t< int64_t, float const * > edge_weight_view)

template rmm::device_uvector< float > compute_in_weight_sums< int64_t, int64_t, float, true, false > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, false > const &graph_view, edge_property_view_t< int64_t, float const * > edge_weight_view)

template rmm::device_uvector< double > compute_in_weight_sums< int64_t, int64_t, double, false, false > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, edge_property_view_t< int64_t, double const * > edge_weight_view)

template rmm::device_uvector< double > compute_in_weight_sums< int64_t, int64_t, double, true, false > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, false > const &graph_view, edge_property_view_t< int64_t, double const * > edge_weight_view)

template rmm::device_uvector< float > compute_out_weight_sums< int64_t, int64_t, float, false, false > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, edge_property_view_t< int64_t, float const * > edge_weight_view)

template rmm::device_uvector< float > compute_out_weight_sums< int64_t, int64_t, float, true, false > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, false > const &graph_view, edge_property_view_t< int64_t, float const * > edge_weight_view)

template rmm::device_uvector< double > compute_out_weight_sums< int64_t, int64_t, double, false, false > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, edge_property_view_t< int64_t, double const * > edge_weight_view)

template rmm::device_uvector< double > compute_out_weight_sums< int64_t, int64_t, double, true, false > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, false > const &graph_view, edge_property_view_t< int64_t, double const * > edge_weight_view)

template float compute_max_in_weight_sum< int64_t, int64_t, float, false, false > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, edge_property_view_t< int64_t, float const * > edge_weight_view)

template float compute_max_in_weight_sum< int64_t, int64_t, float, true, false > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, false > const &graph_view, edge_property_view_t< int64_t, float const * > edge_weight_view)

template double compute_max_in_weight_sum< int64_t, int64_t, double, false, false > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, edge_property_view_t< int64_t, double const * > edge_weight_view)

template double compute_max_in_weight_sum< int64_t, int64_t, double, true, false > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, false > const &graph_view, edge_property_view_t< int64_t, double const * > edge_weight_view)

template float compute_max_out_weight_sum< int64_t, int64_t, float, false, false > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, edge_property_view_t< int64_t, float const * > edge_weight_view)

template float compute_max_out_weight_sum< int64_t, int64_t, float, true, false > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, false > const &graph_view, edge_property_view_t< int64_t, float const * > edge_weight_view)

template double compute_max_out_weight_sum< int64_t, int64_t, double, false, false > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, edge_property_view_t< int64_t, double const * > edge_weight_view)

template double compute_max_out_weight_sum< int64_t, int64_t, double, true, false > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, false > const &graph_view, edge_property_view_t< int64_t, double const * > edge_weight_view)

template float compute_total_edge_weight< int64_t, int64_t, float, false, false > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, edge_property_view_t< int64_t, float const * > edge_weight_view)

template float compute_total_edge_weight< int64_t, int64_t, float, true, false > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, false > const &graph_view, edge_property_view_t< int64_t, float const * > edge_weight_view)

template double compute_total_edge_weight< int64_t, int64_t, double, false, false > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, edge_property_view_t< int64_t, double const * > edge_weight_view)

template double compute_total_edge_weight< int64_t, int64_t, double, true, false > (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, false > const &graph_view, edge_property_view_t< int64_t, double const * > edge_weight_view)

template<typename vertex_t, typename edge_t, typename weight_t, bool store_transposed, bool multi_gpu> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<weight_t>>, rmm::device_uvector<size_t>> extract_induced_subgraphs(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu> const &graph_view, std::optional<edge_property_view_t<edge_t, weight_t const*>> edge_weight_view, raft::device_span<size_t const> subgraph_offsets, raft::device_span<vertex_t const> subgraph_vertices, bool do_expensive_check = false)#

extract induced subgraph(s).

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
weight_t – Type of edge weights.
store_transposed – Flag indicating whether to use sources (if false) or destinations (if true) as major indices in storing edges using a 2D sparse matrix.
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false) or multi-GPU (true).

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Graph view object, we extract induced subgraphs from graph_view.
edge_weight_view – Optional view object holding edge weights for graph_view.
subgraph_offsets – Span pointing to subgraph vertex offsets
subgraph_vertices – Span pointing to subgraph vertices. subgraph_offsets and subgraph_vertices provide vertex sets (or local vertex sets in multi-GPU) for subgraph_offsets.size() - 1 subgraphs to extract. For the i’th subgraph to extract, one can extract the (local-)vertex set by accessing a subset of subgraph_vertices, where the range of the subset is [subgraph_offsetes[i], subgraph_offsets[i + 1]). In multi-GPU, the vertex set for each subgraph is distributed in multiple-GPUs and each GPU holds only the vertices that are local to the GPU.
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

Quadraplet of edge major (destination if store_transposed is true, source otherwise) vertices, edge minor (source if store_transposed is true, destination otherwise) vertices, edge weights (if edge_weight_view.has_value() is true), and edge offsets for each induced subgraphs (size == num_subgraphs + 1). The sizes of the edge major & minor vertices are edge_offsets[num_subgraphs].

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > >, rmm::device_uvector< size_t > > extract_induced_subgraphs (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, raft::device_span< size_t const > subgraph_offsets, raft::device_span< int32_t const > subgraph_vertices, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > >, rmm::device_uvector< size_t > > extract_induced_subgraphs (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, raft::device_span< size_t const > subgraph_offsets, raft::device_span< int32_t const > subgraph_vertices, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > >, rmm::device_uvector< size_t > > extract_induced_subgraphs (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, raft::device_span< size_t const > subgraph_offsets, raft::device_span< int64_t const > subgraph_vertices, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > >, rmm::device_uvector< size_t > > extract_induced_subgraphs (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, raft::device_span< size_t const > subgraph_offsets, raft::device_span< int64_t const > subgraph_vertices, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > >, rmm::device_uvector< size_t > > extract_induced_subgraphs (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, raft::device_span< size_t const > subgraph_offsets, raft::device_span< int32_t const > subgraph_vertices, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > >, rmm::device_uvector< size_t > > extract_induced_subgraphs (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, raft::device_span< size_t const > subgraph_offsets, raft::device_span< int32_t const > subgraph_vertices, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > >, rmm::device_uvector< size_t > > extract_induced_subgraphs (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, raft::device_span< size_t const > subgraph_offsets, raft::device_span< int64_t const > subgraph_vertices, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > >, rmm::device_uvector< size_t > > extract_induced_subgraphs (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, raft::device_span< size_t const > subgraph_offsets, raft::device_span< int64_t const > subgraph_vertices, bool do_expensive_check)

template<typename vertex_t, bool multi_gpu> void relabel(raft::handle_t const &handle, std::tuple<vertex_t const*, vertex_t const*> old_new_label_pairs, vertex_t num_label_pairs, vertex_t *labels, vertex_t num_labels, bool skip_missing_labels, bool do_expensive_check = false)#

Relabel old labels to new labels.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false) or multi-GPU (true).

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
old_new_label_pairs – Pairs of an old label and the corresponding new label (each process holds only part of the entire old labels and the corresponding new labels; partitioning can be arbitrary).
num_label_pairs – Number of (old, new) label pairs.
labels – Labels to be relabeled. This initially holds old labels. Old labels are updated to new labels in-place ([INOUT] parameter).
num_labels – Number of labels to be relabeled.
skip_missing_labels – Flag dictating the behavior on missing labels (labels contains old labels missing in old_new_label_pairs). If set to true, missing elements are skipped (not relabeled). If set to false, undefined behavior (if do_expensive_check is set to true, this function will throw an exception).
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

rmm::device_uvector<vertex_t> New labels corresponding to the old_labels.

template void relabel< int32_t, true > (raft::handle_t const &handle, std::tuple< int32_t const *, int32_t const * > old_new_label_pairs, int32_t num_label_pairs, int32_t *labels, int32_t num_labels, bool skip_missing_labels, bool do_expensive_check)

template void relabel< int64_t, true > (raft::handle_t const &handle, std::tuple< int64_t const *, int64_t const * > old_new_label_pairs, int64_t num_label_pairs, int64_t *labels, int64_t num_labels, bool skip_missing_labels, bool do_expensive_check)

template void relabel< int32_t, false > (raft::handle_t const &handle, std::tuple< int32_t const *, int32_t const * > old_new_label_pairs, int32_t num_label_pairs, int32_t *labels, int32_t num_labels, bool skip_missing_labels, bool do_expensive_check)

template void relabel< int64_t, false > (raft::handle_t const &handle, std::tuple< int64_t const *, int64_t const * > old_new_label_pairs, int64_t num_label_pairs, int64_t *labels, int64_t num_labels, bool skip_missing_labels, bool do_expensive_check)

template<typename vertex_t, typename edge_t, typename weight_t, typename edge_type_t> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<weight_t>>, std::optional<rmm::device_uvector<edge_t>>, std::optional<rmm::device_uvector<edge_type_t>>> remove_multi_edges(raft::handle_t const &handle, rmm::device_uvector<vertex_t> &&edgelist_srcs, rmm::device_uvector<vertex_t> &&edgelist_dsts, std::optional<rmm::device_uvector<weight_t>> &&edgelist_weights, std::optional<rmm::device_uvector<edge_t>> &&edgelist_edge_ids, std::optional<rmm::device_uvector<edge_type_t>> &&edgelist_edge_types, bool keep_min_value_edge = false)#

Remove all but one edge when a multi-edge exists.

When a multi-edge exists, one of the edges will remain. If keep_min_value_edge is false, an arbitrary edge will be selected among the edges in the multi-edge. If keep_min_value_edge is true, the edge with the minimum value will be selected. The edge weights will be first compared (if edgelist_weights.has_value() is true); edge IDs will be compared next (if edgelist_edge_ids.has_value() is true); and edge types (if edgelist_edge_types.has_value() is true) will compared last.

In an MG context it is assumed that edges have been shuffled to the proper GPU, in which case any multi-edges will be on the same GPU.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
weight_t – Type of edge weight. Currently float and double are supported.
edge_type_t – Type of edge type. Needs to be an integral type.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
edgelist_srcs – List of source vertex ids
edgelist_dsts – List of destination vertex ids
edgelist_weights – Optional list of edge weights
edgelist_edge_ids – Optional list of edge ids
edgelist_edge_types – Optional list of edge types
keep_min_value_edge – Flag indicating whether to keep an arbitrary edge (false) or the minimum value edge (true) among the edges in a multi-edge. Relevant only if edgelist_weights.has_value() | edgelist_edge_ids.has_value() | edgelist_edge_types.has_value() is true. Setting this to true incurs performance overhead as this requires more comparisons.

Returns:

Tuple of vectors storing edge sources, destinations, optional weights, optional edge ids, optional edge types.

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > > > remove_multi_edges (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&edgelist_srcs, rmm::device_uvector< int32_t > &&edgelist_dsts, std::optional< rmm::device_uvector< float > > &&edgelist_weights, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types, bool keep_min_value_edge)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > > > remove_multi_edges (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&edgelist_srcs, rmm::device_uvector< int32_t > &&edgelist_dsts, std::optional< rmm::device_uvector< double > > &&edgelist_weights, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types, bool keep_min_value_edge)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > > > remove_multi_edges (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&edgelist_srcs, rmm::device_uvector< int64_t > &&edgelist_dsts, std::optional< rmm::device_uvector< float > > &&edgelist_weights, std::optional< rmm::device_uvector< int64_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types, bool keep_min_value_edge)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > > > remove_multi_edges (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&edgelist_srcs, rmm::device_uvector< int64_t > &&edgelist_dsts, std::optional< rmm::device_uvector< double > > &&edgelist_weights, std::optional< rmm::device_uvector< int64_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types, bool keep_min_value_edge)

template<typename vertex_t, typename edge_t, typename weight_t, typename edge_type_t> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<weight_t>>, std::optional<rmm::device_uvector<edge_t>>, std::optional<rmm::device_uvector<edge_type_t>>> remove_self_loops(raft::handle_t const &handle, rmm::device_uvector<vertex_t> &&edgelist_srcs, rmm::device_uvector<vertex_t> &&edgelist_dsts, std::optional<rmm::device_uvector<weight_t>> &&edgelist_weights, std::optional<rmm::device_uvector<edge_t>> &&edgelist_edge_ids, std::optional<rmm::device_uvector<edge_type_t>> &&edgelist_edge_types)#

Remove self loops from an edge list.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
weight_t – Type of edge weight. Currently float and double are supported.
edge_type_t – Type of edge type. Needs to be an integral type.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
edgelist_srcs – List of source vertex ids
edgelist_dsts – List of destination vertex ids
edgelist_weights – Optional list of edge weights
edgelist_edge_ids – Optional list of edge ids
edgelist_edge_types – Optional list of edge types

Returns:

Tuple of vectors storing edge sources, destinations, optional weights, optional edge ids, optional edge types.

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > > > remove_self_loops (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&edgelist_srcs, rmm::device_uvector< int32_t > &&edgelist_dsts, std::optional< rmm::device_uvector< float > > &&edgelist_weights, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > > > remove_self_loops (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&edgelist_srcs, rmm::device_uvector< int32_t > &&edgelist_dsts, std::optional< rmm::device_uvector< double > > &&edgelist_weights, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > > > remove_self_loops (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&edgelist_srcs, rmm::device_uvector< int64_t > &&edgelist_dsts, std::optional< rmm::device_uvector< float > > &&edgelist_weights, std::optional< rmm::device_uvector< int64_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > > > remove_self_loops (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&edgelist_srcs, rmm::device_uvector< int64_t > &&edgelist_dsts, std::optional< rmm::device_uvector< double > > &&edgelist_weights, std::optional< rmm::device_uvector< int64_t > > &&edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edgelist_edge_types)

template<typename vertex_t, typename edge_t, bool multi_gpu> std::enable_if_t<multi_gpu, std::tuple<rmm::device_uvector<vertex_t>, renumber_meta_t<vertex_t, edge_t, multi_gpu>>> renumber_edgelist(raft::handle_t const &handle, std::optional<rmm::device_uvector<vertex_t>> &&local_vertices, std::vector<vertex_t*> const &edgelist_srcs, std::vector<vertex_t*> const &edgelist_dsts, std::vector<edge_t> const &edgelist_edge_counts, std::optional<std::vector<std::vector<edge_t>>> const &edgelist_intra_partition_segment_offsets, bool store_transposed, bool do_expensive_check = false)#

renumber edgelist (multi-GPU)

This function assumes that vertices are pre-shuffled to their target processes and edges are pre-shuffled to their target processess and edge partitions using compute_gpu_id_from_vertex_t and compute_gpu_id_from_ext_edge_endpoints_t & compute_partition_id_from_ext_edge_endpoints_t functors, respectively.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false) or multi-GPU (true).

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
local_vertices – If valid, part of the entire set of vertices in the graph to be renumbered. This parameter can be used to include isolated vertices. Applying the compute_gpu_id_from_vertex_t to every vertex should return the local GPU ID for this function to work (vertices should be pre-shuffled).
edgelist_srcs – Pointers (one pointer per local edge partition assigned to this process) to edge source vertex IDs. Source IDs are updated in-place ([INOUT] parameter). Applying the compute_gpu_id_from_ext_edge_endpoints_t functor to every (destination ID, source ID) pair (if store_transposed = true) or (source ID, destination ID) pair (if store_transposed = false) should return the local GPU ID for this function to work (edges should be pre-shuffled). Applying the compute_partition_id_from_ext_edge_endpoints_t to every (destination ID, source ID) pair (if store_transposed = true) or (source ID, destination ID) pair (if store_transposed = false) should also return the corresponding edge partition ID. The best way to enforce this is to use shuffle_ext_vertex_pairs_to_local_gpu_by_edge_partitioning & groupby_and_count_edgelist_by_local_partition_id.
edgelist_dsts – Pointers (one pointer per local edge partition assigned to this process) to edge destination vertex IDs. Destination IDs are updated in-place ([INOUT] parameter).
edgelist_edge_counts – Edge counts (one count per local edge partition assigned to this process).
edgelist_intra_partition_segment_offsets – If valid, store segment offsets within a local edge partition; a local edge partition can be further segmented by applying the compute_gpu_id_from_vertex_t function to edge minor vertex IDs. This optinoal information is used for further memory footprint optimization if provided.
store_transposed – Should be true if renumbered edges will be used to create a graph with store_transposed = true. Should be false if the edges will be used to create a graph with store_transposed = false.
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

std::tuple<rmm::device_uvector<vertex_t>, renumber_meta_t<vertex_t, edge_t, multi_gpu>> Tuple of labels (vertex IDs before renumbering) for the entire set of vertices (assigned to this process in multi-GPU) and meta-data collected while renumbering. The meta-data includes total number of vertices, total number of edges, partition_t object storing graph partitioning information, vertex partition segment offsets (a vertex partition is partitioned to multiple segments based on vertex degrees), and the number of local unique edge major & minor vertex IDs. This meta-data is expected to be used in graph construction & graph primitives.

template<typename vertex_t, typename edge_t, bool multi_gpu> std::enable_if_t<!multi_gpu, std::tuple<rmm::device_uvector<vertex_t>, renumber_meta_t<vertex_t, edge_t, multi_gpu>>> renumber_edgelist(raft::handle_t const &handle, std::optional<rmm::device_uvector<vertex_t>> &&vertices, vertex_t *edgelist_srcs, vertex_t *edgelist_dsts, edge_t num_edgelist_edges, bool store_transposed, bool do_expensive_check = false)#

renumber edgelist (single-GPU)

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false) or multi-GPU (true).

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
vertices – If valid, vertices in the graph to be renumbered. This parameter can be used to include isolated vertices.
edgelist_srcs – A pointer to edge source vertex IDs. Source IDs are updated in-place ([INOUT] parameter).
edgelist_dsts – A pointer to edge destination vertex IDs. Destination IDs are updated in-place ([INOUT] parameter).
num_edgelist_edges – Number of edges in the edgelist.
store_transposed – Should be true if renumbered edges will be used to create a graph with store_transposed = true. Should be false if the edges will be used to create a graph with store_transposed = false.
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

std::tuple<rmm::device_uvector<vertex_t>, renumber_meta_t<vertex_t, edge_t, multi_gpu>> Tuple of labels (vertex IDs before renumbering) for the entire set of vertices and meta-data collected while renumbering. The meta-data includes vertex partition segment offsets (a vertex partition is partitioned to multiple segments based on vertex degrees). This meta-data is expected to be used in graph construction & graph primitives.

template std::tuple< rmm::device_uvector< int32_t >, renumber_meta_t< int32_t, int32_t, true > > renumber_edgelist< int32_t, int32_t, true > (raft::handle_t const &handle, std::optional< rmm::device_uvector< int32_t > > &&local_vertices, std::vector< int32_t * > const &edgelist_srcs, std::vector< int32_t * > const &edgelist_dsts, std::vector< int32_t > const &edgelist_edge_counts, std::optional< std::vector< std::vector< int32_t > > > const &edgelist_intra_partition_segment_offsets, bool store_transposed, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, renumber_meta_t< int64_t, int64_t, true > > renumber_edgelist< int64_t, int64_t, true > (raft::handle_t const &handle, std::optional< rmm::device_uvector< int64_t > > &&local_vertices, std::vector< int64_t * > const &edgelist_srcs, std::vector< int64_t * > const &edgelist_dsts, std::vector< int64_t > const &edgelist_edge_counts, std::optional< std::vector< std::vector< int64_t > > > const &edgelist_intra_partition_segment_offsets, bool store_transposed, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, renumber_meta_t< int32_t, int32_t, false > > renumber_edgelist< int32_t, int32_t, false > (raft::handle_t const &handle, std::optional< rmm::device_uvector< int32_t > > &&vertices, int32_t *edgelist_srcs, int32_t *edgelist_dsts, int32_t num_edgelist_edges, bool store_transposed, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, renumber_meta_t< int64_t, int64_t, false > > renumber_edgelist< int64_t, int64_t, false > (raft::handle_t const &handle, std::optional< rmm::device_uvector< int64_t > > &&vertices, int64_t *edgelist_srcs, int64_t *edgelist_dsts, int64_t num_edgelist_edges, bool store_transposed, bool do_expensive_check)

template<typename vertex_t, bool multi_gpu> void renumber_ext_vertices(raft::handle_t const &handle, vertex_t *vertices, size_t num_vertices, vertex_t const *renumber_map_labels, vertex_t local_int_vertex_first, vertex_t local_int_vertex_last, bool do_expensive_check = false)#

Renumber external vertices to internal vertices based on the provided renumber_map_labels.

Note cugraph::invalid_id<vertex_t>::value remains unchanged.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false) or multi-GPU (true).

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
vertices – Pointer to the vertices to be renumbered. The input external vertices are renumbered to internal vertices in-place.
num_vertices – Number of vertices to be renumbered.
renumber_map_labels – Pointer to the external vertices corresponding to the internal vertices in the range [local_int_vertex_first, local_int_vertex_last).
local_int_vertex_first – The first local internal vertex (inclusive, assigned to this process in multi-GPU).
local_int_vertex_last – The last local internal vertex (exclusive, assigned to this process in multi-GPU).
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

template<typename vertex_t, bool multi_gpu> void renumber_local_ext_vertices(raft::handle_t const &handle, vertex_t *vertices, size_t num_vertices, vertex_t const *renumber_map_labels, vertex_t local_int_vertex_first, vertex_t local_int_vertex_last, bool do_expensive_check = false)#

Renumber local external vertices to internal vertices based on the provided renumber_map_labels.

Note cugraph::invalid_id<vertex_t>::value remains unchanged.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false) or multi-GPU (true).

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
vertices – Pointer to the vertices to be renumbered. The input external vertices are renumbered to internal vertices in-place.
num_vertices – Number of vertices to be renumbered.
renumber_map_labels – Pointer to the external vertices corresponding to the internal vertices in the range [local_int_vertex_first, local_int_vertex_last).
local_int_vertex_first – The first local internal vertex (inclusive, assigned to this process in multi-GPU).
local_int_vertex_last – The last local internal vertex (exclusive, assigned to this process in multi-GPU).
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

template<typename vertex_t> void unrenumber_local_int_vertices(raft::handle_t const &handle, vertex_t *vertices, size_t num_vertices, vertex_t const *renumber_map_labels, vertex_t local_int_vertex_first, vertex_t local_int_vertex_last, bool do_expensive_check = false)#

Unrenumber local internal vertices to external vertices based on the providied renumber_map_labels.

Note cugraph::invalid_id<vertex_t>::value remains unchanged.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
vertices – Pointer to the local internal vertices to be unrenumbered. Each input element should be in [local_int_vertex_first, local_int_vertex_last). The input internal vertices are renumbered to external vertices in-place.
num_vertices – Number of vertices to be unrenumbered.
renumber_map_labels – Pointer to the external vertices corresponding to the internal vertices in the range [local_int_vertex_first, local_int_vertex_last).
local_int_vertex_first – The first local internal vertex (inclusive, assigned to this process in multi-GPU).
local_int_vertex_last – The last local internal vertex (exclusive, assigned to this process in multi-GPU).
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

template<typename vertex_t, bool multi_gpu> void unrenumber_int_vertices(raft::handle_t const &handle, vertex_t *vertices, size_t num_vertices, vertex_t const *renumber_map_labels, std::vector<vertex_t> const &vertex_partition_range_lasts, bool do_expensive_check = false)#

Unrenumber (possibly non-local) internal vertices to external vertices based on the providied renumber_map_labels.

Note cugraph::invalid_id<vertex_t>::value remains unchanged.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false) or multi-GPU (true).

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
vertices – Pointer to the internal vertices to be unrenumbered. The input internal vertices are renumbered to external vertices in-place.
num_vertices – Number of vertices to be unrenumbered.
renumber_map_labels – Pointer to the external vertices corresponding to the internal vertices in the range [local_int_vertex_first, local_int_vertex_last).
vertex_partition_range_lasts – Last local internal vertices (exclusive, assigned to each process in multi-GPU).
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

template<typename vertex_t, bool store_transposed, bool multi_gpu> std::enable_if_t<multi_gpu, void> unrenumber_local_int_edges(raft::handle_t const &handle, std::vector<vertex_t*> const &edgelist_srcs, std::vector<vertex_t*> const &edgelist_dsts, std::vector<size_t> const &edgelist_edge_counts, vertex_t const *renumber_map_labels, std::vector<vertex_t> const &vertex_partition_range_lasts, std::optional<std::vector<std::vector<size_t>>> const &edgelist_intra_partition_segment_offsets, bool do_expensive_check = false)#

Unrenumber local edges’ internal source & destination IDs to external IDs based on the provided renumber_map_labels (multi-GPU).

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
store_transposed – Flag indicating whether to use sources (if false) or destinations (if true) as major indices in storing edges using a 2D sparse matrix.
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false) or multi-GPU (true).

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms. @params edgelist_srcs Pointers (one pointer per local edge partition assigned to this process) to the local internal source vertex IDs to be unrenumbered. The input source vertex IDs are renumbered to external IDs in-place. @params edgelist_dsts Pointers (one pointer per local edge partition assigned to this process) to the local internal destination vertex IDs to be unrenumbered. The input destination vertex IDs are renumbered to external IDs in-place.
edgelist_edge_counts – Edge counts (one count per local edge partition assigned to this process).
renumber_map_labels – Pointer to the external vertices corresponding to the internal vertices in the range assigned to this process.
vertex_partition_range_lasts – Last local internal vertices (exclusive, assigned to each process in multi-GPU).
edgelist_intra_partition_segment_offsets – If valid, store segment offsets within a local edge partition; a local edge partition can be further segmented by applying the compute_gpu_id_from_vertex_t function to edge minor vertex IDs. This optinoal information is used for further memory footprint optimization if provided.
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

template<typename vertex_t, bool store_transposed, bool multi_gpu> std::enable_if_t<!multi_gpu, void> unrenumber_local_int_edges(raft::handle_t const &handle, vertex_t *edgelist_srcs, vertex_t *edgelist_dsts, size_t num_edgelist_edges, vertex_t const *renumber_map_labels, vertex_t num_vertices, bool do_expensive_check = false)#

Unrenumber local edges’ internal source & destination IDs to external IDs based on the provided renumber_map_labels (single-GPU).

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
store_transposed – Flag indicating whether to use sources (if false) or destinations (if true) as major indices in storing edges using a 2D sparse matrix.
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false) or multi-GPU (true).

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms. @params edgelist_srcs Pointer to the local internal source vertex IDs to be unrenumbered. The input source vertex IDs are renumbered to external IDs in-place. @params edgelist_dsts Pointer to the local internal destination vertex IDs to be unrenumbered. The input destination vertex IDs are renumbered to external IDs in-place.
num_edgelist_edges – Number of edges in the edge list.
renumber_map_labels – Pointer to the external vertices corresponding to the internal vertices.
num_vertices – Number of vertices to be unrenumbered.
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

template void renumber_ext_vertices< int32_t, true > (raft::handle_t const &handle, int32_t *vertices, size_t num_vertices, int32_t const *renumber_map_labels, int32_t local_int_vertex_first, int32_t local_int_vertex_last, bool do_expensive_check)

template void renumber_local_ext_vertices< int32_t, true > (raft::handle_t const &handle, int32_t *vertices, size_t num_vertices, int32_t const *renumber_map_labels, int32_t local_int_vertex_first, int32_t local_int_vertex_last, bool do_expensive_check)

template void unrenumber_int_vertices< int32_t, true > (raft::handle_t const &handle, int32_t *vertices, size_t num_vertices, int32_t const *renumber_map_labels, std::vector< int32_t > const &vertex_partition_range_lasts, bool do_expensive_check)

template void unrenumber_local_int_edges< int32_t, false, true > (raft::handle_t const &handle, std::vector< int32_t * > const &edgelist_srcs, std::vector< int32_t * > const &edgelist_dsts, std::vector< size_t > const &edgelist_edge_counts, int32_t const *renumber_map_labels, std::vector< int32_t > const &vertex_partition_range_lasts, std::optional< std::vector< std::vector< size_t > > > const &edgelist_intra_partition_segment_offsets, bool do_expensive_check)

template void unrenumber_local_int_edges< int32_t, true, true > (raft::handle_t const &handle, std::vector< int32_t * > const &edgelist_srcs, std::vector< int32_t * > const &edgelist_dsts, std::vector< size_t > const &edgelist_edge_counts, int32_t const *renumber_map_labels, std::vector< int32_t > const &vertex_partition_range_lasts, std::optional< std::vector< std::vector< size_t > > > const &edgelist_intra_partition_segment_offsets, bool do_expensive_check)

template void renumber_ext_vertices< int64_t, true > (raft::handle_t const &handle, int64_t *vertices, size_t num_vertices, int64_t const *renumber_map_labels, int64_t local_int_vertex_first, int64_t local_int_vertex_last, bool do_expensive_check)

template void renumber_local_ext_vertices< int64_t, true > (raft::handle_t const &handle, int64_t *vertices, size_t num_vertices, int64_t const *renumber_map_labels, int64_t local_int_vertex_first, int64_t local_int_vertex_last, bool do_expensive_check)

template void unrenumber_int_vertices< int64_t, true > (raft::handle_t const &handle, int64_t *vertices, size_t num_vertices, int64_t const *renumber_map_labels, std::vector< int64_t > const &vertex_partition_range_lasts, bool do_expensive_check)

template void unrenumber_local_int_edges< int64_t, false, true > (raft::handle_t const &handle, std::vector< int64_t * > const &edgelist_srcs, std::vector< int64_t * > const &edgelist_dsts, std::vector< size_t > const &edgelist_edge_counts, int64_t const *renumber_map_labels, std::vector< int64_t > const &vertex_partition_range_lasts, std::optional< std::vector< std::vector< size_t > > > const &edgelist_intra_partition_segment_offsets, bool do_expensive_check)

template void unrenumber_local_int_edges< int64_t, true, true > (raft::handle_t const &handle, std::vector< int64_t * > const &edgelist_srcs, std::vector< int64_t * > const &edgelist_dsts, std::vector< size_t > const &edgelist_edge_counts, int64_t const *renumber_map_labels, std::vector< int64_t > const &vertex_partition_range_lasts, std::optional< std::vector< std::vector< size_t > > > const &edgelist_intra_partition_segment_offsets, bool do_expensive_check)

template void renumber_ext_vertices< int32_t, false > (raft::handle_t const &handle, int32_t *vertices, size_t num_vertices, int32_t const *renumber_map_labels, int32_t local_int_vertex_first, int32_t local_int_vertex_last, bool do_expensive_check)

template void renumber_local_ext_vertices< int32_t, false > (raft::handle_t const &handle, int32_t *vertices, size_t num_vertices, int32_t const *renumber_map_labels, int32_t local_int_vertex_first, int32_t local_int_vertex_last, bool do_expensive_check)

template void unrenumber_local_int_vertices< int32_t > (raft::handle_t const &handle, int32_t *vertices, size_t num_vertices, int32_t const *renumber_map_labels, int32_t local_int_vertex_first, int32_t local_int_vertex_last, bool do_expensive_check)

template void unrenumber_int_vertices< int32_t, false > (raft::handle_t const &handle, int32_t *vertices, size_t num_vertices, int32_t const *renumber_map_labels, std::vector< int32_t > const &vertex_partition_range_lasts, bool do_expensive_check)

template void unrenumber_local_int_edges< int32_t, false, false > (raft::handle_t const &handle, int32_t *edgelist_srcs, int32_t *edgelist_dsts, size_t num_edgelist_edges, int32_t const *renumber_map_labels, int32_t num_vertices, bool do_expensive_check)

template void unrenumber_local_int_edges< int32_t, true, false > (raft::handle_t const &handle, int32_t *edgelist_srcs, int32_t *edgelist_dsts, size_t num_edgelist_edges, int32_t const *renumber_map_labels, int32_t num_vertices, bool do_expensive_check)

template void renumber_ext_vertices< int64_t, false > (raft::handle_t const &handle, int64_t *vertices, size_t num_vertices, int64_t const *renumber_map_labels, int64_t local_int_vertex_first, int64_t local_int_vertex_last, bool do_expensive_check)

template void renumber_local_ext_vertices< int64_t, false > (raft::handle_t const &handle, int64_t *vertices, size_t num_vertices, int64_t const *renumber_map_labels, int64_t local_int_vertex_first, int64_t local_int_vertex_last, bool do_expensive_check)

template void unrenumber_local_int_vertices< int64_t > (raft::handle_t const &handle, int64_t *vertices, size_t num_vertices, int64_t const *renumber_map_labels, int64_t local_int_vertex_first, int64_t local_int_vertex_last, bool do_expensive_check)

template void unrenumber_int_vertices< int64_t, false > (raft::handle_t const &handle, int64_t *vertices, size_t num_vertices, int64_t const *renumber_map_labels, std::vector< int64_t > const &vertex_partition_range_lasts, bool do_expensive_check)

template void unrenumber_local_int_edges< int64_t, false, false > (raft::handle_t const &handle, int64_t *edgelist_srcs, int64_t *edgelist_dsts, size_t num_edgelist_edges, int64_t const *renumber_map_labels, int64_t num_vertices, bool do_expensive_check)

template void unrenumber_local_int_edges< int64_t, true, false > (raft::handle_t const &handle, int64_t *edgelist_srcs, int64_t *edgelist_dsts, size_t num_edgelist_edges, int64_t const *renumber_map_labels, int64_t num_vertices, bool do_expensive_check)

template<typename vertex_t, typename edge_t, bool store_transposed, bool multi_gpu> rmm::device_uvector<vertex_t> select_random_vertices(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu> const &graph_view, std::optional<raft::device_span<vertex_t const>> given_set, raft::random::RngState &rng_state, size_t select_count, bool with_replacement, bool sort_vertices, bool do_expensive_check = false)#

Select random vertices.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
weight_t – Type of edge weights. Needs to be a floating point type.
store_transposed – Flag indicating whether to use sources (if false) or destinations (if true) as major indices in storing edges using a 2D sparse matrix.
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false) or multi-GPU (true).

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Graph view object of the input graph to select random vertices from.
given_set – Distributed set to sample from. If given_set is not specified, sample from the entire vertex range provided by graph_view.
rng_state – The RngState instance holding pseudo-random number generator state.
select_count – The number of vertices to select from the graph
with_replacement – If true, select with replacement, if false select without replacement
sort_vertices – If true, return the sorted vertices (in the ascending order).

Returns:

Device vector of selected vertices.

template rmm::device_uvector< int32_t > select_random_vertices (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< raft::device_span< int32_t const > > given_set, raft::random::RngState &rng_state, size_t select_count, bool with_replacement, bool sort_vertices, bool do_expensive_check)

template rmm::device_uvector< int32_t > select_random_vertices (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, true > const &graph_view, std::optional< raft::device_span< int32_t const > > given_set, raft::random::RngState &rng_state, size_t select_count, bool with_replacement, bool sort_vertices, bool do_expensive_check)

template rmm::device_uvector< int64_t > select_random_vertices (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< raft::device_span< int64_t const > > given_set, raft::random::RngState &rng_state, size_t select_count, bool with_replacement, bool sort_vertices, bool do_expensive_check)

template rmm::device_uvector< int64_t > select_random_vertices (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, true > const &graph_view, std::optional< raft::device_span< int64_t const > > given_set, raft::random::RngState &rng_state, size_t select_count, bool with_replacement, bool sort_vertices, bool do_expensive_check)

template rmm::device_uvector< int32_t > select_random_vertices (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< raft::device_span< int32_t const > > given_set, raft::random::RngState &rng_state, size_t select_count, bool with_replacement, bool sort_vertices, bool do_expensive_check)

template rmm::device_uvector< int32_t > select_random_vertices (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, true, false > const &graph_view, std::optional< raft::device_span< int32_t const > > given_set, raft::random::RngState &rng_state, size_t select_count, bool with_replacement, bool sort_vertices, bool do_expensive_check)

template rmm::device_uvector< int64_t > select_random_vertices (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< raft::device_span< int64_t const > > given_set, raft::random::RngState &rng_state, size_t select_count, bool with_replacement, bool sort_vertices, bool do_expensive_check)

template rmm::device_uvector< int64_t > select_random_vertices (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, true, false > const &graph_view, std::optional< raft::device_span< int64_t const > > given_set, raft::random::RngState &rng_state, size_t select_count, bool with_replacement, bool sort_vertices, bool do_expensive_check)

template<typename vertex_t, typename weight_t, bool store_transposed, bool multi_gpu> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<weight_t>>> symmetrize_edgelist(raft::handle_t const &handle, rmm::device_uvector<vertex_t> &&edgelist_srcs, rmm::device_uvector<vertex_t> &&edgelist_dsts, std::optional<rmm::device_uvector<weight_t>> &&edgelist_weights, bool reciprocal)#

Symmetrize edgelist.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
weight_t – Type of edge weights. Needs to be a floating point type.
store_transposed – Flag indicating whether to use sources (if false) or destinations (if true) as major indices in storing edges using a 2D sparse matrix.
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false) or multi-GPU (true).

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
edgelist_srcs – Vector of edge source vertex IDs. If multi-GPU, applying the compute_gpu_id_from_ext_edge_endpoints_t to every edge should return the local GPU ID for this function to work (edges should be pre-shuffled).
edgelist_dsts – Vector of edge destination vertex IDs.
edgelist_weights – Vector of edge weights.
reciprocal – Flag indicating whether to keep (if set to false) or discard (if set to true) edges that appear only in one direction.

Returns:

std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<weight_t>>> Tuple of symmetrized sources, destinations, and optional weights (if edgelist_weights is valid).

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > > > symmetrize_edgelist< int32_t, float, false, true > (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&edgelist_srcs, rmm::device_uvector< int32_t > &&edgelist_dsts, std::optional< rmm::device_uvector< float > > &&edgelist_weights, bool reciprocal)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > > > symmetrize_edgelist< int32_t, float, true, true > (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&edgelist_srcs, rmm::device_uvector< int32_t > &&edgelist_dsts, std::optional< rmm::device_uvector< float > > &&edgelist_weights, bool reciprocal)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > > > symmetrize_edgelist< int32_t, double, false, true > (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&edgelist_srcs, rmm::device_uvector< int32_t > &&edgelist_dsts, std::optional< rmm::device_uvector< double > > &&edgelist_weights, bool reciprocal)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > > > symmetrize_edgelist< int32_t, double, true, true > (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&edgelist_srcs, rmm::device_uvector< int32_t > &&edgelist_dsts, std::optional< rmm::device_uvector< double > > &&edgelist_weights, bool reciprocal)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > > > symmetrize_edgelist< int64_t, float, false, true > (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&edgelist_srcs, rmm::device_uvector< int64_t > &&edgelist_dsts, std::optional< rmm::device_uvector< float > > &&edgelist_weights, bool reciprocal)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > > > symmetrize_edgelist< int64_t, float, true, true > (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&edgelist_srcs, rmm::device_uvector< int64_t > &&edgelist_dsts, std::optional< rmm::device_uvector< float > > &&edgelist_weights, bool reciprocal)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > > > symmetrize_edgelist< int64_t, double, false, true > (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&edgelist_srcs, rmm::device_uvector< int64_t > &&edgelist_dsts, std::optional< rmm::device_uvector< double > > &&edgelist_weights, bool reciprocal)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > > > symmetrize_edgelist< int64_t, double, true, true > (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&edgelist_srcs, rmm::device_uvector< int64_t > &&edgelist_dsts, std::optional< rmm::device_uvector< double > > &&edgelist_weights, bool reciprocal)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > > > symmetrize_edgelist< int32_t, float, false, false > (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&edgelist_srcs, rmm::device_uvector< int32_t > &&edgelist_dsts, std::optional< rmm::device_uvector< float > > &&edgelist_weights, bool reciprocal)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > > > symmetrize_edgelist< int32_t, float, true, false > (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&edgelist_srcs, rmm::device_uvector< int32_t > &&edgelist_dsts, std::optional< rmm::device_uvector< float > > &&edgelist_weights, bool reciprocal)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > > > symmetrize_edgelist< int32_t, double, false, false > (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&edgelist_srcs, rmm::device_uvector< int32_t > &&edgelist_dsts, std::optional< rmm::device_uvector< double > > &&edgelist_weights, bool reciprocal)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > > > symmetrize_edgelist< int32_t, double, true, false > (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&edgelist_srcs, rmm::device_uvector< int32_t > &&edgelist_dsts, std::optional< rmm::device_uvector< double > > &&edgelist_weights, bool reciprocal)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > > > symmetrize_edgelist< int64_t, float, false, false > (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&edgelist_srcs, rmm::device_uvector< int64_t > &&edgelist_dsts, std::optional< rmm::device_uvector< float > > &&edgelist_weights, bool reciprocal)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > > > symmetrize_edgelist< int64_t, float, true, false > (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&edgelist_srcs, rmm::device_uvector< int64_t > &&edgelist_dsts, std::optional< rmm::device_uvector< float > > &&edgelist_weights, bool reciprocal)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > > > symmetrize_edgelist< int64_t, double, false, false > (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&edgelist_srcs, rmm::device_uvector< int64_t > &&edgelist_dsts, std::optional< rmm::device_uvector< double > > &&edgelist_weights, bool reciprocal)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > > > symmetrize_edgelist< int64_t, double, true, false > (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&edgelist_srcs, rmm::device_uvector< int64_t > &&edgelist_dsts, std::optional< rmm::device_uvector< double > > &&edgelist_weights, bool reciprocal)

template<typename vertex_t, typename edge_t, typename weight_t, bool store_transposed, bool multi_gpu> std::tuple<graph_t<vertex_t, edge_t, store_transposed, multi_gpu>, std::optional<edge_property_t<graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu>, weight_t>>, std::optional<rmm::device_uvector<vertex_t>>> symmetrize_graph(raft::handle_t const &handle, graph_t<vertex_t, edge_t, store_transposed, multi_gpu> &&graph, std::optional<edge_property_t<graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu>, weight_t>> &&edge_weights, std::optional<rmm::device_uvector<vertex_t>> &&renumber_map, bool reciprocal = false, bool do_expensive_check = false)#

Symmetrize the input graph.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
weight_t – Type of edge weights. Needs to be a floating point type.
store_transposed – Flag indicating whether to use sources (if false) or destinations (if true) as major indices in storing edges using a 2D sparse matrix.
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false) or multi-GPU (true).

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph – Graph object to be symmetrized.
edge_weights – Optional owning object holding edge weights for graph.
renumber_map – Renumber map to recover the original vertex IDs from the renumbered vertex IDs. This should be valid if multi-GPU.
reciprocal – If true, an edge is kept only when the reversed edge also exists. If false, keep (and symmetrize) all the edges that appear only in one direction.
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

Return a symmetrized graph, an owning object holding edge weights (if edge_weights.has_value() is true) and a new renumber map (to recover the original vertex IDs, if renumber_map.has_value() is true).

template std::tuple< graph_t< int32_t, int32_t, true, true >, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, true, true >, float > >, std::optional< rmm::device_uvector< int32_t > > > symmetrize_graph (raft::handle_t const &handle, graph_t< int32_t, int32_t, true, true > &&graph, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, true, true >, float > > &&edge_weights, std::optional< rmm::device_uvector< int32_t > > &&renumber_map, bool reciprocal, bool do_expensive_check)

template std::tuple< graph_t< int32_t, int32_t, false, true >, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, false, true >, float > >, std::optional< rmm::device_uvector< int32_t > > > symmetrize_graph (raft::handle_t const &handle, graph_t< int32_t, int32_t, false, true > &&graph, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, false, true >, float > > &&edge_weights, std::optional< rmm::device_uvector< int32_t > > &&renumber_map, bool reciprocal, bool do_expensive_check)

template std::tuple< graph_t< int32_t, int32_t, true, true >, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, true, true >, double > >, std::optional< rmm::device_uvector< int32_t > > > symmetrize_graph (raft::handle_t const &handle, graph_t< int32_t, int32_t, true, true > &&graph, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, true, true >, double > > &&edge_weights, std::optional< rmm::device_uvector< int32_t > > &&renumber_map, bool reciprocal, bool do_expensive_check)

template std::tuple< graph_t< int32_t, int32_t, false, true >, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, false, true >, double > >, std::optional< rmm::device_uvector< int32_t > > > symmetrize_graph (raft::handle_t const &handle, graph_t< int32_t, int32_t, false, true > &&graph, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, false, true >, double > > &&edge_weights, std::optional< rmm::device_uvector< int32_t > > &&renumber_map, bool reciprocal, bool do_expensive_check)

template std::tuple< graph_t< int64_t, int64_t, true, true >, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, true, true >, float > >, std::optional< rmm::device_uvector< int64_t > > > symmetrize_graph (raft::handle_t const &handle, graph_t< int64_t, int64_t, true, true > &&graph, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, true, true >, float > > &&edge_weights, std::optional< rmm::device_uvector< int64_t > > &&renumber_map, bool reciprocal, bool do_expensive_check)

template std::tuple< graph_t< int64_t, int64_t, false, true >, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, false, true >, float > >, std::optional< rmm::device_uvector< int64_t > > > symmetrize_graph (raft::handle_t const &handle, graph_t< int64_t, int64_t, false, true > &&graph, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, false, true >, float > > &&edge_weights, std::optional< rmm::device_uvector< int64_t > > &&renumber_map, bool reciprocal, bool do_expensive_check)

template std::tuple< graph_t< int64_t, int64_t, true, true >, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, true, true >, double > >, std::optional< rmm::device_uvector< int64_t > > > symmetrize_graph (raft::handle_t const &handle, graph_t< int64_t, int64_t, true, true > &&graph, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, true, true >, double > > &&edge_weights, std::optional< rmm::device_uvector< int64_t > > &&renumber_map, bool reciprocal, bool do_expensive_check)

template std::tuple< graph_t< int64_t, int64_t, false, true >, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, false, true >, double > >, std::optional< rmm::device_uvector< int64_t > > > symmetrize_graph (raft::handle_t const &handle, graph_t< int64_t, int64_t, false, true > &&graph, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, false, true >, double > > &&edge_weights, std::optional< rmm::device_uvector< int64_t > > &&renumber_map, bool reciprocal, bool do_expensive_check)

template std::tuple< graph_t< int32_t, int32_t, true, false >, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, true, false >, float > >, std::optional< rmm::device_uvector< int32_t > > > symmetrize_graph (raft::handle_t const &handle, graph_t< int32_t, int32_t, true, false > &&graph, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, true, false >, float > > &&edge_weights, std::optional< rmm::device_uvector< int32_t > > &&renumber_map, bool reciprocal, bool do_expensive_check)

template std::tuple< graph_t< int32_t, int32_t, false, false >, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, false, false >, float > >, std::optional< rmm::device_uvector< int32_t > > > symmetrize_graph (raft::handle_t const &handle, graph_t< int32_t, int32_t, false, false > &&graph, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, false, false >, float > > &&edge_weights, std::optional< rmm::device_uvector< int32_t > > &&renumber_map, bool reciprocal, bool do_expensive_check)

template std::tuple< graph_t< int32_t, int32_t, true, false >, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, true, false >, double > >, std::optional< rmm::device_uvector< int32_t > > > symmetrize_graph (raft::handle_t const &handle, graph_t< int32_t, int32_t, true, false > &&graph, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, true, false >, double > > &&edge_weights, std::optional< rmm::device_uvector< int32_t > > &&renumber_map, bool reciprocal, bool do_expensive_check)

template std::tuple< graph_t< int32_t, int32_t, false, false >, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, false, false >, double > >, std::optional< rmm::device_uvector< int32_t > > > symmetrize_graph (raft::handle_t const &handle, graph_t< int32_t, int32_t, false, false > &&graph, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, false, false >, double > > &&edge_weights, std::optional< rmm::device_uvector< int32_t > > &&renumber_map, bool reciprocal, bool do_expensive_check)

template std::tuple< graph_t< int64_t, int64_t, true, false >, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, true, false >, float > >, std::optional< rmm::device_uvector< int64_t > > > symmetrize_graph (raft::handle_t const &handle, graph_t< int64_t, int64_t, true, false > &&graph, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, true, false >, float > > &&edge_weights, std::optional< rmm::device_uvector< int64_t > > &&renumber_map, bool reciprocal, bool do_expensive_check)

template std::tuple< graph_t< int64_t, int64_t, false, false >, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, false, false >, float > >, std::optional< rmm::device_uvector< int64_t > > > symmetrize_graph (raft::handle_t const &handle, graph_t< int64_t, int64_t, false, false > &&graph, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, false, false >, float > > &&edge_weights, std::optional< rmm::device_uvector< int64_t > > &&renumber_map, bool reciprocal, bool do_expensive_check)

template std::tuple< graph_t< int64_t, int64_t, true, false >, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, true, false >, double > >, std::optional< rmm::device_uvector< int64_t > > > symmetrize_graph (raft::handle_t const &handle, graph_t< int64_t, int64_t, true, false > &&graph, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, true, false >, double > > &&edge_weights, std::optional< rmm::device_uvector< int64_t > > &&renumber_map, bool reciprocal, bool do_expensive_check)

template std::tuple< graph_t< int64_t, int64_t, false, false >, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, false, false >, double > >, std::optional< rmm::device_uvector< int64_t > > > symmetrize_graph (raft::handle_t const &handle, graph_t< int64_t, int64_t, false, false > &&graph, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, false, false >, double > > &&edge_weights, std::optional< rmm::device_uvector< int64_t > > &&renumber_map, bool reciprocal, bool do_expensive_check)

template<typename vertex_t, typename edge_t, typename weight_t, bool store_transposed, bool multi_gpu> std::tuple<graph_t<vertex_t, edge_t, store_transposed, multi_gpu>, std::optional<edge_property_t<graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu>, weight_t>>, std::optional<rmm::device_uvector<vertex_t>>> transpose_graph(raft::handle_t const &handle, graph_t<vertex_t, edge_t, store_transposed, multi_gpu> &&graph, std::optional<edge_property_t<graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu>, weight_t>> &&edge_weights, std::optional<rmm::device_uvector<vertex_t>> &&renumber_map, bool do_expensive_check = false)#

Transpose the input graph.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
weight_t – Type of edge weights. Needs to be a floating point type.
store_transposed – Flag indicating whether to use sources (if false) or destinations (if true) as major indices in storing edges using a 2D sparse matrix.
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false) or multi-GPU (true).

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph – Graph object to be transposed.
edge_weights – Optional owning object holding edge weights for graph.
renumber_map – Renumber map to recover the original vertex IDs from the renumbered vertex IDs. This should be valid if multi-GPU.
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

Return a transposed graph, an owning object holding edge weights (if edge_weights.has_value() is true) and a new renumber map (to recover the original vertex IDs, if renumber_map.has_value() is true).

template std::tuple< graph_t< int32_t, int32_t, true, true >, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, true, true >, float > >, std::optional< rmm::device_uvector< int32_t > > > transpose_graph (raft::handle_t const &handle, graph_t< int32_t, int32_t, true, true > &&graph, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, true, true >, float > > &&edge_weights, std::optional< rmm::device_uvector< int32_t > > &&renumber_map, bool do_expensive_check)

template std::tuple< graph_t< int32_t, int32_t, false, true >, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, false, true >, float > >, std::optional< rmm::device_uvector< int32_t > > > transpose_graph (raft::handle_t const &handle, graph_t< int32_t, int32_t, false, true > &&graph, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, false, true >, float > > &&edge_weights, std::optional< rmm::device_uvector< int32_t > > &&renumber_map, bool do_expensive_check)

template std::tuple< graph_t< int32_t, int32_t, true, true >, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, true, true >, double > >, std::optional< rmm::device_uvector< int32_t > > > transpose_graph (raft::handle_t const &handle, graph_t< int32_t, int32_t, true, true > &&graph, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, true, true >, double > > &&edge_weights, std::optional< rmm::device_uvector< int32_t > > &&renumber_map, bool do_expensive_check)

template std::tuple< graph_t< int32_t, int32_t, false, true >, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, false, true >, double > >, std::optional< rmm::device_uvector< int32_t > > > transpose_graph (raft::handle_t const &handle, graph_t< int32_t, int32_t, false, true > &&graph, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, false, true >, double > > &&edge_weights, std::optional< rmm::device_uvector< int32_t > > &&renumber_map, bool do_expensive_check)

template std::tuple< graph_t< int64_t, int64_t, true, true >, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, true, true >, float > >, std::optional< rmm::device_uvector< int64_t > > > transpose_graph (raft::handle_t const &handle, graph_t< int64_t, int64_t, true, true > &&graph, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, true, true >, float > > &&edge_weights, std::optional< rmm::device_uvector< int64_t > > &&renumber_map, bool do_expensive_check)

template std::tuple< graph_t< int64_t, int64_t, false, true >, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, false, true >, float > >, std::optional< rmm::device_uvector< int64_t > > > transpose_graph (raft::handle_t const &handle, graph_t< int64_t, int64_t, false, true > &&graph, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, false, true >, float > > &&edge_weights, std::optional< rmm::device_uvector< int64_t > > &&renumber_map, bool do_expensive_check)

template std::tuple< graph_t< int64_t, int64_t, true, true >, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, true, true >, double > >, std::optional< rmm::device_uvector< int64_t > > > transpose_graph (raft::handle_t const &handle, graph_t< int64_t, int64_t, true, true > &&graph, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, true, true >, double > > &&edge_weights, std::optional< rmm::device_uvector< int64_t > > &&renumber_map, bool do_expensive_check)

template std::tuple< graph_t< int64_t, int64_t, false, true >, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, false, true >, double > >, std::optional< rmm::device_uvector< int64_t > > > transpose_graph (raft::handle_t const &handle, graph_t< int64_t, int64_t, false, true > &&graph, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, false, true >, double > > &&edge_weights, std::optional< rmm::device_uvector< int64_t > > &&renumber_map, bool do_expensive_check)

template std::tuple< graph_t< int32_t, int32_t, true, false >, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, true, false >, float > >, std::optional< rmm::device_uvector< int32_t > > > transpose_graph (raft::handle_t const &handle, graph_t< int32_t, int32_t, true, false > &&graph, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, true, false >, float > > &&edge_weights, std::optional< rmm::device_uvector< int32_t > > &&renumber_map, bool do_expensive_check)

template std::tuple< graph_t< int32_t, int32_t, false, false >, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, false, false >, float > >, std::optional< rmm::device_uvector< int32_t > > > transpose_graph (raft::handle_t const &handle, graph_t< int32_t, int32_t, false, false > &&graph, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, false, false >, float > > &&edge_weights, std::optional< rmm::device_uvector< int32_t > > &&renumber_map, bool do_expensive_check)

template std::tuple< graph_t< int32_t, int32_t, true, false >, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, true, false >, double > >, std::optional< rmm::device_uvector< int32_t > > > transpose_graph (raft::handle_t const &handle, graph_t< int32_t, int32_t, true, false > &&graph, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, true, false >, double > > &&edge_weights, std::optional< rmm::device_uvector< int32_t > > &&renumber_map, bool do_expensive_check)

template std::tuple< graph_t< int32_t, int32_t, false, false >, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, false, false >, double > >, std::optional< rmm::device_uvector< int32_t > > > transpose_graph (raft::handle_t const &handle, graph_t< int32_t, int32_t, false, false > &&graph, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, false, false >, double > > &&edge_weights, std::optional< rmm::device_uvector< int32_t > > &&renumber_map, bool do_expensive_check)

template std::tuple< graph_t< int64_t, int64_t, true, false >, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, true, false >, float > >, std::optional< rmm::device_uvector< int64_t > > > transpose_graph (raft::handle_t const &handle, graph_t< int64_t, int64_t, true, false > &&graph, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, true, false >, float > > &&edge_weights, std::optional< rmm::device_uvector< int64_t > > &&renumber_map, bool do_expensive_check)

template std::tuple< graph_t< int64_t, int64_t, false, false >, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, false, false >, float > >, std::optional< rmm::device_uvector< int64_t > > > transpose_graph (raft::handle_t const &handle, graph_t< int64_t, int64_t, false, false > &&graph, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, false, false >, float > > &&edge_weights, std::optional< rmm::device_uvector< int64_t > > &&renumber_map, bool do_expensive_check)

template std::tuple< graph_t< int64_t, int64_t, true, false >, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, true, false >, double > >, std::optional< rmm::device_uvector< int64_t > > > transpose_graph (raft::handle_t const &handle, graph_t< int64_t, int64_t, true, false > &&graph, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, true, false >, double > > &&edge_weights, std::optional< rmm::device_uvector< int64_t > > &&renumber_map, bool do_expensive_check)

template std::tuple< graph_t< int64_t, int64_t, false, false >, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, false, false >, double > >, std::optional< rmm::device_uvector< int64_t > > > transpose_graph (raft::handle_t const &handle, graph_t< int64_t, int64_t, false, false > &&graph, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, false, false >, double > > &&edge_weights, std::optional< rmm::device_uvector< int64_t > > &&renumber_map, bool do_expensive_check)

template<typename vertex_t, typename edge_t, typename weight_t, bool store_transposed, bool multi_gpu> std::tuple<graph_t<vertex_t, edge_t, !store_transposed, multi_gpu>, std::optional<edge_property_t<graph_view_t<vertex_t, edge_t, !store_transposed, multi_gpu>, weight_t>>, std::optional<rmm::device_uvector<vertex_t>>> transpose_graph_storage(raft::handle_t const &handle, graph_t<vertex_t, edge_t, store_transposed, multi_gpu> &&graph, std::optional<edge_property_t<graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu>, weight_t>> &&edge_weights, std::optional<rmm::device_uvector<vertex_t>> &&renumber_map, bool do_expensive_check = false)#

Transpose the storage format (no change in an actual graph topology).

In SG, convert between CSR and CSC. In multi-GPU, currently convert between CSR + DCSR hybrid and CSC + DCSC hybrid (but the internal representation in multi-GPU is subject to change).

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
weight_t – Type of edge weights. Needs to be a floating point type.
store_transposed – Flag indicating whether to use sources (if false) or destinations (if true) as major indices in storing edges using a 2D sparse matrix.
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false) or multi-GPU (true).

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph – Graph object to transpose its storage format.
edge_weights – Optional owning object holding edge weights for graph.
renumber_map – Renumber map to recover the original vertex IDs from the renumbered vertex IDs. This should be valid if multi-GPU.
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

std::tuple<graph_t<vertex_t, edge_t, weight_t, !store_transposed, multi_gpu>,

Returns:

Return a storage transposed graph, an owning object holding edge weights (if edge_weights.has_value() is true) and a new renumber map (to recover the original vertex IDs, if renumber_map.has_value() is true).

template std::tuple< graph_t< int32_t, int32_t, false, true >, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, false, true >, float > >, std::optional< rmm::device_uvector< int32_t > > > transpose_graph_storage (raft::handle_t const &handle, graph_t< int32_t, int32_t, true, true > &&graph, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, true, true >, float > > &&edge_weights, std::optional< rmm::device_uvector< int32_t > > &&renumber_map, bool do_expensive_check)

template std::tuple< graph_t< int32_t, int32_t, true, true >, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, true, true >, float > >, std::optional< rmm::device_uvector< int32_t > > > transpose_graph_storage (raft::handle_t const &handle, graph_t< int32_t, int32_t, false, true > &&graph, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, false, true >, float > > &&edge_weights, std::optional< rmm::device_uvector< int32_t > > &&renumber_map, bool do_expensive_check)

template std::tuple< graph_t< int32_t, int32_t, false, true >, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, false, true >, double > >, std::optional< rmm::device_uvector< int32_t > > > transpose_graph_storage (raft::handle_t const &handle, graph_t< int32_t, int32_t, true, true > &&graph, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, true, true >, double > > &&edge_weights, std::optional< rmm::device_uvector< int32_t > > &&renumber_map, bool do_expensive_check)

template std::tuple< graph_t< int32_t, int32_t, true, true >, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, true, true >, double > >, std::optional< rmm::device_uvector< int32_t > > > transpose_graph_storage (raft::handle_t const &handle, graph_t< int32_t, int32_t, false, true > &&graph, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, false, true >, double > > &&edge_weights, std::optional< rmm::device_uvector< int32_t > > &&renumber_map, bool do_expensive_check)

template std::tuple< graph_t< int64_t, int64_t, false, true >, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, false, true >, float > >, std::optional< rmm::device_uvector< int64_t > > > transpose_graph_storage (raft::handle_t const &handle, graph_t< int64_t, int64_t, true, true > &&graph, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, true, true >, float > > &&edge_weights, std::optional< rmm::device_uvector< int64_t > > &&renumber_map, bool do_expensive_check)

template std::tuple< graph_t< int64_t, int64_t, true, true >, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, true, true >, float > >, std::optional< rmm::device_uvector< int64_t > > > transpose_graph_storage (raft::handle_t const &handle, graph_t< int64_t, int64_t, false, true > &&graph, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, false, true >, float > > &&edge_weights, std::optional< rmm::device_uvector< int64_t > > &&renumber_map, bool do_expensive_check)

template std::tuple< graph_t< int64_t, int64_t, false, true >, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, false, true >, double > >, std::optional< rmm::device_uvector< int64_t > > > transpose_graph_storage (raft::handle_t const &handle, graph_t< int64_t, int64_t, true, true > &&graph, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, true, true >, double > > &&edge_weights, std::optional< rmm::device_uvector< int64_t > > &&renumber_map, bool do_expensive_check)

template std::tuple< graph_t< int64_t, int64_t, true, true >, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, true, true >, double > >, std::optional< rmm::device_uvector< int64_t > > > transpose_graph_storage (raft::handle_t const &handle, graph_t< int64_t, int64_t, false, true > &&graph, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, false, true >, double > > &&edge_weights, std::optional< rmm::device_uvector< int64_t > > &&renumber_map, bool do_expensive_check)

template std::tuple< graph_t< int32_t, int32_t, false, false >, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, false, false >, float > >, std::optional< rmm::device_uvector< int32_t > > > transpose_graph_storage (raft::handle_t const &handle, graph_t< int32_t, int32_t, true, false > &&graph, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, true, false >, float > > &&edge_weights, std::optional< rmm::device_uvector< int32_t > > &&renumber_map, bool do_expensive_check)

template std::tuple< graph_t< int32_t, int32_t, true, false >, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, true, false >, float > >, std::optional< rmm::device_uvector< int32_t > > > transpose_graph_storage (raft::handle_t const &handle, graph_t< int32_t, int32_t, false, false > &&graph, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, false, false >, float > > &&edge_weights, std::optional< rmm::device_uvector< int32_t > > &&renumber_map, bool do_expensive_check)

template std::tuple< graph_t< int32_t, int32_t, false, false >, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, false, false >, double > >, std::optional< rmm::device_uvector< int32_t > > > transpose_graph_storage (raft::handle_t const &handle, graph_t< int32_t, int32_t, true, false > &&graph, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, true, false >, double > > &&edge_weights, std::optional< rmm::device_uvector< int32_t > > &&renumber_map, bool do_expensive_check)

template std::tuple< graph_t< int32_t, int32_t, true, false >, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, true, false >, double > >, std::optional< rmm::device_uvector< int32_t > > > transpose_graph_storage (raft::handle_t const &handle, graph_t< int32_t, int32_t, false, false > &&graph, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, false, false >, double > > &&edge_weights, std::optional< rmm::device_uvector< int32_t > > &&renumber_map, bool do_expensive_check)

template std::tuple< graph_t< int64_t, int64_t, false, false >, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, false, false >, float > >, std::optional< rmm::device_uvector< int64_t > > > transpose_graph_storage (raft::handle_t const &handle, graph_t< int64_t, int64_t, true, false > &&graph, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, true, false >, float > > &&edge_weights, std::optional< rmm::device_uvector< int64_t > > &&renumber_map, bool do_expensive_check)

template std::tuple< graph_t< int64_t, int64_t, true, false >, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, true, false >, float > >, std::optional< rmm::device_uvector< int64_t > > > transpose_graph_storage (raft::handle_t const &handle, graph_t< int64_t, int64_t, false, false > &&graph, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, false, false >, float > > &&edge_weights, std::optional< rmm::device_uvector< int64_t > > &&renumber_map, bool do_expensive_check)

template std::tuple< graph_t< int64_t, int64_t, false, false >, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, false, false >, double > >, std::optional< rmm::device_uvector< int64_t > > > transpose_graph_storage (raft::handle_t const &handle, graph_t< int64_t, int64_t, true, false > &&graph, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, true, false >, double > > &&edge_weights, std::optional< rmm::device_uvector< int64_t > > &&renumber_map, bool do_expensive_check)

template std::tuple< graph_t< int64_t, int64_t, true, false >, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, true, false >, double > >, std::optional< rmm::device_uvector< int64_t > > > transpose_graph_storage (raft::handle_t const &handle, graph_t< int64_t, int64_t, false, false > &&graph, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, false, false >, double > > &&edge_weights, std::optional< rmm::device_uvector< int64_t > > &&renumber_map, bool do_expensive_check)

template void bfs (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, int32_t *distances, int32_t *predecessors, int32_t const *sources, size_t n_sources, bool direction_optimizing, int32_t depth_limit, bool do_expensive_check)

template void bfs (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, int64_t *distances, int64_t *predecessors, int64_t const *sources, size_t n_sources, bool direction_optimizing, int64_t depth_limit, bool do_expensive_check)

template void bfs (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, int32_t *distances, int32_t *predecessors, int32_t const *sources, size_t n_sources, bool direction_optimizing, int32_t depth_limit, bool do_expensive_check)

template void bfs (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, int64_t *distances, int64_t *predecessors, int64_t const *sources, size_t n_sources, bool direction_optimizing, int64_t depth_limit, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, int32_t > extract_bfs_paths (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, int32_t const *distances, int32_t const *predecessors, int32_t const *destinations, size_t n_destinations)

template std::tuple< rmm::device_uvector< int64_t >, int64_t > extract_bfs_paths (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, int64_t const *distances, int64_t const *predecessors, int64_t const *destinations, size_t n_destinations)

template std::tuple< rmm::device_uvector< int32_t >, int32_t > extract_bfs_paths (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, int32_t const *distances, int32_t const *predecessors, int32_t const *destinations, size_t n_destinations)

template std::tuple< rmm::device_uvector< int64_t >, int64_t > extract_bfs_paths (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, int64_t const *distances, int64_t const *predecessors, int64_t const *destinations, size_t n_destinations)

template<typename vertex_t, typename edge_t, bool multi_gpu> std::tuple<rmm::device_uvector<size_t>, rmm::device_uvector<vertex_t>> k_hop_nbrs(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, false, multi_gpu> const &graph_view, raft::device_span<vertex_t const> start_vertices, size_t k, bool do_expensive_check)#

template std::tuple< rmm::device_uvector< size_t >, rmm::device_uvector< int32_t > > k_hop_nbrs (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, raft::device_span< int32_t const > start_vertices, size_t k, bool do_expensive_check)

template std::tuple< rmm::device_uvector< size_t >, rmm::device_uvector< int64_t > > k_hop_nbrs (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, raft::device_span< int64_t const > start_vertices, size_t k, bool do_expensive_check)

template std::tuple< rmm::device_uvector< size_t >, rmm::device_uvector< int32_t > > k_hop_nbrs (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, raft::device_span< int32_t const > start_vertices, size_t k, bool do_expensive_check)

template std::tuple< rmm::device_uvector< size_t >, rmm::device_uvector< int64_t > > k_hop_nbrs (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, raft::device_span< int64_t const > start_vertices, size_t k, bool do_expensive_check)

template rmm::device_uvector< float > od_shortest_distances (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, edge_property_view_t< int32_t, float const * > edge_weight_view, raft::device_span< int32_t const > origins, raft::device_span< int32_t const > destinations, float cutoff, bool do_expensive_check)

template rmm::device_uvector< double > od_shortest_distances (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, edge_property_view_t< int32_t, double const * > edge_weight_view, raft::device_span< int32_t const > origins, raft::device_span< int32_t const > destinations, double cutoff, bool do_expensive_check)

template rmm::device_uvector< float > od_shortest_distances (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, edge_property_view_t< int64_t, float const * > edge_weight_view, raft::device_span< int64_t const > origins, raft::device_span< int64_t const > destinations, float cutoff, bool do_expensive_check)

template rmm::device_uvector< double > od_shortest_distances (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, edge_property_view_t< int64_t, double const * > edge_weight_view, raft::device_span< int64_t const > origins, raft::device_span< int64_t const > destinations, double cutoff, bool do_expensive_check)

template void sssp (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, edge_property_view_t< int32_t, float const * > edge_weight_view, float *distances, int32_t *predecessors, int32_t source_vertex, float cutoff, bool do_expensive_check)

template void sssp (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, edge_property_view_t< int32_t, double const * > edge_weight_view, double *distances, int32_t *predecessors, int32_t source_vertex, double cutoff, bool do_expensive_check)

template void sssp (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, edge_property_view_t< int64_t, float const * > edge_weight_view, float *distances, int64_t *predecessors, int64_t source_vertex, float cutoff, bool do_expensive_check)

template void sssp (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, edge_property_view_t< int64_t, double const * > edge_weight_view, double *distances, int64_t *predecessors, int64_t source_vertex, double cutoff, bool do_expensive_check)

template void sssp (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, edge_property_view_t< int32_t, float const * > edge_weight_view, float *distances, int32_t *predecessors, int32_t source_vertex, float cutoff, bool do_expensive_check)

template void sssp (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, edge_property_view_t< int32_t, double const * > edge_weight_view, double *distances, int32_t *predecessors, int32_t source_vertex, double cutoff, bool do_expensive_check)

template void sssp (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, edge_property_view_t< int64_t, float const * > edge_weight_view, float *distances, int64_t *predecessors, int64_t source_vertex, float cutoff, bool do_expensive_check)

template void sssp (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, edge_property_view_t< int64_t, double const * > edge_weight_view, double *distances, int64_t *predecessors, int64_t source_vertex, double cutoff, bool do_expensive_check)

template std::unique_ptr< legacy::GraphCOO< int, int, float > > minimum_spanning_tree< int, int, float > (raft::handle_t const &handle, legacy::GraphCSRView< int, int, float > const &graph, rmm::device_async_resource_ref mr)

template std::unique_ptr< legacy::GraphCOO< int, int, double > > minimum_spanning_tree< int, int, double > (raft::handle_t const &handle, legacy::GraphCSRView< int, int, double > const &graph, rmm::device_async_resource_ref mr)

template<typename KVStoreViewType, typename KeyIterator, typename KeyToCommRankOp> dataframe_buffer_type_t<typename KVStoreViewType::value_type> collect_values_for_keys(raft::comms::comms_t const &comm, KVStoreViewType kv_store_view, KeyIterator collect_key_first, KeyIterator collect_key_last, KeyToCommRankOp key_to_comm_rank_op, rmm::cuda_stream_view stream_view)#

template<typename KVStoreViewType, typename KeyToCommRankOp> std::tuple<rmm::device_uvector<typename KVStoreViewType::key_type>, dataframe_buffer_type_t<typename KVStoreViewType::value_type>> collect_values_for_unique_keys(raft::comms::comms_t const &comm, KVStoreViewType kv_store_view, rmm::device_uvector<typename KVStoreViewType::key_type> &&collect_unique_keys, KeyToCommRankOp key_to_comm_rank_op, rmm::cuda_stream_view stream_view)#

template<typename vertex_t, typename ValueIterator> dataframe_buffer_type_t<typename thrust::iterator_traits<ValueIterator>::value_type> collect_values_for_sorted_unique_int_vertices(raft::comms::comms_t const &comm, raft::device_span<vertex_t const> collect_sorted_unique_int_vertices, ValueIterator local_value_first, std::vector<vertex_t> const &comm_rank_vertex_partition_range_lasts, vertex_t local_vertex_partition_range_first, rmm::cuda_stream_view stream_view)#

template<typename VertexIterator, typename ValueIterator> dataframe_buffer_type_t<typename thrust::iterator_traits<ValueIterator>::value_type> collect_values_for_int_vertices(raft::comms::comms_t const &comm, VertexIterator collect_vertex_first, VertexIterator collect_vertex_last, ValueIterator local_value_first, std::vector<typename thrust::iterator_traits<VertexIterator>::value_type> const &comm_rank_vertex_partition_range_lasts, typename thrust::iterator_traits<VertexIterator>::value_type local_vertex_partition_range_first, rmm::cuda_stream_view stream_view)#

template<typename T> rmm::device_uvector<T> device_allgatherv(raft::handle_t const &handle, raft::comms::comms_t const &comms, raft::device_span<T const> d_input)#

template<typename vertex_t, typename weight_t> void get_traversed_cost(raft::handle_t const &handle, vertex_t const *vertices, vertex_t const *preds, weight_t const *info_weights, weight_t *out, vertex_t stop_vertex, vertex_t num_vertices)#

Takes the results of BFS or SSSP function call and sums the given weights along the path to the starting vertex.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
weight_t – Type of edge weights. Needs to be a floating point type.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms. Must have at least one worker stream.
vertices – Pointer to vertex ids.
preds – Pointer to predecessors.
info_weights – Secondary weights along the edge from predecessor to vertex.
out – Contains for each index the sum of weights along the path unfolding.
num_vertices – Number of vertices.

template void get_traversed_cost< int32_t, float > (raft::handle_t const &handle, int32_t const *vertices, int32_t const *preds, float const *info_weights, float *out, int32_t stop_vertex, int32_t num_vertices)

template void get_traversed_cost< int32_t, double > (raft::handle_t const &handle, int32_t const *vertices, int32_t const *preds, double const *info_weights, double *out, int32_t stop_vertex, int32_t num_vertices)

template void get_traversed_cost< int64_t, float > (raft::handle_t const &handle, int64_t const *vertices, int64_t const *preds, float const *info_weights, float *out, int64_t stop_vertex, int64_t num_vertices)

template void get_traversed_cost< int64_t, double > (raft::handle_t const &handle, int64_t const *vertices, int64_t const *preds, double const *info_weights, double *out, int64_t stop_vertex, int64_t num_vertices)

template<typename vertex_t, typename edge_t, typename weight_t, typename edge_type_t> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<weight_t>>, std::optional<rmm::device_uvector<edge_t>>, std::optional<rmm::device_uvector<edge_type_t>>, std::vector<size_t>> shuffle_external_edges(raft::handle_t const &handle, rmm::device_uvector<vertex_t> &&edge_srcs, rmm::device_uvector<vertex_t> &&edge_dsts, std::optional<rmm::device_uvector<weight_t>> &&edge_weights, std::optional<rmm::device_uvector<edge_t>> &&edge_ids, std::optional<rmm::device_uvector<edge_type_t>> &&edge_types)#

Shuffle external edges to the proper GPU.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
weight_t – Type of edge weight. Currently float and double are supported.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
edge_srcs – List of source vertex ids
edge_dsts – List of destination vertex ids
edge_weights – Optional list of edge weights
edge_ids – Optional list of edge ids
edge_types – Optional list of edge types

Returns:

Tuple of vectors storing edge sources, destinations, optional weights, optional edge ids, optional edge types mapped to this GPU and a vector storing the number of edges received from each GPU.

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::vector< size_t > > shuffle_external_edges (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&majors, rmm::device_uvector< int32_t > &&minors, std::optional< rmm::device_uvector< float > > &&weights, std::optional< rmm::device_uvector< int32_t > > &&edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edge_types)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::vector< size_t > > shuffle_external_edges (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&majors, rmm::device_uvector< int32_t > &&minors, std::optional< rmm::device_uvector< double > > &&weights, std::optional< rmm::device_uvector< int32_t > > &&edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edge_types)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::vector< size_t > > shuffle_external_edges (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&majors, rmm::device_uvector< int64_t > &&minors, std::optional< rmm::device_uvector< float > > &&weights, std::optional< rmm::device_uvector< int64_t > > &&edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edge_types)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::vector< size_t > > shuffle_external_edges (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&majors, rmm::device_uvector< int64_t > &&minors, std::optional< rmm::device_uvector< double > > &&weights, std::optional< rmm::device_uvector< int64_t > > &&edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edge_types)

template<typename vertex_t, typename value_t> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<value_t>> shuffle_external_vertex_value_pairs(raft::handle_t const &handle, rmm::device_uvector<vertex_t> &&vertices, rmm::device_uvector<value_t> &&values)#

Shuffle external vertex ids and values to the proper GPU.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
value_t – Type of values. currently supported types are int32_t, int64_t, size_t, float and double.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
vertices – List of vertex ids
values – List of values

Returns:

Tuple of vectors storing vertex ids and values mapped to this GPU.

template<typename vertex_t> rmm::device_uvector<vertex_t> shuffle_external_vertices(raft::handle_t const &handle, rmm::device_uvector<vertex_t> &&vertices)#

Shuffle external vertex ids to the proper GPU.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
vertices – List of vertex ids

Returns:

Vector of vertex ids mapped to this GPU.

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< float > > shuffle_external_vertex_value_pairs (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&vertices, rmm::device_uvector< float > &&values)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< double > > shuffle_external_vertex_value_pairs (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&vertices, rmm::device_uvector< double > &&values)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t > > shuffle_external_vertex_value_pairs (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&vertices, rmm::device_uvector< int32_t > &&values)

template rmm::device_uvector< int32_t > shuffle_external_vertices (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&d_vertices)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< size_t > > shuffle_external_vertex_value_pairs (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&vertices, rmm::device_uvector< size_t > &&values)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< float > > shuffle_external_vertex_value_pairs (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&vertices, rmm::device_uvector< float > &&values)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< double > > shuffle_external_vertex_value_pairs (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&vertices, rmm::device_uvector< double > &&values)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int32_t > > shuffle_external_vertex_value_pairs (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&vertices, rmm::device_uvector< int32_t > &&values)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< size_t > > shuffle_external_vertex_value_pairs (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&vertices, rmm::device_uvector< size_t > &&values)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t > > shuffle_external_vertex_value_pairs (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&vertices, rmm::device_uvector< int64_t > &&values)

template rmm::device_uvector< int64_t > shuffle_external_vertices (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&d_vertices)

template<typename edge_t, typename ...Iters, typename ...Types> auto view_concat(edge_property_view_t<edge_t, Iters, Types> const&... views)#

template<typename vertex_t, typename ...Iters, typename ...Types> auto view_concat(detail::edge_major_property_view_t<vertex_t, Iters, Types> const&... views)#

template<typename vertex_t, typename ...Iters, typename ...Types> auto view_concat(detail::edge_minor_property_view_t<vertex_t, Iters, Types> const&... views)#

template<typename vertex_t> __host__ __device__ std::enable_if_t< std::is_signed< vertex_t >::value, bool > is_valid_vertex (vertex_t num_vertices, vertex_t v)

template<typename vertex_t> __host__ __device__ std::enable_if_t< std::is_unsigned< vertex_t >::value, bool > is_valid_vertex (vertex_t num_vertices, vertex_t v)

template<typename vertex_t, typename edge_t, typename weight_t, typename edge_id_t, typename edge_type_t, bool store_transposed, bool multi_gpu> std::tuple<graph_t<vertex_t, edge_t, store_transposed, multi_gpu>, std::optional<edge_property_t<graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu>, weight_t>>, std::optional<edge_property_t<graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu>, edge_id_t>>, std::optional<edge_property_t<graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu>, edge_type_t>>, std::optional<rmm::device_uvector<vertex_t>>> create_graph_from_edgelist(raft::handle_t const &handle, std::optional<rmm::device_uvector<vertex_t>> &&vertices, rmm::device_uvector<vertex_t> &&edgelist_srcs, rmm::device_uvector<vertex_t> &&edgelist_dsts, std::optional<rmm::device_uvector<weight_t>> &&edgelist_weights, std::optional<rmm::device_uvector<edge_id_t>> &&edgelist_edge_ids, std::optional<rmm::device_uvector<edge_type_t>> &&edgelist_edge_types, graph_properties_t graph_properties, bool renumber, bool do_expensive_check = false)#

create a graph from (the optional vertex list and) the given edge list (with optional edge IDs and types).

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
weight_t – Type of edge weight. Needs to be floating point type
edge_id_t – Type of edge id. Needs to be an integral type
edge_type_t – Type of edge type. Needs to be an integral type, currently only int32_t is supported
store_transposed – Flag indicating whether to use sources (if false) or destinations (if true) as major indices in storing edges using a 2D sparse matrix.
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false) or multi-GPU (true).

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
vertices – If valid, part of the entire set of vertices in the graph to be renumbered. This parameter can be used to include isolated vertices. If renumber is false and vertices is valid, vertices elements should be consecutive integers starting from 0. If multi-GPU, applying the compute_gpu_id_from_vertex_t to every vertex should return the local GPU ID for this function to work (vertices should be pre-shuffled).
edgelist_srcs – Vector of edge source vertex IDs. If multi-GPU, applying the compute_gpu_id_from_ext_edge_endpoints_t to every edge should return the local GPU ID for this function to work (edges should be pre-shuffled).
edgelist_dsts – Vector of edge destination vertex IDs.
edgelist_weights – Vector of weight values for edges
edgelist_edge_ids – Vector of edge_id values for edges
edgelist_edge_types – Vector of edge_type values for edges
graph_properties – Properties of the graph represented by the input (optional vertex list and) edge list.
renumber – Flag indicating whether to renumber vertices or not (must be true if multi_gpu is true).
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

Tuple of the generated graph and optional edge_property_t objects storing the provided edge properties and a renumber map (if renumber is true).

template<typename vertex_t, typename edge_t, typename weight_t, typename edge_id_t, typename edge_type_t, bool store_transposed, bool multi_gpu> std::tuple<graph_t<vertex_t, edge_t, store_transposed, multi_gpu>, std::optional<edge_property_t<graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu>, weight_t>>, std::optional<edge_property_t<graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu>, edge_id_t>>, std::optional<edge_property_t<graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu>, edge_type_t>>, std::optional<rmm::device_uvector<vertex_t>>> create_graph_from_edgelist(raft::handle_t const &handle, std::optional<rmm::device_uvector<vertex_t>> &&vertices, std::vector<rmm::device_uvector<vertex_t>> &&edgelist_srcs, std::vector<rmm::device_uvector<vertex_t>> &&edgelist_dsts, std::optional<std::vector<rmm::device_uvector<weight_t>>> &&edgelist_weights, std::optional<std::vector<rmm::device_uvector<edge_id_t>>> &&edgelist_edge_ids, std::optional<std::vector<rmm::device_uvector<edge_type_t>>> &&edgelist_edge_types, graph_properties_t graph_properties, bool renumber, bool do_expensive_check = false)#

create a graph from (the optional vertex list and) the given edge list (with optional edge IDs and types).

This version takes edge list in multiple chunks (e.g. edge data from multiple files).

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
weight_t – Type of edge weight. Needs to be floating point type
edge_id_t – Type of edge id. Needs to be an integral type
edge_type_t – Type of edge type. Needs to be an integral type, currently only int32_t is supported
store_transposed – Flag indicating whether to use sources (if false) or destinations (if true) as major indices in storing edges using a 2D sparse matrix.
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false) or multi-GPU (true).

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
vertices – If valid, part of the entire set of vertices in the graph to be renumbered. This parameter can be used to include isolated vertices. If renumber is false and vertices is valid, vertices elements should be consecutive integers starting from 0. If multi-GPU, applying the compute_gpu_id_from_vertex_t to every vertex should return the local GPU ID for this function to work (vertices should be pre-shuffled).
edgelist_srcs – Vectors of edge source vertex IDs. If multi-GPU, applying the compute_gpu_id_from_ext_edge_endpoints_t to every edge should return the local GPU ID for this function to work (edges should be pre-shuffled).
edgelist_dsts – Vectors of edge destination vertex IDs.
edgelist_weights – Vectors of weight values for edges
edgelist_edge_ids – Vectors of edge_id values for edges
edgelist_edge_types – Vectors of edge_type values for edges
graph_properties – Properties of the graph represented by the input (optional vertex list and) edge list.
renumber – Flag indicating whether to renumber vertices or not (must be true if multi_gpu is true).
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

Tuple of the generated graph and optional edge_property_t objects storing the provided edge properties and a renumber map (if renumber is true).

template<typename vertex_t, typename edge_t, bool store_transposed, bool multi_gpu> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>> get_two_hop_neighbors(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu> const &graph_view, std::optional<raft::device_span<vertex_t const>> start_vertices)#

Find all 2-hop neighbors in the graph.

Find pairs of vertices in the input graph such that each pair is connected by a path that is two hops in length.

Throws:

cugraph::logic_error – when an error occurs.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
store_transposed – Flag indicating whether to use sources (if false) or destinations (if true) as major indices in storing edges using a 2D sparse matrix.
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false) or multi-GPU (true).

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph – The input graph object
start_vertices – Optional list of starting vertices to discover two-hop neighbors of

Returns:

tuple containing pairs of vertices that are 2-hops apart.

template<typename value_t> void comms_bcast(const raft::handle_t &handle, value_t *value, size_t count)#

Broadcast using handle communicator.

Use handle’s communicator to operate broadcasting.

Throws:

cugraph::logic_error – when an error occurs.

Template Parameters:

value_t – Type of the data to broadcast

Parameters:

value – [out] Point to the data
count – [in] Number of elements to broadcast

template<typename vertex_t, typename edge_t, typename edge_type_t, bool multi_gpu> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>> lookup_endpoints_from_edge_ids_and_single_type(raft::handle_t const &handle, lookup_container_t<edge_t, edge_type_t, vertex_t> const &lookup_container, raft::device_span<edge_t const> edge_ids_to_lookup, edge_type_t edge_type_to_lookup)#

template<typename vertex_t, typename edge_t, typename edge_type_t, bool multi_gpu> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>> lookup_endpoints_from_edge_ids_and_types(raft::handle_t const &handle, lookup_container_t<edge_t, edge_type_t, vertex_t> const &lookup_container, raft::device_span<edge_t const> edge_ids_to_lookup, raft::device_span<edge_type_t const> edge_types_to_lookup)#

template<typename Iterator, typename T> __device__ std::enable_if_t< thrust::detail::is_discard_iterator< Iterator >::value, void > atomic_and (Iterator iter, T value)

template<typename Iterator, typename T> __device__ std::enable_if_t< std::is_arithmetic_v< T > &&std::is_same_v< typename thrust::iterator_traits< Iterator >::value_type, T >, T > atomic_and (Iterator iter, T value)

template<typename Iterator, typename T> __device__ std::enable_if_t< is_thrust_tuple< T >::value &&std::is_same_v< typename thrust::iterator_traits< Iterator >::value_type, T >, T > atomic_and (Iterator iter, T value)

template<typename Iterator, typename T> __device__ std::enable_if_t< thrust::detail::is_discard_iterator< Iterator >::value, void > atomic_or (Iterator iter, T value)

template<typename Iterator, typename T> __device__ std::enable_if_t< std::is_arithmetic_v< T > &&std::is_same_v< typename thrust::iterator_traits< Iterator >::value_type, T >, T > atomic_or (Iterator iter, T value)

template<typename Iterator, typename T> __device__ std::enable_if_t< is_thrust_tuple< T >::value &&std::is_same_v< typename thrust::iterator_traits< Iterator >::value_type, T >, T > atomic_or (Iterator iter, T value)

template<typename Iterator, typename T> __device__ std::enable_if_t< thrust::detail::is_discard_iterator< Iterator >::value, void > atomic_add (Iterator iter, T value)

template<typename Iterator, typename T> __device__ std::enable_if_t< std::is_arithmetic_v< T > &&std::is_same_v< typename thrust::iterator_traits< Iterator >::value_type, T >, T > atomic_add (Iterator iter, T value)

template<typename Iterator, typename T> __device__ std::enable_if_t< is_thrust_tuple< typename thrust::iterator_traits< Iterator >::value_type >::value &&is_thrust_tuple< T >::value, T > atomic_add (Iterator iter, T value)

template<typename Iterator, typename T> __device__ std::enable_if_t< std::is_arithmetic_v< T > &&std::is_same_v< typename thrust::iterator_traits< Iterator >::value_type, T >, T > elementwise_atomic_cas (Iterator iter, T compare, T value)

template<typename Iterator, typename T> __device__ std::enable_if_t< is_thrust_tuple< T >::value &&std::is_same_v< typename thrust::iterator_traits< Iterator >::value_type, T >, T > elementwise_atomic_cas (Iterator iter, T compare, T value)

template<typename Iterator, typename T> __device__ std::enable_if_t< thrust::detail::is_discard_iterator< Iterator >::value, void > elementwise_atomic_min (Iterator iter, T const &value)

template<typename Iterator, typename T> __device__ std::enable_if_t< std::is_same< typename thrust::iterator_traits< Iterator >::value_type, T >::value &&std::is_arithmetic< T >::value, T > elementwise_atomic_min (Iterator iter, T const &value)

template<typename Iterator, typename T> __device__ std::enable_if_t< is_thrust_tuple< typename thrust::iterator_traits< Iterator >::value_type >::value &&is_thrust_tuple< T >::value, T > elementwise_atomic_min (Iterator iter, T const &value)

template<typename Iterator, typename T> __device__ std::enable_if_t< thrust::detail::is_discard_iterator< Iterator >::value, void > elementwise_atomic_max (Iterator iter, T const &value)

template<typename Iterator, typename T> __device__ std::enable_if_t< std::is_same< typename thrust::iterator_traits< Iterator >::value_type, T >::value &&std::is_arithmetic< T >::value, T > elementwise_atomic_max (Iterator iter, T const &value)

template<typename Iterator, typename T> __device__ std::enable_if_t< is_thrust_tuple< typename thrust::iterator_traits< Iterator >::value_type >::value &&is_thrust_tuple< T >::value, T > elementwise_atomic_max (Iterator iter, T const &value)

template<typename Iterator, typename T> __device__ void packed_bool_atomic_set (Iterator iter, T offset, bool val)

template<typename T, typename std::enable_if_t<std::is_arithmetic<T>::value>* = nullptr> auto allocate_dataframe_buffer(size_t buffer_size, rmm::cuda_stream_view stream_view)#

template<typename T> std::optional<dataframe_buffer_type_t<T>> try_allocate_dataframe_buffer(size_t buffer_size, rmm::cuda_stream_view stream_view)#

template<typename BufferType> void reserve_dataframe_buffer(BufferType &buffer, size_t new_buffer_capacity, rmm::cuda_stream_view stream_view)#

template<typename BufferType> void resize_dataframe_buffer(BufferType &buffer, size_t new_buffer_size, rmm::cuda_stream_view stream_view)#

template<typename BufferType> void shrink_to_fit_dataframe_buffer(BufferType &buffer, rmm::cuda_stream_view stream_view)#

template<typename BufferType> size_t size_dataframe_buffer(BufferType &buffer)#

template<typename BufferType, typename std::enable_if_t<is_arithmetic_vector<std::remove_cv_t<BufferType>, rmm::device_uvector>::value>* = nullptr> auto get_dataframe_buffer_begin(BufferType &buffer)#

template<typename BufferType, typename std::enable_if_t<is_arithmetic_vector<std::remove_cv_t<BufferType>, rmm::device_uvector>::value>* = nullptr> auto get_dataframe_buffer_cbegin(BufferType &buffer)#

template<typename BufferType, typename std::enable_if_t<is_arithmetic_vector<std::remove_cv_t<BufferType>, rmm::device_uvector>::value>* = nullptr> auto get_dataframe_buffer_end(BufferType &buffer)#

template<typename BufferType, typename std::enable_if_t<is_arithmetic_vector<std::remove_cv_t<BufferType>, rmm::device_uvector>::value>* = nullptr> auto get_dataframe_buffer_cend(BufferType &buffer)#

template<typename InputIterator, typename OutputIterator> std::enable_if_t<std::is_arithmetic<typename std::iterator_traits<InputIterator>::value_type>::value, void> device_isend(raft::comms::comms_t const &comm, InputIterator input_first, size_t count, int dst, int base_tag, raft::comms::request_t *requests)#

template<typename InputIterator, typename OutputIterator> std::enable_if_t<is_thrust_tuple_of_arithmetic<typename std::iterator_traits<InputIterator>::value_type>::value && is_thrust_tuple<typename std::iterator_traits<OutputIterator>::value_type>::value, void> device_isend(raft::comms::comms_t const &comm, InputIterator input_first, size_t count, int dst, int base_tag, raft::comms::request_t *requests)#

template<typename InputIterator, typename OutputIterator> std::enable_if_t<std::is_arithmetic<typename std::iterator_traits<InputIterator>::value_type>::value, void> device_irecv(raft::comms::comms_t const &comm, OutputIterator output_first, size_t count, int src, int base_tag, raft::comms::request_t *requests)#

template<typename InputIterator, typename OutputIterator> std::enable_if_t<is_thrust_tuple_of_arithmetic<typename std::iterator_traits<InputIterator>::value_type>::value && is_thrust_tuple<typename std::iterator_traits<OutputIterator>::value_type>::value, void> device_irecv(raft::comms::comms_t const &comm, OutputIterator output_first, size_t count, int src, int base_tag, raft::comms::request_t *requests)#

template<typename InputIterator, typename OutputIterator> std::enable_if_t<std::is_arithmetic<typename std::iterator_traits<InputIterator>::value_type>::value, void> device_sendrecv(raft::comms::comms_t const &comm, InputIterator input_first, size_t tx_count, int dst, OutputIterator output_first, size_t rx_count, int src, rmm::cuda_stream_view stream_view)#

template<typename InputIterator, typename OutputIterator> std::enable_if_t<is_thrust_tuple_of_arithmetic<typename std::iterator_traits<InputIterator>::value_type>::value && is_thrust_tuple<typename std::iterator_traits<OutputIterator>::value_type>::value, void> device_sendrecv(raft::comms::comms_t const &comm, InputIterator input_first, size_t tx_count, int dst, OutputIterator output_first, size_t rx_count, int src, rmm::cuda_stream_view stream_view)#

template<typename InputIterator, typename OutputIterator> std::enable_if_t<std::is_arithmetic<typename std::iterator_traits<InputIterator>::value_type>::value, void> device_multicast_sendrecv(raft::comms::comms_t const &comm, InputIterator input_first, std::vector<size_t> const &tx_counts, std::vector<size_t> const &tx_offsets, std::vector<int> const &tx_dst_ranks, OutputIterator output_first, std::vector<size_t> const &rx_counts, std::vector<size_t> const &rx_offsets, std::vector<int> const &rx_src_ranks, rmm::cuda_stream_view stream_view)#

template<typename InputIterator, typename OutputIterator> std::enable_if_t<is_thrust_tuple_of_arithmetic<typename std::iterator_traits<InputIterator>::value_type>::value && is_thrust_tuple<typename std::iterator_traits<OutputIterator>::value_type>::value, void> device_multicast_sendrecv(raft::comms::comms_t const &comm, InputIterator input_first, std::vector<size_t> const &tx_counts, std::vector<size_t> const &tx_offsets, std::vector<int> const &tx_dst_ranks, OutputIterator output_first, std::vector<size_t> const &rx_counts, std::vector<size_t> const &rx_offsets, std::vector<int> const &rx_src_ranks, rmm::cuda_stream_view stream_view)#

template<typename InputIterator, typename OutputIterator> std::enable_if_t<std::is_arithmetic<typename std::iterator_traits<InputIterator>::value_type>::value, void> device_bcast(raft::comms::comms_t const &comm, InputIterator input_first, OutputIterator output_first, size_t count, int root, rmm::cuda_stream_view stream_view)#

template<typename InputIterator, typename OutputIterator> std::enable_if_t<is_thrust_tuple_of_arithmetic<typename std::iterator_traits<InputIterator>::value_type>::value && is_thrust_tuple<typename std::iterator_traits<OutputIterator>::value_type>::value, void> device_bcast(raft::comms::comms_t const &comm, InputIterator input_first, OutputIterator output_first, size_t count, int root, rmm::cuda_stream_view stream_view)#

template<typename InputIterator, typename OutputIterator> std::enable_if_t<std::is_arithmetic<typename std::iterator_traits<InputIterator>::value_type>::value, void> device_allreduce(raft::comms::comms_t const &comm, InputIterator input_first, OutputIterator output_first, size_t count, raft::comms::op_t op, rmm::cuda_stream_view stream_view)#

template<typename InputIterator, typename OutputIterator> std::enable_if_t<is_thrust_tuple_of_arithmetic<typename std::iterator_traits<InputIterator>::value_type>::value && is_thrust_tuple<typename std::iterator_traits<OutputIterator>::value_type>::value, void> device_allreduce(raft::comms::comms_t const &comm, InputIterator input_first, OutputIterator output_first, size_t count, raft::comms::op_t op, rmm::cuda_stream_view stream_view)#

template<typename InputIterator, typename OutputIterator> std::enable_if_t<std::is_arithmetic<typename std::iterator_traits<InputIterator>::value_type>::value, void> device_reduce(raft::comms::comms_t const &comm, InputIterator input_first, OutputIterator output_first, size_t count, raft::comms::op_t op, int root, rmm::cuda_stream_view stream_view)#

template<typename InputIterator, typename OutputIterator> std::enable_if_t<is_thrust_tuple_of_arithmetic<typename std::iterator_traits<InputIterator>::value_type>::value && is_thrust_tuple<typename std::iterator_traits<OutputIterator>::value_type>::value, void> device_reduce(raft::comms::comms_t const &comm, InputIterator input_first, OutputIterator output_first, size_t count, raft::comms::op_t op, int root, rmm::cuda_stream_view stream_view)#

template<typename InputIterator, typename OutputIterator> std::enable_if_t<std::is_arithmetic<typename std::iterator_traits<InputIterator>::value_type>::value, void> device_allgather(raft::comms::comms_t const &comm, InputIterator input_first, OutputIterator output_first, size_t sendcount, rmm::cuda_stream_view stream_view)#

template<typename InputIterator, typename OutputIterator> std::enable_if_t<is_thrust_tuple_of_arithmetic<typename std::iterator_traits<InputIterator>::value_type>::value && is_thrust_tuple<typename std::iterator_traits<OutputIterator>::value_type>::value, void> device_allgather(raft::comms::comms_t const &comm, InputIterator input_first, OutputIterator output_first, size_t sendcount, rmm::cuda_stream_view stream_view)#

template<typename InputIterator, typename OutputIterator> std::enable_if_t<std::is_arithmetic<typename std::iterator_traits<InputIterator>::value_type>::value, void> device_allgatherv(raft::comms::comms_t const &comm, InputIterator input_first, OutputIterator output_first, std::vector<size_t> const &recvcounts, std::vector<size_t> const &displacements, rmm::cuda_stream_view stream_view)#

template<typename InputIterator, typename OutputIterator> std::enable_if_t<is_thrust_tuple_of_arithmetic<typename std::iterator_traits<InputIterator>::value_type>::value && is_thrust_tuple<typename std::iterator_traits<OutputIterator>::value_type>::value, void> device_allgatherv(raft::comms::comms_t const &comm, InputIterator input_first, OutputIterator output_first, std::vector<size_t> const &recvcounts, std::vector<size_t> const &displacements, rmm::cuda_stream_view stream_view)#

template<typename InputIterator, typename OutputIterator> std::enable_if_t<std::is_arithmetic<typename std::iterator_traits<InputIterator>::value_type>::value, void> device_gatherv(raft::comms::comms_t const &comm, InputIterator input_first, OutputIterator output_first, size_t sendcount, std::vector<size_t> const &recvcounts, std::vector<size_t> const &displacements, int root, rmm::cuda_stream_view stream_view)#

template<typename InputIterator, typename OutputIterator> std::enable_if_t<is_thrust_tuple_of_arithmetic<typename std::iterator_traits<InputIterator>::value_type>::value && is_thrust_tuple<typename std::iterator_traits<OutputIterator>::value_type>::value, void> device_gatherv(raft::comms::comms_t const &comm, InputIterator input_first, OutputIterator output_first, size_t sendcount, std::vector<size_t> const &recvcounts, std::vector<size_t> const &displacements, int root, rmm::cuda_stream_view stream_view)#

inline void device_group_start(raft::comms::comms_t const &comm)#

inline void device_group_end(raft::comms::comms_t const &comm)#

template<typename T> std::enable_if_t<std::is_arithmetic<T>::value, T> host_scalar_allreduce(raft::comms::comms_t const &comm, T input, raft::comms::op_t op, cudaStream_t stream)#

template<typename T> std::enable_if_t<cugraph::is_thrust_tuple_of_arithmetic<T>::value, T> host_scalar_allreduce(raft::comms::comms_t const &comm, T input, raft::comms::op_t op, cudaStream_t stream)#

template<typename T> std::enable_if_t<std::is_arithmetic<T>::value, T> host_scalar_reduce(raft::comms::comms_t const &comm, T input, raft::comms::op_t op, int root, cudaStream_t stream)#

template<typename T> std::enable_if_t<cugraph::is_thrust_tuple_of_arithmetic<T>::value, T> host_scalar_reduce(raft::comms::comms_t const &comm, T input, raft::comms::op_t op, int root, cudaStream_t stream)#

template<typename T> std::enable_if_t<std::is_arithmetic<T>::value, T> host_scalar_bcast(raft::comms::comms_t const &comm, T input, int root, cudaStream_t stream)#

template<typename T> std::enable_if_t<cugraph::is_thrust_tuple_of_arithmetic<T>::value, T> host_scalar_bcast(raft::comms::comms_t const &comm, T input, int root, cudaStream_t stream)#

template<typename T> std::enable_if_t<std::is_arithmetic<T>::value, std::vector<T>> host_scalar_allgather(raft::comms::comms_t const &comm, T input, cudaStream_t stream)#

template<typename T> std::enable_if_t<cugraph::is_thrust_tuple_of_arithmetic<T>::value, std::vector<T>> host_scalar_allgather(raft::comms::comms_t const &comm, T input, cudaStream_t stream)#

template<typename T> std::enable_if_t<std::is_arithmetic<T>::value, T> host_scalar_scatter(raft::comms::comms_t const &comm, std::vector<T> const &inputs, int root, cudaStream_t stream)#

template<typename T> std::enable_if_t<cugraph::is_thrust_tuple_of_arithmetic<T>::value, T> host_scalar_scatter(raft::comms::comms_t const &comm, std::vector<T> const &inputs, int root, cudaStream_t stream)#

template<typename T> std::enable_if_t<std::is_arithmetic<T>::value, std::vector<T>> host_scalar_gather(raft::comms::comms_t const &comm, T input, int root, cudaStream_t stream)#

template<typename T> std::enable_if_t<cugraph::is_thrust_tuple_of_arithmetic<T>::value, std::vector<T>> host_scalar_gather(raft::comms::comms_t const &comm, T input, int root, cudaStream_t stream)#

template<typename ValueIterator, typename value_t> bool is_packed_bool()#

template<typename ValueIterator, typename value_t> bool has_packed_bool_element()#

size_t packed_bools_per_word()#

size_t packed_bool_size(size_t bool_size)#

template<typename T> uint32_t packed_bool_mask(T bool_offset)#

uint32_t packed_bool_full_mask()#

template<typename T> uint32_t packed_bool_partial_mask(T num_set_bits)#

uint32_t packed_bool_empty_mask()#

template<typename T> T packed_bool_offset(T bool_offset)#

template<typename ValueIterator, typename ValueToGroupIdOp> rmm::device_uvector<size_t> groupby_and_count(ValueIterator tx_value_first, ValueIterator tx_value_last, ValueToGroupIdOp value_to_group_id_op, int num_groups, size_t mem_frugal_threshold, rmm::cuda_stream_view stream_view)#

template<typename VertexIterator, typename ValueIterator, typename KeyToGroupIdOp> rmm::device_uvector<size_t> groupby_and_count(VertexIterator tx_key_first, VertexIterator tx_key_last, ValueIterator tx_value_first, KeyToGroupIdOp key_to_group_id_op, int num_groups, size_t mem_frugal_threshold, rmm::cuda_stream_view stream_view)#

template<typename TxValueIterator> auto shuffle_values(raft::comms::comms_t const &comm, TxValueIterator tx_value_first, std::vector<size_t> const &tx_value_counts, rmm::cuda_stream_view stream_view)#

template<typename TxValueIterator> auto shuffle_values(raft::comms::comms_t const &comm, TxValueIterator tx_value_first, std::vector<size_t> const &tx_value_counts, size_t alignment, std::optional<typename thrust::iterator_traits<TxValueIterator>::value_type> fill_value, rmm::cuda_stream_view stream_view)#

template<typename TxValueIterator> auto shuffle_and_unique_segment_sorted_values(raft::comms::comms_t const &comm, TxValueIterator segment_sorted_tx_value_first, std::vector<size_t> const &tx_value_counts, rmm::cuda_stream_view stream_view)#

template<typename ValueIterator, typename ValueToGPUIdOp> auto groupby_gpu_id_and_shuffle_values(raft::comms::comms_t const &comm, ValueIterator tx_value_first, ValueIterator tx_value_last, ValueToGPUIdOp value_to_gpu_id_op, rmm::cuda_stream_view stream_view)#

template<typename VertexIterator, typename ValueIterator, typename KeyToGPUIdOp> auto groupby_gpu_id_and_shuffle_kv_pairs(raft::comms::comms_t const &comm, VertexIterator tx_key_first, VertexIterator tx_key_last, ValueIterator tx_value_first, KeyToGPUIdOp key_to_gpu_id_op, rmm::cuda_stream_view stream_view)#

template<typename TupleType> size_t sum_thrust_tuple_element_sizes()#

template<typename TupleType> size_t min_thrust_tuple_element_sizes()#

template<typename TupleType> size_t max_thrust_tuple_element_sizes()#

template<typename TupleType> auto thrust_tuple_to_std_tuple(TupleType tup)#

template<typename TupleType> auto std_tuple_to_thrust_tuple(TupleType tup)#

template<typename T> auto to_thrust_tuple(T scalar_value)#

template<typename ...Ts> auto to_thrust_tuple(thrust::tuple<Ts...> tuple_value)#

template<typename Iterator, typename std::enable_if_t<std::is_arithmetic_v<typename std::iterator_traits<Iterator>::value_type>>* = nullptr> auto to_thrust_iterator_tuple(Iterator iter)#

template<typename T, size_t I, typename std::enable_if_t<std::is_arithmetic_v<T>>* = nullptr> auto thrust_tuple_get_or_identity(T val)#

template<typename Iterator, size_t I, typename std::enable_if_t<std::is_arithmetic_v<typename thrust::iterator_traits<Iterator>::value_type>>* = nullptr> auto thrust_tuple_get_or_identity(Iterator val)#

template<typename ...TupleTypes> auto thrust_tuple_cat(TupleTypes... tups)#

template<typename TupleType> TupleType thrust_tuple_of_arithmetic_numeric_limits_lowest()#

template<typename TupleType> TupleType thrust_tuple_of_arithmetic_numeric_limits_max()#

template<typename T, typename ...Ts> decltype(auto) get_first_of_pack(T &&t, Ts&&...)#

Variables

template<typename vertex_t> vertex_t invalid_vertex_id_v = invalid_vertex_id<vertex_t>::value#

template<typename edge_t> edge_t invalid_edge_id_v = invalid_edge_id<edge_t>::value#

template<typename component_t> component_t invalid_component_id_v = invalid_component_id<component_t>::value#

template<typename GraphViewType, typename key_t, typename EdgePartitionSrcValueInputWrapper, typename EdgePartitionDstValueInputWrapper, typename EdgePartitionEdgeValueInputWrapper, typename EdgeOp, typename T> struct cast_edge_op_bool_to_integer#

struct centrality_algorithm_metadata_t#: #include <algorithms.hpp>

Metadata about the execution of one of the centrality algorithms.

template<typename TupleType> struct compute_thrust_tuple_element_sizes#

template<typename T> struct dataframe_buffer_const_iterator_type#

template<typename... Ts> tuple< Ts... > >

template<typename T> struct dataframe_buffer_iterator_type#

template<typename... Ts> tuple< Ts... > >

template<typename T> struct dataframe_buffer_type#

template<typename vertex_t> class Dendrogram#

template<typename vertex_t, typename tag_t = void, bool src_major = false, bool multi_gpu = false, bool sorted_unique = false> class edge_bucket_t#

Public Functions

template<typename tag_type = tag_t, std::enable_if_t<std::is_same_v<tag_type, void>>* = nullptr> inline void insert(vertex_t src, vertex_t dst)#

@ brief insert an edge to the bucket

Parameters:

src – edge source vertex.
dst – edge destination vertex.

template<typename tag_type = tag_t, std::enable_if_t<!std::is_same_v<tag_type, void>>* = nullptr> inline void insert(vertex_t src, vertex_t dst, tag_type tag)#

@ brief insert a tagged-edge to the bucket

Parameters:

src – edge source vertex.
dst – edge destination vertex.
tag – edge tag.

template<typename VertexIterator, typename tag_type = tag_t, std::enable_if_t<std::is_same_v<tag_type, void>>* = nullptr> inline void insert(VertexIterator src_first, VertexIterator src_last, VertexIterator dst_first)#

@ brief insert a list of edges to the bucket

Parameters:

src_first – Iterator pointing to the first (inclusive) element of the edge source vertices in device memory.
src_last – Iterator pointing to the last (exclusive) element of the edge source vertices stored in device memory.
dst_first – Iterator pointing to the first (inclusive) element of the edge destination vertices in device memory.

template<typename VertexIterator, typename TagIterator, typename tag_type = tag_t, std::enable_if_t<!std::is_same_v<tag_type, void>>* = nullptr> inline void insert(VertexIterator src_first, VertexIterator src_last, VertexIterator dst_first, TagIterator tag_first)#

@ brief insert a list of tagged-edges to the bucket

Parameters:

src_first – Iterator pointing to the first (inclusive) element of the edge source vertices in device memory.
src_last – Iterator pointing to the last (exclusive) element of the edge source vertices stored in device memory.
dst_first – Iterator pointing to the first (inclusive) element of the edge destination vertices in device memory.
tag_first – Iterator pointing to the first (inclusive) element of the edge tags in device memory.

class edge_dst_dummy_property_t#

template<typename GraphViewType, typename T> class edge_dst_property_t#

class edge_dummy_property_t#

class edge_dummy_property_view_t#

template<typename vertex_t, typename edge_t, bool multi_gpu, typename Enable = void> class edge_partition_device_view_t#

template<typename vertex_t, typename edge_t, bool multi_gpu> enable_if_t< multi_gpu > > : public cugraph::detail::edge_partition_device_view_base_t< vertex_t, edge_t >

template<typename vertex_t, typename edge_t, bool multi_gpu> enable_if_t<!multi_gpu > > : public cugraph::detail::edge_partition_device_view_base_t< vertex_t, edge_t >

template<typename vertex_t, typename edge_t, bool multi_gpu, typename Enable = void> class edge_partition_view_t#

template<typename vertex_t, typename edge_t, bool multi_gpu> enable_if_t< multi_gpu > > : public cugraph::detail::edge_partition_view_base_t< vertex_t, edge_t >

template<typename vertex_t, typename edge_t, bool multi_gpu> enable_if_t<!multi_gpu > > : public cugraph::detail::edge_partition_view_base_t< vertex_t, edge_t >

template<typename GraphViewType, typename T> class edge_property_t#

template<typename edge_t, typename ValueIterator, typename value_t = typename thrust::iterator_traits<ValueIterator>::value_type> class edge_property_view_t#

class edge_src_dummy_property_t#

template<typename GraphViewType, typename T> class edge_src_property_t#

template<typename vertex_t, typename edge_t, bool multi_gpu, typename Enable = void> struct graph_meta_t#

template<typename vertex_t, typename edge_t, bool multi_gpu> enable_if_t< multi_gpu > >

template<typename vertex_t, typename edge_t, bool multi_gpu> enable_if_t<!multi_gpu > >

struct graph_properties_t#

template<typename vertex_t, typename edge_t, bool store_transposed, bool multi_gpu, typename Enable = void> class graph_t#

template<typename vertex_t, typename edge_t, bool store_transposed, bool multi_gpu> enable_if_t< multi_gpu > > : public cugraph::detail::graph_base_t< vertex_t, edge_t >

template<typename vertex_t, typename edge_t, bool store_transposed, bool multi_gpu> enable_if_t<!multi_gpu > > : public cugraph::detail::graph_base_t< vertex_t, edge_t >

template<typename vertex_t, typename edge_t, bool store_transposed, bool multi_gpu, typename Enable = void> struct graph_view_meta_t#

template<typename vertex_t, typename edge_t, bool store_transposed, bool multi_gpu> enable_if_t< multi_gpu > >

template<typename vertex_t, typename edge_t, bool store_transposed, bool multi_gpu> enable_if_t<!multi_gpu > >

template<typename vertex_t, typename edge_t, bool store_transposed, bool multi_gpu, typename Enable = void> class graph_view_t#

template<typename vertex_t, typename edge_t, bool store_transposed, bool multi_gpu> enable_if_t< multi_gpu > > : public cugraph::detail::graph_base_t< vertex_t, edge_t >

template<typename vertex_t, typename edge_t, bool store_transposed, bool multi_gpu> enable_if_t<!multi_gpu > > : public cugraph::detail::graph_base_t< vertex_t, edge_t >

template<typename component_t> struct invalid_component_id : public cugraph::invalid_idx<component_t>#

template<typename edge_t> struct invalid_edge_id : public cugraph::invalid_idx<edge_t>#

template<typename T, typename Enable = void> struct invalid_idx#

template<typename T> value > > : public std::integral_constant< T, -1 >

template<typename T> value > > : public std::integral_constant< T, std::numeric_limits< T >::max()>

template<typename vertex_t> struct invalid_vertex_id : public cugraph::invalid_idx<vertex_t>#

template<typename T> struct is_arithmetic_or_thrust_tuple_of_arithmetic : public std::integral_constant<bool, std::is_arithmetic_v<T>>#

template<typename... Ts> tuple< Ts... > > : public std::integral_constant< bool, is_thrust_tuple_of_arithmetic< thrust::tuple< Ts... > >::value >

template<typename T, template<typename> typename Vector> struct is_arithmetic_vector : public std::false_type#

template<template<typename> typename Vector, typename T> struct is_arithmetic_vector<Vector<T>, Vector> : public std::integral_constant<bool, std::is_arithmetic_v<T>>#

template<typename vertex_t, typename edge_t, typename weight_t> struct is_candidate#

template<typename vertex_t, typename edge_t, typename weight_t> struct is_candidate_legacy#

template<typename Src, typename ...Types> struct is_one_of#

template<typename Src> struct is_one_of<Src>#

template<typename Src, typename Head, typename ...Tail> struct is_one_of<Src, Head, Tail...>#

template<typename T> struct is_std_tuple : public std::false_type#

template<typename... Ts> tuple< Ts... > > : public std::true_type

template<typename T> struct is_std_tuple_of_arithmetic_vectors : public std::false_type#

template<typename... Ts> device_uvector< Ts >... > >

template<typename T> struct is_thrust_tuple : public std::false_type#

template<typename... Ts> tuple< Ts... > > : public std::true_type

template<typename TupleType> struct is_thrust_tuple_of_arithmetic : public std::false_type#

template<typename... Ts> tuple< Ts... > >

template<typename TupleType> struct is_thrust_tuple_of_integral : public std::false_type#

template<typename... Ts> tuple< Ts... > >

template<typename vertex_t, typename edge_t> struct is_vertex_edge_combo#

template<typename vertex_t, typename edge_t> struct is_vertex_edge_combo_legacy#

template<typename vertex_t, typename tag_t = void, bool multi_gpu = false, bool sorted_unique = false> class key_bucket_t#

Public Functions

template<typename tag_type = tag_t, std::enable_if_t<std::is_same_v<tag_type, void>>* = nullptr> inline void insert(vertex_t vertex)#

@ brief insert a vertex to the bucket

Parameters:: vertex – vertex to insert

template<typename tag_type = tag_t, std::enable_if_t<!std::is_same_v<tag_type, void>>* = nullptr> inline void insert(thrust::tuple<vertex_t, tag_type> key)#

@ brief insert a (vertex, tag) pair to the bucket

Parameters:

vertex – vertex of the (vertex, tag) pair to insert
tag – tag of the (vertex, tag) pair to insert

template<typename VertexIterator, typename tag_type = tag_t, std::enable_if_t<std::is_same_v<tag_type, void>>* = nullptr> inline void insert(VertexIterator vertex_first, VertexIterator vertex_last)#

@ brief insert a list of vertices to the bucket

Parameters:

vertex_first – Iterator pointing to the first (inclusive) element of the vertices stored in device memory.
vertex_last – Iterator pointing to the last (exclusive) element of the vertices stored in device memory.

template<typename KeyIterator, typename tag_type = tag_t, std::enable_if_t<!std::is_same_v<tag_type, void>>* = nullptr> inline void insert(KeyIterator key_first, KeyIterator key_last)#

@ brief insert a list of (vertex, tag) pairs to the bucket

Parameters:

key_first – Iterator pointing to the first (inclusive) element of the (vertex,tag) pairs stored in device memory.
key_last – Iterator pointing to the last (exclusive) element of the (vertex,tag) pairs stored in device memory.

template<typename key_t, bool use_binary_search = true> class key_store_t#

template<typename key_t, typename value_t, bool use_binary_search = true> class kv_store_t#

struct logic_error : public raft::exception#

#include <error.hpp>

Exception thrown when logical precondition is violated.

This exception should not be thrown directly and is instead thrown by the CUGRAPH_EXPECTS and CUGRAPH_FAIL macros.

template<typename edge_id_t, typename edge_type_t, typename vertex_t, typename value_t = thrust::tuple<vertex_t, vertex_t>> class lookup_container_t#

class partition_manager#: #include <partition_manager.hpp>

managed the mapping between graph partitioning and GPU partitioning

template<typename vertex_t> class partition_t#

#include <graph_view.hpp>

store graph vertex/edge partitioning map

We need to partition 1D vertex array and the 2D edge matrix (major = source if not transposed, destination if transposed).

Assume we have P GPUs. An 1D vertex array of size V is divided to P linear partitions; each partition has the size close to V / P.

Say P = major_comm_size * minor_comm_size. And each GPU will have (major_comm_rank, minor_comm_rank). cugraph::partition_manager is responsible for mapping (major_comm_rank, minor_comm_rank) to the global rank. The 2D edge matrix is first partitioned along the major axis to P slabs, then each slab will be further partitioned along the minor axis to minor_comm_size rectangles. One GPU will be responsible minor_comm_size rectangular partitions.

To be more specific, a GPU with (major_comm_rank, minor_comm_rank) will be responsible for minor_comm_size rectangular partitions with [a_i, b_i) by [c, d) (i = [0, minor_comm_size) where a_i = vertex_partition_range_offsets[major_comm_size * i + major_comm_rank], b_i = vertex_partition_range_offsets[major_comm_size * i + major_comm_rank + 1], c = vertex_partition_range_offsets[major_comm_size * minor_comm_rank], and d = vertex_partition_range_offsets[major_comm_size * (minor_comm_rank + 1)],

Here, vertex_partition_range_offsets (size = P + 1) stores the 1D partitioning of the vertex ID range [0, # vertices). The first P values store the beginning (inclusive) of each GPU partition. The last value marks the end (exclusive) of the last GPU partition (which coincides with # vertices).

See E. G. Boman et. al., “Scalable matrix computations on large scale-free graphs using 2D graph partitioning”, 2013 for additional detail.

Template Parameters:: vertex_t – Type of vertex ID

template<typename T, template<typename> typename Op> struct property_op : public Op<T>#

template<typename... Args, template< typename > typename Op> tuple< Args... >, Op > : public thrust::binary_function< thrust::tuple< Args... >, thrust::tuple< Args... >, thrust::tuple< Args... > >

template<typename vertex_t, typename edge_t, bool multi_gpu, typename Enable = void> struct renumber_meta_t#

template<typename vertex_t, typename edge_t, bool multi_gpu> enable_if_t< multi_gpu > >

template<typename vertex_t, typename edge_t, bool multi_gpu> enable_if_t<!multi_gpu > >

struct sampling_flags_t#

Public Members

prior_sources_behavior_t prior_sources_behavior = {}#: Specifies how to handle prior sources. Default is DEFAULT.

bool return_hops = {false}#: Specifies if the hop information should be returned. Default is false.

bool dedupe_sources = {false}#: If true then if a vertex v appears as a destination in hop X multiple times with the same label, it will only be passed once (for each label) as a source for the next hop. Default is false.

bool with_replacement = {true}#: Specifies if random sampling is done with replacement (true) or without replacement (false). Default is true.

struct sampling_params_t#

template<typename TupleType, size_t I> struct thrust_tuple_get#

template<typename T> struct thrust_tuple_size_or_one : public std::integral_constant<size_t, 1>#

template<typename... Ts> tuple< Ts... > > : public std::integral_constant< size_t, thrust::tuple_size< thrust::tuple< Ts... > >::value >

template<typename vertex_t, typename tag_t = void, bool multi_gpu = false, bool sorted_unique_key_bucket = false> class vertex_frontier_t#

template<typename GraphViewType, bool multi_gpu, typename Enable = void> class vertex_partition_device_view_t#

template<typename vertex_t, bool multi_gpu> enable_if_t< multi_gpu > > : public cugraph::detail::vertex_partition_device_view_base_t< vertex_t >

template<typename vertex_t, bool multi_gpu> enable_if_t<!multi_gpu > > : public cugraph::detail::vertex_partition_device_view_base_t< vertex_t >

template<typename vertex_t, bool multi_gpu, typename Enable = void> class vertex_partition_view_t#

template<typename vertex_t, bool multi_gpu> enable_if_t< multi_gpu > > : public cugraph::detail::vertex_partition_view_base_t< vertex_t >

template<typename vertex_t, bool multi_gpu> enable_if_t<!multi_gpu > > : public cugraph::detail::vertex_partition_view_base_t< vertex_t >

namespace c_api#

Functions

template<typename vertex_t, typename edge_t, typename weight_t, typename edge_type_t, bool store_transposed, typename functor_t> decltype(auto) multi_gpu_dispatcher(bool multi_gpu, functor_t &functor)#

template<typename vertex_t, typename edge_t, typename weight_t, typename edge_type_t, typename functor_t> decltype(auto) transpose_dispatcher(bool store_transposed, bool multi_gpu, functor_t &functor)#

template<typename vertex_t, typename edge_t, typename weight_t, typename functor_t> decltype(auto) edge_type_type_dispatcher(cugraph_data_type_id_t edge_type_type, bool store_transposed, bool multi_gpu, functor_t &functor)#

template<typename vertex_t, typename edge_t, typename functor_t> decltype(auto) weight_dispatcher(cugraph_data_type_id_t weight_type, cugraph_data_type_id_t edge_type_type, bool store_transposed, bool multi_gpu, functor_t &functor)#

template<typename vertex_t, typename functor_t> decltype(auto) edge_dispatcher(cugraph_data_type_id_t edge_type, cugraph_data_type_id_t weight_type, cugraph_data_type_id_t edge_type_type, bool store_transposed, bool multi_gpu, functor_t &functor)#

template<typename functor_t> inline decltype(auto) vertex_dispatcher(cugraph_data_type_id_t vertex_type, cugraph_data_type_id_t edge_type, cugraph_data_type_id_t weight_type, cugraph_data_type_id_t edge_type_type, bool store_transposed, bool multi_gpu, functor_t &functor)#

template<typename vertex_t, typename edge_t, typename weight_t, bool store_transposed, bool multi_gpu> cugraph_error_code_t transpose_storage(raft::handle_t const &handle, cugraph_graph_t *graph, cugraph_error_t *error)#

template<typename vertex_t, typename edge_t> rmm::device_uvector<vertex_t> expand_sparse_offsets(raft::device_span<edge_t const> offsets, vertex_t base_vertex_id, rmm::cuda_stream_view const &stream)#

template<typename GraphViewType, typename T> edge_property_t<GraphViewType, T> create_constant_edge_property(raft::handle_t const &handle, GraphViewType const &graph_view, T constant_value)#

template edge_property_t< cugraph::graph_view_t< int32_t, int32_t, false, true >, float > create_constant_edge_property (raft::handle_t const &handle, cugraph::graph_view_t< int32_t, int32_t, false, true > const &graph_view, float constant_value)

template edge_property_t< cugraph::graph_view_t< int64_t, int64_t, false, true >, float > create_constant_edge_property (raft::handle_t const &handle, cugraph::graph_view_t< int64_t, int64_t, false, true > const &graph_view, float constant_value)

template edge_property_t< cugraph::graph_view_t< int32_t, int32_t, true, true >, float > create_constant_edge_property (raft::handle_t const &handle, cugraph::graph_view_t< int32_t, int32_t, true, true > const &graph_view, float constant_value)

template edge_property_t< cugraph::graph_view_t< int64_t, int64_t, true, true >, float > create_constant_edge_property (raft::handle_t const &handle, cugraph::graph_view_t< int64_t, int64_t, true, true > const &graph_view, float constant_value)

template edge_property_t< cugraph::graph_view_t< int32_t, int32_t, false, true >, double > create_constant_edge_property (raft::handle_t const &handle, cugraph::graph_view_t< int32_t, int32_t, false, true > const &graph_view, double constant_value)

template edge_property_t< cugraph::graph_view_t< int64_t, int64_t, false, true >, double > create_constant_edge_property (raft::handle_t const &handle, cugraph::graph_view_t< int64_t, int64_t, false, true > const &graph_view, double constant_value)

template edge_property_t< cugraph::graph_view_t< int32_t, int32_t, true, true >, double > create_constant_edge_property (raft::handle_t const &handle, cugraph::graph_view_t< int32_t, int32_t, true, true > const &graph_view, double constant_value)

template edge_property_t< cugraph::graph_view_t< int64_t, int64_t, true, true >, double > create_constant_edge_property (raft::handle_t const &handle, cugraph::graph_view_t< int64_t, int64_t, true, true > const &graph_view, double constant_value)

template rmm::device_uvector< int32_t > expand_sparse_offsets (raft::device_span< int32_t const > offsets, int32_t base_vertex_id, rmm::cuda_stream_view const &stream)

template rmm::device_uvector< int32_t > expand_sparse_offsets (raft::device_span< int64_t const > offsets, int32_t base_vertex_id, rmm::cuda_stream_view const &stream)

template rmm::device_uvector< int64_t > expand_sparse_offsets (raft::device_span< int64_t const > offsets, int64_t base_vertex_id, rmm::cuda_stream_view const &stream)

template rmm::device_uvector< int32_t > expand_sparse_offsets (raft::device_span< size_t const > offsets, int32_t base_vertex_id, rmm::cuda_stream_view const &stream)

template rmm::device_uvector< int64_t > expand_sparse_offsets (raft::device_span< size_t const > offsets, int64_t base_vertex_id, rmm::cuda_stream_view const &stream)

template edge_property_t< cugraph::graph_view_t< int32_t, int32_t, false, false >, float > create_constant_edge_property (raft::handle_t const &handle, cugraph::graph_view_t< int32_t, int32_t, false, false > const &graph_view, float constant_value)

template edge_property_t< cugraph::graph_view_t< int64_t, int64_t, false, false >, float > create_constant_edge_property (raft::handle_t const &handle, cugraph::graph_view_t< int64_t, int64_t, false, false > const &graph_view, float constant_value)

template edge_property_t< cugraph::graph_view_t< int32_t, int32_t, true, false >, float > create_constant_edge_property (raft::handle_t const &handle, cugraph::graph_view_t< int32_t, int32_t, true, false > const &graph_view, float constant_value)

template edge_property_t< cugraph::graph_view_t< int64_t, int64_t, true, false >, float > create_constant_edge_property (raft::handle_t const &handle, cugraph::graph_view_t< int64_t, int64_t, true, false > const &graph_view, float constant_value)

template edge_property_t< cugraph::graph_view_t< int32_t, int32_t, false, false >, double > create_constant_edge_property (raft::handle_t const &handle, cugraph::graph_view_t< int32_t, int32_t, false, false > const &graph_view, double constant_value)

template edge_property_t< cugraph::graph_view_t< int64_t, int64_t, false, false >, double > create_constant_edge_property (raft::handle_t const &handle, cugraph::graph_view_t< int64_t, int64_t, false, false > const &graph_view, double constant_value)

template edge_property_t< cugraph::graph_view_t< int32_t, int32_t, true, false >, double > create_constant_edge_property (raft::handle_t const &handle, cugraph::graph_view_t< int32_t, int32_t, true, false > const &graph_view, double constant_value)

template edge_property_t< cugraph::graph_view_t< int64_t, int64_t, true, false >, double > create_constant_edge_property (raft::handle_t const &handle, cugraph::graph_view_t< int64_t, int64_t, true, false > const &graph_view, double constant_value)

template<typename functor_t, typename result_t>
cugraph_error_code_t run_algorithm(::cugraph_graph_t const *graph, functor_t &functor, result_t *result, ::cugraph_error_t **error)#

Variables

size_t data_type_sz[] = {1, 2, 4, 8, 1, 2, 4, 8, 4, 8, 8, 1}#

struct abstract_functor#: Subclassed by cugraph::c_api::bfs_functor, cugraph::c_api::extract_paths_functor, cugraph::c_api::node2vec_functor, cugraph::c_api::sssp_functor

struct bfs_functor : public cugraph::c_api::abstract_functor #

struct cugraph_centrality_result_t#

struct cugraph_clustering_result_t#

struct cugraph_coo_list_t#

struct cugraph_coo_t#

struct cugraph_core_result_t#

struct cugraph_degrees_result_t#

struct cugraph_edge_centrality_result_t#

struct cugraph_edge_property_t#

struct cugraph_edge_property_view_t#

struct cugraph_edgelist_t#

struct cugraph_error_t#

struct cugraph_extract_paths_result_t#

struct cugraph_graph_t#

struct cugraph_hierarchical_clustering_result_t#

struct cugraph_hits_result_t#

struct cugraph_induced_subgraph_result_t#

struct cugraph_k_core_result_t#

struct cugraph_labeling_result_t#

struct cugraph_lookup_container_t#

struct cugraph_lookup_result_t#

struct cugraph_paths_result_t#

struct cugraph_random_walk_result_t#

struct cugraph_resource_handle_t#

struct cugraph_rng_state_t#

struct cugraph_sample_result_t#

struct cugraph_sampling_options_t#

struct cugraph_similarity_result_t#

struct cugraph_triangle_count_result_t#

struct cugraph_type_erased_device_array_t#

struct cugraph_type_erased_device_array_view_t#

struct cugraph_type_erased_host_array_t#

struct cugraph_type_erased_host_array_view_t#

struct cugraph_vertex_pairs_t#

struct cugraph_vertex_property_t#

struct cugraph_vertex_property_view_t#

struct extract_paths_functor : public cugraph::c_api::abstract_functor #

struct node2vec_functor : public cugraph::c_api::abstract_functor #

struct sampling_flags_t#

struct sssp_functor : public cugraph::c_api::abstract_functor #

namespace detail#

Functions

template<typename vertex_t> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<size_t>> shuffle_vertex_ids_and_offsets(raft::handle_t const &handle, rmm::device_uvector<vertex_t> &&vertices, raft::device_span<size_t const> offsets)#

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< size_t > > shuffle_vertex_ids_and_offsets (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&vertices, raft::device_span< size_t const > offsets)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< size_t > > shuffle_vertex_ids_and_offsets (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&vertices, raft::device_span< size_t const > offsets)

template<typename key_t, typename value_t> void sort_by_key(raft::handle_t const &handle, raft::device_span<key_t> keys, raft::device_span<value_t> values)#

template void sort_by_key (raft::handle_t const &handle, raft::device_span< int32_t > keys, raft::device_span< int32_t > values)

template void sort_by_key (raft::handle_t const &handle, raft::device_span< int64_t > keys, raft::device_span< int64_t > values)

template<typename vertex_t, typename weight_t> std::tuple<rmm::device_uvector<size_t>, rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<weight_t>>> reorder_extracted_egonets(raft::handle_t const &handle, rmm::device_uvector<size_t> &&source_indices, rmm::device_uvector<size_t> &&offsets, rmm::device_uvector<vertex_t> &&edge_srcs, rmm::device_uvector<vertex_t> &&edge_dsts, std::optional<rmm::device_uvector<weight_t>> &&edge_weights)#

template std::tuple< rmm::device_uvector< size_t >, rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > > > reorder_extracted_egonets (raft::handle_t const &handle, rmm::device_uvector< size_t > &&source_indices, rmm::device_uvector< size_t > &&offsets, rmm::device_uvector< int32_t > &&edge_srcs, rmm::device_uvector< int32_t > &&edge_dsts, std::optional< rmm::device_uvector< float > > &&edge_weights)

template std::tuple< rmm::device_uvector< size_t >, rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > > > reorder_extracted_egonets (raft::handle_t const &handle, rmm::device_uvector< size_t > &&source_indices, rmm::device_uvector< size_t > &&offsets, rmm::device_uvector< int32_t > &&edge_srcs, rmm::device_uvector< int32_t > &&edge_dsts, std::optional< rmm::device_uvector< double > > &&edge_weights)

template std::tuple< rmm::device_uvector< size_t >, rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > > > reorder_extracted_egonets (raft::handle_t const &handle, rmm::device_uvector< size_t > &&source_indices, rmm::device_uvector< size_t > &&offsets, rmm::device_uvector< int64_t > &&edge_srcs, rmm::device_uvector< int64_t > &&edge_dsts, std::optional< rmm::device_uvector< float > > &&edge_weights)

template std::tuple< rmm::device_uvector< size_t >, rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > > > reorder_extracted_egonets (raft::handle_t const &handle, rmm::device_uvector< size_t > &&source_indices, rmm::device_uvector< size_t > &&offsets, rmm::device_uvector< int64_t > &&edge_srcs, rmm::device_uvector< int64_t > &&edge_dsts, std::optional< rmm::device_uvector< double > > &&edge_weights)

namespace dense#

Functions

template<typename index_t, typename weight_t> weight_t hungarian(raft::handle_t const &handle, weight_t const *costs, index_t num_rows, index_t num_cols, index_t *assignment)#

template<typename index_t, typename weight_t> weight_t hungarian(raft::handle_t const &handle, weight_t const *costs, index_t num_rows, index_t num_cols, index_t *assignment, weight_t epsilon)#

template int32_t hungarian< int32_t, int32_t > (raft::handle_t const &, int32_t const *, int32_t, int32_t, int32_t *)

template float hungarian< int32_t, float > (raft::handle_t const &, float const *, int32_t, int32_t, int32_t *)

template double hungarian< int32_t, double > (raft::handle_t const &, double const *, int32_t, int32_t, int32_t *)

template int32_t hungarian< int32_t, int32_t > (raft::handle_t const &, int32_t const *, int32_t, int32_t, int32_t *, int32_t)

template float hungarian< int32_t, float > (raft::handle_t const &, float const *, int32_t, int32_t, int32_t *, float)

template double hungarian< int32_t, double > (raft::handle_t const &, double const *, int32_t, int32_t, int32_t *, double)

namespace detail#

Typedefs

template<typename T> using optional_dataframe_buffer_type_t = typename optional_dataframe_buffer_type<T>::type#

typedef cuco::storage<1> cuco_storage_type#: cuco window storage type

Enums

enum class coefficient_t#

Values:

enumerator JACCARD#

enumerator SORENSEN#

enumerator OVERLAP#

enumerator COSINE#

Functions

template<typename vertex_t, typename edge_t, typename weight_t, bool multi_gpu> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<edge_t>> brandes_bfs(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, false, multi_gpu> const &graph_view, std::optional<edge_property_view_t<edge_t, weight_t const*>> edge_weight_view, vertex_frontier_t<vertex_t, void, multi_gpu, true> &vertex_frontier, bool do_expensive_check)#

template<typename vertex_t, typename edge_t, typename weight_t, bool multi_gpu> void accumulate_vertex_results(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, false, multi_gpu> const &graph_view, std::optional<edge_property_view_t<edge_t, weight_t const*>> edge_weight_view, raft::device_span<weight_t> centralities, rmm::device_uvector<vertex_t> &&distances, rmm::device_uvector<edge_t> &&sigmas, bool with_endpoints, bool do_expensive_check)#

template<typename vertex_t, typename edge_t, typename weight_t, bool multi_gpu> void accumulate_edge_results(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, false, multi_gpu> const &graph_view, std::optional<edge_property_view_t<edge_t, weight_t const*>> edge_weight_view, edge_property_view_t<edge_t, weight_t*> centralities_view, rmm::device_uvector<vertex_t> &&distances, rmm::device_uvector<edge_t> &&sigmas, bool do_expensive_check)#

template<typename vertex_t, typename edge_t, typename weight_t, bool multi_gpu, typename VertexIterator> rmm::device_uvector<weight_t> betweenness_centrality(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, false, multi_gpu> const &graph_view, std::optional<edge_property_view_t<edge_t, weight_t const*>> edge_weight_view, VertexIterator vertices_begin, VertexIterator vertices_end, bool const normalized, bool const include_endpoints, bool const do_expensive_check)#

template<typename vertex_t, typename edge_t, typename weight_t, bool multi_gpu, typename VertexIterator> edge_property_t<graph_view_t<vertex_t, edge_t, false, multi_gpu>, weight_t> edge_betweenness_centrality(const raft::handle_t &handle, graph_view_t<vertex_t, edge_t, false, multi_gpu> const &graph_view, std::optional<edge_property_view_t<edge_t, weight_t const*>> edge_weight_view, VertexIterator vertices_begin, VertexIterator vertices_end, bool const normalized, bool const do_expensive_check)#

template<typename vertex_t, typename edge_t, typename weight_t, bool multi_gpu> rmm::device_uvector<weight_t> eigenvector_centrality(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, true, multi_gpu> const &pull_graph_view, std::optional<edge_property_view_t<edge_t, weight_t const*>> edge_weight_view, std::optional<raft::device_span<weight_t const>> initial_centralities, weight_t epsilon, size_t max_iterations, bool do_expensive_check)#

template<typename GraphViewType, typename weight_t, typename result_t> void katz_centrality(raft::handle_t const &handle, GraphViewType const &pull_graph_view, std::optional<edge_property_view_t<typename GraphViewType::edge_type, weight_t const*>> edge_weight_view, result_t const *betas, result_t *katz_centralities, result_t alpha, result_t beta, result_t epsilon, size_t max_iterations, bool has_initial_guess, bool normalize, bool do_expensive_check)#

template<typename vertex_t, typename edge_t, typename weight_t, bool multi_gpu> std::tuple<rmm::device_uvector<vertex_t>, weight_t> approximate_weighted_matching(raft::handle_t const &handle, cugraph::graph_view_t<vertex_t, edge_t, false, multi_gpu> const &graph_view, edge_property_view_t<edge_t, weight_t const*> edge_weight_view)#

template<typename vertex_t, typename edge_t, typename weight_t, bool multi_gpu> weight_t compute_modularity(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, false, multi_gpu> const &graph_view, std::optional<edge_property_view_t<edge_t, weight_t const*>> edge_weight_view, edge_src_property_t<graph_view_t<vertex_t, edge_t, false, multi_gpu>, vertex_t> const &src_clusters_cache, edge_dst_property_t<graph_view_t<vertex_t, edge_t, false, multi_gpu>, vertex_t> const &dst_clusters_cache, rmm::device_uvector<vertex_t> const &next_clusters, rmm::device_uvector<weight_t> const &cluster_weights, weight_t total_edge_weight, weight_t resolution)#

template<typename vertex_t, typename edge_t, typename weight_t, bool multi_gpu> std::tuple<cugraph::graph_t<vertex_t, edge_t, false, multi_gpu>, std::optional<edge_property_t<graph_view_t<vertex_t, edge_t, false, multi_gpu>, weight_t>>> graph_contraction(raft::handle_t const &handle, cugraph::graph_view_t<vertex_t, edge_t, false, multi_gpu> const &graph_view, std::optional<edge_property_view_t<edge_t, weight_t const*>> edge_weights_view, raft::device_span<vertex_t> labels)#

template<typename vertex_t, typename edge_t, typename weight_t, bool multi_gpu> rmm::device_uvector<vertex_t> update_clustering_by_delta_modularity(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, false, multi_gpu> const &graph_view, std::optional<edge_property_view_t<edge_t, weight_t const*>> edge_weight_view, weight_t total_edge_weight, weight_t resolution, rmm::device_uvector<weight_t> const &vertex_weights_v, rmm::device_uvector<vertex_t> &&cluster_keys_v, rmm::device_uvector<weight_t> &&cluster_weights_v, rmm::device_uvector<vertex_t> &&next_clusters_v, edge_src_property_t<graph_view_t<vertex_t, edge_t, false, multi_gpu>, weight_t> const &src_vertex_weights_cache, edge_src_property_t<graph_view_t<vertex_t, edge_t, false, multi_gpu>, vertex_t> const &src_clusters_cache, edge_dst_property_t<graph_view_t<vertex_t, edge_t, false, multi_gpu>, vertex_t> const &dst_clusters_cache, bool up_down)#

template<typename vertex_t, typename edge_t, typename weight_t, bool multi_gpu> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<weight_t>> compute_cluster_keys_and_values(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, false, multi_gpu> const &graph_view, std::optional<edge_property_view_t<edge_t, weight_t const*>> edge_weight_view, rmm::device_uvector<vertex_t> const &next_clusters_v, edge_src_property_t<graph_view_t<vertex_t, edge_t, false, multi_gpu>, vertex_t> const &src_clusters_cache)#

template<typename vertex_t, typename edge_t, typename weight_t, bool multi_gpu> std::tuple<graph_t<vertex_t, edge_t, false, multi_gpu>, std::optional<edge_property_t<graph_view_t<vertex_t, edge_t, false, multi_gpu>, weight_t>>> graph_contraction(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, false, multi_gpu> const &graph_view, std::optional<edge_property_view_t<edge_t, weight_t const*>> edge_weights, raft::device_span<vertex_t> labels)#

template float compute_modularity (raft::handle_t const &handle, cugraph::graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, edge_src_property_t< cugraph::graph_view_t< int32_t, int32_t, false, true >, int32_t > const &src_clusters_cache, edge_dst_property_t< cugraph::graph_view_t< int32_t, int32_t, false, true >, int32_t > const &dst_clusters_cache, rmm::device_uvector< int32_t > const &next_clusters, rmm::device_uvector< float > const &cluster_weights, float total_edge_weight, float resolution)

template double compute_modularity (raft::handle_t const &handle, cugraph::graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, edge_src_property_t< cugraph::graph_view_t< int32_t, int32_t, false, true >, int32_t > const &src_clusters_cache, edge_dst_property_t< cugraph::graph_view_t< int32_t, int32_t, false, true >, int32_t > const &dst_clusters_cache, rmm::device_uvector< int32_t > const &next_clusters, rmm::device_uvector< double > const &cluster_weights, double total_edge_weight, double resolution)

template std::tuple< cugraph::graph_t< int32_t, int32_t, false, true >, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, false, true >, float > > > graph_contraction (raft::handle_t const &handle, cugraph::graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weights, raft::device_span< int32_t > labels)

template std::tuple< cugraph::graph_t< int32_t, int32_t, false, true >, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, false, true >, double > > > graph_contraction (raft::handle_t const &handle, cugraph::graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weights, raft::device_span< int32_t > labels)

template rmm::device_uvector< int32_t > update_clustering_by_delta_modularity (raft::handle_t const &handle, cugraph::graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, float total_edge_weight, float resolution, rmm::device_uvector< float > const &vertex_weights_v, rmm::device_uvector< int32_t > &&cluster_keys_v, rmm::device_uvector< float > &&cluster_weights_v, rmm::device_uvector< int32_t > &&next_clusters_v, edge_src_property_t< cugraph::graph_view_t< int32_t, int32_t, false, true >, float > const &src_vertex_weights_cache, edge_src_property_t< cugraph::graph_view_t< int32_t, int32_t, false, true >, int32_t > const &src_clusters_cache, edge_dst_property_t< cugraph::graph_view_t< int32_t, int32_t, false, true >, int32_t > const &dst_clusters_cache, bool up_down)

template rmm::device_uvector< int32_t > update_clustering_by_delta_modularity (raft::handle_t const &handle, cugraph::graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, double total_edge_weight, double resolution, rmm::device_uvector< double > const &vertex_weights_v, rmm::device_uvector< int32_t > &&cluster_keys_v, rmm::device_uvector< double > &&cluster_weights_v, rmm::device_uvector< int32_t > &&next_clusters_v, edge_src_property_t< cugraph::graph_view_t< int32_t, int32_t, false, true >, double > const &src_vertex_weights_cache, edge_src_property_t< cugraph::graph_view_t< int32_t, int32_t, false, true >, int32_t > const &src_clusters_cache, edge_dst_property_t< cugraph::graph_view_t< int32_t, int32_t, false, true >, int32_t > const &dst_clusters_cache, bool up_down)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< float > > compute_cluster_keys_and_values (raft::handle_t const &handle, cugraph::graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, rmm::device_uvector< int32_t > const &next_clusters_v, edge_src_property_t< cugraph::graph_view_t< int32_t, int32_t, false, true >, int32_t > const &src_clusters_cache)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< double > > compute_cluster_keys_and_values (raft::handle_t const &handle, cugraph::graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, rmm::device_uvector< int32_t > const &next_clusters_v, edge_src_property_t< cugraph::graph_view_t< int32_t, int32_t, false, true >, int32_t > const &src_clusters_cache)

template float compute_modularity (raft::handle_t const &handle, cugraph::graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, edge_src_property_t< cugraph::graph_view_t< int64_t, int64_t, false, true >, int64_t > const &src_clusters_cache, edge_dst_property_t< cugraph::graph_view_t< int64_t, int64_t, false, true >, int64_t > const &dst_clusters_cache, rmm::device_uvector< int64_t > const &next_clusters, rmm::device_uvector< float > const &cluster_weights, float total_edge_weight, float resolution)

template double compute_modularity (raft::handle_t const &handle, cugraph::graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, edge_src_property_t< cugraph::graph_view_t< int64_t, int64_t, false, true >, int64_t > const &src_clusters_cache, edge_dst_property_t< cugraph::graph_view_t< int64_t, int64_t, false, true >, int64_t > const &dst_clusters_cache, rmm::device_uvector< int64_t > const &next_clusters, rmm::device_uvector< double > const &cluster_weights, double total_edge_weight, double resolution)

template std::tuple< cugraph::graph_t< int64_t, int64_t, false, true >, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, false, true >, float > > > graph_contraction (raft::handle_t const &handle, cugraph::graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weights, raft::device_span< int64_t > labels)

template std::tuple< cugraph::graph_t< int64_t, int64_t, false, true >, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, false, true >, double > > > graph_contraction (raft::handle_t const &handle, cugraph::graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weights, raft::device_span< int64_t > labels)

template rmm::device_uvector< int64_t > update_clustering_by_delta_modularity (raft::handle_t const &handle, cugraph::graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, float total_edge_weight, float resolution, rmm::device_uvector< float > const &vertex_weights_v, rmm::device_uvector< int64_t > &&cluster_keys_v, rmm::device_uvector< float > &&cluster_weights_v, rmm::device_uvector< int64_t > &&next_clusters_v, edge_src_property_t< cugraph::graph_view_t< int64_t, int64_t, false, true >, float > const &src_vertex_weights_cache, edge_src_property_t< cugraph::graph_view_t< int64_t, int64_t, false, true >, int64_t > const &src_clusters_cache, edge_dst_property_t< cugraph::graph_view_t< int64_t, int64_t, false, true >, int64_t > const &dst_clusters_cache, bool up_down)

template rmm::device_uvector< int64_t > update_clustering_by_delta_modularity (raft::handle_t const &handle, cugraph::graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, double total_edge_weight, double resolution, rmm::device_uvector< double > const &vertex_weights_v, rmm::device_uvector< int64_t > &&cluster_keys_v, rmm::device_uvector< double > &&cluster_weights_v, rmm::device_uvector< int64_t > &&next_clusters_v, edge_src_property_t< cugraph::graph_view_t< int64_t, int64_t, false, true >, double > const &src_vertex_weights_cache, edge_src_property_t< cugraph::graph_view_t< int64_t, int64_t, false, true >, int64_t > const &src_clusters_cache, edge_dst_property_t< cugraph::graph_view_t< int64_t, int64_t, false, true >, int64_t > const &dst_clusters_cache, bool up_down)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< float > > compute_cluster_keys_and_values (raft::handle_t const &handle, cugraph::graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, rmm::device_uvector< int64_t > const &next_clusters_v, edge_src_property_t< cugraph::graph_view_t< int64_t, int64_t, false, true >, int64_t > const &src_clusters_cache)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< double > > compute_cluster_keys_and_values (raft::handle_t const &handle, cugraph::graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, rmm::device_uvector< int64_t > const &next_clusters_v, edge_src_property_t< cugraph::graph_view_t< int64_t, int64_t, false, true >, int64_t > const &src_clusters_cache)

template float compute_modularity (raft::handle_t const &handle, cugraph::graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, edge_src_property_t< cugraph::graph_view_t< int32_t, int32_t, false, false >, int32_t > const &src_clusters_cache, edge_dst_property_t< cugraph::graph_view_t< int32_t, int32_t, false, false >, int32_t > const &dst_clusters_cache, rmm::device_uvector< int32_t > const &next_clusters, rmm::device_uvector< float > const &cluster_weights, float total_edge_weight, float resolution)

template double compute_modularity (raft::handle_t const &handle, cugraph::graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, edge_src_property_t< cugraph::graph_view_t< int32_t, int32_t, false, false >, int32_t > const &src_clusters_cache, edge_dst_property_t< cugraph::graph_view_t< int32_t, int32_t, false, false >, int32_t > const &dst_clusters_cache, rmm::device_uvector< int32_t > const &next_clusters, rmm::device_uvector< double > const &cluster_weights, double total_edge_weight, double resolution)

template std::tuple< cugraph::graph_t< int32_t, int32_t, false, false >, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, false, false >, float > > > graph_contraction (raft::handle_t const &handle, cugraph::graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weights, raft::device_span< int32_t > labels)

template std::tuple< cugraph::graph_t< int32_t, int32_t, false, false >, std::optional< edge_property_t< graph_view_t< int32_t, int32_t, false, false >, double > > > graph_contraction (raft::handle_t const &handle, cugraph::graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weights, raft::device_span< int32_t > labels)

template rmm::device_uvector< int32_t > update_clustering_by_delta_modularity (raft::handle_t const &handle, cugraph::graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, float total_edge_weight, float resolution, rmm::device_uvector< float > const &vertex_weights_v, rmm::device_uvector< int32_t > &&cluster_keys_v, rmm::device_uvector< float > &&cluster_weights_v, rmm::device_uvector< int32_t > &&next_clusters_v, edge_src_property_t< cugraph::graph_view_t< int32_t, int32_t, false, false >, float > const &src_vertex_weights_cache, edge_src_property_t< cugraph::graph_view_t< int32_t, int32_t, false, false >, int32_t > const &src_clusters_cache, edge_dst_property_t< cugraph::graph_view_t< int32_t, int32_t, false, false >, int32_t > const &dst_clusters_cache, bool up_down)

template rmm::device_uvector< int32_t > update_clustering_by_delta_modularity (raft::handle_t const &handle, cugraph::graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, double total_edge_weight, double resolution, rmm::device_uvector< double > const &vertex_weights_v, rmm::device_uvector< int32_t > &&cluster_keys_v, rmm::device_uvector< double > &&cluster_weights_v, rmm::device_uvector< int32_t > &&next_clusters_v, edge_src_property_t< cugraph::graph_view_t< int32_t, int32_t, false, false >, double > const &src_vertex_weights_cache, edge_src_property_t< cugraph::graph_view_t< int32_t, int32_t, false, false >, int32_t > const &src_clusters_cache, edge_dst_property_t< cugraph::graph_view_t< int32_t, int32_t, false, false >, int32_t > const &dst_clusters_cache, bool up_down)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< float > > compute_cluster_keys_and_values (raft::handle_t const &handle, cugraph::graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, rmm::device_uvector< int32_t > const &next_clusters_v, edge_src_property_t< cugraph::graph_view_t< int32_t, int32_t, false, false >, int32_t > const &src_clusters_cache)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< double > > compute_cluster_keys_and_values (raft::handle_t const &handle, cugraph::graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, rmm::device_uvector< int32_t > const &next_clusters_v, edge_src_property_t< cugraph::graph_view_t< int32_t, int32_t, false, false >, int32_t > const &src_clusters_cache)

template float compute_modularity (raft::handle_t const &handle, cugraph::graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, edge_src_property_t< cugraph::graph_view_t< int64_t, int64_t, false, false >, int64_t > const &src_clusters_cache, edge_dst_property_t< cugraph::graph_view_t< int64_t, int64_t, false, false >, int64_t > const &dst_clusters_cache, rmm::device_uvector< int64_t > const &next_clusters, rmm::device_uvector< float > const &cluster_weights, float total_edge_weight, float resolution)

template double compute_modularity (raft::handle_t const &handle, cugraph::graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, edge_src_property_t< cugraph::graph_view_t< int64_t, int64_t, false, false >, int64_t > const &src_clusters_cache, edge_dst_property_t< cugraph::graph_view_t< int64_t, int64_t, false, false >, int64_t > const &dst_clusters_cache, rmm::device_uvector< int64_t > const &next_clusters, rmm::device_uvector< double > const &cluster_weights, double total_edge_weight, double resolution)

template std::tuple< cugraph::graph_t< int64_t, int64_t, false, false >, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, false, false >, float > > > graph_contraction (raft::handle_t const &handle, cugraph::graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weights, raft::device_span< int64_t > labels)

template std::tuple< cugraph::graph_t< int64_t, int64_t, false, false >, std::optional< edge_property_t< graph_view_t< int64_t, int64_t, false, false >, double > > > graph_contraction (raft::handle_t const &handle, cugraph::graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weights, raft::device_span< int64_t > labels)

template rmm::device_uvector< int64_t > update_clustering_by_delta_modularity (raft::handle_t const &handle, cugraph::graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, float total_edge_weight, float resolution, rmm::device_uvector< float > const &vertex_weights_v, rmm::device_uvector< int64_t > &&cluster_keys_v, rmm::device_uvector< float > &&cluster_weights_v, rmm::device_uvector< int64_t > &&next_clusters_v, edge_src_property_t< cugraph::graph_view_t< int64_t, int64_t, false, false >, float > const &src_vertex_weights_cache, edge_src_property_t< cugraph::graph_view_t< int64_t, int64_t, false, false >, int64_t > const &src_clusters_cache, edge_dst_property_t< cugraph::graph_view_t< int64_t, int64_t, false, false >, int64_t > const &dst_clusters_cache, bool up_down)

template rmm::device_uvector< int64_t > update_clustering_by_delta_modularity (raft::handle_t const &handle, cugraph::graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, double total_edge_weight, double resolution, rmm::device_uvector< double > const &vertex_weights_v, rmm::device_uvector< int64_t > &&cluster_keys_v, rmm::device_uvector< double > &&cluster_weights_v, rmm::device_uvector< int64_t > &&next_clusters_v, edge_src_property_t< cugraph::graph_view_t< int64_t, int64_t, false, false >, double > const &src_vertex_weights_cache, edge_src_property_t< cugraph::graph_view_t< int64_t, int64_t, false, false >, int64_t > const &src_clusters_cache, edge_dst_property_t< cugraph::graph_view_t< int64_t, int64_t, false, false >, int64_t > const &dst_clusters_cache, bool up_down)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< float > > compute_cluster_keys_and_values (raft::handle_t const &handle, cugraph::graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, rmm::device_uvector< int64_t > const &next_clusters_v, edge_src_property_t< cugraph::graph_view_t< int64_t, int64_t, false, false >, int64_t > const &src_clusters_cache)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< double > > compute_cluster_keys_and_values (raft::handle_t const &handle, cugraph::graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, rmm::device_uvector< int64_t > const &next_clusters_v, edge_src_property_t< cugraph::graph_view_t< int64_t, int64_t, false, false >, int64_t > const &src_clusters_cache)

template<typename vertex_t, typename edge_t, bool multi_gpu> rmm::device_uvector<vertex_t> maximal_independent_moves(raft::handle_t const &handle, cugraph::graph_view_t<vertex_t, edge_t, false, multi_gpu> const &graph_view, raft::random::RngState &rng_state)#

template rmm::device_uvector< int32_t > maximal_independent_moves (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &decision_graph_view, raft::random::RngState &rng_state)

template rmm::device_uvector< int64_t > maximal_independent_moves (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &decision_graph_view, raft::random::RngState &rng_state)

template rmm::device_uvector< int32_t > maximal_independent_moves (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &decision_graph_view, raft::random::RngState &rng_state)

template rmm::device_uvector< int64_t > maximal_independent_moves (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &decision_graph_view, raft::random::RngState &rng_state)

template<typename graph_view_t, typename weight_t> std::tuple<rmm::device_uvector<typename graph_view_t::vertex_type>, std::pair<rmm::device_uvector<typename graph_view_t::vertex_type>, rmm::device_uvector<typename graph_view_t::vertex_type>>> refine_clustering(raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t const &graph_view, std::optional<edge_property_view_t<typename graph_view_t::edge_type, weight_t const*>> edge_weight_view, weight_t total_edge_weight, weight_t resolution, weight_t theta, rmm::device_uvector<weight_t> const &vertex_weights_v, rmm::device_uvector<typename graph_view_t::vertex_type> &&cluster_keys_v, rmm::device_uvector<weight_t> &&cluster_weights_v, rmm::device_uvector<typename graph_view_t::vertex_type> &&next_clusters_v, edge_src_property_t<graph_view_t, weight_t> const &src_vertex_weights_cache, edge_src_property_t<graph_view_t, typename graph_view_t::vertex_type> const &src_clusters_cache, edge_dst_property_t<graph_view_t, typename graph_view_t::vertex_type> const &dst_clusters_cache)#

template<typename GraphViewType, typename weight_t> std::tuple<rmm::device_uvector<typename GraphViewType::vertex_type>, std::pair<rmm::device_uvector<typename GraphViewType::vertex_type>, rmm::device_uvector<typename GraphViewType::vertex_type>>> refine_clustering(raft::handle_t const &handle, raft::random::RngState &rng_state, GraphViewType const &graph_view, std::optional<edge_property_view_t<typename GraphViewType::edge_type, weight_t const*>> edge_weight_view, weight_t total_edge_weight, weight_t resolution, weight_t theta, rmm::device_uvector<weight_t> const &weighted_degree_of_vertices, rmm::device_uvector<typename GraphViewType::vertex_type> &&louvain_cluster_keys, rmm::device_uvector<weight_t> &&louvain_cluster_weights, rmm::device_uvector<typename GraphViewType::vertex_type> &&louvain_assignment_of_vertices, edge_src_property_t<GraphViewType, weight_t> const &src_vertex_weights_cache, edge_src_property_t<GraphViewType, typename GraphViewType::vertex_type> const &src_louvain_assignment_cache, edge_dst_property_t<GraphViewType, typename GraphViewType::vertex_type> const &dst_louvain_assignment_cache)#

template std::tuple< rmm::device_uvector< int32_t >, std::pair< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t > > > refine_clustering (raft::handle_t const &handle, raft::random::RngState &rng_state, cugraph::graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, float total_edge_weight, float resolution, float theta, rmm::device_uvector< float > const &vertex_weights_v, rmm::device_uvector< int32_t > &&cluster_keys_v, rmm::device_uvector< float > &&cluster_weights_v, rmm::device_uvector< int32_t > &&next_clusters_v, edge_src_property_t< cugraph::graph_view_t< int32_t, int32_t, false, true >, float > const &src_vertex_weights_cache, edge_src_property_t< cugraph::graph_view_t< int32_t, int32_t, false, true >, int32_t > const &src_clusters_cache, edge_dst_property_t< cugraph::graph_view_t< int32_t, int32_t, false, true >, int32_t > const &dst_clusters_cache)

template std::tuple< rmm::device_uvector< int32_t >, std::pair< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t > > > refine_clustering (raft::handle_t const &handle, raft::random::RngState &rng_state, cugraph::graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, double total_edge_weight, double resolution, double theta, rmm::device_uvector< double > const &vertex_weights_v, rmm::device_uvector< int32_t > &&cluster_keys_v, rmm::device_uvector< double > &&cluster_weights_v, rmm::device_uvector< int32_t > &&next_clusters_v, edge_src_property_t< cugraph::graph_view_t< int32_t, int32_t, false, true >, double > const &src_vertex_weights_cache, edge_src_property_t< cugraph::graph_view_t< int32_t, int32_t, false, true >, int32_t > const &src_clusters_cache, edge_dst_property_t< cugraph::graph_view_t< int32_t, int32_t, false, true >, int32_t > const &dst_clusters_cache)

template std::tuple< rmm::device_uvector< int64_t >, std::pair< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t > > > refine_clustering (raft::handle_t const &handle, raft::random::RngState &rng_state, cugraph::graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, float total_edge_weight, float resolution, float theta, rmm::device_uvector< float > const &vertex_weights_v, rmm::device_uvector< int64_t > &&cluster_keys_v, rmm::device_uvector< float > &&cluster_weights_v, rmm::device_uvector< int64_t > &&next_clusters_v, edge_src_property_t< cugraph::graph_view_t< int64_t, int64_t, false, true >, float > const &src_vertex_weights_cache, edge_src_property_t< cugraph::graph_view_t< int64_t, int64_t, false, true >, int64_t > const &src_clusters_cache, edge_dst_property_t< cugraph::graph_view_t< int64_t, int64_t, false, true >, int64_t > const &dst_clusters_cache)

template std::tuple< rmm::device_uvector< int64_t >, std::pair< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t > > > refine_clustering (raft::handle_t const &handle, raft::random::RngState &rng_state, cugraph::graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, double total_edge_weight, double resolution, double theta, rmm::device_uvector< double > const &vertex_weights_v, rmm::device_uvector< int64_t > &&cluster_keys_v, rmm::device_uvector< double > &&cluster_weights_v, rmm::device_uvector< int64_t > &&next_clusters_v, edge_src_property_t< cugraph::graph_view_t< int64_t, int64_t, false, true >, double > const &src_vertex_weights_cache, edge_src_property_t< cugraph::graph_view_t< int64_t, int64_t, false, true >, int64_t > const &src_clusters_cache, edge_dst_property_t< cugraph::graph_view_t< int64_t, int64_t, false, true >, int64_t > const &dst_clusters_cache)

template std::tuple< rmm::device_uvector< int32_t >, std::pair< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t > > > refine_clustering (raft::handle_t const &handle, raft::random::RngState &rng_state, cugraph::graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, float total_edge_weight, float resolution, float theta, rmm::device_uvector< float > const &vertex_weights_v, rmm::device_uvector< int32_t > &&cluster_keys_v, rmm::device_uvector< float > &&cluster_weights_v, rmm::device_uvector< int32_t > &&next_clusters_v, edge_src_property_t< cugraph::graph_view_t< int32_t, int32_t, false, false >, float > const &src_vertex_weights_cache, edge_src_property_t< cugraph::graph_view_t< int32_t, int32_t, false, false >, int32_t > const &src_clusters_cache, edge_dst_property_t< cugraph::graph_view_t< int32_t, int32_t, false, false >, int32_t > const &dst_clusters_cache)

template std::tuple< rmm::device_uvector< int32_t >, std::pair< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t > > > refine_clustering (raft::handle_t const &handle, raft::random::RngState &rng_state, cugraph::graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, double total_edge_weight, double resolution, double theta, rmm::device_uvector< double > const &vertex_weights_v, rmm::device_uvector< int32_t > &&cluster_keys_v, rmm::device_uvector< double > &&cluster_weights_v, rmm::device_uvector< int32_t > &&next_clusters_v, edge_src_property_t< cugraph::graph_view_t< int32_t, int32_t, false, false >, double > const &src_vertex_weights_cache, edge_src_property_t< cugraph::graph_view_t< int32_t, int32_t, false, false >, int32_t > const &src_clusters_cache, edge_dst_property_t< cugraph::graph_view_t< int32_t, int32_t, false, false >, int32_t > const &dst_clusters_cache)

template std::tuple< rmm::device_uvector< int64_t >, std::pair< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t > > > refine_clustering (raft::handle_t const &handle, raft::random::RngState &rng_state, cugraph::graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, float total_edge_weight, float resolution, float theta, rmm::device_uvector< float > const &vertex_weights_v, rmm::device_uvector< int64_t > &&cluster_keys_v, rmm::device_uvector< float > &&cluster_weights_v, rmm::device_uvector< int64_t > &&next_clusters_v, edge_src_property_t< cugraph::graph_view_t< int64_t, int64_t, false, false >, float > const &src_vertex_weights_cache, edge_src_property_t< cugraph::graph_view_t< int64_t, int64_t, false, false >, int64_t > const &src_clusters_cache, edge_dst_property_t< cugraph::graph_view_t< int64_t, int64_t, false, false >, int64_t > const &dst_clusters_cache)

template std::tuple< rmm::device_uvector< int64_t >, std::pair< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t > > > refine_clustering (raft::handle_t const &handle, raft::random::RngState &rng_state, cugraph::graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, double total_edge_weight, double resolution, double theta, rmm::device_uvector< double > const &vertex_weights_v, rmm::device_uvector< int64_t > &&cluster_keys_v, rmm::device_uvector< double > &&cluster_weights_v, rmm::device_uvector< int64_t > &&next_clusters_v, edge_src_property_t< cugraph::graph_view_t< int64_t, int64_t, false, false >, double > const &src_vertex_weights_cache, edge_src_property_t< cugraph::graph_view_t< int64_t, int64_t, false, false >, int64_t > const &src_clusters_cache, edge_dst_property_t< cugraph::graph_view_t< int64_t, int64_t, false, false >, int64_t > const &dst_clusters_cache)

template<typename vertex_t, typename edge_t, typename weight_t, bool multi_gpu> std::tuple<rmm::device_uvector<vertex_t>, size_t, weight_t> ecg(raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t<vertex_t, edge_t, false, multi_gpu> const &graph_view, std::optional<edge_property_view_t<edge_t, weight_t const*>> edge_weight_view, weight_t min_weight, size_t ensemble_size, size_t max_level, weight_t threshold, weight_t resolution)#

template<typename vertex_t, typename edge_t, bool store_transposed, bool multi_gpu> edge_property_t<graph_view_t<vertex_t, edge_t, false, multi_gpu>, edge_t> edge_triangle_count_impl(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu> const &graph_view, bool do_expensive_check)#

template<typename vertex_t, typename edge_t, bool multi_gpu> void check_clustering(graph_view_t<vertex_t, edge_t, false, multi_gpu> const &graph_view, vertex_t *clustering)#

template<typename vertex_t, bool multi_gpu> vertex_t remove_duplicates(raft::handle_t const &handle, rmm::device_uvector<vertex_t> &input_array)#

template<typename vertex_t, typename edge_t, typename weight_t, bool multi_gpu, bool store_transposed = false> std::pair<std::unique_ptr<Dendrogram<vertex_t>>, weight_t> leiden(raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t<vertex_t, edge_t, false, multi_gpu> const &graph_view, std::optional<edge_property_view_t<edge_t, weight_t const*>> edge_weight_view, size_t max_level, weight_t resolution, weight_t theta = 1.0)#

template<typename vertex_t, bool multi_gpu> void relabel_cluster_ids(raft::handle_t const &handle, rmm::device_uvector<vertex_t> &unique_cluster_ids, vertex_t *clustering, size_t num_nodes)#

template<typename vertex_t, typename edge_t, bool multi_gpu> void flatten_leiden_dendrogram(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, false, multi_gpu> const &graph_view, Dendrogram<vertex_t> const &dendrogram, vertex_t *clustering)#

template<typename vertex_t, typename edge_t, typename weight_t, bool multi_gpu> std::pair<std::unique_ptr<Dendrogram<vertex_t>>, weight_t> louvain(raft::handle_t const &handle, std::optional<std::reference_wrapper<raft::random::RngState>> rng_state, graph_view_t<vertex_t, edge_t, false, multi_gpu> const &graph_view, std::optional<edge_property_view_t<edge_t, weight_t const*>> edge_weight_view, size_t max_level, weight_t threshold, weight_t resolution)#

template<typename vertex_t, typename edge_t, bool multi_gpu> void flatten_dendrogram(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, false, multi_gpu> const &graph_view, Dendrogram<vertex_t> const &dendrogram, vertex_t *clustering)#

template<typename VT, typename ET, typename WT, int TPB_X = 32> std::enable_if_t<std::is_signed<VT>::value> connected_components_impl(legacy::GraphCSRView<VT, ET, WT> const &graph, cugraph_cc_t connectivity_type, VT *labels, cudaStream_t stream)#

Compute connected components. The weak version has been eliminated in lieu of the primitive based implementation.

The strong version (for directed or undirected graphs) is based on: [2] Gilbert, J. et al, 2011. “Graph Algorithms in the Language of Linear Algebra”

C = I | A | A^2 |…| A^k where matrix multiplication is via semi-ring: (combine, reduce) == (&, |) (bitwise ops) Then: X = C & transpose(C); and finally, apply get_labels(X);

Template Parameters:

IndexT – the numeric type of non-floating point elements
TPB_X – the threads to use per block when configuring the kernel

Parameters:

graph – input graph; assumed undirected for weakly CC [in]
connectivity_type – Ignored [in]
stream – the cuda stream [in]

template<typename vertex_t, typename edge_t, bool multi_gpu> rmm::device_uvector<vertex_t> maximal_independent_set(raft::handle_t const &handle, cugraph::graph_view_t<vertex_t, edge_t, false, multi_gpu> const &graph_view, raft::random::RngState &rng_state)#

template<typename vertex_t, typename edge_t, bool multi_gpu> rmm::device_uvector<vertex_t> vertex_coloring(raft::handle_t const &handle, cugraph::graph_view_t<vertex_t, edge_t, false, multi_gpu> const &graph_view, raft::random::RngState &rng_state)#

template<typename VT, typename ET, typename WT> VT sort(legacy::GraphCOOView<VT, ET, WT> &graph, rmm::cuda_stream_view stream_view)#

Sort input graph and find the total number of vertices.

Lexicographically sort a COO view and find the total number of vertices

Throws:

cugraph::logic_error – when an error occurs.

Template Parameters:

VT – Type of vertex identifiers. Supported value : int (signed, 32-bit)
ET – Type of edge identifiers. Supported value : int (signed, 32-bit)
WT – Type of edge weights. Supported value : float or double.

Parameters:

graph – [in] The input graph object
stream_view – [in] The cuda stream for kernel calls
result – [out] Total number of vertices

template<typename VT, typename ET> void fill_offset(VT *source, ET *offsets, VT number_of_vertices, ET number_of_edges, rmm::cuda_stream_view stream_view)#

template<typename VT, typename ET> rmm::device_buffer create_offset(VT *source, VT number_of_vertices, ET number_of_edges, rmm::cuda_stream_view stream_view, rmm::device_async_resource_ref mr)#

template<typename T> rmm::device_uvector<T> device_allgatherv(raft::handle_t const &handle, raft::comms::comms_t const &comm, raft::device_span<T const> d_input)#

Gather the span of data from all ranks and broadcast the combined data to all ranks.

Parameters:

handle – [in] RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
comm – [in] Raft comms that manages underlying NCCL comms handles across the ranks.
d_input – [in] The span of data to perform the ‘allgatherv’.

Returns:

A vector containing the combined data of all ranks.

template rmm::device_uvector< int32_t > device_allgatherv (raft::handle_t const &handle, raft::comms::comms_t const &comm, raft::device_span< int32_t const > d_input)

template rmm::device_uvector< float > device_allgatherv (raft::handle_t const &handle, raft::comms::comms_t const &comm, raft::device_span< float const > d_input)

template rmm::device_uvector< int64_t > device_allgatherv (raft::handle_t const &handle, raft::comms::comms_t const &comm, raft::device_span< int64_t const > d_input)

template rmm::device_uvector< double > device_allgatherv (raft::handle_t const &handle, raft::comms::comms_t const &comm, raft::device_span< double const > d_input)

template<typename vertex_t, typename value_t, bool multi_gpu> rmm::device_uvector<value_t> collect_local_vertex_values_from_ext_vertex_value_pairs(raft::handle_t const &handle, rmm::device_uvector<vertex_t> &&d_vertices, rmm::device_uvector<value_t> &&d_values, rmm::device_uvector<vertex_t> const &number_map, vertex_t local_vertex_first, vertex_t local_vertex_last, value_t default_value, bool do_expensive_check)#

Collect vertex values (represented as k/v pairs across cluster) and return local value arrays on the GPU responsible for each vertex.

Data will be shuffled, renumbered and initialized with the default value, then: return_array[d_vertices[i]] = d_values[i]

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
value_t – Type of value associated with the vertex.
bool – multi_gpu flag

Parameters:

handle – [in] RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
d_vertices – [in] Vertex IDs for the k/v pair
d_values – [in] Values for the k/v pair
The – [in] number map for performing renumbering
local_vertex_first – [in] The first vertex id assigned to the local GPU
local_vertex_last – [in] The last vertex id assigned to the local GPU
default_value – [in] The default value the return array will be initialized by
do_expensive_check – [in] If true, enable expensive validation checks

Returns:

device vector of values, where return[i] is the value associated with vertex (i + local_vertex_first)

template rmm::device_uvector< float > collect_local_vertex_values_from_ext_vertex_value_pairs< int32_t, float, true > (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&d_vertices, rmm::device_uvector< float > &&d_values, rmm::device_uvector< int32_t > const &number_map, int32_t local_vertex_first, int32_t local_vertex_last, float default_value, bool do_expensive_check)

template rmm::device_uvector< int32_t > collect_local_vertex_values_from_ext_vertex_value_pairs< int32_t, int32_t, true > (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&d_vertices, rmm::device_uvector< int32_t > &&d_values, rmm::device_uvector< int32_t > const &number_map, int32_t local_vertex_first, int32_t local_vertex_last, int32_t default_value, bool do_expensive_check)

template rmm::device_uvector< double > collect_local_vertex_values_from_ext_vertex_value_pairs< int32_t, double, true > (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&d_vertices, rmm::device_uvector< double > &&d_values, rmm::device_uvector< int32_t > const &number_map, int32_t local_vertex_first, int32_t local_vertex_last, double default_value, bool do_expensive_check)

template rmm::device_uvector< float > collect_local_vertex_values_from_ext_vertex_value_pairs< int64_t, float, true > (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&d_vertices, rmm::device_uvector< float > &&d_values, rmm::device_uvector< int64_t > const &number_map, int64_t local_vertex_first, int64_t local_vertex_last, float default_value, bool do_expensive_check)

template rmm::device_uvector< double > collect_local_vertex_values_from_ext_vertex_value_pairs< int64_t, double, true > (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&d_vertices, rmm::device_uvector< double > &&d_values, rmm::device_uvector< int64_t > const &number_map, int64_t local_vertex_first, int64_t local_vertex_last, double default_value, bool do_expensive_check)

template rmm::device_uvector< int64_t > collect_local_vertex_values_from_ext_vertex_value_pairs< int64_t, int64_t, true > (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&d_vertices, rmm::device_uvector< int64_t > &&d_values, rmm::device_uvector< int64_t > const &number_map, int64_t local_vertex_first, int64_t local_vertex_last, int64_t default_value, bool do_expensive_check)

template rmm::device_uvector< float > collect_local_vertex_values_from_ext_vertex_value_pairs< int32_t, float, false > (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&d_vertices, rmm::device_uvector< float > &&d_values, rmm::device_uvector< int32_t > const &number_map, int32_t local_vertex_first, int32_t local_vertex_last, float default_value, bool do_expensive_check)

template rmm::device_uvector< int32_t > collect_local_vertex_values_from_ext_vertex_value_pairs< int32_t, int32_t, false > (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&d_vertices, rmm::device_uvector< int32_t > &&d_values, rmm::device_uvector< int32_t > const &number_map, int32_t local_vertex_first, int32_t local_vertex_last, int32_t default_value, bool do_expensive_check)

template rmm::device_uvector< double > collect_local_vertex_values_from_ext_vertex_value_pairs< int32_t, double, false > (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&d_vertices, rmm::device_uvector< double > &&d_values, rmm::device_uvector< int32_t > const &number_map, int32_t local_vertex_first, int32_t local_vertex_last, double default_value, bool do_expensive_check)

template rmm::device_uvector< float > collect_local_vertex_values_from_ext_vertex_value_pairs< int64_t, float, false > (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&d_vertices, rmm::device_uvector< float > &&d_values, rmm::device_uvector< int64_t > const &number_map, int64_t local_vertex_first, int64_t local_vertex_last, float default_value, bool do_expensive_check)

template rmm::device_uvector< double > collect_local_vertex_values_from_ext_vertex_value_pairs< int64_t, double, false > (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&d_vertices, rmm::device_uvector< double > &&d_values, rmm::device_uvector< int64_t > const &number_map, int64_t local_vertex_first, int64_t local_vertex_last, double default_value, bool do_expensive_check)

template rmm::device_uvector< int64_t > collect_local_vertex_values_from_ext_vertex_value_pairs< int64_t, int64_t, false > (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&d_vertices, rmm::device_uvector< int64_t > &&d_values, rmm::device_uvector< int64_t > const &number_map, int64_t local_vertex_first, int64_t local_vertex_last, int64_t default_value, bool do_expensive_check)

template<typename vertex_t, typename edge_t, typename weight_t, typename edge_type_t> rmm::device_uvector<size_t> groupby_and_count_edgelist_by_local_partition_id(raft::handle_t const &handle, rmm::device_uvector<vertex_t> &d_edgelist_majors, rmm::device_uvector<vertex_t> &d_edgelist_minors, std::optional<rmm::device_uvector<weight_t>> &d_edgelist_weights, std::optional<rmm::device_uvector<edge_t>> &d_edgelist_edge_ids, std::optional<rmm::device_uvector<edge_type_t>> &d_edgelist_edge_types, bool groupby_and_count_local_partition_by_minor = false)#

Groupby and count edgelist using the key function which returns the target local partition ID for an edge.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
weight_t – Type of edge weights. Needs to be a floating point type.

Parameters:

handle – [in] RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
d_edgelist_majors – [inout] Vertex IDs for sources (if we are internally storing edges in the sparse 2D matrix using sources as major indices) or destinations (otherwise)
d_edgelist_minors – [inout] Vertex IDs for destinations (if we are internally storing edges in the sparse 2D matrix using sources as major indices) or sources (otherwise)
d_edgelist_weights – [inout] Optional edge weights
d_edgelist_id_type_pairs – [inout] Optional edge (ID, type) pairs
groupby_and_count_local_partition_by_minor – [in] If set to true, groupby and count edges based on (local partition ID, GPU ID) pairs (where GPU IDs are computed by applying the compute_gpu_id_from_vertex_t function to the minor vertex ID). If set to false, groupby and count edges by just local partition ID.

Returns:

A vector containing the number of edges in each local partition (if groupby_and_count_local_partition is false) or in each segment with the same (local partition ID, GPU ID) pair.

template rmm::device_uvector< size_t > groupby_and_count_edgelist_by_local_partition_id (raft::handle_t const &handle, rmm::device_uvector< int32_t > &d_edgelist_majors, rmm::device_uvector< int32_t > &d_edgelist_minors, std::optional< rmm::device_uvector< float > > &d_edgelist_weights, std::optional< rmm::device_uvector< int32_t > > &d_edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &d_edgelist_edge_types, bool groupby_and_counts_local_partition)

template rmm::device_uvector< size_t > groupby_and_count_edgelist_by_local_partition_id (raft::handle_t const &handle, rmm::device_uvector< int32_t > &d_edgelist_majors, rmm::device_uvector< int32_t > &d_edgelist_minors, std::optional< rmm::device_uvector< double > > &d_edgelist_weights, std::optional< rmm::device_uvector< int32_t > > &d_edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &d_edgelist_edge_types, bool groupby_and_counts_local_partition)

template rmm::device_uvector< size_t > groupby_and_count_edgelist_by_local_partition_id (raft::handle_t const &handle, rmm::device_uvector< int64_t > &d_edgelist_majors, rmm::device_uvector< int64_t > &d_edgelist_minors, std::optional< rmm::device_uvector< float > > &d_edgelist_weights, std::optional< rmm::device_uvector< int64_t > > &d_edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &d_edgelist_edge_types, bool groupby_and_counts_local_partition)

template rmm::device_uvector< size_t > groupby_and_count_edgelist_by_local_partition_id (raft::handle_t const &handle, rmm::device_uvector< int64_t > &d_edgelist_majors, rmm::device_uvector< int64_t > &d_edgelist_minors, std::optional< rmm::device_uvector< double > > &d_edgelist_weights, std::optional< rmm::device_uvector< int64_t > > &d_edgelist_edge_ids, std::optional< rmm::device_uvector< int32_t > > &d_edgelist_edge_types, bool groupby_and_counts_local_partition)

template<typename vertex_t> rmm::device_uvector<vertex_t> permute_range(raft::handle_t const &handle, raft::random::RngState &rng_state, vertex_t local_start, vertex_t local_range_size, bool multi_gpu = false, bool do_expensive_check = false)#

Permute a range.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.

Parameters:

handle – [in] RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
rng_state – [in] The RngState instance holding pseudo-random number generator state.
local_range_size – [in] Size of local range assigned to this process.
local_start – [in] Start of local range assigned to this process.

Returns:

permuted range.

template rmm::device_uvector< int32_t > permute_range (raft::handle_t const &handle, raft::random::RngState &rng_state, int32_t local_range_start, int32_t local_range_size, bool multi_gpu, bool do_expensive_check)

template rmm::device_uvector< int64_t > permute_range (raft::handle_t const &handle, raft::random::RngState &rng_state, int64_t local_range_start, int64_t local_range_size, bool multi_gpu, bool do_expensive_check)

template void uniform_random_fill (rmm::cuda_stream_view const &stream_view, int32_t *d_value, size_t size, int32_t min_value, int32_t max_value, raft::random::RngState &rng_state)

template void uniform_random_fill (rmm::cuda_stream_view const &stream_view, float *d_value, size_t size, float min_value, float max_value, raft::random::RngState &rng_state)

template void scalar_fill (raft::handle_t const &handle, int32_t *d_value, size_t size, int32_t value)

template void scalar_fill (raft::handle_t const &handle, size_t *d_value, size_t size, size_t value)

template void scalar_fill (raft::handle_t const &handle, float *d_value, size_t size, float value)

template void sort_ints (raft::handle_t const &handle, raft::device_span< int32_t > values)

template size_t unique_ints (raft::handle_t const &handle, raft::device_span< int32_t > values)

template void sequence_fill (rmm::cuda_stream_view const &stream_view, int32_t *d_value, size_t size, int32_t start_value)

template void sequence_fill (rmm::cuda_stream_view const &stream_view, uint32_t *d_value, size_t size, uint32_t start_value)

template void transform_increment_ints (raft::device_span< int32_t > values, int32_t value, rmm::cuda_stream_view const &stream_view)

template void stride_fill (rmm::cuda_stream_view const &stream_view, int32_t *d_value, size_t size, int32_t start_value, int32_t stride)

template void stride_fill (rmm::cuda_stream_view const &stream_view, uint32_t *d_value, size_t size, uint32_t start_value, uint32_t stride)

template int32_t compute_maximum_vertex_id (rmm::cuda_stream_view const &stream_view, int32_t const *d_edgelist_srcs, int32_t const *d_edgelist_dsts, size_t num_edges)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t > > filter_degree_0_vertices (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&d_vertices, rmm::device_uvector< int32_t > &&d_out_degs)

template bool is_sorted (raft::handle_t const &handle, raft::device_span< int32_t > span)

template bool is_equal (raft::handle_t const &handle, raft::device_span< int32_t > span1, raft::device_span< int32_t > span2)

template size_t count_values< int32_t > (raft::handle_t const &handle, raft::device_span< int32_t const > span, int32_t value)

template void uniform_random_fill (rmm::cuda_stream_view const &stream_view, int64_t *d_value, size_t size, int64_t min_value, int64_t max_value, raft::random::RngState &rng_state)

template void uniform_random_fill (rmm::cuda_stream_view const &stream_view, double *d_value, size_t size, double min_value, double max_value, raft::random::RngState &rng_state)

template void scalar_fill (raft::handle_t const &handle, int64_t *d_value, size_t size, int64_t value)

template void scalar_fill (raft::handle_t const &handle, double *d_value, size_t size, double value)

template void sort_ints (raft::handle_t const &handle, raft::device_span< int64_t > values)

template size_t unique_ints (raft::handle_t const &handle, raft::device_span< int64_t > values)

template void sequence_fill (rmm::cuda_stream_view const &stream_view, int64_t *d_value, size_t size, int64_t start_value)

template void sequence_fill (rmm::cuda_stream_view const &stream_view, uint64_t *d_value, size_t size, uint64_t start_value)

template void transform_increment_ints (raft::device_span< int64_t > values, int64_t value, rmm::cuda_stream_view const &stream_view)

template void stride_fill (rmm::cuda_stream_view const &stream_view, int64_t *d_value, size_t size, int64_t start_value, int64_t stride)

template void stride_fill (rmm::cuda_stream_view const &stream_view, uint64_t *d_value, size_t size, uint64_t start_value, uint64_t stride)

template int64_t compute_maximum_vertex_id (rmm::cuda_stream_view const &stream_view, int64_t const *d_edgelist_srcs, int64_t const *d_edgelist_dsts, size_t num_edges)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int64_t > > filter_degree_0_vertices (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&d_vertices, rmm::device_uvector< int64_t > &&d_out_degs)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t > > filter_degree_0_vertices (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&d_vertices, rmm::device_uvector< int64_t > &&d_out_degs)

template bool is_sorted (raft::handle_t const &handle, raft::device_span< int64_t > span)

template bool is_equal (raft::handle_t const &handle, raft::device_span< int64_t > span1, raft::device_span< int64_t > span2)

template size_t count_values< int64_t > (raft::handle_t const &handle, raft::device_span< int64_t const > span, int64_t value)

template<typename value_t> void uniform_random_fill(rmm::cuda_stream_view const &stream_view, value_t *d_value, size_t size, value_t min_value, value_t max_value, raft::random::RngState &rng_state)#

Fill a buffer with uniformly distributed random values.

Fills a buffer with uniformly distributed random values between the specified minimum and maximum values.

Template Parameters:

value_t – type of the value to operate on

Parameters:

stream_view – [in] stream view
d_value – [out] device array to fill
size – [in] number of elements in array
min_value – [in] minimum value (inclusive)
max_value – [in] maximum value (exclusive)
rng_state – [in] The RngState instance holding pseudo-random number generator state.

template<typename value_t> void scalar_fill(raft::handle_t const &handle, value_t *d_value, size_t size, value_t value)#

Fill a buffer with a constant value.

Template Parameters:

value_t – type of the value to operate on

Parameters:

handle – [in] RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
d_value – [out] device array to fill
size – [in] number of elements in array
value – [in] value

template<typename value_t> void sort_ints(raft::handle_t const &handle, raft::device_span<value_t> values)#

Sort a device span.

Template Parameters:

value_t – type of the value to operate on. Must be either int32_t or int64_t.

Parameters:

handle – [in] RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
values – [out] device span to sort

template<typename value_t> size_t unique_ints(raft::handle_t const &handle, raft::device_span<value_t> values)#

Keep unique element from a device span.

Template Parameters:

value_t – type of the value to operate on. Must be either int32_t or int64_t.

Parameters:

handle – [in] RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
values – [in] device span of unique elements.

Returns:

the number of unique elements.

template<typename value_t> void sequence_fill(rmm::cuda_stream_view const &stream_view, value_t *d_value, size_t size, value_t start_value)#

Fill a buffer with a sequence of values.

Fills the buffer with the sequence: {start_value, start_value+1, start_value+2, …, start_value+size-1}

Similar to the function std::iota, wraps the function thrust::sequence

Template Parameters:

value_t – type of the value to operate on.

Parameters:

stream_view – [in] stream view
d_value – [out] device array to fill
size – [in] number of elements in array
start_value – [in] starting value for sequence

template<typename value_t> void transform_increment_ints(raft::device_span<value_t> values, value_t value, rmm::cuda_stream_view const &stream_view)#

Increment the values of a device span by a constant value.

Template Parameters:

value_t – type of the value to operate on. Must be either int32_t or int64_t.

Parameters:

values – [out] device span to update
value – [in] value to be added to each element of the buffer
stream_view – [in] stream view

template<typename value_t> void stride_fill(rmm::cuda_stream_view const &stream_view, value_t *d_value, size_t size, value_t start_value, value_t stride)#

Fill a buffer with a sequence of values with the input stride.

Fills the buffer with the sequence with the input stride: {start_value, start_value+stride, start_value+stride*2, …, start_value+stride*(size-1)}

Template Parameters:

value_t – type of the value to operate on

Parameters:

stream_view – [in] stream view
d_value – [out] device array to fill
size – [in] number of elements in array
start_value – [in] starting value for sequence
stride – [in] input stride

template<typename vertex_t> vertex_t compute_maximum_vertex_id(rmm::cuda_stream_view const &stream_view, vertex_t const *d_edgelist_srcs, vertex_t const *d_edgelist_dsts, size_t num_edges)#

Compute the maximum vertex id of an edge list.

max(d_edgelist_srcs.max(), d_edgelist_dsts.max())

Template Parameters:

vertex_t – vertex type

Parameters:

stream_view – [in] stream view
d_edgelist_srcs – [in] device array storing edge source IDs
d_edgelist_dsts – [in] device array storing edge destination IDs
num_edges – [in] number of edges in the input source & destination arrays
the – maximum value occurring in the edge list

template<typename vertex_t, typename edge_t> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<edge_t>> filter_degree_0_vertices(raft::handle_t const &handle, rmm::device_uvector<vertex_t> &&d_vertices, rmm::device_uvector<edge_t> &&d_out_degs)#

Filter zero degree vertices from this frontier.

Template Parameters:

vertex_t – vertex type
edge_t – edge type

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
d_vertices – The input list of vertices
d_out_degs – The output degree of each vertex

Returns:

A tuple of device vectors the updated list of vertices and output degrees

template<typename data_t> bool is_sorted(raft::handle_t const &handle, raft::device_span<data_t> span)#

Check if device span is sorted.

Template Parameters:

data_t – type of data in span

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
span – The span of data to check

Returns:

true if sorted, false if not sorted

template<typename data_t> bool is_equal(raft::handle_t const &handle, raft::device_span<data_t> span1, raft::device_span<data_t> span2)#

Check if two device spans are equal. Returns true if every element in the spans are equal.

Template Parameters:

data_t – type of data in span

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
span1 – The span of data to compare
span2 – The span of data to compare

Returns:

true if equal, false if not equal

template<typename data_t> size_t count_values(raft::handle_t const &handle, raft::device_span<data_t const> span, data_t value)#

Count the number of times a value appears in a span.

Template Parameters:

data_t – type of data in span

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
span – The span of data to compare
value – The value to count

Returns:

The count of how many instances of that value occur

template<typename T> rmm::device_uvector<T> append_all(raft::handle_t const &handle, std::vector<rmm::device_uvector<T>> &&input)#

template<typename uvertex_t> __device__ std::enable_if_t< sizeof(uvertex_t)==8, uvertex_t > bitreversal (uvertex_t value)

template<typename uvertex_t> __device__ std::enable_if_t< sizeof(uvertex_t)==4, uvertex_t > bitreversal (uvertex_t value)

template<typename uvertex_t> __device__ std::enable_if_t< sizeof(uvertex_t)==2, uvertex_t > bitreversal (uvertex_t value)

template<typename vertex_t> __device__ vertex_t scramble (vertex_t value, size_t lgN)

template<typename vertex_t, typename edge_t, typename weight_t> void barnes_hut(raft::handle_t const &handle, legacy::GraphCOOView<vertex_t, edge_t, weight_t> &graph, float *pos, const int max_iter = 500, float *x_start = nullptr, float *y_start = nullptr, bool outbound_attraction_distribution = true, bool lin_log_mode = false, bool prevent_overlapping = false, const float edge_weight_influence = 1.0, const float jitter_tolerance = 1.0, const float theta = 0.5, const float scaling_ratio = 2.0, bool strong_gravity_mode = false, const float gravity = 1.0, bool verbose = false, internals::GraphBasedDimRedCallback *callback = nullptr)#

static __global__ void InitializationKernel (unsigned *restrict limiter, int *restrict maxdepthd, float *restrict radiusd): Intializes the states of objects. This speeds the overall kernel up.

static __global__ void ResetKernel (float *restrict radiusd_squared, int *restrict bottomd, const int NNODES, const float *restrict radiusd): Reset root.

static __global__ __launch_bounds__ (THREADS1, FACTOR1) void BoundingBoxKernel(int *restrict startd: Figures the bounding boxes for every point in the embedding.

for (int j=i+blockIdx.x *THREADS1;j< N;j+=inc)

for (int j=THREADS1/2;j > i;j/=2)

if (i==0)

static __global__ __launch_bounds__ (1024, 1) void ClearKernel1(int *restrict childd

Clear some of the state vectors up.

Clean more state vectors.

if (k< FOUR_N) k+

static __global__ __launch_bounds__ (THREADS2, FACTOR2) void TreeBuildingKernel(int *restrict childd: Build the actual KD Tree.

while (i< N)

if (localmaxdepth > 32) localmaxdepth

atomicMax(maxdepthd, localmaxdepth)#

static __global__ __launch_bounds__ (THREADS3, FACTOR3) void SummarizationKernel(int *restrict countd: Summarize the KD Tree via cell gathering

while (k<=NNODES)

static __global__ __launch_bounds__ (THREADS4, FACTOR4) void SortKernel(int *restrict sortd: Sort the cells

while (k >=bottom)

static __global__ __launch_bounds__ (THREADS5, FACTOR5) void RepulsionKernel(const float scaling_ratio: Calculate the repulsive forces using the KD Tree

if (threadIdx.x==0)

__syncthreads()#

__threadfence_block()#

static __global__ __launch_bounds__ (THREADS6, FACTOR6) void apply_forces_bh(float *restrict Y_x

template<typename vertex_t, typename edge_t, typename weight_t> void exact_fa2(raft::handle_t const &handle, legacy::GraphCOOView<vertex_t, edge_t, weight_t> &graph, float *pos, const int max_iter = 500, float *x_start = nullptr, float *y_start = nullptr, bool outbound_attraction_distribution = true, bool lin_log_mode = false, bool prevent_overlapping = false, const float edge_weight_influence = 1.0, const float jitter_tolerance = 1.0, const float scaling_ratio = 2.0, bool strong_gravity_mode = false, const float gravity = 1.0, bool verbose = false, internals::GraphBasedDimRedCallback *callback = nullptr)#

template<typename vertex_t> static __global__ void repulsion_kernel (const float *restrict x_pos, const float *restrict y_pos, float *restrict repel_x, float *restrict repel_y, const int *restrict mass, const float scaling_ratio, const vertex_t n)

template<typename vertex_t, int TPB_X = 32, int TPB_Y = 32> void apply_repulsion (const float *restrict x_pos, const float *restrict y_pos, float *restrict repel_x, float *restrict repel_y, const int *restrict mass, const float scaling_ratio, const vertex_t n, cudaStream_t stream)

template<typename vertex_t, typename edge_t, typename weight_t> static __global__ void attraction_kernel (const vertex_t *restrict row, const vertex_t *restrict col, const weight_t *restrict v, const edge_t e, const float *restrict x_pos, const float *restrict y_pos, float *restrict attract_x, float *restrict attract_y, const int *restrict mass, bool outbound_attraction_distribution, bool lin_log_mode, const float edge_weight_influence, const float coef)

template<typename vertex_t, typename edge_t, typename weight_t> void apply_attraction (const vertex_t *restrict row, const vertex_t *restrict col, const weight_t *restrict v, const edge_t e, const float *restrict x_pos, const float *restrict y_pos, float *restrict attract_x, float *restrict attract_y, const int *restrict mass, bool outbound_attraction_distribution, bool lin_log_mode, const float edge_weight_influence, const float coef, cudaStream_t stream)

template<typename vertex_t> static __global__ void linear_gravity_kernel (const float *restrict x_pos, const float *restrict y_pos, float *restrict attract_x, float *restrict attract_y, const int *restrict mass, const float gravity, const vertex_t n)

template<typename vertex_t> static __global__ void strong_gravity_kernel (const float *restrict x_pos, const float *restrict y_pos, float *restrict attract_x, float *restrict attract_y, const int *restrict mass, const float gravity, const float scaling_ratio, const vertex_t n)

template<typename vertex_t> void apply_gravity (const float *restrict x_pos, const float *restrict y_pos, float *restrict attract_x, float *restrict attract_y, const int *restrict mass, const float gravity, bool strong_gravity_mode, const float scaling_ratio, const vertex_t n, cudaStream_t stream)

template<typename vertex_t> static __global__ void local_speed_kernel (const float *restrict repel_x, const float *restrict repel_y, const float *restrict attract_x, const float *restrict attract_y, const float *restrict old_dx, const float *restrict old_dy, const int *restrict mass, float *restrict swinging, float *restrict traction, const vertex_t n)

template<typename vertex_t> void compute_local_speed (const float *restrict repel_x, const float *restrict repel_y, const float *restrict attract_x, const float *restrict attract_y, float *restrict old_dx, float *restrict old_dy, const int *restrict mass, float *restrict swinging, float *restrict traction, const vertex_t n, cudaStream_t stream)

template<typename vertex_t> void adapt_speed (const float jitter_tolerance, float *restrict jt, float *restrict speed, float *restrict speed_efficiency, const float s, const float t, const vertex_t n)

template<typename vertex_t> static __global__ void update_positions_kernel (float *restrict x_pos, float *restrict y_pos, const float *restrict repel_x, const float *restrict repel_y, const float *restrict attract_x, const float *restrict attract_y, float *restrict old_dx, float *restrict old_dy, const float *restrict swinging, const float speed, const vertex_t n)

template<typename vertex_t> void apply_forces (float *restrict x_pos, float *restrict y_pos, const float *restrict repel_x, const float *restrict repel_y, const float *restrict attract_x, const float *restrict attract_y, float *restrict old_dx, float *restrict old_dy, const float *restrict swinging, const float speed, const vertex_t n, cudaStream_t stream)

inline int getMultiProcessorCount()#: helper method to get multi-processor count parameter

template<typename weight_t> weight_t default_epsilon()#

template<> float default_epsilon()#

template<> double default_epsilon()#

template<typename index_t, typename weight_t> weight_t hungarian(raft::handle_t const &handle, index_t num_rows, index_t num_cols, weight_t const *d_original_cost, index_t *d_assignment, weight_t epsilon)#

template<typename vertex_t, typename edge_t, typename weight_t> weight_t hungarian_sparse(raft::handle_t const &handle, legacy::GraphCOOView<vertex_t, edge_t, weight_t> const &graph, vertex_t num_workers, vertex_t const *workers, vertex_t *assignment, weight_t epsilon)#

template<typename GraphViewType, typename ReduceOp, typename result_t> void normalize(raft::handle_t const &handle, GraphViewType const &graph_view, result_t *hubs, result_t init, ReduceOp reduce_op)#

template<typename GraphViewType, typename result_t> std::tuple<result_t, size_t> hits(raft::handle_t const &handle, GraphViewType const &graph_view, result_t *const hubs, result_t *const authorities, result_t epsilon, size_t max_iterations, bool has_initial_hubs_guess, bool normalize, bool do_expensive_check)#

template<typename GraphViewType, typename weight_t, typename result_t> centrality_algorithm_metadata_t pagerank(raft::handle_t const &handle, GraphViewType const &pull_graph_view, std::optional<edge_property_view_t<typename GraphViewType::edge_type, weight_t const*>> edge_weight_view, std::optional<raft::device_span<weight_t const>> precomputed_vertex_out_weight_sums, std::optional<std::tuple<raft::device_span<typename GraphViewType::vertex_type const>, raft::device_span<result_t const>>> personalization, raft::device_span<result_t> pageranks, result_t alpha, result_t epsilon, size_t max_iterations, bool do_expensive_check)#

template<typename vertex_t, typename edge_t, typename weight_t, bool multi_gpu, typename functor_t> rmm::device_uvector<weight_t> similarity(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, false, multi_gpu> const &graph_view, std::optional<edge_property_view_t<edge_t, weight_t const*>> edge_weight_view, std::tuple<raft::device_span<vertex_t const>, raft::device_span<vertex_t const>> vertex_pairs, functor_t functor, coefficient_t coeff, bool do_expensive_check = false)#

template<typename vertex_t, typename edge_t, typename weight_t, bool multi_gpu, typename functor_t> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>, rmm::device_uvector<weight_t>> all_pairs_similarity(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, false, multi_gpu> const &graph_view, std::optional<edge_property_view_t<edge_t, weight_t const*>> edge_weight_view, std::optional<raft::device_span<vertex_t const>> vertices, std::optional<size_t> topk, functor_t functor, coefficient_t coeff, bool do_expensive_check = false)#

template<typename GraphViewType, typename EdgeIdInputWrapper, typename EdgeTypeInputWrapper, typename EdgeTypeAndIdToSrcDstLookupContainerType> EdgeTypeAndIdToSrcDstLookupContainerType build_edge_id_and_type_to_src_dst_lookup_map(raft::handle_t const &handle, GraphViewType const &graph_view, EdgeIdInputWrapper edge_id_view, EdgeTypeInputWrapper edge_type_view)#

template<typename vertex_t, typename edge_id_t, typename edge_type_t, typename EdgeTypeAndIdToSrcDstLookupContainerType, bool multi_gpu> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>> lookup_endpoints_from_edge_ids_and_single_type(raft::handle_t const &handle, EdgeTypeAndIdToSrcDstLookupContainerType const &search_container, raft::device_span<edge_id_t const> edge_ids_to_lookup, edge_type_t edge_type_to_lookup)#

template<typename vertex_t, typename edge_id_t, typename edge_type_t, typename EdgeTypeAndIdToSrcDstLookupContainerType, bool multi_gpu> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>> lookup_endpoints_from_edge_ids_and_types(raft::handle_t const &handle, EdgeTypeAndIdToSrcDstLookupContainerType const &search_container, raft::device_span<edge_id_t const> edge_ids_to_lookup, raft::device_span<edge_type_t const> edge_types_to_lookup)#

template<typename BufferKeyOutputIterator, typename BufferValueOutputIterator, typename e_op_result_t> __device__ void push_buffer_element (BufferKeyOutputIterator buffer_key_output_first, BufferValueOutputIterator buffer_value_output_first, size_t buffer_idx, e_op_result_t e_op_result)

template<typename BufferKeyOutputIterator, typename BufferValueOutputIterator, typename e_op_result_t> __device__ void warp_push_buffer_elements (BufferKeyOutputIterator buffer_key_output_first, BufferValueOutputIterator buffer_value_output_first, cuda::atomic_ref< size_t, cuda::thread_scope_device > &buffer_idx, int lane_id, e_op_result_t e_op_result)

template<bool hypersparse, typename GraphViewType, typename KeyIterator, typename EdgePartitionSrcValueInputWrapper, typename EdgePartitionDstValueInputWrapper, typename EdgePartitionEdgeValueInputWrapper, typename EdgePartitionEdgeMaskWrapper, typename BufferKeyOutputIterator, typename BufferValueOutputIterator, typename EdgeOp> static __global__ void extract_transform_v_frontier_e_hypersparse_or_low_degree (edge_partition_device_view_t< typename GraphViewType::vertex_type, typename GraphViewType::edge_type, GraphViewType::is_multi_gpu > edge_partition, KeyIterator key_first, KeyIterator key_last, EdgePartitionSrcValueInputWrapper edge_partition_src_value_input, EdgePartitionDstValueInputWrapper edge_partition_dst_value_input, EdgePartitionEdgeValueInputWrapper edge_partition_e_value_input, thrust::optional< EdgePartitionEdgeMaskWrapper > edge_partition_e_mask, BufferKeyOutputIterator buffer_key_output_first, BufferValueOutputIterator buffer_value_output_first, size_t *buffer_idx_ptr, EdgeOp e_op)

template<typename GraphViewType, typename KeyIterator, typename EdgePartitionSrcValueInputWrapper, typename EdgePartitionDstValueInputWrapper, typename EdgePartitionEdgeValueInputWrapper, typename EdgePartitionEdgeMaskWrapper, typename BufferKeyOutputIterator, typename BufferValueOutputIterator, typename EdgeOp> static __global__ void extract_transform_v_frontier_e_mid_degree (edge_partition_device_view_t< typename GraphViewType::vertex_type, typename GraphViewType::edge_type, GraphViewType::is_multi_gpu > edge_partition, KeyIterator key_first, KeyIterator key_last, EdgePartitionSrcValueInputWrapper edge_partition_src_value_input, EdgePartitionDstValueInputWrapper edge_partition_dst_value_input, EdgePartitionEdgeValueInputWrapper edge_partition_e_value_input, thrust::optional< EdgePartitionEdgeMaskWrapper > edge_partition_e_mask, BufferKeyOutputIterator buffer_key_output_first, BufferValueOutputIterator buffer_value_output_first, size_t *buffer_idx_ptr, EdgeOp e_op)

template<typename GraphViewType, typename KeyIterator, typename EdgePartitionSrcValueInputWrapper, typename EdgePartitionDstValueInputWrapper, typename EdgePartitionEdgeValueInputWrapper, typename EdgePartitionEdgeMaskWrapper, typename BufferKeyOutputIterator, typename BufferValueOutputIterator, typename EdgeOp> static __global__ void extract_transform_v_frontier_e_high_degree (edge_partition_device_view_t< typename GraphViewType::vertex_type, typename GraphViewType::edge_type, GraphViewType::is_multi_gpu > edge_partition, KeyIterator key_first, raft::device_span< size_t const > key_local_degree_offsets, EdgePartitionSrcValueInputWrapper edge_partition_src_value_input, EdgePartitionDstValueInputWrapper edge_partition_dst_value_input, EdgePartitionEdgeValueInputWrapper edge_partition_e_value_input, thrust::optional< EdgePartitionEdgeMaskWrapper > edge_partition_e_mask, BufferKeyOutputIterator buffer_key_output_first, BufferValueOutputIterator buffer_value_output_first, size_t *buffer_idx_ptr, EdgeOp e_op)

template<typename GraphViewType, typename InputKeyIterator, typename EdgePartitionSrcValueInputWrapper, typename EdgePartitionDstValueInputWrapper, typename EdgePartitionValueInputWrapper, typename EdgePartitionEdgeMaskWrapper, typename OptionalOutputKeyIterator, typename OptionalOutputValueIterator, typename EdgeOp> void extract_transform_v_frontier_e_edge_partition(raft::handle_t const &handle, edge_partition_device_view_t<typename GraphViewType::vertex_type, typename GraphViewType::edge_type, GraphViewType::is_multi_gpu> edge_partition, InputKeyIterator edge_partition_frontier_key_first, InputKeyIterator edge_partition_frontier_key_last, EdgePartitionSrcValueInputWrapper edge_partition_src_value_input, EdgePartitionDstValueInputWrapper edge_partition_dst_value_input, EdgePartitionValueInputWrapper edge_partition_e_value_input, thrust::optional<EdgePartitionEdgeMaskWrapper> edge_partition_e_mask, OptionalOutputKeyIterator output_key_first, OptionalOutputValueIterator output_value_first, raft::device_span<size_t> count, EdgeOp e_op, std::optional<raft::device_span<size_t const>> high_segment_key_local_degree_offsets, std::optional<size_t> high_segment_edge_count, std::optional<raft::host_span<size_t const>> key_segment_offsets, std::optional<raft::host_span<size_t const>> const &edge_partition_stream_pool_indices)#

template<bool incoming, typename OutputKeyT, typename OutputValueT, typename GraphViewType, typename KeyBucketType, typename EdgeSrcValueInputWrapper, typename EdgeDstValueInputWrapper, typename EdgeValueInputWrapper, typename EdgeOp> std::tuple<optional_dataframe_buffer_type_t<OutputKeyT>, optional_dataframe_buffer_type_t<OutputValueT>> extract_transform_v_frontier_e(raft::handle_t const &handle, GraphViewType const &graph_view, KeyBucketType const &frontier, EdgeSrcValueInputWrapper edge_src_value_input, EdgeDstValueInputWrapper edge_dst_value_input, EdgeValueInputWrapper edge_value_input, EdgeOp e_op, bool do_expensive_check = false)#

inline std::vector<size_t> init_stream_pool_indices(size_t max_tmp_buffer_size, size_t approx_tmp_buffer_size_per_loop, size_t loop_count, size_t num_streams_per_loop, size_t max_streams)#

template<typename InputIterator, typename FlagIterator, typename OutputIterator> void copy_if_nosync(InputIterator input_first, InputIterator input_last, FlagIterator flag_first, OutputIterator output_first, raft::device_span<size_t> count, rmm::cuda_stream_view stream_view)#

template<typename InputIterator> void count_nosync(InputIterator input_first, InputIterator input_last, raft::device_span<size_t> count, typename thrust::iterator_traits<InputIterator>::value_type value, rmm::cuda_stream_view stream_view)#

template<typename InputIterator> void sum_nosync(InputIterator input_first, InputIterator input_last, raft::device_span<typename thrust::iterator_traits<InputIterator>::value_type> sum, rmm::cuda_stream_view stream_view)#

template<bool check_edge_mask, typename InputKeyIterator0, typename InputKeyIterator1, typename InputValueIterator0, typename InputValueIterator1, typename MaskIterator, typename OutputKeyIterator, typename OutputValueIterator0, typename OutputValueIterator1, typename edge_t> __device__ edge_t set_intersection_by_key_with_mask (InputKeyIterator0 input_key_first0, InputKeyIterator1 input_key_first1, InputValueIterator0 input_value_first0, InputValueIterator1 input_value_first1, MaskIterator mask_first, OutputKeyIterator output_key_first, OutputValueIterator0 output_value_first0, OutputValueIterator1 output_value_first1, edge_t input_start_offset0, edge_t input_size0, bool apply_mask0, edge_t input_start_offset1, edge_t input_size1, bool apply_mask1, size_t output_start_offset)

template<typename GraphViewType, typename VertexPairIterator, typename EdgeValueInputIterator> std::conditional_t<!std::is_same_v<typename EdgeValueInputIterator::value_type, thrust::nullopt_t>, std::tuple<rmm::device_uvector<size_t>, rmm::device_uvector<typename GraphViewType::vertex_type>, rmm::device_uvector<typename EdgeValueInputIterator::value_type>, rmm::device_uvector<typename EdgeValueInputIterator::value_type>>, std::tuple<rmm::device_uvector<size_t>, rmm::device_uvector<typename GraphViewType::vertex_type>>> nbr_intersection(raft::handle_t const &handle, GraphViewType const &graph_view, EdgeValueInputIterator edge_value_input, VertexPairIterator vertex_pair_first, VertexPairIterator vertex_pair_last, std::array<bool, 2> intersect_dst_nbr, bool do_expensive_check = false)#

template<typename T> auto allocate_optional_dataframe_buffer(size_t size, rmm::cuda_stream_view stream)#

template<typename T> auto get_optional_dataframe_buffer_begin(optional_dataframe_buffer_type_t<T> &optional_dataframe_buffer)#

template<typename T> auto get_optional_dataframe_buffer_end(optional_dataframe_buffer_type_t<T> &optional_dataframe_buffer)#

template<typename T> auto get_optional_dataframe_buffer_cbegin(optional_dataframe_buffer_type_t<T> const &optional_dataframe_buffer)#

template<typename T> auto get_optional_dataframe_buffer_cend(optional_dataframe_buffer_type_t<T> const &optional_dataframe_buffer)#

template<typename T> void reserve_optional_dataframe_buffer(optional_dataframe_buffer_type_t<T> &optional_dataframe_buffer, size_t new_buffer_capacity, rmm::cuda_stream_view stream_view)#

template<typename T> void resize_optional_dataframe_buffer(optional_dataframe_buffer_type_t<T> &optional_dataframe_buffer, size_t new_buffer_size, rmm::cuda_stream_view stream_view)#

template<typename T> void shrink_to_fit_optional_dataframe_buffer(optional_dataframe_buffer_type_t<T> &optional_dataframe_buffer, rmm::cuda_stream_view stream_view)#

template<typename T> size_t size_optional_dataframe_buffer(optional_dataframe_buffer_type_t<T> &optional_dataframe_buffer)#

template<typename ValueIterator> std::tuple<rmm::device_uvector<size_t>, std::vector<size_t>> partition_v_frontier(raft::handle_t const &handle, ValueIterator frontier_value_first, ValueIterator frontier_value_last, std::vector<typename thrust::iterator_traits<ValueIterator>::value_type> const &thresholds)#

template<typename GraphViewType, typename key_t, typename EdgePartitionSrcValueInputWrapper, typename EdgePartitionDstValueInputWrapper, typename EdgePartitionEdgeValueInputWrapper, typename PredOp> __device__ auto init_pred_op(edge_partition_device_view_t<typename GraphViewType::vertex_type, typename GraphViewType::edge_type, GraphViewType::is_multi_gpu> const &edge_partition, EdgePartitionSrcValueInputWrapper const &edge_partition_src_value_input, EdgePartitionDstValueInputWrapper const &edge_partition_dst_value_input, EdgePartitionEdgeValueInputWrapper const &edge_partition_e_value_input, PredOp const &pred_op, key_t key, typename GraphViewType::vertex_type major_offset, typename GraphViewType::vertex_type const *indices, typename GraphViewType::edge_type edge_offset)#

template<bool update_major, typename vertex_t, typename edge_t, bool multi_gpu, typename result_t, typename TransformOp, typename ReduceOp, typename PredOp, typename ResultValueOutputIteratorOrWrapper> __device__ void update_result_value_output (edge_partition_device_view_t< vertex_t, edge_t, multi_gpu > const &edge_partition, vertex_t const *indices, edge_t local_degree, TransformOp const &transform_op, result_t init, ReduceOp const &reduce_op, PredOp const &pred_op, size_t output_idx, ResultValueOutputIteratorOrWrapper &result_value_output)

template<bool update_major, typename GraphViewType, typename OptionalKeyIterator, typename EdgePartitionSrcValueInputWrapper, typename EdgePartitionDstValueInputWrapper, typename EdgePartitionEdgeValueInputWrapper, typename EdgePartitionEdgeMaskWrapper, typename ResultValueOutputIteratorOrWrapper, typename EdgeOp, typename ReduceOp, typename PredOp, typename T> static __global__ void per_v_transform_reduce_e_hypersparse (edge_partition_device_view_t< typename GraphViewType::vertex_type, typename GraphViewType::edge_type, GraphViewType::is_multi_gpu > edge_partition, OptionalKeyIterator key_first, OptionalKeyIterator key_last, EdgePartitionSrcValueInputWrapper edge_partition_src_value_input, EdgePartitionDstValueInputWrapper edge_partition_dst_value_input, EdgePartitionEdgeValueInputWrapper edge_partition_e_value_input, thrust::optional< EdgePartitionEdgeMaskWrapper > edge_partition_e_mask, ResultValueOutputIteratorOrWrapper result_value_output, EdgeOp e_op, T init, ReduceOp reduce_op, PredOp pred_op)

template<bool update_major, typename GraphViewType, typename KeyIterator, typename EdgePartitionSrcValueInputWrapper, typename EdgePartitionDstValueInputWrapper, typename EdgePartitionEdgeValueInputWrapper, typename EdgePartitionEdgeMaskWrapper, typename ResultValueOutputIteratorOrWrapper, typename EdgeOp, typename ReduceOp, typename PredOp, typename T> static __global__ void per_v_transform_reduce_e_low_degree (edge_partition_device_view_t< typename GraphViewType::vertex_type, typename GraphViewType::edge_type, GraphViewType::is_multi_gpu > edge_partition, KeyIterator key_first, KeyIterator key_last, EdgePartitionSrcValueInputWrapper edge_partition_src_value_input, EdgePartitionDstValueInputWrapper edge_partition_dst_value_input, EdgePartitionEdgeValueInputWrapper edge_partition_e_value_input, thrust::optional< EdgePartitionEdgeMaskWrapper > edge_partition_e_mask, ResultValueOutputIteratorOrWrapper result_value_output, EdgeOp e_op, T init, ReduceOp reduce_op, PredOp pred_op)

template<bool update_major, typename GraphViewType, typename KeyIterator, typename EdgePartitionSrcValueInputWrapper, typename EdgePartitionDstValueInputWrapper, typename EdgePartitionEdgeValueInputWrapper, typename EdgePartitionEdgeMaskWrapper, typename ResultValueOutputIteratorOrWrapper, typename EdgeOp, typename ReduceOp, typename PredOp, typename T> static __global__ void per_v_transform_reduce_e_mid_degree (edge_partition_device_view_t< typename GraphViewType::vertex_type, typename GraphViewType::edge_type, GraphViewType::is_multi_gpu > edge_partition, KeyIterator key_first, KeyIterator key_last, EdgePartitionSrcValueInputWrapper edge_partition_src_value_input, EdgePartitionDstValueInputWrapper edge_partition_dst_value_input, EdgePartitionEdgeValueInputWrapper edge_partition_e_value_input, thrust::optional< EdgePartitionEdgeMaskWrapper > edge_partition_e_mask, ResultValueOutputIteratorOrWrapper result_value_output, EdgeOp e_op, T init, T identity_element, ReduceOp reduce_op, PredOp pred_op)

template<bool update_major, typename GraphViewType, typename KeyIterator, typename EdgePartitionSrcValueInputWrapper, typename EdgePartitionDstValueInputWrapper, typename EdgePartitionEdgeValueInputWrapper, typename EdgePartitionEdgeMaskWrapper, typename ResultValueOutputIteratorOrWrapper, typename EdgeOp, typename ReduceOp, typename PredOp, typename T> static __global__ void per_v_transform_reduce_e_high_degree (edge_partition_device_view_t< typename GraphViewType::vertex_type, typename GraphViewType::edge_type, GraphViewType::is_multi_gpu > edge_partition, KeyIterator key_first, KeyIterator key_last, EdgePartitionSrcValueInputWrapper edge_partition_src_value_input, EdgePartitionDstValueInputWrapper edge_partition_dst_value_input, EdgePartitionEdgeValueInputWrapper edge_partition_e_value_input, thrust::optional< EdgePartitionEdgeMaskWrapper > edge_partition_e_mask, ResultValueOutputIteratorOrWrapper result_value_output, EdgeOp e_op, T init, T identity_element, ReduceOp reduce_op, PredOp pred_op)

template<typename vertex_t, typename priority_t, typename ValueIterator> void compute_priorities(raft::comms::comms_t const &comm, ValueIterator value_first, raft::device_span<priority_t> priorities, std::optional<std::variant<raft::device_span<uint32_t const>, raft::device_span<size_t const>>> hypersparse_key_offsets, size_t contiguous_size, int root, int subgroup_size, typename thrust::iterator_traits<ValueIterator>::value_type init, bool ignore_local_values, rmm::cuda_stream_view stream_view)#

template<typename vertex_t, typename priority_t> std::variant<rmm::device_uvector<std::conditional_t<std::is_same_v<priority_t, uint32_t>, int, priority_t>>, std::optional<rmm::device_uvector<uint32_t>>> compute_selected_ranks_from_priorities(raft::comms::comms_t const &comm, raft::device_span<priority_t const> priorities, std::optional<std::variant<raft::device_span<uint32_t const>, raft::device_span<size_t const>>> hypersparse_key_offsets, size_t contiguous_size, int root, int subgroup_size, bool ignore_local_values, rmm::cuda_stream_view stream_view)#

template<bool update_major, typename GraphViewType, typename OptionalKeyIterator, typename EdgePartitionSrcValueInputWrapper, typename EdgePartitionDstValueInputWrapper, typename EdgePartitionValueInputWrapper, typename EdgePartitionEdgeMaskWrapper, typename ResultValueOutputIteratorOrWrapper, typename EdgeOp, typename ReduceOp, typename PredOp, typename T> void per_v_transform_reduce_e_edge_partition(raft::handle_t const &handle, edge_partition_device_view_t<typename GraphViewType::vertex_type, typename GraphViewType::edge_type, GraphViewType::is_multi_gpu> edge_partition, OptionalKeyIterator edge_partition_key_first, OptionalKeyIterator edge_partition_key_last, EdgePartitionSrcValueInputWrapper edge_partition_src_value_input, EdgePartitionDstValueInputWrapper edge_partition_dst_value_input, EdgePartitionValueInputWrapper edge_partition_e_value_input, thrust::optional<EdgePartitionEdgeMaskWrapper> edge_partition_e_mask, ResultValueOutputIteratorOrWrapper output_buffer, EdgeOp e_op, T major_init, T major_identity_element, ReduceOp reduce_op, PredOp pred_op, std::optional<raft::host_span<size_t const>> key_segment_offsets, std::optional<raft::host_span<size_t const>> const &edge_partition_stream_pool_indices)#

template<bool incoming, typename GraphViewType, typename OptionalKeyIterator, typename EdgeSrcValueInputWrapper, typename EdgeDstValueInputWrapper, typename EdgeValueInputWrapper, typename EdgeOp, typename ReduceOp, typename PredOp, typename T, typename VertexValueOutputIterator> void per_v_transform_reduce_e(raft::handle_t const &handle, GraphViewType const &graph_view, OptionalKeyIterator sorted_unique_key_first, OptionalKeyIterator sorted_unique_key_last, EdgeSrcValueInputWrapper edge_src_value_input, EdgeDstValueInputWrapper edge_dst_value_input, EdgeValueInputWrapper edge_value_input, EdgeOp e_op, T init, ReduceOp reduce_op, PredOp pred_op, VertexValueOutputIterator vertex_value_output_first)#

template<typename vertex_t, typename priority_t> __host__ __device__ priority_t rank_to_priority (int rank, int root, int subgroup_size, int comm_size, vertex_t offset)

template<typename vertex_t, typename priority_t> __host__ __device__ int priority_to_rank (priority_t priority, int root, int subgroup_size, int comm_size, vertex_t offset)

template<typename vertex_t, typename edge_t, bool multi_gpu> static __global__ void compute_valid_local_nbr_count_inclusive_sums_mid_local_degree (edge_partition_device_view_t< vertex_t, edge_t, multi_gpu > edge_partition, edge_partition_edge_property_device_view_t< edge_t, uint32_t const *, bool > edge_partition_e_mask, vertex_t const *edge_partition_frontier_major_first, raft::device_span< size_t const > inclusive_sum_offsets, raft::device_span< size_t const > frontier_indices, raft::device_span< edge_t > inclusive_sums)

template<typename vertex_t, typename edge_t, bool multi_gpu> static __global__ void compute_valid_local_nbr_count_inclusive_sums_high_local_degree (edge_partition_device_view_t< vertex_t, edge_t, multi_gpu > edge_partition, edge_partition_edge_property_device_view_t< edge_t, uint32_t const *, bool > edge_partition_e_mask, vertex_t const *edge_partition_frontier_major_first, raft::device_span< size_t const > inclusive_sum_offsets, raft::device_span< size_t const > frontier_indices, raft::device_span< edge_t > inclusive_sums)

template<typename KeyIterator> std::tuple<dataframe_buffer_type_t<typename thrust::iterator_traits<KeyIterator>::value_type>, rmm::device_uvector<size_t>, std::vector<size_t>, std::vector<size_t>> compute_unique_keys(raft::handle_t const &handle, KeyIterator aggregate_local_frontier_key_first, std::vector<size_t> const &local_frontier_displacements, std::vector<size_t> const &local_frontier_sizes)#

template<typename value_t> std::tuple<rmm::device_uvector<value_t>, rmm::device_uvector<value_t>> compute_frontier_value_sums_and_partitioned_local_value_sum_displacements(raft::handle_t const &handle, raft::device_span<value_t const> aggregate_local_frontier_local_value_sums, std::vector<size_t> const &local_frontier_displacements, std::vector<size_t> const &local_frontier_sizes)#

template<typename GraphViewType, typename VertexIterator> std::vector<std::tuple<rmm::device_uvector<size_t>, rmm::device_uvector<typename GraphViewType::edge_type>>> compute_valid_local_nbr_count_inclusive_sums(raft::handle_t const &handle, GraphViewType const &graph_view, VertexIterator aggregate_local_frontier_major_first, std::vector<size_t> const &local_frontier_displacements, std::vector<size_t> const &local_frontier_sizes)#

template<typename edge_t> rmm::device_uvector<edge_t> compute_uniform_sampling_index_without_replacement(raft::handle_t const &handle, rmm::device_uvector<edge_t> &&frontier_degrees, raft::random::RngState &rng_state, size_t K)#

template<typename edge_t, typename bias_t> void compute_biased_sampling_index_without_replacement(raft::handle_t const &handle, std::optional<raft::device_span<size_t const>> input_frontier_indices, raft::device_span<size_t const> input_degree_offsets, raft::device_span<bias_t const> input_biases, std::optional<raft::device_span<size_t const>> output_frontier_indices, raft::device_span<edge_t> output_nbr_indices, std::optional<raft::device_span<bias_t>> output_keys, raft::random::RngState &rng_state, size_t K, bool jump)#

template<typename GraphViewType, typename VertexIterator> rmm::device_uvector<typename GraphViewType::edge_type> compute_aggregate_local_frontier_local_degrees(raft::handle_t const &handle, GraphViewType const &graph_view, VertexIterator aggregate_local_frontier_major_first, std::vector<size_t> const &local_frontier_displacements, std::vector<size_t> const &local_frontier_sizes)#

template<typename GraphViewType, typename KeyIterator, typename EdgeSrcValueInputWrapper, typename EdgeDstValueInputWrapper, typename EdgeValueInputWrapper, typename EdgeBiasOp> std::tuple<rmm::device_uvector<typename edge_op_result_type<typename thrust::iterator_traits<KeyIterator>::value_type, typename GraphViewType::vertex_type, typename EdgeSrcValueInputWrapper::value_type, typename EdgeDstValueInputWrapper::value_type, typename EdgeValueInputWrapper::value_type, EdgeBiasOp>::type>, rmm::device_uvector<size_t>> compute_aggregate_local_frontier_biases(raft::handle_t const &handle, GraphViewType const &graph_view, KeyIterator aggregate_local_frontier_key_first, EdgeSrcValueInputWrapper edge_src_value_input, EdgeDstValueInputWrapper edge_dst_value_input, EdgeValueInputWrapper edge_value_input, EdgeBiasOp e_bias_op, std::vector<size_t> const &local_frontier_displacements, std::vector<size_t> const &local_frontier_sizes, bool do_expensive_check)#

template<typename value_t, bool multi_gpu> std::tuple<rmm::device_uvector<value_t>, std::optional<rmm::device_uvector<size_t>>, std::vector<size_t>> shuffle_and_compute_local_nbr_values(raft::handle_t const &handle, rmm::device_uvector<value_t> &&sample_nbr_values, std::optional<raft::device_span<value_t const>> frontier_partitioned_value_local_sum_displacements, size_t K, value_t invalid_value)#

template<typename GraphViewType, typename VertexIterator> rmm::device_uvector<typename GraphViewType::edge_type> convert_to_unmasked_local_nbr_idx(raft::handle_t const &handle, GraphViewType const &graph_view, VertexIterator aggregate_local_frontier_major_first, rmm::device_uvector<typename GraphViewType::edge_type> &&local_nbr_indices, std::optional<raft::device_span<size_t const>> key_indices, std::vector<size_t> const &local_frontier_sample_offsets, std::vector<size_t> const &local_frontier_displacements, std::vector<size_t> const &local_frontier_sizes, size_t K)#

template<typename GraphViewType, typename KeyIterator> std::tuple<rmm::device_uvector<typename GraphViewType::edge_type>, std::optional<rmm::device_uvector<size_t>>, std::vector<size_t>> uniform_sample_and_compute_local_nbr_indices(raft::handle_t const &handle, GraphViewType const &graph_view, KeyIterator aggregate_local_frontier_key_first, std::vector<size_t> const &local_frontier_displacements, std::vector<size_t> const &local_frontier_sizes, raft::random::RngState &rng_state, size_t K, bool with_replacement)#

template<typename GraphViewType, typename KeyIterator, typename EdgeSrcValueInputWrapper, typename EdgeDstValueInputWrapper, typename EdgeValueInputWrapper, typename EdgeBiasOp> std::tuple<rmm::device_uvector<typename GraphViewType::edge_type>, std::optional<rmm::device_uvector<size_t>>, std::vector<size_t>> biased_sample_and_compute_local_nbr_indices(raft::handle_t const &handle, GraphViewType const &graph_view, KeyIterator aggregate_local_frontier_key_first, EdgeSrcValueInputWrapper edge_src_value_input, EdgeDstValueInputWrapper edge_dst_value_input, EdgeValueInputWrapper edge_value_input, EdgeBiasOp e_bias_op, std::vector<size_t> const &local_frontier_displacements, std::vector<size_t> const &local_frontier_sizes, raft::random::RngState &rng_state, size_t K, bool with_replacement, bool do_expensive_check)#

template<typename key_t, typename GraphViewType, typename EdgePartitionSrcValueInputWrapper, typename EdgePartitionDstValueInputWrapper, typename EdgePartitionEdgeValueInputWrapper, typename EdgeOp, typename ValueIterator> __device__ void transform_v_frontier_e_update_buffer_element (edge_partition_device_view_t< typename GraphViewType::vertex_type, typename GraphViewType::edge_type, GraphViewType::is_multi_gpu > &edge_partition, key_t key, typename GraphViewType::vertex_type major_offset, typename GraphViewType::vertex_type minor, typename GraphViewType::edge_type edge_offset, EdgePartitionSrcValueInputWrapper edge_partition_src_value_input, EdgePartitionDstValueInputWrapper edge_partition_dst_value_input, EdgePartitionEdgeValueInputWrapper edge_partition_e_value_input, EdgeOp e_op, ValueIterator value_iter)

template<bool hypersparse, typename GraphViewType, typename KeyIterator, typename IndexIterator, typename EdgePartitionSrcValueInputWrapper, typename EdgePartitionDstValueInputWrapper, typename EdgePartitionEdgeValueInputWrapper, typename EdgePartitionEdgeMaskWrapper, typename EdgeOp, typename ValueIterator> static __global__ void transform_v_frontier_e_hypersparse_or_low_degree (edge_partition_device_view_t< typename GraphViewType::vertex_type, typename GraphViewType::edge_type, GraphViewType::is_multi_gpu > edge_partition, KeyIterator edge_partition_frontier_key_first, IndexIterator edge_partition_frontier_key_index_first, IndexIterator edge_partition_frontier_key_index_last, EdgePartitionSrcValueInputWrapper edge_partition_src_value_input, EdgePartitionDstValueInputWrapper edge_partition_dst_value_input, EdgePartitionEdgeValueInputWrapper edge_partition_e_value_input, EdgePartitionEdgeMaskWrapper edge_partition_e_mask, raft::device_span< size_t const > edge_partition_frontier_local_degree_offsets, EdgeOp e_op, ValueIterator value_first)

template<typename GraphViewType, typename KeyIterator, typename IndexIterator, typename EdgePartitionSrcValueInputWrapper, typename EdgePartitionDstValueInputWrapper, typename EdgePartitionEdgeValueInputWrapper, typename EdgePartitionEdgeMaskWrapper, typename EdgeOp, typename ValueIterator> static __global__ void transform_v_frontier_e_mid_degree (edge_partition_device_view_t< typename GraphViewType::vertex_type, typename GraphViewType::edge_type, GraphViewType::is_multi_gpu > edge_partition, KeyIterator edge_partition_frontier_key_first, IndexIterator edge_partition_frontier_key_index_first, IndexIterator edge_partition_frontier_key_index_last, EdgePartitionSrcValueInputWrapper edge_partition_src_value_input, EdgePartitionDstValueInputWrapper edge_partition_dst_value_input, EdgePartitionEdgeValueInputWrapper edge_partition_e_value_input, EdgePartitionEdgeMaskWrapper edge_partition_e_mask, raft::device_span< size_t const > edge_partition_frontier_local_degree_offsets, EdgeOp e_op, ValueIterator value_first)

template<typename GraphViewType, typename KeyIterator, typename IndexIterator, typename EdgePartitionSrcValueInputWrapper, typename EdgePartitionDstValueInputWrapper, typename EdgePartitionEdgeValueInputWrapper, typename EdgePartitionEdgeMaskWrapper, typename EdgeOp, typename ValueIterator> static __global__ void transform_v_frontier_e_high_degree (edge_partition_device_view_t< typename GraphViewType::vertex_type, typename GraphViewType::edge_type, GraphViewType::is_multi_gpu > edge_partition, KeyIterator edge_partition_frontier_key_first, IndexIterator edge_partition_frontier_key_index_first, IndexIterator edge_partition_frontier_key_index_last, EdgePartitionSrcValueInputWrapper edge_partition_src_value_input, EdgePartitionDstValueInputWrapper edge_partition_dst_value_input, EdgePartitionEdgeValueInputWrapper edge_partition_e_value_input, EdgePartitionEdgeMaskWrapper edge_partition_e_mask, raft::device_span< size_t const > edge_partition_frontier_local_degree_offsets, EdgeOp e_op, ValueIterator value_first)

template<typename GraphViewType, typename KeyIterator, typename EdgeSrcValueInputWrapper, typename EdgeDstValueInputWrapper, typename EdgeValueInputWrapper, typename EdgeOp> auto transform_v_frontier_e(raft::handle_t const &handle, GraphViewType const &graph_view, KeyIterator aggregate_local_frontier_key_first, EdgeSrcValueInputWrapper edge_src_value_input, EdgeDstValueInputWrapper edge_dst_value_input, EdgeValueInputWrapper edge_value_input, EdgeOp e_op, std::vector<size_t> const &local_frontier_displacements, std::vector<size_t> const &local_frontier_sizes)#

template<typename GraphViewType, typename EdgePropertyOutputWrapper, typename T> void fill_edge_property(raft::handle_t const &handle, GraphViewType const &graph_view, EdgePropertyOutputWrapper edge_property_output, T input)#

template<typename Iterator, typename T> __device__ std::enable_if_t< std::is_same_v< T, bool >, void > fill_thrust_tuple_element (Iterator iter, size_t offset, T value)

template<typename Iterator, typename T> __device__ std::enable_if_t<!std::is_same_v< T, bool >, void > fill_thrust_tuple_element (Iterator iter, size_t offset, T value)

template<typename Iterator, typename T, std::size_t... Is> __device__ void fill_thrust_tuple (Iterator iter, size_t offset, T value, std::index_sequence< Is... >)

template<typename Iterator, typename T> __device__ void fill_scalar_or_thrust_tuple (Iterator iter, size_t offset, T value)

template<typename GraphViewType, typename EdgeMajorPropertyOutputWrapper, typename T> void fill_edge_major_property(raft::handle_t const &handle, GraphViewType const &graph_view, EdgeMajorPropertyOutputWrapper edge_major_property_output, T input)#

template<typename GraphViewType, typename VertexIterator, typename EdgeMajorPropertyOutputWrapper, typename T> void fill_edge_major_property(raft::handle_t const &handle, GraphViewType const &graph_view, VertexIterator sorted_unique_vertex_first, VertexIterator sorted_unique_vertex_last, EdgeMajorPropertyOutputWrapper edge_major_property_output, T input)#

template<typename GraphViewType, typename EdgeMinorPropertyOutputWrapper, typename T> void fill_edge_minor_property(raft::handle_t const &handle, GraphViewType const &graph_view, EdgeMinorPropertyOutputWrapper edge_minor_property_output, T input)#

template<typename GraphViewType, typename VertexIterator, typename EdgeMinorPropertyOutputWrapper, typename T> void fill_edge_minor_property(raft::handle_t const &handle, GraphViewType const &graph_view, VertexIterator sorted_unique_vertex_first, VertexIterator sorted_unique_vertex_last, EdgeMinorPropertyOutputWrapper edge_minor_property_output, T input)#

template<bool incoming, typename GraphViewType, typename KeyBucketType, typename EdgeBiasSrcValueInputWrapper, typename EdgeBiasDstValueInputWrapper, typename EdgeBiasValueInputWrapper, typename EdgeBiasOp, typename EdgeSrcValueInputWrapper, typename EdgeDstValueInputWrapper, typename EdgeValueInputWrapper, typename EdgeOp, typename T> std::tuple<std::optional<rmm::device_uvector<size_t>>, decltype(allocate_dataframe_buffer<T>(size_t{0}, rmm::cuda_stream_view{}))> per_v_random_select_transform_e(raft::handle_t const &handle, GraphViewType const &graph_view, KeyBucketType const &key_list, EdgeBiasSrcValueInputWrapper edge_bias_src_value_input, EdgeBiasDstValueInputWrapper edge_bias_dst_value_input, EdgeBiasValueInputWrapper edge_bias_value_input, EdgeBiasOp e_bias_op, EdgeSrcValueInputWrapper edge_src_value_input, EdgeDstValueInputWrapper edge_dst_value_input, EdgeValueInputWrapper edge_value_input, EdgeOp e_op, raft::random::RngState &rng_state, size_t K, bool with_replacement, std::optional<T> invalid_value, bool do_expensive_check)#

template<bool check_edge_mask, typename GraphViewType, typename EdgePartitionSrcValueInputWrapper, typename EdgePartitionDstValueInputWrapper, typename EdgePartitionEdgeValueInputWrapper, typename EdgePartitionEdgeMaskWrapper, typename EdgePartitionEdgeValueOutputWrapper, typename EdgeOp> static __global__ void transform_e_packed_bool (edge_partition_device_view_t< typename GraphViewType::vertex_type, typename GraphViewType::edge_type, GraphViewType::is_multi_gpu > edge_partition, EdgePartitionSrcValueInputWrapper edge_partition_src_value_input, EdgePartitionDstValueInputWrapper edge_partition_dst_value_input, EdgePartitionEdgeValueInputWrapper edge_partition_e_value_input, EdgePartitionEdgeMaskWrapper edge_partition_e_mask, EdgePartitionEdgeValueOutputWrapper edge_partition_e_value_output, EdgeOp e_op)

template<typename vertex_t, typename ValueBuffer> std::tuple<rmm::device_uvector<vertex_t>, ValueBuffer> sort_and_reduce_by_vertices(raft::handle_t const &handle, rmm::device_uvector<vertex_t> &&vertices, ValueBuffer &&value_buffer)#

template<typename GraphViewType, typename EdgePartitionSrcValueInputWrapper, typename EdgePartitionDstValueInputWrapper, typename EdgePartitionEdgeValueInputWrapper, typename EdgePartitionEdgeMaskWrapper, typename ResultIterator, typename EdgeOp> static __global__ void transform_reduce_e_hypersparse (edge_partition_device_view_t< typename GraphViewType::vertex_type, typename GraphViewType::edge_type, GraphViewType::is_multi_gpu > edge_partition, EdgePartitionSrcValueInputWrapper edge_partition_src_value_input, EdgePartitionDstValueInputWrapper edge_partition_dst_value_input, EdgePartitionEdgeValueInputWrapper edge_partition_e_value_input, thrust::optional< EdgePartitionEdgeMaskWrapper > edge_partition_e_mask, ResultIterator result_iter, EdgeOp e_op)

template<typename GraphViewType, typename EdgePartitionSrcValueInputWrapper, typename EdgePartitionDstValueInputWrapper, typename EdgePartitionEdgeValueInputWrapper, typename EdgePartitionEdgeMaskWrapper, typename ResultIterator, typename EdgeOp> static __global__ void transform_reduce_e_low_degree (edge_partition_device_view_t< typename GraphViewType::vertex_type, typename GraphViewType::edge_type, GraphViewType::is_multi_gpu > edge_partition, typename GraphViewType::vertex_type major_range_first, typename GraphViewType::vertex_type major_range_last, EdgePartitionSrcValueInputWrapper edge_partition_src_value_input, EdgePartitionDstValueInputWrapper edge_partition_dst_value_input, EdgePartitionEdgeValueInputWrapper edge_partition_e_value_input, thrust::optional< EdgePartitionEdgeMaskWrapper > edge_partition_e_mask, ResultIterator result_iter, EdgeOp e_op)

template<typename GraphViewType, typename EdgePartitionSrcValueInputWrapper, typename EdgePartitionDstValueInputWrapper, typename EdgePartitionEdgeValueInputWrapper, typename EdgePartitionEdgeMaskWrapper, typename ResultIterator, typename EdgeOp> static __global__ void transform_reduce_e_mid_degree (edge_partition_device_view_t< typename GraphViewType::vertex_type, typename GraphViewType::edge_type, GraphViewType::is_multi_gpu > edge_partition, typename GraphViewType::vertex_type major_range_first, typename GraphViewType::vertex_type major_range_last, EdgePartitionSrcValueInputWrapper edge_partition_src_value_input, EdgePartitionDstValueInputWrapper edge_partition_dst_value_input, EdgePartitionEdgeValueInputWrapper edge_partition_e_value_input, thrust::optional< EdgePartitionEdgeMaskWrapper > edge_partition_e_mask, ResultIterator result_iter, EdgeOp e_op)

template<typename GraphViewType, typename EdgePartitionSrcValueInputWrapper, typename EdgePartitionDstValueInputWrapper, typename EdgePartitionEdgeValueInputWrapper, typename EdgePartitionEdgeMaskWrapper, typename ResultIterator, typename EdgeOp> static __global__ void transform_reduce_e_high_degree (edge_partition_device_view_t< typename GraphViewType::vertex_type, typename GraphViewType::edge_type, GraphViewType::is_multi_gpu > edge_partition, typename GraphViewType::vertex_type major_range_first, typename GraphViewType::vertex_type major_range_last, EdgePartitionSrcValueInputWrapper edge_partition_src_value_input, EdgePartitionDstValueInputWrapper edge_partition_dst_value_input, EdgePartitionEdgeValueInputWrapper edge_partition_e_value_input, thrust::optional< EdgePartitionEdgeMaskWrapper > edge_partition_e_mask, ResultIterator result_iter, EdgeOp e_op)

template<bool edge_partition_src_key, typename GraphViewType, typename EdgePartitionSrcValueInputWrapper, typename EdgePartitionDstValueInputWrapper, typename EdgePartitionEdgeValueInputWrapper, typename EdgePartitionSrcDstKeyInputWrapper, typename EdgeOp, typename ValueIterator> __device__ void transform_reduce_e_by_src_dst_key_update_buffer_element (edge_partition_device_view_t< typename GraphViewType::vertex_type, typename GraphViewType::edge_type, GraphViewType::is_multi_gpu > &edge_partition, typename GraphViewType::vertex_type major, typename GraphViewType::vertex_type minor, typename GraphViewType::edge_type edge_offset, EdgePartitionSrcValueInputWrapper edge_partition_src_value_input, EdgePartitionDstValueInputWrapper edge_partition_dst_value_input, EdgePartitionEdgeValueInputWrapper edge_partition_e_value_input, EdgePartitionSrcDstKeyInputWrapper edge_partition_src_dst_key_input, EdgeOp e_op, typename GraphViewType::vertex_type *key, ValueIterator value)

template<bool edge_partition_src_key, typename GraphViewType, typename EdgePartitionSrcValueInputWrapper, typename EdgePartitionDstValueInputWrapper, typename EdgePartitionEdgeValueInputWrapper, typename EdgePartitionSrcDstKeyInputWrapper, typename EdgePartitionEdgeMaskWrapper, typename EdgeOp, typename ValueIterator> static __global__ void transform_reduce_by_src_dst_key_hypersparse (edge_partition_device_view_t< typename GraphViewType::vertex_type, typename GraphViewType::edge_type, GraphViewType::is_multi_gpu > edge_partition, EdgePartitionSrcValueInputWrapper edge_partition_src_value_input, EdgePartitionDstValueInputWrapper edge_partition_dst_value_input, EdgePartitionEdgeValueInputWrapper edge_partition_e_value_input, EdgePartitionSrcDstKeyInputWrapper edge_partition_src_dst_key_input, EdgePartitionEdgeMaskWrapper edge_partition_e_mask, thrust::optional< raft::device_span< typename GraphViewType::edge_type const > > edge_offsets_with_mask, EdgeOp e_op, typename GraphViewType::vertex_type *keys, ValueIterator value_iter)

template<bool edge_partition_src_key, typename GraphViewType, typename EdgePartitionSrcValueInputWrapper, typename EdgePartitionDstValueInputWrapper, typename EdgePartitionEdgeValueInputWrapper, typename EdgePartitionSrcDstKeyInputWrapper, typename EdgePartitionEdgeMaskWrapper, typename EdgeOp, typename ValueIterator> static __global__ void transform_reduce_by_src_dst_key_low_degree (edge_partition_device_view_t< typename GraphViewType::vertex_type, typename GraphViewType::edge_type, GraphViewType::is_multi_gpu > edge_partition, typename GraphViewType::vertex_type major_range_first, typename GraphViewType::vertex_type major_range_last, EdgePartitionSrcValueInputWrapper edge_partition_src_value_input, EdgePartitionDstValueInputWrapper edge_partition_dst_value_input, EdgePartitionEdgeValueInputWrapper edge_partition_e_value_input, EdgePartitionSrcDstKeyInputWrapper edge_partition_src_dst_key_input, EdgePartitionEdgeMaskWrapper edge_partition_e_mask, thrust::optional< raft::device_span< typename GraphViewType::edge_type const > > edge_offsets_with_mask, EdgeOp e_op, typename GraphViewType::vertex_type *keys, ValueIterator value_iter)

template<bool edge_partition_src_key, typename GraphViewType, typename EdgePartitionSrcValueInputWrapper, typename EdgePartitionDstValueInputWrapper, typename EdgePartitionEdgeValueInputWrapper, typename EdgePartitionSrcDstKeyInputWrapper, typename EdgePartitionEdgeMaskWrapper, typename EdgeOp, typename ValueIterator> static __global__ void transform_reduce_by_src_dst_key_mid_degree (edge_partition_device_view_t< typename GraphViewType::vertex_type, typename GraphViewType::edge_type, GraphViewType::is_multi_gpu > edge_partition, typename GraphViewType::vertex_type major_range_first, typename GraphViewType::vertex_type major_range_last, EdgePartitionSrcValueInputWrapper edge_partition_src_value_input, EdgePartitionDstValueInputWrapper edge_partition_dst_value_input, EdgePartitionEdgeValueInputWrapper edge_partition_e_value_input, EdgePartitionSrcDstKeyInputWrapper edge_partition_src_dst_key_input, EdgePartitionEdgeMaskWrapper edge_partition_e_mask, thrust::optional< raft::device_span< typename GraphViewType::edge_type const > > edge_offsets_with_mask, EdgeOp e_op, typename GraphViewType::vertex_type *keys, ValueIterator value_iter)

template<bool edge_partition_src_key, typename GraphViewType, typename EdgePartitionSrcValueInputWrapper, typename EdgePartitionDstValueInputWrapper, typename EdgePartitionEdgeValueInputWrapper, typename EdgePartitionSrcDstKeyInputWrapper, typename EdgePartitionEdgeMaskWrapper, typename EdgeOp, typename ValueIterator> static __global__ void transform_reduce_by_src_dst_key_high_degree (edge_partition_device_view_t< typename GraphViewType::vertex_type, typename GraphViewType::edge_type, GraphViewType::is_multi_gpu > edge_partition, typename GraphViewType::vertex_type major_range_first, typename GraphViewType::vertex_type major_range_last, EdgePartitionSrcValueInputWrapper edge_partition_src_value_input, EdgePartitionDstValueInputWrapper edge_partition_dst_value_input, EdgePartitionEdgeValueInputWrapper edge_partition_e_value_input, EdgePartitionSrcDstKeyInputWrapper edge_partition_src_dst_key_input, EdgePartitionEdgeMaskWrapper edge_partition_e_mask, thrust::optional< raft::device_span< typename GraphViewType::edge_type const > > edge_offsets_with_mask, EdgeOp e_op, typename GraphViewType::vertex_type *keys, ValueIterator value_iter)

template<typename vertex_t, typename value_t, typename BufferType, typename ReduceOp> std::tuple<rmm::device_uvector<vertex_t>, BufferType> reduce_to_unique_kv_pairs(rmm::device_uvector<vertex_t> &&keys, BufferType &&value_buffer, ReduceOp reduce_op, cudaStream_t stream)#

template<bool edge_src_key, typename GraphViewType, typename EdgeSrcValueInputWrapper, typename EdgeDstValueInputWrapper, typename EdgeValueInputWrapper, typename EdgeSrcDstKeyInputWrapper, typename EdgeOp, typename ReduceOp, typename T> std::tuple<rmm::device_uvector<typename GraphViewType::vertex_type>, decltype(allocate_dataframe_buffer<T>(0, cudaStream_t{nullptr}))> transform_reduce_e_by_src_dst_key(raft::handle_t const &handle, GraphViewType const &graph_view, EdgeSrcValueInputWrapper edge_src_value_input, EdgeDstValueInputWrapper edge_dst_value_input, EdgeValueInputWrapper edge_value_input, EdgeSrcDstKeyInputWrapper edge_src_dst_key_input, EdgeOp e_op, T init, ReduceOp reduce_op)#

template<typename priority_t, typename vertex_t, typename payload_t> std::tuple<rmm::device_uvector<vertex_t>, optional_dataframe_buffer_type_t<payload_t>> filter_buffer_elements(raft::handle_t const &handle, rmm::device_uvector<vertex_t> &&unique_v_buffer, optional_dataframe_buffer_type_t<payload_t> &&payload_buffer, raft::device_span<vertex_t const> vertex_partition_range_offsets, vertex_t allreduce_count_per_rank, int subgroup_size)#

template<typename input_key_t, typename key_t, typename payload_t, typename ReduceOp> std::tuple<dataframe_buffer_type_t<key_t>, optional_dataframe_buffer_type_t<payload_t>> sort_and_reduce_buffer_elements(raft::handle_t const &handle, dataframe_buffer_type_t<input_key_t> &&key_buffer, optional_dataframe_buffer_type_t<payload_t> &&payload_buffer, ReduceOp reduce_op, std::conditional_t<std::is_integral_v<key_t>, std::tuple<key_t, key_t>, std::byte> vertex_range, std::optional<input_key_t> invalid_key)#

decltype(allocate_dataframe_buffer<typename KeyBucketType::key_type>(0, rmm::cuda_stream_view{})) transform_reduce_v_frontier_outgoing_e_by_dst(raft::handle_t const &handle, GraphViewType const &graph_view, KeyBucketType const &frontier, EdgeSrcValueInputWrapper edge_src_value_input, EdgeDstValueInputWrapper edge_dst_value_input, EdgeValueInputWrapper edge_value_input, EdgeOp e_op, ReduceOp reduce_op, bool do_expensive_check = false)#

template<typename BoolInputIterator, typename PackedBoolOutputIterator> void pack_bools(raft::handle_t const &handle, BoolInputIterator input_first, BoolInputIterator input_last, PackedBoolOutputIterator output_first)#

template<typename BoolInputIterator, typename PackedBoolOutputIterator> void pack_unaligned_bools(raft::handle_t const &handle, BoolInputIterator input_first, BoolInputIterator input_last, PackedBoolOutputIterator output_first, size_t intraword_start_offset)#

template<typename GraphViewType, typename VertexPropertyInputIterator, typename EdgeMajorPropertyOutputWrapper> void update_edge_major_property(raft::handle_t const &handle, GraphViewType const &graph_view, VertexPropertyInputIterator vertex_property_input_first, EdgeMajorPropertyOutputWrapper edge_major_property_output)#

template<typename GraphViewType, typename VertexIterator, typename VertexPropertyInputIterator, typename EdgeMajorPropertyOutputWrapper> void update_edge_major_property(raft::handle_t const &handle, GraphViewType const &graph_view, VertexIterator sorted_unique_vertex_first, VertexIterator sorted_unique_vertex_last, VertexPropertyInputIterator vertex_property_input_first, EdgeMajorPropertyOutputWrapper edge_major_property_output)#

template<typename GraphViewType, typename VertexPropertyInputIterator, typename EdgeMinorPropertyOutputWrapper> void update_edge_minor_property(raft::handle_t const &handle, GraphViewType const &graph_view, VertexPropertyInputIterator vertex_property_input_first, EdgeMinorPropertyOutputWrapper edge_minor_property_output)#

template<typename GraphViewType, typename VertexIterator, typename VertexPropertyInputIterator, typename EdgeMinorPropertyOutputWrapper> void update_edge_minor_property(raft::handle_t const &handle, GraphViewType const &graph_view, VertexIterator sorted_unique_vertex_first, VertexIterator sorted_unique_vertex_last, VertexPropertyInputIterator vertex_property_input_first, EdgeMinorPropertyOutputWrapper edge_minor_property_output)#

template<typename vertex_t, typename edge_t, typename bias_t, bool multi_gpu> std::tuple<size_t, size_t> check_edge_bias_values(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, false, multi_gpu> const &graph_view, edge_property_view_t<edge_t, bias_t const*> edge_bias_view)#

Check edge bias values.

Count the number of negative edge bias values & the number of vertices with the sum of their outgoing edge bias values exceeding std::numeric_limits<bias_t>::max().

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
bias_t – Type of edge bias values. Needs to be a floating point type.
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false)

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Graph View object to generate neighbor sampling on.
edge_weight_view – View object holding edge bias values for graph_view.

template std::tuple< size_t, size_t > check_edge_bias_values (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, edge_property_view_t< int32_t, float const * > edge_bias_view)

template std::tuple< size_t, size_t > check_edge_bias_values (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, edge_property_view_t< int32_t, double const * > edge_bias_view)

template std::tuple< size_t, size_t > check_edge_bias_values (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, edge_property_view_t< int64_t, float const * > edge_bias_view)

template std::tuple< size_t, size_t > check_edge_bias_values (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, edge_property_view_t< int64_t, double const * > edge_bias_view)

template std::tuple< size_t, size_t > check_edge_bias_values (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, edge_property_view_t< int32_t, float const * > edge_bias_view)

template std::tuple< size_t, size_t > check_edge_bias_values (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, edge_property_view_t< int32_t, double const * > edge_bias_view)

template std::tuple< size_t, size_t > check_edge_bias_values (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, edge_property_view_t< int64_t, float const * > edge_bias_view)

template std::tuple< size_t, size_t > check_edge_bias_values (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, edge_property_view_t< int64_t, double const * > edge_bias_view)

rmm::device_uvector<int32_t> convert_starting_vertex_label_offsets_to_labels(raft::handle_t const &handle, raft::device_span<size_t const> starting_vertex_label_offsets)#

Convert the starting vertex offsets into starting vertex labels.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
starting_vertex_label_offsets – Offsets array defining where each vertex label begins

Returns:

device vector containing labels for each starting vertex

template<typename label_t> rmm::device_uvector<int32_t> flatten_label_map(raft::handle_t const &handle, std::tuple<raft::device_span<label_t const>, raft::device_span<int32_t const>> label_to_output_comm_rank)#

Flatten the legacy label_to_output_comm_rank into the new structure.

Legacy structure supported arbitrary labels, the new structure is a dense mapping of labels from [0,n).

Template Parameters:

label_t – typename for the label

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
label_to_output_comm_rank – A tuple containing label ids and the comm rank each label should be assigned to

Returns:

device vector containing the mapping to comm_rank. Entry i will be the comm rank destination for label i.

template rmm::device_uvector< int32_t > flatten_label_map (raft::handle_t const &handle, std::tuple< raft::device_span< int32_t const >, raft::device_span< int32_t const > > label_to_output_comm_rank)

template<typename vertex_t, typename edge_t, typename weight_t, typename edge_type_t, typename label_t, typename tag_t, bool multi_gpu> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<weight_t>>, std::optional<rmm::device_uvector<edge_t>>, std::optional<rmm::device_uvector<edge_type_t>>, std::optional<rmm::device_uvector<label_t>>> gather_one_hop_edgelist(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, false, multi_gpu> const &graph_view, std::optional<edge_property_view_t<edge_t, weight_t const*>> edge_weight_view, std::optional<edge_property_view_t<edge_t, edge_t const*>> edge_id_view, std::optional<edge_property_view_t<edge_t, edge_type_t const*>> edge_type_view, cugraph::vertex_frontier_t<vertex_t, tag_t, multi_gpu, false> const &vertex_frontier, bool do_expensive_check)#

template<typename vertex_t, typename edge_t, typename weight_t, typename edge_type_t, typename label_t, bool multi_gpu> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<weight_t>>, std::optional<rmm::device_uvector<edge_t>>, std::optional<rmm::device_uvector<edge_type_t>>, std::optional<rmm::device_uvector<label_t>>> gather_one_hop_edgelist(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, false, multi_gpu> const &graph_view, std::optional<edge_property_view_t<edge_t, weight_t const*>> edge_weight_view, std::optional<edge_property_view_t<edge_t, edge_t const*>> edge_id_view, std::optional<edge_property_view_t<edge_t, edge_type_t const*>> edge_type_view, raft::device_span<vertex_t const> active_majors, std::optional<raft::device_span<label_t const>> active_major_labels, bool do_expensive_check = false)#

Gather edge list for specified vertices.

Collect all the edges that are present in the adjacency lists on the current gpu

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
weight_t – Type of edge weights. Needs to be a floating point type.
edge_type_t – Type of edge type. Needs to be an integral type.
label_t – Type of label. Needs to be an integral type.
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false)

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Graph View object to generate neighbor sampling on.
edge_weight_view – Optional view object holding edge weights for graph_view.
edge_id_view – Optional view object holding edge ids for graph_view.
edge_type_view – Optional view object holding edge types for graph_view.
active_majors – Device vector containing all the vertex id that are processed by gpus in the column communicator
active_major_labels – Optional device vector containing labels for each device vector

Returns:

A tuple of device vectors containing the majors, minors, optional weights, optional edge ids, optional edge types and optional label

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > > > gather_one_hop_edgelist (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_edge_type_view, raft::device_span< int32_t const > active_majors, std::optional< raft::device_span< int32_t const > > active_major_labels, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > > > gather_one_hop_edgelist (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_edge_type_view, raft::device_span< int32_t const > active_majors, std::optional< raft::device_span< int32_t const > > active_major_labels, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > > > gather_one_hop_edgelist (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_edge_type_view, raft::device_span< int64_t const > active_majors, std::optional< raft::device_span< int32_t const > > active_major_labels, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > > > gather_one_hop_edgelist (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_edge_type_view, raft::device_span< int64_t const > active_majors, std::optional< raft::device_span< int32_t const > > active_major_labels, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > > > gather_one_hop_edgelist (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_edge_type_view, raft::device_span< int32_t const > active_majors, std::optional< raft::device_span< int32_t const > > active_major_labels, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > > > gather_one_hop_edgelist (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_edge_type_view, raft::device_span< int32_t const > active_majors, std::optional< raft::device_span< int32_t const > > active_major_labels, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > > > gather_one_hop_edgelist (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_edge_type_view, raft::device_span< int64_t const > active_majors, std::optional< raft::device_span< int32_t const > > active_major_labels, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > > > gather_one_hop_edgelist (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_edge_type_view, raft::device_span< int64_t const > active_majors, std::optional< raft::device_span< int32_t const > > active_major_labels, bool do_expensive_check)

template<typename vertex_t, typename label_t, bool multi_gpu> std::tuple<rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<label_t>>, std::optional<std::tuple<rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<label_t>>>>> prepare_next_frontier(raft::handle_t const &handle, raft::device_span<vertex_t const> sampled_src_vertices, std::optional<raft::device_span<label_t const>> sampled_src_vertex_labels, raft::device_span<vertex_t const> sampled_dst_vertices, std::optional<raft::device_span<label_t const>> sampled_dst_vertex_labels, std::optional<std::tuple<rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<label_t>>>> &&vertex_used_as_source, vertex_partition_view_t<vertex_t, multi_gpu> vertex_partition, std::vector<vertex_t> const &vertex_partition_range_lasts, prior_sources_behavior_t prior_sources_behavior, bool dedupe_sources, bool do_expensive_check)#

Use the sampling results from hop N to populate the new frontier for hop N+1.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
label_t – Type of label. Needs to be an integral type.
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false)

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
sampled_src_vertices – The source vertices for the current sampling
sampled_src_vertex_labels – Optional labels for the vertices for the current sampling
sampled_dst_vertices – Vertices for the next frontier
sampled_dst_vertex_labels – Optional labels for the next frontier
vertex_used_as_source – Optional. If specified then we want to exclude vertices that were previously used as sources. These vertices (and optional labels) will be updated based on the contents of sampled_src_vertices/sampled_src_vertex_labels and the update will be part of the return value.
vertex_partition – Vertex partition view from the graph view
vertex_partition_range_lasts – End of range information from graph view
prior_sources_behavior – Identifies how to treat sources in each hop
dedupe_sources – boolean flag, if true then if a vertex v appears as a destination in hop X multiple times with the same label, it will only be passed once (for each label) as a source for the next hop. Default is false.
do_expensive_check – A flag to run expensive checks for input arguments (if set to true).

Returns:

A tuple of device vectors containing the vertices for the next frontier expansion and optional labels associated with the vertices, along with the updated value for vertex_used_as_sources

template std::tuple< rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< int32_t > >, std::optional< std::tuple< rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< int32_t > > > > > prepare_next_frontier (raft::handle_t const &handle, raft::device_span< int32_t const > sampled_src_vertices, std::optional< raft::device_span< int32_t const > > sampled_src_vertex_labels, raft::device_span< int32_t const > sampled_dst_vertices, std::optional< raft::device_span< int32_t const > > sampled_dst_vertex_labels, std::optional< std::tuple< rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< int32_t > > > > &&vertex_used_as_source, vertex_partition_view_t< int32_t, true > vertex_partition, std::vector< int32_t > const &vertex_partition_range_lasts, prior_sources_behavior_t prior_sources_behavior, bool dedupe_sources, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< int32_t > >, std::optional< std::tuple< rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< int32_t > > > > > prepare_next_frontier (raft::handle_t const &handle, raft::device_span< int64_t const > sampled_src_vertices, std::optional< raft::device_span< int32_t const > > sampled_src_vertex_labels, raft::device_span< int64_t const > sampled_dst_vertices, std::optional< raft::device_span< int32_t const > > sampled_dst_vertex_labels, std::optional< std::tuple< rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< int32_t > > > > &&vertex_used_as_source, vertex_partition_view_t< int64_t, true > vertex_partition, std::vector< int64_t > const &vertex_partition_range_lasts, prior_sources_behavior_t prior_sources_behavior, bool dedupe_sources, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< int32_t > >, std::optional< std::tuple< rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< int32_t > > > > > prepare_next_frontier (raft::handle_t const &handle, raft::device_span< int32_t const > sampled_src_vertices, std::optional< raft::device_span< int32_t const > > sampled_src_vertex_labels, raft::device_span< int32_t const > sampled_dst_vertices, std::optional< raft::device_span< int32_t const > > sampled_dst_vertex_labels, std::optional< std::tuple< rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< int32_t > > > > &&vertex_used_as_source, vertex_partition_view_t< int32_t, false > vertex_partition, std::vector< int32_t > const &vertex_partition_range_lasts, prior_sources_behavior_t prior_sources_behavior, bool dedupe_sources, bool do_expensive_check)

template std::tuple< rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< int32_t > >, std::optional< std::tuple< rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< int32_t > > > > > prepare_next_frontier (raft::handle_t const &handle, raft::device_span< int64_t const > sampled_src_vertices, std::optional< raft::device_span< int32_t const > > sampled_src_vertex_labels, raft::device_span< int64_t const > sampled_dst_vertices, std::optional< raft::device_span< int32_t const > > sampled_dst_vertex_labels, std::optional< std::tuple< rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< int32_t > > > > &&vertex_used_as_source, vertex_partition_view_t< int64_t, false > vertex_partition, std::vector< int64_t > const &vertex_partition_range_lasts, prior_sources_behavior_t prior_sources_behavior, bool dedupe_sources, bool do_expensive_check)

template<typename vertex_t, typename label_t> std::tuple<rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<label_t>>> remove_visited_vertices_from_frontier(raft::handle_t const &handle, rmm::device_uvector<vertex_t> &&frontier_vertices, std::optional<rmm::device_uvector<label_t>> &&frontier_vertex_labels, raft::device_span<vertex_t const> vertices_used_as_source, std::optional<raft::device_span<label_t const>> vertex_labels_used_as_source)#

Remove from the frontier any vertices that have already been used as a source.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
label_t – Type of label. Needs to be an integral type.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
frontier_vertices – Vertices discovered in the current hop
frontier_vertex_labels – Labels for the vertices discovered in the current hop
vertices_used_as_source – Device vector containing all vertices used in previous hops as a source
vertex_labels_used_as_source – Device vector containing vertex labels associated with the vertices_used_as_source used in previous hops as a source vertex label

Returns:

tuple containing the modified frontier_vertices and frontier_vertex_labels

template std::tuple< rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< int32_t > > > remove_visited_vertices_from_frontier (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&frontier_vertices, std::optional< rmm::device_uvector< int32_t > > &&frontier_vertex_labels, raft::device_span< int32_t const > vertices_used_as_source, std::optional< raft::device_span< int32_t const > > vertex_labels_used_as_source)

template std::tuple< rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< int32_t > > > remove_visited_vertices_from_frontier (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&frontier_vertices, std::optional< rmm::device_uvector< int32_t > > &&frontier_vertex_labels, raft::device_span< int64_t const > vertices_used_as_source, std::optional< raft::device_span< int32_t const > > vertex_labels_used_as_source)

template<typename vertex_t, typename edge_t, typename weight_t, typename edge_type_t, typename bias_t, typename label_t, bool multi_gpu> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<weight_t>>, std::optional<rmm::device_uvector<edge_t>>, std::optional<rmm::device_uvector<edge_type_t>>, std::optional<rmm::device_uvector<label_t>>> sample_edges(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, false, multi_gpu> const &graph_view, std::optional<edge_property_view_t<edge_t, weight_t const*>> edge_weight_view, std::optional<edge_property_view_t<edge_t, edge_t const*>> edge_id_view, std::optional<edge_property_view_t<edge_t, edge_type_t const*>> edge_type_view, std::optional<edge_property_view_t<edge_t, bias_t const*>> edge_bias_view, raft::random::RngState &rng_state, raft::device_span<vertex_t const> active_majors, std::optional<raft::device_span<label_t const>> active_major_labels, size_t fanout, bool with_replacement)#

Randomly sample edges from the adjacency list of specified vertices.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
weight_t – Type of edge weights. Needs to be a floating point type.
edge_type_t – Type of edge type. Needs to be an integral type.
label_t – Type of label. Needs to be an integral type.
multi_gpu – Flag indicating whether template instantiation should target single-GPU (false)

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph_view – Graph View object to generate neighbor sampling on.
edge_weight_view – Optional view object holding edge weights for graph_view.
edge_id_view – Optional view object holding edge ids for graph_view.
edge_type_view – Optional view object holding edge types for graph_view.
rng_state – Random number generator state
active_majors – Device vector containing all the vertex id that are processed by gpus in the column communicator
active_major_labels – Optional device vector containing labels for each device vector
fanout – How many edges to sample for each vertex
with_replacement – If true sample with replacement, otherwise sample without replacement
invalid_vertex_id – Value to use for an invalid vertex

Returns:

A tuple of device vectors containing the majors, minors, optional weights, optional edge ids, optional edge types and optional label

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > > > sample_edges (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_edge_type_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_bias_view, raft::random::RngState &rng_state, raft::device_span< int32_t const > active_majors, std::optional< raft::device_span< int32_t const > > active_major_labels, size_t fanout, bool with_replacement)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > > > sample_edges (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, true > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_edge_type_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_bias_view, raft::random::RngState &rng_state, raft::device_span< int32_t const > active_majors, std::optional< raft::device_span< int32_t const > > active_major_labels, size_t fanout, bool with_replacement)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > > > sample_edges (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_edge_type_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_bias_view, raft::random::RngState &rng_state, raft::device_span< int64_t const > active_majors, std::optional< raft::device_span< int32_t const > > active_major_labels, size_t fanout, bool with_replacement)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > > > sample_edges (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, true > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_edge_type_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_bias_view, raft::random::RngState &rng_state, raft::device_span< int64_t const > active_majors, std::optional< raft::device_span< int32_t const > > active_major_labels, size_t fanout, bool with_replacement)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > > > sample_edges (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_edge_type_view, std::optional< edge_property_view_t< int32_t, float const * > > edge_bias_view, raft::random::RngState &rng_state, raft::device_span< int32_t const > active_majors, std::optional< raft::device_span< int32_t const > > active_major_labels, size_t fanout, bool with_replacement)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > > > sample_edges (raft::handle_t const &handle, graph_view_t< int32_t, int32_t, false, false > const &graph_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_id_view, std::optional< edge_property_view_t< int32_t, int32_t const * > > edge_edge_type_view, std::optional< edge_property_view_t< int32_t, double const * > > edge_bias_view, raft::random::RngState &rng_state, raft::device_span< int32_t const > active_majors, std::optional< raft::device_span< int32_t const > > active_major_labels, size_t fanout, bool with_replacement)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > > > sample_edges (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_edge_type_view, std::optional< edge_property_view_t< int64_t, float const * > > edge_bias_view, raft::random::RngState &rng_state, raft::device_span< int64_t const > active_majors, std::optional< raft::device_span< int32_t const > > active_major_labels, size_t fanout, bool with_replacement)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > > > sample_edges (raft::handle_t const &handle, graph_view_t< int64_t, int64_t, false, false > const &graph_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_weight_view, std::optional< edge_property_view_t< int64_t, int64_t const * > > edge_id_view, std::optional< edge_property_view_t< int64_t, int32_t const * > > edge_edge_type_view, std::optional< edge_property_view_t< int64_t, double const * > > edge_bias_view, raft::random::RngState &rng_state, raft::device_span< int64_t const > active_majors, std::optional< raft::device_span< int32_t const > > active_major_labels, size_t fanout, bool with_replacement)

template<typename vertex_t, typename edge_t, typename weight_t, typename edge_type_t, typename label_t> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<weight_t>>, std::optional<rmm::device_uvector<edge_t>>, std::optional<rmm::device_uvector<edge_type_t>>, std::optional<rmm::device_uvector<int32_t>>, std::optional<rmm::device_uvector<label_t>>> shuffle_sampling_results(raft::handle_t const &handle, rmm::device_uvector<vertex_t> &&majors, rmm::device_uvector<vertex_t> &&minors, std::optional<rmm::device_uvector<weight_t>> &&weights, std::optional<rmm::device_uvector<edge_t>> &&edge_ids, std::optional<rmm::device_uvector<edge_type_t>> &&edge_types, std::optional<rmm::device_uvector<int32_t>> &&hops, std::optional<rmm::device_uvector<label_t>> &&labels, raft::device_span<int32_t const> label_to_output_gpu_mapping)#

Shuffle sampling results to the desired GPU based on label_to_output_gpu_mapping[label[i]].

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
weight_t – Type of edge weights. Needs to be a floating point type.
edge_type_t – Type of edge type. Needs to be an integral type.
label_t – Type of label. Needs to be an integral type.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
majors – Major vertices
minors – Minor vertices
weights – Optional edge weight
edge_ids – Optional edge id
edge_types – Optional edge type
hops – Optional indicator of which hop the edge was found in
labels – Label associated with the seed that resulted in this edge being part of the result
label_to_output_gpu_mapping – Mapping that identifies the GPU that is associated with the output label

Returns:

A tuple of device vectors containing the majors, minors, optional weights, optional edge ids, optional edge types, optional hops and optional labels after shuffling to the specified output GPU

template<typename vertex_t, typename edge_t, typename weight_t, typename edge_type_t, typename label_t> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<weight_t>>, std::optional<rmm::device_uvector<edge_t>>, std::optional<rmm::device_uvector<edge_type_t>>, std::optional<rmm::device_uvector<int32_t>>, std::optional<rmm::device_uvector<label_t>>, std::optional<rmm::device_uvector<size_t>>> shuffle_and_organize_output(raft::handle_t const &handle, rmm::device_uvector<vertex_t> &&majors, rmm::device_uvector<vertex_t> &&minors, std::optional<rmm::device_uvector<weight_t>> &&weights, std::optional<rmm::device_uvector<edge_t>> &&edge_ids, std::optional<rmm::device_uvector<edge_type_t>> &&edge_types, std::optional<rmm::device_uvector<int32_t>> &&hops, std::optional<rmm::device_uvector<label_t>> &&labels, std::optional<raft::device_span<int32_t const>> label_to_output_comm_rank)#

template<typename vertex_t, typename weight_t, typename edge_t, typename edge_type_t, typename label_t> void sort_sampled_tuples(raft::handle_t const &handle, rmm::device_uvector<vertex_t> &majors, rmm::device_uvector<vertex_t> &minors, std::optional<rmm::device_uvector<weight_t>> &weights, std::optional<rmm::device_uvector<edge_t>> &edge_ids, std::optional<rmm::device_uvector<edge_type_t>> &edge_types, std::optional<rmm::device_uvector<int32_t>> &hops, rmm::device_uvector<label_t> &labels)#

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > shuffle_and_organize_output (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&majors, rmm::device_uvector< int32_t > &&minors, std::optional< rmm::device_uvector< float > > &&weights, std::optional< rmm::device_uvector< int32_t > > &&edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edge_types, std::optional< rmm::device_uvector< int32_t > > &&hops, std::optional< rmm::device_uvector< int32_t > > &&labels, std::optional< raft::device_span< int32_t const > > label_to_output_comm_rank)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > shuffle_and_organize_output (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&majors, rmm::device_uvector< int32_t > &&minors, std::optional< rmm::device_uvector< double > > &&weights, std::optional< rmm::device_uvector< int32_t > > &&edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edge_types, std::optional< rmm::device_uvector< int32_t > > &&hops, std::optional< rmm::device_uvector< int32_t > > &&labels, std::optional< raft::device_span< int32_t const > > label_to_output_comm_rank)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > shuffle_and_organize_output (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&majors, rmm::device_uvector< int64_t > &&minors, std::optional< rmm::device_uvector< float > > &&weights, std::optional< rmm::device_uvector< int64_t > > &&edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edge_types, std::optional< rmm::device_uvector< int32_t > > &&hops, std::optional< rmm::device_uvector< int32_t > > &&labels, std::optional< raft::device_span< int32_t const > > label_to_output_comm_rank)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< size_t > > > shuffle_and_organize_output (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&majors, rmm::device_uvector< int64_t > &&minors, std::optional< rmm::device_uvector< double > > &&weights, std::optional< rmm::device_uvector< int64_t > > &&edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edge_types, std::optional< rmm::device_uvector< int32_t > > &&hops, std::optional< rmm::device_uvector< int32_t > > &&labels, std::optional< raft::device_span< int32_t const > > label_to_output_comm_rank)

template<typename vertex_t, typename edge_t, typename weight_t, bool store_transposed, bool multi_gpu> std::tuple<std::optional<rmm::device_uvector<weight_t>>, std::optional<rmm::device_uvector<weight_t>>> normalize_biases(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu> const &graph_view, raft::device_span<weight_t const> biases)#

template<typename vertex_t, typename edge_t, typename weight_t, bool store_transposed, bool multi_gpu> rmm::device_uvector<vertex_t> create_local_samples(raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu> const &graph_view, std::optional<rmm::device_uvector<weight_t>> const &normalized_biases, std::optional<rmm::device_uvector<weight_t>> const &gpu_biases, size_t samples_in_this_batch)#

template<typename vertex_t, typename edge_t, typename weight_t, typename edge_type_t, typename bias_t, typename label_t, bool store_transposed, bool multi_gpu> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<weight_t>>, std::optional<rmm::device_uvector<edge_t>>, std::optional<rmm::device_uvector<edge_type_t>>, std::optional<rmm::device_uvector<int32_t>>, std::optional<rmm::device_uvector<label_t>>, std::optional<rmm::device_uvector<size_t>>> neighbor_sample_impl(raft::handle_t const &handle, raft::random::RngState &rng_state, graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu> const &graph_view, std::optional<edge_property_view_t<edge_t, weight_t const*>> edge_weight_view, std::optional<edge_property_view_t<edge_t, edge_t const*>> edge_id_view, std::optional<edge_property_view_t<edge_t, edge_type_t const*>> edge_type_view, std::optional<edge_property_view_t<edge_t, bias_t const*>> edge_bias_view, raft::device_span<vertex_t const> starting_vertices, std::optional<raft::device_span<label_t const>> starting_vertex_labels, std::optional<raft::device_span<int32_t const>> label_to_output_comm_rank, raft::host_span<int32_t const> fan_out, edge_type_t num_edge_types, bool return_hops, bool with_replacement, prior_sources_behavior_t prior_sources_behavior, bool dedupe_sources, bool do_expensive_check)#

template<typename vertex_t, typename edge_t, typename weight_t, typename selector_t, typename traversal_t = original::horizontal_traversal_t, typename random_engine_t = rrandom_gen_t<vertex_t, edge_t>, typename seeding_policy_t = original::clock_seeding_t<typename random_engine_t::seed_type>, typename index_t = edge_t> std::tuple<original::device_vec_t<vertex_t>, original::device_vec_t<weight_t>, original::device_vec_t<index_t>, typename random_engine_t::seed_type> random_walks_impl(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, false, false> const &graph_view, std::optional<edge_property_view_t<edge_t, weight_t const*>> edge_weight_view, original::device_const_vector_view<vertex_t, index_t> &d_v_start, index_t max_depth, selector_t const &selector, bool use_padding = false, seeding_policy_t seeder = original::clock_seeding_t<typename random_engine_t::seed_type>{})#

returns random walks (RW) from starting sources, where each path is of given maximum length. Single-GPU specialization.

Template Parameters:

graph_t – Type of graph (view).
traversal_t – Traversal policy. Either horizontal (faster but requires more memory) or vertical. Defaults to horizontal.
random_engine_t – Type of random engine used to generate RW.
seeding_policy_t – Random engine seeding policy: variable or fixed (for reproducibility). Defaults to variable, clock dependent.
index_t – Indexing type. Defaults to edge_type.

Parameters:

handle – RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
graph – Graph object to generate RW on.
d_v_start – Device (view) set of starting vertex indices for the RW. number(paths) == d_v_start.size().
max_depth – maximum length of RWs.
use_padding – (optional) specifies if return uses padded format (true), or coalesced (compressed) format; when padding is used the output is a matrix of vertex paths and a matrix of edges paths (weights); in this case the matrices are stored in row major order; the vertex path matrix is padded with num_vertices values and the weight matrix is padded with 0 values;
seeder – (optional) is object providing the random seeding mechanism. Defaults to local clock time as initial seed.

Returns:

std::tuple<device_vec_t<vertex_t>, device_vec_t<weight_t>, device_vec_t<index_t>> Triplet of either padded or coalesced RW paths; in the coalesced case (default), the return consists of corresponding vertex and edge weights for each, and corresponding path sizes. This is meant to minimize the number of DF’s to be passed to the Python layer. The meaning of “coalesced” here is that a 2D array of paths of different sizes is represented as a 1D contiguous array. In the padded case the return is a matrix of num_paths x max_depth vertex paths; and num_paths x (max_depth-1) edge (weight) paths, with an empty array of sizes. Note: if the graph is un-weighted the edge (weight) paths consists of weight_t{1} entries;

template<typename vertex_t, typename edge_t, typename weight_t, bool multi_gpu, typename random_selector_t> std::tuple<rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<weight_t>>> random_walk_impl(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, false, multi_gpu> const &graph_view, std::optional<edge_property_view_t<edge_t, weight_t const*>> edge_weight_view, raft::device_span<vertex_t const> start_vertices, size_t max_length, random_selector_t random_selector)#

template<typename vertex_t, typename edge_t, typename weight_t, bool store_transposed, bool multi_gpu> std::enable_if_t<multi_gpu, std::tuple<graph_t<vertex_t, edge_t, store_transposed, multi_gpu>, std::optional<edge_property_t<graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu>, weight_t>>, std::optional<rmm::device_uvector<vertex_t>>>> coarsen_graph(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu> const &graph_view, std::optional<edge_property_view_t<edge_t, weight_t const*>> edge_weight_view, vertex_t const *labels, bool renumber, bool do_expensive_check)#

template<typename vertex_t, typename edge_t, typename weight_t, bool store_transposed, bool multi_gpu> std::enable_if_t<!multi_gpu, std::tuple<graph_t<vertex_t, edge_t, store_transposed, multi_gpu>, std::optional<edge_property_t<graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu>, weight_t>>, std::optional<rmm::device_uvector<vertex_t>>>> coarsen_graph(raft::handle_t const &handle, graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu> const &graph_view, std::optional<edge_property_view_t<edge_t, weight_t const*>> edge_weight_view, vertex_t const *labels, bool renumber, bool do_expensive_check)#

template<typename edge_t, typename VertexIterator> rmm::device_uvector<edge_t> compute_sparse_offsets(VertexIterator edgelist_major_first, VertexIterator edgelist_major_last, typename thrust::iterator_traits<VertexIterator>::value_type major_range_first, typename thrust::iterator_traits<VertexIterator>::value_type major_range_last, bool edgelist_major_sorted, rmm::cuda_stream_view stream_view)#

template<typename vertex_t, typename edge_t> std::tuple<rmm::device_uvector<edge_t>, rmm::device_uvector<vertex_t>> compress_hypersparse_offsets(rmm::device_uvector<edge_t> &&offsets, vertex_t major_range_first, vertex_t major_hypersparse_first, vertex_t major_range_last, rmm::cuda_stream_view stream_view)#

template<typename vertex_t, typename edge_t, typename edge_value_t, bool store_transposed> std::tuple< rmm::device_uvector< edge_t >, rmm::device_uvector< vertex_t >, decltype(allocate_dataframe_buffer< edge_value_t >(size_t{0}, rmm::cuda_stream_view{})), std::optional< rmm::device_uvector< vertex_t > > sort_and_compress_edgelist (rmm::device_uvector< vertex_t > &&edgelist_srcs, rmm::device_uvector< vertex_t > &&edgelist_dsts, decltype(allocate_dataframe_buffer< edge_value_t >(0, rmm::cuda_stream_view{}))&&edgelist_values, vertex_t major_range_first, std::optional< vertex_t > major_hypersparse_first, vertex_t major_range_last, vertex_t, vertex_t, size_t mem_frugal_threshold, rmm::cuda_stream_view stream_view)

template<typename vertex_t, typename edge_t, bool store_transposed> std::tuple<rmm::device_uvector<edge_t>, rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<vertex_t>>> sort_and_compress_edgelist(rmm::device_uvector<vertex_t> &&edgelist_srcs, rmm::device_uvector<vertex_t> &&edgelist_dsts, vertex_t major_range_first, std::optional<vertex_t> major_hypersparse_first, vertex_t major_range_last, vertex_t, vertex_t, size_t mem_frugal_threshold, rmm::cuda_stream_view stream_view)#

template<typename edge_t, typename VertexIterator, typename EdgeValueIterator> void sort_adjacency_list(raft::handle_t const &handle, raft::device_span<edge_t const> offsets, VertexIterator index_first, VertexIterator index_last, EdgeValueIterator edge_value_first)#

template<typename edge_t, typename VertexIterator> void sort_adjacency_list(raft::handle_t const &handle, raft::device_span<edge_t const> offsets, VertexIterator index_first, VertexIterator index_last)#

template<typename comparison_t> std::tuple<size_t, rmm::device_uvector<uint32_t>> mark_entries(raft::handle_t const &handle, size_t num_entries, comparison_t comparison)#

template<typename T> rmm::device_uvector<T> keep_flagged_elements(raft::handle_t const &handle, rmm::device_uvector<T> &&vector, raft::device_span<uint32_t const> keep_flags, size_t keep_count)#

template<typename vertex_t> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>> group_multi_edges(raft::handle_t const &handle, rmm::device_uvector<vertex_t> &&edgelist_srcs, rmm::device_uvector<vertex_t> &&edgelist_dsts, size_t mem_frugal_threshold)#

template<typename vertex_t, typename edge_value_t> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>, decltype(allocate_dataframe_buffer<edge_value_t>(size_t{0}, rmm::cuda_stream_view{}))> group_multi_edges(raft::handle_t const &handle, rmm::device_uvector<vertex_t> &&edgelist_srcs, rmm::device_uvector<vertex_t> &&edgelist_dsts, decltype(allocate_dataframe_buffer<edge_value_t>(0, rmm::cuda_stream_view{})) &&edgelist_values, size_t mem_frugal_threshold, bool keep_min_value_edge)#

template<typename vertex_t> std::optional<vertex_t> find_locally_unused_ext_vertex_id(raft::handle_t const &handle, raft::device_span<vertex_t const> sorted_local_vertices, bool multi_gpu)#

template<typename vertex_t, typename edge_t, bool multi_gpu> std::tuple<rmm::device_uvector<vertex_t>, std::vector<vertex_t>, std::optional<std::vector<vertex_t>>, vertex_t> compute_renumber_map(raft::handle_t const &handle, std::optional<rmm::device_uvector<vertex_t>> &&local_vertices, std::vector<vertex_t const*> const &edgelist_majors, std::vector<vertex_t const*> const &edgelist_minors, std::vector<edge_t> const &edgelist_edge_counts)#

template<typename vertex_t, typename edge_t, bool multi_gpu> void expensive_check_edgelist(raft::handle_t const &handle, std::optional<rmm::device_uvector<vertex_t>> const &local_vertices, std::vector<vertex_t const*> const &edgelist_majors, std::vector<vertex_t const*> const &edgelist_minors, std::vector<edge_t> const &edgelist_edge_counts, std::optional<std::vector<std::vector<edge_t>>> const &edgelist_intra_partition_segment_offsets)#

template<typename vertex_t> std::vector<vertex_t> aggregate_offset_vectors(raft::handle_t const &handle, std::vector<vertex_t> const &offsets)#

template<typename vertex_t> void unrenumber_local_int_edges(raft::handle_t const &handle, std::vector<vertex_t*> const &edgelist_majors, std::vector<vertex_t*> const &edgelist_minors, std::vector<size_t> const &edgelist_edge_counts, vertex_t const *renumber_map_labels, std::vector<vertex_t> const &vertex_partition_range_lasts, std::optional<std::vector<std::vector<size_t>>> const &edgelist_intra_partition_segment_offsets, bool do_expensive_check)#

template<typename vertex_t, typename weight_t, bool multi_gpu> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<weight_t>>> symmetrize_edgelist(raft::handle_t const &handle, rmm::device_uvector<vertex_t> &&edgelist_majors, rmm::device_uvector<vertex_t> &&edgelist_minors, std::optional<rmm::device_uvector<weight_t>> &&edgelist_weights, bool reciprocal)#

template<typename GraphViewType, typename PredecessorIterator> void bfs(raft::handle_t const &handle, GraphViewType const &graph_view, typename GraphViewType::vertex_type *distances, PredecessorIterator predecessor_first, typename GraphViewType::vertex_type const *sources, size_t n_sources, bool direction_optimizing, typename GraphViewType::vertex_type depth_limit, bool do_expensive_check)#

template<typename vertex_t> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<size_t>> shrink_extraction_list(raft::handle_t const &handle, rmm::device_uvector<vertex_t> &&vertex_list, rmm::device_uvector<size_t> &&path_offset)#

template<typename GraphViewType> std::tuple<rmm::device_uvector<size_t>, rmm::device_uvector<typename GraphViewType::vertex_type>> k_hop_nbrs(raft::handle_t const &handle, GraphViewType const &push_graph_view, raft::device_span<typename GraphViewType::vertex_type const> start_vertices, size_t k, bool do_expensive_check)#

template<typename GraphViewType, typename weight_t, typename PredecessorIterator> void sssp(raft::handle_t const &handle, GraphViewType const &push_graph_view, edge_property_view_t<typename GraphViewType::edge_type, weight_t const*> edge_weight_view, weight_t *distances, PredecessorIterator predecessor_first, typename GraphViewType::vertex_type source_vertex, weight_t cutoff, bool do_expensive_check)#

template<typename vertex_t, typename edge_t, typename weight_t> std::unique_ptr<legacy::GraphCOO<vertex_t, edge_t, weight_t>> mst_impl(raft::handle_t const &handle, legacy::GraphCSRView<vertex_t, edge_t, weight_t> const &graph, rmm::device_async_resource_ref mr)#

template<typename GraphViewType, typename VertexPairIterator> size_t count_invalid_vertex_pairs(raft::handle_t const &handle, GraphViewType const &graph_view, VertexPairIterator vertex_pair_first, VertexPairIterator vertex_pair_last)#

template<typename vertex_t, typename weight_t> static __global__ void get_traversed_cost_kernel (vertex_t const *vertices, vertex_t const *preds, vertex_t const *vtx_map, weight_t const *info_weights, weight_t *out, vertex_t stop_vertex, vertex_t num_vertices)

template<typename vertex_t, typename weight_t> void get_traversed_cost_impl(raft::handle_t const &handle, vertex_t const *vertices, vertex_t const *preds, weight_t const *info_weights, weight_t *out, vertex_t stop_vertex, vertex_t num_vertices)#

template<typename vertex_t, typename edge_t, typename weight_t, typename edge_type_t> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<weight_t>>, std::optional<rmm::device_uvector<edge_t>>, std::optional<rmm::device_uvector<edge_type_t>>, std::vector<size_t>> shuffle_ext_vertex_pairs_with_values_to_local_gpu_by_edge_partitioning(raft::handle_t const &handle, rmm::device_uvector<vertex_t> &&majors, rmm::device_uvector<vertex_t> &&minors, std::optional<rmm::device_uvector<weight_t>> &&weights, std::optional<rmm::device_uvector<edge_t>> &&edge_ids, std::optional<rmm::device_uvector<edge_type_t>> &&edge_types)#

template<typename vertex_t, typename edge_t, typename weight_t, typename edge_type_t> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<weight_t>>, std::optional<rmm::device_uvector<edge_t>>, std::optional<rmm::device_uvector<edge_type_t>>, std::vector<size_t>> shuffle_int_vertex_pairs_with_values_to_local_gpu_by_edge_partitioning(raft::handle_t const &handle, rmm::device_uvector<vertex_t> &&majors, rmm::device_uvector<vertex_t> &&minors, std::optional<rmm::device_uvector<weight_t>> &&weights, std::optional<rmm::device_uvector<edge_t>> &&edge_ids, std::optional<rmm::device_uvector<edge_type_t>> &&edge_types, std::vector<vertex_t> const &vertex_partition_range_lasts)#

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::vector< size_t > > shuffle_ext_vertex_pairs_with_values_to_local_gpu_by_edge_partitioning (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&majors, rmm::device_uvector< int32_t > &&minors, std::optional< rmm::device_uvector< float > > &&weights, std::optional< rmm::device_uvector< int32_t > > &&edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edge_types)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::vector< size_t > > shuffle_ext_vertex_pairs_with_values_to_local_gpu_by_edge_partitioning (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&majors, rmm::device_uvector< int32_t > &&minors, std::optional< rmm::device_uvector< double > > &&weights, std::optional< rmm::device_uvector< int32_t > > &&edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edge_types)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::vector< size_t > > shuffle_int_vertex_pairs_with_values_to_local_gpu_by_edge_partitioning (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&majors, rmm::device_uvector< int32_t > &&minors, std::optional< rmm::device_uvector< float > > &&weights, std::optional< rmm::device_uvector< int32_t > > &&edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edge_types, std::vector< int32_t > const &vertex_partition_range_lasts)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int32_t > >, std::optional< rmm::device_uvector< int32_t > >, std::vector< size_t > > shuffle_int_vertex_pairs_with_values_to_local_gpu_by_edge_partitioning (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&majors, rmm::device_uvector< int32_t > &&minors, std::optional< rmm::device_uvector< double > > &&weights, std::optional< rmm::device_uvector< int32_t > > &&edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edge_types, std::vector< int32_t > const &vertex_partition_range_lasts)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::vector< size_t > > shuffle_ext_vertex_pairs_with_values_to_local_gpu_by_edge_partitioning (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&majors, rmm::device_uvector< int64_t > &&minors, std::optional< rmm::device_uvector< float > > &&weights, std::optional< rmm::device_uvector< int64_t > > &&edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edge_types)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::vector< size_t > > shuffle_ext_vertex_pairs_with_values_to_local_gpu_by_edge_partitioning (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&majors, rmm::device_uvector< int64_t > &&minors, std::optional< rmm::device_uvector< double > > &&weights, std::optional< rmm::device_uvector< int64_t > > &&edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edge_types)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< float > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::vector< size_t > > shuffle_int_vertex_pairs_with_values_to_local_gpu_by_edge_partitioning (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&majors, rmm::device_uvector< int64_t > &&minors, std::optional< rmm::device_uvector< float > > &&weights, std::optional< rmm::device_uvector< int64_t > > &&edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edge_types, std::vector< int64_t > const &vertex_partition_range_lasts)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t >, std::optional< rmm::device_uvector< double > >, std::optional< rmm::device_uvector< int64_t > >, std::optional< rmm::device_uvector< int32_t > >, std::vector< size_t > > shuffle_int_vertex_pairs_with_values_to_local_gpu_by_edge_partitioning (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&majors, rmm::device_uvector< int64_t > &&minors, std::optional< rmm::device_uvector< double > > &&weights, std::optional< rmm::device_uvector< int64_t > > &&edge_ids, std::optional< rmm::device_uvector< int32_t > > &&edge_types, std::vector< int64_t > const &vertex_partition_range_lasts)

template<typename vertex_t> rmm::device_uvector<vertex_t> shuffle_ext_vertices_to_local_gpu_by_vertex_partitioning(raft::handle_t const &handle, rmm::device_uvector<vertex_t> &&vertices)#

Shuffle external (i.e. before renumbering) vertices to their local GPU based on vertex partitioning.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.

Parameters:

handle – [in] RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
vertices – [in] Vertices to shuffle.

Returns:

Vector of shuffled vertices.

template<typename vertex_t, typename value_t> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<value_t>> shuffle_ext_vertex_value_pairs_to_local_gpu_by_vertex_partitioning(raft::handle_t const &handle, rmm::device_uvector<vertex_t> &&vertices, rmm::device_uvector<value_t> &&values)#

Shuffle external (i.e. before renumbering) vertex & value pairs to their local GPU based on vertex partitioning.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
value_t – Type of values.

Parameters:

handle – [in] RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
vertices – [in] Vertices to shuffle.
values – [in] Values to shuffle.

Returns:

Tuple of vectors storing shuffled vertex & value pairs.

template<typename vertex_t> rmm::device_uvector<vertex_t> shuffle_int_vertices_to_local_gpu_by_vertex_partitioning(raft::handle_t const &handle, rmm::device_uvector<vertex_t> &&vertices, std::vector<vertex_t> const &vertex_partition_range_lasts)#

Shuffle internal (i.e. renumbered) vertices to their local GPUs based on vertex partitioning.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.

Parameters:

handle – [in] RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
vertices – [in] Vertices to shuffle.
vertex_partition_range_lasts – [in] Vector of each GPU’s vertex partition range’s last (exclusive) vertex ID.

Returns:

Vector of shuffled vertices.

template<typename vertex_t, typename value_t> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<value_t>> shuffle_int_vertex_value_pairs_to_local_gpu_by_vertex_partitioning(raft::handle_t const &handle, rmm::device_uvector<vertex_t> &&vertices, rmm::device_uvector<value_t> &&values, std::vector<vertex_t> const &vertex_partition_range_lasts)#

Shuffle vertices using the internal vertex key function which returns the target GPU ID.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
value_t – Type of vertex values. Needs to be an integral type.

Parameters:

handle – [in] RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator,
vertices – [in] Vertex IDs to shuffle
values – [in] Vertex Values to shuffle
vertex_partition_range_lasts – [in] From graph view, vector of last vertex id for each gpu

Returns:

tuple containing device vector of shuffled vertices and device vector of corresponding values

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< float > > shuffle_ext_vertex_value_pairs_to_local_gpu_by_vertex_partitioning (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&vertices, rmm::device_uvector< float > &&values)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< double > > shuffle_ext_vertex_value_pairs_to_local_gpu_by_vertex_partitioning (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&vertices, rmm::device_uvector< double > &&values)

template rmm::device_uvector< int32_t > shuffle_int_vertices_to_local_gpu_by_vertex_partitioning (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&vertices, std::vector< int32_t > const &vertex_partition_range_lasts)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t > > shuffle_int_vertex_value_pairs_to_local_gpu_by_vertex_partitioning (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&d_vertices, rmm::device_uvector< int32_t > &&d_values, std::vector< int32_t > const &vertex_partition_range_lasts)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int64_t > > shuffle_int_vertex_value_pairs_to_local_gpu_by_vertex_partitioning (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&d_vertices, rmm::device_uvector< int64_t > &&d_values, std::vector< int32_t > const &vertex_partition_range_lasts)

template rmm::device_uvector< int32_t > shuffle_ext_vertices_to_local_gpu_by_vertex_partitioning (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&d_vertices)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< int32_t > > shuffle_ext_vertex_value_pairs_to_local_gpu_by_vertex_partitioning (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&vertices, rmm::device_uvector< int32_t > &&values)

template std::tuple< rmm::device_uvector< int32_t >, rmm::device_uvector< size_t > > shuffle_ext_vertex_value_pairs_to_local_gpu_by_vertex_partitioning (raft::handle_t const &handle, rmm::device_uvector< int32_t > &&vertices, rmm::device_uvector< size_t > &&values)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< float > > shuffle_ext_vertex_value_pairs_to_local_gpu_by_vertex_partitioning (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&vertices, rmm::device_uvector< float > &&values)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< double > > shuffle_ext_vertex_value_pairs_to_local_gpu_by_vertex_partitioning (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&vertices, rmm::device_uvector< double > &&values)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int32_t > > shuffle_int_vertex_value_pairs_to_local_gpu_by_vertex_partitioning (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&d_vertices, rmm::device_uvector< int32_t > &&d_values, std::vector< int64_t > const &vertex_partition_range_lasts)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t > > shuffle_int_vertex_value_pairs_to_local_gpu_by_vertex_partitioning (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&d_vertices, rmm::device_uvector< int64_t > &&d_values, std::vector< int64_t > const &vertex_partition_range_lasts)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int32_t > > shuffle_ext_vertex_value_pairs_to_local_gpu_by_vertex_partitioning (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&vertices, rmm::device_uvector< int32_t > &&values)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< size_t > > shuffle_ext_vertex_value_pairs_to_local_gpu_by_vertex_partitioning (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&vertices, rmm::device_uvector< size_t > &&values)

template rmm::device_uvector< int64_t > shuffle_int_vertices_to_local_gpu_by_vertex_partitioning (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&vertices, std::vector< int64_t > const &vertex_partition_range_lasts)

template rmm::device_uvector< int64_t > shuffle_ext_vertices_to_local_gpu_by_vertex_partitioning (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&d_vertices)

template std::tuple< rmm::device_uvector< int64_t >, rmm::device_uvector< int64_t > > shuffle_ext_vertex_value_pairs_to_local_gpu_by_vertex_partitioning (raft::handle_t const &handle, rmm::device_uvector< int64_t > &&vertices, rmm::device_uvector< int64_t > &&values)

template<typename vertex_t, typename edge_t, bool multi_gpu> static __global__ void decompress_to_edgelist_mid_degree (edge_partition_device_view_t< vertex_t, edge_t, multi_gpu > edge_partition, vertex_t major_range_first, vertex_t major_range_last, raft::device_span< vertex_t > majors)

template<typename vertex_t, typename edge_t, bool multi_gpu> static __global__ void decompress_to_edgelist_high_degree (edge_partition_device_view_t< vertex_t, edge_t, multi_gpu > edge_partition, vertex_t major_range_first, vertex_t major_range_last, raft::device_span< vertex_t > majors)

template<typename vertex_t, typename edge_t, bool multi_gpu> void decompress_edge_partition_to_fill_edgelist_majors(raft::handle_t const &handle, edge_partition_device_view_t<vertex_t, edge_t, multi_gpu> edge_partition, std::optional<edge_partition_edge_property_device_view_t<edge_t, uint32_t const*, bool>> edge_partition_mask_view, raft::device_span<vertex_t> majors, std::optional<std::vector<vertex_t>> const &segment_offsets)#

template<typename vertex_t, typename edge_t, typename weight_t, typename edge_type_t, bool multi_gpu> void decompress_edge_partition_to_edgelist(raft::handle_t const &handle, edge_partition_device_view_t<vertex_t, edge_t, multi_gpu> edge_partition, std::optional<edge_partition_edge_property_device_view_t<edge_t, weight_t const*>> edge_partition_weight_view, std::optional<edge_partition_edge_property_device_view_t<edge_t, edge_t const*>> edge_partition_id_view, std::optional<edge_partition_edge_property_device_view_t<edge_t, edge_type_t const*>> edge_partition_type_view, std::optional<edge_partition_edge_property_device_view_t<edge_t, uint32_t const*, bool>> edge_partition_mask_view, raft::device_span<vertex_t> edgelist_majors, raft::device_span<vertex_t> edgelist_minors, std::optional<raft::device_span<weight_t>> edgelist_weights, std::optional<raft::device_span<edge_t>> edgelist_ids, std::optional<raft::device_span<edge_type_t>> edgelist_types, std::optional<std::vector<vertex_t>> const &segment_offsets)#

template<typename vertex_t, typename edge_t, typename weight_t, typename edge_type_id_t> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<weight_t>>, std::optional<rmm::device_uvector<edge_t>>, std::optional<rmm::device_uvector<edge_type_id_t>>, std::vector<size_t>> shuffle_ext_vertex_pairs_with_values_to_local_gpu_by_edge_partitioning(raft::handle_t const &handle, rmm::device_uvector<vertex_t> &&majors, rmm::device_uvector<vertex_t> &&minors, std::optional<rmm::device_uvector<weight_t>> &&weights, std::optional<rmm::device_uvector<edge_t>> &&edge_ids, std::optional<rmm::device_uvector<edge_type_id_t>> &&edge_types)#

Shuffle external (i.e. before renumbering) vertex pairs (which can be edge end points) to their local GPUs based on edge partitioning.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
weight_t – Type of edge weights. Needs to be a floating point type.
edge_type_t – Type of edge type identifiers. Needs to be an integral type.

Parameters:

handle – [in] RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
majors – [in] Vector of first elemetns in vertex pairs. To determine the local GPU of a (major, minor) pair, we assume there exists an edge from major=>minor (if we store edges in the sparse 2D matrix using sources as major indices) or minor=>major (otherwise) and apply the edge partitioning to determine the local GPU.
minors – [in] Vector of second elements in vertex pairs.
weights – [in] Optional vector of vertex pair weight values.
edge_ids – [in] Optional vector of vertex pair edge id values.
edge_types – [in] Optional vector of vertex pair edge type values.

Returns:

Tuple of vectors storing shuffled major vertices, minor vertices and optional weights, edge ids and edge types

template<typename vertex_t, typename edge_t, typename weight_t, typename edge_type_id_t> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>, std::optional<rmm::device_uvector<weight_t>>, std::optional<rmm::device_uvector<edge_t>>, std::optional<rmm::device_uvector<edge_type_id_t>>, std::vector<size_t>> shuffle_int_vertex_pairs_with_values_to_local_gpu_by_edge_partitioning(raft::handle_t const &handle, rmm::device_uvector<vertex_t> &&majors, rmm::device_uvector<vertex_t> &&minors, std::optional<rmm::device_uvector<weight_t>> &&weights, std::optional<rmm::device_uvector<edge_t>> &&edge_ids, std::optional<rmm::device_uvector<edge_type_id_t>> &&edge_types, std::vector<vertex_t> const &vertex_partition_range_lasts)#

Shuffle internal (i.e. renumbered) vertex pairs (which can be edge end points) to their local GPUs based on edge partitioning.

Template Parameters:

vertex_t – Type of vertex identifiers. Needs to be an integral type.
edge_t – Type of edge identifiers. Needs to be an integral type.
weight_t – Type of edge weights. Needs to be a floating point type.
edge_type_t – Type of edge type identifiers. Needs to be an integral type.

Parameters:

handle – [in] RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and handles to various CUDA libraries) to run graph algorithms.
majors – [in] Vector of first elemetns in vertex pairs. To determine the local GPU of a (major, minor) pair, we assume there exists an edge from major=>minor (if we store edges in the sparse 2D matrix using sources as major indices) or minor=>major (otherwise) and apply the edge partitioning to determine the local GPU.
minors – [in] Vector of second elements in vertex pairs.
weights – [in] Optional vector of vertex pair weight values.
edge_ids – [in] Optional vector of vertex pair edge id values.
edge_types – [in] Optional vector of vertex pair edge type values.
vertex_partition_range_lasts – [in] Vector of each GPU’s vertex partition range’s last (exclusive) vertex ID.

Returns:

Tuple of vectors storing shuffled major vertices, minor vertices and optional weights, edge ids and edge types and rx counts

template<typename vertex_t> vertex_t compute_maximum_vertex_id(rmm::cuda_stream_view const &stream_view, rmm::device_uvector<vertex_t> const &d_edgelist_srcs, rmm::device_uvector<vertex_t> const &d_edgelist_dsts)#

Compute the maximum vertex id of an edge list.

max(d_edgelist_srcs.max(), d_edgelist_dsts.max())

Template Parameters:

vertex_t – vertex type

Parameters:

stream_view – [in] stream view
d_edgelist_srcs – [in] device array storing source IDs
d_edgelist_dsts – [in] device array storing destination IDs
the – maximum value occurring in the edge list

template<typename vertex_t> __device__ thrust::optional< vertex_t > major_hypersparse_idx_from_major_nocheck_impl (raft::device_span< vertex_t const > dcs_nzd_vertices, vertex_t major)

template<typename Iterator, typename TupleType, std::size_t... Is> __device__ constexpr TupleType thrust_tuple_atomic_and (Iterator iter, TupleType tup, std::index_sequence< Is... >)

template<typename Iterator, typename TupleType, std::size_t... Is> __device__ constexpr TupleType thrust_tuple_atomic_or (Iterator iter, TupleType tup, std::index_sequence< Is... >)

template<typename Iterator, typename TupleType, std::size_t... Is> __device__ constexpr TupleType thrust_tuple_atomic_add (Iterator iter, TupleType tup, std::index_sequence< Is... >)

template<typename Iterator, typename TupleType, std::size_t... Is> __device__ constexpr TupleType thrust_tuple_elementwise_atomic_cas (Iterator iter, TupleType comp_tup, TupleType val_tup, std::index_sequence< Is... >)

template<typename Iterator, typename TupleType, std::size_t... Is> __device__ constexpr TupleType thrust_tuple_elementwise_atomic_min (Iterator iter, TupleType tup, std::index_sequence< Is... >)

template<typename Iterator, typename TupleType, std::size_t... Is> __device__ constexpr TupleType thrust_tuple_elementwise_atomic_max (Iterator iter, TupleType tup, std::index_sequence< Is... >)

template<typename TupleType, size_t... Is> auto allocate_dataframe_buffer_tuple_impl(std::index_sequence<Is...>, size_t buffer_size, rmm::cuda_stream_view stream_view)#

template<typename TupleType, std::size_t... Is> auto get_dataframe_buffer_begin_tuple_impl(std::index_sequence<Is...>, TupleType &buffer)#

template<typename TupleType, std::size_t... Is> auto get_dataframe_buffer_end_tuple_impl(std::index_sequence<Is...>, TupleType &buffer)#

template<typename TupleType, size_t... Is> auto get_dataframe_buffer_cbegin_tuple_impl(std::index_sequence<Is...>, TupleType &buffer)#

template<typename TupleType, std::size_t... Is> auto get_dataframe_buffer_cend_tuple_impl(std::index_sequence<Is...>, TupleType &buffer)#

template<typename T> T *iter_to_raw_ptr(T *ptr)#

template<typename T> T *iter_to_raw_ptr(thrust::device_ptr<T> ptr)#

template<typename T> auto iter_to_raw_ptr(thrust::detail::normal_iterator<thrust::device_ptr<T>> iter)#

template<typename InputIterator, typename OutputValueType> std::enable_if_t<std::is_same_v<OutputValueType, thrust::detail::any_assign>, void> device_isend_impl(raft::comms::comms_t const &comm, InputIterator input_first, size_t count, int dst, int tag, raft::comms::request_t *request)#

template<typename InputIterator, typename OutputValueType> std::enable_if_t<std::is_arithmetic<OutputValueType>::value, void> device_isend_impl(raft::comms::comms_t const &comm, InputIterator input_first, size_t count, int dst, int tag, raft::comms::request_t *request)#

template<typename InputValueType, typename OutputIterator> std::enable_if_t<thrust::detail::is_discard_iterator<OutputIterator>::value, void> device_irecv_impl(raft::comms::comms_t const &comm, OutputIterator output_first, size_t count, int src, int tag, raft::comms::request_t *request)#

template<typename InputValueType, typename OutputIterator> std::enable_if_t<std::is_arithmetic<typename std::iterator_traits<OutputIterator>::value_type>::value, void> device_irecv_impl(raft::comms::comms_t const &comm, OutputIterator output_first, size_t count, int src, int tag, raft::comms::request_t *request)#

template<typename InputIterator, typename OutputIterator> std::enable_if_t<thrust::detail::is_discard_iterator<OutputIterator>::value, void> device_sendrecv_impl(raft::comms::comms_t const &comm, InputIterator input_first, size_t tx_count, int dst, OutputIterator output_first, size_t rx_count, int src, rmm::cuda_stream_view stream_view)#

template<typename InputIterator, typename OutputIterator> std::enable_if_t<std::is_arithmetic<typename std::iterator_traits<OutputIterator>::value_type>::value, void> device_sendrecv_impl(raft::comms::comms_t const &comm, InputIterator input_first, size_t tx_count, int dst, OutputIterator output_first, size_t rx_count, int src, rmm::cuda_stream_view stream_view)#

template<typename InputIterator, typename OutputIterator> std::enable_if_t<thrust::detail::is_discard_iterator<OutputIterator>::value, void> device_multicast_sendrecv_impl(raft::comms::comms_t const &comm, InputIterator input_first, std::vector<size_t> const &tx_counts, std::vector<size_t> const &tx_offsets, std::vector<int> const &tx_dst_ranks, OutputIterator output_first, std::vector<size_t> const &rx_counts, std::vector<size_t> const &rx_offsets, std::vector<int> const &rx_src_ranks, rmm::cuda_stream_view stream_view)#

template<typename InputIterator, typename OutputIterator> std::enable_if_t<std::is_arithmetic<typename std::iterator_traits<OutputIterator>::value_type>::value, void> device_multicast_sendrecv_impl(raft::comms::comms_t const &comm, InputIterator input_first, std::vector<size_t> const &tx_counts, std::vector<size_t> const &tx_offsets, std::vector<int> const &tx_dst_ranks, OutputIterator output_first, std::vector<size_t> const &rx_counts, std::vector<size_t> const &rx_offsets, std::vector<int> const &rx_src_ranks, rmm::cuda_stream_view stream_view)#

template<typename InputIterator, typename OutputIterator> std::enable_if_t<thrust::detail::is_discard_iterator<OutputIterator>::value, void> device_bcast_impl(raft::comms::comms_t const &comm, InputIterator input_first, OutputIterator output_first, size_t count, int root, rmm::cuda_stream_view stream_view)#

template<typename InputIterator, typename OutputIterator> std::enable_if_t<std::is_arithmetic<typename std::iterator_traits<OutputIterator>::value_type>::value, void> device_bcast_impl(raft::comms::comms_t const &comm, InputIterator input_first, OutputIterator output_first, size_t count, int root, rmm::cuda_stream_view stream_view)#

template<typename InputIterator, typename OutputIterator> std::enable_if_t<thrust::detail::is_discard_iterator<OutputIterator>::value, void> device_allreduce_impl(raft::comms::comms_t const &comm, InputIterator input_first, OutputIterator output_first, size_t count, raft::comms::op_t op, rmm::cuda_stream_view stream_view)#

template<typename InputIterator, typename OutputIterator> std::enable_if_t<std::is_arithmetic<typename std::iterator_traits<OutputIterator>::value_type>::value, void> device_allreduce_impl(raft::comms::comms_t const &comm, InputIterator input_first, OutputIterator output_first, size_t count, raft::comms::op_t op, rmm::cuda_stream_view stream_view)#

template<typename InputIterator, typename OutputIterator> std::enable_if_t<thrust::detail::is_discard_iterator<OutputIterator>::value, void> device_reduce_impl(raft::comms::comms_t const &comm, InputIterator input_first, OutputIterator output_first, size_t count, raft::comms::op_t op, int root, rmm::cuda_stream_view stream_view)#

template<typename InputIterator, typename OutputIterator> std::enable_if_t<std::is_arithmetic<typename std::iterator_traits<OutputIterator>::value_type>::value, void> device_reduce_impl(raft::comms::comms_t const &comm, InputIterator input_first, OutputIterator output_first, size_t count, raft::comms::op_t op, int root, rmm::cuda_stream_view stream_view)#

template<typename InputIterator, typename OutputIterator> std::enable_if_t<thrust::detail::is_discard_iterator<OutputIterator>::value, void> device_allgather_impl(raft::comms::comms_t const &comm, InputIterator input_first, OutputIterator output_first, size_t sendcount, rmm::cuda_stream_view stream_view)#

template<typename InputIterator, typename OutputIterator> std::enable_if_t<std::is_arithmetic<typename std::iterator_traits<OutputIterator>::value_type>::value, void> device_allgather_impl(raft::comms::comms_t const &comm, InputIterator input_first, OutputIterator output_first, size_t sendcount, rmm::cuda_stream_view stream_view)#

template<typename InputIterator, typename OutputIterator> std::enable_if_t<thrust::detail::is_discard_iterator<OutputIterator>::value, void> device_allgatherv_impl(raft::comms::comms_t const &comm, InputIterator input_first, OutputIterator output_first, std::vector<size_t> const &recvcounts, std::vector<size_t> const &displacements, rmm::cuda_stream_view stream_view)#

template<typename InputIterator, typename OutputIterator> std::enable_if_t<std::is_arithmetic<typename std::iterator_traits<OutputIterator>::value_type>::value, void> device_allgatherv_impl(raft::comms::comms_t const &comm, InputIterator input_first, OutputIterator output_first, std::vector<size_t> const &recvcounts, std::vector<size_t> const &displacements, rmm::cuda_stream_view stream_view)#

template<typename InputIterator, typename OutputIterator> std::enable_if_t<thrust::detail::is_discard_iterator<OutputIterator>::value, void> device_gatherv_impl(raft::comms::comms_t const &comm, InputIterator input_first, OutputIterator output_first, size_t sendcount, std::vector<size_t> const &recvcounts, std::vector<size_t> const &displacements, int root, rmm::cuda_stream_view stream_view)#

template<typename InputIterator, typename OutputIterator> std::enable_if_t<std::is_arithmetic<typename std::iterator_traits<OutputIterator>::value_type>::value, void> device_gatherv_impl(raft::comms::comms_t const &comm, InputIterator input_first, OutputIterator output_first, size_t sendcount, std::vector<size_t> const &recvcounts, std::vector<size_t> const &displacements, int root, rmm::cuda_stream_view stream_view)#

template<typename MaskIterator> __device__ size_t count_set_bits (MaskIterator mask_first, size_t start_offset, size_t num_bits)

template<typename MaskIterator> __device__ size_t find_nth_set_bits (MaskIterator mask_first, size_t start_offset, size_t num_bits, size_t n)

template<typename InputIterator, typename MaskIterator, typename OutputIterator, typename input_value_type = typename thrust::iterator_traits<InputIterator>::value_type, typename output_value_type = typename thrust::iterator_traits< OutputIterator>::value_type> __device__ size_t copy_if_mask_set (InputIterator input_first, MaskIterator mask_first, OutputIterator output_first, size_t input_start_offset, size_t output_start_offset, size_t num_items)

template<typename MaskIterator> size_t count_set_bits(raft::handle_t const &handle, MaskIterator mask_first, size_t num_bits)#

template<typename InputIterator, typename MaskIterator, typename OutputIterator> OutputIterator copy_if_mask_set(raft::handle_t const &handle, InputIterator input_first, InputIterator input_last, MaskIterator mask_first, OutputIterator output_first)#

template<typename vertex_t, typename offset_t> std::tuple<std::vector<vertex_t>, std::vector<offset_t>> compute_offset_aligned_element_chunks(raft::handle_t const &handle, raft::device_span<offset_t const> offsets, offset_t num_elements, vertex_t approx_element_chunk_size)#

template<typename T> thrust::optional<T> to_thrust_optional(std::optional<T> val)#

template<typename T> std::optional<T> to_std_optional(thrust::optional<T> val)#

template<typename idx_t, typename offset_t> rmm::device_uvector<idx_t> expand_sparse_offsets(raft::device_span<offset_t const> offsets, idx_t base_idx, rmm::cuda_stream_view stream_view)#

template<typename ValueIterator, typename value_t, std::size_t... Is> std::enable_if_t<cugraph::is_thrust_tuple_of_arithmetic<typename thrust::iterator_traits<ValueIterator>::value_type>::value && cugraph::is_thrust_tuple_of_arithmetic<value_t>::value, bool> has_packed_bool_element(std::index_sequence<Is...>)#

inline std::tuple<std::vector<size_t>, std::vector<size_t>, std::vector<int>, std::vector<size_t>, std::vector<size_t>, std::vector<int>> compute_tx_rx_counts_offsets_ranks(raft::comms::comms_t const &comm, rmm::device_uvector<size_t> const &d_tx_value_counts, bool drop_empty_ranks, rmm::cuda_stream_view stream_view)#

template<typename ValueIterator, typename ValueToGroupIdOp> void multi_partition(ValueIterator value_first, ValueIterator value_last, ValueToGroupIdOp value_to_group_id_op, int group_first, int group_last, rmm::cuda_stream_view stream_view)#

template<typename KeyIterator, typename ValueIterator, typename KeyToGroupIdOp> void multi_partition(KeyIterator key_first, KeyIterator key_last, ValueIterator value_first, KeyToGroupIdOp key_to_group_id_op, int group_first, int group_last, rmm::cuda_stream_view stream_view)#

template<typename ValueIterator> void swap_partitions(ValueIterator value_first, ValueIterator value_last, size_t first_partition_size, rmm::cuda_stream_view stream_view)#

template<typename KeyIterator, typename ValueIterator> void swap_partitions(KeyIterator key_first, KeyIterator key_last, ValueIterator value_first, size_t first_partition_size, rmm::cuda_stream_view stream_view)#

template<typename ValueIterator, typename ValueToGroupIdOp> ValueIterator mem_frugal_partition(ValueIterator value_first, ValueIterator value_last, ValueToGroupIdOp value_to_group_id_op, int pivot, rmm::cuda_stream_view stream_view)#

template<typename KeyIterator, typename ValueIterator, typename KeyToGroupIdOp> std::tuple<KeyIterator, ValueIterator> mem_frugal_partition(KeyIterator key_first, KeyIterator key_last, ValueIterator value_first, KeyToGroupIdOp key_to_group_id_op, int pivot, rmm::cuda_stream_view stream_view)#

template<typename ValueIterator, typename ValueToGroupIdOp> void mem_frugal_groupby(ValueIterator value_first, ValueIterator value_last, ValueToGroupIdOp value_to_group_id_op, int num_groups, size_t mem_frugal_threshold, rmm::cuda_stream_view stream_view)#

template<typename KeyIterator, typename ValueIterator, typename KeyToGroupIdOp> void mem_frugal_groupby(KeyIterator key_first, KeyIterator key_last, ValueIterator value_first, KeyToGroupIdOp key_to_group_id_op, int num_groups, size_t mem_frugal_threshold, rmm::cuda_stream_view stream_view)#

template<typename TupleType, std::size_t... Is> size_t sum_thrust_tuple_element_sizes(std::index_sequence<Is...>)#

template<typename TupleType, std::size_t... Is> size_t min_thrust_tuple_element_sizes(std::index_sequence<Is...>)#

template<typename TupleType, std::size_t... Is> size_t max_thrust_tuple_element_sizes(std::index_sequence<Is...>)#

template<typename TupleType, std::size_t... Is> auto thrust_tuple_to_std_tuple(TupleType tup, std::index_sequence<Is...>)#

template<typename TupleType, std::size_t... Is> auto std_tuple_to_thrust_tuple(TupleType tup, std::index_sequence<Is...>)#

template<typename TupleType, std::size_t... Is> TupleType thrust_tuple_of_arithmetic_numeric_limits_lowest(std::index_sequence<Is...>)#

template<typename TupleType, std::size_t... Is> TupleType thrust_tuple_of_arithmetic_numeric_limits_max(std::index_sequence<Is...>)#

Variables

__global__ int *restrict childd

__global__ int *restrict int *restrict massd

__global__ int *restrict int *restrict float *restrict posxd

__global__ int *restrict int *restrict float *restrict float *restrict posyd

__global__ int *restrict int *restrict float *restrict float *restrict float *restrict maxxd

__global__ int *restrict int *restrict float *restrict float *restrict float *restrict float *restrict maxyd

__global__ int *restrict int *restrict float *restrict float *restrict float *restrict float *restrict float *restrict minxd

__global__ int *restrict int *restrict float *restrict float *restrict float *restrict float *restrict float *restrict float *restrict minyd

__global__ int *restrict int *restrict float *restrict float *restrict float *restrict float *restrict float *restrict float *restrict const int FOUR_NNODES

__global__ int *restrict int *restrict float *restrict float *restrict float *restrict float *restrict float *restrict float *restrict const int const int NNODES

__global__ int *restrict int *restrict float *restrict float *restrict float *restrict float *restrict float *restrict float *restrict const int const int const int N

__global__ int *restrict int *restrict float *restrict float *restrict float *restrict float *restrict float *restrict float *restrict const int const int const int unsigned *restrict limiter = 0

__global__ int *restrict int *restrict float *restrict float *restrict float *restrict float *restrict float *restrict float *restrict const int const int const int unsigned *restrict float *restrict radiusd {float val, minx, maxx, miny, maxy

__shared__ float sminx [THREADS1] = minx

__shared__ float smaxx [THREADS1] = maxx

__shared__ float sminy [THREADS1] = miny

__shared__ float smaxy [THREADS1] = maxy

minx = maxx = posxd[0]

miny = maxy = posyd[0]

const int i = threadIdx.x#

const int inc = THREADS1 * gridDim.x#

__global__ const int const int FOUR_N {const int inc = blockDim.x * gridDim.x

int k = (FOUR_N & -32) + threadIdx.x + blockIdx.x * blockDim.x#

__global__ const float *restrict const float *restrict const int const int int *restrict maxdepthd {__shared__ int pos[THREADS5], node[THREADS5]

__global__ const float *restrict const float *restrict const int const int int *restrict int *restrict bottomd {const int bottom = bottomd[0]

float x#

float y#

float r#

float px#

float py#

int ch#

int n#

int locked#

int patch#

const float radius = radiusd[0]#

const float rootx = posxd[NNODES]#

const float rooty = posyd[NNODES]#

int localmaxdepth = 1#

int skip = 1#

float cm#

__shared__ int child [THREADS3 *4]

__shared__ int mass [THREADS3 *4]

const int bottom = bottomd[0]#

const int restart = k #

int j = 0#

__global__ const int *restrict countd

__global__ const int *restrict volatile int *restrict startd

const int dec = blockDim.x * gridDim.x#

int start#

__global__ const float theta

__global__ const float const float epssqd

__global__ const float const float const int *restrict sortd

__global__ const float const float const int *restrict const int *restrict const int *restrict const float *restrict const float *restrict float *restrict velxd

__global__ const float const float const int *restrict const int *restrict const int *restrict const float *restrict const float *restrict float *restrict float *restrict velyd

__global__ const float const float const int *restrict const int *restrict const int *restrict const float *restrict const float *restrict float *restrict float *restrict const float theta_squared

__global__ const float const float const int *restrict const int *restrict const int *restrict const float *restrict const float *restrict float *restrict float *restrict const float const int const int const int const float *restrict radiusd_squared

__shared__ float dq [THREADS5] = dq[diff]

const int sbase = (threadIdx.x / 32) * 32#

const bool SBASE_EQ_THREAD = (sbase == threadIdx.x)#

const int diff = threadIdx.x - sbase #

const int MAX_SIZE = FOUR_NNODES + 4#

__global__ float *restrict Y_y

__global__ float *restrict const float *restrict attract_x

__global__ float *restrict const float *restrict const float *restrict attract_y

__global__ float *restrict const float *restrict const float *restrict const float *restrict repel_x

__global__ float *restrict const float *restrict const float *restrict const float *restrict const float *restrict repel_y

__global__ float *restrict const float *restrict const float *restrict const float *restrict const float *restrict float *restrict old_dx

__global__ float *restrict const float *restrict const float *restrict const float *restrict const float *restrict float *restrict float *restrict old_dy

__global__ float *restrict const float *restrict const float *restrict const float *restrict const float *restrict float *restrict float *restrict const float *restrict swinging

__global__ float *restrict const float *restrict const float *restrict const float *restrict const float *restrict float *restrict float *restrict const float *restrict const float speed

int32_t constexpr extract_transform_v_frontier_e_kernel_block_size = 512#

int32_t constexpr per_v_transform_reduce_e_kernel_block_size = 512#

int32_t constexpr per_v_transform_reduce_e_kernel_high_degree_reduce_any_block_size = 128#

int32_t constexpr sample_and_compute_local_nbr_indices_block_size = 256#

size_t constexpr compute_valid_local_nbr_count_inclusive_sum_local_degree_threshold = packed_bools_per_word() * size_t{4}#

size_t constexpr compute_valid_local_nbr_count_inclusive_sum_mid_local_degree_threshold = packed_bools_per_word() * static_cast<size_t>(raft::warp_size()) * size_t{4}#

size_t constexpr compute_valid_local_nbr_count_inclusive_sum_high_local_degree_threshold = packed_bools_per_word() * static_cast<size_t>(sample_and_compute_local_nbr_indices_block_size) * size_t{4}#

int32_t constexpr transform_v_frontier_e_kernel_block_size = 128#

int32_t constexpr transform_e_kernel_block_size = 512#

int32_t constexpr transform_reduce_e_kernel_block_size = 128#

int32_t constexpr transform_reduce_e_by_src_dst_key_kernel_block_size = 128#

int32_t constexpr update_v_frontier_from_outgoing_e_kernel_block_size = 512#

int32_t constexpr decompress_edge_partition_block_size = 1024#

double constexpr edge_partition_src_dst_property_values_kv_pair_fill_ratio_threshold = 0.1#

double constexpr hypersparse_threshold_ratio = 0.5#

size_t constexpr low_degree_threshold{raft::warp_size()}#

size_t constexpr mid_degree_threshold{1024}#

size_t constexpr num_sparse_segments_per_vertex_partition = {3}#

size_t cache_line_size = 128#

template<typename vertex_t, typename VertexValueOutputIterator> struct accumulate_vertex_property_t#

template<typename vertex_t, typename bias_t> struct biased_random_walk_e_bias_op_t#

template<typename vertex_t, typename weight_t> struct biased_sample_edges_op_t#

template<typename weight_t> struct biased_selector#

template<typename edge_t> struct call_const_true_e_op_t#

template<typename GraphViewType, typename key_t, typename EdgePartitionSrcValueInputWrapper, typename EdgePartitionDstValueInputWrapper, typename EdgePartitionEdgeValueInputWrapper, typename EdgeOp> struct call_e_op_t#

template<typename GraphViewType, typename key_t, typename EdgePartitionSrcValueInputWrapper, typename EdgePartitionDstValueInputWrapper, typename EdgePartitionEdgeValueInputWrapper, typename EdgeOp> struct call_e_op_with_key_t#

template<typename GraphViewType, typename EdgePartitionSrcValueInputWrapper, typename EdgePartitionDstValueInputWrapper, typename EdgeValueInputIterator, typename IntersectionOp, typename VertexPairIterator> struct call_intersection_op_t#

template<typename vertex_t, typename edge_value_t, typename e_op_result_t, typename EdgePartitionDeviceView, typename EdgeMajorValueMap, typename EdgePartitionMajorValueInputWrapper, typename EdgeMinorKeyValueMap, typename KeyAggregatedEdgeOp> struct call_key_aggregated_e_op_t#

template<typename PackedBoolIterator, typename T> struct check_bit_set_t#

template<typename vertex_t> struct check_edge_src_and_dst_t#

template<typename T> struct check_in_range_t#

template<typename key_t> struct check_invalid_bucket_idx_t#

template<typename edge_t, typename T> struct check_invalid_t#

template<typename T> struct check_out_of_range_t#

template<typename vertex_t, typename weight_t> struct cluster_update_op_t#

template<typename vertex_t, typename edge_t, typename weight_t, typename index_t> struct col_indx_extract_t#

template<typename vertex_t> struct compute_chunk_id_t#

template<typename vertex_t> struct compute_edge_partition_id_from_ext_edge_endpoints_t#

template<typename vertex_t> struct compute_edge_partition_id_from_int_edge_endpoints_t#

template<typename vertex_t> struct compute_gpu_id_from_ext_edge_endpoints_t#

template<typename edge_t> struct compute_gpu_id_from_ext_edge_id_t#

template<typename vertex_t> struct compute_gpu_id_from_ext_vertex_t#

template<typename vertex_t> struct compute_gpu_id_from_int_edge_endpoints_t#

template<typename vertex_t> struct compute_gpu_id_from_int_vertex_t#

template<typename GroupIdIterator> struct compute_group_id_count_pair_t#

template<typename vertex_t> struct compute_local_edge_partition_id_from_ext_edge_endpoints_t#

template<typename vertex_t> struct compute_local_edge_partition_id_from_int_edge_endpoints_t#

template<typename VertexPairIterator> struct compute_local_edge_partition_id_t#

struct compute_local_edge_partition_major_range_vertex_partition_id_t#

struct compute_local_edge_partition_minor_range_vertex_partition_id_t#

struct compute_local_nbr_count_per_rank_t#

template<typename value_t> struct compute_local_value_displacements_and_global_value_t#

template<typename vertex_t> struct compute_max#

template<typename vertex_t, bool is_multi_gpu> struct compute_max_distance#

template<typename TupleType, size_t I, size_t N> struct compute_thrust_tuple_element_sizes_impl#

template<typename TupleType, size_t I> struct compute_thrust_tuple_element_sizes_impl<TupleType, I, I>#

template<typename vertex_t> struct compute_vertex_partition_id_from_ext_vertex_t#

template<typename vertex_t> struct compute_vertex_partition_id_from_int_vertex_t#

template<typename key_t, typename vertex_t, typename src_value_t, typename dst_value_t, typename e_value_t, bool store_transposed> struct const_true_e_op_t#

template<typename GraphViewType, typename EdgeSrcValueInputWrapper, typename EdgeDstValueInputWrapper, typename EdgeValueInputWrapper, typename key_t> struct constant_e_bias_op_t#

template<typename value_t> struct convert_pair_to_quadruplet_t#

template<typename vertex_t, typename index_t> struct coo_convertor_t#

template<typename FirstElementToIdxMap, typename SecondElementToIdxMap, typename VertexPairIterator, typename vertex_t, typename edge_t, typename edge_partition_e_input_device_view_t, typename optional_property_buffer_view_t, typename optional_property_buffer_mutable_view_t, bool multi_gpu> struct copy_intersecting_nbrs_and_update_intersection_size_t#

template<typename weight_t> struct cosine_functor_t#

template<typename vertex_t, typename VertexValueInputIterator, typename VertexOp> struct count_if_call_v_op_t#

struct count_t#

template<typename vertex_t, typename weight_t> struct count_updown_moves_op_t#

template<typename edge_t> struct count_valids_t#

struct decrement_position#

template<typename InputIterator, typename OutputIterator, size_t I, size_t N> struct device_allgather_tuple_iterator_element_impl#

template<typename InputIterator, typename OutputIterator, size_t I> struct device_allgather_tuple_iterator_element_impl<InputIterator, OutputIterator, I, I>#

template<typename InputIterator, typename OutputIterator, size_t I, size_t N> struct device_allgatherv_tuple_iterator_element_impl#

template<typename InputIterator, typename OutputIterator, size_t I> struct device_allgatherv_tuple_iterator_element_impl<InputIterator, OutputIterator, I, I>#

template<typename InputIterator, typename OutputIterator, size_t I, size_t N> struct device_allreduce_tuple_iterator_element_impl#

template<typename InputIterator, typename OutputIterator, size_t I> struct device_allreduce_tuple_iterator_element_impl<InputIterator, OutputIterator, I, I>#

template<typename InputIterator, typename OutputIterator, size_t I, size_t N> struct device_bcast_tuple_iterator_element_impl#

template<typename InputIterator, typename OutputIterator, size_t I> struct device_bcast_tuple_iterator_element_impl<InputIterator, OutputIterator, I, I>#

template<typename InputIterator, typename OutputIterator, size_t I, size_t N> struct device_gatherv_tuple_iterator_element_impl#

template<typename InputIterator, typename OutputIterator, size_t I> struct device_gatherv_tuple_iterator_element_impl<InputIterator, OutputIterator, I, I>#

template<typename InputIterator, typename OutputIterator, size_t I, size_t N> struct device_irecv_tuple_iterator_element_impl#

template<typename InputIterator, typename OutputIterator, size_t I> struct device_irecv_tuple_iterator_element_impl<InputIterator, OutputIterator, I, I>#

template<typename InputIterator, typename OutputIterator, size_t I, size_t N> struct device_isend_tuple_iterator_element_impl#

template<typename InputIterator, typename OutputIterator, size_t I> struct device_isend_tuple_iterator_element_impl<InputIterator, OutputIterator, I, I>#

template<typename InputIterator, typename OutputIterator, size_t I, size_t N> struct device_multicast_sendrecv_tuple_iterator_element_impl#

template<typename InputIterator, typename OutputIterator, size_t I> struct device_multicast_sendrecv_tuple_iterator_element_impl<InputIterator, OutputIterator, I, I>#

template<typename InputIterator, typename OutputIterator, size_t I, size_t N> struct device_reduce_tuple_iterator_element_impl#

template<typename InputIterator, typename OutputIterator, size_t I> struct device_reduce_tuple_iterator_element_impl<InputIterator, OutputIterator, I, I>#

template<typename InputIterator, typename OutputIterator, size_t I, size_t N> struct device_sendrecv_tuple_iterator_element_impl#

template<typename InputIterator, typename OutputIterator, size_t I> struct device_sendrecv_tuple_iterator_element_impl<InputIterator, OutputIterator, I, I>#

template<typename T> struct divider_t#

class edge_endpoint_dummy_property_view_t#

template<typename vertex_t, typename T> class edge_major_property_t#

template<typename vertex_t, typename ValueIterator, typename value_t = typename thrust::iterator_traits<ValueIterator>::value_type> class edge_major_property_view_t#

template<typename vertex_t, typename T> class edge_minor_property_t#

template<typename vertex_t, typename ValueIterator, typename value_t = typename thrust::iterator_traits<ValueIterator>::value_type> class edge_minor_property_view_t#

template<typename key_t, typename vertex_t, typename src_value_t, typename dst_value_t, typename e_value_t, typename EdgeOp, typename Enable = void> struct edge_op_result_type#

template<typename key_t, typename vertex_t, typename src_value_t, typename dst_value_t, typename e_value_t, typename EdgeOp> is_invocable_v< EdgeOp, key_t, vertex_t, src_value_t, dst_value_t, e_value_t > > >

template<typename vertex_t, typename edge_t> class edge_partition_device_view_base_t#: Subclassed by cugraph::edge_partition_device_view_t< vertex_t, edge_t, multi_gpu, std::enable_if_t< multi_gpu > >, cugraph::edge_partition_device_view_t< vertex_t, edge_t, multi_gpu, std::enable_if_t<!multi_gpu > >

template<typename edge_t> class edge_partition_edge_dummy_property_device_view_t#

template<typename edge_t, typename ValueIterator, typename value_t = typename thrust::iterator_traits<ValueIterator>::value_type> class edge_partition_edge_property_device_view_t#

template<typename vertex_t> class edge_partition_endpoint_dummy_property_device_view_t#

template<typename vertex_t, typename ValueIterator, typename value_t = typename thrust::iterator_traits<ValueIterator>::value_type> class edge_partition_endpoint_property_device_view_t#

template<typename vertex_t, typename edge_t> class edge_partition_view_base_t#: Subclassed by cugraph::edge_partition_view_t< vertex_t, edge_t, multi_gpu, std::enable_if_t< multi_gpu > >, cugraph::edge_partition_view_t< vertex_t, edge_t, multi_gpu, std::enable_if_t<!multi_gpu > >

template<typename vertex_t, typename edge_t, typename EdgeIterator> struct extract_p_r_q_r#

template<typename vertex_t, typename edge_t, typename EdgeIterator> struct extract_q_r#

template<typename GraphViewType, typename EdgePartitionEdgeMaskWrapper, typename VertexIterator> struct find_nth_valid_nbr_idx_t#

template<typename vertex_t> struct find_unused_id_t#

template<typename vertex_t, typename edge_property_value_t, typename optional_property_buffer_view_t, typename optional_property_buffer_mutable_view_t> struct gatherv_indices_t#

template<typename vertex_t, typename edge_t> class graph_base_t#: Subclassed by cugraph::graph_t< vertex_t, edge_t, store_transposed, multi_gpu, std::enable_if_t< multi_gpu > >, cugraph::graph_t< vertex_t, edge_t, store_transposed, multi_gpu, std::enable_if_t<!multi_gpu > >, cugraph::graph_view_t< vertex_t, edge_t, store_transposed, multi_gpu, std::enable_if_t< multi_gpu > >, cugraph::graph_view_t< vertex_t, edge_t, store_transposed, multi_gpu, std::enable_if_t<!multi_gpu > >

template<typename vertex_t> struct hash_src_dst_pair#

template<typename TupleType, size_t I, size_t N> struct host_allreduce_tuple_scalar_element_impl#

template<typename TupleType, size_t I> struct host_allreduce_tuple_scalar_element_impl<TupleType, I, I>#

template<typename TupleType, size_t I, size_t N> struct host_reduce_tuple_scalar_element_impl#

template<typename TupleType, size_t I> struct host_reduce_tuple_scalar_element_impl<TupleType, I, I>#

template<typename VertexPairIterator> struct indirection_compare_less_t#

template<typename index_t, typename Iterator> struct indirection_if_idx_valid_t#

template<typename index_t, typename Iterator> struct indirection_t#

template<typename vertex_t, typename property_t> struct induced_subgraph_unweighted_edge_op#

template<typename vertex_t, typename weight_t, typename property_t> struct induced_subgraph_weighted_edge_op#

template<typename vertex_t, typename src_value_t, typename dst_value_t, typename IntersectionOp, typename Enable = void> struct intersection_op_result_type#

template<typename vertex_t, typename src_value_t, typename dst_value_t, typename IntersectionOp> device_span< vertex_t const > > > >

template<typename vertex_t> struct invalidate_if_not_first_in_run_t#

template<typename T> struct is_equal_t#

template<typename Iterator> struct is_first_in_run_t#

template<typename vertex_t> struct is_invalid_input_vertex_pair_t#

template<typename T> struct is_not_equal_t#

template<typename TupleType, size_t I, size_t N> struct is_thrust_tuple_of_arithemetic_impl#

template<typename TupleType, size_t I> struct is_thrust_tuple_of_arithemetic_impl<TupleType, I, I>#

template<typename vertex_t> struct is_valid_vertex_t#

template<typename Iterator, typename default_t, typename Enable = void> struct iterator_value_type_or_default_t#

template<typename Iterator, typename default_t> is_same_v< Iterator, void * > > >

template<typename Iterator, typename default_t> is_same_v< Iterator, void * > > >

template<typename weight_t> struct jaccard_functor_t#

template<typename vertex_t, typename weight_t> struct key_aggregated_edge_op_t#

template<typename KeyIterator> struct key_binary_search_contains_op_t#

template<typename ViewType> struct key_binary_search_store_device_view_t#

template<typename key_t> class key_binary_search_store_t#

template<typename KeyIterator> class key_binary_search_store_view_t#

template<typename ViewType> struct key_cuco_store_contains_device_view_t#

template<typename ViewType> struct key_cuco_store_insert_device_view_t#

template<typename key_t> class key_cuco_store_t#

template<typename key_t> class key_cuco_store_view_t#

template<typename key_type, typename KeyToGroupIdOp> struct key_group_id_less_t#

template<typename KeyIterator> struct kv_binary_search_contains_op_t#

template<typename KeyIterator, typename ValueIterator> struct kv_binary_search_find_op_t#

template<typename ViewType> struct kv_binary_search_store_device_view_t#

template<typename key_t, typename value_t> class kv_binary_search_store_t#

template<typename KeyIterator, typename ValueIterator> class kv_binary_search_store_view_t#

template<typename RefType, typename key_t, typename value_t> struct kv_cuco_insert_and_assign_t#

template<typename RefType, typename KeyIterator> struct kv_cuco_insert_and_increment_t#

template<typename RefType, typename KeyIterator, typename StencilIterator, typename PredOp> struct kv_cuco_insert_if_and_increment_t#

template<typename ViewType> struct kv_cuco_store_find_device_view_t#

template<typename key_t, typename value_t> class kv_cuco_store_t#

template<typename key_t, typename ValueIterator> class kv_cuco_store_view_t#

template<typename key_type, typename value_type, typename KeyToGroupIdOp> struct kv_pair_group_id_greater_equal_t#

template<typename key_type, typename value_type, typename KeyToGroupIdOp> struct kv_pair_group_id_less_t#

template<typename vertex_t, typename weight_t, typename cluster_value_t> struct leiden_key_aggregated_edge_op_t#

template<typename vertex_t, typename edge_t, typename return_type_t, bool multi_gpu, bool use_dcs> struct local_degree_op_t#

template<typename vertex_t, typename edge_t, typename return_type_t, bool multi_gpu, bool use_dcs, typename MaskIterator> struct local_degree_with_mask_op_t#

template<typename vertex_t> struct major_to_group_idx_t#

template<typename vertex_t, bool is_multi_gpu> struct map_index_to_path_offset#

template<typename EdgePartitionDstKeyInputWrapper> struct minor_to_key_t#

template<typename T> struct multiplier_t#

template<typename T> struct multiply_and_add_t#

template<typename vertex_t, typename bias_t, typename weight_t> struct node2vec_random_walk_e_bias_op_t#

template<typename vertex_t, typename weight_t> struct node2vec_sample_edges_op_t#

template<typename weight_t> struct node2vec_selector#

template<typename Iterator, typename Enable = void> struct optional_dataframe_buffer_iterator_value_type_t#

template<typename Iterator> is_same_v< Iterator, void * > > >

template<typename Iterator> is_same_v< Iterator, void * > > >

template<typename T> struct optional_dataframe_buffer_type#

template<typename weight_t> struct overlap_functor_t#

template<typename BoolIterator> struct pack_bool_t#

template<typename vertex_t> struct pair_to_binary_partition_id_t#

template<typename FirstElementToIdxMap, typename SecondElementToIdxMap, typename vertex_t, typename edge_t, bool multi_gpu> struct pick_min_degree_t#

template<typename vertex_t, typename edge_t, typename weight_t, typename random_engine_t = rrandom_gen_t<vertex_t, edge_t>, typename index_t = edge_t> struct random_walker_t#

Class abstracting the RW initialization, stepping, and stopping functionality The outline of the algorithm is as follows:

(1) vertex sets are coalesced into d_coalesced_v, weight sets are coalesced into d_coalesced_w; i.e., the 2 coalesced vectors are allocated to num_paths * max_depth, and num_paths * (max_depth -1), respectively (since each path has a number of edges equal one less than the number of vertices); d_coalesced_v is initialized for each i*max_depth entry (i=0,,,,num_paths-1) to the corresponding starting vertices; (2) d_sizes maintains the current size is for each path; Note that a path may end prematurely if it reaches a sink vertex; (3) d_crt_out_degs maintains the out-degree of each of the latest vertices in the path; i.e., if N(v) := set of destination vertices from v, then this vector stores |N(v)| for last v in each path; i.e., d_crt_out_degs[i] = out-degree( d_coalesced_v[i*max_depth + d_sizes[i]-1] ), for i in {0,…, num_paths-1}; (4) a set of num_paths floating point numbers between [0,1] are generated at each step; then they get translated into indices k in {0,…d_crt_out_degs[i]-1}; (5) the next vertex v is then picked as the k-th out-neighbor: next(v) = N(v)[k]; (6) d_sizes are incremented accordingly; i.e., for those paths whose corresponding last vertex has out-degree > 0; (7) then next(v) and corresponding weight of (v, next(v)) are stored at appropriate location in their corresponding coalesced vectors; (8) the client of this class (the random_walks() function) then repeats this process max_depth times or until all paths have reached sinks; i.e., d_crt_out_degs = {0, 0,…,0}, whichever comes first; (9) in the end some post-processing is done (stop()) to remove unused entries from the 2 coalesced vectors; (10) the triplet made of the 2 coalesced vectors and d_sizes is then returned;

template<typename edge_t> struct rebase_offset_t#

template<typename vertex_t, typename weight_t> struct reduce_op_t#

template<typename ReduceOp, typename T> struct reduce_with_init_t#

struct reorder_group_count_t#

template<typename vertex_t, typename weight_t> struct return_edge_weight_t#

struct return_edges_with_properties_e_op#

template<typename vertex_t, typename weight_t> struct return_one_t#

template<bool use_invalid_value> struct return_value_compute_offset_t#

template<typename vertex_t, typename edge_t, typename seed_t = uint64_t, typename real_t = float, typename index_t = edge_t> struct rrandom_gen_t#

template<typename vertex_t, typename bias_t> struct sample_edge_biases_op_t#

template<typename vertex_t, typename weight_t> struct sample_edges_op_t#

template<typename vertex_t, typename edge_t> struct search_and_increment_degree_t#

template<typename vertex_t, typename ValueIterator> struct segmented_fill_t#

template<typename vertex_t> struct sg_lookup_predecessor#

template<typename T> struct shift_left_t#

template<typename T> struct shift_right_t#

struct shuffle_index_compute_offset_t#

template<typename label_t> struct shuffle_to_output_comm_rank_t#

template<typename weight_t> struct sorensen_functor_t#

template<typename edge_t> struct strided_accumulate_t#

template<typename T> struct strided_sum_t#

template<typename vertex_t, typename edge_t, bool multi_gpu, typename result_t, typename TransformOp, typename ReduceOp, typename PredOp, typename ResultValueOutputIteratorOrWrapper> struct transform_and_atomic_reduce_t#

template<typename GraphViewType, typename KeyIterator, typename LocalNbrIdxIterator, typename EdgePartitionSrcValueInputWrapper, typename EdgePartitionDstValueInputWrapper, typename EdgePartitionEdgeValueInputWrapper, typename EdgeOp, typename T> struct transform_local_nbr_indices_t#

template<typename vertex_t, typename VertexValueInputIterator, typename VertexOp, typename T> struct transform_reduce_call_v_op_t#

template<typename key_t, typename payload_t, typename vertex_t, typename src_value_t, typename dst_value_t, typename e_value_t, typename EdgeOp> struct transform_reduce_v_frontier_call_e_op_t#

template<typename vertex_t, typename edge_value_t> struct tuple_to_minor_comm_rank_t#

template<typename input_t, typename output_t> struct typecast_t#

template<typename weight_t> struct uniform_selector#

template<bool check_edge_mask, typename GraphViewType, typename EdgePartitionSrcValueInputWrapper, typename EdgePartitionDstValueInputWrapper, typename EdgePartitionEdgeValueInputWrapper, typename EdgePartitionEdgeMaskWrapper, typename EdgeOp, typename EdgeValueOutputWrapper> struct update_e_value_t#

template<typename vertex_t, typename edge_t, typename EdgeIterator> struct update_edges_p_r_q_r_num_triangles#

template<typename InputKeyIterator, typename key_t> struct update_keep_flag_t#

template<typename vertex_t> struct update_paths#

template<typename vertex_t, typename edge_t, bool multi_gpu> struct update_rx_major_local_degree_t#

template<typename vertex_t, typename edge_t, typename edge_partition_e_input_device_view_t, typename optional_property_buffer_mutable_view_t, bool multi_gpu> struct update_rx_major_local_nbrs_t#

template<typename TupleType, size_t I, size_t N> struct update_tuple_from_vector_of_tuple_scalar_elements_impl#

template<typename TupleType, size_t I> struct update_tuple_from_vector_of_tuple_scalar_elements_impl<TupleType, I, I>#

template<typename vertex_t, typename VertexValueInputIterator, typename VertexValueOutputIterator, typename VertexOp, typename key_t, typename payload_t> struct update_v_frontier_call_v_op_t#

template<typename vertex_t, typename VertexValueInputIterator, typename VertexValueOutputIterator, typename VertexOp, typename key_t> struct update_v_frontier_call_v_op_t<vertex_t, VertexValueInputIterator, VertexValueOutputIterator, VertexOp, key_t, void>#

template<typename TupleType, size_t I, size_t N> struct update_vector_of_tuple_scalar_elements_from_tuple_impl#

template<typename TupleType, size_t I> struct update_vector_of_tuple_scalar_elements_from_tuple_impl<TupleType, I, I>#

template<typename value_type, typename ValueToGroupIdOp> struct value_group_id_greater_equal_t#

template<typename value_type, typename ValueToGroupIdOp> struct value_group_id_less_t#

template<typename vertex_t, bool multi_gpu> struct vertex_local_offset_t#

template<typename vertex_t> class vertex_partition_device_view_base_t#: Subclassed by cugraph::vertex_partition_device_view_t< vertex_t, multi_gpu, std::enable_if_t< multi_gpu > >, cugraph::vertex_partition_device_view_t< vertex_t, multi_gpu, std::enable_if_t<!multi_gpu > >

template<typename vertex_t> class vertex_partition_view_base_t#: Subclassed by cugraph::vertex_partition_view_t< vertex_t, multi_gpu, std::enable_if_t< multi_gpu > >, cugraph::vertex_partition_view_t< vertex_t, multi_gpu, std::enable_if_t<!multi_gpu > >

namespace original#

Typedefs

template<typename T> using device_vec_t = rmm::device_uvector<T>#

template<typename T> using device_v_it = typename device_vec_t<T>::iterator#

Functions

template<typename value_t> value_t *raw_ptr(device_vec_t<value_t> &dv)#

template<typename value_t> value_t const *raw_const_ptr(device_vec_t<value_t> const &dv)#

template<typename value_t> value_t const *raw_const_ptr(device_const_vector_view<value_t> &dv)#

template<typename vertex_t, typename edge_t, typename weight_t, typename real_t> struct biased_selector_t#

struct sampler_t#

template<typename seed_t> struct clock_seeding_t#

template<typename value_t, typename index_t = size_t> struct device_const_vector_view#

template<typename seed_t> struct fixed_seeding_t#

struct horizontal_traversal_t#

template<typename vertex_t, typename edge_t, typename weight_t, typename real_t> struct node2vec_selector_t#

struct sampler_t#

template<typename vertex_t, typename edge_t, typename weight_t, typename real_t> struct uniform_selector_t#

struct sampler_t#

struct vertical_traversal_t#

namespace ext_raft#

Wrapper function for Nvgraph balanced cut clustering.

Throws cugraph::logic_error:

when an error occurs.

Template Parameters:

VT – Type of vertex identifiers. Supported value : int (signed, 32-bit)
ET – Type of edge identifiers. Supported value : int (signed, 32-bit)
WT – Type of edge weights. Supported values : float or double.

Param graph:

[in] input graph object (CSR)

Param num_clusters:

[in] The desired number of clusters

Param num_eigen_vects:

[in] The number of eigenvectors to use

Param evs_tolerance:

[in] The tolerance to use for the eigenvalue solver

Param evs_max_iter:

[in] The maximum number of iterations of the eigenvalue solver

Param kmean_tolerance:

[in] The tolerance to use for the kmeans solver

Param kmean_max_iter:

[in] The maximum number of iteration of the k-means solver

Param clustering:

[out] Pointer to device memory where the resulting clustering will be stored

Functions

template<typename VT, typename ET, typename WT> void balancedCutClustering(legacy::GraphCSRView<VT, ET, WT> const &graph, VT num_clusters, VT num_eigen_vects, WT evs_tolerance, int evs_max_iter, WT kmean_tolerance, int kmean_max_iter, VT *clustering)#

template void balancedCutClustering< int, int, float > (legacy::GraphCSRView< int, int, float > const &, int, int, float, int, float, int, int *)

template void balancedCutClustering< int, int, double > (legacy::GraphCSRView< int, int, double > const &, int, int, double, int, double, int, int *)

template void spectralModularityMaximization< int, int, float > (legacy::GraphCSRView< int, int, float > const &, int, int, float, int, float, int, int *)

template void spectralModularityMaximization< int, int, double > (legacy::GraphCSRView< int, int, double > const &, int, int, double, int, double, int, int *)

template void analyzeClustering_modularity< int, int, float > (legacy::GraphCSRView< int, int, float > const &, int, int const *, float *)

template void analyzeClustering_modularity< int, int, double > (legacy::GraphCSRView< int, int, double > const &, int, int const *, double *)

template void analyzeClustering_edge_cut< int, int, float > (legacy::GraphCSRView< int, int, float > const &, int, int const *, float *)

template void analyzeClustering_edge_cut< int, int, double > (legacy::GraphCSRView< int, int, double > const &, int, int const *, double *)

template void analyzeClustering_ratio_cut< int, int, float > (legacy::GraphCSRView< int, int, float > const &, int, int const *, float *)

template void analyzeClustering_ratio_cut< int, int, double > (legacy::GraphCSRView< int, int, double > const &, int, int const *, double *)

namespace detail#

Functions

template<typename vertex_t, typename edge_t, typename weight_t> void balancedCutClustering_impl(legacy::GraphCSRView<vertex_t, edge_t, weight_t> const &graph, vertex_t n_clusters, vertex_t n_eig_vects, weight_t evs_tolerance, int evs_max_iter, weight_t kmean_tolerance, int kmean_max_iter, vertex_t *clustering, weight_t *eig_vals, weight_t *eig_vects)#

template<typename vertex_t, typename edge_t, typename weight_t> void spectralModularityMaximization_impl(legacy::GraphCSRView<vertex_t, edge_t, weight_t> const &graph, vertex_t n_clusters, vertex_t n_eig_vects, weight_t evs_tolerance, int evs_max_iter, weight_t kmean_tolerance, int kmean_max_iter, vertex_t *clustering, weight_t *eig_vals, weight_t *eig_vects)#

template<typename vertex_t, typename edge_t, typename weight_t> void analyzeModularityClustering_impl(legacy::GraphCSRView<vertex_t, edge_t, weight_t> const &graph, int n_clusters, vertex_t const *clustering, weight_t *modularity)#

template<typename vertex_t, typename edge_t, typename weight_t> void analyzeBalancedCut_impl(legacy::GraphCSRView<vertex_t, edge_t, weight_t> const &graph, vertex_t n_clusters, vertex_t const *clustering, weight_t *edgeCut, weight_t *ratioCut)#

namespace internals#

class Callback#: Subclassed by cugraph::internals::GraphBasedDimRedCallback

class GraphBasedDimRedCallback : public cugraph::internals::Callback #

namespace legacy#

Enums

enum class PropType#

Values:

enumerator PROP_UNDEF#

enumerator PROP_FALSE#

enumerator PROP_TRUE#

enum class DegreeDirection#

Values:

enumerator IN_PLUS_OUT#

enumerator IN#

Compute sum of in and out degree

enumerator OUT#

Compute in degree

enumerator DEGREE_DIRECTION_COUNT#

Compute out degree

template<typename vertex_t, typename edge_t, typename weight_t> class GraphCompressedSparseBase#

#include <graph.hpp>

Base class for constructted graphs stored in CSR (Compressed Sparse Row) format or CSC (Compressed Sparse Column) format.

Template Parameters:

vertex_t – Type of vertex id
edge_t – Type of edge id
weight_t – Type of weight

Subclassed by cugraph::legacy::GraphCSR< vertex_t, edge_t, weight_t >

Public Functions

inline GraphCompressedSparseBase(vertex_t number_of_vertices, edge_t number_of_edges, bool has_data, cudaStream_t stream, rmm::device_async_resource_ref mr)#

Take ownership of the provided graph arrays in CSR/CSC format.

Parameters:

number_of_vertices – The number of vertices in the graph
number_of_edges – The number of edges in the graph
has_data – Wiether or not the class has data, default = False
stream – Specify the cudaStream, default = null
mr – Specify the memory resource

template<typename vertex_t, typename edge_t, typename weight_t> class GraphCompressedSparseBaseView : public cugraph::legacy::GraphViewBase<vertex_t, edge_t, weight_t>#

#include <graph.hpp>

Base class for graph stored in CSR (Compressed Sparse Row) format or CSC (Compressed Sparse Column) format.

Template Parameters:

vertex_t – Type of vertex id
edge_t – Type of edge id
weight_t – Type of weight

Subclassed by cugraph::legacy::GraphCSRView< vertex_t, edge_t, weight_t >

Public Functions

void get_source_indices(vertex_t *src_indices) const#

Fill the identifiers in the array with the source vertex identifiers.

Parameters:: src_indices – [out] Pointer to device memory to store the source vertex identifiers

void degree(edge_t *degree, DegreeDirection direction) const#

Computes degree(in, out, in+out) of all the nodes of a Graph.

Throws:

cugraph::logic_error – when an error occurs.

Parameters:

degree – [out] Device array of size V (V is number of vertices) initialized to zeros. Will contain the computed degree of every vertex.
direction – [in] Integer value indicating type of degree calculation 0 : in+out degree 1 : in-degree 2 : out-degree

inline GraphCompressedSparseBaseView(edge_t *offsets, vertex_t *indices, weight_t *edge_data, vertex_t number_of_vertices, edge_t number_of_edges)#

Wrap existing arrays representing adjacency lists in a Graph. GraphCSRView does not own the memory used to represent this graph. This function does not allocate memory.

Parameters:

offsets – This array of size V+1 (V is number of vertices) contains the offset of adjacency lists of every vertex. Offsets must be in the range [0, E] (number of edges).
indices – This array of size E contains the index of the destination for each edge. Indices must be in the range [0, V-1].
edge_data – This array of size E (number of edges) contains the weight for each edge. This array can be null in which case the graph is considered unweighted.
number_of_vertices – The number of vertices in the graph
number_of_edges – The number of edges in the graph

Public Members

edge_t *offsets = {nullptr}#: CSR offsets.

vertex_t *indices = {nullptr}#: CSR indices.

template<typename vertex_t, typename edge_t, typename weight_t> class GraphCOO#

#include <graph.hpp>

A constructed graph stored in COO (COOrdinate) format.

This class will src_indices and dst_indicies (until moved)

Template Parameters:

vertex_t – Type of vertex id
edge_t – Type of edge id
weight_t – Type of weight

Public Functions

inline GraphCOO(vertex_t number_of_vertices, edge_t number_of_edges, bool has_data = false, cudaStream_t stream = nullptr, rmm::device_async_resource_ref mr = rmm::mr::get_current_device_resource())#

Take ownership of the provided graph arrays in COO format.

Parameters:

number_of_vertices – The number of vertices in the graph
number_of_edges – The number of edges in the graph
has_data – Whether or not the class has data, default = False
stream – Specify the cudaStream, default = null
mr – Specify the memory resource

template<typename vertex_t, typename edge_t, typename weight_t> struct GraphCOOContents#

#include <graph.hpp>

TODO : Change this Take ownership of the provided graph arrays in COO format.

Param source_indices:: This array of size E (number of edges) contains the index of the source for each edge. Indices must be in the range [0, V-1].
Param destination_indices:: This array of size E (number of edges) contains the index of the destination for each edge. Indices must be in the range [0, V-1].
Param edge_data:: This array size E (number of edges) contains the weight for each edge. This array can be null in which case the graph is considered unweighted.
Param number_of_vertices:: The number of vertices in the graph
Param number_of_edges:: The number of edges in the graph

template<typename vertex_t, typename edge_t, typename weight_t> class GraphCOOView : public cugraph::legacy::GraphViewBase<vertex_t, edge_t, weight_t>#

#include <graph.hpp>

A graph stored in COO (COOrdinate) format.

Template Parameters:

vertex_t – Type of vertex id
edge_t – Type of edge id
weight_t – Type of weight

Public Functions

void degree(edge_t *degree, DegreeDirection direction) const#

Computes degree(in, out, in+out) of all the nodes of a Graph.

Throws:

cugraph::logic_error – when an error occurs.

Parameters:

degree – [out] Device array of size V (V is number of vertices) initialized to zeros. Will contain the computed degree of every vertex.
direction – [in] IN_PLUS_OUT, IN or OUT

inline GraphCOOView()#: Default constructor.

inline GraphCOOView(vertex_t *src_indices, vertex_t *dst_indices, weight_t *edge_data, vertex_t number_of_vertices, edge_t number_of_edges)#

Wrap existing arrays representing an edge list in a Graph.

        GraphCOOView does not own the memory used to represent this

graph. This function does not allocate memory.

Parameters:

source_indices – This array of size E (number of edges) contains the index of the source for each edge. Indices must be in the range [0, V-1].
destination_indices – This array of size E (number of edges) contains the index of the destination for each edge. Indices must be in the range [0, V-1].
edge_data – This array size E (number of edges) contains the weight for each edge. This array can be null in which case the graph is considered unweighted.
number_of_vertices – The number of vertices in the graph
number_of_edges – The number of edges in the graph

Public Members

vertex_t *src_indices = {nullptr}#: rowInd

vertex_t *dst_indices = {nullptr}#: colInd

template<typename vertex_t, typename edge_t, typename weight_t> class GraphCSR : public cugraph::legacy::GraphCompressedSparseBase<vertex_t, edge_t, weight_t>#

#include <graph.hpp>

A constructed graph stored in CSR (Compressed Sparse Row) format.

Template Parameters:

vertex_t – Type of vertex id
edge_t – Type of edge id
weight_t – Type of weight

Public Functions

inline GraphCSR()#: Default constructor.

inline GraphCSR(vertex_t number_of_vertices_, edge_t number_of_edges_, bool has_data_ = false, cudaStream_t stream = nullptr, rmm::device_async_resource_ref mr = rmm::mr::get_current_device_resource())#

Take ownership of the provided graph arrays in CSR format.

Parameters:

number_of_vertices – The number of vertices in the graph
number_of_edges – The number of edges in the graph
has_data – Wiether or not the class has data, default = False
stream – Specify the cudaStream, default = null
mr – Specify the memory resource

template<typename vertex_t, typename edge_t, typename weight_t> class GraphCSRView : public cugraph::legacy::GraphCompressedSparseBaseView<vertex_t, edge_t, weight_t>#

#include <graph.hpp>

A graph stored in CSR (Compressed Sparse Row) format.

Template Parameters:

vertex_t – Type of vertex id
edge_t – Type of edge id
weight_t – Type of weight

Public Functions

inline GraphCSRView()#: Default constructor.

inline GraphCSRView(edge_t *offsets, vertex_t *indices, weight_t *edge_data, vertex_t number_of_vertices, edge_t number_of_edges)#

Wrap existing arrays representing adjacency lists in a Graph. GraphCSRView does not own the memory used to represent this graph. This function does not allocate memory.

Parameters:

offsets – This array of size V+1 (V is number of vertices) contains the offset of adjacency lists of every vertex. Offsets must be in the range [0, E] (number of edges).
indices – This array of size E contains the index of the destination for each edge. Indices must be in the range [0, V-1].
edge_data – This array of size E (number of edges) contains the weight for each edge. This array can be null in which case the graph is considered unweighted.
number_of_vertices – The number of vertices in the graph
number_of_edges – The number of edges in the graph

struct GraphProperties#

template<typename vertex_t, typename edge_t, typename weight_t> struct GraphSparseContents#

template<typename vertex_t, typename edge_t, typename weight_t> class GraphViewBase#

#include <graph.hpp>

Base class graphs, all but vertices and edges.

Template Parameters:

vertex_t – Type of vertex id
edge_t – Type of edge id
weight_t – Type of weight

Subclassed by cugraph::legacy::GraphCOOView< vertex_t, edge_t, weight_t >, cugraph::legacy::GraphCompressedSparseBaseView< vertex_t, edge_t, weight_t >

Public Functions

void get_vertex_identifiers(vertex_t *identifiers) const#

Fill the identifiers array with the vertex identifiers.

Parameters:: identifiers – [out] Pointer to device memory to store the vertex identifiers

Public Members

weight_t *edge_data#: edge weight

template<typename edge_t> struct invalid_edge_id : public cugraph::legacy::invalid_idx<edge_t>#

template<typename T, typename Enable = void> struct invalid_idx#

template<typename T> value > > : public std::integral_constant< T, -1 >

template<typename T> value > > : public std::integral_constant< T, std::numeric_limits< T >::max()>

template<typename vertex_t> struct invalid_vertex_id : public cugraph::legacy::invalid_idx<vertex_t>#

namespace ops#

namespace graph#

Unnamed Group

void get_sampling_index(int32_t *index, raft::random::RngState &rng, const int32_t *sizes, int32_t n_sizes, int32_t sample_size, bool replace, cudaStream_t stream)#

Generate indexes given population sizes and a sample size, with or without replacement.

Parameters:

index – [out] The (dense) index matrix. [on device] [dim = n_sizes x sample_size] In case replace is false, this may contain ops::graph::INVALID_ID<IdxT> if no index could be generated.
rng – [inout] RAFT RngState state object
sizes – [in] Input array of population sizes [on device] [len = n_sizes]
n_sizes – [in] number of sizes to sample from.
sample_size – [in] max number of indexes to be sampled per element in sizes. Assumed to be <= 384 at the moment.
replace – [in] If true, sample with replacement, otherwise without replacement.
stream – [in] cuda stream

void get_sampling_index(int64_t *index, raft::random::RngState &rng, const int64_t *sizes, int64_t n_sizes, int32_t sample_size, bool replace, cudaStream_t stream)#

Typedefs

template<typename IdxT> using smem_algo_r_t = utils::smem_unit_simple_t<1, IdxT>#

Functions

template<typename IdxT, typename GenT> CUGRAPH_OPS_KERNEL void index_replace_kernel (raft::random::DeviceState< GenT > rng_state, IdxT *index, const IdxT *sizes, IdxT n_sizes, int sample_size)

template<typename IdxT> void get_sampling_index_replace(IdxT *index, raft::random::RngState &rng, const IdxT *sizes, IdxT n_sizes, int32_t sample_size, cudaStream_t stream)#

template<int N_WARPS, typename IdxT, typename GenT> CUGRAPH_OPS_KERNEL void index_algo_r_kernel (raft::random::DeviceState< GenT > rng_state, IdxT *index, const IdxT *sizes, IdxT n_sizes, int sample_size)

template<typename IdxT> void get_sampling_index_reservoir(IdxT *index, raft::random::RngState &rng, const IdxT *sizes, IdxT n_sizes, int32_t sample_size, cudaStream_t stream)#

template<typename IdxT> void get_sampling_index_impl(IdxT *index, raft::random::RngState &rng, const IdxT *sizes, IdxT n_sizes, int32_t sample_size, bool replace, cudaStream_t stream)#

namespace mtmg#

Typedefs

template<typename edge_t, typename value_iterator_t> using edge_property_view_t = detail::device_shared_wrapper_t<cugraph::edge_property_view_t<edge_t, value_iterator_t>>#: Edge property object for each GPU.

template<typename vertex_t> using renumber_map_view_t = detail::device_shared_device_span_t<vertex_t const>#: An MTMG device span for storing a renumber map.

Functions

template<typename vertex_t, typename edge_t, typename weight_t, typename edge_id_t, typename edge_type_t, bool store_transposed, bool multi_gpu> void create_graph_from_edgelist(handle_t const &handle, cugraph::mtmg::edgelist_t<vertex_t, weight_t, edge_id_t, edge_type_t> &edgelist, graph_properties_t graph_properties, bool renumber, cugraph::mtmg::graph_t<vertex_t, edge_t, store_transposed, multi_gpu> &graph, std::optional<cugraph::mtmg::edge_property_t<cugraph::mtmg::graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu>, weight_t>> &edge_weights, std::optional<cugraph::mtmg::edge_property_t<cugraph::mtmg::graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu>, edge_id_t>> &edge_ids, std::optional<cugraph::mtmg::edge_property_t<cugraph::mtmg::graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu>, edge_type_t>> &edge_types, std::optional<cugraph::mtmg::renumber_map_t<vertex_t>> &renumber_map, bool do_expensive_check = false)#

Create an MTMG graph from an edgelist.

Parameters:

handle – [in] Resource handle
edgelist – [in] Edgelist
graph_properties – [in] Graph properties
renumber – [in] If true, renumber graph (must be true for MG)
graph – [out] MTMG graph is stored here
edge_weights – [out] MTMG edge weights is stored here
edge_ids – [out] MTMG edge ids is stored here
edge_types – [out] MTMG edge types is stored here
renumber_map – [in] MTMG renumber_map is stored here
do_expensive_check – [in] A flag to run expensive checks for input arguments (if set to true).

template<typename graph_view_t, typename property_t> class edge_property_t : public cugraph::mtmg::detail::device_shared_wrapper_t<cugraph::edge_property_t<graph_view_t::wrapped_t, property_t>>#

#include <edge_property.hpp>

Edge property object for each GPU.

Public Functions

inline auto view()#: Return a edge_property_view_t (read only)

template<typename vertex_t, typename weight_t, typename edge_t, typename edge_type_t> class edgelist_t : public cugraph::mtmg::detail::device_shared_wrapper_t<detail::per_device_edgelist_t<vertex_t, weight_t, edge_t, edge_type_t>>#

#include <edgelist.hpp>

Edgelist object for each GPU.

Public Functions

inline void set(handle_t const &handle, size_t device_buffer_size, bool use_weight, bool use_edge_id, bool use_edge_type)#: Create a per_device_edgelist for this GPU.

inline void finalize_buffer(handle_t const &handle)#: Stop inserting edges into this edgelist so we can use the edges.

inline void consolidate_and_shuffle(cugraph::mtmg::handle_t const &handle, bool store_transposed)#: Consolidate for the edgelist edges into a single edgelist and then shuffle across GPUs.

template<typename vertex_t, typename edge_t, bool store_transposed, bool multi_gpu> class graph_t : public cugraph::mtmg::detail::device_shared_wrapper_t<cugraph::graph_t<vertex_t, edge_t, store_transposed, multi_gpu>>#

#include <graph.hpp>

Graph object for each GPU.

Public Functions

inline auto view()#: Create an MTMG graph view (read only)

template<typename vertex_t, typename edge_t, bool store_transposed, bool multi_gpu> class graph_view_t : public cugraph::mtmg::detail::device_shared_wrapper_t<cugraph::graph_view_t<vertex_t, edge_t, store_transposed, multi_gpu>>#

#include <graph_view.hpp>

Graph view for each GPU.

Public Functions

inline vertex_partition_view_t<vertex_t, multi_gpu> get_vertex_partition_view(cugraph::mtmg::handle_t const &handle) const#: Get the vertex_partition_view for this graph.

inline std::vector<vertex_t> get_vertex_partition_range_lasts(cugraph::mtmg::handle_t const &handle) const#: Get the vertex_partition_view for this graph.

class handle_t#

#include <handle.hpp>

Resource handler.

Multi-threaded resource handler. Every GPU gets a raft::handle object that provides access to the GPU resources. In a multi-threaded environment multiple threads will share a particular GPU. Following the MPI model, each thread will be assigned to a thread rank.

Public Functions

inline handle_t(raft::handle_t const &raft_handle, int thread_rank, rmm::cuda_device_id device_id)#

Constructor.

Parameters:

raft_handle – Raft handle for the resources
thread_rank – Rank for this thread
device_id – Device id for the device this handle operates on

inline raft::handle_t const &raft_handle() const#

Get the raft handle.

Returns:: const reference to a raft handle

inline rmm::cuda_stream_view get_stream() const#

Get cuda stream.

Returns:: cuda stream

inline void sync_stream(rmm::cuda_stream_view stream) const#

Sync on the cuda stream.

Parameters:: stream – Which stream to synchronize (defaults to the stream for this handle)

inline void sync_stream() const#: Sync on the cuda stream for this handle.

inline void sync_stream_pool() const#: Sync all streams in the stream pool.

inline rmm::exec_policy get_thrust_policy(rmm::cuda_stream_view stream) const#

get thrust policy for the stream

Parameters:: stream – Which stream to use for this thrust call
Returns:: exec policy using the current stream

inline rmm::exec_policy get_thrust_policy() const#

get thrust policy for the stream for this handle

Returns:: exec policy using the current stream

inline int get_thread_rank() const#

Get thread rank.

Returns:: thread rank

inline int get_size() const#

Get number of gpus.

Returns:: number of gpus

inline int get_rank() const#

Get gpu rank.

Returns:: gpu rank

class instance_manager_t#

#include <instance_manager.hpp>

Manages a subset of the cluster for a set of graph computations.

Public Functions

inline instance_manager_t(std::vector<std::unique_ptr<raft::handle_t>> &&handles, std::vector<std::unique_ptr<ncclComm_t>> &&nccl_comms, std::vector<rmm::cuda_device_id> &&device_ids)#

Constructor.

Parameters:: handles – Vector of RAFT handles, one for each device on this node

inline handle_t get_handle()#

Get handle.

The instance manager will construct a handle appropriate for the thread making the request. Threads will be assigned to GPUs in a round-robin fashion to spread requesting threads around the GPU resources.

This function is CPU thread-safe.

Returns:: a handle for this thread.

inline handle_t get_handle(int gpu_id, int thread_id = 0)#

Get handle for particular GPU.

Return a handle for a particular GPU. In a context-free environment this lets the caller reconstitute the handle for the right host thread. It does assume that the caller will not allow multiple threads to concurrently use a gpu_id/thread_id pair.

Returns:: a handle for this thread.

inline void reset_threads()#

Reset the thread counter.

After a parallel activity is completed, we need to reset the thread counter so that future threads will round robin around the GPUs properly.

inline int get_local_gpu_count()#: Number of local GPUs in the instance.

template<typename vertex_t, typename weight_t, typename edge_t, typename edge_type_t> class per_thread_edgelist_t#

#include <per_thread_edgelist.hpp>

Supports creating an edgelist from individual host threads.

A cugraph edgelist needs to contain all of the edges necessary to create the graph stored in GPU memory (distributed across multiple GPUs in a multi-GPU configuration).

This class provides a mechanism for populating the edgelist object from independent CPU threads.

Calls to the append() method will take edges (in CPU host memory) and append them to a local buffer. As the local buffer fills, the buffer will be sent to GPU memory using the flush() method. This allows the CPU to GPU transfers to be larger (and consequently more efficient).

Public Functions

inline per_thread_edgelist_t(detail::per_device_edgelist_t<vertex_t, weight_t, edge_t, edge_type_t> &edgelist, size_t thread_buffer_size)#

Only constructor.

Parameters:

edgelist – The edge list this thread_edgelist_t should be associated with
thread_buffer_size – Size of the local buffer for accumulating edges on the CPU

inline void append(vertex_t src, vertex_t dst, std::optional<weight_t> wgt, std::optional<edge_t> edge_id, std::optional<edge_type_t> edge_type, rmm::cuda_stream_view stream_view)#

Append an edge to the edge list.

Parameters:

src – Source vertex id
dst – Destination vertex id
wgt – Edge weight
edge_id – Edge id
edge_type – Edge type
stream_view – The cuda stream

inline void append(raft::host_span<vertex_t const> src, raft::host_span<vertex_t const> dst, std::optional<raft::host_span<weight_t const>> wgt, std::optional<raft::host_span<edge_t const>> edge_id, std::optional<raft::host_span<edge_type_t const>> edge_type, rmm::cuda_stream_view stream_view)#

Append a list of edges to the edge list.

Parameters:

src – Source vertex id
dst – Destination vertex id
wgt – Edge weight
edge_id – Edge id
edge_type – Edge type
stream_view – The cuda stream

inline void flush(rmm::cuda_stream_view stream_view, bool sync = false)#

Flush thread data from host to GPU memory.

Parameters:

stream_view – The cuda stream
sync – If true, synchronize the asynchronous copy of data; defaults to false.

template<typename vertex_t> class renumber_map_t : public cugraph::mtmg::detail::device_shared_device_vector_t<vertex_t>#

#include <renumber_map.hpp>

An MTMG device vector for storing a renumber map.

Public Functions

inline auto view()#: Return a view (read only) of the renumber map.

class resource_manager_t#

#include <resource_manager.hpp>

Class for managing local and remote GPU resources for use in multi-threaded multi-GPU interface.

Each process in a multi-GPU configuration should have an instance of this class. The resource manager object should be configured by calling register_local_gpu (or register_remote_gpu once we support a multi-node configuration) to allocate resources that can be used in the mtmg space.

Each GPU in the cluster should be given a unique global rank, an integer that will be used to reference the GPU within the resource manager. It is recommended that the GPUs be numbered sequentially from 0, although this is not required.

When we want to execute some graph computations, we need to create an instance for execution. Based on how big a subset of the desired compute resources is desired, we can allocate some number of GPUs to the problem (up to the total set of managed resources).

The returned instance can be used to create a graph, execute one or more algorithms, etc. Once we are done the caller can delete the instance.

The caller is assumed to be responsible for scheduling use of the resources.

For our first release, we will only consider a single node multi-GPU configuration, so the remote GPU methods are currently disabled via ifdef.

Public Functions

inline resource_manager_t()#: Default constructor.

inline void register_local_gpu(int global_rank, rmm::cuda_device_id local_device_id)#

add a local GPU to the resource manager.

Parameters:

global_rank – The global rank to assign to the local GPU
local_device_id – The local device_id corresponding to this rank

inline void register_remote_gpu(int global_rank)#

add a remote GPU to the resource manager.

Parameters:: global_rank – The global rank to assign to the remote GPU

inline std::unique_ptr<instance_manager_t> create_instance_manager(std::vector<int> ranks_to_include, ncclUniqueId instance_manager_id, size_t n_streams = 16) const#

Create an instance using a subset of the registered resources.

The selected set of resources will be configured as an instance manager. If @ranks_to_include is a proper subset of the registered resources, ranks will be renumbered into the range [0, ranks_to_use.size()), making it a proper configuration.

Parameters:

ranks_to_use – a vector containing the ranks to include in the instance. Must be a subset of the entire set of available ranks.
instance_manager_id – a ncclUniqueId that is shared by all processes participating in this instance. All processes must use the same ID in this call, it is up to the calling code to share this ID properly before the call.
n_streams – The number of streams to create in a stream pool for each GPU. Defaults to 16.

Returns:

unique pointer to instance manager

inline std::vector<int> registered_ranks() const#

Get a list of all of the currently registered ranks.

Returns:: A copy of the list of ranks.

template<typename vertex_t, typename result_t> class vertex_pair_result_t : public cugraph::mtmg::detail::device_shared_device_vector_tuple_t<vertex_t, vertex_t, result_t>#

#include <vertex_pair_result.hpp>

An MTMG device vector for storing vertex results.

Public Functions

inline auto view()#: Create a vertex result view (read only)

template<typename vertex_t, typename result_t> class vertex_pair_result_view_t : public cugraph::mtmg::detail::device_shared_wrapper_t<vertex_t, vertex_t, result_t>#

#include <vertex_pair_result_view.hpp>

An MTMG device span for referencing a vertex pair result.

Public Functions

template<bool multi_gpu> std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<vertex_t>, rmm::device_uvector<result_t>> gather(handle_t const &handle, raft::device_span<vertex_t const> vertices, std::vector<vertex_t> const &vertex_partition_range_lasts, cugraph::vertex_partition_view_t<vertex_t, multi_gpu> vertex_partition_view, std::optional<cugraph::mtmg::renumber_map_view_t<vertex_t>> &renumber_map_view)#: Gather results from specified vertices.

template<typename result_t> class vertex_result_t : public cugraph::mtmg::detail::device_shared_device_vector_t<result_t>#

#include <vertex_result.hpp>

An MTMG device vector for storing vertex results.

Public Functions

inline auto view()#: Create a vertex result view (read only)

template<typename result_t> class vertex_result_view_t : public cugraph::mtmg::detail::device_shared_wrapper_t<result_t const>#

#include <vertex_result_view.hpp>

An MTMG device span for referencing a vertex result.

Public Functions

template<typename vertex_t, bool multi_gpu> rmm::device_uvector<result_t> gather(handle_t const &handle, raft::device_span<vertex_t const> vertices, std::vector<vertex_t> const &vertex_partition_range_lasts, cugraph::vertex_partition_view_t<vertex_t, multi_gpu> vertex_partition_view, std::optional<cugraph::mtmg::renumber_map_view_t<vertex_t>> &renumber_map_view, result_t default_value = 0)#: Gather results from specified vertices into a device vector.

namespace detail#

Typedefs

template<typename T> using device_shared_device_span_t = device_shared_wrapper_t<raft::device_span<T>>#: Manage device spans on each GPU.

template<typename ...Ts> using device_shared_device_span_tuple_t = device_shared_wrapper_t<std::tuple<raft::device_span<Ts>...>>#: Manage a tuple of device spans on each GPU.

template<typename T> class device_shared_device_vector_t : public cugraph::mtmg::detail::device_shared_wrapper_t<rmm::device_uvector<T>>#

#include <device_shared_device_vector.hpp>

Manage a device vector on each GPU.

Uses the device_shared_wrapper to manage an rmm::device_uvector<T> on each GPU.

Public Functions

inline auto view()#: Create a device_shared_device_span (read only view)

template<typename ...Ts> class device_shared_device_vector_tuple_t : public cugraph::mtmg::detail::device_shared_wrapper_t<std::tuple<rmm::device_uvector<Ts>...>>#

#include <device_shared_device_vector_tuple.hpp>

Manage a tuple of device vector on each GPU.

Uses the device_shared_wrapper to manage a tuple of rmm::device_uvector instances on each GPU.

Public Functions

inline auto view()#: Create a device_shared_device_span (read only view)

template<typename T> class device_shared_wrapper_t#

#include <device_shared_wrapper.hpp>

Wrap an object to be available for each GPU.

In the MTMG environment we need the ability to manage a collection of objects that are associated with a particular GPU, and fetch the objects from an arbitrary GPU thread. This object will wrap any object and allow it to be accessed from different threads.

Subclassed by cugraph::mtmg::vertex_pair_result_view_t< vertex_t, result_t >, cugraph::mtmg::vertex_result_view_t< result_t >

Public Functions

inline void set(cugraph::mtmg::handle_t const &handle, wrapped_t &&obj)#

Move a wrapped object into the wrapper for this thread.

Parameters:

handle – Handle is used to identify the GPU we associated this object with
obj – Wrapped object

inline void set(int local_rank, wrapped_t &&obj)#

Move a wrapped object into the wrapper for this thread.

Parameters:

local_rank – Identify which GPU to associated this object with
obj – Wrapped object

inline wrapped_t &get(cugraph::mtmg::handle_t const &handle)#

Get reference to an object for a particular thread.

Parameters:: handle – Handle is used to identify the GPU we associated this object with
Returns:: Reference to the wrapped object

inline wrapped_t const &get(cugraph::mtmg::handle_t const &handle) const#

Get the pointer to an object for a particular thread from this wrapper.

Parameters:: handle – Handle is used to identify the GPU we associated this object with
Returns:: Shared pointer the wrapped object

template<typename vertex_t, typename weight_t, typename edge_t, typename edge_type_t> class per_device_edgelist_t#

#include <per_device_edgelist.hpp>

An edgelist for each GPU.

Manages an edge list for edges associated with a particular GPU. Multiple threads can call the append() method, possibly concurrently. To avoid constantly copying when the buffers fill up, the class will create a device buffer containing a number of elements specified in the constructor. When that device buffer is full we will create a new buffer.

When we try and use the edgelist we will consolidate the buffers, since at that time we know the entire size required.

Important note, the expectation is that this object will be used in two phases: 1) The append() method will be used to fill buffers with edges 2) The edges will be consumed to create a graph

These two phases are expected to be disjoint. The calling process is expected to manage some barrier so that all threads are guaranteed to be completed before changing phases. If an append() call (part of the filling phase) overlaps with calls to finalize_buffer(), consolidate_and_shuffle(), get_src(), get_dst(), get_wgt(), get_edge_id() and get_edge_type() then the behavior is undefined (data might change in some non-deterministic way).

Public Functions

inline per_device_edgelist_t(size_t device_buffer_size, bool use_weight, bool use_edge_id, bool use_edge_type, rmm::cuda_stream_view stream_view)#

Construct a new per device edgelist t object.

Parameters:

device_buffer_size – Number of edges to store in each device buffer
use_weight – Whether or not the edgelist will have weights
use_edge_id – Whether or not the edgelist will have edge ids
use_edge_type – Whether or not the edgelist will have edge types
stream_view – CUDA stream view

inline per_device_edgelist_t(per_device_edgelist_t &&other)#

Move construct a new per device edgelist t object.

Parameters:: other – Object to move into this instance

Append a list of edges to the edge list.

Parameters:

src – Source vertex id
dst – Destination vertex id
wgt – Edge weight
edge_id – Edge id
edge_type – Edge type
stream_view – CUDA stream view

inline void finalize_buffer(rmm::cuda_stream_view stream_view)#

Mark the edgelist as ready for reading (all writes are complete)

Parameters:: stream_view – CUDA stream view

inline void consolidate_and_shuffle(cugraph::mtmg::handle_t const &handle, bool store_transposed)#

Consolidate edgelists (if necessary) and shuffle to the proper GPU.

Parameters:: handle – The resource handle

namespace ops#

namespace graph#

Typedefs

template<typename IdxT> using smem_algo_r_t = utils::smem_unit_simple_t<1, IdxT>#

Functions

template<typename IdxT, typename GenT, typename RandT> __device__ __forceinline__ void warp_algo_r_index (IdxT *smem, IdxT pop_size, IdxT idx_offset, int sample_size, raft::random::DeviceState< GenT > &rng_state)

template<typename IdxT, typename GenT, typename RandT> __device__ __forceinline__ void warp_algo_r (IdxT *smem, IdxT row_id, const IdxT *nodes, const IdxT *fg_offsets, int sample_size, IdxT &node_id, IdxT &node_start, IdxT &node_end, raft::random::DeviceState< GenT > &rng_state)

template<typename RandT, int N_WARPS, bool SAMPLE_SELF, bool IS_HG, typename IdxT, typename GenT> CUGRAPH_OPS_KERNEL void algo_r_kernel (raft::random::DeviceState< GenT > rng_state, IdxT *neighbors, IdxT *counts, int32_t *edge_types, int32_t *node_types, const IdxT *offsets, const IdxT *indices, const int32_t *g_edge_types, const int32_t *g_node_types, const IdxT *nodes, IdxT n_dst_nodes, int sample_size)

template<typename IdxT, bool SAMPLE_SELF, bool IS_HG> void algo_r_impl(IdxT *neighbors, IdxT *counts, int32_t *edge_types, int32_t *node_types, raft::random::RngState &rng, const IdxT *offsets, const IdxT *indices, const int32_t *g_edge_types, const int32_t *g_node_types, const IdxT *nodes, IdxT n_dst_nodes, IdxT g_n_dst_nodes, IdxT sample_size, IdxT max_val, cudaStream_t stream)#

namespace utils#

Typedefs

template<typename ...DataT> using smem_simple_t = smem_helper<0, 0, field_type<DataT>...>#

template<int N_UNIT_FIELDS, typename ...DataT> using smem_unit_simple_t = smem_helper<0, N_UNIT_FIELDS, field_type<DataT>...>#

Functions

template<typename IntT> CUGRAPH_OPS_HD IntT ceil_div (IntT a, IntT b)

Provide a ceiling division operation ie. ceil(a / b)

Template Parameters:

IntT – supposed to be only integers for now!

Parameters:

a – [in] dividend
b – [in] divisor

template<typename IntT> CUGRAPH_OPS_HD IntT align_to (IntT a, IntT b)

Provide an alignment function ie. ceil(a / b) * b.

Template Parameters:

IntT – supposed to be only integers for now!

Parameters:

a – [in] dividend
b – [in] divisor

__device__ __forceinline__ int lane_id (): get the lane id of the current thread

template<bool USE_X = true, bool USE_Y = false, bool USE_Z = false> __device__ __forceinline__ int flat_id (): get the flat id of the current thread (within block) template parameters allow to control which CTA dimensions are used

template<bool USE_X = true, bool USE_Y = false, bool USE_Z = false> __device__ __forceinline__ int num_warps (): get the number of warps of the current block template parameters allow to control which CTA dimensions are used

template<bool USE_X = true, bool USE_Y = false, bool USE_Z = false> __device__ __forceinline__ int warp_id (): get the warp id of the current thread template parameters allow to control which CTA dimensions are used

Note

: this only makes sense if the first used dimension of the CTA size is a multiple of WARP_SIZE. If this is not the case, use flat_id<...>() / WARP_SIZE to get the warp id of the current thread

template<bool USE_X = true, bool USE_Y = false, bool USE_Z = false> __device__ __forceinline__ int block_dim (): get the block dimension of the current executing block template parameters allow to control which CTA dimensions are used

template<bool G_USE_X = true, bool G_USE_Y = false, bool G_USE_Z = false, bool B_USE_X = true, bool B_USE_Y = false, bool B_USE_Z = false> __device__ __forceinline__ int flat_grid_id (): get the flat id of the current thread (within device/grid) template parameters allow to control which grid and block/CTA dimensions are used

__host__ __device__ constexpr uint32_t low_thread_mask (int n_threads)

get a bit mask for the n_threads lowest threads of a warp

Parameters:: n_threads – [in] number of threads in the mask
Returns:: the bit mask

template<int NP = WARP_SIZE> inline __device__ void warp_sync ()

apply a warp-wide sync (useful from Volta+ archs)

Note

This works on Pascal and earlier archs as well, but all threads with lane id <= NP must enter this function together and in convergence.

Template Parameters:: NP – number of participating threads

template<typename DataT> inline __device__ DataT shfl (DataT val, int src_lane, int width=WARP_SIZE, uint32_t mask=0xffffffffU)

Shuffle the data inside a warp.

Template Parameters:

DataT – the data type (currently assumed to be 4B)

Parameters:

val – [in] value to be shuffled
src_lane – [in] lane from where to shuffle
width – [in] lane width
mask – [in] mask of participating threads (Volta+)

Returns:

the shuffled data

template<typename DataT, int NP = WARP_SIZE> inline __device__ DataT warp_reduce (DataT val)

Warp-level sum reduction.

TODO(mjoux) Expand this to support arbitrary reduction ops

Note

Why not cub? Because cub doesn’t seem to allow working with arbitrary number of warps in a block.

Note

All threads with lane id <= NP must enter this function together

Template Parameters:

DataT – data type
NP – number of participating threads. must be a power of 2 and at most warp size

Parameters:

val – [in] input value

Returns:

only the lane0 will contain valid reduced result

Variables

static int WARP_SIZE = 32#: number of threads per warp

static int CUDA_VER_WARP_SHFL = 9000#: minimum CUDA version required for warp shfl sync functions

template<typename DataT, int32_t ALIGN = 0> struct field_type#

template<int32_t ALIGN_INIT, int N_UNIT_FIELDS, typename ...FieldsT> class smem_helper#

namespace reduce_op#

Functions

template<typename ReduceOp, typename Iterator> __device__ std::enable_if_t< has_compatible_raft_comms_op_v< ReduceOp >, void > atomic_reduce (Iterator iter, typename thrust::iterator_traits< Iterator >::value_type value)

template<typename ReduceOp, typename EdgePartitionEndpointPropertyValueWrapper> __device__ std::enable_if_t< has_compatible_raft_comms_op_v< ReduceOp >, void > atomic_reduce (EdgePartitionEndpointPropertyValueWrapper edge_partition_endpoint_property_value, typename EdgePartitionEndpointPropertyValueWrapper::vertex_type offset, typename EdgePartitionEndpointPropertyValueWrapper::value_type value)

Variables

template<typename ReduceOp> bool has_compatible_raft_comms_op_v = has_compatible_raft_comms_op<ReduceOp>::value#

template<typename ReduceOp> bool has_identity_element_v = has_identity_element<ReduceOp>::value#

template<typename T> struct any#

template<typename T> struct elementwise_maximum#

template<typename T> struct elementwise_minimum#

template<typename ReduceOp, typename = raft::comms::op_t> struct has_compatible_raft_comms_op : public std::false_type#

template<typename ReduceOp> compatible_raft_comms_op)> > : public std::true_type

template<typename ReduceOp, typename = typename ReduceOp::value_type> struct has_identity_element : public std::false_type#

template<typename ReduceOp> identity_element)> > : public std::true_type

template<typename T, typename Enable = void> struct maximum#

template<typename T> value > >

template<typename T> is_arithmetic_v< T > > >

template<typename T, typename Enable = void> struct minimum#

template<typename T> value > >

template<typename T> is_arithmetic_v< T > > >

struct null#

template<typename T> struct plus#

namespace detail#

Functions

template<typename T, std::size_t... Is> __host__ __device__ std::enable_if_t< cugraph::is_thrust_tuple_of_arithmetic< T >::value, T > elementwise_thrust_min (T lhs, T rhs, std::index_sequence< Is... >)

template<typename T, std::size_t... Is> __host__ __device__ std::enable_if_t< cugraph::is_thrust_tuple_of_arithmetic< T >::value, T > elementwise_thrust_max (T lhs, T rhs, std::index_sequence< Is... >)

namespace subgraph#

cuGraph C++ API documentation#

This Page