Merge pull request #534 from UWB-Biocomputing/issue-490-responder-dispatch

[ISSUE 490] Implemented the responder dispatch logic

Author: jardiamj

Simulator/Connections/NG911/Connections911.cpp

@@ -3,14 +3,12 @@
 *
 * @ingroup Simulator/Connections/NG911
 * 
-* @brief The model of the static network
-*
+* @brief This class manages the Connections of the NG911 network
 */
 
 #include "Connections911.h"
-#include "All911Vertices.h"
+#include "All911Edges.h"
 #include "GraphManager.h"
-#include "Layout911.h"
 #include "ParameterManager.h"
 
 void Connections911::setup()
@@ -64,9 +62,6 @@ void Connections911::printParameters() const
 
 #if !defined(USE_GPU)
 ///  Update the connections status in every epoch.
-///
-///  @param  vertices  The Vertex list to search from.
-///  @return true if successful, false otherwise.
 bool Connections911::updateConnections(AllVertices &vertices)
 {
    // Only run on the first epoch
@@ -92,11 +87,55 @@ bool Connections911::updateConnections(AllVertices &vertices)
    return true;
 }
 
+
+/// Finds the outgoing edge from the given vertex to the Responder closest to
+/// the emergency call location
+BGSIZE Connections911::getEdgeToClosestResponder(const Call &call, BGSIZE vertexIdx)
+{
+   All911Edges &edges911 = dynamic_cast<All911Edges &>(*edges_);
+
+   vertexType requiredType;
+   if (call.type == "Law")
+      requiredType = LAW;
+   else if (call.type == "EMS")
+      requiredType = EMS;
+   else if (call.type == "Fire")
+      requiredType = FIRE;
+
+   // loop over the outgoing edges looking for the responder with the shortest
+   // Euclidean distance to the call's location.
+   BGSIZE startOutEdg = synapseIndexMap_->outgoingEdgeBegin_[vertexIdx];
+   BGSIZE outEdgCount = synapseIndexMap_->outgoingEdgeCount_[vertexIdx];
+   Layout &layout = Simulator::getInstance().getModel().getLayout();
+
+   BGSIZE resp, respEdge;
+   double minDistance = numeric_limits<double>::max();
+   for (BGSIZE eIdxMap = startOutEdg; eIdxMap < startOutEdg + outEdgCount; ++eIdxMap) {
+      BGSIZE outEdg = synapseIndexMap_->outgoingEdgeIndexMap_[eIdxMap];
+      assert(edges911.inUse_[outEdg]);   // Edge must be in use
+
+      BGSIZE dstVertex = edges911.destVertexIndex_[outEdg];
+      if (layout.vertexTypeMap_[dstVertex] == requiredType) {
+         double xDelta = call.x - layout.xloc_[dstVertex];
+         double yDelta = call.y - layout.yloc_[dstVertex];
+         double distance = sqrt(pow(xDelta, 2) + pow(yDelta, 2));
+
+         if (distance < minDistance) {
+            minDistance = distance;
+            resp = dstVertex;
+            respEdge = outEdg;
+         }
+      }
+   }
+
+   // We must have found the closest responder of the right type
+   assert(minDistance < numeric_limits<double>::max());
+   assert(layout.vertexTypeMap_[resp] == requiredType);
+   return respEdge;
+}
+
+
 ///  Randomly delete 1 PSAP and rewire all the edges around it.
-///
-///  @param  vertices  The Vertex list to search from.
-///  @param  layout   Layout information of the vertex network.
-///  @return true if successful, false otherwise.
 bool Connections911::erasePSAP(AllVertices &vertices, Layout &layout)
 {
    int numVertices = Simulator::getInstance().getTotalVertices();
@@ -155,7 +194,8 @@ bool Connections911::erasePSAP(AllVertices &vertices, Layout &layout)
          }
 
          // Identify all psap-less responders
-         if (layout.vertexTypeMap_[destVertex] == RESP) {
+         if (layout.vertexTypeMap_[destVertex] == LAW || layout.vertexTypeMap_[destVertex] == FIRE
+             || layout.vertexTypeMap_[destVertex] == EMS) {
             respsToReroute.push_back(destVertex);
          }
       }
@@ -232,10 +272,6 @@ bool Connections911::erasePSAP(AllVertices &vertices, Layout &layout)
 }
 
 ///  Randomly delete 1 RESP.
-///
-///  @param  vertices  The Vertex list to search from.
-///  @param  layout   Layout information of the vertex network.
-///  @return true if successful, false otherwise.
 bool Connections911::eraseRESP(AllVertices &vertices, Layout &layout)
 {
    int numVertices = Simulator::getInstance().getTotalVertices();
@@ -245,7 +281,8 @@ bool Connections911::eraseRESP(AllVertices &vertices, Layout &layout)
 
    // Find all resps
    for (int i = 0; i < numVertices; i++) {
-      if (layout.vertexTypeMap_[i] == RESP) {
+      if (layout.vertexTypeMap_[i] == LAW || layout.vertexTypeMap_[i] == FIRE
+          || layout.vertexTypeMap_[i] == EMS) {
          resps.push_back(i);
       }
    }
@@ -294,7 +331,8 @@ bool Connections911::eraseRESP(AllVertices &vertices, Layout &layout)
    return changesMade;
 }
 
-///  @return xml representation of a single edge
+
+///  Returns an xml representation of a single edge
 string Connections911::ChangedEdge::toString()
 {
    stringstream os;
@@ -331,8 +369,6 @@ string Connections911::ChangedEdge::toString()
 }
 
 ///  Returns the complete list of all deleted or added edges as a string.
-///  @param added    true returns the list of added edges, false = erased
-///  @return xml representation of all deleted or added edges
 string Connections911::changedEdgesToXML(bool added)
 {
    stringstream os;
@@ -357,7 +393,6 @@ string Connections911::changedEdgesToXML(bool added)
 }
 
 ///  Returns the complete list of deleted vertices as a string.
-///  @return xml representation of all deleted vertices
 string Connections911::erasedVerticesToXML()
 {
    stringstream os;

Simulator/Connections/NG911/Connections911.h

@@ -3,15 +3,18 @@
  *
  * @ingroup Simulator/Connections/NG911
  * 
- * @brief The model of the static network
- *
+ * @brief This class manages the Connections of the NG911 network
+ * 
+ * Connections in the NG911 models, represent communication links between the
+ * various network nodes. These are potentially dynamic connections, where
+ * edges between nodes are erased and added, representing loss of communication
+ * between nodes and re-routing of disconnected nodes.
  */
 
 #pragma once
 
 #include "Connections.h"
-#include "Global.h"
-#include "Simulator.h"
+#include "InputEvent.h"
 #include <vector>
 
 using namespace std;
@@ -73,6 +76,14 @@ class Connections911 : public Connections {
    ///  @return true if successful, false otherwise.
    virtual bool updateConnections(AllVertices &vertices) override;
 
+   /// Finds the outgoing edge from the given vertex to the Responder closest to
+   /// the emergency call location
+   ///
+   /// @param call         The call that needs a Responder
+   /// @param vertexIdx    The index of the vertex serving the call (A PSAP)
+   /// @return    The index of the outgoing edge to the closest Responder
+   BGSIZE getEdgeToClosestResponder(const Call &call, BGSIZE vertexIdx);
+
    ///  Returns the complete list of all deleted or added edges as a string.
    ///  @return xml representation of all deleted or added edges
    string changedEdgesToXML(bool added);

Simulator/Edges/NG911/All911Edges.cpp

@@ -3,7 +3,7 @@
  *
  *  @ingroup Simulator/Edges/NG911
  *
- *  @brief A container of all 911 edge data
+ *  @brief Specialization of the AllEdges class for the NG911 network
  */
 
 #include "All911Edges.h"
@@ -44,9 +44,6 @@ void All911Edges::createEdge(const BGSIZE iEdg, int srcVertex, int destVertex, c
 #if !defined(USE_GPU)
 
 ///  Advance all the edges in the simulation.
-///
-///  @param  vertices           The vertex list to search from.
-///  @param  edgeIndexMap   Pointer to EdgeIndexMap structure.
 void All911Edges::advanceEdges(AllVertices &vertices, EdgeIndexMap &edgeIndexMap)
 {
    Simulator &simulator = Simulator::getInstance();
@@ -72,22 +69,25 @@ void All911Edges::advanceEdges(AllVertices &vertices, EdgeIndexMap &edgeIndexMap
          }   // Edge doesn't have a call
 
          int dst = destVertexIndex_[edgeIdx];
-
          // The destination vertex should be the one pulling the information
          assert(dst == vertex);
-         if (all911Vertices.vertexQueues_[dst].isFull()) {
+
+         CircularBuffer<Call> &dstQueue = all911Vertices.vertexQueues_[dst];
+         if (dstQueue.size() == dstQueue.capacity() - all911Vertices.busyServers_[dst]) {
             // Call is dropped because there is no space in the waiting queue
             if (!isRedial_[edgeIdx]) {
                // Only count the dropped call if it's not a redial
                all911Vertices.droppedCalls_[dst]++;
                // Record that we received a call
                all911Vertices.receivedCalls_[dst]++;
-               LOG4CPLUS_DEBUG(edgeLogger_, "Call dropped: " << all911Vertices.droppedCalls_[dst]
-                                                             << ", time: " << call_[edgeIdx].time
-                                                             << ", eIdx: " << edgeIdx);
+               LOG4CPLUS_DEBUG(edgeLogger_,
+                               "Call dropped: " << all911Vertices.droppedCalls_[dst] << ", time: "
+                                                << call_[edgeIdx].time << ", vertex: " << dst
+                                                << ", queue size: " << dstQueue.size());
             }
          } else {
-            all911Vertices.vertexQueues_[dst].put(call_[edgeIdx]);
+            // Transfer call to destination
+            dstQueue.put(call_[edgeIdx]);
             // Record that we received a call
             all911Vertices.receivedCalls_[dst]++;
             isAvailable_[edgeIdx] = true;

Simulator/Edges/NG911/All911Edges.h

@@ -1,23 +1,26 @@
 /**
- *  @file All911Edges.h
+ * @file All911Edges.h
  *
- *  @ingroup Simulator/Edges/NG911
- *
- *  @brief A container of all 911 edge data
- *
- *  The container holds edge parameters of all edges.
- *  Each kind of edge parameter is stored in a 2D array. Each item in the first
- *  dimension of the array corresponds with each vertex, and each item in the second
- *  dimension of the array corresponds with an edge parameter of each edge of the vertex.
- * Because each vertex owns different number of edges, the number of edges
- *  for each vertex is stored in a 1D array, edge_counts.
- *
- *  For CUDA implementation, we used another structure, AllEdgesDevice, where edge
- *  parameters are stored in 1D arrays instead of 2D arrays, so that device functions
- *  can access these data with less latency. When copying a edge parameter, P[i][j],
- *  from host to device, it is stored in P[i * max_edges_per_vertex + j] in
- *  AllEdgesDevice structure.
+ * @ingroup Simulator/Edges/NG911
  *
+ * @brief Specialization of the AllEdges class for the NG911 network
+ * 
+ * In the NG911 Model, an edge represent a communication link between two nodes.
+ * When communication messages, such as calls, are send between the vertices;
+ * they are placed in the outgoing edge of the vertex where the message
+ * originates. These messages are then pulled, for processing, by the destination
+ * vertex.
+ * 
+ * Besides having a placeholder for the message being sent, each edge has
+ * parameters to keep track of its availability. It is worth mentioning that
+ * because the class contains all the edges; these parameters are contained in
+ * vectors or arrays, where each item correspond to an edge parameter.
+ * 
+ * During the `advanceEdges` step of the simulation the destination vertex pulls
+ * the calls placed in the given edge and queues them into their internal queue.
+ * Here we check that there is space in the queue, the queue in considered full
+ * if all trunks are busy. That is, if the total calls in the waiting queue +
+ * the number of busy agents equals the total number of trunks available.
  */
 
 #pragma once
@@ -82,7 +85,7 @@ class All911Edges : public AllEdges {
 public:
    ///  Advance all the edges in the simulation.
    ///
-   ///  @param  vertices           The vertex list to search from.
+   ///  @param  vertices       The vertex list to search from.
    ///  @param  edgeIndexMap   Pointer to EdgeIndexMap structure.
    virtual void advanceEdges(AllVertices &vertices, EdgeIndexMap &edgeIndexMap);
 

Simulator/Layouts/NG911/Layout911.cpp

@@ -3,14 +3,14 @@
 * 
 * @ingroup Simulator/Layouts/NG911
 *
-* @brief The Layout class defines the layout of vertices in networks
+* @brief Specialization of the Layout class for the NG911 network
 */
 
-// #include <string>
 #include "Layout911.h"
 #include "GraphManager.h"
 #include "ParameterManager.h"
 
+// Register vertex properties with the GraphManager
 void Layout911::registerGraphProperties()
 {
    // The base class registers properties that are common to all vertices
@@ -27,17 +27,19 @@ void Layout911::registerGraphProperties()
    gm.registerProperty("type", &VertexProperty::type);
    gm.registerProperty("y", &VertexProperty::y);
    gm.registerProperty("x", &VertexProperty::x);
-   gm.registerProperty("agents", &VertexProperty::agents);
+   gm.registerProperty("servers", &VertexProperty::servers);
    gm.registerProperty("trunks", &VertexProperty::trunks);
    gm.registerProperty("segments", &VertexProperty::segments);
 }
 
+// Loads Layout911 member variables.
 void Layout911::loadParameters()
 {
    // Get the number of verticese from the GraphManager
    numVertices_ = GraphManager::getInstance().numVertices();
 }
 
+// Setup the internal structure of the class.
 void Layout911::setup()
 {
    // Base class allocates memory for: xLoc_, yLoc, dist2_, and dist_
@@ -69,12 +71,12 @@ void Layout911::setup()
    dist_ = sqrt(dist2_);
 }
 
+// Prints out all parameters to logging file.
 void Layout911::printParameters() const
 {
 }
 
-/// Creates a vertex type map.
-/// @param  numVertices number of the vertices to have in the type map.
+// Creates a vertex type map.
 void Layout911::generateVertexTypeMap(int numVertices)
 {
    DEBUG(cout << "\nInitializing vertex type map" << endl;);
@@ -83,9 +85,9 @@ void Layout911::generateVertexTypeMap(int numVertices)
    // In the GraphML file Responders are divided in LAW, FIRE, and EMS.
    // Perhaps, we need to expand the vertex types?
    map<string, vertexType> vTypeMap = {{"CALR", vertexType::CALR},
-                                       {"LAW", vertexType::RESP},
-                                       {"FIRE", vertexType::RESP},
-                                       {"EMS", vertexType::RESP},
+                                       {"LAW", vertexType::LAW},
+                                       {"FIRE", vertexType::FIRE},
+                                       {"EMS", vertexType::EMS},
                                        {"PSAP", vertexType::PSAP}};
    // Count map for debugging
    map<string, int> vTypeCount;
@@ -110,24 +112,26 @@ void Layout911::generateVertexTypeMap(int numVertices)
    LOG4CPLUS_INFO(fileLogger_, "Finished initializing vertex type map");
 }
 
-///  Returns the type of synapse at the given coordinates
-///
-///  @param    srcVertex  integer that points to a Neuron in the type map as a source.
-///  @param    destVertex integer that points to a Neuron in the type map as a destination.
-///  @return type of the synapse.
+// Returns the type of synapse at the given coordinates
 edgeType Layout911::edgType(const int srcVertex, const int destVertex)
 {
    if (vertexTypeMap_[srcVertex] == CALR && vertexTypeMap_[destVertex] == PSAP)
       return CP;
-   else if (vertexTypeMap_[srcVertex] == PSAP && vertexTypeMap_[destVertex] == RESP)
+   else if (vertexTypeMap_[srcVertex] == PSAP
+            && (vertexTypeMap_[destVertex] == LAW || vertexTypeMap_[destVertex] == FIRE
+                || vertexTypeMap_[destVertex] == EMS))
       return PR;
    else if (vertexTypeMap_[srcVertex] == PSAP && vertexTypeMap_[destVertex] == CALR)
       return PC;
    else if (vertexTypeMap_[srcVertex] == PSAP && vertexTypeMap_[destVertex] == PSAP)
       return PP;
-   else if (vertexTypeMap_[srcVertex] == RESP && vertexTypeMap_[destVertex] == PSAP)
+   else if ((vertexTypeMap_[srcVertex] == LAW || vertexTypeMap_[destVertex] == FIRE
+             || vertexTypeMap_[destVertex] == EMS)
+            && vertexTypeMap_[destVertex] == PSAP)
       return RP;
-   else if (vertexTypeMap_[srcVertex] == RESP && vertexTypeMap_[destVertex] == CALR)
+   else if ((vertexTypeMap_[srcVertex] == LAW || vertexTypeMap_[destVertex] == FIRE
+             || vertexTypeMap_[destVertex] == EMS)
+            && vertexTypeMap_[destVertex] == CALR)
       return RC;
    else
       return ETYPE_UNDEF;