Simulation summary and incast logging

Author: rajkiranjoshi

simulation/simulation.cpp

@@ -6,6 +6,7 @@
 #include "simulation/simulation.hpp"
 #include "utils/logger.hpp"
 #include "utils/utils.hpp"
+#include "utils/pktdumper.hpp"
 #include "topology/fattree_topology.hpp"
 
 
@@ -433,6 +434,41 @@ void Simulation::printSimulationStats(){
     ndebug_print("Generated: {} | Delivered: {}", this->nextPktId, this->totalPktsDelivered);
 }
 
+
+void Simulation::printSimulationSetup(){
+     
+    ndebug_print_yellow("########  Simulation Setup  ########");
+    ndebug_print("TrafficPattern type is {}", trafficPatternTypeToString(syndbConfig.trafficPatternType));
+    ndebug_print("TrafficDistribution type is {}", trafficGenTypeToString(syndbConfig.trafficGenType));
+    ndebug_print("Trigger initial delay is {}ns", syndbConfig.triggerInitialDelay);
+    #if LOGGING
+        ndebug_print("Logging is enabled!");
+    #else
+        ndebug_print("Logging is disabled!");
+    #endif
+
+    #if HOP_DELAY_NOISE
+        ndebug_print("HopDelayNoise is enabled!");
+    #else
+        ndebug_print("HopDelayNoise is disabled!");
+    #endif
+
+    #if TRIGGERS_ENABLED
+        ndebug_print("Triggers are enabled!");
+    #else
+        ndebug_print("Triggers are disabled!");
+    #endif
+
+    #if INCASTS_ENABLED
+        ndebug_print("Incasts are enabled!");
+    #else
+        ndebug_print("Incasts are disabled!");
+    #endif
+
+    ndebug_print("Time increment is {}ns", syndbSim.timeIncrement);
+    ndebug_print("Running simulation for {}ns ...\n",syndbSim.totalTime);
+}
+
 void Simulation::cleanUp(){
 
     ndebug_print_yellow("Flushing remaining normal pkts");

simulation/simulation.hpp

@@ -59,6 +59,7 @@ typedef struct Simulation
     void logTriggerInfoMap();
     void showLinkUtilizations();
 
+    void printSimulationSetup();
     void printSimulationStats();
     void cleanUp();
 

syndb-sim.cpp

@@ -22,6 +22,12 @@ int main(){
 
     syndbSim = Simulation();
 
+    // Init Step 0: Open files for logging
+    #if LOGGING
+    syndbSim.pktDumper->openFiles(syndbConfig.numSwitches, syndbConfig.numHosts);
+    #endif
+    syndbSim.printSimulationSetup();
+    
     // Init Step 1: Build the topology
     syndbSim.buildTopo();
 
@@ -38,13 +44,6 @@ int main(){
     // Init Step 3: Initialize the hosts
     syndbSim.initHosts();
 
-    // Init Step 4: Open files for logging
-    #if LOGGING
-    syndbSim.pktDumper->openFiles(syndbConfig.numSwitches, syndbConfig.numHosts);
-    #endif
-
-    ndebug_print("Time increment is {}ns", syndbSim.timeIncrement);
-    ndebug_print("Running simulation for {}ns ...",syndbSim.totalTime);
 
     // Main simulation loop: at time = 0; all event lists are empty. Only step 4 does some work.
     for ( ; syndbSim.currTime <= syndbSim.totalTime; syndbSim.currTime += syndbSim.timeIncrement)

traffic/incastGenerator.cpp

@@ -126,6 +126,8 @@ void IncastGenerator::generateIncast(){
             // ndebug_print("Incast pkt ID: {}", host->nextPkt->id);
         }
 
+        syndbSim.pktDumper->dumpIncastInfo(*this->nextIncast);
+
         this->updateNextIncast();
     }
 

traffic/incastGenerator.hpp

@@ -4,6 +4,7 @@
 #include <memory>
 #include <functional>
 #include <list>
+#include <set>
 #include "utils/types.hpp"
 
 

utils/logger.hpp

@@ -5,6 +5,7 @@
 #include <stdarg.h>
 #include <fmt/core.h>
 #include <fmt/color.h>
+#include "simulation/simulation.hpp"
 
 
 void log_debug(const std::string &msg);
@@ -31,13 +32,26 @@ void debug_print_yellow(const std::string &format, const Args&... args){
 
 template <typename... Args>
 void ndebug_print(const std::string &format, const Args&... args){
-    fmt::print(format, args...);
+    
+    std::string msg = fmt::format(format, args...);
+
+    #if LOGGING
+        syndbSim.pktDumper->logSimSummary(msg);
+    #endif
+
+    fmt::print(msg);
     std::putc('\n', stdout);
 }
 
 template <typename... Args>
 void ndebug_print_yellow(const std::string &format, const Args&... args){
-    std::string msg = fmt::format(format, args...); 
+    
+    std::string msg = fmt::format(format, args...);
+
+    #if LOGGING
+        syndbSim.pktDumper->logSimSummary(msg);
+    #endif
+    
     fmt::print(fg(fmt::color::yellow), msg);
     std::putc('\n', stdout);
 }

utils/pktdumper.cpp

@@ -2,6 +2,8 @@
 #include <typeinfo>
 
 #include "utils/pktdumper.hpp"
+#include "utils/logger.hpp"
+#include "traffic/triggerGenerator.hpp"
 #include <spdlog/cfg/env.h>
 
 
@@ -13,19 +15,25 @@ void PktDumper::openFiles(switch_id_t numberOfSwitches, host_id_t numberOfHosts)
     const std::tm *calendarTime = std::localtime(&currentTime);
 
     // clear stpdlog default pattern
+    debug_print("Clearing default spdlog dump pattern.");
     spdlog::set_pattern("%v");
     spdlog::init_thread_pool(QUEUE_SIZE, 1);
-    debug_print("Clearing default spdlog dump pattern.");
+
 
     this->prefixStringForFileName = "dump_" + std::to_string(calendarTime->tm_hour) + "_" + 
                                     std::to_string(calendarTime->tm_min) + "_" + 
                                     std::to_string(calendarTime->tm_sec) + "_";
-    ndebug_print("PktDump file prefix: {}", this->prefixStringForFileName);
+
+    std::string simSummaryFileName = "./data/" + prefixStringForFileName + "summary.txt";
+    this->simSummaryFilePointer = spdlog::basic_logger_mt("summary", simSummaryFileName);
 
     // open all file pointers in write/output mode
     std::string triggerFileName = "./data/" + prefixStringForFileName + "trigger.txt";
     this->triggerFilePointer = spdlog::basic_logger_mt<spdlog::async_factory>("trigger", triggerFileName);
 
+    std::string incastFileName = "./data/" + prefixStringForFileName + "incast.txt";
+    this->incastFilePointer = spdlog::basic_logger_mt<spdlog::async_factory>("incast", incastFileName);
+
     std::string sourceDestinationFile = "./data/" + prefixStringForFileName + "sourceDestination.txt";
     this->sourceDestinationFilePointer = spdlog::basic_logger_mt<spdlog::async_factory>("sourceDestination", sourceDestinationFile);
 
@@ -37,6 +45,8 @@ void PktDumper::openFiles(switch_id_t numberOfSwitches, host_id_t numberOfHosts)
     }
 
     debug_print("Number of Hosts: {}", numberOfHosts);
+
+    ndebug_print("PktDump file prefix: {}", this->prefixStringForFileName);
 }
 
 
@@ -52,7 +62,7 @@ PktDumper::~PktDumper() {
 }
 
 
-void PktDumper::dumpPacket(normalpkt_p pkt){
+void PktDumper::dumpPacket(const normalpkt_p pkt){
 
     debug_print_yellow("--------   HOSTS   ----------");
     debug_print("Start Time: {}", pkt->startTime);
@@ -68,7 +78,7 @@ void PktDumper::dumpPacket(normalpkt_p pkt){
 }
 
 
-void PktDumper::dumpTriggerInfo(trigger_id_t triggerId, triggerInfo tinfo, SwitchType switchType){
+void PktDumper::dumpTriggerInfo(const trigger_id_t &triggerId, triggerInfo &tinfo, const SwitchType &switchType){
 
     std::string stringForTriggerFile = std::to_string(triggerId) + "\t" + std::to_string(tinfo.triggerOrigTime) + "\t" + std::to_string(tinfo.originSwitch);
 
@@ -79,3 +89,12 @@ void PktDumper::dumpTriggerInfo(trigger_id_t triggerId, triggerInfo tinfo, Switc
 
     this->triggerFilePointer->info("{}", stringForTriggerFile);
 }
+
+void PktDumper::dumpIncastInfo(const incastScheduleInfo &incastInfo){
+    this->incastFilePointer->info("{}\t{}", incastInfo.time, incastInfo.targetHostId);
+}
+
+void PktDumper::logSimSummary(const std::string &msg){
+    // this->simSummaryFilePointer->info("{}",msg);
+    this->simSummaryFilePointer->info("{}", msg);
+}

utils/pktdumper.hpp

@@ -1,4 +1,4 @@
-#ifndef PACKETDUMPER_H
+ #ifndef PACKETDUMPER_H
 #define PACKETDUMPER_H
 
 #include <map>
@@ -8,34 +8,35 @@
 #include <time.h>
 
 #include "traffic/packet.hpp"
+#include "traffic/incastGenerator.hpp"
+#include "traffic/triggerGenerator.hpp"
 #include "topology/switch.hpp"
-#include "utils/logger.hpp"
+#include <fmt/core.h>
+#include <fmt/color.h>
+
 
 // need to declare logger.hpp first because of conflict in fmt
 #include <spdlog/async.h>
+#include <spdlog/logger.h>
 #include <spdlog/sinks/basic_file_sink.h>
 
 #define QUEUE_SIZE 32768 * 2
-
-struct triggerInfo {
-    sim_time_t triggerOrigTime;
-    switch_id_t originSwitch;
-    std::map<switch_id_t, sim_time_t> rxSwitchTimes;
-};
-
-typedef struct PktDumper
+    typedef struct PktDumper
 {
     std::string prefixStringForFileName;
 
-    std::shared_ptr<spdlog::logger> triggerFilePointer, sourceDestinationFilePointer;
+    std::shared_ptr<spdlog::logger> triggerFilePointer, sourceDestinationFilePointer, incastFilePointer, simSummaryFilePointer;
     std::vector<std::shared_ptr<spdlog::logger>> switchFilePointers;
 
     ~PktDumper();
     PktDumper() = default;
 
     void openFiles(switch_id_t numberOfSwitches, host_id_t numberOfHosts);
-    void dumpPacket(normalpkt_p pkt);
-    void dumpTriggerInfo(trigger_id_t triggerId, triggerInfo tinfo, SwitchType switchType);
+    void dumpPacket(const normalpkt_p pkt);
+    void dumpTriggerInfo(const trigger_id_t &triggerId, triggerInfo &tinfo, const SwitchType &switchType);
+    void dumpIncastInfo(const incastScheduleInfo &incastInfo);
+    void logSimSummary(const std::string &msg);
+
 } PktDumper;
 
 

utils/types.hpp

@@ -2,6 +2,7 @@
 #define TYPES_H
 
 #include <cstdint>
+#include <fmt/core.h>
 
 /* Simulation Related Types */
 typedef uint64_t sim_time_t;
@@ -46,4 +47,39 @@ enum class TrafficPatternType {SimpleTopo, AlltoAll, FtUniform, FtMixed};
 enum class TrafficGenType {Continuous, Distribution};
 enum class TrafficDstType {IntraRack, InterRack};
 
+inline std::string trafficPatternTypeToString(TrafficPatternType type){
+    switch(type){
+        case TrafficPatternType::SimpleTopo:
+            return "SimpleTopo";
+            break;
+        case TrafficPatternType::AlltoAll:
+            return "AlltoAll";
+            break;
+        case TrafficPatternType::FtUniform:
+            return "FtUniform";
+            break;
+        case TrafficPatternType::FtMixed:
+            return "FtMixed";
+            break;
+        default:
+            std::string msg = fmt::format("Unknown TrafficPatternType {}", type);
+            throw std::logic_error(msg);
+            break;
+    }
+}
+
+inline std::string trafficGenTypeToString(TrafficGenType type){
+    switch(type){
+        case TrafficGenType::Continuous:
+            return "Continuous";
+            break;
+        case TrafficGenType::Distribution:
+            return "Distribution";
+            break;
+        default:
+            std::string msg = fmt::format("Unknown TrafficGenType {}", type);
+            throw std::logic_error(msg);
+    }
+}
+
 #endif