add RED, ARED and PIE

rattan-core/src/cells/bandwidth/queue/mod.rs

@@ -15,11 +15,15 @@ mod codel;
 mod drophead;
 mod droptail;
 mod infinite;
+mod pie;
+mod red;
 
 pub use codel::*;
 pub use drophead::*;
 pub use droptail::*;
 pub use infinite::*;
+pub use pie::*;
+pub use red::*;
 
 #[cfg(feature = "serde")]
 fn serde_default<T: Default + PartialEq>(t: &T) -> bool {

rattan-core/src/config/bandwidth.rs

@@ -35,6 +35,8 @@ pub enum BwCellBuildConfig<P: Packet> {
     DropTail(bandwidth::BwCellConfig<P, queue::DropTailQueue<P>>),
     DropHead(bandwidth::BwCellConfig<P, queue::DropHeadQueue<P>>),
     CoDel(bandwidth::BwCellConfig<P, queue::CoDelQueue<P>>),
+    Red(bandwidth::BwCellConfig<P, queue::RedQueue<P>>),
+    Pie(bandwidth::BwCellConfig<P, queue::PieQueue<P>>),
 }
 
 macro_rules! impl_bw_cell_into_factory {
@@ -56,7 +58,14 @@ macro_rules! impl_bw_cell_into_factory {
     };
 }
 
-impl_bw_cell_into_factory!(InfiniteQueue, DropTailQueue, DropHeadQueue, CoDelQueue);
+impl_bw_cell_into_factory!(
+    InfiniteQueue,
+    DropTailQueue,
+    DropHeadQueue,
+    CoDelQueue,
+    RedQueue,
+    PieQueue
+);
 
 #[cfg_attr(
     feature = "serde",
@@ -69,6 +78,8 @@ pub enum BwReplayCellBuildConfig<P: Packet> {
     DropTail(BwReplayQueueConfig<P, queue::DropTailQueue<P>>),
     DropHead(BwReplayQueueConfig<P, queue::DropHeadQueue<P>>),
     CoDel(BwReplayQueueConfig<P, queue::CoDelQueue<P>>),
+    Red(BwReplayQueueConfig<P, queue::RedQueue<P>>),
+    Pie(BwReplayQueueConfig<P, queue::PieQueue<P>>),
 }
 
 #[cfg_attr(
@@ -218,4 +229,11 @@ macro_rules! impl_bw_replay_cell_into_factory {
     };
 }
 
-impl_bw_replay_cell_into_factory!(InfiniteQueue, DropTailQueue, DropHeadQueue, CoDelQueue);
+impl_bw_replay_cell_into_factory!(
+    InfiniteQueue,
+    DropTailQueue,
+    DropHeadQueue,
+    CoDelQueue,
+    RedQueue,
+    PieQueue
+);

rattan-core/src/radix/mod.rs

@@ -348,6 +348,12 @@ where
                     crate::config::BwCellBuildConfig::CoDel(config) => {
                         self.build_cell(id, config.into_factory())?;
                     }
+                    crate::config::BwCellBuildConfig::Red(config) => {
+                        self.build_cell(id, config.into_factory())?;
+                    }
+                    crate::config::BwCellBuildConfig::Pie(config) => {
+                        self.build_cell(id, config.into_factory())?;
+                    }
                 },
                 CellBuildConfig::BwReplay(bw_replay_config) => match bw_replay_config {
                     crate::config::BwReplayCellBuildConfig::Infinite(config) => {
@@ -362,6 +368,12 @@ where
                     crate::config::BwReplayCellBuildConfig::CoDel(config) => {
                         self.build_cell(id, config.into_factory())?;
                     }
+                    crate::config::BwReplayCellBuildConfig::Red(config) => {
+                        self.build_cell(id, config.into_factory())?;
+                    }
+                    crate::config::BwReplayCellBuildConfig::Pie(config) => {
+                        self.build_cell(id, config.into_factory())?;
+                    }
                 },
                 CellBuildConfig::Delay(config) => {
                     self.build_cell(id, config.into_factory())?;

src/channel.rs

@@ -5,7 +5,10 @@ use netem_trace::{Bandwidth, Delay};
 use paste::paste;
 use rattan_core::{
     cells::bandwidth::{
-        queue::{CoDelQueueConfig, DropHeadQueueConfig, DropTailQueueConfig, InfiniteQueueConfig},
+        queue::{
+            CoDelQueueConfig, DropHeadQueueConfig, DropTailQueueConfig, InfiniteQueueConfig,
+            PieQueueConfig, RedQueueConfig,
+        },
         BwCellConfig,
     },
     config::{
@@ -92,6 +95,8 @@ enum QueueType {
     DropTail,
     DropHead,
     CoDel,
+    Red,
+    Pie,
 }
 
 // Deserialize queue args and create BwCellBuildConfig
@@ -170,6 +175,12 @@ impl ChannelArgs {
                 Some(QueueType::CoDel) => {
                     bw_q_args_into_config!(CoDel, self.uplink_queue_args.clone(), bandwidth)
                 }
+                Some(QueueType::Red) => {
+                    bw_q_args_into_config!(Red, self.uplink_queue_args.clone(), bandwidth)
+                }
+                Some(QueueType::Pie) => {
+                    bw_q_args_into_config!(Pie, self.uplink_queue_args.clone(), bandwidth)
+                }
             };
             uplink_count += 1;
             cells_config.insert(format!("up_{uplink_count}"), cell_config);
@@ -197,6 +208,12 @@ impl ChannelArgs {
                 Some(QueueType::CoDel) => {
                     bwreplay_q_args_into_config!(CoDel, self.uplink_queue_args.clone(), trace_file)
                 }
+                Some(QueueType::Red) => {
+                    bwreplay_q_args_into_config!(Red, self.uplink_queue_args.clone(), trace_file)
+                }
+                Some(QueueType::Pie) => {
+                    bwreplay_q_args_into_config!(Pie, self.uplink_queue_args.clone(), trace_file)
+                }
             };
             uplink_count += 1;
             cells_config.insert(format!("up_{uplink_count}"), cell_config);
@@ -220,6 +237,12 @@ impl ChannelArgs {
                 Some(QueueType::CoDel) => {
                     bw_q_args_into_config!(CoDel, self.downlink_queue_args.clone(), bandwidth)
                 }
+                Some(QueueType::Red) => {
+                    bw_q_args_into_config!(Red, self.downlink_queue_args.clone(), bandwidth)
+                }
+                Some(QueueType::Pie) => {
+                    bw_q_args_into_config!(Pie, self.downlink_queue_args.clone(), bandwidth)
+                }
             };
             downlink_count += 1;
             cells_config.insert(format!("down_{downlink_count}"), cell_config);
@@ -251,6 +274,12 @@ impl ChannelArgs {
                         trace_file
                     )
                 }
+                Some(QueueType::Red) => {
+                    bwreplay_q_args_into_config!(Red, self.downlink_queue_args.clone(), trace_file)
+                }
+                Some(QueueType::Pie) => {
+                    bwreplay_q_args_into_config!(Pie, self.downlink_queue_args.clone(), trace_file)
+                }
             };
             downlink_count += 1;
             cells_config.insert(format!("down_{downlink_count}"), cell_config);

src/visualize_trace.rs

@@ -261,6 +261,8 @@ pub fn write_visualize_trace<P: Packet>(
                     BwCellBuildConfig::Infinite(config) => config.bandwidth,
                     BwCellBuildConfig::DropHead(config) => config.bandwidth,
                     BwCellBuildConfig::DropTail(config) => config.bandwidth,
+                    BwCellBuildConfig::Red(config) => config.bandwidth,
+                    BwCellBuildConfig::Pie(config) => config.bandwidth,
                 }
                 .unwrap_or(Bandwidth::from_bps(u64::MAX));
                 trace_record.add_cell(
@@ -292,6 +294,8 @@ pub fn write_visualize_trace<P: Packet>(
                     BwReplayCellBuildConfig::DropHead(config) => config.get_trace(),
                     BwReplayCellBuildConfig::DropTail(config) => config.get_trace(),
                     BwReplayCellBuildConfig::Infinite(config) => config.get_trace(),
+                    BwReplayCellBuildConfig::Red(config) => config.get_trace(),
+                    BwReplayCellBuildConfig::Pie(config) => config.get_trace(),
                 }?;
 
                 let trace_points = expand_bw_trace(trace.as_mut(), start, end_time)