Add SSSP API, test and implementation #2016
+416
−32
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,186 @@ | ||
| /* | ||
| * Copyright (c) 2022, NVIDIA CORPORATION. | ||
| * | ||
| * Licensed under the Apache License, Version 2.0 (the "License"); | ||
| * you may not use this file except in compliance with the License. | ||
| * You may obtain a copy of the License at | ||
| * | ||
| * http://www.apache.org/licenses/LICENSE-2.0 | ||
| * | ||
| * Unless required by applicable law or agreed to in writing, software | ||
| * distributed under the License is distributed on an "AS IS" BASIS, | ||
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | ||
| * See the License for the specific language governing permissions and | ||
| * limitations under the License. | ||
| */ | ||
|
|
||
| #include <cugraph_c/algorithms.h> | ||
|
|
||
| #include <c_api/abstract_functor.hpp> | ||
| #include <c_api/graph.hpp> | ||
| #include <c_api/paths_result.hpp> | ||
|
|
||
| #include <cugraph/algorithms.hpp> | ||
| #include <cugraph/detail/utility_wrappers.hpp> | ||
| #include <cugraph/graph_functions.hpp> | ||
| #include <cugraph/visitors/generic_cascaded_dispatch.hpp> | ||
|
|
||
| #include <raft/handle.hpp> | ||
|
|
||
| namespace cugraph { | ||
| namespace c_api { | ||
|
|
||
| struct sssp_functor : public abstract_functor { | ||
| raft::handle_t const& handle_; | ||
| cugraph_graph_t* graph_; | ||
| size_t source_; | ||
| double cutoff_; | ||
| bool do_expensive_check_; | ||
| bool compute_predecessors_; | ||
| cugraph_paths_result_t* result_{}; | ||
|
|
||
| sssp_functor(raft::handle_t const& handle, | ||
| cugraph_graph_t* graph, | ||
| size_t source, | ||
| double cutoff, | ||
| bool do_expensive_check, | ||
| bool compute_predecessors) | ||
| : abstract_functor(), | ||
| handle_(handle), | ||
| graph_(graph), | ||
| source_(source), | ||
| cutoff_(cutoff), | ||
| do_expensive_check_(do_expensive_check), | ||
| compute_predecessors_(compute_predecessors) | ||
| { | ||
| } | ||
|
|
||
| template <typename vertex_t, | ||
| typename edge_t, | ||
| typename weight_t, | ||
| bool store_transposed, | ||
| bool multi_gpu> | ||
| void operator()() | ||
| { | ||
| // FIXME: Think about how to handle SG vice MG | ||
| if constexpr (!cugraph::is_candidate<vertex_t, edge_t, weight_t>::value) { | ||
| unsupported(); | ||
| } else { | ||
| // SSSP expects store_transposed == false | ||
| if constexpr (store_transposed) { | ||
| error_code_ = cugraph::c_api:: | ||
| transpose_storage<vertex_t, edge_t, weight_t, store_transposed, multi_gpu>( | ||
| handle_, graph_, error_.get()); | ||
| if (error_code_ != CUGRAPH_SUCCESS) return; | ||
| } | ||
|
|
||
| auto graph = | ||
| reinterpret_cast<cugraph::graph_t<vertex_t, edge_t, weight_t, false, multi_gpu>*>( | ||
| graph_->graph_); | ||
|
|
||
| auto graph_view = graph->view(); | ||
|
|
||
| auto number_map = reinterpret_cast<rmm::device_uvector<vertex_t>*>(graph_->number_map_); | ||
|
|
||
| rmm::device_uvector<vertex_t> source_ids(1, handle_.get_stream()); | ||
| rmm::device_uvector<vertex_t> vertex_ids(graph->get_number_of_vertices(), | ||
| handle_.get_stream()); | ||
| rmm::device_uvector<weight_t> distances(graph->get_number_of_vertices(), | ||
| handle_.get_stream()); | ||
| rmm::device_uvector<vertex_t> predecessors(0, handle_.get_stream()); | ||
|
|
||
| if (compute_predecessors_) { | ||
| predecessors.resize(graph->get_number_of_vertices(), handle_.get_stream()); | ||
| } | ||
|
|
||
| vertex_t src = static_cast<vertex_t>(source_); | ||
| raft::update_device(source_ids.data(), &src, 1, handle_.get_stream()); | ||
|
|
||
| // | ||
| // Need to renumber sources | ||
| // | ||
| renumber_ext_vertices<vertex_t, multi_gpu>(handle_, | ||
| source_ids.data(), | ||
| 1, | ||
| number_map->data(), | ||
| graph_view.get_local_vertex_first(), | ||
| graph_view.get_local_vertex_last(), | ||
| do_expensive_check_); | ||
|
|
||
| raft::update_host(&src, source_ids.data(), 1, handle_.get_stream()); | ||
|
|
||
| cugraph::sssp<vertex_t, edge_t, weight_t, multi_gpu>( | ||
| handle_, | ||
| graph_view, | ||
| distances.data(), | ||
| compute_predecessors_ ? predecessors.data() : nullptr, | ||
| src, | ||
| static_cast<weight_t>(cutoff_), | ||
| do_expensive_check_); | ||
|
|
||
| raft::copy(vertex_ids.data(), number_map->data(), vertex_ids.size(), handle_.get_stream()); | ||
|
|
||
| if (compute_predecessors_) { | ||
| std::vector<vertex_t> vertex_partition_lasts = graph_view.get_vertex_partition_lasts(); | ||
|
|
||
| unrenumber_int_vertices<vertex_t, multi_gpu>(handle_, | ||
| predecessors.data(), | ||
| predecessors.size(), | ||
| number_map->data(), | ||
| vertex_partition_lasts, | ||
| do_expensive_check_); | ||
| } | ||
|
|
||
| result_ = new cugraph_paths_result_t{ | ||
| new cugraph_type_erased_device_array_t(vertex_ids, graph_->vertex_type_), | ||
| new cugraph_type_erased_device_array_t(distances, graph_->weight_type_), | ||
| new cugraph_type_erased_device_array_t(predecessors, graph_->vertex_type_)}; | ||
| } | ||
| } | ||
| }; | ||
|
|
||
| } // namespace c_api | ||
| } // namespace cugraph | ||
|
|
||
| extern "C" cugraph_error_code_t cugraph_sssp(const cugraph_resource_handle_t* handle, | ||
| cugraph_graph_t* graph, | ||
| size_t source, | ||
| double cutoff, | ||
| bool_t do_expensive_check, | ||
| bool_t compute_predecessors, | ||
| cugraph_paths_result_t** result, | ||
| cugraph_error_t** error) | ||
| { | ||
| *result = nullptr; | ||
| *error = nullptr; | ||
|
|
||
| try { | ||
| auto p_handle = reinterpret_cast<raft::handle_t const*>(handle); | ||
| auto p_graph = reinterpret_cast<cugraph::c_api::cugraph_graph_t*>(graph); | ||
|
|
||
| cugraph::c_api::sssp_functor functor( | ||
| *p_handle, p_graph, source, cutoff, do_expensive_check, compute_predecessors); | ||
|
|
||
| // FIXME: This seems like a recurring pattern. Can I encapsulate | ||
| // The vertex_dispatcher and error handling calls into a reusable function? | ||
| // After all, we're in C++ here. | ||
| cugraph::dispatch::vertex_dispatcher(cugraph::c_api::dtypes_mapping[p_graph->vertex_type_], | ||
| cugraph::c_api::dtypes_mapping[p_graph->edge_type_], | ||
| cugraph::c_api::dtypes_mapping[p_graph->weight_type_], | ||
| p_graph->store_transposed_, | ||
| p_graph->multi_gpu_, | ||
| functor); | ||
|
|
||
| if (functor.error_code_ != CUGRAPH_SUCCESS) { | ||
| *error = reinterpret_cast<cugraph_error_t*>(functor.error_.release()); | ||
| return functor.error_code_; | ||
| } | ||
|
|
||
| *result = reinterpret_cast<cugraph_paths_result_t*>(functor.result_); | ||
| } catch (std::exception const& ex) { | ||
| *error = reinterpret_cast<cugraph_error_t*>(new cugraph::c_api::cugraph_error_t{ex.what()}); | ||
| return CUGRAPH_UNKNOWN_ERROR; | ||
| } | ||
|
|
||
| return CUGRAPH_SUCCESS; | ||
| } |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Oops, something went wrong.
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Can't
graphhere be const?There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
C api will transpose the graph if the input is opposite from what the algorithm requires. This will modify the graph.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Would it be better to set/return an error in that case? I'm envisioning a case where we or a user has a bug that isn't transposing data if an algo requires it, it gets silently transposed anyway, then we wonder why our benchmarks are slower than expected.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Fair question. I think we've discussed this (or else I had this argument with myself... entirely possible).
From an API perspective, we have two choices:
The C++ layer has always opted for the latter and I believe it should. Thus far I have opted for the former in the C API. Now that @rlratzel is building the
pythonlayer it would make sense for us to have this conversation. Perhaps thepythonlayer should worry about providing the intelligence and the C layer should (like the C++ layer) simply fail fast if the input is in the wrong orientation.That would be an easy change, although I think it should not be rushed into this release.