Add more traces and fix bug (#15)

Signed-off-by: Ze Gan <[email protected]>

alphartc_gym/tests/test_gym.py

@@ -4,6 +4,8 @@
 from alphartc_gym import gym
 
 import os
+import glob
+
 
 def test_basic():
     total_stats = []
@@ -43,18 +45,16 @@ def test_multiple_instances():
 
 def test_trace():
     total_stats = []
-    trace_path = os.path.join(
-        os.path.dirname(__file__),
-        "data",
-        "trace_example.json")
-    g = gym.Gym("test_gym")
-    g.reset(trace_path=trace_path, report_interval_ms=60, duration_time_ms=0)
-    while True:
-        stats, done = g.step(1000)
-        if  not done:
-            total_stats += stats
-        else:
-            break
-    assert(total_stats)
-    for stats in total_stats:
-        assert(isinstance(stats, dict))
+    trace_files = os.path.join(os.path.dirname(__file__), "data", "*.json")
+    for trace_file in glob.glob(trace_files):
+        g = gym.Gym("test_gym")
+        g.reset(trace_path=trace_file, report_interval_ms=60, duration_time_ms=0)
+        while True:
+            stats, done = g.step(1000)
+            if  not done:
+                total_stats += stats
+            else:
+                break
+        assert(total_stats)
+        for stats in total_stats:
+            assert(isinstance(stats, dict))

ns-app/scratch/webrtc_test/trace_player.cc

@@ -1,6 +1,5 @@
 #include "trace_player.h"
 
-#include "ns3/point-to-point-net-device.h"
 #include "ns3/simulator.h"
 #include "ns3/string.h"
 #include "ns3/error-model.h"
@@ -41,16 +40,24 @@ void TracePlayer::LoadTrace() {
     auto uplink_traces = j["uplink"]["trace_pattern"];
     std::vector<TraceItem> traces;
     traces.reserve(uplink_traces.size());
+
+    TraceItem last_available_value;
     for (const auto &trace: uplink_traces) {
         TraceItem ti;
-        ti.capacity_ = lexical_cast<decltype(ti.capacity_)>(trace["capacity"]);
-        ti.duration_ms_ = lexical_cast<decltype(ti.duration_ms_)>(trace["duration"]);
+        ti.capacity_ = lexical_cast<double>(trace["capacity"]);
+        ti.duration_ms_ = lexical_cast<double>(trace["duration"]);
         if (trace.find("loss") != trace.end()) {
             ti.loss_rate_ = lexical_cast<double>(trace["loss"]);
+            last_available_value.loss_rate_ = ti.loss_rate_;
+        } else {
+            ti.loss_rate_ = last_available_value.loss_rate_;
         }
         if (trace.find("rtt") != trace.end()) {
             ti.rtt_ms_ = lexical_cast<std::uint64_t>(trace["rtt"]);
-        }        
+            last_available_value.rtt_ms_ = ti.rtt_ms_;
+        } else {
+            ti.rtt_ms_ = last_available_value.rtt_ms_;
+        }
         traces.push_back(std::move(ti));
     }
     traces_.swap(traces);
@@ -74,16 +81,27 @@ void TracePlayer::PlayTrace(size_t trace_index) {
             auto device =
                 dynamic_cast<PointToPointNetDevice *>(PeekPointer(node->GetDevice(j)));
             if (device) {
-                device->SetDataRate(DataRate(trace.capacity_ * 1e3));
                 // set loss rate in every device
                 if (trace.loss_rate_) {
-                    Ptr<RateErrorModel> em = CreateObjectWithAttributes<RateErrorModel> ("RanVar", StringValue("ns3::UniformRandomVariable[Min=0.0|Max=1.0]"), \
-                                                                                     "ErrorRate", DoubleValue (trace.loss_rate_.value()), \
-                                                                                     "ErrorUnit", StringValue("ERROR_UNIT_PACKET"));
-                    device->SetAttribute("ReceiveErrorModel", PointerValue (em));
+                    SetLossRate(device, trace.loss_rate_.value());
+                }
+                if (trace.capacity_ == 0) {
+                    SetLossRate(device, 1.0);
+                } else {
+                    device->SetDataRate(DataRate(trace.capacity_ * 1e3));
+                    if (!trace.loss_rate_) {
+                        SetLossRate(device, 0.0);
+                    }
                 }
             }
         }
     }
     Simulator::Schedule(MilliSeconds(trace.duration_ms_), &TracePlayer::PlayTrace, this, trace_index + 1);
 }
+
+void TracePlayer::SetLossRate(ns3::PointToPointNetDevice *device, double loss_rate) {
+    Ptr<RateErrorModel> em = CreateObjectWithAttributes<RateErrorModel> ("RanVar", StringValue("ns3::UniformRandomVariable[Min=0.0|Max=1.0]"), \
+                                                                        "ErrorRate", DoubleValue (loss_rate), \
+                                                                        "ErrorUnit", StringValue("ERROR_UNIT_PACKET"));
+    device->SetAttribute("ReceiveErrorModel", PointerValue (em));
+}

ns-app/scratch/webrtc_test/trace_player.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "ns3/point-to-point-net-device.h"
 #include "ns3/node-container.h"
 
 #include <string>
@@ -25,7 +26,10 @@ class TracePlayer {
 
     void PlayTrace(size_t trace_index = 0);
 
+    void SetLossRate(ns3::PointToPointNetDevice *device, double loss_rate);
+
     const std::string source_file_;
     std::vector<TraceItem> traces_;
     ns3::NodeContainer &nodes_;
+
 };