adding test cases

Author: MarcG-TUE

include/maxplus/base/analysis/mcm/mcmdg.h

@@ -14,6 +14,15 @@
  *  Function        :   Compute the MCM for a graph using Dasdan-Gupta's
  *                      algorithm.
  *
+ *  @article{Dasdan1998FasterMA,
+ *    title={Faster maximum and minimum mean cycle algorithms for system-performance analysis},
+ *    author={Ali Dasdan and Rajesh K. Gupta},
+ *    journal={IEEE Trans. Comput. Aided Des. Integr. Circuits Syst.},
+ *    year={1998},
+ *    volume={17},
+ *    pages={889-899}
+ * }
+ *
  *  History         :
  *      08-11-05    :   Initial version.
  *
@@ -48,9 +57,10 @@ namespace Graphs {
 
 /**
  * mcmDG ()
- * The function computes the maximum cycle mean of a HSDF graph using
+ * The function computes the maximum cycle mean of an MCM graph using
  * Dasdan-Gupta's algorithm.
  * Note: this algorithm assumes that edge weights are integer valued !
+ * 
  * @todo
  * check if algorithm can be generalized to float edge weights
  */

include/maxplus/base/analysis/mcm/mcmgraph.h

@@ -105,6 +105,7 @@ class MCMgraph {
     MCMgraph &operator=(MCMgraph &&) = delete;
     MCMgraph &operator=(const MCMgraph &other) = delete;
 
+    [[nodiscard]] unsigned int numberOfNodes() { return static_cast<unsigned int>(this->nodes.size()); };
     [[nodiscard]] MCMnodes &getNodes() { return nodes; };
     [[nodiscard]] MCMnodeRefs getNodeRefs();
     [[nodiscard]] MCMedgeRefs getEdgeRefs();
@@ -127,6 +128,7 @@ class MCMgraph {
         return nullptr;
     };
 
+    [[nodiscard]] unsigned int numberOfEdges() { return static_cast<unsigned int>(this->edges.size()); };
     [[nodiscard]] MCMedges &getEdges() { return edges; };
 
     MCMedge *getEdge(CId id) {
@@ -196,7 +198,7 @@ class MCMgraph {
         e.dst->in.remove(&e);
     }
 
-    void relabelNodeIds(std::map<int, int> &nodeIdMap);
+    void relabelNodeIds(std::map<int, int> *nodeIdMap = nullptr);
 
     // reduce the MCM graph by removing obviously redundant edges
     // in particular if there are multiple edges between the same pair

include/maxplus/base/analysis/mcm/mcmhoward.h

@@ -88,5 +88,8 @@ void Howard(const std::vector<int> &ij,
             int *nr_iterations,
             int *nr_components);
 
+CDouble maximumCycleMeanHoward(MCMgraph &g, MCMnode **criticalNode);
+
+
 } // namespace Graphs
 #endif

src/algebra/mpmatrix.cc

@@ -1090,7 +1090,7 @@ Matrix::mp_generalized_eigenvectors() const {
 
         // MCM calculation requires node relabelling
         std::map<int, int> sccNodeIdMap;
-        scc->relabelNodeIds(sccNodeIdMap);
+        scc->relabelNodeIds(&sccNodeIdMap);
 
         if (scc->nrVisibleEdges() > 0) {
             // compute MCM mu and critical node n of scc

src/base/analysis/mcm/mcmdg.cc

@@ -14,6 +14,15 @@
  *  Function        :   Compute the MCM for an HSDF graph using Dasdan-Gupta's
  *                      algorithm.
  *
+ *  @article{Dasdan1998FasterMA,
+ *    title={Faster maximum and minimum mean cycle algorithms for system-performance analysis},
+ *    author={Ali Dasdan and Rajesh K. Gupta},
+ *    journal={IEEE Trans. Comput. Aided Des. Integr. Circuits Syst.},
+ *    year={1998},
+ *    volume={17},
+ *    pages={889-899}
+ * }
+ *
  *  History         :
  *      08-11-05    :   Initial version.
  *
@@ -46,15 +55,11 @@
 #include <memory>
 
 namespace Graphs {
-/**
- * mcmDG ()
- * The function computes the maximum cycle mean of a HSDF graph using
- * Dasdan-Gupta's algorithm.
- * Note: this algorithm assumes that edge weights are integer valued !
- * @todo
- * check if algorithm can be generalized to float edge weights
- */
-CDouble mcmDG(MCMgraph &mcmGraph) {
+
+// assumes teh graph is strongly connected and assumes the node ids are 0...N-1,
+// where N is the number of nodes
+CDouble mcmDG_SCC(MCMgraph &mcmGraph) {
+
     // Allocate memory
     const int n = mcmGraph.nrVisibleNodes();
     std::vector<int> level(n);
@@ -70,17 +75,17 @@ CDouble mcmDG(MCMgraph &mcmGraph) {
     level[0] = 0;
     std::list<int> Q_k;
     Q_k.push_back(0);
-    std::list<MCMnode*> Q_u;
+    std::list<MCMnode *> Q_u;
     Q_u.push_back(&(mcmGraph.getNodes().front()));
 
     // Compute the distances
     int k = Q_k.front();
     Q_k.pop_front();
-    MCMnode* u = Q_u.front();
+    MCMnode *u = Q_u.front();
     Q_u.pop_front();
     do {
-        for (auto& e: u->out) {
-            MCMnode* v = e->dst;
+        for (auto &e : u->out) {
+            MCMnode *v = e->dst;
 
             if (level[v->id] < static_cast<int>(k + 1)) {
                 Q_k.push_back(k + 1);
@@ -99,7 +104,7 @@ CDouble mcmDG(MCMgraph &mcmGraph) {
 
     // Compute lambda using Karp's theorem
     CDouble l = -INT_MAX;
-    for (const auto & u : mcmGraph.getNodes()) {
+    for (const auto &u : mcmGraph.getNodes()) {
 
         if (level[u.id] == n) {
             CDouble ld = INT_MAX;
@@ -114,5 +119,31 @@ CDouble mcmDG(MCMgraph &mcmGraph) {
 
     return l;
 }
+    
+    
+/**
+ * mcmDG ()
+ * The function computes the maximum cycle mean of an MCM graph using
+ * Dasdan-Gupta's algorithm.
+ * Note: this algorithm assumes that edge weights are integer valued !
+ * @todo
+ * check if algorithm can be generalized to float edge weights
+ */
+CDouble mcmDG(MCMgraph &mcmGraph) {
+
+    MCMgraphs sccs;
+    stronglyConnectedMCMgraph(mcmGraph, sccs, false);
+
+    CDouble mcm = -INFINITY;
+    for (auto &scc : sccs) {
+        scc->relabelNodeIds();
+        CDouble cmcm = mcmDG_SCC(*scc);
+        if (cmcm > mcm) {
+            mcm = cmcm;
+        }
+    }
+
+    return mcm;
+}
 
 } // namespace Graphs

src/base/analysis/mcm/mcmgraph.cc

@@ -755,11 +755,13 @@ CDouble MCMgraph::calculateMaximumCycleRatioAndCriticalCycleYoungTarjanOrlin(
     return maxCycleRatioAndCriticalCycleYoungTarjanOrlin(*this, cycle);
 }
 
-void MCMgraph::relabelNodeIds(std::map<int, int> &nodeIdMap) {
+void MCMgraph::relabelNodeIds(std::map<int, int> *nodeIdMap) {
     int k = 0;
     for (auto &i : this->nodes) {
         MCMnode &n = i;
-        nodeIdMap[k] = static_cast<int>(n.id);
+        if (nodeIdMap != nullptr) {
+            (*nodeIdMap)[k] = static_cast<int>(n.id);
+        }
         n.id = k;
         k++;
     }

src/base/analysis/mcm/mcmhoward.cc

@@ -514,4 +514,54 @@ void convertMCMgraphToMatrix(MCMgraph &g,
         }
     }
 }
+
+CDouble maximumCycleMeanHoward(MCMgraph& g, MCMnode* *criticalNode) {
+
+    if (g.numberOfNodes() == 0) {
+        if (criticalNode != nullptr) {
+            (*criticalNode) = nullptr;
+        }
+        return -INFINITY;
+    }
+
+    std::shared_ptr<std::vector<int>> ij = nullptr;
+    std::shared_ptr<std::vector<CDouble>> A = nullptr;
+    std::shared_ptr<std::vector<CDouble>> chi = nullptr;
+    std::shared_ptr<std::vector<CDouble>> v = nullptr;
+    std::shared_ptr<std::vector<int>> policy = nullptr;
+    int nr_iterations = 0;
+    int nr_components = 0;
+
+    convertMCMgraphToMatrix(g, &ij, &A);
+
+    Howard(*ij,
+           *A,
+           g.numberOfNodes(),
+           g.numberOfEdges(),
+           &chi,
+           &v,
+           &policy,
+           &nr_iterations,
+           &nr_components);
+
+    // find maximum cycle mean in chi vector
+    MCMnodes& nodes = g.getNodes();
+    auto &n = nodes.begin();
+    CDouble mcm = chi->at(0);
+    MCMnode *critNode = &(*n);
+    for (auto &val : *chi) {
+        if (val > mcm) {
+            mcm = val;
+            critNode = &(*n);
+            n++;
+        }
+    }
+
+    if (criticalNode != nullptr) {
+        (*criticalNode) = &(*n);
+    }
+    return mcm;
+}
+
+
 } // namespace Graphs

src/testbench/base/mcmtest.cc

@@ -38,19 +38,35 @@ MCMgraph makeGraph1() {
     return g;
 }
 
+// A corner case graph
+MCMgraph makeGraph2() {
+    MCMgraph g;
+
+    MCMnode &n0 = *g.addNode(0);
+    MCMnode &n1 = *g.addNode(1);
+    g.addEdge(0, n0, n1, 1.0, 1.0);
+    //g.addEdge(1, n1, n1, 1.0, 1.0);
+    return g;
+}
+
+
 // Test mcmdg.
 void MCMTest::test_dg() {
     std::cout << "Running test: MCM-dg" << std::endl;
 
-    MCMgraph g = makeGraph1();
-    CDouble result =  mcmDG(g);
+    MCMgraph g1 = makeGraph1();
+    CDouble result =  mcmDG(g1);
     ASSERT_APPROX_EQUAL(2.5, result, 1e-5);
+
+    MCMgraph g2 = makeGraph2();
+    result = mcmDG(g2);
+    ASSERT_EQUAL(-INFINITY, result);
 }
 
 /// Test MCM Howard.
 void MCMTest::test_howard() {
     std::cout << "Running test: MCM-Howard" << std::endl;
-    MCMgraph g = makeGraph1();
+    MCMgraph g1 = makeGraph1();
 
     std::shared_ptr<std::vector<int>> ij = nullptr;
     std::shared_ptr<std::vector<CDouble>> A = nullptr;
@@ -60,12 +76,12 @@ void MCMTest::test_howard() {
     int nr_iterations = 0;
     int nr_components = 0;
 
-    convertMCMgraphToMatrix(g, &ij, &A);
+    convertMCMgraphToMatrix(g1, &ij, &A);
 
-    Howard(*ij,
+   Howard(*ij,
            *A,
-           static_cast<int>(g.getNodes().size()),
-           static_cast<int>(g.getEdges().size()),
+           static_cast<int>(g1.getNodes().size()),
+           static_cast<int>(g1.getEdges().size()),
            &chi,
            &v,
            &policy,
@@ -83,6 +99,16 @@ void MCMTest::test_howard() {
     ASSERT_EQUAL(3, policy->at(2));
     ASSERT_EQUAL(0, policy->at(3));
     ASSERT_EQUAL(4, policy->at(4));
+
+    MCMnode *criticalNode;
+    CDouble result = maximumCycleMeanHoward(g1, &criticalNode);
+    ASSERT_APPROX_EQUAL(2.5, result, 1e-5);
+    ASSERT_THROW(criticalNode->id == 0 || criticalNode->id == 1 || criticalNode->id == 2
+                 || criticalNode->id == 3);
+
+    MCMgraph g2 = makeGraph2();
+    result = maximumCycleMeanHoward(g2, &criticalNode);
+    ASSERT_EQUAL(-INFINITY, result);
 }
 
 /// Test MCM Karp.