modified HyperdagDB reader, added hyperDagDB writer

added hyperdagDB writer

update

Author: tonibohnlein

include/osp/auxiliary/io/hdag_graph_file_reader.hpp

@@ -164,7 +164,8 @@ bool readComputationalDagHyperdagFormatDB(std::ifstream& infile, Graph_t& graph)
         return false;
     }
 
-    std::vector<v_commw_t<Graph_t>> hyperedge_weights(static_cast<size_t>(hEdges), 1);
+    std::vector<v_commw_t<Graph_t>> hyperedge_comm_weights(static_cast<size_t>(hEdges), 1);
+    std::vector<v_memw_t<Graph_t>> hyperedge_mem_weights(static_cast<size_t>(hEdges), 1);
 
     // Read hyperedges
     for (int i = 0; i < hEdges; ++i) {
@@ -175,18 +176,19 @@ bool readComputationalDagHyperdagFormatDB(std::ifstream& infile, Graph_t& graph)
         }
 
         std::istringstream edgeStream(line);
-        int hEdge = -1, weight = 1;
+        int hEdge = -1, comm_weight = 1, mem_weight = 1;
         if (!(edgeStream >> hEdge)) {
             std::cerr << "Warning: Could not read hyperedge ID for hyperedge " << i << ".\n";
             continue;
         }
-        edgeStream >> weight; // optional
+        edgeStream >> comm_weight >> mem_weight; // optional
 
         if (hEdge < 0 || hEdge >= hEdges) {
             std::cerr << "Error: Hyperedge ID " << hEdge << " is out of range (0 to " << hEdges - 1 << ").\n";
             continue;
         }
-        hyperedge_weights[static_cast<size_t>(hEdge)] = weight;
+        hyperedge_comm_weights[static_cast<size_t>(hEdge)] = static_cast<v_commw_t<Graph_t>>(comm_weight);
+        hyperedge_mem_weights[static_cast<size_t>(hEdge)] = static_cast<v_memw_t<Graph_t>>(mem_weight);
     }
 
     graph = Graph_t(static_cast<vertex_idx_t<Graph_t>>(N));
@@ -200,20 +202,23 @@ bool readComputationalDagHyperdagFormatDB(std::ifstream& infile, Graph_t& graph)
         }
 
         std::istringstream vertexStream(line);
-        int node = -1, work = 1, comm = 1;
+        int node = -1, work = 1, type = 0;
         if (!(vertexStream >> node)) {
             std::cerr << "Warning: Could not read vertex ID for vertex " << i << ".\n";
             continue;
         }
-        vertexStream >> work >> comm;
+        vertexStream >> work >> type;
 
         if (node < 0 || node >= N) {
             std::cerr << "Error: Vertex ID " << node << " is out of range (0 to " << N - 1 << ").\n";
             continue;
         }
 
         graph.set_vertex_work_weight(static_cast<vertex_idx_t<Graph_t>>(node), static_cast<v_workw_t<Graph_t>>(work));
-        graph.set_vertex_comm_weight(static_cast<vertex_idx_t<Graph_t>>(node), static_cast<v_commw_t<Graph_t>>(comm));
+
+        if constexpr (has_typed_vertices_v<Graph_t>) {
+            graph.set_vertex_type(static_cast<vertex_idx_t<Graph_t>>(node), static_cast<v_type_t<Graph_t>>(type));
+        }  
     }
 
     // Resize(N);
@@ -239,18 +244,20 @@ bool readComputationalDagHyperdagFormatDB(std::ifstream& infile, Graph_t& graph)
             continue;
         }
 
-        std::size_t edgeIdx = static_cast<std::size_t>(hEdge);
-        std::size_t nodeIdx = static_cast<std::size_t>(node);
+        const std::size_t edgeIdx = static_cast<std::size_t>(hEdge);
+        const std::size_t nodeIdx = static_cast<std::size_t>(node);
 
         if (edgeSource[edgeIdx] == -1) {
             edgeSource[edgeIdx] = node;
+            graph.set_vertex_comm_weight(static_cast<vertex_idx_t<Graph_t>>(node), hyperedge_comm_weights[edgeIdx]);
+            graph.set_vertex_mem_weight(static_cast<vertex_idx_t<Graph_t>>(node), hyperedge_mem_weights[edgeIdx]);
         } else {
             auto edge = graph.add_edge(static_cast<vertex_idx_t<Graph_t>>(edgeSource[edgeIdx]),
                                     static_cast<vertex_idx_t<Graph_t>>(nodeIdx));
 
             if constexpr (is_modifiable_cdag_comm_edge_v<Graph_t>) {
                 graph.set_edge_comm_weight(edge.first,
-                    static_cast<e_commw_t<Graph_t>>(hyperedge_weights[edgeIdx]));
+                    static_cast<e_commw_t<Graph_t>>(hyperedge_comm_weights[edgeIdx]));
             }
         }
     }

include/osp/auxiliary/io/hdag_graph_file_writer.hpp

@@ -0,0 +1,115 @@
+/*
+Copyright 2025 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
+
+    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.
+
+@author Toni Boehnlein, Christos K. Matzoros, Pal Andras Papp, Raphael S. Steiner
+*/
+
+#pragma once
+
+#include <fstream>
+#include <iostream>
+#include <vector>
+
+#include "osp/concepts/computational_dag_concept.hpp"
+
+namespace osp {
+namespace file_writer {
+
+/**
+ * @brief Writes a computational DAG to a stream in the HyperdagDB format.
+ *
+ * This function converts a given graph into a hypergraph representation where each node
+ * with outgoing edges becomes a hyperedge source. The format is compatible with the
+ * `readComputationalDagHyperdagFormatDB` reader.
+ *
+ * @tparam Graph_t The type of the graph, which must satisfy the ComputationalDag concept.
+ * @param os The output stream to write to.
+ * @param graph The computational DAG to write.
+ */
+template <typename Graph_t>
+void writeComputationalDagHyperdagFormatDB(std::ostream &os, const Graph_t &graph) {
+    static_assert(is_computational_dag_v<Graph_t>, "Graph_t must be a computational DAG");
+
+    const auto num_vertices = graph.num_vertices();
+    unsigned num_hyperedges = 0;
+    unsigned num_pins = 0;
+
+    std::vector<unsigned> node_to_hyperedge_idx(num_vertices);
+    std::vector<const vertex_idx_t<Graph_t> *> hyperedge_idx_to_node;
+
+    for (const auto &u : graph.vertices()) {
+        if (graph.out_degree(u) > 0) {
+            node_to_hyperedge_idx[u] = num_hyperedges;
+            hyperedge_idx_to_node.push_back(&u);
+            num_hyperedges++;
+            num_pins += (graph.out_degree(u) + 1);
+        }
+    }
+
+    // Header
+    os << "%% HyperdagDB format written by OneStopParallel\n";
+    os << num_hyperedges << " " << num_vertices << " " << num_pins << "\n";
+
+    // Hyperedges
+    os << "%% Hyperedges: ID comm_weight mem_weight\n";
+    for (unsigned i = 0; i < num_hyperedges; ++i) {
+        const auto u = *hyperedge_idx_to_node[i];
+        os << i << " " << graph.vertex_comm_weight(u) << " " << graph.vertex_mem_weight(u) << "\n";
+    }
+
+    // Vertices
+    os << "%% Vertices: ID work_weight type\n";
+    for (const auto &u : graph.vertices()) {
+        os << u << " " << graph.vertex_work_weight(u);
+        if constexpr (has_typed_vertices_v<Graph_t>) {
+            os << " " << graph.vertex_type(u);
+        } else {
+            os << " " << 0;
+        }
+        os << "\n";
+    }
+
+    // Pins
+    os << "%% Pins: HyperedgeID NodeID\n";
+    for (unsigned i = 0; i < num_hyperedges; ++i) {
+        const auto u = *hyperedge_idx_to_node[i];
+        os << i << " " << u << "\n"; // Source pin
+        for (const auto &v : graph.children(u)) {
+            os << i << " " << v << "\n"; // Target pins
+        }
+    }
+}
+
+/**
+ * @brief Writes a computational DAG to a file in the HyperdagDB format.
+ *
+ * @tparam Graph_t The type of the graph, which must satisfy the ComputationalDag concept.
+ * @param filename The path to the output file.
+ * @param graph The computational DAG to write.
+ * @return true if writing was successful, false otherwise.
+ */
+template <typename Graph_t>
+bool writeComputationalDagHyperdagFormatDB(const std::string &filename, const Graph_t &graph) {
+    std::ofstream os(filename);
+    if (!os.is_open()) {
+        std::cerr << "Error: Failed to open file for writing: " << filename << "\n";
+        return false;
+    }
+    writeComputationalDagHyperdagFormatDB(os, graph);
+    return true;
+}
+
+} // namespace file_writer
+} // namespace osp