wifi: Enable windowed PER for PLCP payload

Enables to compute per MPDU PER. Also add a method to get SNR over whole event.

Author: rediet-orange

src/wifi/model/interference-helper.cc

@@ -278,9 +278,9 @@ InterferenceHelper::CalculateChunkSuccessRate (double snir, Time duration, WifiM
 }
 
 double
-InterferenceHelper::CalculatePayloadPer (Ptr<const Event> event, NiChanges *ni) const
+InterferenceHelper::CalculatePayloadPer (Ptr<const Event> event, NiChanges *ni, std::pair<Time, Time> window) const
 {
-  NS_LOG_FUNCTION (this);
+  NS_LOG_FUNCTION (this << window.first << window.second);
   const WifiTxVector txVector = event->GetTxVector ();
   double psr = 1.0; /* Packet Success Rate */
   auto j = ni->begin ();
@@ -291,35 +291,43 @@ InterferenceHelper::CalculatePayloadPer (Ptr<const Event> event, NiChanges *ni)
   Time plcpHsigHeaderStart = plcpHeaderStart + WifiPhy::GetPlcpHeaderDuration (txVector); //packet start time + preamble + L-SIG
   Time plcpTrainingSymbolsStart = plcpHsigHeaderStart + WifiPhy::GetPlcpHtSigHeaderDuration (preamble) + WifiPhy::GetPlcpSigA1Duration (preamble) + WifiPhy::GetPlcpSigA2Duration (preamble); //packet start time + preamble + L-SIG + HT-SIG or SIG-A
   Time plcpPayloadStart = plcpTrainingSymbolsStart + WifiPhy::GetPlcpTrainingSymbolDuration (txVector) + WifiPhy::GetPlcpSigBDuration (preamble); //packet start time + preamble + L-SIG + HT-SIG or SIG-A + Training + SIG-B
+  Time windowStart = plcpPayloadStart + window.first;
+  Time windowEnd = plcpPayloadStart + window.second;
   double noiseInterferenceW = m_firstPower;
   double powerW = event->GetRxPowerW ();
   while (++j != ni->end ())
     {
       Time current = j->first;
       NS_LOG_DEBUG ("previous= " << previous << ", current=" << current);
       NS_ASSERT (current >= previous);
-      //Case 1: Both previous and current point to the payload
-      if (previous >= plcpPayloadStart)
+      //Case 1: Both previous and current point to the windowed payload
+      if (previous >= windowStart)
         {
           psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
                                                           noiseInterferenceW,
                                                           txVector.GetChannelWidth ()),
                                             current - previous,
                                             payloadMode, txVector);
-          NS_LOG_DEBUG ("Both previous and current point to the payload: mode=" << payloadMode << ", psr=" << psr);
+          NS_LOG_DEBUG ("Both previous and current point to the windowed payload: mode=" << payloadMode << ", psr=" << psr);
         }
-      //Case 2: previous is before payload and current is in the payload
-      else if (current >= plcpPayloadStart)
+      //Case 2: previous is before windowed payload and current is in the windowed payload
+      else if (current >= windowStart)
         {
           psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
                                                           noiseInterferenceW,
                                                           txVector.GetChannelWidth ()),
-                                            current - plcpPayloadStart,
+                                            current - windowStart,
                                             payloadMode, txVector);
-          NS_LOG_DEBUG ("previous is before payload and current is in the payload: mode=" << payloadMode << ", psr=" << psr);
+          NS_LOG_DEBUG ("previous is before windowed payload and current is in the windowed payload: mode=" << payloadMode << ", psr=" << psr);
         }
       noiseInterferenceW = j->second.GetPower () - powerW;
       previous = j->first;
+      if (previous > windowEnd)
+        {
+          NS_LOG_DEBUG ("Stop: new previous=" << previous << " after time window end=" << windowEnd);
+          break;
+        }
+
     }
   double per = 1 - psr;
   return per;
@@ -839,25 +847,36 @@ InterferenceHelper::CalculateNonLegacyPhyHeaderPer (Ptr<const Event> event, NiCh
 }
 
 struct InterferenceHelper::SnrPer
-InterferenceHelper::CalculatePayloadSnrPer (Ptr<Event> event) const
+InterferenceHelper::CalculatePayloadSnrPer (Ptr<Event> event, std::pair<Time, Time> relativeMpduStartStop) const
 {
   NiChanges ni;
   double noiseInterferenceW = CalculateNoiseInterferenceW (event, &ni);
   double snr = CalculateSnr (event->GetRxPowerW (),
                              noiseInterferenceW,
                              event->GetTxVector ().GetChannelWidth ());
 
-  /* calculate the SNIR at the start of the packet and accumulate
+  /* calculate the SNIR at the start of the MPDU (located through windowing) and accumulate
    * all SNIR changes in the snir vector.
    */
-  double per = CalculatePayloadPer (event, &ni);
+  double per = CalculatePayloadPer (event, &ni, relativeMpduStartStop);
 
   struct SnrPer snrPer;
   snrPer.snr = snr;
   snrPer.per = per;
   return snrPer;
 }
 
+double
+InterferenceHelper::CalculateSnr (Ptr<Event> event) const
+{
+  NiChanges ni;
+  double noiseInterferenceW = CalculateNoiseInterferenceW (event, &ni);
+  double snr = CalculateSnr (event->GetRxPowerW (),
+                             noiseInterferenceW,
+                             event->GetTxVector ().GetChannelWidth ());
+ return snr;
+}
+
 struct InterferenceHelper::SnrPer
 InterferenceHelper::CalculateLegacyPhyHeaderSnrPer (Ptr<Event> event) const
 {

src/wifi/model/interference-helper.h

@@ -173,13 +173,25 @@ class InterferenceHelper
   void AddForeignSignal (Time duration, double rxPower);
   /**
    * Calculate the SNIR at the start of the payload and accumulate
-   * all SNIR changes in the snir vector.
+   * all SNIR changes in the snir vector for each MPDU of an A-MPDU.
+   * This workaround is required in order to provide one PER per MPDU, for
+   * reception success/failure evaluation, while hiding aggregation details from
+   * this class.
    *
    * \param event the event corresponding to the first time the corresponding packet arrives
+   * \param relativeMpduStartStop the time window (pair of start and end times) of PLCP payload to focus on
    *
-   * \return struct of SNR and PER
+   * \return struct of SNR and PER (with PER being evaluated over the provided time window)
+   */
+  struct InterferenceHelper::SnrPer CalculatePayloadSnrPer (Ptr<Event> event, std::pair<Time, Time> relativeMpduStartStop) const;
+  /**
+   * Calculate the SNIR for the event (starting from now until the event end).
+   *
+   * \param event the event corresponding to the first time the corresponding packet arrives
+   *
+   * \return the SNR for the packet
    */
-  struct InterferenceHelper::SnrPer CalculatePayloadSnrPer (Ptr<Event> event) const;
+  double CalculateSnr (Ptr<Event> event) const;
   /**
    * Calculate the SNIR at the start of the legacy PHY header and accumulate
    * all SNIR changes in the snir vector.
@@ -295,15 +307,17 @@ class InterferenceHelper
    */
   double CalculateChunkSuccessRate (double snir, Time duration, WifiMode mode, WifiTxVector txVector) const;
   /**
-   * Calculate the error rate of the given payload. The payload can be divided into
+   * Calculate the error rate of the given PLCP payload only in the provided time
+   * window (thus enabling per MPDU PER information). The PLCP payload can be divided into
    * multiple chunks (e.g. due to interference from other transmissions).
    *
    * \param event
    * \param ni
+   * \param window time window (pair of start and end times) of PLCP payload to focus on
    *
    * \return the error rate of the payload
    */
-  double CalculatePayloadPer (Ptr<const Event> event, NiChanges *ni) const;
+  double CalculatePayloadPer (Ptr<const Event> event, NiChanges *ni, std::pair<Time, Time> window) const;
   /**
    * Calculate the error rate of the legacy PHY header. The legacy PHY header
    * can be divided into multiple chunks (e.g. due to interference from other transmissions).

src/wifi/model/wifi-phy.cc

@@ -2739,7 +2739,7 @@ WifiPhy::EndReceive (Ptr<Packet> packet, WifiPreamble preamble, MpduType mpdutyp
   NS_ASSERT (event->GetEndTime () == Simulator::Now ());
 
   InterferenceHelper::SnrPer snrPer;
-  snrPer = m_interference.CalculatePayloadSnrPer (event);
+  snrPer = m_interference.CalculatePayloadSnrPer (event, std::make_pair (NanoSeconds (0), Simulator::Now () - event->GetStartTime ())); //TODO update with correct MPDU relative start and stop times
   m_interference.NotifyRxEnd ();
   m_currentEvent = 0;