revision hasher

Author: tonibohnlein

include/osp/dag_divider/isomorphism_divider/EftSubgraphScheduler.hpp

@@ -105,7 +105,6 @@ class EftSubgraphScheduler {
         JobStatus status_ = JobStatus::WAITING;
         VWorkwT<GraphT> upwardRank_ = 0.0;
 
-        // --- Execution Tracking Members ---
         std::vector<unsigned> assignedWorkers_;
         double startTime_ = -1.0;
         double finishTime_ = -1.0;
@@ -321,8 +320,6 @@ class EftSubgraphScheduler {
     void ProcessCompletedJobs(std::vector<JobIdT> &runningJobs, std::vector<unsigned> &availableWorkers, unsigned &completedCount,
                               double currentTime, const GraphT &graph) {
         const size_t numWorkerTypes = availableWorkers.size();
-
-        // Optimize removal loop
         for (size_t i = 0; i < runningJobs.size();) {
             Job &job = jobs_.at(runningJobs[i]);
             if (job.finishTime_ <= currentTime) {
@@ -344,7 +341,6 @@ class EftSubgraphScheduler {
                     }
                 }
 
-                // Fast removal: swap with last and pop
                 runningJobs[i] = runningJobs.back();
                 runningJobs.pop_back();
             } else {

include/osp/dag_divider/isomorphism_divider/HashComputer.hpp

@@ -30,20 +30,50 @@ namespace osp {
  * This class provides an interface for obtaining hash values for individual vertices,
  * the full list of vertex hashes, the number of unique orbits, and the vertices belonging to specific orbits.
  *
- * @tparam index_type The type used for indexing vertices in the graph.
+ * @tparam IndexType The type used for indexing vertices in the graph.
  */
 template <typename IndexType>
 class HashComputer {
   public:
     virtual ~HashComputer() = default;
 
+    /**
+     * @brief Gets the hash value of a specific vertex.
+     * @param v The vertex index.
+     * @return The computed hash value of the vertex.
+     */
     virtual std::size_t GetVertexHash(const IndexType &v) const = 0;
+
+    /**
+     * @brief Gets the reference to the vector of all vertex hashes.
+     * @return A const reference to the vector containing hashes for all vertices.
+     */
     virtual const std::vector<std::size_t> &GetVertexHashes() const = 0;
+
+    /**
+     * @brief Gets the number of unique orbits (equivalence classes) found.
+     * @return The number of orbits.
+     */
     virtual std::size_t NumOrbits() const = 0;
 
+    /**
+     * @brief Gets the orbit (list of equivalent vertices) that a specific vertex belongs to.
+     * @param v The vertex index.
+     * @return A const reference to the vector of indices in the same orbit.
+     */
     virtual const std::vector<IndexType> &GetOrbit(const IndexType &v) const = 0;
+
+    /**
+     * @brief Gets the map of all orbits.
+     * @return A const reference to the map where keys are hash values and values are vectors of vertex indices.
+     */
     virtual const std::unordered_map<std::size_t, std::vector<IndexType>> &GetOrbits() const = 0;
 
+    /**
+     * @brief Gets the orbit corresponding to a specific hash value.
+     * @param hash The hash value of the orbit.
+     * @return A const reference to the vector of vertex indices in the orbit.
+     */
     virtual const std::vector<IndexType> &GetOrbitFromHash(const std::size_t &hash) const = 0;
 };
 

include/osp/dag_divider/isomorphism_divider/MerkleHashComputer.hpp

@@ -3,7 +3,7 @@ Copyright 2024 Huawei Technologies Co., Ltd.
 
 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
+you may obtain a copy of the License at
 
     http://www.apache.org/licenses/LICENSE-2.0
 
@@ -18,9 +18,12 @@ limitations under the License.
 
 #pragma once
 
+#include <algorithm>
 #include <set>
 #include <stdexcept>
+#include <type_traits>
 #include <unordered_map>
+#include <utility>
 #include <vector>
 
 #include "osp/auxiliary/hash_util.hpp"
@@ -32,6 +35,7 @@ limitations under the License.
 namespace osp {
 
 /**
+ * @class MerkleHashComputer
  * @brief Computes Merkle hashes for graph vertices to identify isomorphic orbits.
  *
  * The Merkle hash of a vertex is computed recursively based on its own properties
@@ -57,7 +61,7 @@ class MerkleHashComputer : public HashComputer<VertexIdxT<GraphT>> {
 
     NodeHashFuncT nodeHashFunc_;
 
-    inline void ComputeHashesHelper(const VertexType &v, std::vector<std::size_t> &parentChildHashes) {
+    void ComputeHashesHelper(const VertexType &v, std::vector<std::size_t> &parentChildHashes) {
         std::sort(parentChildHashes.begin(), parentChildHashes.end());
 
         std::size_t hash = nodeHashFunc_(v);
@@ -76,64 +80,84 @@ class MerkleHashComputer : public HashComputer<VertexIdxT<GraphT>> {
 
     template <typename RetT = void>
     std::enable_if_t<forward, RetT> ComputeHashes(const GraphT &graph) {
-        vertexHashes_.resize(graph.NumVertices());
+        const size_t numVertices = graph.NumVertices();
+        vertexHashes_.resize(numVertices);
+        std::vector<std::size_t> neighborHashes;
 
         for (const VertexType &v : TopSortView(graph)) {
-            std::vector<std::size_t> parentHashes;
+            neighborHashes.clear();
             for (const VertexType &parent : graph.Parents(v)) {
-                parentHashes.push_back(vertexHashes_[parent]);
+                neighborHashes.push_back(vertexHashes_[parent]);
             }
-            ComputeHashesHelper(v, parentHashes);
+            ComputeHashesHelper(v, neighborHashes);
         }
     }
 
     template <typename RetT = void>
     std::enable_if_t<not forward, RetT> ComputeHashes(const GraphT &graph) {
-        vertexHashes_.resize(graph.NumVertices());
+        const size_t numVertices = graph.NumVertices();
+        vertexHashes_.resize(numVertices);
+        std::vector<std::size_t> neighborHashes;
 
         const auto topSort = GetTopOrderReverse(graph);
         for (auto it = topSort.cbegin(); it != topSort.cend(); ++it) {
             const VertexType &v = *it;
-            std::vector<std::size_t> childHashes;
+            neighborHashes.clear();
             for (const VertexType &child : graph.Children(v)) {
-                childHashes.push_back(vertexHashes_[child]);
+                neighborHashes.push_back(vertexHashes_[child]);
             }
-            ComputeHashesHelper(v, childHashes);
+            ComputeHashesHelper(v, neighborHashes);
         }
     }
 
   public:
+    /**
+     * @brief Constructs the MerkleHashComputer and immediately computes the hashes.
+     * @tparam Args Arguments forwarded to the NodeHashFuncT constructor.
+     * @param graph The graph to process.
+     * @param args Arguments for the node hash function.
+     */
     template <typename... Args>
     MerkleHashComputer(const GraphT &graph, Args &&...args)
         : HashComputer<VertexType>(), nodeHashFunc_(std::forward<Args>(args)...) {
         ComputeHashes(graph);
     }
 
-    virtual ~MerkleHashComputer() override = default;
+    ~MerkleHashComputer() override = default;
 
-    inline std::size_t GetVertexHash(const VertexType &v) const override { return vertexHashes_[v]; }
+    std::size_t GetVertexHash(const VertexType &v) const override { return vertexHashes_[v]; }
 
-    inline const std::vector<std::size_t> &GetVertexHashes() const override { return vertexHashes_; }
+    const std::vector<std::size_t> &GetVertexHashes() const override { return vertexHashes_; }
 
-    inline std::size_t NumOrbits() const override { return orbits_.size(); }
+    std::size_t NumOrbits() const override { return orbits_.size(); }
 
-    inline const std::vector<VertexType> &GetOrbit(const VertexType &v) const override {
+    const std::vector<VertexType> &GetOrbit(const VertexType &v) const override {
         return this->GetOrbitFromHash(this->GetVertexHash(v));
     }
 
-    inline const std::unordered_map<std::size_t, std::vector<VertexType>> &GetOrbits() const override { return orbits_; }
+    const std::unordered_map<std::size_t, std::vector<VertexType>> &GetOrbits() const override { return orbits_; }
 
-    inline const std::vector<VertexType> &GetOrbitFromHash(const std::size_t &hash) const override { return orbits_.at(hash); }
+    const std::vector<VertexType> &GetOrbitFromHash(const std::size_t &hash) const override { return orbits_.at(hash); }
 };
 
+/**
+ * @brief Checks if two graphs are isomorphic based on Merkle hashes.
+ * @note This is a necessary but not sufficient condition for graph isomorphism in general cases,
+ *       but sufficient for the kinds of DAGs often encountered in this context.
+ *
+ * @tparam GraphT The graph type.
+ * @tparam NodeHashFuncT The node hash function type.
+ * @tparam forward Direction of hash computation.
+ * @param g1 The first graph.
+ * @param g2 The second graph.
+ * @return True if they have the same orbit structure, false otherwise.
+ */
 template <typename GraphT, typename NodeHashFuncT = UniformNodeHashFunc<VertexIdxT<GraphT>>, bool forward = true>
 bool AreIsomorphicByMerkleHash(const GraphT &g1, const GraphT &g2) {
-    // Basic check: Different numbers of vertices or edges mean they can't be isomorphic.
     if (g1.NumVertices() != g2.NumVertices() || g1.NumEdges() != g2.NumEdges()) {
         return false;
     }
 
-    // --- Compute Hashes in the Specified Direction ---
     MerkleHashComputer<GraphT, NodeHashFuncT, forward> hash1(g1);
     MerkleHashComputer<GraphT, NodeHashFuncT, forward> hash2(g2);
 

include/osp/dag_divider/isomorphism_divider/PrecomputedHashComputer.hpp

@@ -3,7 +3,7 @@ Copyright 2024 Huawei Technologies Co., Ltd.
 
 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
+you may obtain a copy of the License at
 
     http://www.apache.org/licenses/LICENSE-2.0
 
@@ -26,6 +26,7 @@ limitations under the License.
 namespace osp {
 
 /**
+ * @class PrecomputedHashComputer
  * @brief A class to store precomputed hash values for a set of objects and provide an orbit-based interface.
  *
  * This class takes a vector of hash values for objects indexed from 0 to n-1. It then computes the orbits
@@ -43,7 +44,7 @@ class PrecomputedHashComputer : public HashComputer<IndexType> {
     /**
      * @brief Construct a new Precomputed Hash Computer object.
      *
-     * @param precomputed_hashes A vector of hash values for objects 0 to n-1.
+     * @param precomputedHashes A vector of hash values for objects 0 to n-1.
      */
     PrecomputedHashComputer(const std::vector<std::size_t> &precomputedHashes) : vertexHashes_(precomputedHashes) {
         for (std::size_t i = 0; i < vertexHashes_.size(); ++i) {
@@ -52,21 +53,21 @@ class PrecomputedHashComputer : public HashComputer<IndexType> {
         }
     }
 
-    virtual ~PrecomputedHashComputer() override = default;
+    ~PrecomputedHashComputer() override = default;
 
-    inline std::size_t GetVertexHash(const IndexType &v) const override { return vertexHashes_[v]; }
+    std::size_t GetVertexHash(const IndexType &v) const override { return vertexHashes_[v]; }
 
-    inline const std::vector<std::size_t> &GetVertexHashes() const override { return vertexHashes_; }
+    const std::vector<std::size_t> &GetVertexHashes() const override { return vertexHashes_; }
 
-    inline std::size_t NumOrbits() const override { return orbits_.size(); }
+    std::size_t NumOrbits() const override { return orbits_.size(); }
 
-    inline const std::vector<IndexType> &GetOrbit(const IndexType &v) const override {
+    const std::vector<IndexType> &GetOrbit(const IndexType &v) const override {
         return this->GetOrbitFromHash(this->GetVertexHash(v));
     }
 
-    inline const std::unordered_map<std::size_t, std::vector<IndexType>> &GetOrbits() const override { return orbits_; }
+    const std::unordered_map<std::size_t, std::vector<IndexType>> &GetOrbits() const override { return orbits_; }
 
-    inline const std::vector<IndexType> &GetOrbitFromHash(const std::size_t &hash) const override { return orbits_.at(hash); }
+    const std::vector<IndexType> &GetOrbitFromHash(const std::size_t &hash) const override { return orbits_.at(hash); }
 };
 
 }    // namespace osp