Attachment #264 for bug #376

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




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

#include "ns3/simulator.h"
#include "ns3/nstime.h"
#include "ns3/log.h"
#include "ns3/wall-clock-synchronizer.h"
#include "ns3/system-thread.h"
#include "ns3/string.h"
#include "ns3/config.h"
#include "ns3/global-value.h"

#include <unistd.h>
#include <sys/time.h>

using namespace ns3;

NS_LOG_COMPONENT_DEFINE ("TestSync");

bool gFirstRun = false;

  void 
inserted_function (void)
{
  NS_ASSERT (gFirstRun);
  NS_LOG_UNCOND ("inserted_function() called at " << 
    Simulator::Now ().GetSeconds () << " s");
}

  void 
background_function (void)
{
  NS_ASSERT (gFirstRun);
  NS_LOG_UNCOND ("background_function() called at " << 
    Simulator::Now ().GetSeconds () << " s");
}

  void 
first_function (void)
{
  NS_LOG_UNCOND ("first_function() called at " << 
    Simulator::Now ().GetSeconds () << " s");
  gFirstRun = true;
}

class FakeNetDevice
{
public:
  FakeNetDevice ();
  void Doit1 (void);
  void Doit2 (void);
};

FakeNetDevice::FakeNetDevice ()
{
  NS_LOG_FUNCTION_NOARGS ();
}

  void
FakeNetDevice::Doit2 (void)
{
  NS_LOG_FUNCTION_NOARGS ();
  sleep (1);
  for (uint32_t i = 0.001; i < 10000; ++i)
    {
      //
      // Exercise the relative schedule path
      //
      Simulator::Schedule (Seconds (0), &inserted_function);
      usleep (1000);
    }
}

  void
FakeNetDevice::Doit1 (void)
{
  NS_LOG_FUNCTION_NOARGS ();
  sleep (1);
  for (uint32_t i = 0.001; i < 10000; ++i)
    {
      // 
      // Exercise the ScheduleNow path
      //
      Simulator::ScheduleNow (&inserted_function);
      usleep (1000);
    }
}

  void 
test (void)
{
  GlobalValue::Bind ("SimulatorImplementationType", 
    StringValue ("ns3::RealtimeSimulatorImpl"));

  FakeNetDevice fnd;

  // 
  // Make sure ScheduleNow works when the system isn't running
  //
  Simulator::ScheduleNow(&first_function);

  // 
  // drive the progression of m_currentTs at a ten millisecond rate
  //
  for (double d = 0.; d < 14.999; d += 0.01)
    {
      Simulator::Schedule (Seconds (d), &background_function);
    }

  Ptr<SystemThread> st1 = Create<SystemThread> (
    MakeCallback (&FakeNetDevice::Doit1, &fnd));
  st1->Start ();
  Ptr<SystemThread> st2 = Create<SystemThread> (
    MakeCallback (&FakeNetDevice::Doit2, &fnd));
  st2->Start ();

  Simulator::Stop (Seconds (15.0));
  Simulator::Run ();
  st1->Join ();
  st2->Join ();
  Simulator::Destroy ();
}

  int
main (int argc, char *argv[])
{
  for (;;)
    {
      test ();
    }
}


(-)a/samples/wscript (+3 lines)

Lines 19-24 def build(bld):	Link Here

    obj = bld.create_ns3_program('main-test')

    obj = bld.create_ns3_program('main-test')

    obj.source = 'main-test.cc'

    obj.source = 'main-test.cc'

    obj = bld.create_ns3_program('main-test-sync')

    obj.source = 'main-test-sync.cc'

    obj = bld.create_ns3_program('main-simple',

    obj = bld.create_ns3_program('main-simple',

                                 ['node', 'internet-stack', 'onoff'])

                                 ['node', 'internet-stack', 'onoff'])

    obj.source = 'main-simple.cc'

    obj.source = 'main-simple.cc'

(-)a/src/simulator/default-simulator-impl.cc (-3 / +8 lines)

Lines 180-191 DefaultSimulatorImpl::Stop (Time const &	Link Here

180

  m_stopAt = absolute.GetTimeStep ();

180

  m_stopAt = absolute.GetTimeStep ();

181

182

183

//

184

// Schedule an event for a _relative_ time in the future.

185

//

183

EventId

186

EventId

184

DefaultSimulatorImpl::Schedule (Time const &time, const Ptr<EventImpl> &event)

187

DefaultSimulatorImpl::Schedule (Time const &time, const Ptr<EventImpl> &event)

185

188

186

  NS_ASSERT (time.IsPositive ());

189

  Time tAbsolute = time + Now();

187

  NS_ASSERT (time >= TimeStep (m_currentTs));

190

188

  uint64_t ts = (uint64_t) time.GetTimeStep ();

191

  NS_ASSERT (tAbsolute.IsPositive ());

192

  NS_ASSERT (tAbsolute >= TimeStep (m_currentTs));

193

  uint64_t ts = (uint64_t) tAbsolute.GetTimeStep ();

189

  EventId id (event, ts, m_uid);

194

  EventId id (event, ts, m_uid);

190

  m_uid++;

195

  m_uid++;

191

  ++m_unscheduledEvents;

196

  ++m_unscheduledEvents;




  NS_LOG_FUNCTION_NOARGS ();
  //
  // The idea here is to wait until the next event comes due.  In the case of
  // a realtime simulation, we want real time to be consumed between events.  
  // It is the realtime synchronizer that causes real time to be consumed by
  // doing some kind of a wait.
  // between events.  It is the synchronizer that causes real time to be 
  // consumed.
  //
  // We need to be able to have external events (such as a packet reception event)
  // cause us to re-evaluate our state.  The way this works is that the synchronizer
  // gets interrupted and returs.  So, there is a possibility that things may change
  // out from under us dynamically.  In this case, we need to re-evaluate how long to 
  // wait in a for-loop until we have waited sucessfully (until a timeout) for the 
  // event at the head of the event list.
  //
  // m_synchronizer->Synchronize will return true if the wait was completed without 
  // interruption, otherwise it will return false indicating that something has changed
  // out from under us.  If we sit in the for-loop trying to synchronize until 
  // Synchronize() returns true, we will have successfully synchronized the execution 
  // time of the next event with the wall clock time of the synchronizer.
  //

  for (;;) 
    {
      uint64_t tsDelay = 0;
      uint64_t tsNow = m_currentTs;
      uint64_t tsNext = 0;

      //
      // It is important to understand that m_currentTs is interpreted only as the 
      // timestamp  of the last event we executed.  Current time can a bit of a 
      // slippery concept in realtime mode.  What we have here is a discrete event 
      // simulator, so the last event is, by defintion, executed entirely at a single
      //  discrete time.  This is the definition of m_currentTs.  It really has 
      // nothing to do with the current real time, except that we are trying to arrange
      // that at the instant of the beginning of event execution, the current real time
      // and m_currentTs coincide.
      //
      // We use tsNow as the indication of the current real time.
      //
      uint64_t tsNow;

      { 
        CriticalSection cs (m_mutex);

        NS_ASSERT_MSG (NextTs () >= m_currentTs, 
          "RealtimeSimulatorImpl::ProcessOneEvent (): "
          "Next event time earlier than m_currentTs (list order error)");
        //
        // Since we are in realtime mode, the time to delay has got to be the 
        // difference between the current realtime and the timestamp of the next 
        // event.  Since m_currentTs is actually the timestamp of the last event we 
        // executed, it's not particularly meaningful for us here since real time has
        // certainly elapsed since it was last updated.
        //
        // It is possible that the current realtime has drifted past the next event
        // time so we need to be careful about that and not delay in that case.

        NS_ASSERT_MSG (m_synchronizer->Realtime (), 
          "RealtimeSimulatorImpl::ProcessOneEvent (): Synchronizer reports not Realtime ()");

        //
        // tsNow is set to the normalized current real time.  When the simulation was
        // started, the current real time was effectively set to zero; so tsNow is
        // the current "real" simulation time.
        //
        // tsNext is the simulation time of the next event we want to execute.
        //
        tsNow = m_synchronizer->GetCurrentRealtime ();
        tsNext = NextTs ();

        //
        // tsDelay is therefore the real time we need to delay in order to bring the
        // real time in sync with the simulation time.  If we wait for this amount of
        // real time, we will accomplish moving the simulation time at the same rate
        // as the real time.  This is typically called "pacing" the simulation time.
        //
        // We do have to be careful if we are falling behind.  If so, tsDelay must be
        // zero.  If we're late, don't dawdle.
        //
        if (tsNext <= tsNow)
          {
            tsDelay = 0;

            tsDelay = tsNext - tsNow;
          }
      
        //
        // We've figured out how long we need to delay in order to pace the 
        // simulation time with the real time.  We're going to sleep, but need
        // to work with the synchronizer to make sure we're awakened if something 
        // external happens (like a packet is received).  This next line resets
        // the synchronizer so that any future event will cause it to interrupt.
        //
        m_synchronizer->SetCondition (false);
      }

      //
      // We have a time to delay.  This time may actually not be valid anymore
      // since we released the critical section immediately above, and a real-time
      // ScheduleReal or ScheduleRealNow may have snuck in, well, between the 
      // closing brace above and this comment so to speak.  If this is the case, 
      // that schedule operation will have done a synchronizer Signal() that 
      // will set the condition variable to true and cause the Synchronize call 
      // below to return immediately.
      //
      // It's easiest to understand if you just consider a short tsDelay that only
      // requires a SpinWait down in the synchronizer.  What will happen is that 

      // until the condition variable becomes true.  A true condition indicates that
      // the wait should stop.  The condition is set to true by one of the Schedule
      // methods of the simulator; so if we are in a wait down in Synchronize, and
      // a Simulator::ScheduleReal is done, the wait down in Synchronize will exit and
      // Synchronize will return false.  This means we have not actually synchronized
      // to the event expiration time.  If no real-time schedule operation is done
      // while down in Synchronize, the wait will time out and Synchronize will return 
      // true.  This indicates that we have synchronized to the event time.
      //
      // So we need to stay in this for loop, looking for the next event timestamp and 
      // attempting to sleep until its due.  If we've slept until the timestamp is due, 
      // Synchronize returns true and we break out of the sync loop.  If an external
      // event happens that requires a re-schedule, Synchronize returns false and
      // we re-evaluate our timing by continuing in the loop.  
      // Synchronize, the Synchronize code will check the condition before going to
      // sleep.  If a Schedule happens while we are sleeping, we let the kernel wake
      // us up.
      //
      // It is expected that tsDelay become shorter as external events interrupt our
      // waits.
      // the timestamp is due, Synchronize() returns true and we break out of the 
      //sync loop.  If we're interrupted we continue in the loop.  We may find that
      // the next timestamp is actually earlier than we thought, but we continue 
      // around the loop and reevaluate and wait for that one correctly.
      //
      if (m_synchronizer->Synchronize (tsNow, tsDelay))
        {
          NS_LOG_LOGIC ("Interrupted ...");
          break;
        }
 
      //
      // If we get to this point, we have been interrupted during a wait by a real-time
      // schedule operation.  This means all bets are off regarding tsDelay and we need
      // to re-evaluate what it is we want to do.  We'll loop back around in the 
      // for-loop and start again from scratch.
      //
    }

  //
  // If we break out of the for-loop above, we have waited until the time specified
  // by the event that was at the head of the event list when we started the process.
  // Since there is a bunch of code that was executed outside a critical section (the
  // Synchronize call) we cannot be sure that the event at the head of the event list
  // is the one we think it is.  What we can be sure of is that it is time to execute
  // whatever event is at the head of this list if the list is in time order.
  // If you think about it, this is not a problem, since the best we can 
  // possibly do is to execute the event as soon as we can execute it.  We'll
  // be a little late, but we were late anyway.
  //
  // So we just go ahead and pull the first event off of the list, even though
  // it may be the case that it's not actually the one we waited for.
  //
  // One final tidbit is, "what the heck time is it anyway"?  The simulator is
  // going to want to get a timestamp from the next event and wait until the
  // wall clock time is equal to the timestamp.  At the point when those times
  // are the same (roughly) we get to this point and set the m_currentTs below.
  // That's straightforward here, but you might ask, how does the next event get
  // the time when it is inserted from an external source?
  //
  // The method RealtimeSimulatorImpl::ScheduleNow takes makes an event and 
  // needs to schedule that event for immediate execution.  If the simulator is 
  // not locked to a realtime source, the current time is m_currentTs.  If it is
  // locked to a realtime source, we need to use the real current real time.
  // This real time is then used to set the event execution time and will be 
  // read by the next.GetTs below and will set the current simulation time.
  //
  EventId next;

  { 
    CriticalSection cs (m_mutex);

    // 
    // We do know we're waiting for an event, so there had better be an event on the 
    // event queue.  Let's pull it off.  When we release the critical section, the
    // event we're working on won't be on the list and so subsequent operations won't
    // mess with us.
    //
    NS_ASSERT_MSG (m_events->IsEmpty () == false, 
      "RealtimeSimulatorImpl::ProcessOneEvent(): event queue is empty");

    next = m_events->RemoveNext ();
    --m_unscheduledEvents;

    //
    // We cannot make any assumption that "next" is the same event we originally waited 
    // for.  We can only assume that only that it must be due and cannot cause time 
    // to move backward.
    //
    NS_ASSERT_MSG (next.GetTs () >= m_currentTs,
                   "RealtimeSimulatorImpl::ProcessOneEvent(): "
                   "next.GetTs() earlier than m_currentTs (list order error)");
    NS_LOG_LOGIC ("handle " << next.GetTs ());

    // 
    // Update the current simulation time to be the timestamp of the event we're 
    // executing.  From the rest of the simulation's point of view, simulation time
    // is frozen until the next event is executed.
    //
    m_currentTs = next.GetTs ();
    m_currentUid = next.GetUid ();

    // 
    // We're about to run the event and we've done our best to synchronize this
    // event execution time to real time.  Now, if we're in SYNC_HARD_LIMIT mode
    // we have to decide if we've done a good enough job and if we haven't, we've
    // been asked to commit ritual suicide.
    //
    // We check the simulation time against the current real time to make this
    // judgement.
    //
    if (m_synchronizationMode == SYNC_HARD_LIMIT)
      {
        uint64_t tsFinal = m_synchronizer->GetCurrentRealtime ();
        uint64_t tsJitter;

        if (tsFinal >= m_currentTs)
          {
            tsJitter = tsFinal - m_currentTs;
          }
        else
          {
            tsJitter = m_currentTs - tsFinal;
          }

        if (tsJitter > static_cast<uint64_t>(m_hardLimit.GetTimeStep ()))
          {
            NS_FATAL_ERROR ("RealtimeSimulatorImpl::ProcessOneEvent (): "
                            "Hard real-time limit exceeded (jitter = " << tsJitter << ")");
          }
      }
  }

  NS_ASSERT_MSG (next.GetTs () >= m_currentTs,
    "RealtimeSimulatorImpl::ProcessOneEvent(): "
    "next.GetTs() earlier than m_currentTs (list order error)");
  NS_LOG_LOGIC ("handle " << next.GetTs ());
  m_currentTs = next.GetTs ();
  m_currentUid = next.GetUid ();

  // 
  // We're about to run the event and we've done our best to synchronize this
  // event execution time to real time.  Now, if we're in SYNC_HARD_LIMIT mode
  // we have to decide if we've done a good enough job and if we haven't, we've
  // been asked to commit ritual suicide.
  //
  // We have got the event we're about to execute completely disentangled from the 
  // event list so we can execute it outside a critical section without fear of someone
  // changing things out from under us.
      uint64_t tsJitter;

      if (tsFinal >= m_currentTs)
        {
          tsJitter = tsFinal - m_currentTs;
        }
      else
        {
          tsJitter = m_currentTs - tsFinal;
        }

      if (tsJitter > static_cast<uint64_t>(m_hardLimit.GetTimeStep ()))
        {
          NS_FATAL_ERROR ("RealtimeSimulatorImpl::ProcessOneEvent (): "
                          "Hard real-time limit exceeded (jitter = " << tsJitter << ")");
        }
    }

  EventImpl *event = next.PeekEventImpl ();
  m_synchronizer->EventStart ();


static void Placeholder (void) {}

//
// Schedule a stop for a _relative_ time in the future.  If the simulation
// hasn't started yet, this will effectively be an absolute time.
//
void 
RealtimeSimulatorImpl::Stop (Time const &time)
{
  NS_LOG_FUNCTION (time);
  NS_ASSERT_MSG (time.IsPositive (),
    "RealtimeSimulatorImpl::Stop(): Negative time");

  Time tAbsolute = Simulator::Now () + time;
  NS_ASSERT (tAbsolute.IsPositive ());
  NS_ASSERT (tAbsolute >= TimeStep (m_currentTs));
  m_stopAt = tAbsolute.GetTimeStep ();
  //
  // For the realtime case, we need a real event sitting out at the end of time
  // to keep the simulator running (sleeping) while there are no other events 

  //
  // The easiest thing to do is to call back up into the simulator to take 
  // advantage of all of the nice event wrappers.  This will call back down into
  // RealtimeSimulatorImpl::Schedule to do the work.  This path interprets the 
  // time as relative, so pass the relative time.
  //
  Simulator::Schedule (time, &Placeholder);
}

//
// Schedule an event for a _relative_ time in the future.
//
EventId
RealtimeSimulatorImpl::Schedule (Time const &time, const Ptr<EventImpl> &event)
{

  // This is a little tricky.  We get a Ptr<EventImpl> passed down to us in some
  // thread context.  This Ptr<EventImpl> is not yet shared in any way.  It is 
  // possible however that the calling context is not the context of the main 
  // scheduler thread (e.g. it is in the context of a separate device thread).  
  // It would be bad (TM) if we naively wrapped the EventImpl up in an EventId 
  // that would be accessible from multiple threads without considering thread 
  // safety.
  //
  // Having multiple EventId containing Ptr<EventImpl> in different thread
  // contexts creates a situation where atomic reference count decrements
  // would be required (think about an event being scheduled with the calling
  // yielding immediately afterward.  The scheduler could become ready and 
  // fire the event which would eventually want to release the EventImpl.  If
  // the calling thread were readied and executed in mid-release, it would also
  // want to release the EventImpl "at the same time."  If we are careless about
  // this, multiple deletes are sure to eventually happen as the threads 
  // separately play with the EventImpl reference counts.
  // 
  // The way this all works is that we created an EventImpl in the template 
  // function that called us, which may be in the context of a thread separate
  // from the simulator thread.  We are managing the lifetime of the EventImpl
  // with an intrusive reference count.  The count was initialized to one when
  // it was created and is still one right now.  We're going to "wrap" this
  // EventImpl in an EventId in this method.  There's an assignment of our 
  // Ptr<EventImpl> into another Ptr<EventImpl> inside the EventId which will 
  // bump the ref count to two.  We're going to return this EventId to the 
  // caller so the calling thread will hold a reference to the underlying 
  // EventImpl.  This is what causes the first half of the multithreading issue.
  //
  // We are going to call Insert() on the EventId to put the event into the 
  // scheduler.  Down there, it will do a PeekEventImpl to get the pointer to
  // the EventImpl and manually increment the reference count (to three).  From 
  // there, the sheduler works with the EventImpl pointer.  When the EventId 
  // below goes out of scope, the Ptr<EventImpl> destructor is run and the ref
  // count is decremented to two.  When this function returns to the calling
  // template function, the Ptr<EventImpl> there will go out of scope and we'll
  // decrement the EventImpl ref count leaving it to be the one held by our
  // scheduler directly.
  //
  // The scheduler removes the EventImpl in Remove() or RemoveNext().  In the
  // case of Remove(), the scheduler is provided an Event reference and locates
  // the corresponding EventImpl in the event list.  It gets the raw pointer to
  // the EventImpl, erases the pointer in the list, and manually calls Unref()
  // on the pointer.  In RemoveNext(), it gets the raw pointer from the list and
  // assigns it to a Ptr<EventImpl> without bumping the reference count, thereby
  // transferring ownership to a containing EventId.  This is the second half of
  // the multithreading issue.
  //
  // It's clear that we cannot have a situation where the EventImpl is "owned" by
  // multiple threads.  The calling thread is free to hold the EventId as long as

  // wants.  The scheduler is free to do the same; and will eventually release
  // the reference in the context of thread running ProcessOneEvent().  It is 
  // "a bad thing" (TM) if these two threads decide to release the underlying
  // EventImpl "at the same time" since the result is sure to be multiple frees,
  // memory leaks or bus errors.
  //
  // The answer is to make the reference counting of the EventImpl thread safe; 
  // which we do.  We don't want to force the event implementation to carry around
  // a mutex, so we "lend" it one using a RealtimeEventLock object (m_eventLock)
  // in the constructor of the event and take it back in the destructor.  See the
  // event code for details.
  //
  EventId id;

  {
    CriticalSection cs (m_mutex);
    //
    // This is the reason we had to bring the absolute time calcualtion in from the
    // simulator.h into the implementation.  Since the implementations may be 
    // multi-threaded, we need this calculation to be atomic.  You can see it is
    // here since we are running in a CriticalSection.
    //
    Time tAbsolute = Simulator::Now () + time;
    NS_ASSERT_MSG (tAbsolute.IsPositive (), "RealtimeSimulatorImpl::Schedule(): Negative time");
    NS_ASSERT_MSG (tAbsolute >= TimeStep (m_currentTs), "RealtimeSimulatorImpl::Schedule(): time < m_currentTs");
    uint64_t ts = (uint64_t) tAbsolute.GetTimeStep ();
    id = EventId (event, ts, m_uid);
    m_uid++;
    ++m_unscheduledEvents;

  {
    CriticalSection cs (m_mutex);

    id = EventId (event, m_currentTs, m_uid);
    
    m_uid++;
    ++m_unscheduledEvents;
    m_events->Insert (id);

(-)a/src/simulator/simulator.cc (-1 / +1 lines)

Lines 210-216 Simulator::Schedule (Time const &time, c	Link Here

210

Simulator::Schedule (Time const &time, const Ptr<EventImpl> &ev)

210

Simulator::Schedule (Time const &time, const Ptr<EventImpl> &ev)

211

212

  NS_LOG_FUNCTION (time << ev);

212

  NS_LOG_FUNCTION (time << ev);

213

  return GetImpl ()->Schedule (Now () + time, ev);

213

  return GetImpl ()->Schedule (time, ev);

214

215

216

EventId

216

EventId

(-)a/src/simulator/simulator.h (-3 / +7 lines)

Lines 138-146 public:	Link Here

138

  static void Stop (Time const &time);

138

  static void Stop (Time const &time);

139

140

/**

140

/**

141

   * Schedule an event to expire when the time "now + time"

141

   * Schedule an event to expire at the relative time "time"

142

   * is reached. When the event expires, the input method

142

   * is reached.  This can be thought of as scheduling an event

143

   * will be invoked on the input object.

143

   * for the current simulation time plus the Time passed as a

144

   * parameter

145

146

   * When the event expires (when it becomes due to be run), the

147

   * input method will be invoked on the input object.

144

148

145

   * @param time the relative expiration time of the event.

149

   * @param time the relative expiration time of the event.

146

   * @param mem_ptr member method pointer to invoke

150

   * @param mem_ptr member method pointer to invoke




  return id;
}

Time
RealtimeSimulatorImpl::Now (void) const
{
  return TimeStep (m_currentTs);
}

//
// Schedule an event for a _relative_ time in the future.
//
EventId
RealtimeSimulatorImpl::ScheduleReal (Time const &time, const Ptr<EventImpl> &event)
{
  NS_LOG_FUNCTION (time << event);
  NS_ASSERT (false);
  EventId id;
  return id;
}

EventId
RealtimeSimulatorImpl::ScheduleRealNow (const Ptr<EventImpl> &event)
{
  NS_LOG_FUNCTION (event);
  NS_ASSERT (false);
  EventId id;
  return id;
}

Time
RealtimeSimulatorImpl::RealNow (void) const
{
  NS_ASSERT (false);
  return TimeStep (m_currentTs);
}


EventId
RealtimeSimulatorImpl::ScheduleDestroy (const Ptr<EventImpl> &event)
{

  }

  return id;
}

Time
RealtimeSimulatorImpl::Now (void) const
{
  return TimeStep (m_currentTs);
}

Time 

(-)a/src/simulator/realtime-simulator-impl.h (-1 / +4 lines)

Lines 69-81 public:	Link Here

  void Stop (Time const &time);

  void Stop (Time const &time);

  EventId Schedule (Time const &time, const Ptr<EventImpl> &event);

  EventId Schedule (Time const &time, const Ptr<EventImpl> &event);

  EventId ScheduleNow (const Ptr<EventImpl> &event);

  EventId ScheduleNow (const Ptr<EventImpl> &event);

  EventId ScheduleReal (Time const &time, const Ptr<EventImpl> &event);

  EventId ScheduleRealNow (const Ptr<EventImpl> &event);

  EventId ScheduleDestroy (const Ptr<EventImpl> &event);

  EventId ScheduleDestroy (const Ptr<EventImpl> &event);

  Time Now (void) const;

  Time RealNow (void) const;

  void Remove (const EventId &ev);

  void Remove (const EventId &ev);

  void Cancel (const EventId &ev);

  void Cancel (const EventId &ev);

  bool IsExpired (const EventId &ev) const;

  bool IsExpired (const EventId &ev) const;

  virtual void RunOneEvent (void);

  virtual void RunOneEvent (void);

  void Run (void);

  void Run (void);

  Time Now (void) const;

  Time GetDelayLeft (const EventId &id) const;

  Time GetDelayLeft (const EventId &id) const;

  Time GetMaximumSimulationTime (void) const;

  Time GetMaximumSimulationTime (void) const;




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2008 University of Washington
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "simulator.h"
#include "realtime-simulator.h"
#include "realtime-simulator-impl.h"
#include "event-impl.h"

#include "ns3/assert.h"
#include "ns3/log.h"

NS_LOG_COMPONENT_DEFINE ("RealtimeSimulatorExtension");

namespace ns3 {

RealtimeSimulatorImpl *
RealtimeSimulatorExtension::GetRealtimeImpl (void)
{
  RealtimeSimulatorImpl *impl = dynamic_cast<RealtimeSimulatorImpl *>(Simulator::GetImpl ());
  NS_ASSERT_MSG (impl, 
                 "RealtimeSimulatorExtension::GetImpl (): Underlying simulator implementation not realtime");
  return impl;
}

Time
RealtimeSimulatorExtension::RealNow (void)
{
  return GetRealtimeImpl ()->RealNow ();
}

EventId
RealtimeSimulatorExtension::ScheduleReal (Time const &time, const Ptr<EventImpl> &ev)
{
  NS_LOG_FUNCTION (time << ev);
  return GetRealtimeImpl ()->ScheduleReal (time, ev);
}

EventId
RealtimeSimulatorExtension::ScheduleRealNow (const Ptr<EventImpl> &ev)
{
  NS_LOG_FUNCTION (ev);
  return GetRealtimeImpl ()->ScheduleRealNow (ev);
}

EventId
RealtimeSimulatorExtension::ScheduleReal (Time const &time, void (*f) (void))
{
  NS_LOG_FUNCTION (time << f);
  return ScheduleReal (time, Simulator::MakeEvent (f));
}

EventId
RealtimeSimulatorExtension::ScheduleRealNow (void (*f) (void))
{
  NS_LOG_FUNCTION (f);
  return ScheduleRealNow (Simulator::MakeEvent (f));
}

} // namespace ns3




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2008 University of Washington
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef REALTIME_SIMULATOR_H
#define REALTIME_SIMULATOR_H

#include "simulator.h"
#include "realtime-simulator-impl.h"

namespace ns3 {

/**
 * \ingroup simulator
 *
 * \brief Extension class to control the scheduling of real-time simulation 
 * events.  Intended to be used by threads driven by "external" system
 * events and will schedule events using the current real-time instead of 
 * the current simulation time.
 */
class RealtimeSimulatorExtension 
{
public:
  /**
   * Schedule an event to expire at the relative real-time "time"
   * is reached.  This can be thought of as scheduling an event
   * for the current real-time plus the Time passed as a parameter
   *
   * When the event expires (when it becomes due to be run), the 
   * input method will be invoked on the input object.  
   *
   * @param time the relative expiration time of the event.
   * @param mem_ptr member method pointer to invoke
   * @param obj the object on which to invoke the member method
   * @returns an id for the scheduled event.
   */
  template <typename MEM, typename OBJ>
  static EventId ScheduleReal (Time const &time, MEM mem_ptr, OBJ obj);

  /**
   * @param time the relative expiration time of the event.
   * @param mem_ptr member method pointer to invoke
   * @param obj the object on which to invoke the member method
   * @param a1 the first argument to pass to the invoked method
   * @returns an id for the scheduled event.
   */
  template <typename MEM, typename OBJ, typename T1>
  static EventId ScheduleReal (Time const &time, MEM mem_ptr, OBJ obj, T1 a1);

  /**
   * @param time the relative expiration time of the event.
   * @param mem_ptr member method pointer to invoke
   * @param obj the object on which to invoke the member method
   * @param a1 the first argument to pass to the invoked method
   * @param a2 the second argument to pass to the invoked method
   * @returns an id for the scheduled event.
   */
  template <typename MEM, typename OBJ, typename T1, typename T2>
  static EventId ScheduleReal (Time const &time, MEM mem_ptr, OBJ obj, T1 a1, T2 a2);

  /**
   * @param time the relative expiration time of the event.
   * @param mem_ptr member method pointer to invoke
   * @param obj the object on which to invoke the member method
   * @param a1 the first argument to pass to the invoked method
   * @param a2 the second argument to pass to the invoked method
   * @param a3 the third argument to pass to the invoked method
   * @returns an id for the scheduled event.
   */
  template <typename MEM, typename OBJ, 
            typename T1, typename T2, typename T3>
  static EventId ScheduleReal (Time const &time, MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3);

  /**
   * @param time the relative expiration time of the event.
   * @param mem_ptr member method pointer to invoke
   * @param obj the object on which to invoke the member method
   * @param a1 the first argument to pass to the invoked method
   * @param a2 the second argument to pass to the invoked method
   * @param a3 the third argument to pass to the invoked method
   * @param a4 the fourth argument to pass to the invoked method
   * @returns an id for the scheduled event.
   */
  template <typename MEM, typename OBJ, 
            typename T1, typename T2, typename T3, typename T4>
  static EventId ScheduleReal (Time const &time, MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3, T4 a4);

  /**
   * @param time the relative expiration time of the event.
   * @param mem_ptr member method pointer to invoke
   * @param obj the object on which to invoke the member method
   * @param a1 the first argument to pass to the invoked method
   * @param a2 the second argument to pass to the invoked method
   * @param a3 the third argument to pass to the invoked method
   * @param a4 the fourth argument to pass to the invoked method
   * @param a5 the fifth argument to pass to the invoked method
   * @returns an id for the scheduled event.
   */
  template <typename MEM, typename OBJ, 
            typename T1, typename T2, typename T3, typename T4, typename T5>
  static EventId ScheduleReal (Time const &time, MEM mem_ptr, OBJ obj, 
                           T1 a1, T2 a2, T3 a3, T4 a4, T5 a5);
  /**
   * @param time the relative expiration time of the event.
   * @param f the function to invoke
   * @returns an id for the scheduled event.
   */
  static EventId ScheduleReal (Time const &time, void (*f) (void));

  /**
   * @param time the relative expiration time of the event.
   * @param f the function to invoke
   * @param a1 the first argument to pass to the function to invoke
   * @returns an id for the scheduled event.
   */
  template <typename U1, typename T1>
  static EventId ScheduleReal (Time const &time, void (*f) (U1), T1 a1);

  /**
   * @param time the relative expiration time of the event.
   * @param f the function to invoke
   * @param a1 the first argument to pass to the function to invoke
   * @param a2 the second argument to pass to the function to invoke
   * @returns an id for the scheduled event.
   */
  template <typename U1, typename U2, typename T1, typename T2>
  static EventId ScheduleReal (Time const &time, void (*f) (U1,U2), T1 a1, T2 a2);

  /**
   * @param time the relative expiration time of the event.
   * @param f the function to invoke
   * @param a1 the first argument to pass to the function to invoke
   * @param a2 the second argument to pass to the function to invoke
   * @param a3 the third argument to pass to the function to invoke
   * @returns an id for the scheduled event.
   */
  template <typename U1, typename U2, typename U3, typename T1, typename T2, typename T3>
  static EventId ScheduleReal (Time const &time, void (*f) (U1,U2,U3), T1 a1, T2 a2, T3 a3);

  /**
   * @param time the relative expiration time of the event.
   * @param f the function to invoke
   * @param a1 the first argument to pass to the function to invoke
   * @param a2 the second argument to pass to the function to invoke
   * @param a3 the third argument to pass to the function to invoke
   * @param a4 the fourth argument to pass to the function to invoke
   * @returns an id for the scheduled event.
   */
  template <typename U1, typename U2, typename U3, typename U4, 
            typename T1, typename T2, typename T3, typename T4>
  static EventId ScheduleReal (Time const &time, void (*f) (U1,U2,U3,U4), T1 a1, T2 a2, T3 a3, T4 a4);

  /**
   * @param time the relative expiration time of the event.
   * @param f the function to invoke
   * @param a1 the first argument to pass to the function to invoke
   * @param a2 the second argument to pass to the function to invoke
   * @param a3 the third argument to pass to the function to invoke
   * @param a4 the fourth argument to pass to the function to invoke
   * @param a5 the fifth argument to pass to the function to invoke
   * @returns an id for the scheduled event.
   */
  template <typename U1, typename U2, typename U3, typename U4, typename U5,
            typename T1, typename T2, typename T3, typename T4, typename T5>
  static EventId ScheduleReal (Time const &time, void (*f) (U1,U2,U3,U4,U5), T1 a1, T2 a2, T3 a3, T4 a4, T5 a5);

  /**
   * Schedule an event to expire Now. All events scheduled to
   * to expire "Now" are scheduled FIFO, after all normal events
   * have expired. 
   *
   * @param mem_ptr member method pointer to invoke
   * @param obj the object on which to invoke the member method
   */
  template <typename MEM, typename OBJ>
  static EventId ScheduleRealNow (MEM mem_ptr, OBJ obj);

  /**
   * @param mem_ptr member method pointer to invoke
   * @param obj the object on which to invoke the member method
   * @param a1 the first argument to pass to the invoked method
   */
  template <typename MEM, typename OBJ, 
            typename T1>
  static EventId ScheduleRealNow (MEM mem_ptr, OBJ obj, T1 a1);

  /**
   * @param mem_ptr member method pointer to invoke
   * @param obj the object on which to invoke the member method
   * @param a1 the first argument to pass to the invoked method
   * @param a2 the second argument to pass to the invoked method
   */
  template <typename MEM, typename OBJ, 
            typename T1, typename T2>
  static EventId ScheduleRealNow (MEM mem_ptr, OBJ obj, T1 a1, T2 a2);

  /**
   * @param mem_ptr member method pointer to invoke
   * @param obj the object on which to invoke the member method
   * @param a1 the first argument to pass to the invoked method
   * @param a2 the second argument to pass to the invoked method
   * @param a3 the third argument to pass to the invoked method
   */
  template <typename MEM, typename OBJ, 
            typename T1, typename T2, typename T3>
  static EventId ScheduleRealNow (MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3);

  /**
   * @param mem_ptr member method pointer to invoke
   * @param obj the object on which to invoke the member method
   * @param a1 the first argument to pass to the invoked method
   * @param a2 the second argument to pass to the invoked method
   * @param a3 the third argument to pass to the invoked method
   * @param a4 the fourth argument to pass to the invoked method
   */
  template <typename MEM, typename OBJ, 
            typename T1, typename T2, typename T3, typename T4>
  static EventId ScheduleRealNow (MEM mem_ptr, OBJ obj, 
                              T1 a1, T2 a2, T3 a3, T4 a4);
  /**
   * @param mem_ptr member method pointer to invoke
   * @param obj the object on which to invoke the member method
   * @param a1 the first argument to pass to the invoked method
   * @param a2 the second argument to pass to the invoked method
   * @param a3 the third argument to pass to the invoked method
   * @param a4 the fourth argument to pass to the invoked method
   * @param a5 the fifth argument to pass to the invoked method
   */
  template <typename MEM, typename OBJ, 
            typename T1, typename T2, typename T3, typename T4, typename T5>
  static EventId ScheduleRealNow (MEM mem_ptr, OBJ obj, 
                              T1 a1, T2 a2, T3 a3, T4 a4, T5 a5);
  /**
   * @param f the function to invoke
   */
  static EventId ScheduleRealNow (void (*f) (void));

  /**
   * @param f the function to invoke
   * @param a1 the first argument to pass to the function to invoke
   */
  template <typename U1,
            typename T1>
  static EventId ScheduleRealNow (void (*f) (U1), T1 a1);

  /**
   * @param f the function to invoke
   * @param a1 the first argument to pass to the function to invoke
   * @param a2 the second argument to pass to the function to invoke
   */
  template <typename U1, typename U2,
            typename T1, typename T2>
  static EventId ScheduleRealNow (void (*f) (U1,U2), T1 a1, T2 a2);

  /**
   * @param f the function to invoke
   * @param a1 the first argument to pass to the function to invoke
   * @param a2 the second argument to pass to the function to invoke
   * @param a3 the third argument to pass to the function to invoke
   */
  template <typename U1, typename U2, typename U3,
            typename T1, typename T2, typename T3>
  static EventId ScheduleRealNow (void (*f) (U1,U2,U3), T1 a1, T2 a2, T3 a3);

  /**
   * @param f the function to invoke
   * @param a1 the first argument to pass to the function to invoke
   * @param a2 the second argument to pass to the function to invoke
   * @param a3 the third argument to pass to the function to invoke
   * @param a4 the fourth argument to pass to the function to invoke
   */
  template <typename U1, typename U2, typename U3, typename U4,
            typename T1, typename T2, typename T3, typename T4>
  static EventId ScheduleRealNow (void (*f) (U1,U2,U3,U4), T1 a1, T2 a2, T3 a3, T4 a4);

  /**
   * @param f the function to invoke
   * @param a1 the first argument to pass to the function to invoke
   * @param a2 the second argument to pass to the function to invoke
   * @param a3 the third argument to pass to the function to invoke
   * @param a4 the fourth argument to pass to the function to invoke
   * @param a5 the fifth argument to pass to the function to invoke
   */
  template <typename U1, typename U2, typename U3, typename U4, typename U5,
            typename T1, typename T2, typename T3, typename T4, typename T5>
  static EventId ScheduleRealNow (void (*f) (U1,U2,U3,U4,U5), T1 a1, T2 a2, T3 a3, T4 a4, T5 a5);

  /**
   * Return the "current normalized real-time".
   */
  static Time RealNow (void);

  /**
   * \param time delay until the event expires
   * \param event the event to schedule
   * \returns a unique identifier for the newly-scheduled event.
   *
   * This method will be typically used by language bindings
   * to delegate events to their own subclass of the EventImpl base class.
   */
  static EventId ScheduleReal (Time const &time, const Ptr<EventImpl> &event);  

  /**
   * \param event the event to schedule
   * \returns a unique identifier for the newly-scheduled event.
   *
   * This method will be typically used by language bindings
   * to delegate events to their own subclass of the EventImpl base class.
   */
  static EventId ScheduleRealNow (const Ptr<EventImpl> &event);
private:
  RealtimeSimulatorExtension ();
  ~RealtimeSimulatorExtension ();

  static RealtimeSimulatorImpl *GetRealtimeImpl (void);
};

template <typename MEM, typename OBJ>
EventId RealtimeSimulatorExtension::ScheduleReal (Time const &time, MEM mem_ptr, OBJ obj) 
{
  return ScheduleReal (time, Simulator::MakeEvent (mem_ptr, obj));
}

template <typename MEM, typename OBJ,
          typename T1>
EventId RealtimeSimulatorExtension::ScheduleReal (Time const &time, MEM mem_ptr, OBJ obj, T1 a1) 
{
  return ScheduleReal (time, Simulator::MakeEvent (mem_ptr, obj, a1));
}

template <typename MEM, typename OBJ, 
          typename T1, typename T2>
EventId RealtimeSimulatorExtension::ScheduleReal (Time const &time, MEM mem_ptr, OBJ obj, T1 a1, T2 a2)
{
  return ScheduleReal (time, Simulator::MakeEvent (mem_ptr, obj, a1, a2));
}

template <typename MEM, typename OBJ,
          typename T1, typename T2, typename T3>
EventId RealtimeSimulatorExtension::ScheduleReal (Time const &time, MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3) 
{
  return ScheduleReal (time, Simulator::MakeEvent (mem_ptr, obj, a1, a2, a3));
}

template <typename MEM, typename OBJ, 
          typename T1, typename T2, typename T3, typename T4>
EventId RealtimeSimulatorExtension::ScheduleReal (Time const &time, MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3, T4 a4) 
{
  return ScheduleReal (time, Simulator::MakeEvent (mem_ptr, obj, a1, a2, a3, a4));
}

template <typename MEM, typename OBJ, 
          typename T1, typename T2, typename T3, typename T4, typename T5>
EventId RealtimeSimulatorExtension::ScheduleReal (Time const &time, MEM mem_ptr, OBJ obj, 
                             T1 a1, T2 a2, T3 a3, T4 a4, T5 a5) 
{
  return ScheduleReal (time, Simulator::MakeEvent (mem_ptr, obj, a1, a2, a3, a4, a5));
}

template <typename U1, typename T1>
EventId RealtimeSimulatorExtension::ScheduleReal (Time const &time, void (*f) (U1), T1 a1) 
{
  return ScheduleReal (time, Simulator::MakeEvent (f, a1));
}

template <typename U1, typename U2, 
          typename T1, typename T2>
EventId RealtimeSimulatorExtension::ScheduleReal (Time const &time, void (*f) (U1,U2), T1 a1, T2 a2) 
{
  return ScheduleReal (time, Simulator::MakeEvent (f, a1, a2));
}

template <typename U1, typename U2, typename U3,
          typename T1, typename T2, typename T3>
EventId RealtimeSimulatorExtension::ScheduleReal (Time const &time, void (*f) (U1,U2,U3), T1 a1, T2 a2, T3 a3)
{
  return ScheduleReal (time, Simulator::MakeEvent (f, a1, a2, a3));
}

template <typename U1, typename U2, typename U3, typename U4,
          typename T1, typename T2, typename T3, typename T4>
EventId RealtimeSimulatorExtension::ScheduleReal (Time const &time, void (*f) (U1,U2,U3,U4), T1 a1, T2 a2, T3 a3, T4 a4) 
{
  return ScheduleReal (time, Simulator::MakeEvent (f, a1, a2, a3, a4));
}

template <typename U1, typename U2, typename U3, typename U4, typename U5,
          typename T1, typename T2, typename T3, typename T4, typename T5>
EventId RealtimeSimulatorExtension::ScheduleReal (Time const &time, void (*f) (U1,U2,U3,U4,U5), T1 a1, T2 a2, T3 a3, T4 a4, T5 a5) 
{
  return ScheduleReal (time, Simulator::MakeEvent (f, a1, a2, a3, a4, a5));
}

template <typename MEM, typename OBJ>
EventId
RealtimeSimulatorExtension::ScheduleRealNow (MEM mem_ptr, OBJ obj) 
{
  return ScheduleRealNow (Simulator::MakeEvent (mem_ptr, obj));
}

template <typename MEM, typename OBJ, 
          typename T1>
EventId
RealtimeSimulatorExtension::ScheduleRealNow (MEM mem_ptr, OBJ obj, T1 a1) 
{
  return ScheduleRealNow (Simulator::MakeEvent (mem_ptr, obj, a1));
}

template <typename MEM, typename OBJ, 
          typename T1, typename T2>
EventId
RealtimeSimulatorExtension::ScheduleRealNow (MEM mem_ptr, OBJ obj, T1 a1, T2 a2) 
{
  return ScheduleRealNow (Simulator::MakeEvent (mem_ptr, obj, a1, a2));
}

template <typename MEM, typename OBJ, 
          typename T1, typename T2, typename T3>
EventId
RealtimeSimulatorExtension::ScheduleRealNow (MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3) 
{
  return ScheduleRealNow (Simulator::MakeEvent (mem_ptr, obj, a1, a2, a3));
}

template <typename MEM, typename OBJ, 
          typename T1, typename T2, typename T3, typename T4>
EventId
RealtimeSimulatorExtension::ScheduleRealNow (MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3, T4 a4) 
{
  return ScheduleRealNow (Simulator::MakeEvent (mem_ptr, obj, a1, a2, a3, a4));
}

template <typename MEM, typename OBJ, 
          typename T1, typename T2, typename T3, typename T4, typename T5>
EventId
RealtimeSimulatorExtension::ScheduleRealNow (MEM mem_ptr, OBJ obj, 
                        T1 a1, T2 a2, T3 a3, T4 a4, T5 a5) 
{
  return ScheduleRealNow (Simulator::MakeEvent (mem_ptr, obj, a1, a2, a3, a4, a5));
}

template <typename U1,
          typename T1>
EventId
RealtimeSimulatorExtension::ScheduleRealNow (void (*f) (U1), T1 a1) 
{
  return ScheduleRealNow (Simulator::MakeEvent (f, a1));
}

template <typename U1, typename U2,
          typename T1, typename T2>
EventId
RealtimeSimulatorExtension::ScheduleRealNow (void (*f) (U1,U2), T1 a1, T2 a2) 
{
  return ScheduleRealNow (Simulator::MakeEvent (f, a1, a2));
}

template <typename U1, typename U2, typename U3,
          typename T1, typename T2, typename T3>
EventId
RealtimeSimulatorExtension::ScheduleRealNow (void (*f) (U1,U2,U3), T1 a1, T2 a2, T3 a3)
{
  return ScheduleRealNow (Simulator::MakeEvent (f, a1, a2, a3));
}

template <typename U1, typename U2, typename U3, typename U4,
          typename T1, typename T2, typename T3, typename T4>
EventId
RealtimeSimulatorExtension::ScheduleRealNow (void (*f) (U1,U2,U3,U4), T1 a1, T2 a2, T3 a3, T4 a4) 
{
  return ScheduleRealNow (Simulator::MakeEvent (f, a1, a2, a3, a4));
}

template <typename U1, typename U2, typename U3, typename U4, typename U5,
          typename T1, typename T2, typename T3, typename T4, typename T5>
EventId
RealtimeSimulatorExtension::ScheduleRealNow (void (*f) (U1,U2,U3,U4,U5), T1 a1, T2 a2, T3 a3, T4 a4, T5 a5) 
{
  return ScheduleRealNow (Simulator::MakeEvent (f, a1, a2, a3, a4, a5));
}

}; // namespace ns3

#endif /* REALTIME_SIMULATOR_H */

(-)a/src/simulator/simulator.h (+2 lines)

Lines 56-61 class SimulatorImpl;	Link Here

*/

*/

class Simulator

class Simulator

  friend class RealtimeSimulatorExtension;

public:

public:

/**

/**

   * \param impl a new simulator implementation

   * \param impl a new simulator implementation

(-)a/src/simulator/wscript (+2 lines)

Lines 61-66 def build(bld):	Link Here

        'heap-scheduler.cc',

        'heap-scheduler.cc',

        'event-impl.cc',

        'event-impl.cc',

        'simulator.cc',

        'simulator.cc',

        'realtime-simulator.cc',

        'default-simulator-impl.cc',

        'default-simulator-impl.cc',

        'timer.cc',

        'timer.cc',

        'watchdog.cc',

        'watchdog.cc',

Lines 75-80 def build(bld):	Link Here

        'event-id.h',

        'event-id.h',

        'event-impl.h',

        'event-impl.h',

        'simulator.h',

        'simulator.h',

        'realtime-simulator.h',

        'simulator-impl.h',

        'simulator-impl.h',

        'default-simulator-impl.h',

        'default-simulator-impl.h',

        'scheduler.h',

        'scheduler.h',

(-)a/samples/main-test-sync.cc (-5 / +48 lines)

Lines 1-9	Link Here

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

#include "ns3/simulator.h"

#include "ns3/simulator.h"

#include "ns3/realtime-simulator.h"

#include "ns3/nstime.h"

#include "ns3/nstime.h"

#include "ns3/log.h"

#include "ns3/log.h"

#include "ns3/wall-clock-synchronizer.h"

#include "ns3/system-thread.h"

#include "ns3/system-thread.h"

#include "ns3/string.h"

#include "ns3/string.h"

#include "ns3/config.h"

#include "ns3/config.h"

Lines 48-58 public:	Link Here

  FakeNetDevice ();

  FakeNetDevice ();

  void Doit1 (void);

  void Doit1 (void);

  void Doit2 (void);

  void Doit2 (void);

  void Doit3 (void);

  void Doit4 (void);

};

};

FakeNetDevice::FakeNetDevice ()

FakeNetDevice::FakeNetDevice ()

  NS_LOG_FUNCTION_NOARGS ();

  NS_LOG_FUNCTION_NOARGS ();

  void

FakeNetDevice::Doit1 (void)

  NS_LOG_FUNCTION_NOARGS ();

  sleep (1);

  for (uint32_t i = 0.001; i < 10000; ++i)

//

      // Exercise the relative now path

//

      Simulator::ScheduleNow (&inserted_function);

      usleep (1000);

  void

  void

Lines 71-86 FakeNetDevice::Doit2 (void)	Link Here

  void

  void

FakeNetDevice::Doit1 (void)

FakeNetDevice::Doit3 (void)

  NS_LOG_FUNCTION_NOARGS ();

  NS_LOG_FUNCTION_NOARGS ();

  sleep (1);

  sleep (1);

  for (uint32_t i = 0.001; i < 10000; ++i)

  for (uint32_t i = 0.001; i < 10000; ++i)

//

      // Exercise the ScheduleNow path

//

//

      Simulator::ScheduleNow (&inserted_function);

      // Exercise the realtime relative now path

//

100

      RealtimeSimulatorExtension::ScheduleRealNow (&inserted_function);

101

      usleep (1000);

102

103

104

105

  void

106

FakeNetDevice::Doit4 (void)

107

108

  NS_LOG_FUNCTION_NOARGS ();

109

  sleep (1);

110

  for (uint32_t i = 0.001; i < 10000; ++i)

111

112

//

113

      // Exercise the realtime relative schedule path

114

//

115

      RealtimeSimulatorExtension::ScheduleReal (Seconds (0), &inserted_function);

      usleep (1000);

116

      usleep (1000);

117

118

Lines 109-122 test (void)	Link Here

109

  Ptr<SystemThread> st1 = Create<SystemThread> (

141

  Ptr<SystemThread> st1 = Create<SystemThread> (

110

    MakeCallback (&FakeNetDevice::Doit1, &fnd));

142

    MakeCallback (&FakeNetDevice::Doit1, &fnd));

111

  st1->Start ();

143

  st1->Start ();

144

112

  Ptr<SystemThread> st2 = Create<SystemThread> (

145

  Ptr<SystemThread> st2 = Create<SystemThread> (

113

    MakeCallback (&FakeNetDevice::Doit2, &fnd));

146

    MakeCallback (&FakeNetDevice::Doit2, &fnd));

114

  st2->Start ();

147

  st2->Start ();

148

149

  Ptr<SystemThread> st3 = Create<SystemThread> (

150

    MakeCallback (&FakeNetDevice::Doit3, &fnd));

151

  st3->Start ();

152

153

  Ptr<SystemThread> st4 = Create<SystemThread> (

154

    MakeCallback (&FakeNetDevice::Doit4, &fnd));

155

  st4->Start ();

115

156

116

  Simulator::Stop (Seconds (15.0));

157

  Simulator::Stop (Seconds (15.0));

117

  Simulator::Run ();

158

  Simulator::Run ();

118

  st1->Join ();

159

  st1->Join ();

119

  st2->Join ();

160

  st2->Join ();

161

  st3->Join ();

162

  st4->Join ();

120

  Simulator::Destroy ();

163

  Simulator::Destroy ();

121

164

122

165




//
// Schedule an event for a _relative_ time in the future.
//
// A little side-note on events and multthreading:
//
// This is a little tricky.  We get a Ptr<EventImpl> passed down to us in some
// thread context.  This Ptr<EventImpl> is not yet shared in any way.  It is 
// possible however that the calling context is not the context of the main 
// scheduler thread (e.g. it is in the context of a separate device thread).  
// It would be bad (TM) if we naively wrapped the EventImpl up in an EventId 
// that would be accessible from multiple threads without considering thread 
// safety.
//
// It's clear that we cannot have a situation where the EventImpl is "owned" by
// multiple threads.  The calling thread is free to hold the EventId as long as
// it wants and manage the reference counts to the underlying EventImpl all it
// wants.  The scheduler is free to do the same; and will eventually release
// the reference in the context of thread running ProcessOneEvent().  It is 
// "a bad thing" (TM) if these two threads decide to release the underlying
// EventImpl "at the same time" since the result is sure to be multiple frees,
// memory leaks or bus errors.
//
// The answer is to make the reference counting of the EventImpl thread safe; 
// which we do.  We don't want to force the event implementation to carry around
// a mutex, so we "lend" it one using a RealtimeEventLock object (m_eventLock)
// in the constructor of the event and take it back in the destructor.  See the
// event code for details.
//
EventId
RealtimeSimulatorImpl::Schedule (Time const &time, const Ptr<EventImpl> &event)
{
  NS_LOG_FUNCTION (time << event);

  //
  // This is a little tricky.  We get a Ptr<EventImpl> passed down to us in some
  // thread context.  This Ptr<EventImpl> is not yet shared in any way.  It is 
  // possible however that the calling context is not the context of the main 
  // scheduler thread (e.g. it is in the context of a separate device thread).  
  // It would be bad (TM) if we naively wrapped the EventImpl up in an EventId 
  // that would be accessible from multiple threads without considering thread 
  // safety.
  //
  // It's clear that we cannot have a situation where the EventImpl is "owned" by
  // multiple threads.  The calling thread is free to hold the EventId as long as
  // it wants and manage the reference counts to the underlying EventImpl all it
  // wants.  The scheduler is free to do the same; and will eventually release
  // the reference in the context of thread running ProcessOneEvent().  It is 
  // "a bad thing" (TM) if these two threads decide to release the underlying
  // EventImpl "at the same time" since the result is sure to be multiple frees,
  // memory leaks or bus errors.
  //
  // The answer is to make the reference counting of the EventImpl thread safe; 
  // which we do.  We don't want to force the event implementation to carry around
  // a mutex, so we "lend" it one using a RealtimeEventLock object (m_eventLock)
  // in the constructor of the event and take it back in the destructor.  See the
  // event code for details.
  //
  EventId id;
  {
    CriticalSection cs (m_mutex);

RealtimeSimulatorImpl::ScheduleReal (Time const &time, const Ptr<EventImpl> &event)
{
  NS_LOG_FUNCTION (time << event);

  EventId id;
  {
    CriticalSection cs (m_mutex);

    uint64_t ts = m_synchronizer->GetCurrentRealtime () + time.GetTimeStep ();
    NS_ASSERT_MSG (ts >= m_currentTs, "RealtimeSimulatorImpl::ScheduleReal(): schedule for time < m_currentTs");
    id = EventId (event, ts, m_uid);
    m_uid++;
    ++m_unscheduledEvents;
    m_events->Insert (id);
    m_synchronizer->Signal ();
  }

  return id;
}

EventId
RealtimeSimulatorImpl::ScheduleRealNow (const Ptr<EventImpl> &event)
{
  NS_LOG_FUNCTION_NOARGS ();
  NS_ASSERT (false);
  EventId id;
  {
    CriticalSection cs (m_mutex);

    uint64_t ts = m_synchronizer->GetCurrentRealtime ();
    NS_ASSERT_MSG (ts >= m_currentTs, "RealtimeSimulatorImpl::ScheduleRealNow(): schedule for time < m_currentTs");
    id = EventId (event, ts, m_uid);
    m_uid++;
    ++m_unscheduledEvents;
    m_events->Insert (id);
    m_synchronizer->Signal ();
  }

  return id;
}

Time
RealtimeSimulatorImpl::RealNow (void) const
{
  return TimeStep (m_synchronizer->GetCurrentRealtime ());
  return TimeStep (m_currentTs);
}


EventId
RealtimeSimulatorImpl::ScheduleDestroy (const Ptr<EventImpl> &event)

(-)a/samples/main-test-sync.cc (-2 / +2 lines)

Lines 126-134 test (void)	Link Here

126

  FakeNetDevice fnd;

126

  FakeNetDevice fnd;

127

128

//

128

//

129

  // Make sure ScheduleNow works when the system isn't running

129

  // Make sure ScheduleRealNow works when the system isn't running

130

//

130

//

131

  Simulator::ScheduleNow(&first_function);

131

  RealtimeSimulatorExtension::ScheduleRealNow(&first_function);

132

133

//

133

//

134

  // drive the progression of m_currentTs at a ten millisecond rate

134

  // drive the progression of m_currentTs at a ten millisecond rate

(-)a/src/simulator/realtime-simulator-impl.cc (-1 / +5 lines)

Lines 657-663 RealtimeSimulatorImpl::ScheduleRealNow (	Link Here

657

658

    CriticalSection cs (m_mutex);

658

    CriticalSection cs (m_mutex);

659

660

    uint64_t ts = m_synchronizer->GetCurrentRealtime ();

660

//

661

    // If the simulator is running, we're pacing and have a meaningful

662

    // realtime clock.  If we're not, then m_currentTs is were we stopped.

663

//

664

    uint64_t ts = m_running ? m_synchronizer->GetCurrentRealtime () : m_currentTs;

661

    NS_ASSERT_MSG (ts >= m_currentTs, "RealtimeSimulatorImpl::ScheduleRealNow(): schedule for time < m_currentTs");

665

    NS_ASSERT_MSG (ts >= m_currentTs, "RealtimeSimulatorImpl::ScheduleRealNow(): schedule for time < m_currentTs");

662

    id = EventId (event, ts, m_uid);

666

    id = EventId (event, ts, m_uid);

663

    m_uid++;

667

    m_uid++;

Return to bug 376