Attachment #3231 for bug #3010

View | Details | Raw Unified | Return to bug 3010
Collapse All | Expand All

(-)a/RELEASE_NOTES (+1 lines)

Lines 80-85 New user-visible features	Link Here

  This trace is fired whenever a new path loss value is calculated. It exports pointers

  This trace is fired whenever a new path loss value is calculated. It exports pointers

  to the mobility model of the transmitter and the receiver, Tx antenna gain, Rx antenna gain,

  to the mobility model of the transmitter and the receiver, Tx antenna gain, Rx antenna gain,

  propagation gain and the pathloss value.

  propagation gain and the pathloss value.

- (wifi) It is now possible to transmit A-MPDUs containing up to 256 MPDUs (802.11ax only)

Bugs fixed

Bugs fixed

----------

----------

(-)a/examples/wireless/examples-to-run.py (-3 / +4 lines)

Lines 41-50 cpp_examples = [	Link Here

    ("ht-wifi-network --simulationTime=0.1 --frequency=5 --useRts=1 --minExpectedThroughput=5 --maxExpectedThroughput=130", "True", "True"),

    ("ht-wifi-network --simulationTime=0.1 --frequency=5 --useRts=1 --minExpectedThroughput=5 --maxExpectedThroughput=130", "True", "True"),

    ("ht-wifi-network --simulationTime=0.1 --frequency=2.4 --useRts=0 --minExpectedThroughput=5 --maxExpectedThroughput=132", "True", "True"),

    ("ht-wifi-network --simulationTime=0.1 --frequency=2.4 --useRts=0 --minExpectedThroughput=5 --maxExpectedThroughput=132", "True", "True"),

    ("ht-wifi-network --simulationTime=0.1 --frequency=2.4 --useRts=1 --minExpectedThroughput=4.5 --maxExpectedThroughput=128", "True", "True"),

    ("ht-wifi-network --simulationTime=0.1 --frequency=2.4 --useRts=1 --minExpectedThroughput=4.5 --maxExpectedThroughput=128", "True", "True"),

    ("vht-wifi-network --simulationTime=0.1 --useRts=0  --minExpectedThroughput=5 --maxExpectedThroughput=555", "True", "True"),

    ("vht-wifi-network --simulationTime=0.1 --useRts=0  --minExpectedThroughput=5 --maxExpectedThroughput=607", "True", "True"),

    ("vht-wifi-network --simulationTime=0.2 --useRts=1", "True", "True"),

    ("vht-wifi-network --simulationTime=0.2 --useRts=1", "True", "True"),

    ("he-wifi-network --simulationTime=0.25 --frequency=5 --useRts=0  --minExpectedThroughput=6 --maxExpectedThroughput=754", "True", "True"),

    ("he-wifi-network --simulationTime=0.25 --frequency=5 --useRts=0 --minExpectedThroughput=6 --maxExpectedThroughput=844", "True", "True"),

    ("he-wifi-network --simulationTime=0.3 --frequency=5 --useRts=1 --minExpectedThroughput=6 --maxExpectedThroughput=639", "True", "True"),

    ("he-wifi-network --simulationTime=0.25 --frequency=5 --useRts=0 --useExtendedBlockAck=1 --minExpectedThroughput=6 --maxExpectedThroughput=1033", "True", "True"),

    ("he-wifi-network --simulationTime=0.3 --frequency=5 --useRts=1 --minExpectedThroughput=6 --maxExpectedThroughput=745", "True", "True"),

    ("he-wifi-network --simulationTime=0.25 --frequency=2.4 --useRts=0 --minExpectedThroughput=6 --maxExpectedThroughput=238", "True", "True"),

    ("he-wifi-network --simulationTime=0.25 --frequency=2.4 --useRts=0 --minExpectedThroughput=6 --maxExpectedThroughput=238", "True", "True"),

    ("he-wifi-network --simulationTime=0.3 --frequency=2.4 --useRts=1 --minExpectedThroughput=6 --maxExpectedThroughput=224", "True", "True"),

    ("he-wifi-network --simulationTime=0.3 --frequency=2.4 --useRts=1 --minExpectedThroughput=6 --maxExpectedThroughput=224", "True", "True"),

    ("simple-ht-hidden-stations --simulationTime=1 --enableRts=0 --nMpdus=32 --minExpectedThroughput=59 --maxExpectedThroughput=60", "True", "True"),

    ("simple-ht-hidden-stations --simulationTime=1 --enableRts=0 --nMpdus=32 --minExpectedThroughput=59 --maxExpectedThroughput=60", "True", "True"),




{
  bool udp = true;
  bool useRts = false;
  bool useExtendedBlockAck = false;
  double simulationTime = 10; //seconds
  double distance = 1.0; //meters
  double frequency = 5.0; //whether 2.4 or 5.0 GHz

  cmd.AddValue ("simulationTime", "Simulation time in seconds", simulationTime);
  cmd.AddValue ("udp", "UDP if set to 1, TCP otherwise", udp);
  cmd.AddValue ("useRts", "Enable/disable RTS/CTS", useRts);
  cmd.AddValue ("useExtendedBlockAck", "Enable/disable use of extended BACK", useExtendedBlockAck);
  cmd.AddValue ("mcs", "if set, limit testing to a specific MCS (0-7)", mcs);
  cmd.AddValue ("minExpectedThroughput", "if set, simulation fails if the lowest throughput is below this value", minExpectedThroughput);
  cmd.AddValue ("maxExpectedThroughput", "if set, simulation fails if the highest throughput is above this value", maxExpectedThroughput);

              NetDeviceContainer apDevice;
              apDevice = wifi.Install (phy, mac, wifiApNode);

              // Set channel width, guard interval and MPDU buffer size
              Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/ChannelWidth", UintegerValue (channelWidth));
              Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/HeConfiguration/GuardInterval", TimeValue (NanoSeconds (gi)));
              Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/HeConfiguration/MpduBufferSize", UintegerValue (useExtendedBlockAck ? 256 : 64));

              // mobility.
              MobilityHelper mobility;




  NetDeviceContainer nNGFStaDevice, nGFStaDevice;
  mac.SetType ("ns3::StaWifiMac",
               "Ssid", SsidValue (ssid),
               "BE_MaxAmpduSize", UintegerValue (0),
               "BE_BlockAckThreshold", UintegerValue (2),
               "ShortSlotTimeSupported", BooleanValue (params.enableShortSlotTime));
  nNGFStaDevice = wifi.Install (phy, mac, wifiNNGFStaNodes);

  mac.SetType ("ns3::ApWifiMac",
               "Ssid", SsidValue (ssid),
               "EnableBeaconJitter", BooleanValue (false),
               "BE_MaxAmpduSize", UintegerValue (0),
               "BE_BlockAckThreshold", UintegerValue (2),
               "RifsMode", BooleanValue (params.rifsMode),
               "EnableNonErpProtection", BooleanValue (params.enableErpProtection),

      edca->SetTxopLimit (MicroSeconds (3008));
    }

  Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/HtConfiguration/BeMaxAmpduSize", UintegerValue (0)); //Disable A-MPDU

  // Define mobility model
  MobilityHelper mobility;
  Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();




  std::string apManager = "ns3::MinstrelHtWifiManager";
  std::string standard = "802.11n-5GHz";
  std::string outputFileName = "minstrelHT";
  uint32_t BeMaxAmpduSize = 65535;
  bool shortGuardInterval = false;
  uint32_t chWidth = 20;
  int ap1_x = 0;

  cmd.AddValue ("shortGuardInterval", "Enable Short Guard Interval in all stations", shortGuardInterval);
  cmd.AddValue ("channelWidth", "Channel width of all the stations", chWidth);
  cmd.AddValue ("rtsThreshold", "RTS threshold", rtsThreshold);
  cmd.AddValue ("BeMaxAmpduSize", "BE Mac A-MPDU size", BeMaxAmpduSize);
  cmd.AddValue ("outputFileName", "Output filename", outputFileName);
  cmd.AddValue ("steps", "How many different distances to try", steps);
  cmd.AddValue ("stepsTime", "Time on each step", stepsTime);


      Ssid ssid = Ssid ("AP");
      wifiMac.SetType ("ns3::StaWifiMac",
                       "Ssid", SsidValue (ssid));
                       "BE_MaxAmpduSize", UintegerValue (BE_MaxAmpduSize));
      wifiStaDevices.Add (wifi.Install (wifiPhy, wifiMac, wifiStaNodes.Get (0)));

      //Configure the AP node


      ssid = Ssid ("AP");
      wifiMac.SetType ("ns3::ApWifiMac",
                       "Ssid", SsidValue (ssid));
                       "BE_MaxAmpduSize", UintegerValue (BE_MaxAmpduSize));
      wifiApDevices.Add (wifi.Install (wifiPhy, wifiMac, wifiApNodes.Get (0)));

      Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/HtConfiguration/BeMaxAmpduSize", UintegerValue (BeMaxAmpduSize));
    }
  else if (standard == "802.11ac")
    {


      Ssid ssid = Ssid ("AP");
      wifiMac.SetType ("ns3::StaWifiMac",
                       "Ssid", SsidValue (ssid));
                       "BE_MaxAmpduSize", UintegerValue (BE_MaxAmpduSize));
      wifiStaDevices.Add (wifi.Install (wifiPhy, wifiMac, wifiStaNodes.Get (0)));

      //Configure the AP node


      ssid = Ssid ("AP");
      wifiMac.SetType ("ns3::ApWifiMac",
                       "Ssid", SsidValue (ssid));
                       "BE_MaxAmpduSize", UintegerValue (BE_MaxAmpduSize));
      wifiApDevices.Add (wifi.Install (wifiPhy, wifiMac, wifiApNodes.Get (0)));

      Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/VhtConfiguration/BeMaxAmpduSize", UintegerValue (BeMaxAmpduSize));
    }

  wifiDevices.Add (wifiStaDevices);





  Ssid ssid = Ssid ("simple-mpdu-aggregation");
  mac.SetType ("ns3::StaWifiMac",
               "Ssid", SsidValue (ssid));
               "BE_MaxAmpduSize", UintegerValue (maxAmpduSize));

  NetDeviceContainer staDevices;
  staDevices = wifi.Install (phy, mac, wifiStaNodes);

  mac.SetType ("ns3::ApWifiMac",
               "Ssid", SsidValue (ssid),
               "EnableBeaconJitter", BooleanValue (false));
               "BE_MaxAmpduSize", UintegerValue (maxAmpduSize));

  NetDeviceContainer apDevice;
  apDevice = wifi.Install (phy, mac, wifiApNode);

  Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/HtConfiguration/BeMaxAmpduSize", UintegerValue (maxAmpduSize));

  // Setting mobility model
  MobilityHelper mobility;
  Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();

(-)a/examples/wireless/wifi-aggregation.cc (-19 / +58 lines)

Lines 32-37	Link Here

#include "ns3/udp-client-server-helper.h"

#include "ns3/udp-client-server-helper.h"

#include "ns3/packet-sink-helper.h"

#include "ns3/packet-sink-helper.h"

#include "ns3/yans-wifi-channel.h"

#include "ns3/yans-wifi-channel.h"

#include "ns3/wifi-net-device.h"

#include "ns3/ht-configuration.h"

// This is an example that illustrates how 802.11n aggregation is configured.

// This is an example that illustrates how 802.11n aggregation is configured.

// It defines 4 independent Wi-Fi networks (working on different channels).

// It defines 4 independent Wi-Fi networks (working on different channels).

Lines 109-115 int main (int argc, char *argv[])	Link Here

109

  NetDeviceContainer staDeviceA, staDeviceB, staDeviceC, staDeviceD, apDeviceA, apDeviceB, apDeviceC, apDeviceD;

111

  NetDeviceContainer staDeviceA, staDeviceB, staDeviceC, staDeviceD, apDeviceA, apDeviceB, apDeviceC, apDeviceD;

110

  Ssid ssid;

112

  Ssid ssid;

111

113

112

  //Network A

114

  // Network A

113

  ssid = Ssid ("network-A");

115

  ssid = Ssid ("network-A");

114

  phy.Set ("ChannelNumber", UintegerValue (36));

116

  phy.Set ("ChannelNumber", UintegerValue (36));

115

  mac.SetType ("ns3::StaWifiMac",

117

  mac.SetType ("ns3::StaWifiMac",

Lines 121-181 int main (int argc, char *argv[])	Link Here

121

               "EnableBeaconJitter", BooleanValue (false));

123

               "EnableBeaconJitter", BooleanValue (false));

122

  apDeviceA = wifi.Install (phy, mac, wifiApNodes.Get (0));

124

  apDeviceA = wifi.Install (phy, mac, wifiApNodes.Get (0));

123

125

124

  //Network B

126

  // Network B

125

  ssid = Ssid ("network-B");

127

  ssid = Ssid ("network-B");

126

  phy.Set ("ChannelNumber", UintegerValue (40));

128

  phy.Set ("ChannelNumber", UintegerValue (40));

127

  mac.SetType ("ns3::StaWifiMac",

129

  mac.SetType ("ns3::StaWifiMac",

128

               "Ssid", SsidValue (ssid),

130

               "Ssid", SsidValue (ssid));

129

               "BE_MaxAmpduSize", UintegerValue (0)); //Disable A-MPDU

130

131

  staDeviceB = wifi.Install (phy, mac, wifiStaNodes.Get (1));

132

  staDeviceB = wifi.Install (phy, mac, wifiStaNodes.Get (1));

133

134

  // Disable A-MPDU

135

  Ptr<NetDevice> dev = wifiStaNodes.Get (1)->GetDevice (0);

136

  Ptr<WifiNetDevice> wifi_dev = DynamicCast<WifiNetDevice> (dev);

137

  Ptr<HtConfiguration> htConfiguration = wifi_dev->GetHtConfiguration ();

138

  htConfiguration->SetAttribute ("BeMaxAmpduSize", UintegerValue (0));

132

139

133

  mac.SetType ("ns3::ApWifiMac",

140

  mac.SetType ("ns3::ApWifiMac",

134

               "Ssid", SsidValue (ssid),

141

               "Ssid", SsidValue (ssid),

135

               "EnableBeaconJitter", BooleanValue (false));

142

               "EnableBeaconJitter", BooleanValue (false));

136

  apDeviceB = wifi.Install (phy, mac, wifiApNodes.Get (1));

143

  apDeviceB = wifi.Install (phy, mac, wifiApNodes.Get (1));

137

144

138

  //Network C

145

  // Disable A-MPDU

146

  dev = wifiApNodes.Get (1)->GetDevice (0);

147

  wifi_dev = DynamicCast<WifiNetDevice> (dev);

148

  htConfiguration = wifi_dev->GetHtConfiguration ();

149

  htConfiguration->SetAttribute ("BeMaxAmpduSize", UintegerValue (0));

150

151

  // Network C

139

  ssid = Ssid ("network-C");

152

  ssid = Ssid ("network-C");

140

  phy.Set ("ChannelNumber", UintegerValue (44));

153

  phy.Set ("ChannelNumber", UintegerValue (44));

141

  mac.SetType ("ns3::StaWifiMac",

154

  mac.SetType ("ns3::StaWifiMac",

142

               "Ssid", SsidValue (ssid),

155

               "Ssid", SsidValue (ssid));

143

               "BE_MaxAmpduSize", UintegerValue (0), //Disable A-MPDU

144

               "BE_MaxAmsduSize", UintegerValue (7935)); //Enable A-MSDU with the highest maximum size allowed by the standard (7935 bytes)

145

156

146

  staDeviceC = wifi.Install (phy, mac, wifiStaNodes.Get (2));

157

  staDeviceC = wifi.Install (phy, mac, wifiStaNodes.Get (2));

147

158

159

  // Disable A-MPDU and enable A-MSDU with the highest maximum size allowed by the standard (7935 bytes)

160

  dev = wifiStaNodes.Get (2)->GetDevice (0);

161

  wifi_dev = DynamicCast<WifiNetDevice> (dev);

162

  htConfiguration = wifi_dev->GetHtConfiguration ();

163

  htConfiguration->SetAttribute ("BeMaxAmpduSize", UintegerValue (0));

164

  htConfiguration->SetAttribute ("BeMaxAmsduSize", UintegerValue (7935));

165

148

  mac.SetType ("ns3::ApWifiMac",

166

  mac.SetType ("ns3::ApWifiMac",

149

               "Ssid", SsidValue (ssid),

167

               "Ssid", SsidValue (ssid),

150

               "EnableBeaconJitter", BooleanValue (false));

168

               "EnableBeaconJitter", BooleanValue (false));

151

  apDeviceC = wifi.Install (phy, mac, wifiApNodes.Get (2));

169

  apDeviceC = wifi.Install (phy, mac, wifiApNodes.Get (2));

152

170

153

  //Network D

171

  // Disable A-MPDU and enable A-MSDU with the highest maximum size allowed by the standard (7935 bytes)

172

  dev = wifiApNodes.Get (2)->GetDevice (0);

173

  wifi_dev = DynamicCast<WifiNetDevice> (dev);

174

  htConfiguration = wifi_dev->GetHtConfiguration ();

175

  htConfiguration->SetAttribute ("BeMaxAmpduSize", UintegerValue (0));

176

  htConfiguration->SetAttribute ("BeMaxAmsduSize", UintegerValue (7935));

177

178

  // Network D

154

  ssid = Ssid ("network-D");

179

  ssid = Ssid ("network-D");

155

  phy.Set ("ChannelNumber", UintegerValue (48));

180

  phy.Set ("ChannelNumber", UintegerValue (48));

156

  mac.SetType ("ns3::StaWifiMac",

181

  mac.SetType ("ns3::StaWifiMac",

157

               "Ssid", SsidValue (ssid),

182

               "Ssid", SsidValue (ssid));

158

               "BE_MaxAmpduSize", UintegerValue (32768), //Enable A-MPDU with a smaller size than the default one

159

               "BE_MaxAmsduSize", UintegerValue (3839)); //Enable A-MSDU with the smallest maximum size allowed by the standard (3839 bytes)

160

183

161

  staDeviceD = wifi.Install (phy, mac, wifiStaNodes.Get (3));

184

  staDeviceD = wifi.Install (phy, mac, wifiStaNodes.Get (3));

162

185

186

  // Enable A-MPDU with a smaller size than the default one and

187

  // enable A-MSDU with the smallest maximum size allowed by the standard (3839 bytes)

188

  dev = wifiStaNodes.Get (3)->GetDevice (0);

189

  wifi_dev = DynamicCast<WifiNetDevice> (dev);

190

  htConfiguration = wifi_dev->GetHtConfiguration ();

191

  htConfiguration->SetAttribute ("BeMaxAmpduSize", UintegerValue (32768));

192

  htConfiguration->SetAttribute ("BeMaxAmsduSize", UintegerValue (3839));

193

163

  mac.SetType ("ns3::ApWifiMac",

194

  mac.SetType ("ns3::ApWifiMac",

164

               "Ssid", SsidValue (ssid),

195

               "Ssid", SsidValue (ssid),

165

               "EnableBeaconJitter", BooleanValue (false));

196

               "EnableBeaconJitter", BooleanValue (false));

166

  apDeviceD = wifi.Install (phy, mac, wifiApNodes.Get (3));

197

  apDeviceD = wifi.Install (phy, mac, wifiApNodes.Get (3));

167

198

168

  /* Setting mobility model */

199

  // Enable A-MPDU with a smaller size than the default one and

200

  // enable A-MSDU with the smallest maximum size allowed by the standard (3839 bytes)

201

  dev = wifiApNodes.Get (3)->GetDevice (0);

202

  wifi_dev = DynamicCast<WifiNetDevice> (dev);

203

  htConfiguration = wifi_dev->GetHtConfiguration ();

204

  htConfiguration->SetAttribute ("BeMaxAmpduSize", UintegerValue (32768));

205

  htConfiguration->SetAttribute ("BeMaxAmsduSize", UintegerValue (3839));

206

207

  // Setting mobility model

169

  MobilityHelper mobility;

208

  MobilityHelper mobility;

170

  Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();

209

  Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();

171

  mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");

210

  mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");

172

211

173

  //Set position for APs

212

  // Set position for APs

174

  positionAlloc->Add (Vector (0.0, 0.0, 0.0));

213

  positionAlloc->Add (Vector (0.0, 0.0, 0.0));

175

  positionAlloc->Add (Vector (10.0, 0.0, 0.0));

214

  positionAlloc->Add (Vector (10.0, 0.0, 0.0));

176

  positionAlloc->Add (Vector (20.0, 0.0, 0.0));

215

  positionAlloc->Add (Vector (20.0, 0.0, 0.0));

177

  positionAlloc->Add (Vector (30.0, 0.0, 0.0));

216

  positionAlloc->Add (Vector (30.0, 0.0, 0.0));

178

  //Set position for STAs

217

  // Set position for STAs

179

  positionAlloc->Add (Vector (distance, 0.0, 0.0));

218

  positionAlloc->Add (Vector (distance, 0.0, 0.0));

180

  positionAlloc->Add (Vector (10 + distance, 0.0, 0.0));

219

  positionAlloc->Add (Vector (10 + distance, 0.0, 0.0));

181

  positionAlloc->Add (Vector (20 + distance, 0.0, 0.0));

220

  positionAlloc->Add (Vector (20 + distance, 0.0, 0.0));

Lines 185-191 int main (int argc, char *argv[])	Link Here

185

  mobility.Install (wifiApNodes);

224

  mobility.Install (wifiApNodes);

186

  mobility.Install (wifiStaNodes);

225

  mobility.Install (wifiStaNodes);

187

226

188

  /* Internet stack */

227

  // Internet stack

189

  InternetStackHelper stack;

228

  InternetStackHelper stack;

190

  stack.Install (wifiApNodes);

229

  stack.Install (wifiApNodes);

191

  stack.Install (wifiStaNodes);

230

  stack.Install (wifiStaNodes);

Lines 215-221 int main (int argc, char *argv[])	Link Here

215

  Ipv4InterfaceContainer ApInterfaceD;

254

  Ipv4InterfaceContainer ApInterfaceD;

216

  ApInterfaceD = address.Assign (apDeviceD);

255

  ApInterfaceD = address.Assign (apDeviceD);

217

256

218

  /* Setting applications */

257

  // Setting applications

219

  uint16_t port = 9;

258

  uint16_t port = 9;

220

  UdpServerHelper serverA (port);

259

  UdpServerHelper serverA (port);

221

  ApplicationContainer serverAppA = serverA.Install (wifiStaNodes.Get (0));

260

  ApplicationContainer serverAppA = serverA.Install (wifiStaNodes.Get (0));

Lines 288-294 int main (int argc, char *argv[])	Link Here

288

  Simulator::Stop (Seconds (simulationTime + 1));

327

  Simulator::Stop (Seconds (simulationTime + 1));

289

  Simulator::Run ();

328

  Simulator::Run ();

290

329

291

  /* Show results */

330

  // Show results

292

  uint64_t totalPacketsThroughA = DynamicCast<UdpServer> (serverAppA.Get (0))->GetReceived ();

331

  uint64_t totalPacketsThroughA = DynamicCast<UdpServer> (serverAppA.Get (0))->GetReceived ();

293

  uint64_t totalPacketsThroughB = DynamicCast<UdpServer> (serverAppB.Get (0))->GetReceived ();

332

  uint64_t totalPacketsThroughB = DynamicCast<UdpServer> (serverAppB.Get (0))->GetReceived ();

294

  uint64_t totalPacketsThroughC = DynamicCast<UdpServer> (serverAppC.Get (0))->GetReceived ();

333

  uint64_t totalPacketsThroughC = DynamicCast<UdpServer> (serverAppC.Get (0))->GetReceived ();

(-)a/src/wifi/doc/source/wifi-user.rst (+7 lines)

Lines 790-795 attributes for 802.11ax devices.	Link Here

790

 Ptr<HeConfiguration> heConfiguration = wnd->GetHeConfiguration ();

790

 Ptr<HeConfiguration> heConfiguration = wnd->GetHeConfiguration ();

791

 heConfiguration->SetGuardInterval (NanoSeconds (1600));

791

 heConfiguration->SetGuardInterval (NanoSeconds (1600));

792

793

 802.11ax allows extended compressed Block ACKs containing a 256-bits bitmap, making possible transmissions of A-MPDUs containing up to 256 MPDUs,

794

 depending on the negotiated buffer size. In order to configure the buffer size of an 802.11ax device, the following line of code could be used::

795

796

 heConfiguration->SetMpduBufferSize (256);

797

798

 For transmitting large MPDUs, it might also be needed to increase the maximum aggregation size (see above).

799

793

Mobility configuration

800

Mobility configuration

794

======================

801

======================

795

802




    {
      Ssid ssid = Ssid ("ns-3-ssid");
      wifiMac.SetType ("ns3::StaWifiMac",
                       "Ssid", SsidValue (ssid));
                       "BE_MaxAmpduSize", UintegerValue (maxAmpduSize));
      serverDevice = wifi.Install (wifiPhy, wifiMac, serverNode);
      wifiMac.SetType ("ns3::ApWifiMac",
                       "Ssid", SsidValue (ssid));
                       "BE_MaxAmpduSize", UintegerValue (maxAmpduSize));
      clientDevice = wifi.Install (wifiPhy, wifiMac, clientNode);
    }
  else
    {
      wifiMac.SetType ("ns3::AdhocWifiMac");
                       "BE_MaxAmpduSize", UintegerValue (maxAmpduSize));
      serverDevice = wifi.Install (wifiPhy, wifiMac, serverNode);
      clientDevice = wifi.Install (wifiPhy, wifiMac, clientNode);
    }

  wifi.AssignStreams (serverDevice, 100);
  wifi.AssignStreams (clientDevice, 100);

  Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/HtConfiguration/BeMaxAmpduSize", UintegerValue (maxAmpduSize));
  Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/VhtConfiguration/BeMaxAmpduSize", UintegerValue (maxAmpduSize));
  Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/HeConfiguration/BeMaxAmpduSize", UintegerValue (maxAmpduSize));

  Config::ConnectWithoutContext ("/NodeList/0/DeviceList/*/$ns3::WifiNetDevice/RemoteStationManager/$ns3::" + wifiManager + "WifiManager/Rate", MakeCallback (&RateChange));

  // Configure the mobility.

(-)a/src/wifi/model/ampdu-tag.cc (-1 lines)

Lines 51-57 AmpduTag::AmpduTag ()	Link Here

void

void

AmpduTag::SetRemainingNbOfMpdus (uint8_t nbofmpdus)

AmpduTag::SetRemainingNbOfMpdus (uint8_t nbofmpdus)

  NS_ASSERT (nbofmpdus <= 64);

  m_nbOfMpdus = nbofmpdus;

  m_nbOfMpdus = nbofmpdus;




NS_LOG_COMPONENT_DEFINE ("BlockAckAgreement");

BlockAckAgreement::BlockAckAgreement (Mac48Address peer, uint8_t tid)
  : m_peer (peer),
    m_amsduSupported (0),
    m_blockAckPolicy (1),
    m_tid (tid),
    m_htSupported (0),
    m_inactivityEvent ()
{
  NS_LOG_FUNCTION (this << peer << +tid);
  m_tid = tid;
  m_peer = peer;
}

BlockAckAgreement::~BlockAckAgreement ()

BlockAckAgreement::SetBufferSize (uint16_t bufferSize)
{
  NS_LOG_FUNCTION (this << bufferSize);
  NS_ASSERT (bufferSize <= 256);
  NS_ASSERT (bufferSize % 16 == 0);
  m_bufferSize = bufferSize;
}

uint8_t
BlockAckAgreement::GetTid (void) const
{
  NS_LOG_FUNCTION (this);
  return m_tid;
}


uint16_t
BlockAckAgreement::GetBufferSize (void) const
{
  NS_LOG_FUNCTION (this);
  return m_bufferSize;
}

uint16_t
BlockAckAgreement::GetTimeout (void) const
{
  NS_LOG_FUNCTION (this);
  return m_timeout;
}

uint16_t
BlockAckAgreement::GetStartingSequence (void) const
{
  NS_LOG_FUNCTION (this);
  return m_startingSeq;
}

uint16_t
BlockAckAgreement::GetStartingSequenceControl (void) const
{
  NS_LOG_FUNCTION (this);
  uint16_t seqControl = (m_startingSeq << 4) & 0xfff0;
  return seqControl;
}

bool
BlockAckAgreement::IsImmediateBlockAck (void) const
{
  NS_LOG_FUNCTION (this);
  return (m_blockAckPolicy == 1);
}

bool
BlockAckAgreement::IsAmsduSupported (void) const
{
  NS_LOG_FUNCTION (this);
  return (m_amsduSupported == 1) ? true : false;
}


bool
BlockAckAgreement::IsHtSupported (void) const
{
  NS_LOG_FUNCTION (this);
  return (m_htSupported == 1) ? true : false;
}


(-)a/src/wifi/model/block-ack-cache.cc (-2 / +2 lines)

Lines 36-42 BlockAckCache::Init (uint16_t winStart, uint16_t winSize)	Link Here

  NS_LOG_FUNCTION (this << winStart << winSize);

  NS_LOG_FUNCTION (this << winStart << winSize);

  m_winStart = winStart;

  m_winStart = winStart;

  m_winSize = winSize <= 64 ? winSize : 64;

  m_winSize = winSize;

  m_winEnd = (m_winStart + m_winSize - 1) % 4096;

  m_winEnd = (m_winStart + m_winSize - 1) % 4096;

  memset (m_bitmap, 0, sizeof (m_bitmap));

  memset (m_bitmap, 0, sizeof (m_bitmap));

Lines 119-125 BlockAckCache::FillBlockAckBitmap (CtrlBAckResponseHeader *blockAckHeader)	Link Here

119

120

      NS_FATAL_ERROR ("Basic block ack is only partially implemented.");

120

      NS_FATAL_ERROR ("Basic block ack is only partially implemented.");

121

122

  else if (blockAckHeader->IsCompressed ())

122

  else if (blockAckHeader->IsCompressed () || blockAckHeader->IsExtendedCompressed ())

123

124

      uint16_t i = blockAckHeader->GetStartingSequence ();

124

      uint16_t i = blockAckHeader->GetStartingSequence ();

125

      uint16_t end = (i + m_winSize - 1) % 4096;

125

      uint16_t end = (i + m_winSize - 1) % 4096;




  agreement.SetStartingSequence (reqHdr->GetStartingSequence ());
  /* For now we assume that originator doesn't use this field. Use of this field
     is mandatory only for recipient */
  agreement.SetBufferSize (reqHdr->GetBufferSize());
  agreement.SetWinEnd ((agreement.GetStartingSequence () + agreement.GetBufferSize () - 1) % 4096);
  agreement.SetTimeout (reqHdr->GetTimeout ());
  agreement.SetAmsduSupport (reqHdr->IsAmsduSupported ());

  std::list<PacketQueueI>::const_iterator it = m_retryPackets.begin ();
  while (it != m_retryPackets.end ())
    {
      NS_LOG_FUNCTION (this << (*it)->hdr.GetType ());
      if (!(*it)->hdr.IsQosData ())
        {
          NS_FATAL_ERROR ("Packet in blockAck manager retry queue is not Qos Data");

                    }
                }
            }
          else if (blockAck->IsCompressed () || blockAck->IsExtendedCompressed ())
            {
              for (PacketQueueI queueIt = it->second.second.begin (); queueIt != queueEnd; )
                {

      agreement.CompleteExchange ();

      CtrlBAckRequestHeader reqHdr;
      reqHdr.SetType (m_blockAckType);
      reqHdr.SetTidInfo (agreement.GetTid ());
      reqHdr.SetStartingSequence (agreement.GetStartingSequence ());

          reqHdr.SetStartingSequence (agreement.GetStartingSequence ());
        }
      else if (m_blockAckType == MULTI_TID_BLOCK_ACK)
        {
          NS_FATAL_ERROR ("Multi-tid block ack is not supported.");
        }
      else
        {
          NS_FATAL_ERROR ("Invalid block ack type.");
        }
      Ptr<Packet> bar = Create<Packet> ();
      bar->AddHeader (reqHdr);
      return bar;

    }
}

uint16_t
BlockAckManager::GetRecipientBufferSize (Mac48Address recipient, uint8_t tid) const
{
  uint16_t size = 0;
  AgreementsCI it = m_agreements.find (std::make_pair (recipient, tid));
  if (it != m_agreements.end ())
    {
      size = it->second.first.GetBufferSize ();
    }
  return size;
}

} //namespace ns3

(-)a/src/wifi/model/block-ack-manager.h (+9 lines)

Lines 361-366 public:	Link Here

361

   * \returns true if BAR retransmission needed

361

   * \returns true if BAR retransmission needed

362

*/

362

*/

363

  bool NeedBarRetransmission (uint8_t tid, uint16_t seqNumber, Mac48Address recipient);

363

  bool NeedBarRetransmission (uint8_t tid, uint16_t seqNumber, Mac48Address recipient);

364

/**

365

   * This function returns the buffer size negociated with the recipient.

366

367

   * \param tid Traffic ID

368

   * \param recipient MAC address

369

370

   * \returns the buffer size negociated with the recipient

371

*/

372

  uint16_t GetRecipientBufferSize (Mac48Address recipient, uint8_t tid) const;

364

373

365

/**

374

/**

366

   * typedef for a callback to invoke when a

375

   * typedef for a callback to invoke when a

(-)a/src/wifi/model/block-ack-type.h (-1 / +2 lines)

Lines 31-37 enum BlockAckType	Link Here

  BASIC_BLOCK_ACK,

  BASIC_BLOCK_ACK,

  COMPRESSED_BLOCK_ACK,

  COMPRESSED_BLOCK_ACK,

  MULTI_TID_BLOCK_ACK

  EXTENDED_COMPRESSED_BLOCK_ACK,

  MULTI_TID_BLOCK_ACK,

};

};

} //namespace ns3

} //namespace ns3





CtrlBAckRequestHeader::CtrlBAckRequestHeader ()
  : m_barAckPolicy (false),
    m_baType (BASIC_BLOCK_ACK)
    m_compressed (false)
{
}


{
  uint32_t size = 0;
  size += 2; //Bar control
  switch (m_baType)
    {
      case BASIC_BLOCK_ACK:
      case COMPRESSED_BLOCK_ACK:
      case EXTENDED_COMPRESSED_BLOCK_ACK:
        size += 2;
        break;
      case MULTI_TID_BLOCK_ACK:
        size += (2 + 2) * (m_tidInfo + 1);
        break;
      default:
        NS_FATAL_ERROR ("Invalid BA type");
        break;
    }
  return size;
}

{
  Buffer::Iterator i = start;
  i.WriteHtolsbU16 (GetBarControl ());
  switch (m_baType)
    {
      i.WriteHtolsbU16 (GetStartingSequenceControl ());
    }
  else if (m_compressed)
    {
      NS_FATAL_ERROR ("Multi-tid block ack is not supported.");
    }
  else
    {
      case BASIC_BLOCK_ACK:
      case COMPRESSED_BLOCK_ACK:
      case EXTENDED_COMPRESSED_BLOCK_ACK:
        i.WriteHtolsbU16 (GetStartingSequenceControl ());
        break;
      case MULTI_TID_BLOCK_ACK:
        NS_FATAL_ERROR ("Multi-tid block ack is not supported.");
        break;
      default:
        NS_FATAL_ERROR ("Invalid BA type");
        break;
    }
}


{
  Buffer::Iterator i = start;
  SetBarControl (i.ReadLsbtohU16 ());
  switch (m_baType)
    {
      case BASIC_BLOCK_ACK:
      case COMPRESSED_BLOCK_ACK:
      case EXTENDED_COMPRESSED_BLOCK_ACK:
        SetStartingSequenceControl (i.ReadLsbtohU16 ());
        break;
      case MULTI_TID_BLOCK_ACK:
        NS_FATAL_ERROR ("Multi-tid block ack is not supported.");
        break;
      default:
        NS_FATAL_ERROR ("Invalid BA type");
        break;
    }
  return i.GetDistanceFrom (start);
}

CtrlBAckRequestHeader::GetBarControl (void) const
{
  uint16_t res = 0;
  switch (m_baType)
    {
      case BASIC_BLOCK_ACK:
        break;
      case COMPRESSED_BLOCK_ACK:
        res |= (0x02 << 1);
        break;
      case EXTENDED_COMPRESSED_BLOCK_ACK:
        res |= (0x01 << 1);
        break;
      case MULTI_TID_BLOCK_ACK:
        res |= (0x03 << 1);
        break;
      default:
        NS_FATAL_ERROR ("Invalid BA type");
        break;
    }
  res |= (m_tidInfo << 12) & (0xf << 12);
  return res;

CtrlBAckRequestHeader::SetBarControl (uint16_t bar)
{
  m_barAckPolicy = ((bar & 0x01) == 1) ? true : false;
  if (((bar >> 1) & 0x0f) == 0x03)
    {
      m_baType = MULTI_TID_BLOCK_ACK;
    }
  else if (((bar >> 1) & 0x0f) == 0x01)
    {
      m_baType = EXTENDED_COMPRESSED_BLOCK_ACK;
    }
  else if (((bar >> 1) & 0x0f) == 0x02)
    {
      m_baType = COMPRESSED_BLOCK_ACK;
    }
  else
    {
      m_baType = BASIC_BLOCK_ACK;
    }
  m_tidInfo = (bar >> 12) & 0x0f;
}


void
CtrlBAckRequestHeader::SetType (BlockAckType type)
{
  m_baType = type;
}

BlockAckType
CtrlBAckRequestHeader::GetType (void) const
{
  return m_baType;
      m_multiTid = false;
      m_compressed = true;
      break;
    case MULTI_TID_BLOCK_ACK:
      m_multiTid = true;
      m_compressed = true;
      break;
    default:
      NS_FATAL_ERROR ("Invalid variant type");
      break;
    }
}

void

bool
CtrlBAckRequestHeader::IsBasic (void) const
{
  return (m_baType == BASIC_BLOCK_ACK) ? true : false;
}

bool
CtrlBAckRequestHeader::IsCompressed (void) const
{
  return (m_baType == COMPRESSED_BLOCK_ACK) ? true : false;
}

bool
CtrlBAckRequestHeader::IsExtendedCompressed (void) const
{
  return (m_baType == EXTENDED_COMPRESSED_BLOCK_ACK) ? true : false;
}

bool
CtrlBAckRequestHeader::IsMultiTid (void) const
{
  return (m_baType == MULTI_TID_BLOCK_ACK) ? true : false;
}




CtrlBAckResponseHeader::CtrlBAckResponseHeader ()
  : m_baAckPolicy (false),
    m_baType (BASIC_BLOCK_ACK)
    m_compressed (false)
{
  memset (&bitmap, 0, sizeof (bitmap));
}

{
  uint32_t size = 0;
  size += 2; //Bar control
  switch (m_baType)
    {
      case BASIC_BLOCK_ACK:
        size += (2 + 128);
        break;
      case COMPRESSED_BLOCK_ACK:
        size += (2 + 8);
        break;
      case EXTENDED_COMPRESSED_BLOCK_ACK:
        size += (2 + 32);
        break;
      case MULTI_TID_BLOCK_ACK:
        size += (2 + 2 + 8) * (m_tidInfo + 1); //Multi-tid block ack
        break;
      default:
        NS_FATAL_ERROR ("Invalid BA type");
        break;
      else
        {
          NS_FATAL_ERROR ("Reserved configuration.");
        }
    }
  return size;
}

{
  Buffer::Iterator i = start;
  i.WriteHtolsbU16 (GetBaControl ());
  switch (m_baType)
    {
      i.WriteHtolsbU16 (GetStartingSequenceControl ());
      i = SerializeBitmap (i);
    }
  else if (m_compressed)
    {
      NS_FATAL_ERROR ("Multi-tid block ack is not supported.");
    }
  else
    {
      case BASIC_BLOCK_ACK:
      case COMPRESSED_BLOCK_ACK:
      case EXTENDED_COMPRESSED_BLOCK_ACK:
        i.WriteHtolsbU16 (GetStartingSequenceControl ());
        i = SerializeBitmap (i);
        break;
      case MULTI_TID_BLOCK_ACK:
        NS_FATAL_ERROR ("Multi-tid block ack is not supported.");
        break;
      default:
        NS_FATAL_ERROR ("Invalid BA type");
        break;
    }
}


{
  Buffer::Iterator i = start;
  SetBaControl (i.ReadLsbtohU16 ());
  switch (m_baType)
    {
      case BASIC_BLOCK_ACK:
      case COMPRESSED_BLOCK_ACK:
      case EXTENDED_COMPRESSED_BLOCK_ACK:
        SetStartingSequenceControl (i.ReadLsbtohU16 ());
        i = DeserializeBitmap (i);
        break;
      case MULTI_TID_BLOCK_ACK:
        NS_FATAL_ERROR ("Multi-tid block ack is not supported.");
        break;
      default:
        NS_FATAL_ERROR ("Invalid BA type");
        break;
    }
  return i.GetDistanceFrom (start);
}

void
CtrlBAckResponseHeader::SetType (BlockAckType type)
{
  m_baType = type;
}

BlockAckType
CtrlBAckResponseHeader::GetType (void) const
{
  return m_baType;
      m_multiTid = false;
      m_compressed = true;
      break;
    case MULTI_TID_BLOCK_ACK:
      m_multiTid = true;
      m_compressed = true;
      break;
    default:
      NS_FATAL_ERROR ("Invalid variant type");
      break;
    }
}

void

bool
CtrlBAckResponseHeader::IsBasic (void) const
{
  return (m_baType == BASIC_BLOCK_ACK) ? true : false;
}

bool
CtrlBAckResponseHeader::IsCompressed (void) const
{
  return (m_baType == COMPRESSED_BLOCK_ACK) ? true : false;
}

bool
CtrlBAckResponseHeader::IsExtendedCompressed (void) const
{
  return (m_baType == EXTENDED_COMPRESSED_BLOCK_ACK) ? true : false;
}

bool
CtrlBAckResponseHeader::IsMultiTid (void) const
{
  return (m_baType == MULTI_TID_BLOCK_ACK) ? true : false;
}

uint16_t

    {
      res |= 0x1;
    }
  switch (m_baType)
    {
      case BASIC_BLOCK_ACK:
        break;
      case COMPRESSED_BLOCK_ACK:
        res |= (0x02 << 1);
        break;
      case EXTENDED_COMPRESSED_BLOCK_ACK:
        res |= (0x01 << 1);
        break;
      case MULTI_TID_BLOCK_ACK:
        res |= (0x03 << 1);
        break;
      default:
        NS_FATAL_ERROR ("Invalid BA type");
        break;
    }
  res |= (m_tidInfo << 12) & (0xf << 12);
  return res;

CtrlBAckResponseHeader::SetBaControl (uint16_t ba)
{
  m_baAckPolicy = ((ba & 0x01) == 1) ? true : false;
  if (((ba >> 1) & 0x0f) == 0x03)
    {
      m_baType = MULTI_TID_BLOCK_ACK;
    }
  else if (((ba >> 1) & 0x0f) == 0x01)
    {
      m_baType = EXTENDED_COMPRESSED_BLOCK_ACK;
    }
  else if (((ba >> 1) & 0x0f) == 0x02)
    {
      m_baType = COMPRESSED_BLOCK_ACK;
    }
  else
    {
      m_baType = BASIC_BLOCK_ACK;
    }
  m_tidInfo = (ba >> 12) & 0x0f;
}


CtrlBAckResponseHeader::SerializeBitmap (Buffer::Iterator start) const
{
  Buffer::Iterator i = start;
  switch (m_baType)
    {
      case BASIC_BLOCK_ACK:
        {
          for (uint8_t j = 0; j < 64; j++)
            {
              i.WriteHtolsbU16 (bitmap.m_bitmap[j]);
            }
          break;
      case COMPRESSED_BLOCK_ACK:
        {
          i.WriteHtolsbU64 (bitmap.m_compressedBitmap);
          break;
      case EXTENDED_COMPRESSED_BLOCK_ACK:
          i.WriteHtolsbU64 (bitmap.m_extendedCompressedBitmap[0]);
          i.WriteHtolsbU64 (bitmap.m_extendedCompressedBitmap[1]);
          i.WriteHtolsbU64 (bitmap.m_extendedCompressedBitmap[2]);
          i.WriteHtolsbU64 (bitmap.m_extendedCompressedBitmap[3]);
          break;
      case MULTI_TID_BLOCK_ACK:
        NS_FATAL_ERROR ("Multi-tid block ack is not supported.");
        break;
      default:
        NS_FATAL_ERROR ("Invalid BA type");
        break;
    }
  return i;
}

CtrlBAckResponseHeader::DeserializeBitmap (Buffer::Iterator start)
{
  Buffer::Iterator i = start;
  switch (m_baType)
    {
      case BASIC_BLOCK_ACK:
        {
          for (uint8_t j = 0; j < 64; j++)
            {
              bitmap.m_bitmap[j] = i.ReadLsbtohU16 ();
            }
          break;
      case COMPRESSED_BLOCK_ACK:
        {
          bitmap.m_compressedBitmap = i.ReadLsbtohU64 ();
          break;
      case EXTENDED_COMPRESSED_BLOCK_ACK:
          bitmap.m_extendedCompressedBitmap[0] = i.ReadLsbtohU64 ();
          bitmap.m_extendedCompressedBitmap[1] = i.ReadLsbtohU64 ();
          bitmap.m_extendedCompressedBitmap[2] = i.ReadLsbtohU64 ();
          bitmap.m_extendedCompressedBitmap[3] = i.ReadLsbtohU64 ();
          break;
      case MULTI_TID_BLOCK_ACK:
        NS_FATAL_ERROR ("Multi-tid block ack is not supported.");
        break;
      default:
        NS_FATAL_ERROR ("Invalid BA type");
        break;
    }
  return i;
}

    {
      return;
    }
  switch (m_baType)
    {
      case BASIC_BLOCK_ACK:
        {
          /* To set correctly basic block ack bitmap we need fragment number too.
             So if it's not specified, we consider packet not fragmented. */
          bitmap.m_bitmap[IndexInBitmap (seq)] |= 0x0001;
          break;
        }
      case COMPRESSED_BLOCK_ACK:
        {
          bitmap.m_compressedBitmap |= (uint64_t (0x0000000000000001) << IndexInBitmap (seq));
          break;
        }
      case EXTENDED_COMPRESSED_BLOCK_ACK:
        {
          uint16_t index = IndexInBitmap (seq);
          bitmap.m_extendedCompressedBitmap[index/64] |= (uint64_t (0x0000000000000001) << index);
          break;
        }
      case MULTI_TID_BLOCK_ACK:
        {
          NS_FATAL_ERROR ("Multi-tid block ack is not supported.");
          break;
        }
      default:
        {
          NS_FATAL_ERROR ("Invalid BA type");
          break;
        }
    }
}

    {
      return;
    }
  switch (m_baType)
    {
      case BASIC_BLOCK_ACK:
        bitmap.m_bitmap[IndexInBitmap (seq)] |= (0x0001 << frag);
        break;
      case COMPRESSED_BLOCK_ACK:
      case EXTENDED_COMPRESSED_BLOCK_ACK:
        /* We can ignore this...compressed block ack doesn't support
           acknowledgement of single fragments */
        break;
      case MULTI_TID_BLOCK_ACK:
        NS_FATAL_ERROR ("Multi-tid block ack is not supported.");
        break;
      default:
        NS_FATAL_ERROR ("Invalid BA type");
        break;
          NS_FATAL_ERROR ("Multi-tid block ack is not supported.");
        }
      else
        {
          NS_FATAL_ERROR ("Reserved configuration.");
        }
    }
}


    {
      return false;
    }
  switch (m_baType)
    {
      case BASIC_BLOCK_ACK:
        {
          /*It's impossible to say if an entire packet was correctly received. */
          return false;
        }
      case COMPRESSED_BLOCK_ACK:
        {
          /* Although this could make no sense, if packet with sequence number
             equal to <i>seq</i> was correctly received, also all of its fragments
             were correctly received. */
          uint64_t mask = uint64_t (0x0000000000000001);
          return (((bitmap.m_compressedBitmap >> IndexInBitmap (seq)) & mask) == 1) ? true : false;
        }
      case EXTENDED_COMPRESSED_BLOCK_ACK:
        {
          uint64_t mask = uint64_t (0x0000000000000001);
          uint16_t index = IndexInBitmap (seq);
          return (((bitmap.m_extendedCompressedBitmap[index/64] >> index) & mask) == 1) ? true : false;
        }
      case MULTI_TID_BLOCK_ACK:
        {
          NS_FATAL_ERROR ("Multi-tid block ack is not supported.");
          break;
        }
      default:
        {
          NS_FATAL_ERROR ("Invalid BA type");
          break;
        }
    }
  return false;

    {
      return false;
    }
  switch (m_baType)
    {
      case BASIC_BLOCK_ACK:
        {
          return ((bitmap.m_bitmap[IndexInBitmap (seq)] & (0x0001 << frag)) != 0x0000) ? true : false;
        }
      case COMPRESSED_BLOCK_ACK:
        {
          /* Although this could make no sense, if packet with sequence number
             equal to <i>seq</i> was correctly received, also all of its fragments

          uint64_t mask = uint64_t (0x0000000000000001);
          return (((bitmap.m_compressedBitmap >> IndexInBitmap (seq)) & mask) == 1) ? true : false;
        }
      case EXTENDED_COMPRESSED_BLOCK_ACK:
        {
          uint64_t mask = uint64_t (0x0000000000000001);
          uint16_t index = IndexInBitmap (seq);
          return (((bitmap.m_extendedCompressedBitmap[index/64] >> index) & mask) == 1) ? true : false;
        }
      case MULTI_TID_BLOCK_ACK:
        {
          NS_FATAL_ERROR ("Multi-tid block ack is not supported.");
          break;
        }
      default:
        {
          NS_FATAL_ERROR ("Invalid BA type");
          break;
        }
    }
  return false;

    {
      index = 4096 - m_startingSeq + seq;
    }
  if (m_baType == EXTENDED_COMPRESSED_BLOCK_ACK)
    {
      NS_ASSERT (index <= 255);
    }
  else
    {
      NS_ASSERT (index <= 63);
    }
  return index;
}

bool
CtrlBAckResponseHeader::IsInBitmap (uint16_t seq) const
{
  if (m_baType == EXTENDED_COMPRESSED_BLOCK_ACK)
    {
      return (seq - m_startingSeq + 4096) % 4096 < 256;
    }
  else
    {
      return (seq - m_startingSeq + 4096) % 4096 < 64;
    }
}

const uint16_t*

  return bitmap.m_compressedBitmap;
}

const uint64_t*
CtrlBAckResponseHeader::GetExtendedCompressedBitmap (void) const
{
  return bitmap.m_extendedCompressedBitmap;
}

void
CtrlBAckResponseHeader::ResetBitmap (void)
{

(-)a/src/wifi/model/ctrl-headers.h (-16 / +46 lines)

Lines 88-93 public:	Link Here

*/

*/

  bool MustSendHtImmediateAck (void) const;

  bool MustSendHtImmediateAck (void) const;

/**

/**

   * Return the block ACK type ID.

   * \return type

*/

  BlockAckType GetType (void) const;

/**

   * Return the Traffic ID (TID).

   * Return the Traffic ID (TID).

   * \return TID

   * \return TID

Lines 116-121 public:	Link Here

116

*/

122

*/

117

  bool IsCompressed (void) const;

123

  bool IsCompressed (void) const;

118

/**

124

/**

125

   * Check if the current BA policy is extended compressed block ACK.

126

127

   * \return true if the current BA policy is extended compressed block ACK,

128

   *         false otherwise

129

*/

130

  bool IsExtendedCompressed (void) const;

131

/**

119

   * Check if the current ACK policy has multiple TID.

132

   * Check if the current ACK policy has multiple TID.

120

133

121

   * \return true if the current ACK policy has multiple TID,

134

   * \return true if the current ACK policy has multiple TID,

Lines 158-167 private:	Link Here

158

   * For now only non HT immediate block ack is implemented so this field

171

   * For now only non HT immediate block ack is implemented so this field

159

   * is here only for a future implementation of HT delayed variant.

172

   * is here only for a future implementation of HT delayed variant.

160

*/

173

*/

161

  bool m_barAckPolicy; ///< bar ack policy

174

  bool m_barAckPolicy;    ///< bar ack policy

162

  bool m_multiTid; ///< multi TID

175

  BlockAckType m_baType;  ///< BA type

163

  bool m_compressed; ///< compressed

176

  uint16_t m_tidInfo;     ///< TID info

164

  uint16_t m_tidInfo; ///< TID info

165

  uint16_t m_startingSeq; ///< starting seq

177

  uint16_t m_startingSeq; ///< starting seq

166

};

178

};

167

179

Lines 228-233 public:	Link Here

228

*/

240

*/

229

  bool MustSendHtImmediateAck (void) const;

241

  bool MustSendHtImmediateAck (void) const;

230

/**

242

/**

243

   * Return the block ACK type ID.

244

245

   * \return type

246

*/

247

  BlockAckType GetType (void) const;

248

/**

231

   * Return the Traffic ID (TID).

249

   * Return the Traffic ID (TID).

232

250

233

   * \return TID

251

   * \return TID

Lines 240-264 public:	Link Here

240

*/

258

*/

241

  uint16_t GetStartingSequence (void) const;

259

  uint16_t GetStartingSequence (void) const;

242

/**

260

/**

243

   * Check if the current ACK policy is basic

261

   * Check if the current BA policy is basic block ACK.

244

   * (i.e. not multiple TID and not compressed ACK).

245

262

246

   * \return true if the current ACK policy is basic,

263

   * \return true if the current BA policy is basic block ACK,

247

   *         false otherwise

264

   *         false otherwise

248

*/

265

*/

249

  bool IsBasic (void) const;

266

  bool IsBasic (void) const;

250

/**

267

/**

251

   * Check if the current ACK policy is compressed ACK

268

   * Check if the current BA policy is compressed block ACK.

252

   * and not multiple TID.

253

269

254

   * \return true if the current ACK policy is compressed ACK,

270

   * \return true if the current BA policy is compressed block ACK,

255

   *         false otherwise

271

   *         false otherwise

256

*/

272

*/

257

  bool IsCompressed (void) const;

273

  bool IsCompressed (void) const;

258

/**

274

/**

259

   * Check if the current ACK policy has multiple TID.

275

   * Check if the current BA policy is extended compressed block ACK.

260

276

261

   * \return true if the current ACK policy has multiple TID,

277

   * \return true if the current BA policy is extended compressed block ACK,

278

   *         false otherwise

279

*/

280

  bool IsExtendedCompressed (void) const;

281

/**

282

   * Check if the current BA policy is multi-TID block ACK.

283

284

   * \return true if the current BA policy is multi-TID block ACK,

262

   *         false otherwise

285

   *         false otherwise

263

*/

286

*/

264

  bool IsMultiTid (void) const;

287

  bool IsMultiTid (void) const;

Lines 317-322 public:	Link Here

317

340

318

   * \return the bitmap from the block ACK response header

341

   * \return the bitmap from the block ACK response header

319

*/

342

*/

343

320

  const uint16_t* GetBitmap (void) const;

344

  const uint16_t* GetBitmap (void) const;

321

/**

345

/**

322

   * Return the compressed bitmap from the block ACK response header.

346

   * Return the compressed bitmap from the block ACK response header.

Lines 324-329 public:	Link Here

324

   * \return the compressed bitmap from the block ACK response header

348

   * \return the compressed bitmap from the block ACK response header

325

*/

349

*/

326

  uint64_t GetCompressedBitmap (void) const;

350

  uint64_t GetCompressedBitmap (void) const;

351

/**

352

   * Return the extended compressed bitmap from the block ACK response header.

353

354

   * \return the extended compressed bitmap from the block ACK response header

355

*/

356

  const uint64_t* GetExtendedCompressedBitmap (void) const;

327

357

328

/**

358

/**

329

   * Reset the bitmap to 0.

359

   * Reset the bitmap to 0.

Lines 391-406 private:	Link Here

391

   * For now only non HT immediate block ack is implemented so this field

421

   * For now only non HT immediate block ack is implemented so this field

392

   * is here only for a future implementation of HT delayed variant.

422

   * is here only for a future implementation of HT delayed variant.

393

*/

423

*/

394

  bool m_baAckPolicy; ///< BA ack policy

424

  bool m_baAckPolicy;     ///< BA ack policy

395

  bool m_multiTid; ///< multi TID

425

  BlockAckType m_baType;  ///< BA type

396

  bool m_compressed; ///< compressed

426

  uint16_t m_tidInfo;     ///< TID info

397

  uint16_t m_tidInfo; ///< TID info

398

  uint16_t m_startingSeq; ///< starting seq

427

  uint16_t m_startingSeq; ///< starting seq

399

428

400

  union

429

  union

401

430

402

    uint16_t m_bitmap[64]; ///< the block ack bitmap

431

    uint16_t m_bitmap[64]; ///< the block ack bitmap

403

    uint64_t m_compressedBitmap; ///< the compressed block ack bitmap

432

    uint64_t m_compressedBitmap; ///< the compressed block ack bitmap

433

    uint64_t m_extendedCompressedBitmap[4]; ///< the extended compressed block ack bitmap

404

  } bitmap; ///< bitmap union type

434

  } bitmap; ///< bitmap union type

405

};

435

};

406

436




                   MakeTimeAccessor (&HeConfiguration::GetGuardInterval,
                                     &HeConfiguration::SetGuardInterval),
                   MakeTimeChecker (NanoSeconds (800), NanoSeconds (3200)))
    .AddAttribute ("BssColor",
                   "The BSS color",
                   UintegerValue (0),
                   MakeUintegerAccessor (&HeConfiguration::m_bssColor),
                   MakeUintegerChecker<uint8_t> ())
    .AddAttribute ("MpduBufferSize",
                   "The MPDU buffer size for receiving A-MPDUs",
                   UintegerValue (64),
                   MakeUintegerAccessor (&HeConfiguration::GetMpduBufferSize,
                                         &HeConfiguration::SetMpduBufferSize),
                   MakeUintegerChecker<uint16_t> (64, 256))
    .AddAttribute ("VoMaxAmsduSize",
                   "Maximum length in bytes of an A-MSDU for AC_VO access class. "
                   "Value 0 means A-MSDU is disabled for that AC.",
                   UintegerValue (0),
                   MakeUintegerAccessor (&HeConfiguration::m_voMaxAmsduSize),
                   MakeUintegerChecker<uint16_t> (0, 11454))
    .AddAttribute ("ViMaxAmsduSize",
                   "Maximum length in bytes of an A-MSDU for AC_VI access class."
                   "Value 0 means A-MSDU is disabled for that AC.",
                   UintegerValue (0),
                   MakeUintegerAccessor (&HeConfiguration::m_viMaxAmsduSize),
                   MakeUintegerChecker<uint16_t> (0, 11454))
    .AddAttribute ("BeMaxAmsduSize",
                   "Maximum length in bytes of an A-MSDU for AC_BE access class."
                   "Value 0 means A-MSDU is disabled for that AC.",
                   UintegerValue (0),
                   MakeUintegerAccessor (&HeConfiguration::m_beMaxAmsduSize),
                   MakeUintegerChecker<uint16_t> (0, 11454))
    .AddAttribute ("BkMaxAmsduSize",
                   "Maximum length in bytes of an A-MSDU for AC_BK access class."
                   "Value 0 means A-MSDU is disabled for that AC.",
                   UintegerValue (0),
                   MakeUintegerAccessor (&HeConfiguration::m_bkMaxAmsduSize),
                   MakeUintegerChecker<uint16_t> (0, 11454))
    .AddAttribute ("VoMaxAmpduSize",
                   "Maximum length in bytes of an A-MPDU for AC_VO access class."
                   "Value 0 means A-MPDU is disabled for that AC.",
                   UintegerValue (0),
                   MakeUintegerAccessor (&HeConfiguration::m_voMaxAmpduSize),
                   MakeUintegerChecker<uint32_t> (0, 4194303))
    .AddAttribute ("ViMaxAmpduSize",
                   "Maximum length in bytes of an A-MPDU for AC_VI access class."
                   "Value 0 means A-MPDU is disabled for that AC.",
                   UintegerValue (4194303),
                   MakeUintegerAccessor (&HeConfiguration::m_viMaxAmpduSize),
                   MakeUintegerChecker<uint32_t> (0, 4194303))
    .AddAttribute ("BeMaxAmpduSize",
                   "Maximum length in bytes of an A-MPDU for AC_BE access class."
                   "Value 0 means A-MPDU is disabled for that AC.",
                   UintegerValue (4194303),
                   MakeUintegerAccessor (&HeConfiguration::m_beMaxAmpduSize),
                   MakeUintegerChecker<uint32_t> (0, 4194303))
    .AddAttribute ("BkMaxAmpduSize",
                   "Maximum length in bytes of an A-MPDU for AC_BK access class."
                   "Value 0 means A-MPDU is disabled for that AC.",
                   UintegerValue (0),
                   MakeUintegerAccessor (&HeConfiguration::m_bkMaxAmpduSize),
                   MakeUintegerChecker<uint32_t> (0, 4194303))
    ;
    return tid;
}

  return m_guardInterval;
}

void
HeConfiguration::SetMpduBufferSize (uint16_t size)
{
  NS_LOG_FUNCTION (this << size);
  m_mpduBufferSize = size;
}

uint16_t
HeConfiguration::GetMpduBufferSize (void) const
{
  return m_mpduBufferSize;
}

} //namespace ns3




   * \return the supported HE guard interval
   */
  Time GetGuardInterval (void) const;
  /**
   * \param size the MPDU buffer size to receive A-MPDUs
   */
  void SetMpduBufferSize (uint16_t size);
  /**
   * \return the MPDU buffer size to receive A-MPDUs
   */
  uint16_t GetMpduBufferSize (void) const;


private:
  Time m_guardInterval;      //!< Supported HE guard interval
  uint8_t m_bssColor;        //!< BSS color
  uint16_t m_mpduBufferSize; //!< MPDU buffer size

  uint16_t m_voMaxAmsduSize; ///< maximum A-MSDU size for AC_VO
  uint16_t m_viMaxAmsduSize; ///< maximum A-MSDU size for AC_VI
  uint16_t m_beMaxAmsduSize; ///< maximum A-MSDU size for AC_BE
  uint16_t m_bkMaxAmsduSize; ///< maximum A-MSDU size for AC_BK

  uint32_t m_voMaxAmpduSize; ///< maximum A-MPDU size for AC_VO
  uint32_t m_viMaxAmpduSize; ///< maximum A-MPDU size for AC_VI
  uint32_t m_beMaxAmpduSize; ///< maximum A-MPDU size for AC_BE
  uint32_t m_bkMaxAmpduSize; ///< maximum A-MPDU size for AC_BK
};

} //namespace ns3





#include "ns3/log.h"
#include "ns3/boolean.h"
#include "ns3/uinteger.h"
#include "ht-configuration.h"

namespace ns3 {

                   MakeBooleanAccessor (&HtConfiguration::SetRifsSupported,
                                        &HtConfiguration::GetRifsSupported),
                   MakeBooleanChecker ())
    .AddAttribute ("VoMaxAmsduSize",
                   "Maximum length in bytes of an A-MSDU for AC_VO access class. "
                   "Value 0 means A-MSDU is disabled for that AC.",
                   UintegerValue (0),
                   MakeUintegerAccessor (&HtConfiguration::m_voMaxAmsduSize),
                   MakeUintegerChecker<uint16_t> (0, 7935))
    .AddAttribute ("ViMaxAmsduSize",
                   "Maximum length in bytes of an A-MSDU for AC_VI access class."
                   "Value 0 means A-MSDU is disabled for that AC.",
                   UintegerValue (0),
                   MakeUintegerAccessor (&HtConfiguration::m_viMaxAmsduSize),
                   MakeUintegerChecker<uint16_t> (0, 7935))
    .AddAttribute ("BeMaxAmsduSize",
                   "Maximum length in bytes of an A-MSDU for AC_BE access class."
                   "Value 0 means A-MSDU is disabled for that AC.",
                   UintegerValue (0),
                   MakeUintegerAccessor (&HtConfiguration::m_beMaxAmsduSize),
                   MakeUintegerChecker<uint16_t> (0, 7935))
    .AddAttribute ("BkMaxAmsduSize",
                   "Maximum length in bytes of an A-MSDU for AC_BK access class."
                   "Value 0 means A-MSDU is disabled for that AC.",
                   UintegerValue (0),
                   MakeUintegerAccessor (&HtConfiguration::m_bkMaxAmsduSize),
                   MakeUintegerChecker<uint16_t> (0, 7935))
    .AddAttribute ("VoMaxAmpduSize",
                   "Maximum length in bytes of an A-MPDU for AC_VO access class."
                   "Value 0 means A-MPDU is disabled for that AC.",
                   UintegerValue (0),
                   MakeUintegerAccessor (&HtConfiguration::m_voMaxAmpduSize),
                   MakeUintegerChecker<uint32_t> (0, 65535))
    .AddAttribute ("ViMaxAmpduSize",
                   "Maximum length in bytes of an A-MPDU for AC_VI access class."
                   "Value 0 means A-MPDU is disabled for that AC.",
                   UintegerValue (65535),
                   MakeUintegerAccessor (&HtConfiguration::m_viMaxAmpduSize),
                   MakeUintegerChecker<uint32_t> (0, 65535))
    .AddAttribute ("BeMaxAmpduSize",
                   "Maximum length in bytes of an A-MPDU for AC_BE access class."
                   "Value 0 means A-MPDU is disabled for that AC.",
                   UintegerValue (65535),
                   MakeUintegerAccessor (&HtConfiguration::m_beMaxAmpduSize),
                   MakeUintegerChecker<uint32_t> (0, 65535))
    .AddAttribute ("BkMaxAmpduSize",
                   "Maximum length in bytes of an A-MPDU for AC_BK access class."
                   "Value 0 means A-MPDU is disabled for that AC.",
                   UintegerValue (0),
                   MakeUintegerAccessor (&HtConfiguration::m_bkMaxAmpduSize),
                   MakeUintegerChecker<uint32_t> (0, 65535))
    ;
    return tid;
}




   *         false otherwise.
   */
  bool GetShortGuardIntervalSupported (void) const;

  /**
   * Enable or disable Greenfield support.
   *

   *         false otherwise.
   */
  bool GetGreenfieldSupported (void) const;

  /**
   * Enable or disable RIFS support.
   *



private:
  bool m_sgiSupported;        ///< flag whether short guard interval is supported
  bool m_rifsSupported;       ///< flag whether RIFS is supported
  bool m_greenfieldSupported; ///< flag whether Greenfield is supported

  uint16_t m_voMaxAmsduSize; ///< maximum A-MSDU size for AC_VO
  uint16_t m_viMaxAmsduSize; ///< maximum A-MSDU size for AC_VI
  uint16_t m_beMaxAmsduSize; ///< maximum A-MSDU size for AC_BE
  uint16_t m_bkMaxAmsduSize; ///< maximum A-MSDU size for AC_BK

  uint32_t m_voMaxAmpduSize; ///< maximum A-MPDU size for AC_VO
  uint32_t m_viMaxAmpduSize; ///< maximum A-MPDU size for AC_VI
  uint32_t m_beMaxAmpduSize; ///< maximum A-MPDU size for AC_BE
  uint32_t m_bkMaxAmpduSize; ///< maximum A-MPDU size for AC_BK
};

} //namespace ns3

(-)a/src/wifi/model/mac-low-transmission-parameters.cc (+15 lines)

Lines 56-61 MacLowTransmissionParameters::EnableCompressedBlockAck (void)	Link Here

void

void

MacLowTransmissionParameters::EnableExtendedCompressedBlockAck (void)

  m_waitAck = EXTENDED_BLOCK_ACK_COMPRESSED;

void

MacLowTransmissionParameters::EnableMultiTidBlockAck (void)

MacLowTransmissionParameters::EnableMultiTidBlockAck (void)

  m_waitAck = BLOCK_ACK_MULTI_TID;

  m_waitAck = BLOCK_ACK_MULTI_TID;

Lines 104-109 MacLowTransmissionParameters::MustWaitCompressedBlockAck (void) const	Link Here

104

110

105

111

106

bool

112

bool

113

MacLowTransmissionParameters::MustWaitExtendedCompressedBlockAck (void) const

114

115

  return (m_waitAck == EXTENDED_BLOCK_ACK_COMPRESSED) ? true : false;

116

117

118

bool

107

MacLowTransmissionParameters::MustWaitMultiTidBlockAck (void) const

119

MacLowTransmissionParameters::MustWaitMultiTidBlockAck (void) const

108

120

109

  return (m_waitAck == BLOCK_ACK_MULTI_TID) ? true : false;

121

  return (m_waitAck == BLOCK_ACK_MULTI_TID) ? true : false;

Lines 148-153 std::ostream &operator << (std::ostream &os, const MacLowTransmissionParameters	Link Here

148

    case MacLowTransmissionParameters::BLOCK_ACK_COMPRESSED:

160

    case MacLowTransmissionParameters::BLOCK_ACK_COMPRESSED:

149

      os << "compressed-block-ack";

161

      os << "compressed-block-ack";

150

      break;

162

      break;

163

    case MacLowTransmissionParameters::EXTENDED_BLOCK_ACK_COMPRESSED:

164

      os << "extended-compressed-block-ack";

165

      break;

151

    case MacLowTransmissionParameters::BLOCK_ACK_MULTI_TID:

166

    case MacLowTransmissionParameters::BLOCK_ACK_MULTI_TID:

152

      os << "multi-tid-block-ack";

167

      os << "multi-tid-block-ack";

153

      break;

168

      break;

(-)a/src/wifi/model/mac-low-transmission-parameters.h (+11 lines)

Lines 55-60 public:	Link Here

*/

*/

  void EnableCompressedBlockAck (void);

  void EnableCompressedBlockAck (void);

/**

/**

   * Wait COMPRESSEDBLOCKACKTimeout for an Extended Compressed Block Ack Response frame.

*/

  void EnableExtendedCompressedBlockAck (void);

/**

   * NOT IMPLEMENTED FOR NOW

   * NOT IMPLEMENTED FOR NOW

*/

*/

  void EnableMultiTidBlockAck (void);

  void EnableMultiTidBlockAck (void);

Lines 108-113 public:	Link Here

108

*/

112

*/

109

  bool MustWaitCompressedBlockAck (void) const;

113

  bool MustWaitCompressedBlockAck (void) const;

110

/**

114

/**

115

   * \returns true if extended compressed block ack mechanism is used, false otherwise.

116

117

   * \sa EnableExtendedCompressedBlockAck

118

*/

119

  bool MustWaitExtendedCompressedBlockAck (void) const;

120

/**

111

   * \returns true if multi-tid block ack mechanism is used, false otherwise.

121

   * \returns true if multi-tid block ack mechanism is used, false otherwise.

112

122

113

   * \sa EnableMultiTidBlockAck

123

   * \sa EnableMultiTidBlockAck

Lines 137-142 private:	Link Here

137

    ACK_NORMAL,

147

    ACK_NORMAL,

138

    BLOCK_ACK_BASIC,

148

    BLOCK_ACK_BASIC,

139

    BLOCK_ACK_COMPRESSED,

149

    BLOCK_ACK_COMPRESSED,

150

    EXTENDED_BLOCK_ACK_COMPRESSED,

140

    BLOCK_ACK_MULTI_TID

151

    BLOCK_ACK_MULTI_TID

141

  } m_waitAck; //!< wait ack

152

  } m_waitAck; //!< wait ack

142

  bool m_sendRts; //!< send an RTS?

153

  bool m_sendRts; //!< send an RTS?

(-)a/src/wifi/model/mac-low.cc (-46 / +273 lines)

Lines 39-44	Link Here

#include "wifi-mac-trailer.h"

#include "wifi-mac-trailer.h"

#include "wifi-phy.h"

#include "wifi-phy.h"

#include "wifi-net-device.h"

#include "wifi-net-device.h"

#include "wifi-mac.h"

#include "ht-configuration.h"

#include "vht-configuration.h"

#include "he-configuration.h"

#undef NS_LOG_APPEND_CONTEXT

#undef NS_LOG_APPEND_CONTEXT

#define NS_LOG_APPEND_CONTEXT std::clog << "[mac=" << m_self << "] "

#define NS_LOG_APPEND_CONTEXT std::clog << "[mac=" << m_self << "] "

Lines 271-276 MacLow::ResetPhy (void)	Link Here

271

275

272

276

273

void

277

void

278

MacLow::SetMac (const Ptr<WifiMac> mac)

279

280

  m_mac = mac;

281

282

283

void

274

MacLow::SetWifiRemoteStationManager (const Ptr<WifiRemoteStationManager> manager)

284

MacLow::SetWifiRemoteStationManager (const Ptr<WifiRemoteStationManager> manager)

275

285

276

  m_stationManager = manager;

286

  m_stationManager = manager;

Lines 536-542 MacLow::StartTransmission (Ptr<const Packet> packet,	Link Here

536

      m_ampdu = true;

546

      m_ampdu = true;

537

      if (sentMpdus > 1)

547

      if (sentMpdus > 1)

538

548

539

          m_txParams.EnableCompressedBlockAck ();

549

          AcIndex ac = QosUtilsMapTidToAc (GetTid (packet, *hdr));

550

          std::map<AcIndex, Ptr<QosTxop> >::const_iterator edcaIt = m_edca.find (ac);

551

          if (edcaIt->second->GetBaBufferSize (m_currentHdr.GetAddr1 (), m_currentHdr.GetQosTid ()) > 64)

552

553

              m_txParams.EnableExtendedCompressedBlockAck ();

554

555

          else

556

557

              m_txParams.EnableCompressedBlockAck ();

558

540

559

541

      else if (m_currentHdr.IsQosData ())

560

      else if (m_currentHdr.IsQosData ())

542

561

Lines 551-557 MacLow::StartTransmission (Ptr<const Packet> packet,	Link Here

551

          Ptr<Packet> newPacket = (m_txPackets[GetTid (packet, *hdr)].at (i).packet)->Copy ();

570

          Ptr<Packet> newPacket = (m_txPackets[GetTid (packet, *hdr)].at (i).packet)->Copy ();

552

          newPacket->AddHeader (m_txPackets[GetTid (packet, *hdr)].at (i).hdr);

571

          newPacket->AddHeader (m_txPackets[GetTid (packet, *hdr)].at (i).hdr);

553

          AddWifiMacTrailer (newPacket);

572

          AddWifiMacTrailer (newPacket);

554

          edcaIt->second->GetMpduAggregator ()->Aggregate (newPacket, aggregatedPacket);

573

          edcaIt->second->GetMpduAggregator ()->Aggregate (newPacket, aggregatedPacket, GetMaxAmpduSize (ac));

555

574

556

      m_currentPacket = aggregatedPacket;

575

      m_currentPacket = aggregatedPacket;

557

      m_currentHdr = (m_txPackets[GetTid (packet, *hdr)].at (0).hdr);

576

      m_currentHdr = (m_txPackets[GetTid (packet, *hdr)].at (0).hdr);

Lines 567-573 MacLow::StartTransmission (Ptr<const Packet> packet,	Link Here

567

          m_currentPacket->PeekPacketTag (ampdu);

586

          m_currentPacket->PeekPacketTag (ampdu);

568

          if (ampdu.GetRemainingNbOfMpdus () > 0)

587

          if (ampdu.GetRemainingNbOfMpdus () > 0)

569

588

570

              m_txParams.EnableCompressedBlockAck ();

589

              AcIndex ac = QosUtilsMapTidToAc (GetTid (packet, *hdr));

590

              std::map<AcIndex, Ptr<QosTxop> >::const_iterator edcaIt = m_edca.find (ac);

591

              if (edcaIt->second->GetBaBufferSize (m_currentHdr.GetAddr1 (), m_currentHdr.GetQosTid ()) > 64)

592

593

                  m_txParams.EnableExtendedCompressedBlockAck ();

594

595

              else

596

597

                  m_txParams.EnableCompressedBlockAck ();

598

571

599

572

          else if (m_currentHdr.IsQosData ())

600

          else if (m_currentHdr.IsQosData ())

573

601

Lines 815-821 MacLow::ReceiveOk (Ptr<Packet> packet, double rxSnr, WifiTxVector txVector, bool	Link Here

815

843

816

844

817

  else if (hdr.IsBlockAck () && hdr.GetAddr1 () == m_self

845

  else if (hdr.IsBlockAck () && hdr.GetAddr1 () == m_self

818

           && (m_txParams.MustWaitBasicBlockAck () || m_txParams.MustWaitCompressedBlockAck ())

846

           && (m_txParams.MustWaitBasicBlockAck () || m_txParams.MustWaitCompressedBlockAck () || m_txParams.MustWaitExtendedCompressedBlockAck ())

819

           && m_blockAckTimeoutEvent.IsRunning ())

847

           && m_blockAckTimeoutEvent.IsRunning ())

820

848

821

      NS_LOG_DEBUG ("got block ack from " << hdr.GetAddr2 ());

849

      NS_LOG_DEBUG ("got block ack from " << hdr.GetAddr2 ());

Lines 1573-1582 MacLow::SendRtsForPacket (void)	Link Here

1573

      WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1601

      WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1574

      duration += GetBlockAckDuration (blockAckReqTxVector, BASIC_BLOCK_ACK);

1602

      duration += GetBlockAckDuration (blockAckReqTxVector, BASIC_BLOCK_ACK);

1575

1603

1576

  else if (m_txParams.MustWaitCompressedBlockAck ())

1604

  else if (m_txParams.MustWaitCompressedBlockAck () || m_txParams.MustWaitExtendedCompressedBlockAck ())

1577

1605

1578

      WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1606

      WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1579

      duration += GetBlockAckDuration (blockAckReqTxVector, COMPRESSED_BLOCK_ACK);

1607

        if (m_txParams.MustWaitExtendedCompressedBlockAck ())

1608

1609

            duration += GetBlockAckDuration (blockAckReqTxVector, EXTENDED_COMPRESSED_BLOCK_ACK);

1610

1611

        else

1612

1613

            duration += GetBlockAckDuration (blockAckReqTxVector, COMPRESSED_BLOCK_ACK);

1614

1580

1615

1581

  else if (m_txParams.MustWaitNormalAck ())

1616

  else if (m_txParams.MustWaitNormalAck ())

1582

1617

Lines 1626-1632 MacLow::StartDataTxTimers (WifiTxVector dataTxVector)	Link Here

1626

      NotifyAckTimeoutStartNow (timerDelay);

1661

      NotifyAckTimeoutStartNow (timerDelay);

1627

      m_blockAckTimeoutEvent = Simulator::Schedule (timerDelay, &MacLow::BlockAckTimeout, this);

1662

      m_blockAckTimeoutEvent = Simulator::Schedule (timerDelay, &MacLow::BlockAckTimeout, this);

1628

1663

1629

  else if (m_txParams.MustWaitCompressedBlockAck ())

1664

  else if (m_txParams.MustWaitCompressedBlockAck () || m_txParams.MustWaitExtendedCompressedBlockAck ())

1630

1665

1631

      Time timerDelay = txDuration + GetCompressedBlockAckTimeout ();

1666

      Time timerDelay = txDuration + GetCompressedBlockAckTimeout ();

1632

      NS_ASSERT (m_blockAckTimeoutEvent.IsExpired ());

1667

      NS_ASSERT (m_blockAckTimeoutEvent.IsExpired ());

Lines 1683-1693 MacLow::SendDataPacket (void)	Link Here

1683

          WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1718

          WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1684

          duration += GetBlockAckDuration (blockAckReqTxVector, BASIC_BLOCK_ACK);

1719

          duration += GetBlockAckDuration (blockAckReqTxVector, BASIC_BLOCK_ACK);

1685

1720

1686

      else if (m_txParams.MustWaitCompressedBlockAck ())

1721

      else if (m_txParams.MustWaitCompressedBlockAck () || m_txParams.MustWaitExtendedCompressedBlockAck ())

1687

1722

1688

          duration += GetSifs ();

1723

          duration += GetSifs ();

1689

          WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1724

          WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1690

          duration += GetBlockAckDuration (blockAckReqTxVector, COMPRESSED_BLOCK_ACK);

1725

          if (m_txParams.MustWaitExtendedCompressedBlockAck ())

1726

1727

              duration += GetBlockAckDuration (blockAckReqTxVector, EXTENDED_COMPRESSED_BLOCK_ACK);

1728

1729

          else

1730

1731

              duration += GetBlockAckDuration (blockAckReqTxVector, COMPRESSED_BLOCK_ACK);

1732

1691

1733

1692

      else if (m_txParams.MustWaitNormalAck ())

1734

      else if (m_txParams.MustWaitNormalAck ())

1693

1735

Lines 1807-1817 MacLow::SendCtsToSelf (void)	Link Here

1807

      WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1849

      WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1808

      duration += GetBlockAckDuration (blockAckReqTxVector, BASIC_BLOCK_ACK);

1850

      duration += GetBlockAckDuration (blockAckReqTxVector, BASIC_BLOCK_ACK);

1809

1851

1810

  else if (m_txParams.MustWaitCompressedBlockAck ())

1852

  else if (m_txParams.MustWaitCompressedBlockAck () || m_txParams.MustWaitExtendedCompressedBlockAck ())

1811

1853

1812

      duration += GetSifs ();

1854

      duration += GetSifs ();

1813

      WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1855

      WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1814

      duration += GetBlockAckDuration (blockAckReqTxVector, COMPRESSED_BLOCK_ACK);

1856

      if (m_txParams.MustWaitExtendedCompressedBlockAck ())

1857

1858

          duration += GetBlockAckDuration (blockAckReqTxVector, EXTENDED_COMPRESSED_BLOCK_ACK);

1859

1860

      else

1861

1862

          duration += GetBlockAckDuration (blockAckReqTxVector, COMPRESSED_BLOCK_ACK);

1863

1815

1864

1816

  else if (m_txParams.MustWaitNormalAck ())

1865

  else if (m_txParams.MustWaitNormalAck ())

1817

1866

Lines 1823-1833 MacLow::SendCtsToSelf (void)	Link Here

1823

      duration += GetSifs ();

1872

      duration += GetSifs ();

1824

      duration += m_phy->CalculateTxDuration (m_txParams.GetNextPacketSize (),

1873

      duration += m_phy->CalculateTxDuration (m_txParams.GetNextPacketSize (),

1825

                                              m_currentTxVector, m_phy->GetFrequency ());

1874

                                              m_currentTxVector, m_phy->GetFrequency ());

1826

      if (m_txParams.MustWaitCompressedBlockAck ())

1875

      if (m_txParams.MustWaitCompressedBlockAck () || m_txParams.MustWaitExtendedCompressedBlockAck ())

1827

1876

1828

          duration += GetSifs ();

1877

          duration += GetSifs ();

1829

          WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1878

          WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1830

          duration += GetBlockAckDuration (blockAckReqTxVector, COMPRESSED_BLOCK_ACK);

1879

          if (m_txParams.MustWaitExtendedCompressedBlockAck ())

1880

1881

              duration += GetBlockAckDuration (blockAckReqTxVector, EXTENDED_COMPRESSED_BLOCK_ACK);

1882

1883

          else

1884

1885

              duration += GetBlockAckDuration (blockAckReqTxVector, COMPRESSED_BLOCK_ACK);

1886

1831

1887

1832

      else if (m_txParams.MustWaitNormalAck ())

1888

      else if (m_txParams.MustWaitNormalAck ())

1833

1889

Lines 1916-1926 MacLow::SendDataAfterCts (Time duration)	Link Here

1916

      WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1972

      WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1917

      newDuration += GetBlockAckDuration (blockAckReqTxVector, BASIC_BLOCK_ACK);

1973

      newDuration += GetBlockAckDuration (blockAckReqTxVector, BASIC_BLOCK_ACK);

1918

1974

1919

  else if (m_txParams.MustWaitCompressedBlockAck ())

1975

  else if (m_txParams.MustWaitCompressedBlockAck () || m_txParams.MustWaitExtendedCompressedBlockAck ())

1920

1976

1921

      newDuration += GetSifs ();

1977

      newDuration += GetSifs ();

1922

      WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1978

      WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1923

      newDuration += GetBlockAckDuration (blockAckReqTxVector, COMPRESSED_BLOCK_ACK);

1979

      if (m_txParams.MustWaitExtendedCompressedBlockAck ())

1980

1981

          newDuration += GetBlockAckDuration (blockAckReqTxVector, EXTENDED_COMPRESSED_BLOCK_ACK);

1982

1983

      else

1984

1985

          newDuration += GetBlockAckDuration (blockAckReqTxVector, COMPRESSED_BLOCK_ACK);

1986

1924

1987

1925

  else if (m_txParams.MustWaitNormalAck ())

1988

  else if (m_txParams.MustWaitNormalAck ())

1926

1989

Lines 1938-1948 MacLow::SendDataAfterCts (Time duration)	Link Here

1938

          newDuration += GetSifs ();

2001

          newDuration += GetSifs ();

1939

2002

1940

      newDuration += m_phy->CalculateTxDuration (m_txParams.GetNextPacketSize (), m_currentTxVector, m_phy->GetFrequency ());

2003

      newDuration += m_phy->CalculateTxDuration (m_txParams.GetNextPacketSize (), m_currentTxVector, m_phy->GetFrequency ());

1941

      if (m_txParams.MustWaitCompressedBlockAck ())

2004

      if (m_txParams.MustWaitCompressedBlockAck () || m_txParams.MustWaitExtendedCompressedBlockAck ())

1942

2005

1943

          newDuration += GetSifs ();

2006

          newDuration += GetSifs ();

1944

          WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

2007

          WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1945

          newDuration += GetBlockAckDuration (blockAckReqTxVector, COMPRESSED_BLOCK_ACK);

2008

          if (m_txParams.MustWaitExtendedCompressedBlockAck ())

2009

2010

              newDuration += GetBlockAckDuration (blockAckReqTxVector, EXTENDED_COMPRESSED_BLOCK_ACK);

2011

2012

          else

2013

2014

              newDuration += GetBlockAckDuration (blockAckReqTxVector, COMPRESSED_BLOCK_ACK);

2015

1946

2016

1947

      else if (m_txParams.MustWaitNormalAck ())

2017

      else if (m_txParams.MustWaitNormalAck ())

1948

2018

Lines 2259-2264 MacLow::RxCompleteBufferedPacketsUntilFirstLost (Mac48Address originator, uint8_	Link Here

2259

      (*it).second.second.erase ((*it).second.second.begin (), lastComplete);

2329

      (*it).second.second.erase ((*it).second.second.begin (), lastComplete);

2260

2330

2261

2331

2332

2262

void

2333

void

2263

MacLow::SendBlockAckResponse (const CtrlBAckResponseHeader* blockAck, Mac48Address originator, bool immediate,

2334

MacLow::SendBlockAckResponse (const CtrlBAckResponseHeader* blockAck, Mac48Address originator, bool immediate,

2264

                              Time duration, WifiMode blockAckReqTxMode, double rxSnr)

2335

                              Time duration, WifiMode blockAckReqTxMode, double rxSnr)

Lines 2282-2299 MacLow::SendBlockAckResponse (const CtrlBAckResponseHeader* blockAck, Mac48Addre	Link Here

2282

2353

2283

      m_txParams.DisableAck ();

2354

      m_txParams.DisableAck ();

2284

      duration -= GetSifs ();

2355

      duration -= GetSifs ();

2285

      if (blockAck->IsBasic ())

2356

      duration -= GetBlockAckDuration (blockAckReqTxVector, blockAck->GetType ());

2286

2287

          duration -= GetBlockAckDuration (blockAckReqTxVector, BASIC_BLOCK_ACK);

2288

2289

      else if (blockAck->IsCompressed ())

2290

2291

          duration -= GetBlockAckDuration (blockAckReqTxVector, COMPRESSED_BLOCK_ACK);

2292

2293

      else if (blockAck->IsMultiTid ())

2294

2295

          NS_FATAL_ERROR ("Multi-tid block ack is not supported.");

2296

2297

2357

2298

  else

2358

  else

2299

2359

Lines 2338-2348 MacLow::SendBlockAckAfterAmpdu (uint8_t tid, Mac48Address originator, Time durat	Link Here

2338

      blockAck.SetStartingSequence (seqNumber);

2398

      blockAck.SetStartingSequence (seqNumber);

2339

      blockAck.SetTidInfo (tid);

2399

      blockAck.SetTidInfo (tid);

2340

      immediate = (*it).second.first.IsImmediateBlockAck ();

2400

      immediate = (*it).second.first.IsImmediateBlockAck ();

2341

      blockAck.SetType (COMPRESSED_BLOCK_ACK);

2401

      if ((*it).second.first.GetBufferSize () > 64)

2402

2403

          blockAck.SetType (EXTENDED_COMPRESSED_BLOCK_ACK);

2404

2405

      else

2406

2407

          blockAck.SetType (COMPRESSED_BLOCK_ACK);

2408

2342

      NS_LOG_DEBUG ("Got Implicit block Ack Req with seq " << seqNumber);

2409

      NS_LOG_DEBUG ("Got Implicit block Ack Req with seq " << seqNumber);

2343

      (*i).second.FillBlockAckBitmap (&blockAck);

2410

      (*i).second.FillBlockAckBitmap (&blockAck);

2344

2411

2345

      SendBlockAckResponse (&blockAck, originator, immediate, duration, blockAckReqTxVector.GetMode (), rxSnr);

2412

      WifiTxVector blockAckTxVector = GetBlockAckTxVector (originator, blockAckReqTxVector.GetMode ());

2413

2414

      SendBlockAckResponse (&blockAck, originator, immediate, duration, blockAckTxVector.GetMode (), rxSnr);

2346

2415

2347

  else

2416

  else

2348

2417

Lines 2375-2380 MacLow::SendBlockAckAfterBlockAckRequest (const CtrlBAckRequestHeader reqHdr, Ma	Link Here

2375

2444

2376

              blockAck.SetType (COMPRESSED_BLOCK_ACK);

2445

              blockAck.SetType (COMPRESSED_BLOCK_ACK);

2377

2446

2447

          else if (reqHdr.IsExtendedCompressed ())

2448

2449

              blockAck.SetType (EXTENDED_COMPRESSED_BLOCK_ACK);

2450

2378

          BlockAckCachesI i = m_bAckCaches.find (std::make_pair (originator, tid));

2451

          BlockAckCachesI i = m_bAckCaches.find (std::make_pair (originator, tid));

2379

          NS_ASSERT (i != m_bAckCaches.end ());

2452

          NS_ASSERT (i != m_bAckCaches.end ());

2380

          (*i).second.FillBlockAckBitmap (&blockAck);

2453

          (*i).second.FillBlockAckBitmap (&blockAck);

Lines 2470-2477 MacLow::DeaggregateAmpduAndReceive (Ptr<Packet> aggregatedPacket, double rxSnr,	Link Here

2470

                                                    firsthdr.GetQosTid (),

2543

                                                    firsthdr.GetQosTid (),

2471

                                                    firsthdr.GetAddr2 (),

2544

                                                    firsthdr.GetAddr2 (),

2472

                                                    firsthdr.GetDuration (),

2545

                                                    firsthdr.GetDuration (),

2473

                                                    txVector,

2546

                                                    txVector, rxSnr);

2474

                                                    rxSnr);

2475

2547

2476

2548

2477

          if (firsthdr.IsAck () || firsthdr.IsBlockAck () || firsthdr.IsBlockAckReq ())

2549

          if (firsthdr.IsAck () || firsthdr.IsBlockAck () || firsthdr.IsBlockAckReq ())

Lines 2551-2557 MacLow::StopMpduAggregation (Ptr<const Packet> peekedPacket, WifiMacHeader peeke	Link Here

2551

      return true;

2623

      return true;

2552

2624

2553

2625

2554

  if (!edcaIt->second->GetMpduAggregator ()->CanBeAggregated (peekedPacket->GetSize () + peekedHdr.GetSize () + WIFI_MAC_FCS_LENGTH, aggregatedPacket, blockAckSize))

2626

  if (!edcaIt->second->GetMpduAggregator ()->CanBeAggregated (peekedPacket->GetSize () + peekedHdr.GetSize () + WIFI_MAC_FCS_LENGTH, aggregatedPacket, blockAckSize, GetMaxAmpduSize (ac)))

2555

2627

2556

      NS_LOG_DEBUG ("no more packets can be aggregated because the maximum A-MPDU size has been reached");

2628

      NS_LOG_DEBUG ("no more packets can be aggregated because the maximum A-MPDU size has been reached");

2557

      return true;

2629

      return true;

Lines 2594-2600 MacLow::AggregateToAmpdu (Ptr<const Packet> packet, const WifiMacHeader hdr)	Link Here

2594

2666

2595

      if (!hdr.GetAddr1 ().IsBroadcast () && edcaIt->second->GetMpduAggregator () != 0)

2667

      if (!hdr.GetAddr1 ().IsBroadcast () && edcaIt->second->GetMpduAggregator () != 0)

2596

2668

2597

          //Have to make sure that their exist a block Ack agreement before sending an AMPDU (BlockAck Manager)

2669

          //Have to make sure that their exist a block Ack agreement before sending an A-MPDU

2598

          if (edcaIt->second->GetBaAgreementExists (hdr.GetAddr1 (), tid))

2670

          if (edcaIt->second->GetBaAgreementExists (hdr.GetAddr1 (), tid))

2599

2671

2600

              /* here is performed mpdu aggregation */

2672

              /* here is performed mpdu aggregation */

Lines 2606-2612 MacLow::AggregateToAmpdu (Ptr<const Packet> packet, const WifiMacHeader hdr)	Link Here

2606

              uint8_t qosPolicy = 0;

2678

              uint8_t qosPolicy = 0;

2607

              uint8_t blockAckSize = 0;

2679

              uint8_t blockAckSize = 0;

2608

              bool aggregated = false;

2680

              bool aggregated = false;

2609

              uint8_t i = 0;

2681

              uint16_t i = 0;

2610

              aggPacket = newPacket->Copy ();

2682

              aggPacket = newPacket->Copy ();

2611

2683

2612

              if (!hdr.IsBlockAckReq ())

2684

              if (!hdr.IsBlockAckReq ())

Lines 2620-2626 MacLow::AggregateToAmpdu (Ptr<const Packet> packet, const WifiMacHeader hdr)	Link Here

2620

                  newPacket->AddHeader (peekedHdr);

2692

                  newPacket->AddHeader (peekedHdr);

2621

                  AddWifiMacTrailer (newPacket);

2693

                  AddWifiMacTrailer (newPacket);

2622

2694

2623

                  aggregated = edcaIt->second->GetMpduAggregator ()->Aggregate (newPacket, currentAggregatedPacket);

2695

                  aggregated = edcaIt->second->GetMpduAggregator ()->Aggregate (newPacket, currentAggregatedPacket, GetMaxAmpduSize (ac));

2624

2696

2625

                  if (aggregated)

2697

                  if (aggregated)

2626

2698

Lines 2668-2674 MacLow::AggregateToAmpdu (Ptr<const Packet> packet, const WifiMacHeader hdr)	Link Here

2668

                  currentSequenceNumber = peekedHdr.GetSequenceNumber ();

2740

                  currentSequenceNumber = peekedHdr.GetSequenceNumber ();

2669

2741

2670

2742

2671

              while (IsInWindow (currentSequenceNumber, startingSequenceNumber, 64) && !StopMpduAggregation (peekedPacket, peekedHdr, currentAggregatedPacket, blockAckSize))

2743

              uint16_t maxMpdus = edcaIt->second->GetBaBufferSize (hdr.GetAddr1 (), tid);

2744

              while (IsInWindow (currentSequenceNumber, startingSequenceNumber, maxMpdus) && !StopMpduAggregation (peekedPacket, peekedHdr, currentAggregatedPacket, blockAckSize))

2672

2745

2673

                  //for now always send AMPDU with normal ACK

2746

                  //for now always send AMPDU with normal ACK

2674

                  if (retry == false)

2747

                  if (retry == false)

Lines 2693-2699 MacLow::AggregateToAmpdu (Ptr<const Packet> packet, const WifiMacHeader hdr)	Link Here

2693

2766

2694

                  newPacket->AddHeader (peekedHdr);

2767

                  newPacket->AddHeader (peekedHdr);

2695

                  AddWifiMacTrailer (newPacket);

2768

                  AddWifiMacTrailer (newPacket);

2696

                  aggregated = edcaIt->second->GetMpduAggregator ()->Aggregate (newPacket, currentAggregatedPacket);

2769

                  aggregated = edcaIt->second->GetMpduAggregator ()->Aggregate (newPacket, currentAggregatedPacket, GetMaxAmpduSize (ac));

2697

                  if (aggregated)

2770

                  if (aggregated)

2698

2771

2699

                      m_aggregateQueue[tid]->Enqueue (Create<WifiMacQueueItem> (aggPacket, peekedHdr));

2772

                      m_aggregateQueue[tid]->Enqueue (Create<WifiMacQueueItem> (aggPacket, peekedHdr));

Lines 2747-2753 MacLow::AggregateToAmpdu (Ptr<const Packet> packet, const WifiMacHeader hdr)	Link Here

2747

                              peekedPacket = item->GetPacket ();

2820

                              peekedPacket = item->GetPacket ();

2748

                              peekedHdr = item->GetHeader ();

2821

                              peekedHdr = item->GetHeader ();

2749

                              tstamp = item->GetTimeStamp ();

2822

                              tstamp = item->GetTimeStamp ();

2750

                              //find what will the sequence number be so that we don't send more than 64 packets apart

2751

                              currentSequenceNumber = edcaIt->second->PeekNextSequenceNumberFor (&peekedHdr);

2823

                              currentSequenceNumber = edcaIt->second->PeekNextSequenceNumberFor (&peekedHdr);

2752

2824

2753

                              if (edcaIt->second->GetMsduAggregator () != 0)

2825

                              if (edcaIt->second->GetMsduAggregator () != 0)

Lines 2774-2783 MacLow::AggregateToAmpdu (Ptr<const Packet> packet, const WifiMacHeader hdr)	Link Here

2774

                          peekedPacket = item->GetPacket ();

2846

                          peekedPacket = item->GetPacket ();

2775

                          peekedHdr = item->GetHeader ();

2847

                          peekedHdr = item->GetHeader ();

2776

                          tstamp = item->GetTimeStamp ();

2848

                          tstamp = item->GetTimeStamp ();

2777

                          //find what will the sequence number be so that we don't send more than 64 packets apart

2778

                          currentSequenceNumber = edcaIt->second->PeekNextSequenceNumberFor (&peekedHdr);

2849

                          currentSequenceNumber = edcaIt->second->PeekNextSequenceNumberFor (&peekedHdr);

2779

2850

2780

                          if (edcaIt->second->GetMsduAggregator () != 0 && IsInWindow (currentSequenceNumber, startingSequenceNumber, 64))

2851

                          if (edcaIt->second->GetMsduAggregator () != 0 && IsInWindow (currentSequenceNumber, startingSequenceNumber, maxMpdus))

2781

2852

2782

                              tempPacket = PerformMsduAggregation (peekedPacket, &peekedHdr, &tstamp, currentAggregatedPacket, blockAckSize);

2853

                              tempPacket = PerformMsduAggregation (peekedPacket, &peekedHdr, &tstamp, currentAggregatedPacket, blockAckSize);

2783

                              if (tempPacket != 0) //MSDU aggregation

2854

                              if (tempPacket != 0) //MSDU aggregation

Lines 2803-2809 MacLow::AggregateToAmpdu (Ptr<const Packet> packet, const WifiMacHeader hdr)	Link Here

2803

                      m_aggregateQueue[tid]->Enqueue (Create<WifiMacQueueItem> (aggPacket, peekedHdr));

2874

                      m_aggregateQueue[tid]->Enqueue (Create<WifiMacQueueItem> (aggPacket, peekedHdr));

2804

                      newPacket->AddHeader (peekedHdr);

2875

                      newPacket->AddHeader (peekedHdr);

2805

                      AddWifiMacTrailer (newPacket);

2876

                      AddWifiMacTrailer (newPacket);

2806

                      edcaIt->second->GetMpduAggregator ()->Aggregate (newPacket, currentAggregatedPacket);

2877

                      edcaIt->second->GetMpduAggregator ()->Aggregate (newPacket, currentAggregatedPacket, GetMaxAmpduSize (ac));

2807

                      currentAggregatedPacket->AddHeader (blockAckReq);

2878

                      currentAggregatedPacket->AddHeader (blockAckReq);

2808

2879

2809

2880

Lines 2818-2824 MacLow::AggregateToAmpdu (Ptr<const Packet> packet, const WifiMacHeader hdr)	Link Here

2818

                  newPacket = currentAggregatedPacket;

2889

                  newPacket = currentAggregatedPacket;

2819

                  newPacket->AddPacketTag (ampdutag);

2890

                  newPacket->AddPacketTag (ampdutag);

2820

2891

2821

                  NS_LOG_DEBUG ("tx unicast A-MPDU");

2892

                  NS_LOG_DEBUG ("tx unicast A-MPDU containing " << +i << " MPDUs");

2822

                  edcaIt->second->SetAmpduExist (hdr.GetAddr1 (), true);

2893

                  edcaIt->second->SetAmpduExist (hdr.GetAddr1 (), true);

2823

2894

2824

              else

2895

              else

Lines 2914-2920 MacLow::PerformMsduAggregation (Ptr<const Packet> packet, WifiMacHeader *hdr, Ti	Link Here

2914

2985

2915

  edcaIt->second->GetMsduAggregator ()->Aggregate (packet, currentAmsduPacket,

2986

  edcaIt->second->GetMsduAggregator ()->Aggregate (packet, currentAmsduPacket,

2916

                                                   edcaIt->second->MapSrcAddressForAggregation (*hdr),

2987

                                                   edcaIt->second->MapSrcAddressForAggregation (*hdr),

2917

                                                   edcaIt->second->MapDestAddressForAggregation (*hdr));

2988

                                                   edcaIt->second->MapDestAddressForAggregation (*hdr),

2989

                                                   GetMaxAmsduSize (ac));

2918

2990

2919

  peekedItem = queue->PeekByTidAndAddress (hdr->GetQosTid (), hdr->GetAddr1 ());

2991

  peekedItem = queue->PeekByTidAndAddress (hdr->GetQosTid (), hdr->GetAddr1 ());

2920

  while (peekedItem != 0)

2992

  while (peekedItem != 0)

Lines 2925-2931 MacLow::PerformMsduAggregation (Ptr<const Packet> packet, WifiMacHeader *hdr, Ti	Link Here

2925

2997

2926

      msduAggregation = edcaIt->second->GetMsduAggregator ()->Aggregate (peekedItem->GetPacket (), tempPacket,

2998

      msduAggregation = edcaIt->second->GetMsduAggregator ()->Aggregate (peekedItem->GetPacket (), tempPacket,

2927

                                                                         edcaIt->second->MapSrcAddressForAggregation (*hdr),

2999

                                                                         edcaIt->second->MapSrcAddressForAggregation (*hdr),

2928

                                                                         edcaIt->second->MapDestAddressForAggregation (*hdr));

3000

                                                                         edcaIt->second->MapDestAddressForAggregation (*hdr),

3001

                                                                         GetMaxAmsduSize (ac));

2929

3002

2930

      if (msduAggregation && !StopMpduAggregation (tempPacket, *hdr, currentAmpduPacket, blockAckSize))

3003

      if (msduAggregation && !StopMpduAggregation (tempPacket, *hdr, currentAmpduPacket, blockAckSize))

2931

3004

Lines 2986-2989 MacLow::CanTransmitNextCfFrame (void) const	Link Here

2986

  return ((GetRemainingCfpDuration () - nextTransmission).IsPositive ());

3059

  return ((GetRemainingCfpDuration () - nextTransmission).IsPositive ());

2987

3060

2988

3061

3062

uint16_t

3063

MacLow::GetMaxAmsduSize (AcIndex ac) const

3064

3065

  UintegerValue size;

3066

  WifiModulationClass modulation = GetDataTxVector (m_currentPacket, &m_currentHdr).GetMode ().GetModulationClass ();

3067

  if (modulation == WIFI_MOD_CLASS_HT)

3068

3069

      Ptr<HtConfiguration> htConfiguration = m_mac->GetHtConfiguration ();

3070

      NS_ASSERT (htConfiguration); //If modulation to transmit A-MSDU is HT, we should have a HT configuration attached

3071

      switch (ac)

3072

3073

          case AC_BE:

3074

            htConfiguration->GetAttribute ("BeMaxAmsduSize", size);

3075

            break;

3076

          case AC_BK:

3077

            htConfiguration->GetAttribute ("BkMaxAmsduSize", size);

3078

            break;

3079

          case AC_VI:

3080

            htConfiguration->GetAttribute ("ViMaxAmsduSize", size);

3081

            break;

3082

          case AC_VO:

3083

            htConfiguration->GetAttribute ("VoMaxAmsduSize", size);

3084

            break;

3085

          default:

3086

            NS_ASSERT (false);

3087

            return 0;

3088

3089

3090

  else if (modulation == WIFI_MOD_CLASS_VHT)

3091

3092

      Ptr<VhtConfiguration> vhtConfiguration = m_mac->GetVhtConfiguration ();

3093

      NS_ASSERT (vhtConfiguration); //If modulation to transmit A-MSDU is VHT, we should have a VHT configuration attached

3094

      switch (ac)

3095

3096

          case AC_BE:

3097

            vhtConfiguration->GetAttribute ("BeMaxAmsduSize", size);

3098

            break;

3099

          case AC_BK:

3100

            vhtConfiguration->GetAttribute ("BkMaxAmsduSize", size);

3101

            break;

3102

          case AC_VI:

3103

            vhtConfiguration->GetAttribute ("ViMaxAmsduSize", size);

3104

            break;

3105

          case AC_VO:

3106

            vhtConfiguration->GetAttribute ("VoMaxAmsduSize", size);

3107

            break;

3108

          default:

3109

            NS_ASSERT (false);

3110

            return 0;

3111

3112

3113

  else if (modulation == WIFI_MOD_CLASS_HE)

3114

3115

      Ptr<HeConfiguration> heConfiguration = m_mac->GetHeConfiguration ();

3116

      NS_ASSERT (heConfiguration); //If modulation to transmit A-MSDU is HE, we should have a HE configuration attached

3117

      switch (ac)

3118

3119

          case AC_BE:

3120

            heConfiguration->GetAttribute ("BeMaxAmsduSize", size);

3121

            break;

3122

          case AC_BK:

3123

            heConfiguration->GetAttribute ("BkMaxAmsduSize", size);

3124

            break;

3125

          case AC_VI:

3126

            heConfiguration->GetAttribute ("ViMaxAmsduSize", size);

3127

            break;

3128

          case AC_VO:

3129

            heConfiguration->GetAttribute ("VoMaxAmsduSize", size);

3130

            break;

3131

          default:

3132

            NS_ASSERT (false);

3133

            return 0;

3134

3135

3136

  return size.Get ();

3137

3138

3139

uint32_t

3140

MacLow::GetMaxAmpduSize (AcIndex ac) const

3141

3142

  UintegerValue size;

3143

  WifiModulationClass modulation = GetDataTxVector (m_currentPacket, &m_currentHdr).GetMode ().GetModulationClass ();

3144

  if (modulation == WIFI_MOD_CLASS_HT)

3145

3146

      Ptr<HtConfiguration> htConfiguration = m_mac->GetHtConfiguration ();

3147

      NS_ASSERT (htConfiguration); //If modulation to transmit A-MPDU is HT, we should have a HT configuration attached

3148

      switch (ac)

3149

3150

          case AC_BE:

3151

            htConfiguration->GetAttribute ("BeMaxAmpduSize", size);

3152

            break;

3153

          case AC_BK:

3154

            htConfiguration->GetAttribute ("BkMaxAmpduSize", size);

3155

            break;

3156

          case AC_VI:

3157

            htConfiguration->GetAttribute ("ViMaxAmpduSize", size);

3158

            break;

3159

          case AC_VO:

3160

            htConfiguration->GetAttribute ("VoMaxAmpduSize", size);

3161

            break;

3162

          default:

3163

            NS_ASSERT (false);

3164

            return 0;

3165

3166

3167

  else if (modulation == WIFI_MOD_CLASS_VHT)

3168

3169

      Ptr<VhtConfiguration> vhtConfiguration = m_mac->GetVhtConfiguration ();

3170

      NS_ASSERT (vhtConfiguration); //If modulation to transmit A-MPDU is VHT, we should have a VHT configuration attached

3171

      switch (ac)

3172

3173

          case AC_BE:

3174

            vhtConfiguration->GetAttribute ("BeMaxAmpduSize", size);

3175

            break;

3176

          case AC_BK:

3177

            vhtConfiguration->GetAttribute ("BkMaxAmpduSize", size);

3178

            break;

3179

          case AC_VI:

3180

            vhtConfiguration->GetAttribute ("ViMaxAmpduSize", size);

3181

            break;

3182

          case AC_VO:

3183

            vhtConfiguration->GetAttribute ("VoMaxAmpduSize", size);

3184

            break;

3185

          default:

3186

            NS_ASSERT (false);

3187

            return 0;

3188

3189

3190

  else if (modulation == WIFI_MOD_CLASS_HE)

3191

3192

      Ptr<HeConfiguration> heConfiguration = m_mac->GetHeConfiguration ();

3193

      NS_ASSERT (heConfiguration); //If modulation to transmit A-MPDU is HE, we should have a HE configuration attached

3194

      switch (ac)

3195

3196

          case AC_BE:

3197

            heConfiguration->GetAttribute ("BeMaxAmpduSize", size);

3198

            break;

3199

          case AC_BK:

3200

            heConfiguration->GetAttribute ("BkMaxAmpduSize", size);

3201

            break;

3202

          case AC_VI:

3203

            heConfiguration->GetAttribute ("ViMaxAmpduSize", size);

3204

            break;

3205

          case AC_VO:

3206

            heConfiguration->GetAttribute ("VoMaxAmpduSize", size);

3207

            break;

3208

          default:

3209

            NS_ASSERT (false);

3210

            return 0;

3211

3212

3213

  return size.Get ();

3214

3215

2989

} //namespace ns3

3216

} //namespace ns3

(-)a/src/wifi/model/mac-low.h (-14 / +28 lines)

Lines 37-45	Link Here

class TwoLevelAggregationTest;

class TwoLevelAggregationTest;

class AmpduAggregationTest;

class AmpduAggregationTest;

class HeAggregationTest;

namespace ns3 {

namespace ns3 {

class WifiMac;

class WifiPhy;

class WifiPhy;

class Txop;

class Txop;

class QosTxop;

class QosTxop;

Lines 60-67 class MacLow : public Object	Link Here

public:

public:

  /// Allow test cases to access private members

  /// Allow test cases to access private members

  friend class ::TwoLevelAggregationTest;

  friend class ::TwoLevelAggregationTest;

  /// Allow test cases to access private members

  friend class ::AmpduAggregationTest;

  friend class ::AmpduAggregationTest;

  friend class ::HeAggregationTest;

/**

/**

   * typedef for a callback for MacLowRx

   * typedef for a callback for MacLowRx

*/

*/

Lines 91-96 public:	Link Here

*/

*/

  void ResetPhy (void);

  void ResetPhy (void);

/**

/**

   * Set up WifiMac associated with this MacLow.

   * \param mac WifiMac associated with this MacLow

100

*/

101

  void SetMac (const Ptr<WifiMac> mac);

102

/**

   * Set up WifiRemoteStationManager associated with this MacLow.

103

   * Set up WifiRemoteStationManager associated with this MacLow.

104

   * \param manager WifiRemoteStationManager associated with this MacLow

105

   * \param manager WifiRemoteStationManager associated with this MacLow

Lines 403-419 public:	Link Here

403

*/

412

*/

404

  void DeaggregateAmpduAndReceive (Ptr<Packet> aggregatedPacket, double rxSnr, WifiTxVector txVector);

413

  void DeaggregateAmpduAndReceive (Ptr<Packet> aggregatedPacket, double rxSnr, WifiTxVector txVector);

405

/**

414

/**

406

   * \param peekedPacket the packet to be aggregated

407

   * \param peekedHdr the WifiMacHeader for the packet.

408

   * \param aggregatedPacket the current A-MPDU

409

   * \param blockAckSize the size of a piggybacked block ack request

410

   * \return false if the given packet can be added to an A-MPDU, true otherwise

411

412

   * This function decides if a given packet can be added to an A-MPDU or not

413

414

*/

415

  bool StopMpduAggregation (Ptr<const Packet> peekedPacket, WifiMacHeader peekedHdr, Ptr<Packet> aggregatedPacket, uint8_t blockAckSize) const;

416

/**

417

415

418

   * This function is called to flush the aggregate queue, which is used for A-MPDU

416

   * This function is called to flush the aggregate queue, which is used for A-MPDU

419

   * \param tid the Traffic ID

417

   * \param tid the Traffic ID

Lines 446-451 public:	Link Here

446

   * This function decides if a CF frame can be transmitted in the current CFP.

444

   * This function decides if a CF frame can be transmitted in the current CFP.

447

*/

445

*/

448

  bool CanTransmitNextCfFrame (void) const;

446

  bool CanTransmitNextCfFrame (void) const;

447

  //TODO

448

  uint16_t GetMaxAmsduSize (AcIndex ac) const;

449

  //TODO

450

  uint32_t GetMaxAmpduSize (AcIndex ac) const;

449

451

450

452

451

private:

453

private:

Lines 477-482 private:	Link Here

477

*/

479

*/

478

  void SendMpdu (Ptr<const Packet> packet, WifiTxVector txVector, MpduType mpdutype);

480

  void SendMpdu (Ptr<const Packet> packet, WifiTxVector txVector, MpduType mpdutype);

479

/**

481

/**

482

   * \param peekedPacket the packet to be aggregated

483

   * \param peekedHdr the WifiMacHeader for the packet.

484

   * \param aggregatedPacket the current A-MPDU

485

   * \param blockAckSize the size of a piggybacked block ack request

486

   * \return false if the given packet can be added to an A-MPDU, true otherwise

487

488

   * This function decides if a given packet can be added to an A-MPDU or not

489

490

*/

491

  bool StopMpduAggregation (Ptr<const Packet> peekedPacket, WifiMacHeader peekedHdr, Ptr<Packet> aggregatedPacket, uint8_t blockAckSize) const;

492

/**

480

   * Return a TXVECTOR for the RTS frame given the destination.

493

   * Return a TXVECTOR for the RTS frame given the destination.

481

   * The function consults WifiRemoteStationManager, which controls the rate

494

   * The function consults WifiRemoteStationManager, which controls the rate

482

   * to different destinations.

495

   * to different destinations.

Lines 789-796 private:	Link Here

789

   * \param blockAckReqTxVector the transmit vector

802

   * \param blockAckReqTxVector the transmit vector

790

   * \param rxSnr the receive SNR

803

   * \param rxSnr the receive SNR

791

*/

804

*/

792

  void SendBlockAckAfterAmpdu (uint8_t tid, Mac48Address originator,

805

  void SendBlockAckAfterAmpdu (uint8_t tid, Mac48Address originator, Time duration,

793

                               Time duration, WifiTxVector blockAckReqTxVector, double rxSnr);

806

                               WifiTxVector blockAckReqTxVector, double rxSnr);

794

/**

807

/**

795

   * This method creates block ack frame with header equals to <i>blockAck</i> and start its transmission.

808

   * This method creates block ack frame with header equals to <i>blockAck</i> and start its transmission.

796

809

Lines 857-862 private:	Link Here

857

  Ptr<Packet> PerformMsduAggregation (Ptr<const Packet> packet, WifiMacHeader *hdr, Time *tstamp, Ptr<Packet> currentAmpduPacket, uint8_t blockAckSize);

870

  Ptr<Packet> PerformMsduAggregation (Ptr<const Packet> packet, WifiMacHeader *hdr, Time *tstamp, Ptr<Packet> currentAmpduPacket, uint8_t blockAckSize);

858

871

859

  Ptr<WifiPhy> m_phy; //!< Pointer to WifiPhy (actually send/receives frames)

872

  Ptr<WifiPhy> m_phy; //!< Pointer to WifiPhy (actually send/receives frames)

873

  Ptr<WifiMac> m_mac; //!< Pointer to WifiMac (to fetch configuration)

860

  Ptr<WifiRemoteStationManager> m_stationManager; //!< Pointer to WifiRemoteStationManager (rate control)

874

  Ptr<WifiRemoteStationManager> m_stationManager; //!< Pointer to WifiRemoteStationManager (rate control)

861

  MacLowRxCallback m_rxCallback; //!< Callback to pass packet up

875

  MacLowRxCallback m_rxCallback; //!< Callback to pass packet up

862

876




{
}

void
MpduAggregator::SetMaxAmpduSize (uint16_t maxSize)
{
  m_maxAmpduLength = maxSize;
}

uint16_t
MpduAggregator::GetMaxAmpduSize (void) const
{
  return m_maxAmpduLength;
}

bool
MpduAggregator::Aggregate (Ptr<const Packet> packet, Ptr<Packet> aggregatedPacket, uint32_t maxAmpduSize) const
{
  NS_LOG_FUNCTION (this);
  Ptr<Packet> currentPacket;

  uint8_t padding = CalculatePadding (aggregatedPacket);
  uint32_t actualSize = aggregatedPacket->GetSize ();

  if ((4 + packet->GetSize () + actualSize + padding) <= maxAmpduSize)
    {
      if (padding)
        {

}

bool
MpduAggregator::CanBeAggregated (uint32_t packetSize, Ptr<Packet> aggregatedPacket, uint8_t blockAckSize, uint32_t maxAmpduSize) const
{
  uint8_t padding = CalculatePadding (aggregatedPacket);
  uint32_t actualSize = aggregatedPacket->GetSize ();

    {
      blockAckSize = blockAckSize + 4 + padding;
    }
  if ((4 + packetSize + actualSize + padding + blockAckSize) <= maxAmpduSize)
    {
      return true;
    }




  virtual ~MpduAggregator ();

  /**
   * Sets the maximum A-MPDU size in bytes.
   * Value 0 means that MPDU aggregation is disabled.
   *
   * \param maxSize the maximum A-MPDU size in bytes.
   */
  void SetMaxAmpduSize (uint16_t maxSize);
  /**
   * Returns the maximum A-MPDU size in bytes.
   * Value 0 means that MPDU aggregation is disabled.
   *
   * \return the maximum A-MPDU size in bytes.
   */
  uint16_t GetMaxAmpduSize (void) const;

  /**
   * \param packet Packet we have to insert into <i>aggregatedPacket</i>.
   * \param aggregatedPacket Packet that will contain <i>packet</i>, if aggregation is possible.
   * \param maxAmpduSize the maximum A-MPDU size.
   *
   * \return true if <i>packet</i> can be aggregated to <i>aggregatedPacket</i>, false otherwise.
   *
   * Adds <i>packet</i> to <i>aggregatedPacket</i>. In concrete aggregator's implementation is
   * specified how and if <i>packet</i> can be added to <i>aggregatedPacket</i>.
   */
  bool Aggregate (Ptr<const Packet> packet, Ptr<Packet> aggregatedPacket, uint32_t maxAmpduSize) const;
  /**
   * \param packet the packet we want to insert into <i>aggregatedPacket</i>.
   * \param aggregatedPacket packet that will contain the packet of size <i>packetSize</i>, if aggregation is possible.

   * \param packetSize size of the packet we want to insert into <i>aggregatedPacket</i>.
   * \param aggregatedPacket packet that will contain the packet of size <i>packetSize</i>, if aggregation is possible.
   * \param blockAckSize size of the piggybacked block ack request
   * \param maxAmpduSize the maximum A-MPDU size.
   *
   * \return true if the packet of size <i>packetSize</i> can be aggregated to <i>aggregatedPacket</i>, false otherwise.
   *
   * This method is used to determine if a packet could be aggregated to an A-MPDU without exceeding the maximum packet size.
   */
  bool CanBeAggregated (uint32_t packetSize, Ptr<Packet> aggregatedPacket, uint8_t blockAckSize, uint32_t maxAmpduSize) const;

  /**
   * Deaggregates an A-MPDU by removing the A-MPDU subframe header and padding.

   * Each A-MPDU subframe is padded so that its length is multiple of 4 octets.
   */
  uint8_t CalculatePadding (Ptr<const Packet> packet) const;

  uint16_t m_maxAmpduLength; //!< Maximum length in bytes of A-MPDUs
};

}  //namespace ns3




{
}

void
MsduAggregator::SetMaxAmsduSize (uint16_t maxSize)
{
  m_maxAmsduLength = maxSize;
}

uint16_t
MsduAggregator::GetMaxAmsduSize (void) const
{
  return m_maxAmsduLength;
}

bool
MsduAggregator::Aggregate (Ptr<const Packet> packet, Ptr<Packet> aggregatedPacket,
                           Mac48Address src, Mac48Address dest, uint16_t maxAmsduSize) const
{
  NS_LOG_FUNCTION (this);
  Ptr<Packet> currentPacket;

  uint8_t padding = CalculatePadding (aggregatedPacket);
  uint32_t actualSize = aggregatedPacket->GetSize ();

  if ((14 + packet->GetSize () + actualSize + padding) <= maxAmsduSize)
    {
      if (padding)
        {




  virtual ~MsduAggregator ();

  /**
   * Sets the maximum A-MSDU size in bytes.
   * Value 0 means that MSDU aggregation is disabled.
   *
   * \param maxSize the maximum A-MSDU size in bytes.
   */
  void SetMaxAmsduSize (uint16_t maxSize);
  /**
   * Returns the maximum A-MSDU size in bytes.
   * Value 0 means that MSDU aggregation is disabled.
   *
   * \return the maximum A-MSDU size in bytes.
   */
  uint16_t GetMaxAmsduSize (void) const;

  /**
   * Adds <i>packet</i> to <i>aggregatedPacket</i>. In concrete aggregator's implementation is
   * specified how and if <i>packet</i> can be added to <i>aggregatedPacket</i>. If <i>packet</i>
   * can be added returns true, false otherwise.

   * \param aggregatedPacket the aggregated packet.
   * \param src the source address.
   * \param dest the destination address
   * \param maxAmsduSize the maximum A-MSDU size.
   * \return true if successful.
   */
  bool Aggregate (Ptr<const Packet> packet, Ptr<Packet> aggregatedPacket,
                  Mac48Address src, Mac48Address dest, uint16_t maxAmsduSize) const;

  /**
   *

   * \return the number of octets required for padding
   */
  uint8_t CalculatePadding (Ptr<const Packet> packet) const;

  uint16_t m_maxAmsduLength; ///< maximum AMSDU length
};

} //namespace ns3

(-)a/src/wifi/model/originator-block-ack-agreement.cc (-2 / +1 lines)

Lines 76-83 OriginatorBlockAckAgreement::NotifyMpduTransmission (uint16_t nextSeqNumber)	Link Here

  NS_ASSERT (m_sentMpdus < m_bufferSize);

  NS_ASSERT (m_sentMpdus < m_bufferSize);

  m_sentMpdus++;

  m_sentMpdus++;

  uint16_t delta = (nextSeqNumber - m_startingSeq + 4096) % 4096;

  uint16_t delta = (nextSeqNumber - m_startingSeq + 4096) % 4096;

  uint16_t min = m_bufferSize < 64 ? m_bufferSize : 64;

  if (delta >= m_bufferSize || m_sentMpdus == m_bufferSize)

  if (delta >= min || m_sentMpdus == m_bufferSize)

      m_needBlockAckReq = true;

      m_needBlockAckReq = true;

(-)a/src/wifi/model/qos-txop.cc (-9 / +24 lines)

Lines 117-122 QosTxop::CompleteAmpduTransfer (Mac48Address recipient, uint8_t tid)	Link Here

117

  m_baManager->CompleteAmpduExchange (recipient, tid);

117

  m_baManager->CompleteAmpduExchange (recipient, tid);

118

119

120

uint16_t

121

QosTxop::GetBaBufferSize (Mac48Address address, uint8_t tid) const

122

123

  return m_baManager->GetRecipientBufferSize (address, tid);

124

125

120

void

126

void

121

QosTxop::SetWifiRemoteStationManager (const Ptr<WifiRemoteStationManager> remoteManager)

127

QosTxop::SetWifiRemoteStationManager (const Ptr<WifiRemoteStationManager> remoteManager)

122

128

Lines 283-289 QosTxop::NotifyAccessGranted (void)	Link Here

283

              Ptr<Packet> currentAggregatedPacket = Create<Packet> ();

289

              Ptr<Packet> currentAggregatedPacket = Create<Packet> ();

284

              m_msduAggregator->Aggregate (m_currentPacket, currentAggregatedPacket,

290

              m_msduAggregator->Aggregate (m_currentPacket, currentAggregatedPacket,

285

                                           MapSrcAddressForAggregation (peekedHdr),

291

                                           MapSrcAddressForAggregation (peekedHdr),

286

                                           MapDestAddressForAggregation (peekedHdr));

292

                                           MapDestAddressForAggregation (peekedHdr),

293

                                           GetLow ()->GetMaxAmsduSize (QosUtilsMapTidToAc (m_currentHdr.GetQosTid ())));

287

              bool aggregated = false;

294

              bool aggregated = false;

288

              bool isAmsdu = false;

295

              bool isAmsdu = false;

289

              Ptr<const WifiMacQueueItem> peekedItem = m_queue->PeekByTidAndAddress (m_currentHdr.GetQosTid (),

296

              Ptr<const WifiMacQueueItem> peekedItem = m_queue->PeekByTidAndAddress (m_currentHdr.GetQosTid (),

Lines 293-299 QosTxop::NotifyAccessGranted (void)	Link Here

293

                  peekedHdr = peekedItem->GetHeader ();

300

                  peekedHdr = peekedItem->GetHeader ();

294

                  aggregated = m_msduAggregator->Aggregate (peekedItem->GetPacket (), currentAggregatedPacket,

301

                  aggregated = m_msduAggregator->Aggregate (peekedItem->GetPacket (), currentAggregatedPacket,

295

                                                            MapSrcAddressForAggregation (peekedHdr),

302

                                                            MapSrcAddressForAggregation (peekedHdr),

296

                                                            MapDestAddressForAggregation (peekedHdr));

303

                                                            MapDestAddressForAggregation (peekedHdr),

304

                                                            GetLow ()->GetMaxAmsduSize (QosUtilsMapTidToAc (m_currentHdr.GetQosTid ())));

297

                  if (aggregated)

305

                  if (aggregated)

298

306

299

                      isAmsdu = true;

307

                      isAmsdu = true;

Lines 446-452 QosTxop::MissedCts (void)	Link Here

446

454

447

              NS_LOG_DEBUG ("Transmit Block Ack Request");

455

              NS_LOG_DEBUG ("Transmit Block Ack Request");

448

              CtrlBAckRequestHeader reqHdr;

456

              CtrlBAckRequestHeader reqHdr;

449

              reqHdr.SetType (COMPRESSED_BLOCK_ACK);

457

              reqHdr.SetType (GetBaBufferSize (m_currentHdr.GetAddr1 (), tid) > 64 ? EXTENDED_COMPRESSED_BLOCK_ACK : COMPRESSED_BLOCK_ACK);

450

              reqHdr.SetStartingSequence (m_txMiddle->PeekNextSequenceNumberFor (&m_currentHdr));

458

              reqHdr.SetStartingSequence (m_txMiddle->PeekNextSequenceNumberFor (&m_currentHdr));

451

              reqHdr.SetTidInfo (tid);

459

              reqHdr.SetTidInfo (tid);

452

              reqHdr.SetHtImmediateAck (true);

460

              reqHdr.SetHtImmediateAck (true);

Lines 576-582 QosTxop::MissedAck (void)	Link Here

576

              //send Block ACK Request in order to shift WinStart at the receiver

584

              //send Block ACK Request in order to shift WinStart at the receiver

577

              NS_LOG_DEBUG ("Transmit Block Ack Request");

585

              NS_LOG_DEBUG ("Transmit Block Ack Request");

578

              CtrlBAckRequestHeader reqHdr;

586

              CtrlBAckRequestHeader reqHdr;

579

              reqHdr.SetType (COMPRESSED_BLOCK_ACK);

587

              reqHdr.SetType (GetBaBufferSize (m_currentHdr.GetAddr1 (), tid) > 64 ? EXTENDED_COMPRESSED_BLOCK_ACK : COMPRESSED_BLOCK_ACK);

580

              reqHdr.SetStartingSequence (m_txMiddle->PeekNextSequenceNumberFor (&m_currentHdr));

588

              reqHdr.SetStartingSequence (m_txMiddle->PeekNextSequenceNumberFor (&m_currentHdr));

581

              reqHdr.SetTidInfo (tid);

589

              reqHdr.SetTidInfo (tid);

582

              reqHdr.SetHtImmediateAck (true);

590

              reqHdr.SetHtImmediateAck (true);

Lines 640-646 QosTxop::MissedBlockAck (uint8_t nMpdus)	Link Here

640

          //standard says when losing a BlockAck originator may send a BAR page 139

648

          //standard says when losing a BlockAck originator may send a BAR page 139

641

          NS_LOG_DEBUG ("Transmit Block Ack Request");

649

          NS_LOG_DEBUG ("Transmit Block Ack Request");

642

          CtrlBAckRequestHeader reqHdr;

650

          CtrlBAckRequestHeader reqHdr;

643

          reqHdr.SetType (COMPRESSED_BLOCK_ACK);

651

          reqHdr.SetType (GetBaBufferSize (m_currentHdr.GetAddr1 (), tid) > 64 ? EXTENDED_COMPRESSED_BLOCK_ACK : COMPRESSED_BLOCK_ACK);

644

          if (m_currentHdr.IsQosData ())

652

          if (m_currentHdr.IsQosData ())

645

653

646

              reqHdr.SetStartingSequence (m_currentHdr.GetSequenceNumber ());

654

              reqHdr.SetStartingSequence (m_currentHdr.GetSequenceNumber ());

Lines 956-962 QosTxop::NeedFragmentation (void) const	Link Here

956

      || (m_stationManager->GetHtSupported ()

964

      || (m_stationManager->GetHtSupported ()

957

          && m_currentHdr.IsQosData ()

965

          && m_currentHdr.IsQosData ()

958

          && GetBaAgreementExists (m_currentHdr.GetAddr1 (), GetTid (m_currentPacket, m_currentHdr))

966

          && GetBaAgreementExists (m_currentHdr.GetAddr1 (), GetTid (m_currentPacket, m_currentHdr))

959

          && GetMpduAggregator ()->GetMaxAmpduSize () >= m_currentPacket->GetSize ()))

967

          && GetLow ()->GetMaxAmpduSize (QosUtilsMapTidToAc (GetTid (m_currentPacket, m_currentHdr))) >= m_currentPacket->GetSize ()))

960

968

961

      //MSDU is not fragmented when it is transmitted using an HT-immediate or

969

      //MSDU is not fragmented when it is transmitted using an HT-immediate or

962

      //HT-delayed Block Ack agreement or when it is carried in an A-MPDU.

970

      //HT-delayed Block Ack agreement or when it is carried in an A-MPDU.

Lines 1289-1295 QosTxop::VerifyBlockAck (void)	Link Here

1289

      m_baManager->SwitchToBlockAckIfNeeded (recipient, tid, sequence);

1297

      m_baManager->SwitchToBlockAckIfNeeded (recipient, tid, sequence);

1290

1298

1291

  if ((m_baManager->ExistsAgreementInState (recipient, tid, OriginatorBlockAckAgreement::ESTABLISHED))

1299

  if ((m_baManager->ExistsAgreementInState (recipient, tid, OriginatorBlockAckAgreement::ESTABLISHED))

1292

      && (GetMpduAggregator () == 0 || GetMpduAggregator ()->GetMaxAmpduSize () == 0))

1300

      && (GetMpduAggregator () == 0 || GetLow ()->GetMaxAmpduSize (QosUtilsMapTidToAc (tid)) == 0))

1293

1301

1294

      m_currentHdr.SetQosAckPolicy (WifiMacHeader::BLOCK_ACK);

1302

      m_currentHdr.SetQosAckPolicy (WifiMacHeader::BLOCK_ACK);

1295

1303

Lines 1346-1352 QosTxop::SetupBlockAckIfNeeded (void)	Link Here

1346

  Mac48Address recipient = m_currentHdr.GetAddr1 ();

1354

  Mac48Address recipient = m_currentHdr.GetAddr1 ();

1347

  uint32_t packets = m_queue->GetNPacketsByTidAndAddress (tid, recipient);

1355

  uint32_t packets = m_queue->GetNPacketsByTidAndAddress (tid, recipient);

1348

  if ((GetBlockAckThreshold () > 0 && packets >= GetBlockAckThreshold ())

1356

  if ((GetBlockAckThreshold () > 0 && packets >= GetBlockAckThreshold ())

1349

      || (m_mpduAggregator != 0 && m_mpduAggregator->GetMaxAmpduSize () > 0 && packets > 1)

1357

      || (m_mpduAggregator != 0 && GetLow ()->GetMaxAmpduSize (QosUtilsMapTidToAc (tid)) > 0 && packets > 1)

1350

      || m_stationManager->GetVhtSupported ()

1358

      || m_stationManager->GetVhtSupported ()

1351

      || m_stationManager->GetHeSupported ())

1359

      || m_stationManager->GetHeSupported ())

1352

1360

Lines 1385-1391 QosTxop::SendBlockAckRequest (const Bar &bar)	Link Here

1385

1393

1386

      else if (m_blockAckType == COMPRESSED_BLOCK_ACK)

1394

      else if (m_blockAckType == COMPRESSED_BLOCK_ACK)

1387

1395

1388

          m_currentParams.EnableCompressedBlockAck ();

1396

          if (GetBaBufferSize (m_currentHdr.GetAddr1 (), GetTid (m_currentPacket, m_currentHdr)) > 64)

1397

1398

              m_currentParams.EnableExtendedCompressedBlockAck ();

1399

1400

          else

1401

1402

              m_currentParams.EnableCompressedBlockAck ();

1403

1389

1404

1390

      else if (m_blockAckType == MULTI_TID_BLOCK_ACK)

1405

      else if (m_blockAckType == MULTI_TID_BLOCK_ACK)

1391

1406




#include "qos-utils.h"

class AmpduAggregationTest;
class HeAggregationTest;

namespace ns3 {


public:
  /// Allow test cases to access private members
  friend class ::AmpduAggregationTest;
  friend class ::HeAggregationTest;

  std::map<Mac48Address, bool> m_aMpduEnabled; //!< list containing flags whether A-MPDU is enabled for a given destination address


   * of an A-MPDU with ImmediateBlockAck policy (i.e. no BAR is scheduled).
   */
  void CompleteAmpduTransfer (Mac48Address recipient, uint8_t tid);
  /**
   * \param address recipient address of the peer station
   * \param tid traffic ID.
   *
   * \return the negociated buffer size during ADDBA handshake.
   *
   * Returns the negociated buffer size during ADDBA handshake with station addressed by
   * <i>recipient</i> for tid <i>tid</i>.
   */
  uint16_t GetBaBufferSize (Mac48Address address, uint8_t tid) const;

  /* dcf notifications forwarded here */
  /**

(-)a/src/wifi/model/regular-wifi-mac.cc (-83 / +136 lines)

Lines 55-60 RegularWifiMac::RegularWifiMac ()	Link Here

  m_low = CreateObject<MacLow> ();

  m_low = CreateObject<MacLow> ();

  m_low->SetRxCallback (MakeCallback (&MacRxMiddle::Receive, m_rxMiddle));

  m_low->SetRxCallback (MakeCallback (&MacRxMiddle::Receive, m_rxMiddle));

  m_low->SetMac (this);

  m_channelAccessManager = CreateObject<ChannelAccessManager> ();

  m_channelAccessManager = CreateObject<ChannelAccessManager> ();

  m_channelAccessManager->SetupLow (m_low);

  m_channelAccessManager->SetupLow (m_low);

Lines 159-166 RegularWifiMac::GetHtCapabilities (void) const	Link Here

159

  HtCapabilities capabilities;

160

  HtCapabilities capabilities;

160

  if (GetHtSupported ())

161

  if (GetHtSupported ())

161

162

      Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());

163

      Ptr<HtConfiguration> htConfiguration = GetHtConfiguration ();

163

      Ptr<HtConfiguration> htConfiguration = device->GetHtConfiguration ();

164

      bool greenfieldSupported = htConfiguration->GetGreenfieldSupported ();

164

      bool greenfieldSupported = htConfiguration->GetGreenfieldSupported ();

165

      bool sgiSupported = htConfiguration->GetShortGuardIntervalSupported ();

165

      bool sgiSupported = htConfiguration->GetShortGuardIntervalSupported ();

166

      capabilities.SetHtSupported (1);

166

      capabilities.SetHtSupported (1);

Lines 172-178 RegularWifiMac::GetHtCapabilities (void) const	Link Here

172

      uint32_t maxAmsduLength = std::max (std::max (m_beMaxAmsduSize, m_bkMaxAmsduSize), std::max (m_voMaxAmsduSize, m_viMaxAmsduSize));

172

      uint32_t maxAmsduLength = std::max (std::max (m_beMaxAmsduSize, m_bkMaxAmsduSize), std::max (m_voMaxAmsduSize, m_viMaxAmsduSize));

173

      capabilities.SetMaxAmsduLength (maxAmsduLength > 3839); //0 if 3839 and 1 if 7935

173

      capabilities.SetMaxAmsduLength (maxAmsduLength > 3839); //0 if 3839 and 1 if 7935

174

      capabilities.SetLSigProtectionSupport (!greenfieldSupported);

174

      capabilities.SetLSigProtectionSupport (!greenfieldSupported);

175

      double maxAmpduLengthExponent = std::max (std::ceil ((std::log (std::max (std::max (m_beMaxAmpduSize, m_bkMaxAmpduSize), std::max (m_voMaxAmpduSize, m_viMaxAmpduSize))

175

      UintegerValue beMaxAmpduSize, bkMaxAmpduSize, voMaxAmpduSize, viMaxAmpduSize;

176

      htConfiguration->GetAttribute ("BeMaxAmpduSize", beMaxAmpduSize);

177

      htConfiguration->GetAttribute ("BkMaxAmpduSize", bkMaxAmpduSize);

178

      htConfiguration->GetAttribute ("ViMaxAmpduSize", voMaxAmpduSize);

179

      htConfiguration->GetAttribute ("VoMaxAmpduSize", viMaxAmpduSize);

180

      double maxAmpduLengthExponent = std::max (std::ceil ((std::log (std::max (std::max (beMaxAmpduSize.Get (), bkMaxAmpduSize.Get ()), std::max (voMaxAmpduSize.Get (), viMaxAmpduSize.Get ()))

176

                                                                      + 1.0)

181

                                                                      + 1.0)

177

                                                            / std::log (2.0))

182

                                                            / std::log (2.0))

178

                                                           - 13.0),

183

                                                           - 13.0),

Lines 214-221 RegularWifiMac::GetVhtCapabilities (void) const	Link Here

214

  VhtCapabilities capabilities;

219

  VhtCapabilities capabilities;

215

  if (GetVhtSupported ())

220

  if (GetVhtSupported ())

216

221

217

      Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());

222

      Ptr<HtConfiguration> htConfiguration = GetHtConfiguration ();

218

      Ptr<HtConfiguration> htConfiguration = device->GetHtConfiguration ();

223

      Ptr<VhtConfiguration> vhtConfiguration = GetVhtConfiguration ();

219

      bool sgiSupported = htConfiguration->GetShortGuardIntervalSupported ();

224

      bool sgiSupported = htConfiguration->GetShortGuardIntervalSupported ();

220

      capabilities.SetVhtSupported (1);

225

      capabilities.SetVhtSupported (1);

221

      if (m_phy->GetChannelWidth () == 160)

226

      if (m_phy->GetChannelWidth () == 160)

Lines 231-237 RegularWifiMac::GetVhtCapabilities (void) const	Link Here

231

      capabilities.SetRxLdpc (0);

236

      capabilities.SetRxLdpc (0);

232

      capabilities.SetShortGuardIntervalFor80Mhz ((m_phy->GetChannelWidth () == 80) && sgiSupported);

237

      capabilities.SetShortGuardIntervalFor80Mhz ((m_phy->GetChannelWidth () == 80) && sgiSupported);

233

      capabilities.SetShortGuardIntervalFor160Mhz ((m_phy->GetChannelWidth () == 160) && sgiSupported);

238

      capabilities.SetShortGuardIntervalFor160Mhz ((m_phy->GetChannelWidth () == 160) && sgiSupported);

234

      double maxAmpduLengthExponent = std::max (std::ceil ((std::log (std::max (std::max (m_beMaxAmpduSize, m_bkMaxAmpduSize), std::max (m_voMaxAmpduSize, m_viMaxAmpduSize)) + 1.0) / std::log (2.0)) - 13.0), 0.0);

239

      UintegerValue beMaxAmpduSize, bkMaxAmpduSize, voMaxAmpduSize, viMaxAmpduSize;

240

      vhtConfiguration->GetAttribute ("BeMaxAmpduSize", beMaxAmpduSize);

241

      vhtConfiguration->GetAttribute ("BkMaxAmpduSize", bkMaxAmpduSize);

242

      vhtConfiguration->GetAttribute ("ViMaxAmpduSize", voMaxAmpduSize);

243

      vhtConfiguration->GetAttribute ("VoMaxAmpduSize", viMaxAmpduSize);

244

      double maxAmpduLengthExponent = std::max (std::ceil ((std::log (std::max (std::max (beMaxAmpduSize.Get (), bkMaxAmpduSize.Get ()), std::max (voMaxAmpduSize.Get (), viMaxAmpduSize.Get ())) + 1.0) / std::log (2.0)) - 13.0), 0.0);

235

      NS_ASSERT (maxAmpduLengthExponent >= 0 && maxAmpduLengthExponent <= 255);

245

      NS_ASSERT (maxAmpduLengthExponent >= 0 && maxAmpduLengthExponent <= 255);

236

      capabilities.SetMaxAmpduLengthExponent (std::max<uint8_t> (7, static_cast<uint8_t> (maxAmpduLengthExponent))); //0 to 7 for VHT

246

      capabilities.SetMaxAmpduLengthExponent (std::max<uint8_t> (7, static_cast<uint8_t> (maxAmpduLengthExponent))); //0 to 7 for VHT

237

      uint8_t maxMcs = 0;

247

      uint8_t maxMcs = 0;

Lines 283-290 RegularWifiMac::GetHeCapabilities (void) const	Link Here

283

  HeCapabilities capabilities;

293

  HeCapabilities capabilities;

284

  if (GetHeSupported ())

294

  if (GetHeSupported ())

285

295

286

      Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());

296

      Ptr<HeConfiguration> heConfiguration = GetHeConfiguration ();

287

      Ptr<HeConfiguration> heConfiguration = device->GetHeConfiguration ();

288

      capabilities.SetHeSupported (1);

297

      capabilities.SetHeSupported (1);

289

      uint8_t channelWidthSet = 0;

298

      uint8_t channelWidthSet = 0;

290

      if (m_phy->GetChannelWidth () >= 40 && Is2_4Ghz (m_phy->GetFrequency ()))

299

      if (m_phy->GetChannelWidth () >= 40 && Is2_4Ghz (m_phy->GetFrequency ()))

Lines 311-320 RegularWifiMac::GetHeCapabilities (void) const	Link Here

311

          gi |= 0x02;

320

          gi |= 0x02;

312

321

313

      capabilities.SetHeLtfAndGiForHePpdus (gi);

322

      capabilities.SetHeLtfAndGiForHePpdus (gi);

314

      double maxAmpduLengthExponent = std::max (std::ceil ((std::log (std::max (std::max (m_beMaxAmpduSize, m_bkMaxAmpduSize), std::max (m_voMaxAmpduSize, m_viMaxAmpduSize))

323

      UintegerValue beMaxAmpduSize, bkMaxAmpduSize, voMaxAmpduSize, viMaxAmpduSize;

324

      heConfiguration->GetAttribute ("BeMaxAmpduSize", beMaxAmpduSize);

325

      heConfiguration->GetAttribute ("BkMaxAmpduSize", bkMaxAmpduSize);

326

      heConfiguration->GetAttribute ("ViMaxAmpduSize", voMaxAmpduSize);

327

      heConfiguration->GetAttribute ("VoMaxAmpduSize", viMaxAmpduSize);

328

      double maxAmpduLengthExponent = std::max (std::ceil ((std::log (std::max (std::max (beMaxAmpduSize.Get (), bkMaxAmpduSize.Get ()), std::max (voMaxAmpduSize.Get (), viMaxAmpduSize.Get ()))

315

                                                                      + 1.0)

329

                                                                      + 1.0)

316

                                                            / std::log (2.0))

330

                                                            / std::log (2.0))

317

                                                           - 13.0),

331

                                                           - 20.0),

318

                                                0.0);

332

                                                0.0);

319

      NS_ASSERT (maxAmpduLengthExponent >= 0 && maxAmpduLengthExponent <= 255);

333

      NS_ASSERT (maxAmpduLengthExponent >= 0 && maxAmpduLengthExponent <= 255);

320

      capabilities.SetMaxAmpduLengthExponent (std::max<uint8_t> (7, static_cast<uint8_t> (maxAmpduLengthExponent))); //assume 0 to 7 for HE

334

      capabilities.SetMaxAmpduLengthExponent (std::max<uint8_t> (7, static_cast<uint8_t> (maxAmpduLengthExponent))); //assume 0 to 7 for HE

Lines 338-401 void	Link Here

338

RegularWifiMac::SetVoMaxAmsduSize (uint16_t size)

352

RegularWifiMac::SetVoMaxAmsduSize (uint16_t size)

339

353

340

  NS_LOG_FUNCTION (this << size);

354

  NS_LOG_FUNCTION (this << size);

355

  Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());

356

  if (device)

357

358

      Ptr<HtConfiguration> htConfiguration = device->GetHtConfiguration ();

359

      if (htConfiguration)

360

361

          htConfiguration->SetAttribute ("VoMaxAmsduSize", UintegerValue (size));

362

363

341

  m_voMaxAmsduSize = size;

364

  m_voMaxAmsduSize = size;

342

  ConfigureAggregation ();

343

365

344

366

345

void

367

void

346

RegularWifiMac::SetViMaxAmsduSize (uint16_t size)

368

RegularWifiMac::SetViMaxAmsduSize (uint16_t size)

347

369

348

  NS_LOG_FUNCTION (this << size);

370

  NS_LOG_FUNCTION (this << size);

371

  Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());

372

  if (device)

373

374

      Ptr<HtConfiguration> htConfiguration = device->GetHtConfiguration ();

375

      if (htConfiguration)

376

377

          htConfiguration->SetAttribute ("ViMaxAmsduSize", UintegerValue (size));

378

379

349

  m_viMaxAmsduSize = size;

380

  m_viMaxAmsduSize = size;

350

  ConfigureAggregation ();

351

381

352

382

353

void

383

void

354

RegularWifiMac::SetBeMaxAmsduSize (uint16_t size)

384

RegularWifiMac::SetBeMaxAmsduSize (uint16_t size)

355

385

356

  NS_LOG_FUNCTION (this << size);

386

  NS_LOG_FUNCTION (this << size);

387

  Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());

388

  if (device)

389

390

      Ptr<HtConfiguration> htConfiguration = device->GetHtConfiguration ();

391

      if (htConfiguration)

392

393

          htConfiguration->SetAttribute ("BeMaxAmsduSize", UintegerValue (size));

394

395

357

  m_beMaxAmsduSize = size;

396

  m_beMaxAmsduSize = size;

358

  ConfigureAggregation ();

359

397

360

398

361

void

399

void

362

RegularWifiMac::SetBkMaxAmsduSize (uint16_t size)

400

RegularWifiMac::SetBkMaxAmsduSize (uint16_t size)

363

401

364

  NS_LOG_FUNCTION (this << size);

402

  NS_LOG_FUNCTION (this << size);

403

  Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());

404

  if (device)

405

406

      Ptr<HtConfiguration> htConfiguration = device->GetHtConfiguration ();

407

      if (htConfiguration)

408

409

          htConfiguration->SetAttribute ("BkMaxAmsduSize", UintegerValue (size));

410

411

365

  m_bkMaxAmsduSize = size;

412

  m_bkMaxAmsduSize = size;

366

  ConfigureAggregation ();

367

413

368

414

369

void

415

void

370

RegularWifiMac::SetVoMaxAmpduSize (uint16_t size)

416

RegularWifiMac::SetVoMaxAmpduSize (uint32_t size)

371

417

372

  NS_LOG_FUNCTION (this << size);

418

  NS_LOG_FUNCTION (this << size);

419

  Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());

420

  if (device)

421

422

      Ptr<HtConfiguration> htConfiguration = device->GetHtConfiguration ();

423

      if (htConfiguration)

424

425

          htConfiguration->SetAttribute ("VoMaxAmpduSize", UintegerValue (size));

426

427

373

  m_voMaxAmpduSize = size;

428

  m_voMaxAmpduSize = size;

374

  ConfigureAggregation ();

375

429

376

430

377

void

431

void

378

RegularWifiMac::SetViMaxAmpduSize (uint16_t size)

432

RegularWifiMac::SetViMaxAmpduSize (uint32_t size)

379

433

380

  NS_LOG_FUNCTION (this << size);

434

  NS_LOG_FUNCTION (this << size);

435

  Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());

436

  if (device)

437

438

      Ptr<HtConfiguration> htConfiguration = device->GetHtConfiguration ();

439

      if (htConfiguration)

440

441

          htConfiguration->SetAttribute ("ViMaxAmpduSize", UintegerValue (size));

442

443

381

  m_viMaxAmpduSize = size;

444

  m_viMaxAmpduSize = size;

382

  ConfigureAggregation ();

383

445

384

446

385

void

447

void

386

RegularWifiMac::SetBeMaxAmpduSize (uint16_t size)

448

RegularWifiMac::SetBeMaxAmpduSize (uint32_t size)

387

449

388

  NS_LOG_FUNCTION (this << size);

450

  NS_LOG_FUNCTION (this << size);

451

  Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());

452

  if (device)

453

454

      Ptr<HtConfiguration> htConfiguration = device->GetHtConfiguration ();

455

      if (htConfiguration)

456

457

          htConfiguration->SetAttribute ("BeMaxAmpduSize", UintegerValue (size));

458

459

389

  m_beMaxAmpduSize = size;

460

  m_beMaxAmpduSize = size;

390

  ConfigureAggregation ();

391

461

392

462

393

void

463

void

394

RegularWifiMac::SetBkMaxAmpduSize (uint16_t size)

464

RegularWifiMac::SetBkMaxAmpduSize (uint32_t size)

395

465

396

  NS_LOG_FUNCTION (this << size);

466

  NS_LOG_FUNCTION (this << size);

467

  Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());

468

  if (device)

469

470

      Ptr<HtConfiguration> htConfiguration = device->GetHtConfiguration ();

471

      if (htConfiguration)

472

473

          htConfiguration->SetAttribute ("BkMaxAmpduSize", UintegerValue (size));

474

475

397

  m_bkMaxAmpduSize = size;

476

  m_bkMaxAmpduSize = size;

398

  ConfigureAggregation ();

399

477

400

478

401

void

479

void

Lines 596-603 RegularWifiMac::SetHeSupported (bool enable)	Link Here

596

bool

674

bool

597

RegularWifiMac::GetHtSupported () const

675

RegularWifiMac::GetHtSupported () const

598

676

599

  Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());

677

  if (GetHtConfiguration ())

600

  if (device->GetHtConfiguration ())

601

678

602

      return true;

679

      return true;

603

680

Lines 607-614 RegularWifiMac::GetHtSupported () const	Link Here

607

bool

684

bool

608

RegularWifiMac::GetVhtSupported () const

685

RegularWifiMac::GetVhtSupported () const

609

686

610

  Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());

687

  if (GetVhtConfiguration ())

611

  if (device->GetVhtConfiguration ())

612

688

613

      return true;

689

      return true;

614

690

Lines 618-625 RegularWifiMac::GetVhtSupported () const	Link Here

618

bool

694

bool

619

RegularWifiMac::GetHeSupported () const

695

RegularWifiMac::GetHeSupported () const

620

696

621

  Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());

697

  if (GetHeConfiguration ())

622

  if (device->GetHeConfiguration ())

623

698

624

      return true;

699

      return true;

625

700

Lines 1036-1048 RegularWifiMac::SendAddBaResponse (const MgtAddBaRequestHeader *reqHdr,	Link Here

1036

      respHdr.SetDelayedBlockAck ();

1111

      respHdr.SetDelayedBlockAck ();

1037

1112

1038

  respHdr.SetTid (reqHdr->GetTid ());

1113

  respHdr.SetTid (reqHdr->GetTid ());

1039

  //For now there's not no control about limit of reception. We

1114

1040

  //assume that receiver has no limit on reception. However we assume

1115

  Ptr<HeConfiguration> heConfiguration = GetHeConfiguration ();

1041

  //that a receiver sets a bufferSize in order to satisfy next

1116

  if (heConfiguration && heConfiguration->GetMpduBufferSize () > 64)

1042

  //equation: (bufferSize + 1) % 16 = 0 So if a recipient is able to

1117

1043

  //buffer a packet, it should be also able to buffer all possible

1118

      respHdr.SetBufferSize (255);

1044

  //packet's fragments. See section 7.3.1.14 in IEEE802.11e for more details.

1119

1045

  respHdr.SetBufferSize (1023);

1120

  else

1121

1122

      respHdr.SetBufferSize (63);

1123

1046

  respHdr.SetTimeout (reqHdr->GetTimeout ());

1124

  respHdr.SetTimeout (reqHdr->GetTimeout ());

1047

1125

1048

  WifiActionHeader actionHdr;

1126

  WifiActionHeader actionHdr;

Lines 1132-1156 RegularWifiMac::GetTypeId (void)	Link Here

1132

                   "Value 0 means A-MPDU is disabled for that AC.",

1210

                   "Value 0 means A-MPDU is disabled for that AC.",

1133

                   UintegerValue (0),

1211

                   UintegerValue (0),

1134

                   MakeUintegerAccessor (&RegularWifiMac::SetVoMaxAmpduSize),

1212

                   MakeUintegerAccessor (&RegularWifiMac::SetVoMaxAmpduSize),

1135

                   MakeUintegerChecker<uint16_t> ())

1213

                   MakeUintegerChecker<uint32_t> ())

1136

    .AddAttribute ("VI_MaxAmpduSize",

1214

    .AddAttribute ("VI_MaxAmpduSize",

1137

                   "Maximum length in bytes of an A-MPDU for AC_VI access class."

1215

                   "Maximum length in bytes of an A-MPDU for AC_VI access class."

1138

                   "Value 0 means A-MPDU is disabled for that AC.",

1216

                   "Value 0 means A-MPDU is disabled for that AC.",

1139

                   UintegerValue (65535),

1217

                   UintegerValue (65535),

1140

                   MakeUintegerAccessor (&RegularWifiMac::SetViMaxAmpduSize),

1218

                   MakeUintegerAccessor (&RegularWifiMac::SetViMaxAmpduSize),

1141

                   MakeUintegerChecker<uint16_t> ())

1219

                   MakeUintegerChecker<uint32_t> ())

1142

    .AddAttribute ("BE_MaxAmpduSize",

1220

    .AddAttribute ("BE_MaxAmpduSize",

1143

                   "Maximum length in bytes of an A-MPDU for AC_BE access class."

1221

                   "Maximum length in bytes of an A-MPDU for AC_BE access class."

1144

                   "Value 0 means A-MPDU is disabled for that AC.",

1222

                   "Value 0 means A-MPDU is disabled for that AC.",

1145

                   UintegerValue (65535),

1223

                   UintegerValue (65535),

1146

                   MakeUintegerAccessor (&RegularWifiMac::SetBeMaxAmpduSize),

1224

                   MakeUintegerAccessor (&RegularWifiMac::SetBeMaxAmpduSize),

1147

                   MakeUintegerChecker<uint16_t> ())

1225

                   MakeUintegerChecker<uint32_t> ())

1148

    .AddAttribute ("BK_MaxAmpduSize",

1226

    .AddAttribute ("BK_MaxAmpduSize",

1149

                   "Maximum length in bytes of an A-MPDU for AC_BK access class."

1227

                   "Maximum length in bytes of an A-MPDU for AC_BK access class."

1150

                   "Value 0 means A-MPDU is disabled for that AC.",

1228

                   "Value 0 means A-MPDU is disabled for that AC.",

1151

                   UintegerValue (0),

1229

                   UintegerValue (0),

1152

                   MakeUintegerAccessor (&RegularWifiMac::SetBkMaxAmpduSize),

1230

                   MakeUintegerAccessor (&RegularWifiMac::SetBkMaxAmpduSize),

1153

                   MakeUintegerChecker<uint16_t> ())

1231

                   MakeUintegerChecker<uint32_t> ())

1154

    .AddAttribute ("VO_BlockAckThreshold",

1232

    .AddAttribute ("VO_BlockAckThreshold",

1155

                   "If number of packets in VO queue reaches this value, "

1233

                   "If number of packets in VO queue reaches this value, "

1156

                   "block ack mechanism is used. If this value is 0, block ack is never used."

1234

                   "block ack mechanism is used. If this value is 0, block ack is never used."

Lines 1274-1284 RegularWifiMac::FinishConfigureStandard (WifiPhyStandard standard)	Link Here

1274

    case WIFI_PHY_STANDARD_80211n_5GHZ:

1352

    case WIFI_PHY_STANDARD_80211n_5GHZ:

1275

1353

1276

        EnableAggregation ();

1354

        EnableAggregation ();

1277

        //To be removed once deprecated RifsSupported attribute is removed

1355

        //To be removed once deprecated attributes are removed

1278

        Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());

1356

        Ptr<HtConfiguration> htConfiguration = GetHtConfiguration ();

1279

        Ptr<HtConfiguration> htConfiguration = device->GetHtConfiguration ();

1280

        NS_ASSERT (htConfiguration);

1357

        NS_ASSERT (htConfiguration);

1281

        htConfiguration->SetRifsSupported (m_rifsSupported);

1358

        htConfiguration->SetRifsSupported (m_rifsSupported);

1359

        htConfiguration->SetAttribute ("BeMaxAmpduSize", UintegerValue (m_beMaxAmpduSize));

1360

        htConfiguration->SetAttribute ("BkMaxAmpduSize", UintegerValue (m_bkMaxAmpduSize));

1361

        htConfiguration->SetAttribute ("ViMaxAmpduSize", UintegerValue (m_viMaxAmpduSize));

1362

        htConfiguration->SetAttribute ("VoMaxAmpduSize", UintegerValue (m_voMaxAmpduSize));

1363

        htConfiguration->SetAttribute ("BeMaxAmsduSize", UintegerValue (m_beMaxAmsduSize));

1364

        htConfiguration->SetAttribute ("BkMaxAmsduSize", UintegerValue (m_bkMaxAmsduSize));

1365

        htConfiguration->SetAttribute ("ViMaxAmsduSize", UintegerValue (m_viMaxAmsduSize));

1366

        htConfiguration->SetAttribute ("VoMaxAmsduSize", UintegerValue (m_voMaxAmsduSize));

1282

        SetQosSupported (true);

1367

        SetQosSupported (true);

1283

        cwmin = 15;

1368

        cwmin = 15;

1284

        cwmax = 1023;

1369

        cwmax = 1023;

Lines 1289-1298 RegularWifiMac::FinishConfigureStandard (WifiPhyStandard standard)	Link Here

1289

1374

1290

        EnableAggregation ();

1375

        EnableAggregation ();

1291

        //To be removed once deprecated RifsSupported attribute is removed

1376

        //To be removed once deprecated RifsSupported attribute is removed

1292

        Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());

1377

        Ptr<HtConfiguration> htConfiguration = GetHtConfiguration ();

1293

        Ptr<HtConfiguration> htConfiguration = device->GetHtConfiguration ();

1294

        NS_ASSERT (htConfiguration);

1378

        NS_ASSERT (htConfiguration);

1295

        htConfiguration->SetRifsSupported (m_rifsSupported);

1379

        htConfiguration->SetRifsSupported (m_rifsSupported);

1380

        htConfiguration->SetAttribute ("BeMaxAmpduSize", UintegerValue (m_beMaxAmpduSize));

1381

        htConfiguration->SetAttribute ("BkMaxAmpduSize", UintegerValue (m_bkMaxAmpduSize));

1382

        htConfiguration->SetAttribute ("ViMaxAmpduSize", UintegerValue (m_viMaxAmpduSize));

1383

        htConfiguration->SetAttribute ("VoMaxAmpduSize", UintegerValue (m_voMaxAmpduSize));

1384

        htConfiguration->SetAttribute ("BeMaxAmsduSize", UintegerValue (m_beMaxAmsduSize));

1385

        htConfiguration->SetAttribute ("BkMaxAmsduSize", UintegerValue (m_bkMaxAmsduSize));

1386

        htConfiguration->SetAttribute ("ViMaxAmsduSize", UintegerValue (m_viMaxAmsduSize));

1387

        htConfiguration->SetAttribute ("VoMaxAmsduSize", UintegerValue (m_voMaxAmsduSize));

1296

        SetQosSupported (true);

1388

        SetQosSupported (true);

1297

1389

1298

    case WIFI_PHY_STANDARD_80211g:

1390

    case WIFI_PHY_STANDARD_80211g:

Lines 1346-1389 RegularWifiMac::TxFailed (const WifiMacHeader &hdr)	Link Here

1346

1438

1347

1439

1348

void

1440

void

1349

RegularWifiMac::ConfigureAggregation (void)

1350

1351

  NS_LOG_FUNCTION (this);

1352

  if (GetVOQueue ()->GetMsduAggregator () != 0)

1353

1354

      GetVOQueue ()->GetMsduAggregator ()->SetMaxAmsduSize (m_voMaxAmsduSize);

1355

1356

  if (GetVIQueue ()->GetMsduAggregator () != 0)

1357

1358

      GetVIQueue ()->GetMsduAggregator ()->SetMaxAmsduSize (m_viMaxAmsduSize);

1359

1360

  if (GetBEQueue ()->GetMsduAggregator () != 0)

1361

1362

      GetBEQueue ()->GetMsduAggregator ()->SetMaxAmsduSize (m_beMaxAmsduSize);

1363

1364

  if (GetBKQueue ()->GetMsduAggregator () != 0)

1365

1366

      GetBKQueue ()->GetMsduAggregator ()->SetMaxAmsduSize (m_bkMaxAmsduSize);

1367

1368

  if (GetVOQueue ()->GetMpduAggregator () != 0)

1369

1370

      GetVOQueue ()->GetMpduAggregator ()->SetMaxAmpduSize (m_voMaxAmpduSize);

1371

1372

  if (GetVIQueue ()->GetMpduAggregator () != 0)

1373

1374

      GetVIQueue ()->GetMpduAggregator ()->SetMaxAmpduSize (m_viMaxAmpduSize);

1375

1376

  if (GetBEQueue ()->GetMpduAggregator () != 0)

1377

1378

      GetBEQueue ()->GetMpduAggregator ()->SetMaxAmpduSize (m_beMaxAmpduSize);

1379

1380

  if (GetBKQueue ()->GetMpduAggregator () != 0)

1381

1382

      GetBKQueue ()->GetMpduAggregator ()->SetMaxAmpduSize (m_bkMaxAmpduSize);

1383

1384

1385

1386

void

1387

RegularWifiMac::EnableAggregation (void)

1441

RegularWifiMac::EnableAggregation (void)

1388

1442

1389

  NS_LOG_FUNCTION (this);

1443

  NS_LOG_FUNCTION (this);

Lines 1400-1406 RegularWifiMac::EnableAggregation (void)	Link Here

1400

          i->second->SetMpduAggregator (mpduAggregator);

1454

          i->second->SetMpduAggregator (mpduAggregator);

1401

1455

1402

1456

1403

  ConfigureAggregation ();

1404

1457

1405

1458

1406

void

1459

void




   *
   * \param size the maximum A-MPDU size for AC_VO.
   */
  void SetVoMaxAmpduSize (uint32_t size);
  /**
   * Set the maximum A-MPDU size for AC_VI.
   *
   * \param size the maximum A-MPDU size for AC_VI.
   */
  void SetViMaxAmpduSize (uint32_t size);
  /**
   * Set the maximum A-MPDU size for AC_BE.
   *
   * \param size the maximum A-MPDU size for AC_BE.
   */
  void SetBeMaxAmpduSize (uint32_t size);
  /**
   * Set the maximum A-MPDU size for AC_BK.
   *
   * \param size the maximum A-MPDU size for AC_BK.
   */
  void SetBkMaxAmpduSize (uint32_t size);

  /**
   * Set the Block ACK threshold for AC_VO.

   */
  bool m_dsssSupported;

  /// Configure aggregation function
  void ConfigureAggregation (void);
  /// Enable aggregation function
  void EnableAggregation (void);
  /// Disable aggregation function

  uint16_t m_beMaxAmsduSize; ///< maximum A-MSDU size for AC_BE
  uint16_t m_bkMaxAmsduSize; ///< maximum A-MSDU size for AC_BK

  uint32_t m_voMaxAmpduSize; ///< maximum A-MPDU size for AC_VO
  uint32_t m_viMaxAmpduSize; ///< maximum A-MPDU size for AC_VI
  uint32_t m_beMaxAmpduSize; ///< maximum A-MPDU size for AC_BE
  uint32_t m_bkMaxAmpduSize; ///< maximum A-MPDU size for AC_BK

  TracedCallback<const WifiMacHeader &> m_txOkCallback; ///< transmit OK callback
  TracedCallback<const WifiMacHeader &> m_txErrCallback; ///< transmit error callback

(-)a/src/wifi/model/sta-wifi-mac.h (-1 / +3 lines)

Lines 28-33	Link Here

class TwoLevelAggregationTest;

class TwoLevelAggregationTest;

class AmpduAggregationTest;

class AmpduAggregationTest;

class HeAggregationTest;

namespace ns3  {

namespace ns3  {

Lines 109-115 public:	Link Here

109

  friend class ::TwoLevelAggregationTest;

110

  friend class ::TwoLevelAggregationTest;

110

  /// Allow test cases to access private members

111

  /// Allow test cases to access private members

111

  friend class ::AmpduAggregationTest;

112

  friend class ::AmpduAggregationTest;

112

113

  /// Allow test cases to access private members

114

  friend class ::HeAggregationTest;

113

/**

115

/**

114

   * \brief Get the type ID.

116

   * \brief Get the type ID.

115

   * \return the object TypeId

117

   * \return the object TypeId




 */

#include "ns3/log.h"
#include "ns3/uinteger.h"
#include "vht-configuration.h"

namespace ns3 {

    .SetParent<Object> ()
    .SetGroupName ("Wifi")
    .AddConstructor<VhtConfiguration> ()
    .AddAttribute ("VoMaxAmsduSize",
                   "Maximum length in bytes of an A-MSDU for AC_VO access class. "
                   "Value 0 means A-MSDU is disabled for that AC.",
                   UintegerValue (0),
                   MakeUintegerAccessor (&VhtConfiguration::m_voMaxAmsduSize),
                   MakeUintegerChecker<uint16_t> (0, 11454))
    .AddAttribute ("ViMaxAmsduSize",
                   "Maximum length in bytes of an A-MSDU for AC_VI access class."
                   "Value 0 means A-MSDU is disabled for that AC.",
                   UintegerValue (0),
                   MakeUintegerAccessor (&VhtConfiguration::m_viMaxAmsduSize),
                   MakeUintegerChecker<uint16_t> (0, 11454))
    .AddAttribute ("BeMaxAmsduSize",
                   "Maximum length in bytes of an A-MSDU for AC_BE access class."
                   "Value 0 means A-MSDU is disabled for that AC.",
                   UintegerValue (0),
                   MakeUintegerAccessor (&VhtConfiguration::m_beMaxAmsduSize),
                   MakeUintegerChecker<uint16_t> (0, 11454))
    .AddAttribute ("BkMaxAmsduSize",
                   "Maximum length in bytes of an A-MSDU for AC_BK access class."
                   "Value 0 means A-MSDU is disabled for that AC.",
                   UintegerValue (0),
                   MakeUintegerAccessor (&VhtConfiguration::m_bkMaxAmsduSize),
                   MakeUintegerChecker<uint16_t> (0, 11454))
    .AddAttribute ("VoMaxAmpduSize",
                   "Maximum length in bytes of an A-MPDU for AC_VO access class."
                   "Value 0 means A-MPDU is disabled for that AC.",
                   UintegerValue (0),
                   MakeUintegerAccessor (&VhtConfiguration::m_voMaxAmpduSize),
                   MakeUintegerChecker<uint32_t> (0, 1048575))
    .AddAttribute ("ViMaxAmpduSize",
                   "Maximum length in bytes of an A-MPDU for AC_VI access class."
                   "Value 0 means A-MPDU is disabled for that AC.",
                   UintegerValue (1048575),
                   MakeUintegerAccessor (&VhtConfiguration::m_viMaxAmpduSize),
                   MakeUintegerChecker<uint32_t> (0, 1048575))
    .AddAttribute ("BeMaxAmpduSize",
                   "Maximum length in bytes of an A-MPDU for AC_BE access class."
                   "Value 0 means A-MPDU is disabled for that AC.",
                   UintegerValue (1048575),
                   MakeUintegerAccessor (&VhtConfiguration::m_beMaxAmpduSize),
                   MakeUintegerChecker<uint32_t> (0, 1048575))
    .AddAttribute ("BkMaxAmpduSize",
                   "Maximum length in bytes of an A-MPDU for AC_BK access class."
                   "Value 0 means A-MPDU is disabled for that AC.",
                   UintegerValue (0),
                   MakeUintegerAccessor (&VhtConfiguration::m_bkMaxAmpduSize),
                   MakeUintegerChecker<uint32_t> (0, 1048575))
    ;
    return tid;
}




  virtual ~VhtConfiguration ();

  static TypeId GetTypeId (void);


private:
  uint16_t m_voMaxAmsduSize; ///< maximum A-MSDU size for AC_VO
  uint16_t m_viMaxAmsduSize; ///< maximum A-MSDU size for AC_VI
  uint16_t m_beMaxAmsduSize; ///< maximum A-MSDU size for AC_BE
  uint16_t m_bkMaxAmsduSize; ///< maximum A-MSDU size for AC_BK

  uint32_t m_voMaxAmpduSize; ///< maximum A-MPDU size for AC_VO
  uint32_t m_viMaxAmpduSize; ///< maximum A-MPDU size for AC_VI
  uint32_t m_beMaxAmpduSize; ///< maximum A-MPDU size for AC_BE
  uint32_t m_bkMaxAmpduSize; ///< maximum A-MPDU size for AC_BK
};

} //namespace ns3

(-)a/src/wifi/model/wifi-mac-queue.cc (+22 lines)

Lines 38-43 WifiMacQueue::GetTypeId (void)	Link Here

    .SetParent<Queue<WifiMacQueueItem> > ()

    .SetParent<Queue<WifiMacQueueItem> > ()

    .SetGroupName ("Wifi")

    .SetGroupName ("Wifi")

    .AddConstructor<WifiMacQueue> ()

    .AddConstructor<WifiMacQueue> ()

    .AddAttribute ("MaxQueueSize",

                   "The max queue size",

                   QueueSizeValue (QueueSize ("500p")),

                   MakeQueueSizeAccessor (&WifiMacQueue::SetMaxQueueSize),

                   MakeQueueSizeChecker ())

    .AddAttribute ("MaxDelay", "If a packet stays longer than this delay in the queue, it is dropped.",

    .AddAttribute ("MaxDelay", "If a packet stays longer than this delay in the queue, it is dropped.",

                   TimeValue (MilliSeconds (500)),

                   TimeValue (MilliSeconds (500)),

                   MakeTimeAccessor (&WifiMacQueue::SetMaxDelay),

                   MakeTimeAccessor (&WifiMacQueue::SetMaxDelay),

Lines 62-67 WifiMacQueue::~WifiMacQueue ()	Link Here

void

void

WifiMacQueue::SetMaxQueueSize (QueueSize size)

  NS_LOG_FUNCTION (this << size);

  m_maxSize = size;

QueueSize

WifiMacQueue::GetMaxQueueSize (void) const

  return m_maxSize;

void

WifiMacQueue::SetMaxDelay (Time delay)

WifiMacQueue::SetMaxDelay (Time delay)

  NS_LOG_FUNCTION (this << delay);

  NS_LOG_FUNCTION (this << delay);

Lines 97-102 WifiMacQueue::Enqueue (Ptr<WifiMacQueueItem> item)	Link Here

  NS_ASSERT_MSG (GetMaxSize ().GetUnit () == QueueSizeUnit::PACKETS,

115

  NS_ASSERT_MSG (GetMaxSize ().GetUnit () == QueueSizeUnit::PACKETS,

                 "WifiMacQueues must be in packet mode");

116

                 "WifiMacQueues must be in packet mode");

117

118

  QueueBase::SetMaxSize (GetMaxQueueSize ()); //Make sure QueueBase has the same maximum queue size

119

100

  // if the queue is full, remove the first stale packet (if any) encountered

120

  // if the queue is full, remove the first stale packet (if any) encountered

101

  // starting from the head of the queue, in order to make room for the new packet.

121

  // starting from the head of the queue, in order to make room for the new packet.

102

  if (QueueBase::GetNPackets () == GetMaxSize ().GetValue ())

122

  if (QueueBase::GetNPackets () == GetMaxSize ().GetValue ())

Lines 124-129 WifiMacQueue::PushFront (Ptr<WifiMacQueueItem> item)	Link Here

124

  NS_ASSERT_MSG (GetMaxSize ().GetUnit () == QueueSizeUnit::PACKETS,

144

  NS_ASSERT_MSG (GetMaxSize ().GetUnit () == QueueSizeUnit::PACKETS,

125

                 "WifiMacQueues must be in packet mode");

145

                 "WifiMacQueues must be in packet mode");

126

146

147

  QueueBase::SetMaxSize (GetMaxQueueSize ()); //Make sure QueueBase has the same maximum queue size

148

127

  // if the queue is full, remove the first stale packet (if any) encountered

149

  // if the queue is full, remove the first stale packet (if any) encountered

128

  // starting from the head of the queue, in order to make room for the new packet.

150

  // starting from the head of the queue, in order to make room for the new packet.

129

  if (QueueBase::GetNPackets () == GetMaxSize ().GetValue ())

151

  if (QueueBase::GetNPackets () == GetMaxSize ().GetValue ())




  };

  /**
   * \brief Set the maximum size of this queue
   *
   * Trying to set a null size has no effect.
   *
   * \param size the maximum size
   */
  void SetMaxQueueSize (QueueSize size);
  /**
   * \return the maximum size of this queue
   */
  QueueSize GetMaxQueueSize (void) const;
  /**
   * Set the maximum delay before the packet is discarded.
   *
   * \param delay the maximum delay

   */
  bool TtlExceeded (ConstIterator &it);

  QueueSize m_maxSize;                      //!< max queue size
  Time m_maxDelay;                          //!< Time to live for packets in the queue
  DropPolicy m_dropPolicy;                  //!< Drop behavior of queue


(-)a/src/wifi/model/wifi-mac.cc (+9 lines)

Lines 25-30	Link Here

#include "ssid.h"

#include "ssid.h"

#include "wifi-net-device.h"

#include "wifi-net-device.h"

#include "ht-configuration.h"

#include "ht-configuration.h"

#include "vht-configuration.h"

#include "he-configuration.h"

#include "he-configuration.h"

namespace ns3 {

namespace ns3 {

Lines 414-419 WifiMac::Configure80211ax_5Ghz (void)	Link Here

414

415

  NS_LOG_FUNCTION (this);

416

  NS_LOG_FUNCTION (this);

416

  Configure80211ac ();

417

  Configure80211ac ();

418

  SetCompressedBlockAckTimeout (GetSifs () + GetSlot () + MicroSeconds (85) + GetDefaultMaxPropagationDelay () * 2);

417

419

418

420

419

void

421

void

Lines 480-485 WifiMac::GetHtConfiguration (void) const	Link Here

480

      return device->GetHtConfiguration ();

482

      return device->GetHtConfiguration ();

481

483

482

484

485

Ptr<VhtConfiguration>

486

WifiMac::GetVhtConfiguration (void) const

487

488

      Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());

489

      return device->GetVhtConfiguration ();

490

491

483

Ptr<HeConfiguration>

492

Ptr<HeConfiguration>

484

WifiMac::GetHeConfiguration (void) const

493

WifiMac::GetHeConfiguration (void) const

485

494




class Ssid;
class Txop;
class HtConfiguration;
class VhtConfiguration;
class HeConfiguration;

/**

   */
  void ConfigureStandard (WifiPhyStandard standard);

  /**
   * \return pointer to HtConfiguration if it exists
   */
  Ptr<HtConfiguration> GetHtConfiguration (void) const;
  /**
   * \return pointer to VhtConfiguration if it exists
   */
  Ptr<VhtConfiguration> GetVhtConfiguration (void) const;
  /**
   * \return pointer to HeConfiguration if it exists
   */
  Ptr<HeConfiguration> GetHeConfiguration (void) const;


protected:
  /**

   */
  void ConfigureDcf (Ptr<Txop> dcf, uint32_t cwmin, uint32_t cwmax, bool isDsss, AcIndex ac);

  /**
   * \return pointer to HtConfiguration if it exists
   */
  Ptr<HtConfiguration> GetHtConfiguration (void) const;
  /**
   * \return pointer to HeConfiguration if it exists
   */
  Ptr<HeConfiguration> GetHeConfiguration (void) const;


private:
  /**




  WifiMacHeader hdr;
  hdr.SetType (WIFI_MAC_CTL_BACKRESP);
  CtrlBAckResponseHeader blockAck;
  blockAck.SetType (type);
    {
      blockAck.SetType (BASIC_BLOCK_ACK);
    }
  else if (type == COMPRESSED_BLOCK_ACK)
    {
      blockAck.SetType (COMPRESSED_BLOCK_ACK);
    }
  else if (type == MULTI_TID_BLOCK_ACK)
    {
      //Not implemented
      NS_ASSERT (false);
    }
  return hdr.GetSize () + blockAck.GetSerializedSize () + 4;
}


(-)a/src/wifi/model/wifi-utils.h (-1 / +1 lines)

Lines 120-126 uint32_t GetCtsSize (void);	Link Here

120

/**

120

/**

121

 * \param seq MPDU sequence number

121

 * \param seq MPDU sequence number

122

 * \param winstart sequence number window start

122

 * \param winstart sequence number window start

123

 * \param winsize the size of the sequence number window (currently default is 64)

123

 * \param winsize the size of the sequence number window

124

 * \returns true if in the window

124

 * \returns true if in the window

125

126

 * This method checks if the MPDU's sequence number is inside the scoreboard boundaries or not

126

 * This method checks if the MPDU's sequence number is inside the scoreboard boundaries or not

(-)a/src/wifi/test/wifi-aggregation-test.cc (-6 / +155 lines)

Lines 30-35	Link Here

#include "ns3/mpdu-aggregator.h"

#include "ns3/mpdu-aggregator.h"

#include "ns3/wifi-net-device.h"

#include "ns3/wifi-net-device.h"

#include "ns3/ht-configuration.h"

#include "ns3/ht-configuration.h"

#include "ns3/vht-configuration.h"

#include "ns3/he-configuration.h"

using namespace ns3;

using namespace ns3;

Lines 100-106 AmpduAggregationTest::DoRun (void)	Link Here

100

/*

102

/*

101

   * Configure MPDU aggregation.

103

   * Configure MPDU aggregation.

102

*/

104

*/

103

  m_mac->GetBEQueue ()->GetMpduAggregator ()->SetMaxAmpduSize (65535);

105

  htConfiguration->SetAttribute ("BeMaxAmpduSize", UintegerValue (65535));

104

106

105

/*

107

/*

106

   * Create a dummy packet of 1500 bytes and fill mac header fields.

108

   * Create a dummy packet of 1500 bytes and fill mac header fields.

Lines 124-130 AmpduAggregationTest::DoRun (void)	Link Here

124

  MgtAddBaRequestHeader reqHdr;

126

  MgtAddBaRequestHeader reqHdr;

125

  reqHdr.SetImmediateBlockAck ();

127

  reqHdr.SetImmediateBlockAck ();

126

  reqHdr.SetTid (0);

128

  reqHdr.SetTid (0);

127

  reqHdr.SetBufferSize (0);

129

  reqHdr.SetBufferSize (64);

128

  reqHdr.SetTimeout (0);

130

  reqHdr.SetTimeout (0);

129

  reqHdr.SetStartingSequence (0);

131

  reqHdr.SetStartingSequence (0);

130

  m_mac->GetBEQueue ()->m_baManager->CreateAgreement (&reqHdr, hdr.GetAddr1 ());

132

  m_mac->GetBEQueue ()->m_baManager->CreateAgreement (&reqHdr, hdr.GetAddr1 ());

Lines 305-312 TwoLevelAggregationTest::DoRun (void)	Link Here

305

/*

307

/*

306

   * Configure aggregation.

308

   * Configure aggregation.

307

*/

309

*/

308

  m_mac->GetBEQueue ()->GetMsduAggregator ()->SetMaxAmsduSize (4095);

310

  htConfiguration->SetAttribute ("BeMaxAmsduSize", UintegerValue (4095));

309

  m_mac->GetBEQueue ()->GetMpduAggregator ()->SetMaxAmpduSize (65535);

311

  htConfiguration->SetAttribute ("BeMaxAmpduSize", UintegerValue (65535));

310

312

311

/*

313

/*

312

   * Create dummy packets of 1500 bytes and fill mac header fields that will be used for the tests.

314

   * Create dummy packets of 1500 bytes and fill mac header fields that will be used for the tests.

Lines 354-360 TwoLevelAggregationTest::DoRun (void)	Link Here

354

   * It checks whether MSDU aggregation has been rejected because the maximum MPDU size is set to 0 (returned packet should be equal to 0).

356

   * It checks whether MSDU aggregation has been rejected because the maximum MPDU size is set to 0 (returned packet should be equal to 0).

355

   * This test is needed to ensure that no packets are removed from the queue in MacLow::PerformMsduAggregation, since aggregation will no occur in MacLow::AggregateToAmpdu.

357

   * This test is needed to ensure that no packets are removed from the queue in MacLow::PerformMsduAggregation, since aggregation will no occur in MacLow::AggregateToAmpdu.

356

*/

358

*/

357

  m_mac->GetBEQueue ()->GetMpduAggregator ()->SetMaxAmpduSize (65535);

359

  htConfiguration->SetAttribute ("BeMaxAmpduSize", UintegerValue (65535));

358

360

359

  m_mac->GetBEQueue ()->GetWifiMacQueue ()->Enqueue (Create<WifiMacQueueItem> (pkt, hdr));

361

  m_mac->GetBEQueue ()->GetWifiMacQueue ()->Enqueue (Create<WifiMacQueueItem> (pkt, hdr));

360

  packet = m_mac->GetBEQueue ()->GetLow ()->PerformMsduAggregation (peekedPacket, &peekedHdr, &tstamp, currentAggregatedPacket, 0);

362

  packet = m_mac->GetBEQueue ()->GetLow ()->PerformMsduAggregation (peekedPacket, &peekedHdr, &tstamp, currentAggregatedPacket, 0);

Lines 369-375 TwoLevelAggregationTest::DoRun (void)	Link Here

369

   * It checks whether MSDU aggregation has been rejected because there is no packets ready in the queue (returned packet should be equal to 0).

371

   * It checks whether MSDU aggregation has been rejected because there is no packets ready in the queue (returned packet should be equal to 0).

370

   * This test is needed to ensure that there is no issue when the queue is empty.

372

   * This test is needed to ensure that there is no issue when the queue is empty.

371

*/

373

*/

372

  m_mac->GetBEQueue ()->GetMpduAggregator ()->SetMaxAmpduSize (4095);

374

  htConfiguration->SetAttribute ("BeMaxAmpduSize", UintegerValue (4095));

373

375

374

  m_mac->GetBEQueue ()->GetWifiMacQueue ()->Remove (pkt);

376

  m_mac->GetBEQueue ()->GetWifiMacQueue ()->Remove (pkt);

375

  m_mac->GetBEQueue ()->GetWifiMacQueue ()->Remove (pkt);

377

  m_mac->GetBEQueue ()->GetWifiMacQueue ()->Remove (pkt);

Lines 388-393 TwoLevelAggregationTest::DoRun (void)	Link Here

388

 * \ingroup wifi-test

390

 * \ingroup wifi-test

389

 * \ingroup tests

391

 * \ingroup tests

390

392

393

 * \brief 802.11ax aggregation test which permits 64 or 256 MPDUs in A-MPDU according to the negociated buffer size.

394

*/

395

class HeAggregationTest : public TestCase

396

397

public:

398

  HeAggregationTest ();

399

400

private:

401

  void DoRun (void);

402

  void DoRunSubTest (uint16_t bufferSize);

403

  Ptr<WifiNetDevice> m_device; ///<WifiNetDevice

404

  Ptr<StaWifiMac> m_mac; ///< Mac

405

  Ptr<YansWifiPhy> m_phy; ///< Phy

406

  Ptr<WifiRemoteStationManager> m_manager; ///< remote station manager

407

  ObjectFactory m_factory; ///< factory

408

};

409

410

HeAggregationTest::HeAggregationTest ()

411

  : TestCase ("Check the correctness of 802.11ax aggregation operations")

412

413

414

415

void

416

HeAggregationTest::DoRunSubTest (uint16_t bufferSize)

417

418

/*

419

   * Create device and attach configurations.

420

*/

421

  m_device = CreateObject<WifiNetDevice> ();

422

  Ptr<HtConfiguration> htConfiguration = CreateObject<HtConfiguration> ();

423

  m_device->SetHtConfiguration (htConfiguration);

424

  Ptr<VhtConfiguration> vhtConfiguration = CreateObject<VhtConfiguration> ();

425

  m_device->SetVhtConfiguration (vhtConfiguration);

426

  Ptr<HeConfiguration> heConfiguration = CreateObject<HeConfiguration> ();

427

  m_device->SetHeConfiguration (heConfiguration);

428

429

/*

430

   * Create and configure phy layer.

431

*/

432

  m_phy = CreateObject<YansWifiPhy> ();

433

  m_phy->SetDevice (m_device);

434

  m_phy->ConfigureStandard (WIFI_PHY_STANDARD_80211ax_5GHZ);

435

  m_device->SetPhy (m_phy);

436

437

/*

438

   * Create and configure manager.

439

*/

440

  m_factory = ObjectFactory ();

441

  m_factory.SetTypeId ("ns3::ConstantRateWifiManager");

442

  m_factory.Set ("DataMode", StringValue ("HeMcs11"));

443

  m_manager = m_factory.Create<WifiRemoteStationManager> ();

444

  m_manager->SetupPhy (m_phy);

445

  m_device->SetRemoteStationManager (m_manager);

446

447

/*

448

   * Create and configure mac layer.

449

*/

450

  m_mac = CreateObject<StaWifiMac> ();

451

  m_mac->SetDevice (m_device);

452

  m_mac->SetWifiPhy (m_phy);

453

  m_mac->SetWifiRemoteStationManager (m_manager);

454

  m_mac->SetAddress (Mac48Address ("00:00:00:00:00:01"));

455

  m_mac->ConfigureStandard (WIFI_PHY_STANDARD_80211ax_5GHZ);

456

  m_device->SetMac (m_mac);

457

458

/*

459

   * Create a dummy packet of 100 bytes and fill mac header fields.

460

*/

461

  Ptr<const Packet> pkt = Create<Packet> (100);

462

  Ptr<Packet> currentAggregatedPacket = Create<Packet> ();

463

  WifiMacHeader hdr;

464

  hdr.SetAddr1 (Mac48Address ("00:00:00:00:00:02"));

465

  hdr.SetAddr2 (Mac48Address ("00:00:00:00:00:01"));

466

  hdr.SetType (WIFI_MAC_QOSDATA);

467

  hdr.SetQosTid (0);

468

  uint16_t sequence = m_mac->m_txMiddle->GetNextSequenceNumberFor (&hdr);

469

  hdr.SetSequenceNumber (sequence);

470

  hdr.SetFragmentNumber (0);

471

  hdr.SetNoMoreFragments ();

472

  hdr.SetNoRetry ();

473

474

/*

475

   * Establish agreement.

476

*/

477

  MgtAddBaRequestHeader reqHdr;

478

  reqHdr.SetImmediateBlockAck ();

479

  reqHdr.SetTid (0);

480

  reqHdr.SetBufferSize (bufferSize);

481

  reqHdr.SetTimeout (0);

482

  reqHdr.SetStartingSequence (0);

483

  m_mac->GetBEQueue ()->m_baManager->CreateAgreement (&reqHdr, hdr.GetAddr1 ());

484

485

/*

486

   * Prepare MacLow for transmission

487

*/

488

  m_mac->GetBEQueue ()->GetLow ()->m_currentHdr = hdr;

489

  m_mac->GetBEQueue ()->GetLow ()->m_currentPacket = pkt->Copy ();

490

  m_mac->GetBEQueue ()->GetLow ()->m_currentTxVector = m_mac->GetBEQueue ()->GetLow ()->GetDataTxVector (m_mac->GetBEQueue ()->GetLow ()->m_currentPacket, &m_mac->GetBEQueue ()->GetLow ()->m_currentHdr);

491

492

/*

493

   * Test behavior when 300 packets are ready for transmission but negociated buffer size is 64

494

*/

495

  for (uint16_t i = 0; i < 300; i++)

496

497

      Ptr<const Packet> pkt = Create<Packet> (100);

498

      WifiMacHeader hdr;

499

500

      hdr.SetAddr1 (Mac48Address ("00:00:00:00:00:02"));

501

      hdr.SetAddr2 (Mac48Address ("00:00:00:00:00:01"));

502

      hdr.SetType (WIFI_MAC_QOSDATA);

503

      hdr.SetQosTid (0);

504

505

      m_mac->GetBEQueue ()->GetWifiMacQueue ()->Enqueue (Create<WifiMacQueueItem> (pkt, hdr));

506

507

508

  bool isAmpdu = m_mac->GetBEQueue ()->GetLow ()->IsAmpdu (pkt, hdr);

509

  NS_TEST_EXPECT_MSG_EQ (isAmpdu, true, "MPDU aggregation failed");

510

  uint32_t aggregationQueueSize = m_mac->GetBEQueue ()->GetLow ()->m_aggregateQueue[0]->GetNPackets ();

511

  NS_TEST_EXPECT_MSG_EQ (aggregationQueueSize, bufferSize, "aggregation queue should countain " << bufferSize << " MPDUs");

512

  uint16_t expectedRemainingPacketsInQueue = 300 - bufferSize + 1;

513

  NS_TEST_EXPECT_MSG_EQ (m_mac->GetBEQueue ()->GetWifiMacQueue ()->GetNPackets (), expectedRemainingPacketsInQueue, "queue should contain 300 - "<< bufferSize - 1 << " = "<< expectedRemainingPacketsInQueue << " packets");

514

515

  Simulator::Destroy ();

516

517

  m_manager->Dispose ();

518

  m_manager = 0;

519

520

  m_device->Dispose ();

521

  m_device = 0;

522

523

  htConfiguration = 0;

524

  vhtConfiguration = 0;

525

  heConfiguration = 0;

526

527

528

void

529

HeAggregationTest::DoRun ()

530

531

  DoRunSubTest (64);

532

  DoRunSubTest (256);

533

534

535

/**

536

 * \ingroup wifi-test

537

 * \ingroup tests

538

391

 * \brief Wifi Aggregation Test Suite

539

 * \brief Wifi Aggregation Test Suite

392

*/

540

*/

393

class WifiAggregationTestSuite : public TestSuite

541

class WifiAggregationTestSuite : public TestSuite

Lines 401-406 WifiAggregationTestSuite::WifiAggregationTestSuite ()	Link Here

401

549

402

  AddTestCase (new AmpduAggregationTest, TestCase::QUICK);

550

  AddTestCase (new AmpduAggregationTest, TestCase::QUICK);

403

  AddTestCase (new TwoLevelAggregationTest, TestCase::QUICK);

551

  AddTestCase (new TwoLevelAggregationTest, TestCase::QUICK);

552

  AddTestCase (new HeAggregationTest, TestCase::QUICK);

404

553

405

554

406

static WifiAggregationTestSuite g_wifiAggregationTestSuite; ///< the test suite

555

static WifiAggregationTestSuite g_wifiAggregationTestSuite; ///< the test suite

Return to bug 3010