Attachment #2180 for bug #2116

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

(-)a/examples/wireless/simple-ht-hidden-stations.cc (-25 / +19 lines)

Lines 52-57	Link Here

  uint32_t payloadSize = 1472; //bytes

  uint32_t payloadSize = 1472; //bytes

  uint64_t simulationTime = 10; //seconds

  uint64_t simulationTime = 10; //seconds

  uint32_t nMpdus = 1;

  uint32_t nMpdus = 1;

  uint32_t maxAmpduSize = 0;

  uint16_t blockAckThreshold = 0;

  bool enableRts = 0;

  bool enableRts = 0;

  CommandLine cmd;

  CommandLine cmd;

Lines 72-77	Link Here

  Config::SetDefault ("ns3::WifiRemoteStationManager::FragmentationThreshold", StringValue ("990000"));

  Config::SetDefault ("ns3::WifiRemoteStationManager::FragmentationThreshold", StringValue ("990000"));

  if (nMpdus > 1)

     //enable BlockAck when A-MPDU is used

      blockAckThreshold = 2;

  //Set the maximum size for A-MPDU with regards to the payload size

  maxAmpduSize = nMpdus * (payloadSize + 200);

  // Set the maximum wireless range to 5 meters in order to reproduce a hidden nodes scenario, i.e. the distance between hidden stations is larger than 5 meters

  // Set the maximum wireless range to 5 meters in order to reproduce a hidden nodes scenario, i.e. the distance between hidden stations is larger than 5 meters

  Config::SetDefault ("ns3::RangePropagationLossModel::MaxRange", DoubleValue (5));

  Config::SetDefault ("ns3::RangePropagationLossModel::MaxRange", DoubleValue (5));

Lines 90-129	Link Here

  WifiHelper wifi = WifiHelper::Default ();

100

  WifiHelper wifi = WifiHelper::Default ();

  wifi.SetStandard (WIFI_PHY_STANDARD_80211n_5GHZ);

101

  wifi.SetStandard (WIFI_PHY_STANDARD_80211n_5GHZ);

  wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager", "DataMode", StringValue ("HtMcs7"), "ControlMode", StringValue ("HtMcs0"));

102

  wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager", "DataMode", StringValue ("HtMcs7"), "ControlMode", StringValue ("HtMcs0"));

103

  QosWifiMacHelper mac = QosWifiMacHelper::Default ();

104

  QosWifiMacHelper mac = QosWifiMacHelper::Default ();

105

  Ssid ssid = Ssid ("simple-mpdu-aggregation");

106

  NetDeviceContainer staDevices, apDevice;

107

  Ssid ssid = Ssid ("simple-mpdu-aggregation");

  mac.SetType ("ns3::StaWifiMac",

108

  mac.SetType ("ns3::StaWifiMac",

               "Ssid", SsidValue (ssid),

109

               "Ssid", SsidValue (ssid),

               "ActiveProbing", BooleanValue (false));

110

               "ActiveProbing", BooleanValue (false),

111

               "BE_BlockAckThreshold", UintegerValue (blockAckThreshold),

100

  if (nMpdus > 1)

112

               "BE_MaxAmpduSize", UintegerValue (maxAmpduSize));

101

102

      mac.SetBlockAckThresholdForAc (AC_BE, 2);             //enable Block ACK when A-MPDU is enabled

103

104

105

  mac.SetMpduAggregatorForAc (AC_BE,"ns3::MpduStandardAggregator",

106

                              "MaxAmpduSize", UintegerValue (nMpdus * (payloadSize + 100))); //enable MPDU aggregation for AC_BE with a maximum aggregated size of nMpdus*(payloadSize+100) bytes,

107

                                                                                             //i.e. nMpdus aggregated packets in an A-MPDU

108

109

  NetDeviceContainer staDevices;

110

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

113

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

111

114

112

  mac.SetType ("ns3::ApWifiMac",

115

  mac.SetType ("ns3::ApWifiMac",

113

               "Ssid", SsidValue (ssid),

116

               "Ssid", SsidValue (ssid),

114

               "BeaconInterval", TimeValue (MicroSeconds (102400)),

117

               "BeaconInterval", TimeValue (MicroSeconds (102400)),

115

               "BeaconGeneration", BooleanValue (true));

118

               "BeaconGeneration", BooleanValue (true),

116

119

               "BE_BlockAckThreshold", UintegerValue (blockAckThreshold),

117

  if (nMpdus > 1)

120

               "BE_MaxAmpduSize", UintegerValue (maxAmpduSize));

118

119

      mac.SetBlockAckThresholdForAc (AC_BE, 2);             //enable Block ACK when A-MPDU is enabled

120

121

122

  mac.SetMpduAggregatorForAc (AC_BE,"ns3::MpduStandardAggregator",

123

                              "MaxAmpduSize", UintegerValue (nMpdus * (payloadSize + 100))); //enable MPDU aggregation for AC_BE with a maximum aggregated size of nMpdus*(payloadSize+100) bytes,

124

                                                                                             //i.e. nMpdus aggregated packets in an A-MPDU

125

126

  NetDeviceContainer apDevice;

127

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

121

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

128

122

129

  // Setting mobility model

123

  // Setting mobility model

(-)a/examples/wireless/simple-mpdu-aggregation.cc (-23 / +19 lines)

Lines 55-60	Link Here

  uint32_t payloadSize = 1472; //bytes

  uint32_t payloadSize = 1472; //bytes

  uint64_t simulationTime = 10; //seconds

  uint64_t simulationTime = 10; //seconds

  uint32_t nMpdus = 1;

  uint32_t nMpdus = 1;

  uint32_t maxAmpduSize = 0;

  uint16_t blockAckThreshold = 0;

  bool enableRts = 0;

  bool enableRts = 0;

  CommandLine cmd;

  CommandLine cmd;

Lines 74-79	Link Here

  Config::SetDefault ("ns3::WifiRemoteStationManager::FragmentationThreshold", StringValue ("990000"));

  Config::SetDefault ("ns3::WifiRemoteStationManager::FragmentationThreshold", StringValue ("990000"));

  if (nMpdus > 1)

     //enable BlockAck when A-MPDU is used

      blockAckThreshold = 2;

  //Set the maximum size for A-MPDU with regards to the payload size

  maxAmpduSize = nMpdus * (payloadSize + 200);

  NodeContainer wifiStaNode;

  NodeContainer wifiStaNode;

  wifiStaNode.Create (1);

  wifiStaNode.Create (1);

Lines 88-125	Link Here

  WifiHelper wifi = WifiHelper::Default ();

  WifiHelper wifi = WifiHelper::Default ();

  wifi.SetStandard (WIFI_PHY_STANDARD_80211n_5GHZ);

  wifi.SetStandard (WIFI_PHY_STANDARD_80211n_5GHZ);

  wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager", "DataMode", StringValue ("HtMcs7"), "ControlMode", StringValue ("HtMcs0"));

100

  wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager", "DataMode", StringValue ("HtMcs7"), "ControlMode", StringValue ("HtMcs0"));

101

  QosWifiMacHelper mac = QosWifiMacHelper::Default ();

102

  QosWifiMacHelper mac = QosWifiMacHelper::Default ();

103

  Ssid ssid = Ssid ("simple-mpdu-aggregation");

104

  NetDeviceContainer staDevice, apDevice;

105

  Ssid ssid = Ssid ("simple-mpdu-aggregation");

  mac.SetType ("ns3::StaWifiMac",

106

  mac.SetType ("ns3::StaWifiMac",

               "Ssid", SsidValue (ssid),

107

               "Ssid", SsidValue (ssid),

               "ActiveProbing", BooleanValue (false));

108

               "ActiveProbing", BooleanValue (false),

109

               "BE_BlockAckThreshold", UintegerValue (blockAckThreshold),

  if (nMpdus > 1)

110

               "BE_MaxAmpduSize", UintegerValue (maxAmpduSize));

100

      mac.SetBlockAckThresholdForAc (AC_BE, 2);             //enable Block ACK when A-MPDU is enabled (i.e. nMpdus > 1)

101

102

103

  mac.SetMpduAggregatorForAc (AC_BE,"ns3::MpduStandardAggregator",

104

                              "MaxAmpduSize", UintegerValue (nMpdus * (payloadSize + 100))); //enable MPDU aggregation for AC_BE with a maximum aggregated size of nMpdus*(payloadSize+100) bytes, i.e. nMpdus aggregated packets in an A-MPDU

105

106

  NetDeviceContainer staDevice;

107

  staDevice = wifi.Install (phy, mac, wifiStaNode);

111

  staDevice = wifi.Install (phy, mac, wifiStaNode);

108

112

109

  mac.SetType ("ns3::ApWifiMac",

113

  mac.SetType ("ns3::ApWifiMac",

110

               "Ssid", SsidValue (ssid),

114

               "Ssid", SsidValue (ssid),

111

               "BeaconInterval", TimeValue (MicroSeconds (102400)),

115

               "BeaconInterval", TimeValue (MicroSeconds (102400)),

112

               "BeaconGeneration", BooleanValue (true));

116

               "BeaconGeneration", BooleanValue (true),

113

117

               "BE_BlockAckThreshold", UintegerValue (blockAckThreshold),

114

  if (nMpdus > 1)

118

               "BE_MaxAmpduSize", UintegerValue (maxAmpduSize));

115

116

      mac.SetBlockAckThresholdForAc (AC_BE, 2);             //enable Block ACK when A-MPDU is enabled (i.e. nMpdus > 1)

117

118

119

  mac.SetMpduAggregatorForAc (AC_BE,"ns3::MpduStandardAggregator",

120

                              "MaxAmpduSize", UintegerValue (nMpdus * (payloadSize + 100))); //enable MPDU aggregation for AC_BE with a maximum aggregated size of nMpdus*(payloadSize+100) bytes, i.e. nMpdus aggregated packets in an A-MPDU

121

122

  NetDeviceContainer apDevice;

123

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

119

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

124

120

125

  /* Setting mobility model */

121

  /* Setting mobility model */

(-)a/examples/wireless/simple-msdu-aggregation.cc (-13 / +11 lines)

Lines 74-79	Link Here

  Config::SetDefault ("ns3::WifiRemoteStationManager::FragmentationThreshold", StringValue ("990000"));

  Config::SetDefault ("ns3::WifiRemoteStationManager::FragmentationThreshold", StringValue ("990000"));

  uint32_t maxAmsduSize = nMsdus * (payloadSize + 100);

  NodeContainer wifiStaNode;

  NodeContainer wifiStaNode;

  wifiStaNode.Create (1);

  wifiStaNode.Create (1);

Lines 88-113	Link Here

  WifiHelper wifi = WifiHelper::Default ();

  WifiHelper wifi = WifiHelper::Default ();

  wifi.SetStandard (WIFI_PHY_STANDARD_80211n_5GHZ);

  wifi.SetStandard (WIFI_PHY_STANDARD_80211n_5GHZ);

  wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager", "DataMode", StringValue ("HtMcs7"), "ControlMode", StringValue ("HtMcs0"));

  wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager", "DataMode", StringValue ("HtMcs7"), "ControlMode", StringValue ("HtMcs0"));

  QosWifiMacHelper mac = QosWifiMacHelper::Default ();

  QosWifiMacHelper mac = QosWifiMacHelper::Default ();

  Ssid ssid = Ssid ("simple-msdu-aggregation");

  Ssid ssid = Ssid ("simple-msdu-aggregation");

  NetDeviceContainer staDevice, apDevice;

  mac.SetType ("ns3::StaWifiMac",

  mac.SetType ("ns3::StaWifiMac",

               "Ssid", SsidValue (ssid),

               "Ssid", SsidValue (ssid),

               "ActiveProbing", BooleanValue (false));

100

               "ActiveProbing", BooleanValue (false),

101

  //enable MSDU aggregation for AC_BE with a maximum aggregated size of nMsdus*(payloadSize+100) bytes, i.e. nMsdus aggregated packets in an A-MSDU

  mac.SetMsduAggregatorForAc (AC_BE, "ns3::MsduStandardAggregator",

102

               "BE_MaxAmsduSize", UintegerValue (maxAmsduSize));

                              "MaxAmsduSize", UintegerValue (nMsdus * (payloadSize + 100))); //enable MSDU aggregation for AC_BE with a maximum aggregated size of nMsdus*(payloadSize+100) bytes, i.e. nMsdus aggregated packets in an A-MSDU

100

101

  NetDeviceContainer staDevice;

102

  staDevice = wifi.Install (phy, mac, wifiStaNode);

103

  staDevice = wifi.Install (phy, mac, wifiStaNode);

103

104

  mac.SetType ("ns3::ApWifiMac",

105

  mac.SetType ("ns3::ApWifiMac",

105

               "Ssid", SsidValue (ssid));

106

               "Ssid", SsidValue (ssid),

106

107

  //enable MSDU aggregation for AC_BE with a maximum aggregated size of nMsdus*(payloadSize+100) bytes, i.e. nMsdus aggregated packets in an A-MSDU

107

  mac.SetMsduAggregatorForAc (AC_BE, "ns3::MsduStandardAggregator",

108

               "BE_MaxAmsduSize", UintegerValue (maxAmsduSize));

108

                              "MaxAmsduSize", UintegerValue (nMsdus * (payloadSize + 100))); //enable MSDU aggregation for AC_BE with a maximum aggregated size of nMsdus*(payloadSize+100) bytes, i.e. nMsdus aggregated packets in an A-MSDU

109

110

  NetDeviceContainer apDevice;

111

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

109

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

112

110

113

  /* Setting mobility model */

111

  /* Setting mobility model */

(-)a/examples/wireless/simple-two-level-aggregation.cc (-45 / +32 lines)

Lines 67-72	Link Here

  uint64_t simulationTime = 10; //seconds

  uint64_t simulationTime = 10; //seconds

  uint32_t nMsdus = 1;

  uint32_t nMsdus = 1;

  uint32_t nMpdus = 1;

  uint32_t nMpdus = 1;

  uint16_t blockAckThreshold = 0;

  uint32_t maxAmsduSize = 0;

  uint32_t maxAmpduSize = 0;

  bool enableRts = 0;

  bool enableRts = 0;

  CommandLine cmd;

  CommandLine cmd;

Lines 87-92	Link Here

  Config::SetDefault ("ns3::WifiRemoteStationManager::FragmentationThreshold", StringValue ("990000"));

  Config::SetDefault ("ns3::WifiRemoteStationManager::FragmentationThreshold", StringValue ("990000"));

  if (nMpdus > 1)

     //enable BlockAck when A-MPDU is used

      blockAckThreshold = 2;

  if (nMsdus > 0)

100

101

      //Set the maximum size for A-MPDU with regards to the payload size and the number of MSDUs expected in each MPDU.

102

      maxAmpduSize = nMpdus * (nMsdus * (payloadSize + 100));

103

104

  else

105

106

      //Set the maximum size for A-MPDU with regards to the payload size

107

      maxAmpduSize = nMpdus * (payloadSize + 200);

108

109

  //Set the maximum size for A-MSDU with regards to the payload size

110

  maxAmsduSize = nMsdus * (payloadSize + 100);

111

  NodeContainer wifiStaNode;

112

  NodeContainer wifiStaNode;

  wifiStaNode.Create (1);

113

  wifiStaNode.Create (1);

Lines 104-163	Link Here

104

  wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager",

125

  wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager",

105

                                "DataMode", StringValue ("HtMcs7"),

126

                                "DataMode", StringValue ("HtMcs7"),

106

                                "ControlMode", StringValue ("HtMcs0"));

127

                                "ControlMode", StringValue ("HtMcs0"));

128

107

  QosWifiMacHelper mac = QosWifiMacHelper::Default ();

129

  QosWifiMacHelper mac = QosWifiMacHelper::Default ();

130

  Ssid ssid = Ssid ("simple-two-level-aggregation");

131

  NetDeviceContainer staDevice, apDevice;

108

132

109

  Ssid ssid = Ssid ("simple-two-level-aggregation");

110

  mac.SetType ("ns3::StaWifiMac",

133

  mac.SetType ("ns3::StaWifiMac",

111

               "Ssid", SsidValue (ssid),

134

               "Ssid", SsidValue (ssid),

112

               "ActiveProbing", BooleanValue (false));

135

               "ActiveProbing", BooleanValue (false),

113

136

               "BE_BlockAckThreshold", UintegerValue (blockAckThreshold),

114

137

               "BE_MaxAmsduSize", UintegerValue (maxAmsduSize),

115

  //Enable aggregation at the station side

138

               "BE_MaxAmpduSize", UintegerValue (maxAmpduSize));

116

  if (nMpdus > 1)

117

118

      mac.SetBlockAckThresholdForAc (AC_BE, 2); //enable BlockAck when A-MPDU is used

119

120

  if (nMsdus > 0)

121

122

      mac.SetMpduAggregatorForAc (AC_BE,"ns3::MpduStandardAggregator",

123

                                  "MaxAmpduSize", UintegerValue (nMpdus * (nMsdus * (payloadSize + 100)))); //Set the maximum size for A-MPDU with regards to the payload size and the number of MSDUs expected in each MPDU.

124

125

  else //MPDU aggregation only (one-level aggregation)

126

127

      mac.SetMpduAggregatorForAc (AC_BE,"ns3::MpduStandardAggregator",

128

                                  "MaxAmpduSize", UintegerValue (nMpdus * (payloadSize + 200))); //Set the maximum size for A-MPDU with regards to the payload size

129

130

  mac.SetMsduAggregatorForAc (AC_BE,"ns3::MsduStandardAggregator",

131

                              "MaxAmsduSize", UintegerValue (nMsdus * (payloadSize + 100))); //Set the maximum size for A-MSDU with regards to the payload size

132

133

134

  NetDeviceContainer staDevice;

135

  staDevice = wifi.Install (phy, mac, wifiStaNode);

139

  staDevice = wifi.Install (phy, mac, wifiStaNode);

136

140

137

  mac.SetType ("ns3::ApWifiMac",

141

  mac.SetType ("ns3::ApWifiMac",

138

               "Ssid", SsidValue (ssid),

142

               "Ssid", SsidValue (ssid),

139

               "BeaconInterval", TimeValue (MicroSeconds (102400)),

143

               "BeaconInterval", TimeValue (MicroSeconds (102400)),

140

               "BeaconGeneration", BooleanValue (true));

144

               "BeaconGeneration", BooleanValue (true),

141

145

               "BE_BlockAckThreshold", UintegerValue (blockAckThreshold),

142

  //Enable aggregation at the AP side

146

               "BE_MaxAmsduSize", UintegerValue (maxAmsduSize),

143

  if (nMpdus > 1)

147

               "BE_MaxAmpduSize", UintegerValue (maxAmpduSize));

144

145

      mac.SetBlockAckThresholdForAc (AC_BE, 2); //enable BlockAck when A-MPDU is used

146

147

  if (nMsdus > 0)

148

149

      mac.SetMpduAggregatorForAc (AC_BE,"ns3::MpduStandardAggregator",

150

                                  "MaxAmpduSize", UintegerValue (nMpdus * (nMsdus * (payloadSize + 100)))); //Set the maximum size for A-MPDU according to the payload size and the number of MSDUs expected in each MPDU.

151

152

  else //MPDU aggregation only (one-level aggregation)

153

154

      mac.SetMpduAggregatorForAc (AC_BE,"ns3::MpduStandardAggregator",

155

                                  "MaxAmpduSize", UintegerValue (nMpdus * (payloadSize + 200))); //Set the maximum size for A-MPDU with regards to the payload size

156

157

  mac.SetMsduAggregatorForAc (AC_BE,"ns3::MsduStandardAggregator",

158

                              "MaxAmsduSize", UintegerValue (nMsdus * (payloadSize + 100))); //Set the maximum size for A-MSDU with regards to the payload size

159

160

  NetDeviceContainer apDevice;

161

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

148

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

162

149

163

  /* Setting mobility model */

150

  /* Setting mobility model */





  mac.SetType ("ns3::StaWifiMac",
               "Ssid", SsidValue (ssid),
               "ActiveProbing", BooleanValue (false),
  /* setting blockack threshold for sta's BE queue */
               "BE_BlockAckThreshold", UintegerValue (2),
  /* setting block inactivity timeout to 3*1024 = 3072 microseconds */
               "BE_BlockAckInactivityTimeout", UintegerValue (3));
  NetDeviceContainer staDevice = wifi.Install (phy, mac, sta);

  mac.SetType ("ns3::ApWifiMac",
               "Ssid", SsidValue (ssid),
               "BE_BlockAckThreshold", UintegerValue (0));
  NetDeviceContainer apDevice = wifi.Install (phy, mac, ap);

  /* Setting mobility model */

(-)a/src/test/ns3wifi/wifi-msdu-aggregator-test-suite.cc (-3 / +2 lines)

Lines 87-95	Link Here

  wifiMac.SetType ("ns3::ApWifiMac",

  wifiMac.SetType ("ns3::ApWifiMac",

                   "Ssid", SsidValue (ssid),

                   "Ssid", SsidValue (ssid),

                   "BeaconGeneration", BooleanValue (true),

                   "BeaconGeneration", BooleanValue (true),

                   "BeaconInterval", TimeValue (MicroSeconds (102400)));

                   "BeaconInterval", TimeValue (MicroSeconds (102400)),

  wifiMac.SetMsduAggregatorForAc (AC_BE, "ns3::MsduStandardAggregator",

                   "BE_MaxAmsduSize", UintegerValue (4000));

                                  "MaxAmsduSize", UintegerValue (4000));

  NetDeviceContainer apDev = wifi.Install (wifiPhy, wifiMac, ap);

  NetDeviceContainer apDev = wifi.Install (wifiPhy, wifiMac, ap);

  // Setup one STA, which will be the sink for traffic in this test.

  // Setup one STA, which will be the sink for traffic in this test.

(-)a/src/wave/helper/wave-mac-helper.cc (-2 / +8 lines)

Lines 100-106	Link Here

100

                           std::string n4, const AttributeValue &v4,

100

                           std::string n4, const AttributeValue &v4,

101

                           std::string n5, const AttributeValue &v5,

101

                           std::string n5, const AttributeValue &v5,

102

                           std::string n6, const AttributeValue &v6,

102

                           std::string n6, const AttributeValue &v6,

103

                           std::string n7, const AttributeValue &v7)

103

                           std::string n7, const AttributeValue &v7,

104

                           std::string n8, const AttributeValue &v8,

105

                           std::string n9, const AttributeValue &v9,

106

                           std::string n10, const AttributeValue &v10)

104

107

105

  if (type.compare ("ns3::OcbWifiMac") != 0)

108

  if (type.compare ("ns3::OcbWifiMac") != 0)

106

109

Lines 114-120	Link Here

114

                             n4, v4,

117

                             n4, v4,

115

                             n5, v5,

118

                             n5, v5,

116

                             n6, v6,

119

                             n6, v6,

117

                             n7, v7);

120

                             n7, v7,

121

                             n8, v8,

122

                             n9, v9,

123

                             n10, v10);

118

124

119

125

120

} // namespace ns3

126

} // namespace ns3

(-)a/src/wave/helper/wave-mac-helper.h (-1 / +10 lines)

Lines 119-124	Link Here

119

   * \param v6 the value of the attribute to set

119

   * \param v6 the value of the attribute to set

120

   * \param n7 the name of the attribute to set

120

   * \param n7 the name of the attribute to set

121

   * \param v7 the value of the attribute to set

121

   * \param v7 the value of the attribute to set

122

   * \param n8 the value of the attribute to set

123

   * \param v8 the value of the attribute to set

124

   * \param n9 the value of the attribute to set

125

   * \param v9 the value of the attribute to set

126

   * \param n10 the value of the attribute to set

127

   * \param v10 the value of the attribute to set

122

128

123

   * All the attributes specified in this method should exist

129

   * All the attributes specified in this method should exist

124

   * in the requested mac.

130

   * in the requested mac.

Lines 134-140	Link Here

134

                        std::string n4 = "", const AttributeValue &v4 = EmptyAttributeValue (),

140

                        std::string n4 = "", const AttributeValue &v4 = EmptyAttributeValue (),

135

                        std::string n5 = "", const AttributeValue &v5 = EmptyAttributeValue (),

141

                        std::string n5 = "", const AttributeValue &v5 = EmptyAttributeValue (),

136

                        std::string n6 = "", const AttributeValue &v6 = EmptyAttributeValue (),

142

                        std::string n6 = "", const AttributeValue &v6 = EmptyAttributeValue (),

137

                        std::string n7 = "", const AttributeValue &v7 = EmptyAttributeValue ());

143

                        std::string n7 = "", const AttributeValue &v7 = EmptyAttributeValue (),

144

                        std::string n8 = "", const AttributeValue &v8 = EmptyAttributeValue (),

145

                        std::string n9 = "", const AttributeValue &v9 = EmptyAttributeValue (),

146

                        std::string n10 = "", const AttributeValue &v10 = EmptyAttributeValue ());

138

};

147

};

139

148

140

149

(-)a/src/wifi/helper/qos-wifi-mac-helper.cc (-97 / +7 lines)

Lines 19-32	Link Here

*/

*/

#include "qos-wifi-mac-helper.h"

#include "qos-wifi-mac-helper.h"

#include "ns3/msdu-aggregator.h"

#include "ns3/wifi-mac.h"

#include "ns3/wifi-mac.h"

#include "ns3/edca-txop-n.h"

#include "ns3/pointer.h"

#include "ns3/pointer.h"

#include "ns3/boolean.h"

#include "ns3/boolean.h"

#include "ns3/uinteger.h"

#include "ns3/mpdu-aggregator.h"

#include "ns3/mac-low.h"

namespace ns3 {

namespace ns3 {

Lines 61-67	Link Here

                           std::string n4, const AttributeValue &v4,

                           std::string n4, const AttributeValue &v4,

                           std::string n5, const AttributeValue &v5,

                           std::string n5, const AttributeValue &v5,

                           std::string n6, const AttributeValue &v6,

                           std::string n6, const AttributeValue &v6,

                           std::string n7, const AttributeValue &v7)

                           std::string n7, const AttributeValue &v7,

                           std::string n8, const AttributeValue &v8,

                           std::string n9, const AttributeValue &v9,

                           std::string n10, const AttributeValue &v10)

  m_mac.SetTypeId (type);

  m_mac.SetTypeId (type);

  m_mac.Set (n0, v0);

  m_mac.Set (n0, v0);

Lines 72-174	Link Here

  m_mac.Set (n5, v5);

  m_mac.Set (n5, v5);

  m_mac.Set (n6, v6);

  m_mac.Set (n6, v6);

  m_mac.Set (n7, v7);

  m_mac.Set (n7, v7);

  m_mac.Set (n8, v8);

  m_mac.Set (n9, v9);

void

  m_mac.Set (n10, v10);

QosWifiMacHelper::SetMsduAggregatorForAc (AcIndex ac, std::string type,

                                          std::string n0, const AttributeValue &v0,

                                          std::string n1, const AttributeValue &v1,

                                          std::string n2, const AttributeValue &v2,

                                          std::string n3, const AttributeValue &v3)

  std::map<AcIndex, ObjectFactory>::iterator it = m_aggregators.find (ac);

  if (it != m_aggregators.end ())

      it->second.SetTypeId (type);

      it->second.Set (n0, v0);

      it->second.Set (n1, v1);

      it->second.Set (n2, v2);

      it->second.Set (n3, v3);

  else

      ObjectFactory factory;

      factory.SetTypeId (type);

      factory.Set (n0, v0);

      factory.Set (n1, v1);

      factory.Set (n2, v2);

100

      factory.Set (n3, v3);

101

      m_aggregators.insert (std::make_pair (ac, factory));

102

103

104

105

void

106

QosWifiMacHelper::SetMpduAggregatorForAc (enum AcIndex ac, std::string name,

107

                                          std::string n0, const AttributeValue &v0,

108

                                          std::string n1, const AttributeValue &v1,

109

                                          std::string n2, const AttributeValue &v2,

110

                                          std::string n3, const AttributeValue &v3)

111

112

  m_mpduAggregator = ObjectFactory ();

113

  m_mpduAggregator.SetTypeId (name);

114

  m_mpduAggregator.Set (n0, v0);

115

  m_mpduAggregator.Set (n1, v1);

116

  m_mpduAggregator.Set (n2, v2);

117

  m_mpduAggregator.Set (n3, v3);

118

119

120

void

121

QosWifiMacHelper::SetBlockAckThresholdForAc (enum AcIndex ac, uint8_t threshold)

122

123

  m_bAckThresholds[ac] = threshold;

124

125

126

void

127

QosWifiMacHelper::SetBlockAckInactivityTimeoutForAc (enum AcIndex ac, uint16_t timeout)

128

129

  m_bAckInactivityTimeouts[ac] = timeout;

130

131

132

void

133

QosWifiMacHelper::Setup (Ptr<WifiMac> mac, enum AcIndex ac, std::string dcaAttrName) const

134

135

  std::map<AcIndex, ObjectFactory>::const_iterator it = m_aggregators.find (ac);

136

  PointerValue ptr;

137

  mac->GetAttribute (dcaAttrName, ptr);

138

  Ptr<EdcaTxopN> edca = ptr.Get<EdcaTxopN> ();

139

140

  if (m_mpduAggregator.GetTypeId ().GetUid () != 0)

141

142

      Ptr<MpduAggregator> mpduaggregator = m_mpduAggregator.Create<MpduAggregator> ();

143

      Ptr<MacLow> low = edca->Low ();

144

      low->SetMpduAggregator (mpduaggregator);

145

146

  if (it != m_aggregators.end ())

147

148

      ObjectFactory factory = it->second;

149

      Ptr<MsduAggregator> aggregator = factory.Create<MsduAggregator> ();

150

      edca->SetMsduAggregator (aggregator);

151

152

  if (m_bAckThresholds.find (ac) != m_bAckThresholds.end ())

153

154

      edca->SetBlockAckThreshold (m_bAckThresholds.find (ac)->second);

155

156

  if (m_bAckInactivityTimeouts.find (ac) != m_bAckInactivityTimeouts.end ())

157

158

      edca->SetBlockAckInactivityTimeout (m_bAckInactivityTimeouts.find (ac)->second);

159

160

161

162

Ptr<WifiMac>

Ptr<WifiMac>

163

QosWifiMacHelper::Create (void) const

QosWifiMacHelper::Create (void) const

164

165

  Ptr<WifiMac> mac = m_mac.Create<WifiMac> ();

  Ptr<WifiMac> mac = m_mac.Create<WifiMac> ();

166

167

  Setup (mac, AC_VO, "VO_EdcaTxopN");

168

  Setup (mac, AC_VI, "VI_EdcaTxopN");

169

  Setup (mac, AC_BE, "BE_EdcaTxopN");

170

  Setup (mac, AC_BK, "BK_EdcaTxopN");

171

172

  return mac;

  return mac;

173

174




   * \param n6 the name of the attribute to set
   * \param v6 the value of the attribute to set
   * \param n7 the name of the attribute to set
   * \param v7 the name of the attribute to set
   * \param n8 the value of the attribute to set
   * \param v8 the value of the attribute to set
   * \param n9 the value of the attribute to set
   * \param v9 the value of the attribute to set
   * \param n10 the value of the attribute to set
   * \param v10 the value of the attribute to set
   *
   * All the attributes specified in this method should exist
   * in the requested mac.

                        std::string n4 = "", const AttributeValue &v4 = EmptyAttributeValue (),
                        std::string n5 = "", const AttributeValue &v5 = EmptyAttributeValue (),
                        std::string n6 = "", const AttributeValue &v6 = EmptyAttributeValue (),
                        std::string n7 = "", const AttributeValue &v7 = EmptyAttributeValue (),
                        std::string n8 = "", const AttributeValue &v8 = EmptyAttributeValue (),
                        std::string n9 = "", const AttributeValue &v9 = EmptyAttributeValue (),
                        std::string n10 = "", const AttributeValue &v10 = EmptyAttributeValue ());
   * \param ac access category for which we are setting aggregator.
   *        Possibilities are: AC_BK, AC_BE, AC_VI, AC_VO.
   * \param type the type of ns3::MsduAggregator to create.
   * \param n0 the name of the attribute to set
   * \param v0 the value of the attribute to set
   * \param n1 the name of the attribute to set
   * \param v1 the value of the attribute to set
   * \param n2 the name of the attribute to set
   * \param v2 the value of the attribute to set
   * \param n3 the name of the attribute to set
   * \param v3 the value of the attribute to set
   *
   * All the attributes specified in this method should exist
   * in the requested aggregator.
   */
  void SetMsduAggregatorForAc (AcIndex ac, std::string type,
                               std::string n0 = "", const AttributeValue &v0 = EmptyAttributeValue (),
                               std::string n1 = "", const AttributeValue &v1 = EmptyAttributeValue (),
                               std::string n2 = "", const AttributeValue &v2 = EmptyAttributeValue (),
                               std::string n3 = "", const AttributeValue &v3 = EmptyAttributeValue ());
  /**
   * Set the class, type and attributes for the Mpdu aggregator
   *
   * \param ac access category for which we are setting aggregator.
   *        Possibilities are: AC_BK, AC_BE, AC_VI, AC_VO.
   * \param type the type of ns3::MsduAggregator to create.
   * \param n0 the name of the attribute to set
   * \param v0 the value of the attribute to set
   * \param n1 the name of the attribute to set
   * \param v1 the value of the attribute to set
   * \param n2 the name of the attribute to set
   * \param v2 the value of the attribute to set
   * \param n3 the name of the attribute to set
   * \param v3 the value of the attribute to set
   *
   * All the attributes specified in this method should exist
   * in the requested aggregator.
   */
  void SetMpduAggregatorForAc (enum AcIndex ac, std::string type,
                               std::string n0 = "", const AttributeValue &v0 = EmptyAttributeValue (),
                               std::string n1 = "", const AttributeValue &v1 = EmptyAttributeValue (),
                               std::string n2 = "", const AttributeValue &v2 = EmptyAttributeValue (),
                               std::string n3 = "", const AttributeValue &v3 = EmptyAttributeValue ());
  /**
   * This method sets value of block ack threshold for a specific access class.
   * If number of packets in the respective queue reaches this value block ack mechanism
   * is used.
   *
   * \param ac access category for which we are setting block ack threshold.
   *        Possibilities are: AC_BK, AC_BE, AC_VI, AC_VO.
   * \param threshold the threshold (number of packets)
   */
  void SetBlockAckThresholdForAc (enum AcIndex ac, uint8_t threshold);
  /**
   * Sets value of block ack inactivity timeout for a specific access class. <i>timeout</i>
   * represents number of blocks of 1024 microseconds. When this timer expires the relative
   * block ack agreement is teared down. Timer is reset in an recipient station every time
   * that a block ack request or a MPDU with ack policy BLOCK ACK is received.
   * Timer is reset in a originator station every time that a block ack frame is received.
   *
   * \param ac access category for which we are setting block ack threshold.
   *        Possibilities are: AC_BK, AC_BE, AC_VI, AC_VO.
   * \param timeout number of block of 1024 microseconds.
   */
  void SetBlockAckInactivityTimeoutForAc (enum AcIndex ac, uint16_t timeout);


protected:

   * This method implements the pure virtual method defined in \ref ns3::WifiMacHelper.
   */
  virtual Ptr<WifiMac> Create (void) const;
  void Setup (Ptr<WifiMac> mac, enum AcIndex ac, std::string dcaAttrName) const;

  std::map<AcIndex, ObjectFactory> m_aggregators;
  ObjectFactory m_mpduAggregator;
  /*
   * Next maps contain, for every access category, the values for
   * block ack threshold and block ack inactivity timeout.
   */
  std::map<AcIndex, uint8_t> m_bAckThresholds;
  std::map<AcIndex, uint16_t> m_bAckInactivityTimeouts;
};

} //namespace ns3

(-)a/src/wifi/model/edca-txop-n.cc (-23 / +28 lines)

Lines 32-37	Link Here

#include "random-stream.h"

#include "random-stream.h"

#include "wifi-mac-queue.h"

#include "wifi-mac-queue.h"

#include "msdu-aggregator.h"

#include "msdu-aggregator.h"

#include "mpdu-aggregator.h"

#include "mgt-headers.h"

#include "mgt-headers.h"

#include "qos-blocked-destinations.h"

#include "qos-blocked-destinations.h"

Lines 203-208	Link Here

203

204

    return m_txop->GetMsduAggregator ();

205

    return m_txop->GetMsduAggregator ();

205

206

207

  virtual Ptr<MpduAggregator> GetMpduAggregator (void) const

208

209

    return m_txop->GetMpduAggregator ();

210

206

  virtual Mac48Address GetSrcAddressForAggregation (const WifiMacHeader &hdr)

211

  virtual Mac48Address GetSrcAddressForAggregation (const WifiMacHeader &hdr)

207

212

208

    return m_txop->MapSrcAddressForAggregation (hdr);

213

    return m_txop->MapSrcAddressForAggregation (hdr);

Lines 225-245	Link Here

225

    .SetParent<ns3::Dcf> ()

230

    .SetParent<ns3::Dcf> ()

226

    .SetGroupName ("Wifi")

231

    .SetGroupName ("Wifi")

227

    .AddConstructor<EdcaTxopN> ()

232

    .AddConstructor<EdcaTxopN> ()

228

    .AddAttribute ("BlockAckThreshold",

229

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

230

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

231

                   UintegerValue (0),

232

                   MakeUintegerAccessor (&EdcaTxopN::SetBlockAckThreshold,

233

                                         &EdcaTxopN::GetBlockAckThreshold),

234

                   MakeUintegerChecker<uint8_t> (0, 64))

235

    .AddAttribute ("BlockAckInactivityTimeout",

236

                   "Represents max time (blocks of 1024 micro seconds) allowed for block ack"

237

                   "inactivity. If this value isn't equal to 0 a timer start after that a"

238

                   "block ack setup is completed and will be reset every time that a block"

239

                   "ack frame is received. If this value is 0, block ack inactivity timeout won't be used.",

240

                   UintegerValue (0),

241

                   MakeUintegerAccessor (&EdcaTxopN::SetBlockAckInactivityTimeout),

242

                   MakeUintegerChecker<uint16_t> ())

243

    .AddAttribute ("Queue",

233

    .AddAttribute ("Queue",

244

                   "The WifiMacQueue object",

234

                   "The WifiMacQueue object",

245

                   PointerValue (),

235

                   PointerValue (),

Lines 252-258	Link Here

252

EdcaTxopN::EdcaTxopN ()

242

EdcaTxopN::EdcaTxopN ()

253

  : m_manager (0),

243

  : m_manager (0),

254

    m_currentPacket (0),

244

    m_currentPacket (0),

255

    m_aggregator (0),

245

    m_msduAggregator (0),

246

    m_mpduAggregator (0),

256

    m_typeOfStation (STA),

247

    m_typeOfStation (STA),

257

    m_blockAckType (COMPRESSED_BLOCK_ACK),

248

    m_blockAckType (COMPRESSED_BLOCK_ACK),

258

    m_ampduExist (false)

249

    m_ampduExist (false)

Lines 299-305	Link Here

299

  m_baManager = 0;

290

  m_baManager = 0;

300

  m_blockAckListener = 0;

291

  m_blockAckListener = 0;

301

  m_txMiddle = 0;

292

  m_txMiddle = 0;

302

  m_aggregator = 0;

293

  m_msduAggregator = 0;

294

  m_mpduAggregator = 0;

303

295

304

296

305

bool

297

bool

Lines 581-591	Link Here

581

              && m_queue->PeekByTidAndAddress (&peekedHdr, m_currentHdr.GetQosTid (),

573

              && m_queue->PeekByTidAndAddress (&peekedHdr, m_currentHdr.GetQosTid (),

582

                                               WifiMacHeader::ADDR1, m_currentHdr.GetAddr1 (), &tstamp)

574

                                               WifiMacHeader::ADDR1, m_currentHdr.GetAddr1 (), &tstamp)

583

              && !m_currentHdr.GetAddr1 ().IsBroadcast ()

575

              && !m_currentHdr.GetAddr1 ().IsBroadcast ()

584

              && m_aggregator != 0 && !m_currentHdr.IsRetry ())

576

              && m_msduAggregator != 0 && !m_currentHdr.IsRetry ())

585

577

586

              /* here is performed aggregation */

578

              /* here is performed aggregation */

587

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

579

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

588

              m_aggregator->Aggregate (m_currentPacket, currentAggregatedPacket,

580

              m_msduAggregator->Aggregate (m_currentPacket, currentAggregatedPacket,

589

                                       MapSrcAddressForAggregation (peekedHdr),

581

                                       MapSrcAddressForAggregation (peekedHdr),

590

                                       MapDestAddressForAggregation (peekedHdr));

582

                                       MapDestAddressForAggregation (peekedHdr));

591

              bool aggregated = false;

583

              bool aggregated = false;

Lines 595-601	Link Here

595

                                                                             m_currentHdr.GetAddr1 (), &tstamp);

587

                                                                             m_currentHdr.GetAddr1 (), &tstamp);

596

              while (peekedPacket != 0)

588

              while (peekedPacket != 0)

597

589

598

                  aggregated = m_aggregator->Aggregate (peekedPacket, currentAggregatedPacket,

590

                  aggregated = m_msduAggregator->Aggregate (peekedPacket, currentAggregatedPacket,

599

                                                        MapSrcAddressForAggregation (peekedHdr),

591

                                                        MapSrcAddressForAggregation (peekedHdr),

600

                                                        MapDestAddressForAggregation (peekedHdr));

592

                                                        MapDestAddressForAggregation (peekedHdr));

601

                  if (aggregated)

593

                  if (aggregated)

Lines 957-963	Link Here

957

Ptr<MsduAggregator>

949

Ptr<MsduAggregator>

958

EdcaTxopN::GetMsduAggregator (void) const

950

EdcaTxopN::GetMsduAggregator (void) const

959

951

960

  return m_aggregator;

952

  return m_msduAggregator;

953

954

955

Ptr<MpduAggregator>

956

EdcaTxopN::GetMpduAggregator (void) const

957

958

  return m_mpduAggregator;

961

959

962

960

963

void

961

void

Lines 1189-1195	Link Here

1189

EdcaTxopN::SetMsduAggregator (Ptr<MsduAggregator> aggr)

1187

EdcaTxopN::SetMsduAggregator (Ptr<MsduAggregator> aggr)

1190

1188

1191

  NS_LOG_FUNCTION (this << aggr);

1189

  NS_LOG_FUNCTION (this << aggr);

1192

  m_aggregator = aggr;

1190

  m_msduAggregator = aggr;

1191

1192

1193

void

1194

EdcaTxopN::SetMpduAggregator (Ptr<MpduAggregator> aggr)

1195

1196

  NS_LOG_FUNCTION (this << aggr);

1197

  m_mpduAggregator = aggr;

1193

1198

1194

1199

1195

void

1200

void

Lines 1261-1267	Link Here

1261

1266

1262

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

1267

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

1263

1268

1264

  if ((m_baManager->ExistsAgreementInState (recipient, tid, OriginatorBlockAckAgreement::ESTABLISHED)) && (m_low->GetMpduAggregator () == 0))

1269

  if ((m_baManager->ExistsAgreementInState (recipient, tid, OriginatorBlockAckAgreement::ESTABLISHED)) && (GetMpduAggregator ()->GetMaxAmpduSize () == 0))

1265

1270

1266

      m_currentHdr.SetQosAckPolicy (WifiMacHeader::BLOCK_ACK);

1271

      m_currentHdr.SetQosAckPolicy (WifiMacHeader::BLOCK_ACK);

1267

1272

(-)a/src/wifi/model/edca-txop-n.h (-1 / +6 lines)

Lines 47-52	Link Here

class RandomStream;

class RandomStream;

class QosBlockedDestinations;

class QosBlockedDestinations;

class MsduAggregator;

class MsduAggregator;

class MpduAggregator;

class MgtAddBaResponseHeader;

class MgtAddBaResponseHeader;

class BlockAckManager;

class BlockAckManager;

class MgtDelBaHeader;

class MgtDelBaHeader;

Lines 161-166	Link Here

161

  Ptr<MacLow> Low (void);

162

  Ptr<MacLow> Low (void);

162

163

  Ptr<MsduAggregator> GetMsduAggregator (void) const;

164

  Ptr<MsduAggregator> GetMsduAggregator (void) const;

165

  Ptr<MpduAggregator> GetMpduAggregator (void) const;

166

164

/**

167

/**

165

   * \param recipient address of the peer station

168

   * \param recipient address of the peer station

166

   * \param tid traffic ID.

169

   * \param tid traffic ID.

Lines 379-384	Link Here

379

  void Queue (Ptr<const Packet> packet, const WifiMacHeader &hdr);

382

  void Queue (Ptr<const Packet> packet, const WifiMacHeader &hdr);

380

383

381

  void SetMsduAggregator (Ptr<MsduAggregator> aggr);

384

  void SetMsduAggregator (Ptr<MsduAggregator> aggr);

385

  void SetMpduAggregator (Ptr<MpduAggregator> aggr);

382

386

383

/**

387

/**

384

   * \param packet packet to send

388

   * \param packet packet to send

Lines 543-549	Link Here

543

  Ptr<const Packet> m_currentPacket;

547

  Ptr<const Packet> m_currentPacket;

544

548

545

  WifiMacHeader m_currentHdr;

549

  WifiMacHeader m_currentHdr;

546

  Ptr<MsduAggregator> m_aggregator;

550

  Ptr<MsduAggregator> m_msduAggregator;

551

  Ptr<MpduAggregator> m_mpduAggregator;

547

  TypeOfStation m_typeOfStation;

552

  TypeOfStation m_typeOfStation;

548

  QosBlockedDestinations *m_qosBlockedDestinations;

553

  QosBlockedDestinations *m_qosBlockedDestinations;

549

  BlockAckManager *m_baManager;

554

  BlockAckManager *m_baManager;




#include "yans-wifi-phy.h"
#include "ampdu-tag.h"
#include "wifi-mac-queue.h"
#include "mpdu-standard-aggregator.h"

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

{
  return 0;
}
Ptr<MpduAggregator>
MacLowAggregationCapableTransmissionListener::GetMpduAggregator (void) const
{
  return 0;
}
Mac48Address
MacLowAggregationCapableTransmissionListener::GetSrcAddressForAggregation (const WifiMacHeader &hdr)
{

    m_sendDataEvent (),
    m_waitSifsEvent (),
    m_endTxNoAckEvent (),
    m_mpduAggregator (0),
    m_currentPacket (0),
    m_listener (0),
    m_phyMacLowListener (0),

      delete m_phyMacLowListener;
      m_phyMacLowListener = 0;
    }
  m_mpduAggregator = 0;
  m_sentMpdus = 0;
  m_aggregateQueue = 0;
  m_ampdu = false;

              last = true;
              mpdutype = LAST_MPDU_IN_AGGREGATE;
            }

          uint8_t tid = GetTid (packet, *hdr);
          AcIndex ac = QosUtilsMapTidToAc (tid);
          std::map<AcIndex, MacLowAggregationCapableTransmissionListener*>::const_iterator listenerIt = m_edcaListeners.find (ac);
          listenerIt->second->GetMpduAggregator ()->AddHeaderAndPad (newPacket, last, vhtSingleMpdu);

          if (hdr->IsBlockAckReq ())
            {

}

void
MacLow::SetMpduAggregator (Ptr<MpduAggregator> aggregator)
{
  m_mpduAggregator = aggregator;
}

Ptr<MpduAggregator>
MacLow::GetMpduAggregator (void)
{
  return m_mpduAggregator;
}

void
MacLow::DeaggregateAmpduAndReceive (Ptr<Packet> aggregatedPacket, double rxSnr, WifiTxVector txVector, WifiPreamble preamble)
{
  m_currentTxVector = txVector;

{
  WifiPreamble preamble;
  WifiTxVector dataTxVector = GetDataTxVector (m_currentPacket, &m_currentHdr);

  uint8_t tid = GetTid (peekedPacket, peekedHdr);
  AcIndex ac = QosUtilsMapTidToAc (tid);
  std::map<AcIndex, MacLowAggregationCapableTransmissionListener*>::const_iterator listenerIt = m_edcaListeners.find (ac);

  if (dataTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_VHT)
    {
      preamble = WIFI_PREAMBLE_VHT;

      return true;
    }

  if (!listenerIt->second->GetMpduAggregator ()->CanBeAggregated (peekedPacket->GetSize () + peekedHdr.GetSize () + WIFI_MAC_FCS_LENGTH, aggregatedPacket, size))
    {
      NS_LOG_DEBUG ("no more packets can be aggregated because the maximum A-MPDU size has been reached");
      return true;

      NS_ASSERT (listenerIt != m_edcaListeners.end ());
      queue = listenerIt->second->GetQueue ();

      if (!hdr.GetAddr1 ().IsBroadcast () && listenerIt->second->GetMpduAggregator () != 0)
        {
          //Have to make sure that their exist a block Ack agreement before sending an AMPDU (BlockAck Manager)
          if (listenerIt->second->GetBlockAckAgreementExists (hdr.GetAddr1 (), tid))

                  WifiMacTrailer fcs;
                  newPacket->AddTrailer (fcs);

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

                  if (aggregated)
                    {

                  newPacket->AddHeader (peekedHdr);
                  WifiMacTrailer fcs;
                  newPacket->AddTrailer (fcs);
                  aggregated = listenerIt->second->GetMpduAggregator ()->Aggregate (newPacket, currentAggregatedPacket);
                  if (aggregated)
                    {
                      m_aggregateQueue->Enqueue (aggPacket, peekedHdr);

                      newPacket->AddHeader (peekedHdr);
                      WifiMacTrailer fcs;
                      newPacket->AddTrailer (fcs);
                      listenerIt->second->GetMpduAggregator ()->Aggregate (newPacket, currentAggregatedPacket);
                    }
                  if (qosPolicy == 0)
                    {

              peekedHdr.SetQosAckPolicy (WifiMacHeader::NORMAL_ACK);

              currentAggregatedPacket = Create<Packet> ();
              listenerIt->second->GetMpduAggregator ()->AggregateVhtSingleMpdu (packet, currentAggregatedPacket);
              m_aggregateQueue->Enqueue (packet, peekedHdr);
              m_sentMpdus = 1;





  virtual Ptr<MsduAggregator> GetMsduAggregator (void) const;
  /**
   */
  virtual Ptr<MpduAggregator> GetMpduAggregator (void) const;
  /**
   */
  virtual Mac48Address GetSrcAddressForAggregation (const WifiMacHeader &hdr);
  /**
   */

   */
  void SetWifiRemoteStationManager (Ptr<WifiRemoteStationManager> manager);
  /**
   * Set up MpduAggregator associated with this MacLow.
   *
   * \param aggregator MpduAggregator associated with this MacLow
   */
  void SetMpduAggregator (Ptr<MpduAggregator> aggregator);
  /**
   *
   * \return the attached MpduAggregator
   */
  Ptr<MpduAggregator> GetMpduAggregator (void);
  /**
   * Set MAC address of this MacLow.
   *
   * \param ad Mac48Address of this MacLow

(-)a/src/wifi/model/mpdu-aggregator.h (+3 lines)

Lines 48-53	Link Here

  typedef std::list<std::pair<Ptr<Packet>, AmpduSubframeHeader> >::const_iterator DeaggregatedMpdusCI;

  typedef std::list<std::pair<Ptr<Packet>, AmpduSubframeHeader> >::const_iterator DeaggregatedMpdusCI;

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  virtual void SetMaxAmpduSize (uint32_t maxSize) = 0;

  virtual uint32_t GetMaxAmpduSize (void) const = 0;

/**

/**

   * \param packet Packet we have to insert into <i>aggregatedPacket</i>.

   * \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 aggregatedPacket Packet that will contain <i>packet</i>, if aggregation is possible.




    .SetParent<MpduAggregator> ()
    .SetGroupName ("Wifi")
    .AddConstructor<MpduStandardAggregator> ()
    .AddAttribute ("MaxAmpduSize", "Max length in bytes of an A-MPDU",
                   UintegerValue (65535),
                   MakeUintegerAccessor (&MpduStandardAggregator::m_maxAmpduLength),
                   MakeUintegerChecker<uint32_t> ())
  ;
  return tid;
}

{
}

void
MpduStandardAggregator::SetMaxAmpduSize (uint32_t maxSize)
{
  m_maxAmpduLength = maxSize;
}

uint32_t
MpduStandardAggregator::GetMaxAmpduSize (void) const
{
  return m_maxAmpduLength;
}

bool
MpduStandardAggregator::Aggregate (Ptr<const Packet> packet, Ptr<Packet> aggregatedPacket)
{

(-)a/src/wifi/model/mpdu-standard-aggregator.h (+3 lines)

Lines 36-41	Link Here

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  MpduStandardAggregator ();

  MpduStandardAggregator ();

  ~MpduStandardAggregator ();

  ~MpduStandardAggregator ();

  virtual void SetMaxAmpduSize (uint32_t maxSize);

  virtual uint32_t GetMaxAmpduSize (void) const;

/**

/**

   * \param packet packet we have to insert into <i>aggregatedPacket</i>.

   * \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 aggregatedPacket packet that will contain <i>packet</i>, if aggregation is possible.

(-)a/src/wifi/model/msdu-aggregator.h (+4 lines)

Lines 42-47	Link Here

  typedef std::list<std::pair<Ptr<Packet>, AmsduSubframeHeader> >::const_iterator DeaggregatedMsdusCI;

  typedef std::list<std::pair<Ptr<Packet>, AmsduSubframeHeader> >::const_iterator DeaggregatedMsdusCI;

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  virtual void SetMaxAmsduSize (uint32_t maxSize) = 0;

  virtual uint32_t GetMaxAmsduSize (void) const = 0;

  /* Adds <i>packet</i> to <i>aggregatedPacket</i>. In concrete aggregator's implementation is

  /* 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>

   * 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.

   * can be added returns true, false otherwise.




    .SetParent<MsduAggregator> ()
    .SetGroupName ("Wifi")
    .AddConstructor<MsduStandardAggregator> ()
    .AddAttribute ("MaxAmsduSize", "Max length in byte of an A-MSDU",
                   UintegerValue (7935),
                   MakeUintegerAccessor (&MsduStandardAggregator::m_maxAmsduLength),
                   MakeUintegerChecker<uint32_t> ())
  ;
  return tid;
}

{
}

void
MsduStandardAggregator::SetMaxAmsduSize (uint32_t maxSize)
{
  m_maxAmsduLength = maxSize;
}

uint32_t
MsduStandardAggregator::GetMaxAmsduSize (void) const
{
  return m_maxAmsduLength;
}

bool
MsduStandardAggregator::Aggregate (Ptr<const Packet> packet, Ptr<Packet> aggregatedPacket,
                                   Mac48Address src, Mac48Address dest)

(-)a/src/wifi/model/msdu-standard-aggregator.h (+3 lines)

Lines 36-41	Link Here

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  MsduStandardAggregator ();

  MsduStandardAggregator ();

  ~MsduStandardAggregator ();

  ~MsduStandardAggregator ();

  virtual void SetMaxAmsduSize (uint32_t maxSize);

  virtual uint32_t GetMaxAmsduSize (void) const;

/**

/**

   * \param packet Packet we have to insert into <i>aggregatedPacket</i>.

   * \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 aggregatedPacket Packet that will contain <i>packet</i>, if aggregation is possible,




#include "dcf.h"
#include "dcf-manager.h"
#include "wifi-phy.h"
#include "msdu-standard-aggregator.h"
#include "mpdu-standard-aggregator.h"

namespace ns3 {


}

void
RegularWifiMac::SetVoMaxAmsduSize (uint32_t size)
{
  NS_LOG_FUNCTION (this << size);
  if (m_edca.find (AC_VO)->second->GetMsduAggregator () != 0)
    {
      m_edca.find (AC_VO)->second->GetMsduAggregator ()->SetMaxAmsduSize (size);
    }
}

void
RegularWifiMac::SetViMaxAmsduSize (uint32_t size)
{
  NS_LOG_FUNCTION (this << size);
  if (m_edca.find (AC_VI)->second->GetMsduAggregator () != 0)
    {
      m_edca.find (AC_VI)->second->GetMsduAggregator ()->SetMaxAmsduSize (size);
    }
}

void
RegularWifiMac::SetBeMaxAmsduSize (uint32_t size)
{
  NS_LOG_FUNCTION (this << size);
  if (m_edca.find (AC_BE)->second->GetMsduAggregator () != 0)
    {
      m_edca.find (AC_BE)->second->GetMsduAggregator ()->SetMaxAmsduSize (size);
    }
}

void
RegularWifiMac::SetBkMaxAmsduSize (uint32_t size)
{
  NS_LOG_FUNCTION (this << size);
  if (m_edca.find (AC_BK)->second->GetMsduAggregator () != 0)
    {
      m_edca.find (AC_BK)->second->GetMsduAggregator ()->SetMaxAmsduSize (size);
    }
}

void
RegularWifiMac::SetVoMaxAmpduSize (uint32_t size)
{
  NS_LOG_FUNCTION (this << size);
  if (m_edca.find (AC_VO)->second->GetMpduAggregator () != 0)
    {
      m_edca.find (AC_VO)->second->GetMpduAggregator ()->SetMaxAmpduSize (size);
    }
}

void
RegularWifiMac::SetViMaxAmpduSize (uint32_t size)
{
  NS_LOG_FUNCTION (this << size);
  if (m_edca.find (AC_VI)->second->GetMpduAggregator () != 0)
    {
      m_edca.find (AC_VI)->second->GetMpduAggregator ()->SetMaxAmpduSize (size);
    }
}

void
RegularWifiMac::SetBeMaxAmpduSize (uint32_t size)
{
  NS_LOG_FUNCTION (this << size);
  if (m_edca.find (AC_BE)->second->GetMpduAggregator () != 0)
    {
      m_edca.find (AC_BE)->second->GetMpduAggregator ()->SetMaxAmpduSize (size);
    }
}

void
RegularWifiMac::SetBkMaxAmpduSize (uint32_t size)
{
  NS_LOG_FUNCTION (this << size);
  if (m_edca.find (AC_BK)->second->GetMpduAggregator () != 0)
    {
      m_edca.find (AC_BK)->second->GetMpduAggregator ()->SetMaxAmpduSize (size);
    }
}

void
RegularWifiMac::SetVoBlockAckThreshold (uint8_t threshold)
{
  NS_LOG_FUNCTION (this << threshold);
  m_edca.find (AC_VO)->second->SetBlockAckThreshold (threshold);
}

void
RegularWifiMac::SetViBlockAckThreshold (uint8_t threshold)
{
  NS_LOG_FUNCTION (this << threshold);
  m_edca.find (AC_VI)->second->SetBlockAckThreshold (threshold);
}

void
RegularWifiMac::SetBeBlockAckThreshold (uint8_t threshold)
{
  NS_LOG_FUNCTION (this << threshold);
  m_edca.find (AC_BE)->second->SetBlockAckThreshold (threshold);
}

void
RegularWifiMac::SetBkBlockAckThreshold (uint8_t threshold)
{
  NS_LOG_FUNCTION (this << threshold);
  m_edca.find (AC_BK)->second->SetBlockAckThreshold (threshold);
}

void
RegularWifiMac::SetVoBlockAckInactivityTimeout (uint16_t timeout)
{
  NS_LOG_FUNCTION (this << timeout);
  m_edca.find (AC_VO)->second->SetBlockAckInactivityTimeout (timeout);
}

void
RegularWifiMac::SetViBlockAckInactivityTimeout (uint16_t timeout)
{
  NS_LOG_FUNCTION (this << timeout);
  m_edca.find (AC_VI)->second->SetBlockAckInactivityTimeout (timeout);
}

void
RegularWifiMac::SetBeBlockAckInactivityTimeout (uint16_t timeout)
{
  NS_LOG_FUNCTION (this << timeout);
  m_edca.find (AC_BE)->second->SetBlockAckInactivityTimeout (timeout);
}

void
RegularWifiMac::SetBkBlockAckInactivityTimeout (uint16_t timeout)
{
  NS_LOG_FUNCTION (this << timeout);
  m_edca.find (AC_BK)->second->SetBlockAckInactivityTimeout (timeout);
}

void
RegularWifiMac::SetupEdcaQueue (enum AcIndex ac)
{
  NS_LOG_FUNCTION (this << ac);

  NS_ASSERT (m_edca.find (ac) == m_edca.end ());

  Ptr<EdcaTxopN> edca = CreateObject<EdcaTxopN> ();
  Ptr<MsduStandardAggregator> msduAggregator = CreateObject<MsduStandardAggregator> ();
  Ptr<MpduStandardAggregator> mpduAggregator = CreateObject<MpduStandardAggregator> ();
    
  edca->SetLow (m_low);
  edca->SetManager (m_dcfManager);
  edca->SetTxMiddle (m_txMiddle);
  edca->SetTxOkCallback (MakeCallback (&RegularWifiMac::TxOk, this));
  edca->SetTxFailedCallback (MakeCallback (&RegularWifiMac::TxFailed, this));
  edca->SetAccessCategory (ac);
  edca->SetMsduAggregator (msduAggregator);
  edca->SetMpduAggregator (mpduAggregator);
  edca->CompleteConfig ();

  m_edca.insert (std::make_pair (ac, edca));
}


                   MakeBooleanAccessor (&RegularWifiMac::SetCtsToSelfSupported,
                                        &RegularWifiMac::GetCtsToSelfSupported),
                   MakeBooleanChecker ())
    .AddAttribute ("VO_MaxAmsduSize",
                   "Maximum length in bytes of an A-MSDU for AC_VO access class",
                   UintegerValue (0),
                   MakeUintegerAccessor (&RegularWifiMac::SetVoMaxAmsduSize),
                   MakeUintegerChecker<uint32_t> ())
    .AddAttribute ("VI_MaxAmsduSize",
                   "Maximum length in bytes of an A-MSDU for AC_VI access class",
                   UintegerValue (0),
                   MakeUintegerAccessor (&RegularWifiMac::SetViMaxAmsduSize),
                   MakeUintegerChecker<uint32_t> ())
    .AddAttribute ("BE_MaxAmsduSize",
                   "Maximum length in bytes of an A-MSDU for AC_BE access class",
                   UintegerValue (0),
                   MakeUintegerAccessor (&RegularWifiMac::SetBeMaxAmsduSize),
                   MakeUintegerChecker<uint32_t> ())
    .AddAttribute ("BK_MaxAmsduSize",
                   "Maximum length in bytes of an A-MSDU for AC_BK access class",
                   UintegerValue (0),
                   MakeUintegerAccessor (&RegularWifiMac::SetBkMaxAmsduSize),
                   MakeUintegerChecker<uint32_t> ())
    .AddAttribute ("VO_MaxAmpduSize",
                   "Maximum length in bytes of an A-MPDU for AC_VO access class",
                   UintegerValue (0),
                   MakeUintegerAccessor (&RegularWifiMac::SetVoMaxAmpduSize),
                   MakeUintegerChecker<uint32_t> ())
    .AddAttribute ("VI_MaxAmpduSize",
                   "Maximum length in bytes of an A-MPDU for AC_VI access class",
                   UintegerValue (0),
                   MakeUintegerAccessor (&RegularWifiMac::SetViMaxAmpduSize),
                   MakeUintegerChecker<uint32_t> ())
    .AddAttribute ("BE_MaxAmpduSize",
                   "Maximum length in bytes of an A-MPDU for AC_BE access class",
                   UintegerValue (0),
                   MakeUintegerAccessor (&RegularWifiMac::SetBeMaxAmpduSize),
                   MakeUintegerChecker<uint32_t> ())
    .AddAttribute ("BK_MaxAmpduSize",
                   "Maximum length in bytes of an A-MPDU for AC_BK access class",
                   UintegerValue (0),
                   MakeUintegerAccessor (&RegularWifiMac::SetBkMaxAmpduSize),
                   MakeUintegerChecker<uint32_t> ())
    .AddAttribute ("VO_BlockAckThreshold",
                   "If number of packets in VO queue reaches this value, "
                   "block ack mechanism is used. If this value is 0, block ack is never used.",
                   UintegerValue (0),
                   MakeUintegerAccessor (&RegularWifiMac::SetVoBlockAckThreshold),
                   MakeUintegerChecker<uint8_t> (0, 64))
    .AddAttribute ("VI_BlockAckThreshold",
                   "If number of packets in VI queue reaches this value, "
                   "block ack mechanism is used. If this value is 0, block ack is never used.",
                   UintegerValue (0),
                   MakeUintegerAccessor (&RegularWifiMac::SetViBlockAckThreshold),
                   MakeUintegerChecker<uint8_t> (0, 64))
    .AddAttribute ("BE_BlockAckThreshold",
                   "If number of packets in BE queue reaches this value, "
                   "block ack mechanism is used. If this value is 0, block ack is never used.",
                   UintegerValue (0),
                   MakeUintegerAccessor (&RegularWifiMac::SetBeBlockAckThreshold),
                   MakeUintegerChecker<uint8_t> (0, 64))
    .AddAttribute ("BK_BlockAckThreshold",
                   "If number of packets in BK queue reaches this value, "
                   "block ack mechanism is used. If this value is 0, block ack is never used.",
                   UintegerValue (0),
                   MakeUintegerAccessor (&RegularWifiMac::SetBkBlockAckThreshold),
                   MakeUintegerChecker<uint8_t> (0, 64))
    .AddAttribute ("VO_BlockAckInactivityTimeout",
                   "Represents max time (blocks of 1024 micro seconds) allowed for block ack"
                   "inactivity for AC_VO. If this value isn't equal to 0 a timer start after that a"
                   "block ack setup is completed and will be reset every time that a block ack"
                   "frame is received. If this value is 0, block ack inactivity timeout won't be used.",
                   UintegerValue (0),
                   MakeUintegerAccessor (&RegularWifiMac::SetVoBlockAckInactivityTimeout),
                   MakeUintegerChecker<uint16_t> ())
    .AddAttribute ("VI_BlockAckInactivityTimeout",
                   "Represents max time (blocks of 1024 micro seconds) allowed for block ack"
                   "inactivity for AC_VI. If this value isn't equal to 0 a timer start after that a"
                   "block ack setup is completed and will be reset every time that a block ack"
                   "frame is received. If this value is 0, block ack inactivity timeout won't be used.",
                   UintegerValue (0),
                   MakeUintegerAccessor (&RegularWifiMac::SetViBlockAckInactivityTimeout),
                   MakeUintegerChecker<uint16_t> ())
    .AddAttribute ("BE_BlockAckInactivityTimeout",
                   "Represents max time (blocks of 1024 micro seconds) allowed for block ack"
                   "inactivity for AC_BE. If this value isn't equal to 0 a timer start after that a"
                   "block ack setup is completed and will be reset every time that a block ack"
                   "frame is received. If this value is 0, block ack inactivity timeout won't be used.",
                   UintegerValue (0),
                   MakeUintegerAccessor (&RegularWifiMac::SetBeBlockAckInactivityTimeout),
                   MakeUintegerChecker<uint16_t> ())
    .AddAttribute ("BK_BlockAckInactivityTimeout",
                   "Represents max time (blocks of 1024 micro seconds) allowed for block ack"
                   "inactivity for AC_BK. If this value isn't equal to 0 a timer start after that a"
                   "block ack setup is completed and will be reset every time that a block ack"
                   "frame is received. If this value is 0, block ack inactivity timeout won't be used.",
                   UintegerValue (0),
                   MakeUintegerAccessor (&RegularWifiMac::SetBkBlockAckInactivityTimeout),
                   MakeUintegerChecker<uint16_t> ())
    .AddAttribute ("DcaTxop", "The DcaTxop object",
                   PointerValue (),
                   MakePointerAccessor (&RegularWifiMac::GetDcaTxop),

void
RegularWifiMac::FinishConfigureStandard (enum WifiPhyStandard standard)
{
  uint32_t cwmin = 0;
  uint32_t cwmax = 0;

  switch (standard)
    {




   */
  void SetupEdcaQueue (enum AcIndex ac);

  void SetVoMaxAmsduSize (uint32_t size);
  void SetViMaxAmsduSize (uint32_t size);
  void SetBeMaxAmsduSize (uint32_t size);
  void SetBkMaxAmsduSize (uint32_t size);

  void SetVoMaxAmpduSize (uint32_t size);
  void SetViMaxAmpduSize (uint32_t size);
  void SetBeMaxAmpduSize (uint32_t size);
  void SetBkMaxAmpduSize (uint32_t size);
  
  void SetVoBlockAckThreshold (uint8_t threshold);
  void SetViBlockAckThreshold (uint8_t threshold);
  void SetBeBlockAckThreshold (uint8_t threshold);
  void SetBkBlockAckThreshold (uint8_t threshold);
  
  void SetVoBlockAckInactivityTimeout (uint16_t timeout);
  void SetViBlockAckInactivityTimeout (uint16_t timeout);
  void SetBeBlockAckInactivityTimeout (uint16_t timeout);
  void SetBkBlockAckInactivityTimeout (uint16_t timeout);

  TracedCallback<const WifiMacHeader &> m_txOkCallback;
  TracedCallback<const WifiMacHeader &> m_txErrCallback;
};

(-)a/src/wifi/test/wifi-aggregation-test.cc (-19 / +14 lines)

Lines 26-31	Link Here

#include "ns3/mac-low.h"

#include "ns3/mac-low.h"

#include "ns3/edca-txop-n.h"

#include "ns3/edca-txop-n.h"

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

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

#include "ns3/msdu-standard-aggregator.h"

#include "ns3/mpdu-standard-aggregator.h"

using namespace ns3;

using namespace ns3;

Lines 41-48	Link Here

  Ptr<EdcaTxopN> m_edca;

  Ptr<EdcaTxopN> m_edca;

  Ptr<WifiRemoteStationManager> m_manager;

  Ptr<WifiRemoteStationManager> m_manager;

  ObjectFactory m_factory;

  ObjectFactory m_factory;

  Ptr<MpduAggregator> m_mpduAggregator;

  Ptr<MsduStandardAggregator> msduAggregator;

  Ptr<MsduAggregator> m_msduAggregator;

  Ptr<MpduStandardAggregator> mpduAggregator;

};

};

TwoLevelAggregationTest::TwoLevelAggregationTest ()

TwoLevelAggregationTest::TwoLevelAggregationTest ()

Lines 84-100	Link Here

/*

/*

   * Configure aggregation.

   * Configure aggregation.

*/

*/

  m_factory = ObjectFactory ();

  msduAggregator = CreateObject<MsduStandardAggregator> ();

  m_factory.SetTypeId ("ns3::MsduStandardAggregator");

  mpduAggregator = CreateObject<MpduStandardAggregator> ();

  m_factory.Set ("MaxAmsduSize", UintegerValue (4095));

  m_msduAggregator = m_factory.Create<MsduAggregator> ();

  msduAggregator->SetMaxAmsduSize (4095);

  m_edca->SetMsduAggregator (m_msduAggregator);

  mpduAggregator->SetMaxAmpduSize (65535);

  m_factory = ObjectFactory ();

  m_edca->SetMsduAggregator (msduAggregator);

  m_factory.SetTypeId ("ns3::MpduStandardAggregator");

  m_edca->SetMpduAggregator (mpduAggregator);

  m_factory.Set ("MaxAmpduSize", UintegerValue (65535));

  m_mpduAggregator = m_factory.Create<MpduAggregator> ();

  m_low->SetMpduAggregator (m_mpduAggregator);

/*

/*

100

   * Create dummy packets of 1500 bytes and fill mac header fields that will be used for the tests.

   * Create dummy packets of 1500 bytes and fill mac header fields that will be used for the tests.

Lines 141-151	Link Here

141

   * It checks whether MSDU aggregation has been rejected because the maximum MPDU size is set to 0 (returned packet should be equal to 0).

140

   * It checks whether MSDU aggregation has been rejected because the maximum MPDU size is set to 0 (returned packet should be equal to 0).

142

   * 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.

141

   * 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.

143

*/

142

*/

144

  m_factory = ObjectFactory ();

143

  /*m_factory = ObjectFactory ();

145

  m_factory.SetTypeId ("ns3::MpduStandardAggregator");

144

  m_factory.SetTypeId ("ns3::MpduStandardAggregator");

146

  m_factory.Set ("MaxAmpduSize", UintegerValue (0));

145

  m_factory.Set ("MaxAmpduSize", UintegerValue (0));

147

  m_mpduAggregator = m_factory.Create<MpduAggregator> ();

146

  m_mpduAggregator = m_factory.Create<MpduAggregator> ();

148

  m_low->SetMpduAggregator (m_mpduAggregator);

147

  m_low->SetMpduAggregator (m_mpduAggregator);*/

149

148

150

  m_edca->GetEdcaQueue ()->Enqueue (pkt, hdr);

149

  m_edca->GetEdcaQueue ()->Enqueue (pkt, hdr);

151

  packet = m_low->PerformMsduAggregation (peekedPacket, &peekedHdr, &tstamp, currentAggregatedPacket, 0);

150

  packet = m_low->PerformMsduAggregation (peekedPacket, &peekedHdr, &tstamp, currentAggregatedPacket, 0);

Lines 160-170	Link Here

160

   * It checks whether MSDU aggregation has been rejected because there is no packets ready in the queue (returned packet should be equal to 0).

159

   * It checks whether MSDU aggregation has been rejected because there is no packets ready in the queue (returned packet should be equal to 0).

161

   * This test is needed to ensure that there is no issue when the queue is empty.

160

   * This test is needed to ensure that there is no issue when the queue is empty.

162

*/

161

*/

163

  m_factory = ObjectFactory ();

162

  mpduAggregator->SetMaxAmpduSize (4095);

164

  m_factory.SetTypeId ("ns3::MpduStandardAggregator");

165

  m_factory.Set ("MaxAmpduSize", UintegerValue (4095));

166

  m_mpduAggregator = m_factory.Create<MpduAggregator> ();

167

  m_low->SetMpduAggregator (m_mpduAggregator);

168

163

169

  m_edca->GetEdcaQueue ()->Remove (pkt);

164

  m_edca->GetEdcaQueue ()->Remove (pkt);

170

  m_edca->GetEdcaQueue ()->Remove (pkt);

165

  m_edca->GetEdcaQueue ()->Remove (pkt);

(-)a/src/wifi/wscript (+1 lines)

Lines 136-141	Link Here

136

        'model/edca-txop-n.h',

136

        'model/edca-txop-n.h',

137

        'model/msdu-aggregator.h',

137

        'model/msdu-aggregator.h',

138

        'model/amsdu-subframe-header.h',

138

        'model/amsdu-subframe-header.h',

139

        'model/msdu-standard-aggregator.h',

139

        'model/qos-tag.h',

140

        'model/qos-tag.h',

140

        'model/mgt-headers.h',

141

        'model/mgt-headers.h',

141

        'model/status-code.h',

142

        'model/status-code.h',

Return to bug 2116