Implemented Khop

procedures/CMakeLists.txt

@@ -81,6 +81,7 @@ add_standalone(wlpa)
 add_standalone(subgraph_isomorphism)
 add_standalone(sybilrank)
 add_standalone(leiden)
+add_stanalone(khop)
 
 add_embed(apsp)
 add_embed(bfs)

procedures/algo_cpp/khop_core.cpp

@@ -0,0 +1,60 @@
+/**
+ * Copyright 2024 Yingqi Zhao
+ * 
+ * @Function: Compute the k-hop algorithm.
+ * @param:
+ *
+ *
+ *
+ *
+ graph:
+ The graph to compute on.
+ root_vid: Identifier of root node.
+ result:
+ Set of reachable nodes in K-hop.
+ value_k: Number of search layers.
+ * @return: Number of nodes in K_hop.
+ */
+// #include <cstddef>
+#include "lgraph/olap_base.h"
+#include "./algo.h"
+
+using namespace lgraph_api;
+using namespace lgraph_api::olap;
+
+size_t k_hop(OlapBase<Empty>& graph, size_t root_vid, ParallelVector<size_t>& result, size_t k) {
+    size_t root = root_vid;
+    auto active_in = graph.AllocVertexSubset();
+    active_in.Add(root);
+    auto active_out = graph.AllocVertexSubset();
+    auto parent = graph.AllocVertexArray<size_t>();
+    parent.Fill(0);
+    parent[root] = root;
+    size_t num_activations = 1;
+    size_t discovered_vertices, j = 0;
+    for (size_t ii = 0; ii < k; ii++) {
+        active_out.Clear();
+        num_activations = graph.ProcessVertexActive<size_t>(
+            [&](size_t vi) {
+                size_t num_activations = 0;
+                for (auto& edge : graph.OutEdges(vi)) {
+                    size_t dst = edge.neighbour;
+                    if (parent[dst] == 0) {
+                        auto lock = graph.GuardVertexLock(dst);
+                        if (parent[dst] == 0) {
+                            parent[dst] = vi;
+                            num_activations += 1;
+                            active_out.Add(dst);
+                            result[j++] = dst;
+                        }
+                    }
+                }
+                return num_activations;
+            },
+            active_in);
+        printf("activates(%lu) <= %lu \n", ii+1, num_activations);
+        discovered_vertices += num_activations;
+        active_in.Swap(active_out);
+    }
+    return discovered_vertices;
+}

procedures/algo_cpp/khop_standalone.cpp

@@ -0,0 +1,79 @@
+// Copyright 2024 Yingqi Zhao
+#include "olap/olap_on_disk.h"
+#include "tools/json.hpp"
+#include "./algo.h"
+using namespace lgraph_api;
+using namespace lgraph_api::olap;
+using json = nlohmann::json;
+
+class MyConfig : public ConfigBase<Empty> {
+ public:
+    std::string root = "0";
+    std::string name = std::string("khop");
+    size_t value_k = 3;
+    void AddParameter(fma_common::Configuration& config) {
+        ConfigBase<Empty>::AddParameter(config);
+        config.Add(root, "root", true).Comment("Identifier of the root node.");
+        config.Add(value_k, "value_k", true).Comment(
+            "Number of search layers(value of k in K-hop algorithm).");
+    }
+    void Print() {
+        ConfigBase<Empty>::Print();
+        std::cout << " name: " << name << std::endl;
+        std::cout << " root: " << name << std::endl;
+        std::cout << " value_k: " << value_k << std::endl;
+    }
+    MyConfig(int& argc, char**& argv) : ConfigBase<Empty>(argc, argv) {
+        fma_common::Configuration config;
+        AddParameter(config);
+        config.ExitAfterHelp(true);
+        config.ParseAndFinalize(argc, argv);
+        Print();
+    }
+};
+
+extern size_t k_hop(OlapBase<Empty>& graph, size_t root_vid,
+    ParallelVector<size_t>& result, size_t k);
+
+int main(int argc, char** argv) {
+    double start_time;
+    MemUsage memUsage;
+    memUsage.startMemRecord();
+    start_time = get_time();
+    MyConfig config(argc, argv);
+    OlapOnDisk<Empty> graph;
+    graph.Load(config, INPUT_SYMMETRIC);
+    size_t root_vid;
+    auto result = graph.AllocVertexArray<size_t>();
+    result.Fill(0);
+    if (config.id_mapping)
+        root_vid = graph.hash_list_.find(config.root);
+    else
+        root_vid = std::stoi(config.root);
+    size_t value_k = config.value_k;
+    memUsage.print();
+    memUsage.reset();
+    auto prepare_cost = get_time()- start_time;
+    printf("prepare_cost = %.2lf(s)\n", prepare_cost);
+
+    start_time = get_time();
+    size_t count_result = k_hop(graph, root_vid, result, value_k);
+    memUsage.print();
+    memUsage.reset();
+    auto core_cost = get_time()- start_time;
+
+    start_time = get_time();
+    if (config.output_dir != "") {
+        graph.Write<size_t>(config, result, graph.NumVertices(), config.name);
+    }
+    printf("\n================\n");
+    printf("Find %lu vertexes in %lu-hop from node NO.%lu", count_result, value_k, root_vid);
+    printf("\n================\n");
+    auto output_cost = get_time()- start_time;
+
+    printf("core_cost = %.2lf(s)\n", core_cost);
+    printf("output_cost = %.2lf(s)\n", output_cost);
+    printf("total_cost = %.2lf(s)\n", prepare_cost + core_cost + output_cost);
+    printf("DONE.\n");
+    return 0;
+}

procedures/community/README.md

@@ -1,3 +1,12 @@
 # community procedures
 
- In this directory, The procedures are contribution from the commmunity.
+ In this directory, The procedures are contribution from the commmunity.
+
+## K-hop Algorithm
+The K-hop algorithm is used to find all nodes within K hops from a given starting node in a graph. It is particularly useful in social network analysis, recommendation systems, and network topology analysis.
+
+### Contributor
+This algorithm was contributed by AidenPearce-ZYQ, iwanttoknowwhy and ZhengHeber.
+
+### Usage
+For detailed usage, please refer to the TuGraph-DB OLAP C++ API documentation and run khop_standalone --help.