progress

Author: raphael-s-steiner

include/osp/coarser/Sarkar/Sarkar.hpp

@@ -20,6 +20,7 @@ limitations under the License.
 
 #include <algorithm>
 #include <limits>
+#include <map>
 #include <set>
 #include <tuple>
 #include <utility>
@@ -68,9 +69,7 @@ class Sarkar : public CoarserGenExpansionMap<Graph_t_in, Graph_t_out> {
         vertex_idx_t<Graph_t_in> out_buffer_merge(v_workw_t<Graph_t_in> commCost, const Graph_t_in &graph, std::vector<std::vector<vertex_idx_t<Graph_t_in>>> &expansionMapOutput) const;
         vertex_idx_t<Graph_t_in> in_buffer_merge(v_workw_t<Graph_t_in> commCost, const Graph_t_in &graph, std::vector<std::vector<vertex_idx_t<Graph_t_in>>> &expansionMapOutput) const;
 
-        std::vector<std::size_t> nodeHashes;
-        void computeNodeHashes(const Graph_t_in &graph);
-        std::unordered_map<std::size_t, std::set< vertex_idx_t<Graph_t_in> >> computeHashOrbits() const;
+        std::vector<std::size_t> computeNodeHashes(const Graph_t_in &graph, const std::vector< vertex_idx_t<Graph_t_in> > &vertexPoset, const std::vector< v_workw_t<Graph_t_in> > &dist) const;
 
     public:
         virtual std::vector<std::vector<vertex_idx_t<Graph_t_in>>> generate_vertex_expansion_map(const Graph_t_in &dag_in) override;
@@ -1127,6 +1126,23 @@ vertex_idx_t<Graph_t_in> Sarkar<Graph_t_in, Graph_t_out>::levelContraction(v_wor
     return counter;
 };
 
+template<typename Graph_t_in, typename Graph_t_out>
+std::vector<std::size_t> Sarkar<Graph_t_in, Graph_t_out>::computeNodeHashes(const Graph_t_in &graph, const std::vector< vertex_idx_t<Graph_t_in> > &vertexPoset, const std::vector< v_workw_t<Graph_t_in> > &dist) const {
+    using VertexType = vertex_idx_t<Graph_t_in>;
+
+    std::vector<std::size_t> hashes(graph.num_vertices());
+    for (const VertexType &vert : graph.vertices()) {
+        std::size_t &hash = hashes[vert];
+        hash = std::hash<v_workw_t<Graph_t_in>>{}(graph.vertex_work_weight(vert));
+        hash_combine(hash, vertexPoset[vert]);
+        hash_combine(hash, dist[vert]);
+        if constexpr (has_typed_vertices_v<Graph_t_in>) {
+            hash_combine(hash, graph.vertex_type(vert));
+        }
+    }
+
+    return hashes;
+}
 
 template<typename Graph_t_in, typename Graph_t_out>
 vertex_idx_t<Graph_t_in> Sarkar<Graph_t_in, Graph_t_out>::out_buffer_merge(v_workw_t<Graph_t_in> commCost, const Graph_t_in &graph, std::vector<std::vector<vertex_idx_t<Graph_t_in>>> &expansionMapOutput) const {
@@ -1137,114 +1153,183 @@ vertex_idx_t<Graph_t_in> Sarkar<Graph_t_in, Graph_t_out>::out_buffer_merge(v_wor
     const std::vector< v_workw_t<Graph_t_in> > topDist = getTopDistance(commCost, graph);
     const std::vector< v_workw_t<Graph_t_in> > botDist = getBotDistance(commCost, graph);
 
-    auto cmp = [](const std::pair<long, VertexType> &lhs, const std::pair<long, VertexType> &rhs) {
+    auto cmp = [](const std::pair<long, std::vector<VertexType>> &lhs, const std::pair<long, std::vector<VertexType>> &rhs) {
         return (lhs.first > rhs.first)
                 || ((lhs.first == rhs.first) && (lhs.second < rhs.second));
     };
-    std::set<std::pair<long, VertexType>, decltype(cmp)> vertPriority(cmp);
+    std::set<std::pair<long, std::vector<VertexType>>, decltype(cmp)> vertPriority(cmp);
 
-    for (const VertexType &groupHead : graph.vertices()) {
-        if (graph.out_degree(groupHead) <= 1) continue;
+    std::vector<std::size_t> hashValues = computeNodeHashes(graph, vertexPoset, topDist);
+    std::vector<std::size_t> hashValuesWithParents = hashValues;
+    for (const VertexType &par : graph.vertices()) {
+        for (const VertexType &chld : graph.children(par)) {
+            hash_combine(hashValuesWithParents[chld], hashValues[par]);
+        }        
+    }
 
-        bool shouldSkip = false;
-        if constexpr (has_typed_vertices_v<Graph_t_in>) {
-            v_type_t<Graph_t_in> children_type = std::numeric_limits< v_type_t<Graph_t_in> >::max();
-            
-            for (const VertexType &groupFoot : graph.children(groupHead)) {
-                if (children_type == std::numeric_limits< v_type_t<Graph_t_in> >::max()) {
-                    children_type = graph.vertex_type(groupFoot);
-                }
-                if (graph.vertex_type(groupFoot) != children_type) {
-                    shouldSkip = true;
-                    break;
-                }
-            }
-        }
-        if (shouldSkip) continue;
-        for (const VertexType &groupFoot : graph.children(groupHead)) {
-            if (vertexPoset[groupFoot] != vertexPoset[groupHead] + 1) {
-                shouldSkip = true;
-                break;
-            }
-        }
-        if (shouldSkip) continue;
-        v_workw_t<Graph_t_in> combined_weight = 0;
-        for (const VertexType &groupFoot : graph.children(groupHead)) {
-            combined_weight += graph.vertex_work_weight(groupFoot);
+    std::unordered_map<std::size_t, std::set<VertexType>> orbits;
+    for (const VertexType &vert : graph.vertices()) {
+        if (graph.vertex_work_weight(vert) > params.smallWeightThreshold) continue;
+
+        const std::size_t hash = hashValuesWithParents[vert];
+        auto found_iter = orbits.find(hash); 
+        if (found_iter == orbits.end()) {
+            orbits.emplace(std::piecewise_construct, std::forward_as_tuple(hash), std::forward_as_tuple(std::initializer_list< vertex_idx_t<Graph_t_in> >{vert}));
+        } else {
+            found_iter->second.emplace(vert);
         }
-        if (combined_weight > params.maxWeight) continue;
+    }
 
-        v_workw_t<Graph_t_in> maxPath = topDist[groupHead] + botDist[groupHead] - graph.vertex_work_weight(groupHead);
-        v_workw_t<Graph_t_in> maxParentDist = 0;
-        v_workw_t<Graph_t_in> maxChildDist = 0;
+    
+    std::vector<bool> consideredVertices(graph.num_vertices(), false);
+    for (const VertexType &vert : graph.vertices()) {
+        if (graph.vertex_work_weight(vert) > params.smallWeightThreshold) continue;
+        if (consideredVertices[vert]) continue;
 
-        for (const VertexType &par : graph.parents(groupHead)) {
-            maxParentDist = std::max(maxParentDist, topDist[par] + commCost);
+        const std::set<VertexType> &orb = orbits.at(hashValuesWithParents[vert]);
+        if (orb.size() <= 1U) continue;
+
+        std::set<VertexType> parents;
+        for (const VertexType &par : graph.parents(vert)) {
+            parents.emplace(par);
         }
-        for (const VertexType &groupFoot : graph.children(groupHead)) {
-            for (const VertexType &par : graph.parents(groupFoot)) {
-                if (par == groupHead) continue;
-                maxParentDist = std::max(maxParentDist, topDist[par] + commCost);
+
+        std::set<VertexType> secureOrb;
+        for (const VertexType &vertCandidate : orb) {
+            if (vertexPoset[vertCandidate] != vertexPoset[vert]) continue;
+            if (graph.vertex_work_weight(vertCandidate) != graph.vertex_work_weight(vert)) continue;
+            if (topDist[vertCandidate] != topDist[vert]) continue;
+            if constexpr (has_typed_vertices_v<Graph_t_in>) {
+                if (graph.vertex_type(vertCandidate) != graph.vertex_type(vert)) continue;
             }
+
+            std::set<VertexType> candidateParents;
+            for (const VertexType &par : graph.parents(vertCandidate)) {
+                candidateParents.emplace(par);
+            }
+            if (candidateParents != parents) continue;
+
+            secureOrb.emplace(vertCandidate);
         }
+        if (secureOrb.size() <= 1U) continue;
 
-        for (const VertexType &groupFoot : graph.children(groupHead)) {
-            for (const VertexType &chld : graph.children(groupFoot)) {
-                maxChildDist = std::max(maxChildDist, botDist[chld] + commCost);
+        
+        auto descendantsCmp = [&vertexPoset](const VertexType &lhs, const VertexType &rhs) {
+            return (vertexPoset[lhs] < vertexPoset[rhs])
+            || ((vertexPoset[lhs] == vertexPoset[rhs]) && (lhs < rhs));
+        };
+        
+        std::map<VertexType, std::set<VertexType>, decltype(descendantsCmp)> descendantQueue(descendantsCmp);
+        for (const VertexType orbVert : secureOrb) {
+            for (const VertexType chld : graph.children(orbVert)) {
+                auto it = descendantQueue.find(chld);
+                if (it == descendantQueue.end()) {
+                    descendantQueue.emplace(chld, std::initializer_list< vertex_idx_t<Graph_t_in> >{orbVert});
+                } else {
+                    it->second.emplace(orbVert);
+                }
             }
         }
+        
+        Union_Find_Universe<VertexType, VertexType, v_workw_t<Graph_t_in>, unsigned> similarityGroupings;
+        for (const VertexType orbVert : secureOrb) {
+            similarityGroupings.add_object(orbVert);
+        }
+
+        // todo make me a parameter
+        constexpr vertex_idx_t<Graph_t_in> groupingSearchDepth = static_cast< vertex_idx_t<Graph_t_in> >(5);
+        for (vertex_idx_t<Graph_t_in> i = 0; i < groupingSearchDepth; ++i) {
+            if (descendantQueue.empty()) continue;
+            const vertex_idx_t<Graph_t_in> level = vertexPoset[ descendantQueue.cbegin()->first ];
+            while ((!descendantQueue.empty()) && vertexPoset[ descendantQueue.cbegin()->first ] == level) {
+                const VertexType &descendant = descendantQueue.cbegin()->first;
+                const std::set<VertexType> &orbSubset = descendantQueue.cbegin()->second;
+
+                const VertexType firstVert = *orbSubset.begin();
+                for (const VertexType otherVert : orbSubset) {
+                    similarityGroupings.join_by_name(firstVert, otherVert);
+                }
 
-        v_workw_t<Graph_t_in> newMaxPath = maxParentDist + maxChildDist + graph.vertex_work_weight(groupHead);
-        for (const VertexType &groupFoot : graph.children(groupHead)) {
-            newMaxPath += graph.vertex_work_weight(groupFoot);
+                for (const VertexType chld : graph.children(descendant)) {
+                    auto it = descendantQueue.find(chld);
+                    if (it == descendantQueue.end()) {
+                        descendantQueue.emplace(chld, std::initializer_list< vertex_idx_t<Graph_t_in> >{*orbSubset.cbegin()});
+                    } else {
+                        it->second.insert(*orbSubset.cbegin());
+                    }
+                }
+
+                descendantQueue.erase(descendantQueue.begin());
+            }
+
+            // TODO stuff
         }
 
-        long savings = static_cast<long>(maxPath) - static_cast<long>(newMaxPath);
-        if (savings + static_cast<long>(params.leniency * static_cast<double>(maxPath)) >= 0) {
-            vertPriority.emplace(savings, groupHead);
+        // Union_Find_Universe<VertexType, VertexType, v_workw_t<Graph_t_in>, unsigned> bestSimilarGrouping = similarityGroupings;
+        // todo
+
+
+
+
+
+
+
+        for (const VertexType &touchedVertex : secureOrb) {
+            consideredVertices[touchedVertex] = true;
         }
     }
 
-    std::vector<bool> partitionedFlag(graph.num_vertices(), false);
 
-    vertex_idx_t<Graph_t_in> maxCorseningNum = graph.num_vertices() - static_cast<vertex_idx_t<Graph_t_in>>(static_cast<double>(graph.num_vertices()) * params.geomDecay);
 
-    vertex_idx_t<Graph_t_in> counter = 0;
-    long minSave = std::numeric_limits<long>::lowest();
-    for (auto prioIter = vertPriority.begin(); prioIter != vertPriority.end(); prioIter++) {
-        const long &vertSave = prioIter->first;
-        const VertexType &groupHead = prioIter->second;
 
-        // Iterations halt
-        if (vertSave < minSave) break;
 
-        // Check whether we can glue
-        bool shouldSkip = false;
-        for (const VertexType &groupFoot : graph.children(groupHead)) {
-            if (partitionedFlag[groupFoot]) {
-                shouldSkip = true;
-                break;
-            }
-        }
-        if (shouldSkip) continue;
 
-        // Adding to partition
-        std::vector<VertexType> part;
-        part.reserve(graph.out_degree(groupHead));
-        for (const VertexType &groupFoot : graph.children(groupHead)) {
-            part.emplace_back(groupFoot);
-        }
 
-        expansionMapOutput.emplace_back( std::move(part) );
-        counter += graph.out_degree(groupHead) - 1;
-        if (counter > maxCorseningNum) {
-            minSave = vertSave;
-        }
+
+
+
+    // todo
+
+    std::vector<bool> partitionedFlag(graph.num_vertices(), false);
+
+    // vertex_idx_t<Graph_t_in> maxCorseningNum = graph.num_vertices() - static_cast<vertex_idx_t<Graph_t_in>>(static_cast<double>(graph.num_vertices()) * params.geomDecay);
+
+    vertex_idx_t<Graph_t_in> counter = 0;
+    // long minSave = std::numeric_limits<long>::lowest();
+    // for (auto prioIter = vertPriority.begin(); prioIter != vertPriority.end(); prioIter++) {
+    //     const long &vertSave = prioIter->first;
+    //     const VertexType &groupHead = prioIter->second;
+
+    //     // Iterations halt
+    //     if (vertSave < minSave) break;
+
+    //     // Check whether we can glue
+    //     bool shouldSkip = false;
+    //     for (const VertexType &groupFoot : graph.children(groupHead)) {
+    //         if (partitionedFlag[groupFoot]) {
+    //             shouldSkip = true;
+    //             break;
+    //         }
+    //     }
+    //     if (shouldSkip) continue;
+
+    //     // Adding to partition
+    //     std::vector<VertexType> part;
+    //     part.reserve(graph.out_degree(groupHead));
+    //     for (const VertexType &groupFoot : graph.children(groupHead)) {
+    //         part.emplace_back(groupFoot);
+    //     }
+
+    //     expansionMapOutput.emplace_back( std::move(part) );
+    //     counter += graph.out_degree(groupHead) - 1;
+    //     if (counter > maxCorseningNum) {
+    //         minSave = vertSave;
+    //     }
 
-        for (const VertexType &groupFoot : graph.children(groupHead)) {
-            partitionedFlag[groupFoot] = true;
-        }
-    }
+    //     for (const VertexType &groupFoot : graph.children(groupHead)) {
+    //         partitionedFlag[groupFoot] = true;
+    //     }
+    // }
 
     for (const VertexType &vert : graph.vertices()) {
         if (partitionedFlag[vert]) continue;