fix config and eval script

simulator/ns-3.39/examples/PowerTCP/config-burst.txt

@@ -41,7 +41,17 @@ SAMPLE_FEEDBACK 0
 PINT_LOG_BASE 1.05
 PINT_PROB 1.0
 
-RATE_BOUND 1
+SWIFT_AI 1000
+SWIFT_BETA 0.8
+SWIFT_MAX_MDF 0.5
+SWIFT_BASE_TARGET 60000
+SWIFT_HOP_SCALE 30000
+SWIFT_FS_MAX_CWND 0.1
+SWIFT_FS_MIN_CWND 0.000300
+SWIFT_FS_RANGE 0.000300
+SWIFT_MIN_CWND 0.001
+SWIFT_MAX_CWND 800000
+SWIFT_TARGET_ENDPOINT_DELAY 1000000
 
 ACK_HIGH_PRIO 0
 

simulator/ns-3.39/examples/PowerTCP/config-fairness.txt

@@ -41,7 +41,17 @@ SAMPLE_FEEDBACK 0
 PINT_LOG_BASE 1.05
 PINT_PROB 1.0
 
-RATE_BOUND 1
+SWIFT_AI 1000
+SWIFT_BETA 0.8
+SWIFT_MAX_MDF 0.5
+SWIFT_BASE_TARGET 60000
+SWIFT_HOP_SCALE 30000
+SWIFT_FS_MAX_CWND 0.1
+SWIFT_FS_MIN_CWND 0.000300
+SWIFT_FS_RANGE 0.000300
+SWIFT_MIN_CWND 0.001
+SWIFT_MAX_CWND 800000
+SWIFT_TARGET_ENDPOINT_DELAY 1000000
 
 ACK_HIGH_PRIO 0
 

simulator/ns-3.39/examples/PowerTCP/config-workload.txt

@@ -41,7 +41,17 @@ SAMPLE_FEEDBACK 0
 PINT_LOG_BASE 1.05
 PINT_PROB 1.0
 
-RATE_BOUND 1
+SWIFT_AI 1000
+SWIFT_BETA 0.8
+SWIFT_MAX_MDF 0.5
+SWIFT_BASE_TARGET 60000
+SWIFT_HOP_SCALE 30000
+SWIFT_FS_MAX_CWND 0.1
+SWIFT_FS_MIN_CWND 0.000300
+SWIFT_FS_RANGE 0.000300
+SWIFT_MIN_CWND 0.001
+SWIFT_MAX_CWND 800000
+SWIFT_TARGET_ENDPOINT_DELAY 1000000
 
 ACK_HIGH_PRIO 0
 

simulator/ns-3.39/examples/PowerTCP/powertcp-evaluation-burst.cc

@@ -71,6 +71,19 @@ double u_target = 0.95;
 uint32_t int_multi = 1;
 bool rate_bound = true;
 
+// Swift parameters
+uint32_t SwiftAi = 1000;
+double SwiftBeta = 0.8;
+double SwiftMaxMdf = 0.5;
+double SwiftBaseTarget = 60000;
+double SwiftHopScale = 30000;
+double SwiftFsMaxCwnd = 0.1;
+double SwiftFsMinCwnd = 0.000300;
+double SwiftFsRange = 0.000300;
+double SwiftMinCwnd = 0.001;
+double SwiftMaxCwnd = 800000;
+double SwiftTargetEndpointDelay = 1000000;
+
 uint32_t ack_high_prio = 0;
 uint64_t link_down_time = 0;
 uint32_t link_down_A = 0, link_down_B = 0;
@@ -829,13 +842,6 @@ main(int argc, char* argv[])
             conf >> int_multi;
             std::cout << "INT_MULTI\t\t\t\t" << int_multi << '\n';
         }
-        else if (key == "RATE_BOUND")
-        {
-            uint32_t v;
-            conf >> v;
-            rate_bound = v;
-            std::cout << "RATE_BOUND\t\t" << rate_bound << '\n';
-        }
         else if (key == "ACK_HIGH_PRIO")
         {
             conf >> ack_high_prio;
@@ -951,6 +957,61 @@ main(int argc, char* argv[])
             conf >> pint_prob;
             std::cout << "PINT_PROB\t\t\t\t" << pint_prob << '\n';
         }
+        else if (key == "SWIFT_AI")
+        {
+            conf >> SwiftAi;
+            std::cout << "SWIFT_AI\t\t\t\t" << SwiftAi << '\n';
+        }
+        else if (key == "SWIFT_BETA")
+        {
+            conf >> SwiftBeta;
+            std::cout << "SWIFT_BETA\t\t\t\t" << SwiftBeta << '\n';
+        }
+        else if (key == "SWIFT_MAX_MDF")
+        {
+            conf >> SwiftMaxMdf;
+            std::cout << "SWIFT_MAX_MDF\t\t\t\t" << SwiftMaxMdf << '\n';
+        }
+        else if (key == "SWIFT_BASE_TARGET")
+        {
+            conf >> SwiftBaseTarget;
+            std::cout << "SWIFT_BASE_TARGET\t\t\t\t" << SwiftBaseTarget << '\n';
+        }
+        else if (key == "SWIFT_HOP_SCALE")
+        {
+            conf >> SwiftHopScale;
+            std::cout << "SWIFT_HOP_SCALE\t\t\t\t" << SwiftHopScale << '\n';
+        }
+        else if (key == "SWIFT_FS_MAX_CWND")
+        {
+            conf >> SwiftFsMaxCwnd;
+            std::cout << "SWIFT_FS_MAX_CWND\t\t\t\t" << SwiftFsMaxCwnd << '\n';
+        }
+        else if (key == "SWIFT_FS_MIN_CWND")
+        {
+            conf >> SwiftFsMinCwnd;
+            std::cout << "SWIFT_FS_MIN_CWND\t\t\t\t" << SwiftFsMinCwnd << '\n';
+        }
+        else if (key == "SWIFT_FS_RANGE")
+        {
+            conf >> SwiftFsRange;
+            std::cout << "SWIFT_FS_RANGE\t\t\t\t" << SwiftFsRange << '\n';
+        }
+        else if (key == "SWIFT_MIN_CWND")
+        {
+            conf >> SwiftMinCwnd;
+            std::cout << "SWIFT_MIN_CWND\t\t\t\t" << SwiftMinCwnd << '\n';
+        }
+        else if (key == "SWIFT_MAX_CWND")
+        {
+            conf >> SwiftMaxCwnd;
+            std::cout << "SWIFT_MAX_CWND\t\t\t\t" << SwiftMaxCwnd << '\n';
+        }
+        else if (key == "SWIFT_TARGET_ENDPOINT_DELAY")
+        {
+            conf >> SwiftTargetEndpointDelay;
+            std::cout << "SWIFT_TARGET_ENDPOINT_DELAY\t\t\t\t" << SwiftTargetEndpointDelay << '\n';
+        }
         fflush(stdout);
     }
     conf.close();
@@ -968,26 +1029,37 @@ main(int argc, char* argv[])
     // IntHeader::mode
     switch (cc_mode)
     {
-        case CC_MODE::TIMELY:
-        case CC_MODE::PATCHED_TIMELY:
-            // timely or patched timely, use ts
-            IntHeader::mode = IntHeader::TS;
-            break;
-        case CC_MODE::POWERTCP:
-            // hpcc, powertcp, use int
-            IntHeader::mode = IntHeader::NORMAL;
-            break;
-        case CC_MODE::HPCC_PINT:
-            // hpcc-pint
-            IntHeader::mode = IntHeader::PINT;
-            break;
-        case CC_MODE::SWIFT:
-            IntHeader::mode = IntHeader::SWIFT;
-            break;
-        default:
-            // others, no extra header
-            IntHeader::mode = IntHeader::NONE;
-            break;
+    case CC_MODE::TIMELY:
+    case CC_MODE::PATCHED_TIMELY:
+        // timely or patched timely, use ts
+        IntHeader::mode = IntHeader::TS;
+        break;
+    case CC_MODE::POWERTCP:
+        // hpcc, powertcp, use int
+        IntHeader::mode = IntHeader::NORMAL;
+        break;
+    case CC_MODE::HPCC_PINT:
+        // hpcc-pint
+        IntHeader::mode = IntHeader::PINT;
+        break;
+    case CC_MODE::SWIFT:
+        IntHeader::mode = IntHeader::SWIFT;
+        break;
+    default:
+        // others, no extra header
+        IntHeader::mode = IntHeader::NONE;
+        break;
+    }
+
+    // set rate bound
+    switch (cc_mode)
+    {
+    case CC_MODE::SWIFT:
+        rate_bound = 0;
+        break;
+    default:
+        // it's always 1 in the config, so assuming it's ok
+        rate_bound = 1;
     }
 
     // Set Pint
@@ -1280,6 +1352,18 @@ main(int argc, char* argv[])
             rdmaHw->SetAttribute("DctcpRateAI", DataRateValue(DataRate(dctcp_rate_ai)));
             rdmaHw->SetAttribute("PowerTCPEnabled", BooleanValue(wien));
             rdmaHw->SetAttribute("PowerTCPdelay", BooleanValue(delayWien));
+            rdmaHw->SetAttribute("SwiftAi", UintegerValue(SwiftAi));
+            rdmaHw->SetAttribute("SwiftBeta", DoubleValue(SwiftBeta));
+            rdmaHw->SetAttribute("SwiftMaxMdf", DoubleValue(SwiftMaxMdf));
+            rdmaHw->SetAttribute("SwiftBaseTarget", UintegerValue(SwiftBaseTarget));
+            rdmaHw->SetAttribute("SwiftHopScale", DoubleValue(SwiftHopScale));
+            rdmaHw->SetAttribute("SwiftFsMaxCwnd", DoubleValue(SwiftFsMaxCwnd));
+            rdmaHw->SetAttribute("SwiftFsMinCwnd", DoubleValue(SwiftFsMinCwnd));
+            rdmaHw->SetAttribute("SwiftFsRange", DoubleValue(SwiftFsRange));
+            rdmaHw->SetAttribute("SwiftMinCwnd", DoubleValue(SwiftMinCwnd));
+            rdmaHw->SetAttribute("SwiftMaxCwnd", DoubleValue(SwiftMaxCwnd));
+            rdmaHw->SetAttribute("SwiftTargetEndpointDelay",
+                                 UintegerValue(SwiftTargetEndpointDelay));
             rdmaHw->SetPintSmplThresh(pint_prob);
             // create and install RdmaDriver
             Ptr<RdmaDriver> rdma = CreateObject<RdmaDriver>();

simulator/ns-3.39/examples/PowerTCP/powertcp-evaluation-fairness.cc

@@ -70,6 +70,19 @@ double u_target = 0.95;
 uint32_t int_multi = 1;
 bool rate_bound = true;
 
+// Swift parameters
+uint32_t SwiftAi = 1000;
+double SwiftBeta = 0.8;
+double SwiftMaxMdf = 0.5;
+double SwiftBaseTarget = 60000;
+double SwiftHopScale = 30000;
+double SwiftFsMaxCwnd = 0.1;
+double SwiftFsMinCwnd = 0.000300;
+double SwiftFsRange = 0.000300;
+double SwiftMinCwnd = 0.001;
+double SwiftMaxCwnd = 800000;
+double SwiftTargetEndpointDelay = 1000000;
+
 uint32_t ack_high_prio = 0;
 uint64_t link_down_time = 0;
 uint32_t link_down_A = 0, link_down_B = 0;
@@ -814,13 +827,6 @@ main(int argc, char* argv[])
             conf >> int_multi;
             std::cout << "INT_MULTI\t\t\t\t" << int_multi << '\n';
         }
-        else if (key == "RATE_BOUND")
-        {
-            uint32_t v;
-            conf >> v;
-            rate_bound = v;
-            std::cout << "RATE_BOUND\t\t" << rate_bound << '\n';
-        }
         else if (key == "ACK_HIGH_PRIO")
         {
             conf >> ack_high_prio;
@@ -936,6 +942,61 @@ main(int argc, char* argv[])
             conf >> pint_prob;
             std::cout << "PINT_PROB\t\t\t\t" << pint_prob << '\n';
         }
+        else if (key == "SWIFT_AI")
+        {
+            conf >> SwiftAi;
+            std::cout << "SWIFT_AI\t\t\t\t" << SwiftAi << '\n';
+        }
+        else if (key == "SWIFT_BETA")
+        {
+            conf >> SwiftBeta;
+            std::cout << "SWIFT_BETA\t\t\t\t" << SwiftBeta << '\n';
+        }
+        else if (key == "SWIFT_MAX_MDF")
+        {
+            conf >> SwiftMaxMdf;
+            std::cout << "SWIFT_MAX_MDF\t\t\t\t" << SwiftMaxMdf << '\n';
+        }
+        else if (key == "SWIFT_BASE_TARGET")
+        {
+            conf >> SwiftBaseTarget;
+            std::cout << "SWIFT_BASE_TARGET\t\t\t\t" << SwiftBaseTarget << '\n';
+        }
+        else if (key == "SWIFT_HOP_SCALE")
+        {
+            conf >> SwiftHopScale;
+            std::cout << "SWIFT_HOP_SCALE\t\t\t\t" << SwiftHopScale << '\n';
+        }
+        else if (key == "SWIFT_FS_MAX_CWND")
+        {
+            conf >> SwiftFsMaxCwnd;
+            std::cout << "SWIFT_FS_MAX_CWND\t\t\t\t" << SwiftFsMaxCwnd << '\n';
+        }
+        else if (key == "SWIFT_FS_MIN_CWND")
+        {
+            conf >> SwiftFsMinCwnd;
+            std::cout << "SWIFT_FS_MIN_CWND\t\t\t\t" << SwiftFsMinCwnd << '\n';
+        }
+        else if (key == "SWIFT_FS_RANGE")
+        {
+            conf >> SwiftFsRange;
+            std::cout << "SWIFT_FS_RANGE\t\t\t\t" << SwiftFsRange << '\n';
+        }
+        else if (key == "SWIFT_MIN_CWND")
+        {
+            conf >> SwiftMinCwnd;
+            std::cout << "SWIFT_MIN_CWND\t\t\t\t" << SwiftMinCwnd << '\n';
+        }
+        else if (key == "SWIFT_MAX_CWND")
+        {
+            conf >> SwiftMaxCwnd;
+            std::cout << "SWIFT_MAX_CWND\t\t\t\t" << SwiftMaxCwnd << '\n';
+        }
+        else if (key == "SWIFT_TARGET_ENDPOINT_DELAY")
+        {
+            conf >> SwiftTargetEndpointDelay;
+            std::cout << "SWIFT_TARGET_ENDPOINT_DELAY\t\t\t\t" << SwiftTargetEndpointDelay << '\n';
+        }
         fflush(stdout);
     }
     conf.close();
@@ -952,26 +1013,37 @@ main(int argc, char* argv[])
     // IntHeader::mode
     switch (cc_mode)
     {
-        case CC_MODE::TIMELY:
-        case CC_MODE::PATCHED_TIMELY:
-            // timely or patched timely, use ts
-            IntHeader::mode = IntHeader::TS;
-            break;
-        case CC_MODE::POWERTCP:
-            // hpcc, powertcp, use int
-            IntHeader::mode = IntHeader::NORMAL;
-            break;
-        case CC_MODE::HPCC_PINT:
-            // hpcc-pint
-            IntHeader::mode = IntHeader::PINT;
-            break;
-        case CC_MODE::SWIFT:
-            IntHeader::mode = IntHeader::SWIFT;
-            break;
-        default:
-            // others, no extra header
-            IntHeader::mode = IntHeader::NONE;
-            break;
+    case CC_MODE::TIMELY:
+    case CC_MODE::PATCHED_TIMELY:
+        // timely or patched timely, use ts
+        IntHeader::mode = IntHeader::TS;
+        break;
+    case CC_MODE::POWERTCP:
+        // hpcc, powertcp, use int
+        IntHeader::mode = IntHeader::NORMAL;
+        break;
+    case CC_MODE::HPCC_PINT:
+        // hpcc-pint
+        IntHeader::mode = IntHeader::PINT;
+        break;
+    case CC_MODE::SWIFT:
+        IntHeader::mode = IntHeader::SWIFT;
+        break;
+    default:
+        // others, no extra header
+        IntHeader::mode = IntHeader::NONE;
+        break;
+    }
+
+    // set rate bound
+    switch (cc_mode)
+    {
+    case CC_MODE::SWIFT:
+        rate_bound = 0;
+        break;
+    default:
+        // it's always 1 in the config, so assuming it's ok
+        rate_bound = 1;
     }
 
     // Set Pint
@@ -1260,6 +1332,19 @@ main(int argc, char* argv[])
             rdmaHw->SetAttribute("DctcpRateAI", DataRateValue(DataRate(dctcp_rate_ai)));
             rdmaHw->SetAttribute("PowerTCPEnabled", BooleanValue(wien));
             rdmaHw->SetAttribute("PowerTCPdelay", BooleanValue(delayWien));
+            rdmaHw->SetAttribute("SwiftAi", UintegerValue(SwiftAi));
+            rdmaHw->SetAttribute("SwiftBeta", DoubleValue(SwiftBeta));
+            rdmaHw->SetAttribute("SwiftMaxMdf", DoubleValue(SwiftMaxMdf));
+            rdmaHw->SetAttribute("SwiftBaseTarget", UintegerValue(SwiftBaseTarget));
+            rdmaHw->SetAttribute("SwiftHopScale", DoubleValue(SwiftHopScale));
+            rdmaHw->SetAttribute("SwiftFsMaxCwnd", DoubleValue(SwiftFsMaxCwnd));
+            rdmaHw->SetAttribute("SwiftFsMinCwnd", DoubleValue(SwiftFsMinCwnd));
+            rdmaHw->SetAttribute("SwiftFsRange", DoubleValue(SwiftFsRange));
+            rdmaHw->SetAttribute("SwiftMinCwnd", DoubleValue(SwiftMinCwnd));
+            rdmaHw->SetAttribute("SwiftMaxCwnd", DoubleValue(SwiftMaxCwnd));
+            rdmaHw->SetAttribute("SwiftTargetEndpointDelay",
+                                 UintegerValue(SwiftTargetEndpointDelay));
+
             rdmaHw->SetPintSmplThresh(pint_prob);
             // create and install RdmaDriver
             Ptr<RdmaDriver> rdma = CreateObject<RdmaDriver>();

simulator/ns-3.39/examples/PowerTCP/powertcp-evaluation-workload.cc

@@ -14,6 +14,7 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#include <cstdint>
 #undef PGO_TRAINING
 #define PATH_TO_PGO_CONFIG "path_to_pgo_config"
 
@@ -759,6 +760,19 @@ main(int argc, char* argv[])
     uint64_t LEAF_SERVER_CAPACITY = 25;
     uint64_t SPINE_LEAF_CAPACITY = 100;
 
+    // Swift parameters
+    uint32_t SwiftAi = 1000;
+    double SwiftBeta = 0.8;
+    double SwiftMaxMdf = 0.5;
+    double SwiftBaseTarget = 60000;
+    double SwiftHopScale = 30000;
+    double SwiftFsMaxCwnd = 0.1;
+    double SwiftFsMinCwnd = 0.000300;
+    double SwiftFsRange = 0.000300;
+    double SwiftMinCwnd = 0.001;
+    double SwiftMaxCwnd = 800000;
+    double SwiftTargetEndpointDelay = 1000000;
+
     double START_TIME = 0.1;
     double END_TIME = 6;
     double FLOW_LAUNCH_END_TIME = 5;
@@ -1073,13 +1087,6 @@ main(int argc, char* argv[])
             conf >> int_multi;
             std::cout << "INT_MULTI\t\t\t\t" << int_multi << '\n';
         }
-        else if (key == "RATE_BOUND")
-        {
-            uint32_t v;
-            conf >> v;
-            rate_bound = v;
-            std::cout << "RATE_BOUND\t\t" << rate_bound << '\n';
-        }
         else if (key == "ACK_HIGH_PRIO")
         {
             conf >> ack_high_prio;
@@ -1195,6 +1202,61 @@ main(int argc, char* argv[])
             conf >> pint_prob;
             std::cout << "PINT_PROB\t\t\t\t" << pint_prob << '\n';
         }
+        else if (key == "SWIFT_AI")
+        {
+            conf >> SwiftAi;
+            std::cout << "SWIFT_AI\t\t\t\t" << SwiftAi << '\n';
+        }
+        else if (key == "SWIFT_BETA")
+        {
+            conf >> SwiftBeta;
+            std::cout << "SWIFT_BETA\t\t\t\t" << SwiftBeta << '\n';
+        }
+        else if (key == "SWIFT_MAX_MDF")
+        {
+            conf >> SwiftMaxMdf;
+            std::cout << "SWIFT_MAX_MDF\t\t\t\t" << SwiftMaxMdf << '\n';
+        }
+        else if (key == "SWIFT_BASE_TARGET")
+        {
+            conf >> SwiftBaseTarget;
+            std::cout << "SWIFT_BASE_TARGET\t\t\t\t" << SwiftBaseTarget << '\n';
+        }
+        else if (key == "SWIFT_HOP_SCALE")
+        {
+            conf >> SwiftHopScale;
+            std::cout << "SWIFT_HOP_SCALE\t\t\t\t" << SwiftHopScale << '\n';
+        }
+        else if (key == "SWIFT_FS_MAX_CWND")
+        {
+            conf >> SwiftFsMaxCwnd;
+            std::cout << "SWIFT_FS_MAX_CWND\t\t\t\t" << SwiftFsMaxCwnd << '\n';
+        }
+        else if (key == "SWIFT_FS_MIN_CWND")
+        {
+            conf >> SwiftFsMinCwnd;
+            std::cout << "SWIFT_FS_MIN_CWND\t\t\t\t" << SwiftFsMinCwnd << '\n';
+        }
+        else if (key == "SWIFT_FS_RANGE")
+        {
+            conf >> SwiftFsRange;
+            std::cout << "SWIFT_FS_RANGE\t\t\t\t" << SwiftFsRange << '\n';
+        }
+        else if (key == "SWIFT_MIN_CWND")
+        {
+            conf >> SwiftMinCwnd;
+            std::cout << "SWIFT_MIN_CWND\t\t\t\t" << SwiftMinCwnd << '\n';
+        }
+        else if (key == "SWIFT_MAX_CWND")
+        {
+            conf >> SwiftMaxCwnd;
+            std::cout << "SWIFT_MAX_CWND\t\t\t\t" << SwiftMaxCwnd << '\n';
+        }
+        else if (key == "SWIFT_TARGET_ENDPOINT_DELAY")
+        {
+            conf >> SwiftTargetEndpointDelay;
+            std::cout << "SWIFT_TARGET_ENDPOINT_DELAY\t\t\t\t" << SwiftTargetEndpointDelay << '\n';
+        }
         fflush(stdout);
     }
     conf.close();
@@ -1212,26 +1274,37 @@ main(int argc, char* argv[])
     // IntHeader::mode
     switch (cc_mode)
     {
-        case CC_MODE::TIMELY:
-        case CC_MODE::PATCHED_TIMELY:
-            // timely or patched timely, use ts
-            IntHeader::mode = IntHeader::TS;
-            break;
-        case CC_MODE::POWERTCP:
-            // hpcc, powertcp, use int
-            IntHeader::mode = IntHeader::NORMAL;
-            break;
-        case CC_MODE::HPCC_PINT:
-            // hpcc-pint
-            IntHeader::mode = IntHeader::PINT;
-            break;
-        case CC_MODE::SWIFT:
-            IntHeader::mode = IntHeader::SWIFT;
-            break;
-        default:
-            // others, no extra header
-            IntHeader::mode = IntHeader::NONE;
-            break;
+    case CC_MODE::TIMELY:
+    case CC_MODE::PATCHED_TIMELY:
+        // timely or patched timely, use ts
+        IntHeader::mode = IntHeader::TS;
+        break;
+    case CC_MODE::POWERTCP:
+        // hpcc, powertcp, use int
+        IntHeader::mode = IntHeader::NORMAL;
+        break;
+    case CC_MODE::HPCC_PINT:
+        // hpcc-pint
+        IntHeader::mode = IntHeader::PINT;
+        break;
+    case CC_MODE::SWIFT:
+        IntHeader::mode = IntHeader::SWIFT;
+        break;
+    default:
+        // others, no extra header
+        IntHeader::mode = IntHeader::NONE;
+        break;
+    }
+
+    // set rate bound
+    switch (cc_mode)
+    {
+    case CC_MODE::SWIFT:
+        rate_bound = 0;
+        break;
+    default:
+        // it's always 1 in the config, so assuming it's ok
+        rate_bound = 1;
     }
 
     // Set Pint
@@ -1521,6 +1594,18 @@ main(int argc, char* argv[])
             rdmaHw->SetAttribute("DctcpRateAI", DataRateValue(DataRate(dctcp_rate_ai)));
             rdmaHw->SetAttribute("PowerTCPEnabled", BooleanValue(wien));
             rdmaHw->SetAttribute("PowerTCPdelay", BooleanValue(delayWien));
+            rdmaHw->SetAttribute("SwiftAi", UintegerValue(SwiftAi));
+            rdmaHw->SetAttribute("SwiftBeta", DoubleValue(SwiftBeta));
+            rdmaHw->SetAttribute("SwiftMaxMdf", DoubleValue(SwiftMaxMdf));
+            rdmaHw->SetAttribute("SwiftBaseTarget", UintegerValue(SwiftBaseTarget));
+            rdmaHw->SetAttribute("SwiftHopScale", DoubleValue(SwiftHopScale));
+            rdmaHw->SetAttribute("SwiftFsMaxCwnd", DoubleValue(SwiftFsMaxCwnd));
+            rdmaHw->SetAttribute("SwiftFsMinCwnd", DoubleValue(SwiftFsMinCwnd));
+            rdmaHw->SetAttribute("SwiftFsRange", DoubleValue(SwiftFsRange));
+            rdmaHw->SetAttribute("SwiftMinCwnd", DoubleValue(SwiftMinCwnd));
+            rdmaHw->SetAttribute("SwiftMaxCwnd", DoubleValue(SwiftMaxCwnd));
+            rdmaHw->SetAttribute("SwiftTargetEndpointDelay",
+                                 UintegerValue(SwiftTargetEndpointDelay));
             rdmaHw->SetPintSmplThresh(pint_prob);
             // create and install RdmaDriver
             Ptr<RdmaDriver> rdma = CreateObject<RdmaDriver>();

simulator/ns-3.39/src/point-to-point/model/rdma-hw.cc

@@ -213,7 +213,7 @@ RdmaHw::GetTypeId(void)
             // Swift parameters from code of paper Burst-tolerant datacenter networks with Vertigo
             .AddAttribute("SwiftAi",
                           "Swift's additive increment",
-                          UintegerValue(1),
+                          UintegerValue(1000),
                           MakeUintegerAccessor(&RdmaHw::swift_ai),
                           MakeUintegerChecker<uint32_t>())
             .AddAttribute("SwiftBeta",
@@ -233,7 +233,7 @@ RdmaHw::GetTypeId(void)
                           MakeUintegerChecker<uint32_t>())
             .AddAttribute("SwiftHopScale",
                           "Swift's per hop RTT scaling factor",
-                          DoubleValue(0.000030),
+                          DoubleValue(30000),
                           MakeDoubleAccessor(&RdmaHw::swift_hop_scale),
                           MakeDoubleChecker<double>())
             .AddAttribute("SwiftFsMaxCwnd",
@@ -258,7 +258,7 @@ RdmaHw::GetTypeId(void)
                           MakeDoubleChecker<double>())
             .AddAttribute("SwiftMaxCwnd",
                           "Swift's max cwnd it can exceed (not fs)",
-                          DoubleValue(43),
+                          DoubleValue(800000),
                           MakeDoubleAccessor(&RdmaHw::swift_max_cwnd),
                           MakeDoubleChecker<double>())
             // seems that in emulator there is no endpoint delay
@@ -916,7 +916,7 @@ RdmaHw::UpdateNextAvail(Ptr<RdmaQueuePair> qp, Time interframeGap, uint32_t pkt_
     {
         sendingTime = interframeGap + qp->m_max_rate.CalculateBytesTxTime(pkt_size);
     }
-    qp->m_nextAvail = Simulator::Now() + sendingTime;
+    qp->m_nextAvail = std::max(Simulator::Now() + sendingTime, qp->m_nextAvail);
 }
 
 void
@@ -2027,12 +2027,12 @@ RdmaHw::HandleAckSwift(Ptr<RdmaQueuePair> qp, Ptr<Packet> p, CustomHeader& ch)
     auto ih = ch.ack.ih.swift;
     // std::cout << "[SWIFT] Hops: " << ih.nhop << ", Remote Delay: " << ih.remote_delay <<
     // std::endl;
-    uint32_t ack_seq = ch.ack.seq;
+    // uint32_t ack_seq = ch.ack.seq;
     auto rtt = Simulator::Now().GetNanoSeconds() - ih.ts;
     auto fabric_delay = rtt - ih.remote_delay;
 
     // update ack num
-    qp->swift.num_acked += ack_seq / 1000;
+    // qp->swift.num_acked += ack_seq / 1000;
 
     // on receiving ack
     qp->swift.m_retransmit_cnt = 0;
@@ -2057,7 +2057,7 @@ RdmaHw::HandleAckSwift(Ptr<RdmaQueuePair> qp, Ptr<Packet> p, CustomHeader& ch)
         qp->swift.m_pacing_delay = 0;
         qp->SetWin((uint32_t)cwnd);
     }
-    // std::cout << "[SWIFT] cwnd: " << cwnd << ", rate: " << qp->m_rate << std::endl;
+    std::cout << "[SWIFT] cwnd: " << cwnd << std::endl;
 }
 
 // calculate target fabric delay
@@ -2088,11 +2088,12 @@ RdmaHw::GetCwndSwift(Ptr<RdmaQueuePair> qp,
     {
         if (cwnd >= 1)
         {
-            cwnd = cwnd + (double)swift_ai / cwnd * qp->swift.num_acked;
+            // ch.ack.seq is also num_acked (in seq number)
+            cwnd = cwnd + (double)swift_ai / cwnd * ch.ack.seq;
         }
         else
         {
-            cwnd = cwnd + swift_ai * qp->swift.num_acked;
+            cwnd = cwnd + swift_ai * ch.ack.seq;
         }
     }
     else if (canDecrease)

simulator/ns-3.39/src/point-to-point/model/rdma-queue-pair.cc

@@ -85,7 +85,7 @@ RdmaQueuePair::RdmaQueuePair(uint16_t pg,
     swift.m_curRate = 0;
     swift.m_retransmit_cnt = 0;
     swift.m_pacing_delay = 0;
-    swift.num_acked = 0;
+    // swift.num_acked = 0;
 }
 
 void

simulator/ns-3.39/src/point-to-point/model/rdma-queue-pair.h

@@ -142,7 +142,7 @@ class RdmaQueuePair : public Object
         // pacing delay, i.e. sending interval
         uint64_t m_pacing_delay;
         // num of acked packets
-        uint64_t num_acked;
+        // uint64_t num_acked;
     } swift;
 
     /***********