changes after review

Author: mitya-y

README.md

@@ -1,8 +1,13 @@
 # cuBoolGraph
 cuBool based graph analysis algorithms
 
+## List of algorithms
+
+regular_path_query - Single-Source Regular Path Query Algorithm in Terms of Linear Algebra
+
 # Run tests
 ```
+git submodule update --init --recursive
 cmake -B build -DCUBOOL_GRAPH_ENABLE_TESTING=ON
 cmake --build build
 ./build/tests/cuboolgraph_tests

include/regular_path_query.hpp

@@ -6,17 +6,17 @@ cuBool_Matrix regular_path_query_with_transposed(
   // vector of sparse graph matrices for each label
   const std::vector<cuBool_Matrix> &graph, const std::vector<cuBool_Index> &source_vertices,
   // vector of sparse automat matrices for each label
-  const std::vector<cuBool_Matrix> &automat, const std::vector<cuBool_Index> &start_states,
+  const std::vector<cuBool_Matrix> &automaton, const std::vector<cuBool_Index> &start_states,
   // transposed matrices for graph and automat
   const std::vector<cuBool_Matrix> &graph_transposed,
-  const std::vector<cuBool_Matrix> &automat_transposed,
+  const std::vector<cuBool_Matrix> &automaton_transposed,
 
   const std::vector<bool> &inversed_labels = {}, bool all_labels_are_inversed = false);
 
 cuBool_Matrix regular_path_query(
   // vector of sparse graph matrices for each label
   const std::vector<cuBool_Matrix> &graph, const std::vector<cuBool_Index> &source_vertices,
   // vector of sparse automat matrices for each label
-  const std::vector<cuBool_Matrix> &automat, const std::vector<cuBool_Index> &start_states,
+  const std::vector<cuBool_Matrix> &automaton, const std::vector<cuBool_Index> &start_states,
 
   const std::vector<bool> &inversed_labels = {}, bool all_labels_are_inversed = false);

src/regular_path_query.cpp

@@ -9,17 +9,17 @@
 cuBool_Matrix regular_path_query_with_transposed(
   // vector of sparse graph matrices for each label
   const std::vector<cuBool_Matrix> &graph, const std::vector<cuBool_Index> &source_vertices,
-  // vector of sparse automat matrices for each label
-  const std::vector<cuBool_Matrix> &automat, const std::vector<cuBool_Index> &start_states,
-  // transposed matrices for graph and automat
+  // vector of sparse automaton matrices for each label
+  const std::vector<cuBool_Matrix> &automaton, const std::vector<cuBool_Index> &start_states,
+  // transposed matrices for graph and automaton
   const std::vector<cuBool_Matrix> &graph_transposed,
-  const std::vector<cuBool_Matrix> &automat_transposed,
+  const std::vector<cuBool_Matrix> &automaton_transposed,
 
   const std::vector<bool> &inversed_labels_input, bool all_labels_are_inversed) {
   cuBool_Status status;
 
   auto inversed_labels = inversed_labels_input;
-  inversed_labels.resize(std::max(graph.size(), automat.size()));
+  inversed_labels.resize(std::max(graph.size(), automaton.size()));
 
   for (uint32_t i = 0; i < inversed_labels.size(); i++) {
     bool is_inverse = inversed_labels[i];
@@ -28,7 +28,7 @@ cuBool_Matrix regular_path_query_with_transposed(
   }
 
   cuBool_Index graph_nodes_number = 0;
-  cuBool_Index automat_nodes_number = 0;
+  cuBool_Index automaton_nodes_number = 0;
 
   // get number of graph nodes
   for (auto label_matrix : graph) {
@@ -39,31 +39,31 @@ cuBool_Matrix regular_path_query_with_transposed(
   }
 
   // get number of automat nodes
-  for (auto label_matrix : automat) {
+  for (auto label_matrix : automaton) {
     if (label_matrix != nullptr) {
-      cuBool_Matrix_Nrows(label_matrix, &automat_nodes_number);
+      cuBool_Matrix_Nrows(label_matrix, &automaton_nodes_number);
       break;
     }
   }
 
   // this will be answer
   cuBool_Matrix reacheble {};
-  status = cuBool_Matrix_New(&reacheble, automat_nodes_number, graph_nodes_number);
+  status = cuBool_Matrix_New(&reacheble, automaton_nodes_number, graph_nodes_number);
   assert(status == CUBOOL_STATUS_SUCCESS);
 
   // allocate neccessary for algorithm matrices
   cuBool_Matrix frontier {}, symbol_frontier {}, next_frontier {};
-  status = cuBool_Matrix_New(&next_frontier, automat_nodes_number, graph_nodes_number);
+  status = cuBool_Matrix_New(&next_frontier, automaton_nodes_number, graph_nodes_number);
   assert(status == CUBOOL_STATUS_SUCCESS);
-  status = cuBool_Matrix_New(&frontier, automat_nodes_number, graph_nodes_number);
+  status = cuBool_Matrix_New(&frontier, automaton_nodes_number, graph_nodes_number);
   assert(status == CUBOOL_STATUS_SUCCESS);
-  status = cuBool_Matrix_New(&symbol_frontier, automat_nodes_number, graph_nodes_number);
+  status = cuBool_Matrix_New(&symbol_frontier, automaton_nodes_number, graph_nodes_number);
   assert(status == CUBOOL_STATUS_SUCCESS);
 
   // init start values of algorithm matricies
   for (const auto state : start_states) {
     for (const auto vert : source_vertices) {
-      assert(state < automat_nodes_number);
+      assert(state < automaton_nodes_number);
       assert(vert < graph_nodes_number);
       cuBool_Matrix_SetElement(next_frontier, state, vert);
       cuBool_Matrix_SetElement(reacheble, state, vert);
@@ -74,10 +74,10 @@ cuBool_Matrix regular_path_query_with_transposed(
 
   // temporary matrix for write result of cubool functions
   cuBool_Matrix result;
-  status = cuBool_Matrix_New(&result, automat_nodes_number, graph_nodes_number);
+  status = cuBool_Matrix_New(&result, automaton_nodes_number, graph_nodes_number);
   assert(status == CUBOOL_STATUS_SUCCESS);
 
-  const auto label_number = std::min(graph.size(), automat.size());
+  const auto label_number = std::min(graph.size(), automaton.size());
   while (states > 0) {
     std::swap(frontier, next_frontier);
 
@@ -86,12 +86,12 @@ cuBool_Matrix regular_path_query_with_transposed(
     assert(status == CUBOOL_STATUS_SUCCESS);
 
     for (int i = 0; i < label_number; i++) {
-      if (graph[i] == nullptr || automat[i] == nullptr) {
+      if (graph[i] == nullptr || automaton[i] == nullptr) {
         continue;
       }
 
-      cuBool_Matrix automat_matrix = all_labels_are_inversed ? automat[i] : automat_transposed[i];
-      status = cuBool_MxM(symbol_frontier, automat_matrix, frontier, CUBOOL_HINT_NO);
+      cuBool_Matrix automaton_matrix = all_labels_are_inversed ? automaton[i] : automaton_transposed[i];
+      status = cuBool_MxM(symbol_frontier, automaton_matrix, frontier, CUBOOL_HINT_NO);
       assert(status == CUBOOL_STATUS_SUCCESS);
 
       // next_frontier += (symbol_frontier * graph[i]) & (!reachible)
@@ -127,7 +127,7 @@ cuBool_Matrix regular_path_query(
   // vector of sparse graph matrices for each label
   const std::vector<cuBool_Matrix> &graph, const std::vector<cuBool_Index> &source_vertices,
   // vector of sparse automat matrices for each label
-  const std::vector<cuBool_Matrix> &automat, const std::vector<cuBool_Index> &start_states,
+  const std::vector<cuBool_Matrix> &automaton, const std::vector<cuBool_Index> &start_states,
   // work with inverted labels
   const std::vector<bool> &inversed_labels_input, bool all_labels_are_inversed) {
   cuBool_Status status;
@@ -154,10 +154,10 @@ cuBool_Matrix regular_path_query(
   }
 
   // transpose automat matrices
-  std::vector<cuBool_Matrix> automat_transposed;
-  automat_transposed.reserve(automat.size());
-  for (auto label_matrix : automat) {
-    automat_transposed.emplace_back();
+  std::vector<cuBool_Matrix> automaton_transposed;
+  automaton_transposed.reserve(automaton.size());
+  for (auto label_matrix : automaton) {
+    automaton_transposed.emplace_back();
     if (label_matrix == nullptr) {
       continue;
     }
@@ -166,24 +166,24 @@ cuBool_Matrix regular_path_query(
     cuBool_Matrix_Nrows(label_matrix, &nrows);
     cuBool_Matrix_Ncols(label_matrix, &ncols);
 
-    status = cuBool_Matrix_New(&automat_transposed.back(), ncols, nrows);
+    status = cuBool_Matrix_New(&automaton_transposed.back(), ncols, nrows);
     assert(status == CUBOOL_STATUS_SUCCESS);
-    status = cuBool_Matrix_Transpose(automat_transposed.back(), label_matrix, CUBOOL_HINT_NO);
+    status = cuBool_Matrix_Transpose(automaton_transposed.back(), label_matrix, CUBOOL_HINT_NO);
     assert(status == CUBOOL_STATUS_SUCCESS);
   }
 
   auto result = regular_path_query_with_transposed(
     graph, source_vertices,
-    automat, start_states,
-    graph_transposed, automat_transposed,
+    automaton, start_states,
+    graph_transposed, automaton_transposed,
     inversed_labels_input, all_labels_are_inversed);
 
   for (cuBool_Matrix matrix : graph_transposed) {
     if (matrix != nullptr) {
       cuBool_Matrix_Free(matrix);
     }
   }
-  for (cuBool_Matrix matrix : automat_transposed) {
+  for (cuBool_Matrix matrix : automaton_transposed) {
     if (matrix != nullptr) {
       cuBool_Matrix_Free(matrix);
     }

tests/rpq_tests.cpp

@@ -15,7 +15,7 @@
 
 struct Config {
   std::vector<std::string> graph_data;
-  std::vector<std::string> automat_data;
+  std::vector<std::string> automaton_data;
   std::vector<uint32_t> sources;
   std::string expexted;
   std::string meta_data;
@@ -27,7 +27,7 @@ static bool test_on_config(const Config &config) {
 
   std::vector<cuBool_Matrix> graph;
   std::vector<cuBool_Index> source_vertices;
-  std::vector<cuBool_Matrix> automat;
+  std::vector<cuBool_Matrix> automaton;
   std::vector<cuBool_Index> start_states;
 
   int64_t nrows = 0, ncols = 0;
@@ -56,11 +56,11 @@ static bool test_on_config(const Config &config) {
     graph_rows = std::max(graph_rows, (cuBool_Index)nrows);
   }
 
-  cuBool_Index automat_rows = 0;
-  // load automat
-  automat.reserve(config.automat_data.size());
-  for (const auto &data : config.automat_data) {
-    automat.emplace_back();
+  cuBool_Index automaton_rows = 0;
+  // load automaton
+  automaton.reserve(config.automaton_data.size());
+  for (const auto &data : config.automaton_data) {
+    automaton.emplace_back();
     if (data.empty()) {
       continue;
     }
@@ -71,10 +71,10 @@ static bool test_on_config(const Config &config) {
     }
     fast_matrix_market::read_matrix_market_triplet(file, nrows, ncols, rows, cols, vals);
 
-    cuBool_Matrix_New(&automat.back(), nrows, ncols);
-    cuBool_Matrix_Build(automat.back(), rows.data(), cols.data(), vals.size(), CUBOOL_HINT_NO);
+    cuBool_Matrix_New(&automaton.back(), nrows, ncols);
+    cuBool_Matrix_Build(automaton.back(), rows.data(), cols.data(), vals.size(), CUBOOL_HINT_NO);
 
-    automat_rows = std::max(automat_rows, (cuBool_Index)nrows);
+    automaton_rows = std::max(automaton_rows, (cuBool_Index)nrows);
   }
 
   // temporary hardcoded
@@ -86,13 +86,13 @@ static bool test_on_config(const Config &config) {
     s--;
   }
 
-  auto answer = regular_path_query(graph, source_vertices, automat, start_states);
+  auto answer = regular_path_query(graph, source_vertices, automaton, start_states);
 
   cuBool_Vector P, F;
   cuBool_Vector_New(&P, graph_rows);
-  cuBool_Vector_New(&F, automat_rows);
+  cuBool_Vector_New(&F, automaton_rows);
 
-  std::vector<cuBool_Index> final_states(automat_rows);
+  std::vector<cuBool_Index> final_states(automaton_rows);
   std::iota(final_states.begin(), final_states.end(), 0);
 
   cuBool_Vector_Build(F, final_states.data(), final_states.size(), CUBOOL_HINT_NO);
@@ -140,7 +140,7 @@ static bool test_on_config(const Config &config) {
       cuBool_Matrix_Free(matrix);
     }
   }
-  for (auto matrix : automat) {
+  for (auto matrix : automaton) {
     if (matrix != nullptr) {
       cuBool_Matrix_Free(matrix);
     }
@@ -158,34 +158,34 @@ static std::string get_path(std::string_view file) {
 TEST(RPQ, Tests) {
   std::vector<Config> configs {
     {
-      .graph_data = {get_path("example/graph_a.mtx"), get_path("example/graph_b.mtx")},
-      .automat_data = {get_path("example/automat_a.mtx"), get_path("example/automat_b.mtx")},
+      .graph_data = {get_path("5/graph_a.mtx"), get_path("5/graph_b.mtx")},
+      .automaton_data = {get_path("5/automat_a.mtx"), get_path("5/automat_b.mtx")},
       .sources = {1},
-      .expexted = get_path("example/expected.txt"),
+      .expexted = get_path("5/expected.txt"),
     },
     {
       .graph_data = {get_path("a.mtx"), get_path("b.mtx")},
-      .automat_data {get_path("1_a.mtx"), ""},
+      .automaton_data {get_path("1/a.mtx"), ""},
       .sources = {1},
-      .expexted = get_path("1_expected.txt"),
+      .expexted = get_path("1/expected.txt"),
     },
     {
       .graph_data = {get_path("a.mtx"), get_path("b.mtx")},
-      .automat_data {get_path("2_a.mtx"), get_path("2_b.mtx")},
+      .automaton_data {get_path("2/a.mtx"), get_path("2/b.mtx")},
       .sources = {2},
-      .expexted = get_path("2_expected.txt"),
+      .expexted = get_path("2/expected.txt"),
     },
     {
       .graph_data = {get_path("a.mtx"), get_path("b.mtx")},
-      .automat_data {get_path("3_a.mtx"), get_path("3_b.mtx")},
+      .automaton_data {get_path("3/a.mtx"), get_path("3/b.mtx")},
       .sources = {3, 6},
-      .expexted = get_path("3_expected.txt"),
+      .expexted = get_path("3/expected.txt"),
     },
     {
       .graph_data = {get_path("a.mtx"), get_path("b.mtx")},
-      .automat_data {"", get_path("4_b.mtx")},
+      .automaton_data {"", get_path("4/b.mtx")},
       .sources = {4},
-      .expexted = get_path("4_expected.txt"),
+      .expexted = get_path("4/expected.txt"),
     },
   };