Attachment #933 for bug #445

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




    ## nstime.h: ns3::TimeUnit<-1> [class]
    module.add_class('TimeInvert')
    ## nstime.h: ns3::TimeUnit<0> [class]
    module.add_class('TimeScaleFactor')
    ## nstime.h: ns3::TimeUnit<1> [class]
    module.add_class('Time')
    ## nstime.h: ns3::TimeUnit<2> [class]

    module.add_class('TimeChecker', parent=root_module['ns3::AttributeChecker'])
    ## nstime.h: ns3::TimeValue [class]
    module.add_class('TimeValue', parent=root_module['ns3::AttributeValue'])
    typehandlers.add_type_alias('ns3::TimeUnit< 0 >', 'ns3::TimeScaleFactor')
    typehandlers.add_type_alias('ns3::TimeUnit< 0 >*', 'ns3::TimeScaleFactor*')
    typehandlers.add_type_alias('ns3::TimeUnit< 0 >&', 'ns3::TimeScaleFactor&')
    typehandlers.add_type_alias('ns3::TimeUnit< 2 >', 'ns3::TimeSquare')
    typehandlers.add_type_alias('ns3::TimeUnit< 2 >*', 'ns3::TimeSquare*')
    typehandlers.add_type_alias('ns3::TimeUnit< 2 >&', 'ns3::TimeSquare&')
    typehandlers.add_type_alias('ns3::TimeUnit< - 1 >', 'ns3::TimeInvert')
    typehandlers.add_type_alias('ns3::TimeUnit< - 1 >*', 'ns3::TimeInvert*')
    typehandlers.add_type_alias('ns3::TimeUnit< - 1 >&', 'ns3::TimeInvert&')
    typehandlers.add_type_alias('ns3::TimeUnit< 0 >', 'ns3::Scalar')
    typehandlers.add_type_alias('ns3::TimeUnit< 0 >*', 'ns3::Scalar*')
    typehandlers.add_type_alias('ns3::TimeUnit< 0 >&', 'ns3::Scalar&')
    typehandlers.add_type_alias('ns3::TimeUnit< 1 >', 'ns3::Time')
    typehandlers.add_type_alias('ns3::TimeUnit< 1 >*', 'ns3::Time*')
    typehandlers.add_type_alias('ns3::TimeUnit< 1 >&', 'ns3::Time&')

    register_Ns3HighPrecision_methods(root_module, root_module['ns3::HighPrecision'])
    register_Ns3Simulator_methods(root_module, root_module['ns3::Simulator'])
    register_Ns3TimeInvert_methods(root_module, root_module['ns3::TimeInvert'])
    register_Ns3TimeScaleFactor_methods(root_module, root_module['ns3::TimeScaleFactor'])
    register_Ns3Time_methods(root_module, root_module['ns3::Time'])
    register_Ns3TimeSquare_methods(root_module, root_module['ns3::TimeSquare'])
    register_Ns3Timer_methods(root_module, root_module['ns3::Timer'])

                   [])
    return

def register_Ns3TimeScaleFactor_methods(root_module, cls):
    cls.add_binary_numeric_operator('*', root_module['ns3::Time'], root_module['ns3::TimeScaleFactor'], param('ns3::TimeUnit< 1 > const &', 'right'))
    cls.add_binary_numeric_operator('/', root_module['ns3::TimeInvert'], root_module['ns3::TimeScaleFactor'], param('ns3::TimeUnit< 1 > const &', 'right'))
    ## nstime.h: ns3::TimeUnit<0>::TimeUnit(double timescale) [constructor]
    cls.add_constructor([param('double', 'timescale')])
    ## nstime.h: ns3::TimeUnit<0>::TimeUnit() [constructor]
    cls.add_constructor([])
    ## nstime.h: ns3::TimeUnit<0>::TimeUnit(ns3::TimeUnit<0> const & o) [copy constructor]

    cls.add_binary_numeric_operator('+', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::TimeUnit< 1 > const &', 'right'))
    cls.add_binary_numeric_operator('-', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::TimeUnit< 1 > const &', 'right'))
    cls.add_binary_numeric_operator('/', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::TimeUnit< 0 > const &', 'right'))
    cls.add_binary_numeric_operator('/', root_module['ns3::TimeScaleFactor'], root_module['ns3::Time'], param('ns3::TimeUnit< 1 > const &', 'right'))
    cls.add_binary_comparison_operator('<')
    cls.add_binary_comparison_operator('>')
    cls.add_output_stream_operator()




    ## nstime.h: ns3::TimeUnit<-1> [class]
    module.add_class('TimeInvert')
    ## nstime.h: ns3::TimeUnit<0> [class]
    module.add_class('TimeScaleFactor')
    ## nstime.h: ns3::TimeUnit<1> [class]
    module.add_class('Time')
    ## nstime.h: ns3::TimeUnit<2> [class]

    module.add_class('TimeChecker', parent=root_module['ns3::AttributeChecker'])
    ## nstime.h: ns3::TimeValue [class]
    module.add_class('TimeValue', parent=root_module['ns3::AttributeValue'])
    typehandlers.add_type_alias('ns3::TimeUnit< 0 >', 'ns3::TimeScaleFactor')
    typehandlers.add_type_alias('ns3::TimeUnit< 0 >*', 'ns3::TimeScaleFactor*')
    typehandlers.add_type_alias('ns3::TimeUnit< 0 >&', 'ns3::TimeScaleFactor&')
    typehandlers.add_type_alias('ns3::TimeUnit< 2 >', 'ns3::TimeSquare')
    typehandlers.add_type_alias('ns3::TimeUnit< 2 >*', 'ns3::TimeSquare*')
    typehandlers.add_type_alias('ns3::TimeUnit< 2 >&', 'ns3::TimeSquare&')
    typehandlers.add_type_alias('ns3::TimeUnit< - 1 >', 'ns3::TimeInvert')
    typehandlers.add_type_alias('ns3::TimeUnit< - 1 >*', 'ns3::TimeInvert*')
    typehandlers.add_type_alias('ns3::TimeUnit< - 1 >&', 'ns3::TimeInvert&')
    typehandlers.add_type_alias('ns3::TimeUnit< 0 >', 'ns3::Scalar')
    typehandlers.add_type_alias('ns3::TimeUnit< 0 >*', 'ns3::Scalar*')
    typehandlers.add_type_alias('ns3::TimeUnit< 0 >&', 'ns3::Scalar&')
    typehandlers.add_type_alias('ns3::TimeUnit< 1 >', 'ns3::Time')
    typehandlers.add_type_alias('ns3::TimeUnit< 1 >*', 'ns3::Time*')
    typehandlers.add_type_alias('ns3::TimeUnit< 1 >&', 'ns3::Time&')

    register_Ns3HighPrecision_methods(root_module, root_module['ns3::HighPrecision'])
    register_Ns3Simulator_methods(root_module, root_module['ns3::Simulator'])
    register_Ns3TimeInvert_methods(root_module, root_module['ns3::TimeInvert'])
    register_Ns3TimeScaleFactor_methods(root_module, root_module['ns3::TimeScaleFactor'])
    register_Ns3Time_methods(root_module, root_module['ns3::Time'])
    register_Ns3TimeSquare_methods(root_module, root_module['ns3::TimeSquare'])
    register_Ns3Timer_methods(root_module, root_module['ns3::Timer'])

                   [])
    return

def register_Ns3TimeScaleFactor_methods(root_module, cls):
    cls.add_binary_numeric_operator('*', root_module['ns3::Time'], root_module['ns3::TimeScaleFactor'], param('ns3::TimeUnit< 1 > const &', 'right'))
    cls.add_binary_numeric_operator('/', root_module['ns3::TimeInvert'], root_module['ns3::TimeScaleFactor'], param('ns3::TimeUnit< 1 > const &', 'right'))
    ## nstime.h: ns3::TimeUnit<0>::TimeUnit(double timescale)) [constructor]
    cls.add_constructor([param('double', 'timescale')])
    ## nstime.h: ns3::TimeUnit<0>::TimeUnit() [constructor]
    cls.add_constructor([])
    ## nstime.h: ns3::TimeUnit<0>::TimeUnit(ns3::TimeUnit<0> const & o) [copy constructor]

    cls.add_binary_numeric_operator('+', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::TimeUnit< 1 > const &', 'right'))
    cls.add_binary_numeric_operator('-', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::TimeUnit< 1 > const &', 'right'))
    cls.add_binary_numeric_operator('/', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::TimeUnit< 0 > const &', 'right'))
    cls.add_binary_numeric_operator('/', root_module['ns3::TimeScaleFactor'], root_module['ns3::Time'], param('ns3::TimeUnit< 1 > const &', 'right'))
    cls.add_binary_comparison_operator('<')
    cls.add_binary_comparison_operator('>')
    cls.add_output_stream_operator()

(-)a/bindings/python/wscript (-4 / +4 lines)

Lines 314-323	Link Here

314

   t1 = t2 - t3;

314

   t1 = t2 - t3;

315

   TimeSquare tsq = t2*t3;

315

   TimeSquare tsq = t2*t3;

316

   Time tsqdiv = tsq/Seconds(1);

316

   Time tsqdiv = tsq/Seconds(1);

317

   Scalar scal = t2/t3;

317

   TimeScaleFactor dim = t2/t3;

318

   TimeInvert inv = scal/t3;

318

   TimeInvert inv = dim/t3;

319

   t1 = scal*t1;

319

   t1 = dim*t1;

320

   t1 = t1/scal;

320

   t1 = t1/dim;

321

   t1 < t2;

321

   t1 < t2;

322

   t1 <= t2;

322

   t1 <= t2;

323

   t1 == t2;

323

   t1 == t2;

(-)a/src/applications/onoff/onoff-application.cc (-1 / +1 lines)

Lines 166-172	Link Here

166

    { // Cancel the pending send packet event

166

    { // Cancel the pending send packet event

167

      // Calculate residual bits since last packet sent

167

      // Calculate residual bits since last packet sent

168

      Time delta(Simulator::Now() - m_lastStartTime);

168

      Time delta(Simulator::Now() - m_lastStartTime);

169

      Scalar bits = delta * Scalar (m_cbrRate.GetBitRate ()) / Seconds (1.0);

169

      TimeScaleFactor bits = delta * TimeScaleFactor (m_cbrRate.GetBitRate ()) / Seconds (1.0);

170

      m_residualBits += (uint32_t)bits.GetDouble ();

170

      m_residualBits += (uint32_t)bits.GetDouble ();

171

172

  Simulator::Cancel(m_sendEvent);

172

  Simulator::Cancel(m_sendEvent);

(-)a/src/contrib/delay-jitter-estimation.cc (-1 / +1 lines)

Lines 98-104	Link Here

  tag.GetTxTime ();

  tag.GetTxTime ();

100

  Time delta = (Simulator::Now () - m_previousRx) - (tag.GetTxTime () - m_previousRxTx);

100

  Time delta = (Simulator::Now () - m_previousRx) - (tag.GetTxTime () - m_previousRxTx);

101

  m_jitter += (Abs (delta) - m_jitter ) / Scalar (16.0);

101

  m_jitter += (Abs (delta) - m_jitter ) / TimeScaleFactor (16.0);

102

  m_previousRx = Simulator::Now ();

102

  m_previousRx = Simulator::Now ();

103

  m_previousRxTx = tag.GetTxTime ();

103

  m_previousRxTx = tag.GetTxTime ();

104

  m_delay = Simulator::Now () - tag.GetTxTime ();

104

  m_delay = Simulator::Now () - tag.GetTxTime ();

(-)a/src/contrib/flow-monitor/flow-probe.h (-1 / +1 lines)

Lines 57-63	Link Here

    std::vector<uint32_t> packetsDropped;

    std::vector<uint32_t> packetsDropped;

    /// bytesDropped[reasonCode] => number of dropped bytes

    /// bytesDropped[reasonCode] => number of dropped bytes

    std::vector<uint64_t> bytesDropped;

    std::vector<uint64_t> bytesDropped;

    /// divide by 'Scalar (packets)' to get the average delay from the

    /// divide by 'TimeScaleFactor (packets)' to get the average delay from the

    /// first (entry) probe up to this one (partial delay)

    /// first (entry) probe up to this one (partial delay)

    Time delayFromFirstProbeSum;

    Time delayFromFirstProbeSum;

    /// Number of bytes seen of this flow

    /// Number of bytes seen of this flow

(-)a/src/contrib/stats/time-data-calculators.cc (-1 / +1 lines)

Lines 73-79	Link Here

  callback.OutputSingleton(m_context, m_key + "-count", m_count);

  callback.OutputSingleton(m_context, m_key + "-count", m_count);

  if (m_count > 0) {

  if (m_count > 0) {

    callback.OutputSingleton(m_context, m_key + "-total", m_total);

    callback.OutputSingleton(m_context, m_key + "-total", m_total);

    callback.OutputSingleton(m_context, m_key + "-average", m_total/Scalar(m_count));

    callback.OutputSingleton(m_context, m_key + "-average", m_total/TimeScaleFactor(m_count));

    callback.OutputSingleton(m_context, m_key + "-max", m_max);

    callback.OutputSingleton(m_context, m_key + "-max", m_max);

    callback.OutputSingleton(m_context, m_key + "-min", m_min);

    callback.OutputSingleton(m_context, m_key + "-min", m_min);

(-)a/src/devices/csma/backoff.cc (-1 / +1 lines)

Lines 67-73	Link Here

  uint32_t backoffSlots = (uint32_t)m_rng.GetValue(minSlot, maxSlot);

  uint32_t backoffSlots = (uint32_t)m_rng.GetValue(minSlot, maxSlot);

  backoff = Scalar(backoffSlots) * m_slotTime;

  backoff = TimeScaleFactor(backoffSlots) * m_slotTime;

  return (backoff);

  return (backoff);

(-)a/src/devices/mesh/dot11s/hwmp-protocol.cc (-2 / +2 lines)

Lines 963-969	Link Here

963

  if (i == m_preqTimeouts.end ())

963

  if (i == m_preqTimeouts.end ())

964

965

      m_preqTimeouts[dst].preqTimeout = Simulator::Schedule (

965

      m_preqTimeouts[dst].preqTimeout = Simulator::Schedule (

966

          m_dot11MeshHWMPnetDiameterTraversalTime * Scalar (2),

966

          m_dot11MeshHWMPnetDiameterTraversalTime * TimeScaleFactor (2),

967

          &HwmpProtocol::RetryPathDiscovery, this, dst, 1);

967

          &HwmpProtocol::RetryPathDiscovery, this, dst, 1);

968

      m_preqTimeouts[dst].whenScheduled = Simulator::Now ();

968

      m_preqTimeouts[dst].whenScheduled = Simulator::Now ();

969

      return true;

969

      return true;

Lines 1009-1015	Link Here

1009

      i->second->RequestDestination (dst, originator_seqno, dst_seqno);

1009

      i->second->RequestDestination (dst, originator_seqno, dst_seqno);

1010

1011

  m_preqTimeouts[dst].preqTimeout = Simulator::Schedule (

1011

  m_preqTimeouts[dst].preqTimeout = Simulator::Schedule (

1012

      Scalar (2 * (numOfRetry + 1)) *  m_dot11MeshHWMPnetDiameterTraversalTime,

1012

      TimeScaleFactor (2 * (numOfRetry + 1)) *  m_dot11MeshHWMPnetDiameterTraversalTime,

1013

      &HwmpProtocol::RetryPathDiscovery, this, dst, numOfRetry);

1013

      &HwmpProtocol::RetryPathDiscovery, this, dst, numOfRetry);

1014

1015

//Proactive PREQ routines:

1015

//Proactive PREQ routines:

(-)a/src/devices/spectrum/waveform-generator.cc (-1 / +1 lines)

Lines 173-179	Link Here

173

void

173

void

174

WaveformGenerator::SetDutyCycle (double dutyCycle)

174

WaveformGenerator::SetDutyCycle (double dutyCycle)

175

176

  m_dutyCycle = Scalar (dutyCycle);

176

  m_dutyCycle = TimeScaleFactor (dutyCycle);

177

178

179

double WaveformGenerator::GetDutyCycle () const

179

double WaveformGenerator::GetDutyCycle () const

(-)a/src/devices/spectrum/waveform-generator.h (-1 / +1 lines)

Lines 136-142	Link Here

136

137

  Ptr<SpectrumValue> m_txPowerSpectralDensity;

137

  Ptr<SpectrumValue> m_txPowerSpectralDensity;

138

  Time   m_period;

138

  Time   m_period;

139

  Scalar m_dutyCycle;

139

  TimeScaleFactor m_dutyCycle;

140

  Time m_startTime;

140

  Time m_startTime;

141

  bool m_active;

141

  bool m_active;

142

(-)a/src/devices/wifi/mac-low.cc (-2 / +2 lines)

Lines 987-993	Link Here

987

988

      txTime += m_phy->CalculateTxDuration (GetRtsSize (), rtsMode, WIFI_PREAMBLE_LONG);

988

      txTime += m_phy->CalculateTxDuration (GetRtsSize (), rtsMode, WIFI_PREAMBLE_LONG);

989

      txTime += GetCtsDuration (hdr->GetAddr1 (), rtsMode);

989

      txTime += GetCtsDuration (hdr->GetAddr1 (), rtsMode);

990

      txTime += GetSifs () * Scalar (2);

990

      txTime += GetSifs () * TimeScaleFactor (2);

991

992

  uint32_t dataSize = GetSize (packet, hdr);

992

  uint32_t dataSize = GetSize (packet, hdr);

993

  txTime += m_phy->CalculateTxDuration (dataSize, dataMode, WIFI_PREAMBLE_LONG);

993

  txTime += m_phy->CalculateTxDuration (dataSize, dataMode, WIFI_PREAMBLE_LONG);

Lines 1047-1053	Link Here

1047

          cts.SetType (WIFI_MAC_CTL_CTS);

1047

          cts.SetType (WIFI_MAC_CTL_CTS);

1048

          Time navCounterResetCtsMissedDelay =

1048

          Time navCounterResetCtsMissedDelay =

1049

            m_phy->CalculateTxDuration (cts.GetSerializedSize (), txMode, preamble) +

1049

            m_phy->CalculateTxDuration (cts.GetSerializedSize (), txMode, preamble) +

1050

            Scalar (2) * GetSifs () + Scalar (2) * GetSlotTime ();

1050

            TimeScaleFactor (2) * GetSifs () + TimeScaleFactor (2) * GetSlotTime ();

1051

          m_navCounterResetCtsMissed = Simulator::Schedule (navCounterResetCtsMissedDelay,

1051

          m_navCounterResetCtsMissed = Simulator::Schedule (navCounterResetCtsMissedDelay,

1052

                                                            &MacLow::NavCounterResetCtsMissed, this,

1052

                                                            &MacLow::NavCounterResetCtsMissed, this,

1053

                                                            Simulator::Now ());

1053

                                                            Simulator::Now ());

(-)a/src/devices/wimax/bs-uplink-scheduler-mbqos.cc (-2 / +2 lines)

Lines 314-320	Link Here

314

                      uInterval =

314

                      uInterval =

315

                        MilliSeconds ((*(ssRecord->GetServiceFlows (ServiceFlow::SF_TYPE_UGS).begin ()))->GetUnsolicitedGrantInterval ());

315

                        MilliSeconds ((*(ssRecord->GetServiceFlows (ServiceFlow::SF_TYPE_UGS).begin ()))->GetUnsolicitedGrantInterval ());

316

317

                      Scalar frame = ((timestamp - Simulator::Now ()) / frame_duration);

317

                      TimeScaleFactor frame = ((timestamp - Simulator::Now ()) / frame_duration);

318

319

                      if (frame.GetDouble () <= 1)

319

                      if (frame.GetDouble () <= 1)

320

Lines 668-674	Link Here

668

              Time deadline = job->GetDeadline ();

668

              Time deadline = job->GetDeadline ();

669

              Time frame_duration = GetBs ()->GetPhy ()->GetFrameDuration ();

669

              Time frame_duration = GetBs ()->GetPhy ()->GetFrameDuration ();

670

671

              Scalar frame = ((deadline - Simulator::Now ()) / frame_duration);

671

              TimeScaleFactor frame = ((deadline - Simulator::Now ()) / frame_duration);

672

673

              NS_LOG_DEBUG ("At " << Simulator::Now ().GetSeconds () << " reserved traffic rate: "

673

              NS_LOG_DEBUG ("At " << Simulator::Now ().GetSeconds () << " reserved traffic rate: "

674

                                << job->GetServiceFlow ()->GetMinReservedTrafficRate ()

674

                                << job->GetServiceFlow ()->GetMinReservedTrafficRate ()




  if (nSamples)
    { // Not first
      Time err = m - est;
      est = est + TimeScaleFactor (gain) * err;         // estimated rtt
      err = Abs (err);        // absolute value of error
      variance = variance + TimeScaleFactor (gain) * (err - variance); // variance of rtt
    }
  else
    { // First sample

  // If not enough samples, justjust return 2 times estimate   
  //if (nSamples < 2) return est * 2;
  Time retval;
  if (variance < est / TimeScaleFactor (4.0))
    {
      retval = est * TimeScaleFactor (2 * multiplier);            // At least twice current est
    }
  else
    {
      retval = (est + TimeScaleFactor (4) * variance) * TimeScaleFactor (multiplier); // As suggested by Jacobson
    }
  retval = Max (retval, minrto);
  return retval;

(-)a/src/internet-stack/tcp-socket-impl.cc (-1 / +1 lines)

Lines 1650-1656	Link Here

1650

void TcpSocketImpl::PersistTimeout ()

1650

void TcpSocketImpl::PersistTimeout ()

1651

1652

  NS_LOG_LOGIC ("PersistTimeout expired at "<<Simulator::Now ().GetSeconds ());

1652

  NS_LOG_LOGIC ("PersistTimeout expired at "<<Simulator::Now ().GetSeconds ());

1653

  m_persistTime = Scalar(2)*m_persistTime;

1653

  m_persistTime = TimeScaleFactor(2)*m_persistTime;

1654

  m_persistTime = std::min(Seconds(60),m_persistTime); //maxes out at 60

1654

  m_persistTime = std::min(Seconds(60),m_persistTime); //maxes out at 60

1655

  //the persist timeout sends exactly one byte probes

1655

  //the persist timeout sends exactly one byte probes

1656

  //this is explicit in stevens, and kind of in rfc793 p42, rfc1122 sec4.2.2.17

1656

  //this is explicit in stevens, and kind of in rfc793 p42, rfc1122 sec4.2.2.17




  ActiveRouteTimeout (Seconds (3)),
  NetDiameter (35),
  NodeTraversalTime (MilliSeconds (40)),
  NetTraversalTime (TimeScaleFactor (2 * NetDiameter) * NodeTraversalTime),
  PathDiscoveryTime ( TimeScaleFactor (2) * NetTraversalTime),
  MyRouteTimeout (TimeScaleFactor (2) * std::max (PathDiscoveryTime, ActiveRouteTimeout)),
  HelloInterval(Seconds (1)),
  AllowedHelloLoss (2),
  DeletePeriod (TimeScaleFactor(5) * std::max(ActiveRouteTimeout, HelloInterval)),
  NextHopWait (NodeTraversalTime + MilliSeconds (10)),
  TimeoutBuffer (2),
  BlackListTimeout(TimeScaleFactor (RreqRetries) * NetTraversalTime),
  MaxQueueLen (64),
  MaxQueueTime (Seconds(30)),
  DestinationOnly (false),

  if (EnableHello)
    {
      m_htimer.Cancel ();
      m_htimer.Schedule (HelloInterval - TimeScaleFactor (0.01) * MilliSeconds (UniformVariable ().GetInteger (0, 10)));
    }
}


  m_routingTable.LookupRoute (dst, rt);
  rt.IncrementRreqCnt ();
  m_routingTable.Update (rt);
  m_addressReqTimer[dst].Schedule (TimeScaleFactor (rt.GetRreqCnt ()) * NetTraversalTime);
}

void

      Ptr<NetDevice> dev = m_ipv4->GetNetDevice (m_ipv4->GetInterfaceForAddress (receiver));
      RoutingTableEntry newEntry (/*device=*/dev, /*dst=*/origin, /*validSeno=*/true, /*seqNo=*/rreqHeader.GetOriginSeqno (),
                                  /*iface=*/m_ipv4->GetAddress (m_ipv4->GetInterfaceForAddress (receiver), 0), /*hops=*/hop,
                                  /*nextHop*/src, /*timeLife=*/TimeScaleFactor (2) * NetTraversalTime - TimeScaleFactor (2 * hop) * NodeTraversalTime);
      m_routingTable.AddRoute (newEntry);
    }
  else

      toOrigin.SetOutputDevice (m_ipv4->GetNetDevice (m_ipv4->GetInterfaceForAddress (receiver)));
      toOrigin.SetInterface (m_ipv4->GetAddress (m_ipv4->GetInterfaceForAddress (receiver), 0));
      toOrigin.SetHop (hop);
      toOrigin.SetLifeTime (std::max (TimeScaleFactor (2) * NetTraversalTime - TimeScaleFactor (2 * hop) * NodeTraversalTime, toOrigin.GetLifeTime ()));
      m_routingTable.Update (toOrigin);
    }
  NS_LOG_LOGIC (receiver << " receive RREQ to destination " << rreqHeader.GetDst ());

  if (EnableHello)
    {
      m_htimer.Cancel ();
      m_htimer.Schedule (HelloInterval - TimeScaleFactor(0.1)*MilliSeconds(UniformVariable().GetInteger (0, 10)));
    }
}


    }
  else
    {
      toNeighbor.SetLifeTime (std::max (TimeScaleFactor (AllowedHelloLoss) * HelloInterval, toNeighbor.GetLifeTime ()));
      toNeighbor.SetSeqNo (rrepHeader.GetDstSeqno ());
      toNeighbor.SetValidSeqNo (true);
      toNeighbor.SetFlag (VALID);

    }
  if (EnableHello)
    {
      m_nb.Update (rrepHeader.GetDst (), TimeScaleFactor (AllowedHelloLoss) * HelloInterval);
    }
}


  NS_LOG_FUNCTION (this);
  SendHello ();
  m_htimer.Cancel ();
  Time t = TimeScaleFactor(0.01)*MilliSeconds(UniformVariable().GetInteger (0, 100));
  m_htimer.Schedule (HelloInterval - t);
}


      Ptr<Socket> socket = j->first;
      Ipv4InterfaceAddress iface = j->second;
      RrepHeader helloHeader (/*prefix size=*/0, /*hops=*/0, /*dst=*/iface.GetLocal (), /*dst seqno=*/m_seqNo,
                              /*origin=*/iface.GetLocal (),/*lifetime=*/TimeScaleFactor (AllowedHelloLoss) * HelloInterval);
      Ptr<Packet> packet = Create<Packet> ();
      packet->AddHeader (helloHeader);
      TypeHeader tHeader (AODVTYPE_RREP);

(-)a/src/routing/aodv/test/aodv-regression.cc (-1 / +1 lines)

Lines 101-107	Link Here

101

  // At m_time / 3 move central node away and see what will happen

101

  // At m_time / 3 move central node away and see what will happen

102

  Ptr<Node> node = m_nodes->Get (m_size / 2);

102

  Ptr<Node> node = m_nodes->Get (m_size / 2);

103

  Ptr<MobilityModel> mob = node->GetObject<MobilityModel> ();

103

  Ptr<MobilityModel> mob = node->GetObject<MobilityModel> ();

104

  Simulator::Schedule (m_time / Scalar(3.0), &MobilityModel::SetPosition, mob, Vector (1e5, 1e5, 1e5));

104

  Simulator::Schedule (m_time / TimeScaleFactor(3.0), &MobilityModel::SetPosition, mob, Vector (1e5, 1e5, 1e5));

105

106

  Simulator::Stop (m_time);

106

  Simulator::Stop (m_time);

107

  Simulator::Run ();

107

  Simulator::Run ();




/********** Holding times **********/

/// Neighbor holding time.
#define OLSR_NEIGHB_HOLD_TIME	(TimeScaleFactor (3) * OLSR_REFRESH_INTERVAL)
/// Top holding time.
#define OLSR_TOP_HOLD_TIME	(TimeScaleFactor (3) * m_tcInterval)
/// Dup holding time.
#define OLSR_DUP_HOLD_TIME	Seconds (30)
/// MID holding time.
#define OLSR_MID_HOLD_TIME	(TimeScaleFactor (3) * m_midInterval)
/// HNA holding time.
#define OLSR_HNA_HOLD_TIME  (TimeScaleFactor (3) * m_hnaInterval)

/********** Link types **********/





 * multiply multiple TimeUnit objects. The return type of any such
 * arithmetic expression is always a TimeUnit object.
 *
 * The ns3::TimeScaleFactor, ns3::Time, ns3::TimeSquare, and ns3::TimeInvert classes
 * are aliases for the TimeUnit<0>, TimeUnit<1>, TimeUnit<2> and TimeUnit<-1>
 * types respectively.
 *

 * Time<3> t5 = t3 * t1;
 * Time<-2> t6 = t1 / t5;
 * TimeSquare t7 = t3;
 * TimeScaleFactor s = t4;
 * \endcode
 *
 * If you try to assign the result of an expression which does not

 * the standard C++ operators (if you make sure to obey the rules
 * of the ns3::TimeUnit class template)
 * To scale a Time instance, you can multiply it with an instance of
 * the ns3::TimeScaleFactor class.
 * Time instances can also be manipulated through the following non-member
 * functions:
 *  - \ref ns3-Time-Abs ns3::Abs

  // -*- New methods -*-
public:
  double GetDouble (void) const;
  TimeUnit<0> (double timescale);

  // -*- The rest is the the same as in the generic template class -*-
public:

};

/**
 * \brief hold timescale values
 *
 * This class is used both to construct timescale 
 * values to multiply ns3::Time instances and to 
 * hold the return value of an expression which returns 
 * a timescale value. For example, the
 * following code will output on your terminal 1.5:
 * \code
 * TimeScaleFactor s0 = TimeScaleFactor (1.5);
 * Time t1 = Seconds (10.0) * s0;
 * Time t2 = Seconds (10.0) * TimeScaleFactor (2.5);
 * TimeScaleFactor s1 = Seconds (15.0) / Seconds (10.0);
 * std::cout << s1.GetDouble () << std::endl;
 * \endcode
 *
 * The TimeScaleFactor class has the following additional methods not available in
 * the generic TimeUnit template:
 * \code
 * double GetDouble (void) const;
 * \endcode
 * returns the C double contained in the TimeScaleFactor instance
 *
 * \code
 * TimeScaleFactor(double timescale);
 * \endcode
 * Constructs a TimeScaleFactor instance from a C double.
 */

// Scalar is deprecated; use TimeUnit<0> or TimeScaleFactor instead
typedef TimeUnit<0> Scalar;
typedef TimeUnit<0> TimeScaleFactor;

typedef TimeUnit<-1> TimeInvert;
typedef TimeUnit<2> TimeSquare;




  return Time (HighPrecision (ts, false));
}

TimeUnit<0>::TimeUnit (double timescale)
  : m_data (HighPrecision (timescale))
{
}


  NS_TEST_ASSERT_MSG_EQ ((MilliSeconds (0) > NanoSeconds (0)), false, "Zero is bigger than Zero ?");
  NS_TEST_ASSERT_MSG_EQ ((MilliSeconds (0) < NanoSeconds (0)), false, "Zero is smaller than Zero ?");

  Time t4 = Seconds (10.0) * TimeScaleFactor (1.5);
  ASSERT_EQ (t4.GetSeconds (), 15.0);

  Time t5 = NanoSeconds (10) * TimeScaleFactor (1.5);
  ASSERT_EQ (t5.GetNanoSeconds (), 15.0);

  Time t6 = Seconds (10.0) * TimeScaleFactor (15) / TimeScaleFactor (10);
  ASSERT_EQ (t6.GetSeconds (), 15.0);

  Time t7 = NanoSeconds (10) * TimeScaleFactor (15) / TimeScaleFactor (10);
  ASSERT_EQ (t7.GetNanoSeconds (), 15.0);

  ASSERT_EQ ((t1 + t2).GetSeconds (), t1.GetSeconds () + t2.GetSeconds ());

             (t0.GetSeconds () / t1.GetSeconds () * (t0.GetSeconds () - t1.GetSeconds ())));
  ASSERT_EQ (((t0 / t1) * (t0 - t1)).GetSeconds (),
             (t0.GetSeconds () / t1.GetSeconds ()) * (t0.GetSeconds () - t1.GetSeconds ()));
  ASSERT_EQ ((t0 * TimeScaleFactor (10.0)).GetSeconds (), (t0.GetSeconds () * 10.0));
  ASSERT_EQ ((TimeScaleFactor (10.0) * t0).GetSeconds (), (10.0 * t0.GetSeconds ()));

  // Note: we need to multiply by 1e9 because GetSeconds is multiplying
  ASSERT_EQ (((t0 / (t1 * (t0 - t1))).GetHighPrecision ().GetDouble () * 1e9),


bool Bug863TestCase::DoRun (void)
{
  TimeScaleFactor result = TimeScaleFactor (0.9) / TimeScaleFactor (1.0);
  NS_TEST_ASSERT_MSG_EQ ((result == TimeScaleFactor (0.9)), true, "Invalid arithmetic result");
  return false;
}


(-)a/utils/python-unit-tests.py (-1 / +1 lines)

Lines 53-59	Link Here

        self.assertEqual(ns3.Seconds(10) + ns3.Seconds(5), ns3.Seconds(15))

        self.assertEqual(ns3.Seconds(10) + ns3.Seconds(5), ns3.Seconds(15))

        self.assertEqual(ns3.Seconds(10) - ns3.Seconds(5), ns3.Seconds(5))

        self.assertEqual(ns3.Seconds(10) - ns3.Seconds(5), ns3.Seconds(5))

        v1 = ns3.Scalar(5)*ns3.Seconds(10)

        v1 = ns3.TimeScaleFactor(5)*ns3.Seconds(10)

        self.assertEqual(v1, ns3.Seconds(50))

        self.assertEqual(v1, ns3.Seconds(50))

    def testConfig(self):

    def testConfig(self):

Return to bug 445