Add more argument parsingwip_wait_free

3 files changed, 126 insertions, 10 deletions

diff --git a/include/pgm.h b/include/pgm.h
index cafb18c..dd72bf6 100644
--- a/include/pgm.h
+++ b/include/pgm.h
@@ -90,8 +90,17 @@ typedef struct pgm_edge_attr
         size_t nr_consume;    /* #tokens consumed per invocation */
         size_t nr_threshold;  /* #tokens required before consume allowed */
 
+        // This will be 1 for producer-consumer buffer, 2 for wait-free buffer and
+        // 0 for an unknown type.
+        int ipc_type_to_use;
+
         pgm_edge_type_t type; /* type indicating underlying IPC of the edge */
 
+        /* for logical page support. Refer RTSS16 paper */
+        unsigned int color;
+        unsigned int bank;
+        unsigned long offset;
+
         /* edge-type specific params */
         union
         {
@@ -112,10 +121,6 @@ typedef struct pgm_edge_attr
                 {
                         /* The maximum number of bytes in a wait-free buffer. */
                         size_t buffer_bytes;
-                        /* for logical page support. Refer RTSS16 paper */
-                        unsigned int color;
-                        unsigned int bank;
-                        unsigned long offset;
                 };
                 struct /* POSIX message queue params */
                 {
@@ -139,7 +144,11 @@ static const edge_attr_t default_edge = {
         .nr_produce   = 1,
         .nr_consume   = 1,
         .nr_threshold = 1,
+        .ipc_type_to_use = 0,
         .type         = pgm_cv_edge,
+        .color = 0,
+        .bank = 0,
+        .offset = 0,
 };
 
 /*
diff --git a/sample_arg.txt b/sample_arg.txt
index 7e118fe..507170b 100644
--- a/sample_arg.txt
+++ b/sample_arg.txt
@@ -1 +1,25 @@
-./pgmrt --wait --cluster node0:0,node1:3,node2:-1,node4:-1 --graph node0:node1,node0:node2,node1:node4 --rates node0:1:100 --execution node0:10,node1:15,node2:20,node4:10 --budget node0:99,node1:99,node2:99,node4:99 --criticality node0:0,node1:1,node2:2,node4:2 --buffer node0:node1:512,node0:node2:256,node1:node4:32 --wsCycle 3 --etoe 100 --duration 3 &
+# The original invocation
+
+./pgmrt --wait --cluster node0:0,node1:3,node2:-1,node4:-1 \
+  --graph node0:node1,node0:node2,node1:node4 \
+  --rates node0:1:100 \
+  --execution node0:10,node1:15,node2:20,node4:10 \
+  --budget node0:99,node1:99,node2:99,node4:99 \
+  --criticality node0:0,node1:1,node2:2,node4:2 \
+  --buffer node0:node1:512,node0:node2:256,node1:node4:32 \
+  --wsCycle 3 \
+  --etoe 100 \
+  --duration 3 &
+
+# Indicates node0:node1 edge should use a wait free buffer and node0:node2 to use a producer-consumer buffer.
+
+./pgmrt --wait --cluster node0:0,node1:3,node2:-1,node4:-1 \
+  --graph node0:node1,node0:node2,node1:node4@node0:node1,wf,0000ffff,000000fc,00000000@node0:node2,pc,0000ffff,000000fc,00000400 \
+  --rates node0:1:100 \
+  --execution node0:10,node1:15,node2:20,node4:10 \
+  --budget node0:99,node1:99,node2:99,node4:99 \
+  --criticality node0:0,node1:1,node2:2,node4:2 \
+  --buffer node0:node1:512,node0:node2:256,node1:node4:32 \
+  --wsCycle 3 \
+  --etoe 100 \
+  --duration 3 &
diff --git a/tools/pgmrt.cpp b/tools/pgmrt.cpp
index 25ad7d5..8ec9bee 100644
--- a/tools/pgmrt.cpp
+++ b/tools/pgmrt.cpp
@@ -4,6 +4,7 @@
 /* A program for running a complex PGM application. */
 
 #include <iostream>
+#include <sstream>
 #include <thread>
 #include <exception>
 #include <stdexcept>
@@ -13,6 +14,8 @@
 #include <cstdint>
 
 #include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 
 // TODO: Use std::chrono routines instead.
@@ -567,8 +570,58 @@ std::string make_edge_name(const std::string& a, const std::string& b)
         return name;
 }
 
+typedef struct {
+        std::string EdgeName;
+        // This is 0 if unknown, 1 if wait free, or 2 if producer consumer
+        uint8_t ProducerConsumerOrWaitFree;
+        uint32_t Color;
+        uint32_t Bank;
+        uint32_t Offset;
+} GraphEdgeAttributes;
+
+uint32_t HexToUint32(std::string hex) {
+        std::stringstream ss;
+        uint32_t toReturn;
+        ss << std::hex << hex;
+        ss >> toReturn;
+        return toReturn;
+}
+
+// Graph node attribute format:
+// ./pgmrt <...> --graph node0:node1,node0:node2@node0:node1,wf,0000ffff,000000fc,00000000@node1:...
+//
+// Basically, append an '@' to the end of the --graph argument string, followed
+// by a list of <edge name>:type,color,bank,offset. Attributes for more edges
+// can be appended using additional '@' symbols. Color, bank and offset are all
+// in hex.
+std::vector<GraphEdgeAttributes> ParseGraphEdgeAttributes(std::vector<std::string> desc) {
+        std::vector<std::string> attrs;
+        std::vector<GraphEdgeAttributes> toReturn;
+        for (int i = 0; i < desc.size(); i++) {
+                boost::split(attrs, desc[i], boost::is_any_of(","));
+                if (attrs.size() != 5) {
+                        printf("Error: Edge attributes must be of the format %s\n",
+                                "<edge name>,<edge type (wf or pc)>,<color>,<bank>,<offset>");
+                        exit(1);
+                }
+                GraphEdgeAttributes thisEdge;
+                thisEdge.EdgeName = attrs[0];
+                thisEdge.ProducerConsumerOrWaitFree = 0;
+                if (attrs[1] == "wf") {
+                        thisEdge.ProducerConsumerOrWaitFree = 1;
+                } else if (attrs[1] == "pc") {
+                        thisEdge.ProducerConsumerOrWaitFree = 2;
+                }
+                thisEdge.Color = HexToUint32(attrs[2]);
+                thisEdge.Bank = HexToUint32(attrs[3]);
+                thisEdge.Offset = HexToUint32(attrs[4]);
+                toReturn.push_back(thisEdge);
+        }
+        return toReturn;
+}
+
 void parse_graph_description(
-                                const std::string& desc,
+                                const std::string& desc_original,
                                 const graph_t& g,
                                 std::vector<node_t>& nodes,
                                 std::vector<edge_t>& edges)
@@ -577,10 +630,14 @@ void parse_graph_description(
         // the edges.
         // function does not need to be fast!
 
+        std::vector<std::string> nodeNameChunksAndAttributes;
         // strip token information
         std::vector<std::string> nodeNameChunks;
         std::set<std::string> nodeNames; // set to ensure uniqueness
+        boost::split(nodeNameChunksAndAttributes, desc_original, boost::is_any_of("@"));
+        std::string desc = nodeNameChunksAndAttributes[0];
         boost::split(nodeNameChunks, desc, boost::is_any_of(",") || boost::is_any_of(":"));
+
         for(auto nStr(nodeNameChunks.begin()); nStr != nodeNameChunks.end(); ++nStr) {
                 std::vector<std::string> tokenDesc;
                 boost::split(tokenDesc, *nStr, boost::is_any_of("."));
@@ -591,7 +648,17 @@ void parse_graph_description(
         for(auto nStr(nodeNames.begin()); nStr != nodeNames.end(); ++nStr) {
                 printf("Node = %s\n", nStr->c_str());
         }
-                
+
+        // Delete the original edge definitions in the attributes list...
+        nodeNameChunksAndAttributes[0] = nodeNameChunksAndAttributes[nodeNameChunksAndAttributes.size() - 1];
+        nodeNameChunksAndAttributes.pop_back();
+        std::vector<GraphEdgeAttributes> edgeAttrs = ParseGraphEdgeAttributes(nodeNameChunksAndAttributes);
+        for (int i = 0; i < edgeAttrs.size(); i++) {
+                printf("Edge %s: Type %d, color 0x%08x, bank 0x%08x, offset 0x%08x\n",
+                        edgeAttrs[i].EdgeName.c_str(), (int) edgeAttrs[i].ProducerConsumerOrWaitFree,
+                        edgeAttrs[i].Color, edgeAttrs[i].Bank, edgeAttrs[i].Offset);
+        }
+
         // process each uniquely named node
         std::map<std::string, node_t> nodeMap;
         for(auto nStr(nodeNames.begin()); nStr != nodeNames.end(); ++nStr) {
@@ -604,7 +671,9 @@ void parse_graph_description(
         // create all the edges.
         std::vector<std::string> edgeDesc;
         boost::split(edgeDesc, desc, boost::is_any_of(","));
+        GraphEdgeAttributes *thisEdgeAttributes;
         for(auto eStr(edgeDesc.begin()); eStr != edgeDesc.end(); ++eStr) {
+                thisEdgeAttributes = NULL;
                 std::vector<std::string> nodePair;
                 boost::split(nodePair, *eStr, boost::is_any_of(":"));
                 if(nodePair.size() > 2) {
@@ -614,7 +683,7 @@ void parse_graph_description(
                         // assume single-node graph
                         continue;
                 }
-
+                std::string edgeName = "";
                 int nr_produce = 1;
                 int nr_consume = 1;
                 int nr_threshold = 1;
@@ -627,6 +696,7 @@ void parse_graph_description(
                         nr_produce = boost::lexical_cast<int>(tokenDesc[1]);
                         nodePair[0] = tokenDesc[0];
                 }
+                edgeName = tokenDesc[0] + ":";
                 tokenDesc.clear();
                 boost::split(tokenDesc, nodePair[1], boost::is_any_of("."));
                 if(tokenDesc.size() > 1) {
@@ -639,8 +709,14 @@ void parse_graph_description(
                         }
                         nodePair[1] = tokenDesc[0];
                 }
-
-                
+                edgeName += tokenDesc[0];
+                thisEdgeAttributes = NULL;
+                for (int j = 0; j < edgeAttrs.size(); j++) {
+                        if (edgeAttrs[j].EdgeName == edgeName) {
+                                thisEdgeAttributes = &(edgeAttrs[j]);
+                                break;
+                        }
+                }
                 edge_t e;
                 edge_attr_t cv_attr;
                 memset(&cv_attr, 0, sizeof(cv_attr));
@@ -648,6 +724,13 @@ void parse_graph_description(
                 cv_attr.nr_produce = nr_produce;
                 cv_attr.nr_consume = nr_consume;
                 cv_attr.nr_threshold = nr_threshold;
+                if (thisEdgeAttributes) {
+                        printf("Applying additional attributes for edge %s\n", edgeName.c_str());
+                        cv_attr.color = thisEdgeAttributes->Color;
+                        cv_attr.bank = thisEdgeAttributes->Bank;
+                        cv_attr.offset = thisEdgeAttributes->Offset;
+                        cv_attr.ipc_type_to_use = thisEdgeAttributes->ProducerConsumerOrWaitFree;
+                }
                 CheckError(pgm_init_edge(&e, nodeMap[nodePair[0]], nodeMap[nodePair[1]],
                                 make_edge_name(nodePair[0], nodePair[1]).c_str(), &cv_attr));
                 edges.push_back(e);