added descriptions

Author: tonibohnlein

include/osp/bsp/scheduler/GreedySchedulers/GreedyMetaScheduler.hpp

@@ -26,13 +26,23 @@ limitations under the License.
 
 namespace osp {
 
+
+/**
+ * @class GreedyMetaScheduler
+ * @brief The GreedyMetaScheduler class represents a meta-scheduler that selects the best schedule produced from a list of
+ * added schedulers.
+ *
+ * This class inherits from the Scheduler class and implements the computeSchedule() and getScheduleName() methods.
+ * The computeSchedule() method iterates through a list of schedulers, computes a schedule using each one,
+ * and returns the schedule with the minimum cost.
+ */
 template<typename Graph_t>
 class GreedyMetaScheduler : public Scheduler<Graph_t> {
 
     Serial<Graph_t> serial_scheduler_;
     std::vector<Scheduler<Graph_t>*> schedulers_;
 
-    static constexpr bool verbose = true;
+    static constexpr bool verbose = false;
 
   public:
     /**

include/osp/bsp/scheduler/Serial.hpp

@@ -25,6 +25,12 @@ limitations under the License.
 #include <string>
 namespace osp {
 
+/**
+ * @class Serial
+ * @brief The Serial class represents a scheduler that assigns all tasks to a single processor in a serial manner. 
+ * If the architecture is heterogeneous, it assigns tasks to one processor of each type computing a schedule with the smallest number of supersteps.
+ * 
+ */
 template<typename Graph_t>
 class Serial : public Scheduler<Graph_t> {
 

include/osp/dag_divider/isomorphism_divider/HashComputer.hpp

@@ -23,6 +23,15 @@ limitations under the License.
 
 namespace osp {
 
+/**
+* @class HashComputer
+* @brief Abstract base class for computing and managing hash values and orbits for graph vertices.
+*
+* 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.
+*/
 template<typename index_type>
 class HashComputer {
 public:

include/osp/dag_divider/isomorphism_divider/IsomorphicSubgraphScheduler.hpp

@@ -31,6 +31,24 @@ limitations under the License.
 
 namespace osp {
 
+/** 
+ * @brief A scheduler that leverages isomorphic subgraphs to partition a DAG.
+ *
+ * @class IsomorphicSubgraphScheduler
+ *
+ * This scheduler first identifies isomorphic subgraphs within the input DAG using a hash-based approach.
+ * It then groups these isomorphic subgraphs into "orbits". Each orbit is treated as a single node in a
+ * coarser graph. The scheduler then uses an ETF-like approach to schedule these coarse nodes (orbits)
+ * onto available processors. Finally, the schedule for each orbit is "unrolled" back to the original
+ * DAG, assigning a partition ID to each original vertex.
+ *
+ * The scheduler supports trimming of isomorphic groups to better fit processor counts, and can
+ * dynamically switch between a standard BSP scheduler and a specialized TrimmedGroupScheduler
+ * for these trimmed groups.
+ *
+ * @tparam Graph_t The type of the input computational DAG.
+ * @tparam Constr_Graph_t The type of the constructable computational DAG used for internal representations.
+ */
 template<typename Graph_t, typename Constr_Graph_t>
 class IsomorphicSubgraphScheduler {
     static_assert(is_computational_dag_v<Graph_t>, "Graph must be a computational DAG");

include/osp/dag_divider/isomorphism_divider/MerkleHashComputer.hpp

@@ -31,6 +31,19 @@ limitations under the License.
 
 namespace osp {
 
+/** 
+ * @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
+ * and the sorted hashes of its parents (or children, depending on the `forward` template parameter).
+ * This allows for the identification of structurally isomorphic subgraphs.
+ *
+ * @tparam Graph_t The type of the graph, must satisfy the `directed_graph` concept.
+ * @tparam node_hash_func_t A functor that computes a hash for a single node.
+ *                          Defaults to `uniform_node_hash_func`.
+ * @tparam forward If true, hashes are computed based on parents (top-down).
+ *                 If false, hashes are computed based on children (bottom-up).
+ */
 template<typename Graph_t, typename node_hash_func_t = uniform_node_hash_func<vertex_idx_t<Graph_t>>, bool forward = true>
 class MerkleHashComputer : public HashComputer<vertex_idx_t<Graph_t>> {
 

include/osp/dag_divider/isomorphism_divider/OrbitGraphProcessor.hpp

@@ -304,12 +304,6 @@ class OrbitGraphProcessor {
                                 << temp_coarse_graph.num_vertices() << " nodes.\n";
                     }
 
-                    // No checks are performed in this function, so we commit directly.
-                    if constexpr (verbose) {
-                        std::cout << "  - Merging " << v << " into " << u << ". New coarse graph has "
-                                  << temp_coarse_graph.num_vertices() << " nodes.\n";
-                    }
-
                     commit_merge(u, v, std::move(temp_coarse_graph), temp_contraction_map, std::move(new_subgraphs),
                                  current_coarse_graph, current_groups, current_contraction_map);
 

include/osp/dag_divider/isomorphism_divider/TrimmedGroupScheduler.hpp

@@ -30,7 +30,6 @@ namespace osp {
  * @brief A scheduler for a single trimmed group, which consists of multiple isomorphic connected components.
  *
  * @class TrimmedGroupScheduler
- * @brief A scheduler for a single trimmed group, which consists of multiple isomorphic connected components.
  *
  * This scheduler functions similarly to the ConnectedComponentScheduler but is tailored for a single,
  * potentially disconnected, subgraph that resulted from merging smaller isomorphic subgraphs. It divides