null-message-simulator-impl.h

Go to the documentation of this file.

/*
 *  Copyright 2013. Lawrence Livermore National Security, LLC.
 *
 * SPDX-License-Identifier: GPL-2.0-only
 *
 * Author: Steven Smith <smith84@llnl.gov>
 */
 
/**
 * \file
 * \ingroup mpi
 * Declaration of class ns3::NullMessageSimulatorImpl.
 */
 
#ifndef NULLMESSAGE_SIMULATOR_IMPL_H
#define NULLMESSAGE_SIMULATOR_IMPL_H
 
#include <ns3/event-impl.h>
#include <ns3/ptr.h>
#include <ns3/scheduler.h>
#include <ns3/simulator-impl.h>
 
#include <fstream>
#include <iostream>
#include <list>
 
namespace ns3
{
 
class NullMessageEvent;
class NullMessageMpiInterface;
class RemoteChannelBundle;
 
/**
 * \ingroup mpi
 *
 * \brief Simulator implementation using MPI and a Null Message algorithm.
 */
class NullMessageSimulatorImpl : public SimulatorImpl
{
  public:
    /**
     *  Register this type.
     *  \return The object TypeId.
     */
    static TypeId GetTypeId();
 
    /** Default constructor. */
    NullMessageSimulatorImpl();
 
    /** Destructor. */
    ~NullMessageSimulatorImpl() override;
 
    // virtual from SimulatorImpl
    void Destroy() override;
    bool IsFinished() const override;
    void Stop() override;
    EventId Stop(const Time& delay) override;
    EventId Schedule(const Time& delay, EventImpl* event) override;
    void ScheduleWithContext(uint32_t context, const Time& delay, EventImpl* event) override;
    EventId ScheduleNow(EventImpl* event) override;
    EventId ScheduleDestroy(EventImpl* event) override;
    void Remove(const EventId& id) override;
    void Cancel(const EventId& id) override;
    bool IsExpired(const EventId& id) const override;
    void Run() override;
 
    Time Now() const override;
    Time GetDelayLeft(const EventId& id) const override;
    Time GetMaximumSimulationTime() const override;
    void SetScheduler(ObjectFactory schedulerFactory) override;
    uint32_t GetSystemId() const override;
    uint32_t GetContext() const override;
    uint64_t GetEventCount() const override;
 
    /**
     * \return singleton instance
     *
     * Singleton accessor.
     */
    static NullMessageSimulatorImpl* GetInstance();
 
  private:
    friend class NullMessageEvent;
    friend class NullMessageMpiInterface;
    friend class RemoteChannelBundleManager;
 
    /**
     * Non blocking receive of pending messages.
     */
    void HandleArrivingMessagesNonBlocking();
 
    /**
     * Blocking receive of arriving messages.
     */
    void HandleArrivingMessagesBlocking();
 
    void DoDispose() override;
 
    /**
     * Calculate the lookahead allowable for this MPI task.   Basically
     * the minimum latency on links to neighbor MPI tasks.
     */
    void CalculateLookAhead();
 
    /**
     * Process the next event on the queue.
     */
    void ProcessOneEvent();
 
    /**
     * \return next local event time.
     */
    Time Next() const;
 
    /**
     * Calculate the SafeTime. Should be called after message receives.
     */
    void CalculateSafeTime();
 
    /**
     * Get the current SafeTime; the maximum time that events can
     * be processed based on information received from neighboring
     * MPI tasks.
     * \return the current SafeTime
     */
    Time GetSafeTime();
 
    /**
     * \param bundle Bundle to schedule Null Message event for
     *
     * Schedule Null Message event for the specified RemoteChannelBundle.
     */
    void ScheduleNullMessageEvent(Ptr<RemoteChannelBundle> bundle);
 
    /**
     * \param bundle Bundle to reschedule Null Message event for
     *
     * Reschedule Null Message event for the specified
     * RemoteChannelBundle.  Existing event will be canceled.
     */
    void RescheduleNullMessageEvent(Ptr<RemoteChannelBundle> bundle);
 
    /**
     * \param nodeSysId SystemID to reschedule null event for
     *
     * Reschedule Null Message event for the RemoteChannelBundle to the
     * task nodeSysId.  Existing event will be canceled.
     */
    void RescheduleNullMessageEvent(uint32_t nodeSysId);
 
    /**
     * \param systemId SystemID to compute guarantee time for
     *
     * \return Guarantee time
     *
     * Calculate the guarantee time for incoming RemoteChannelBundle
     * from task nodeSysId.  No message should arrive from task
     * nodeSysId with a receive time less than the guarantee time.
     */
    Time CalculateGuaranteeTime(uint32_t systemId);
 
    /**
     * \param bundle remote channel bundle to schedule an event for.
     *
     * Null message event handler.   Scheduled to send a null message
     * for the specified bundle at regular intervals.   Will canceled
     * and rescheduled when packets are sent.
     */
    void NullMessageEventHandler(RemoteChannelBundle* bundle);
 
    /** Container type for the events to run at Simulator::Destroy(). */
    typedef std::list<EventId> DestroyEvents;
 
    /** The container of events to run at Destroy() */
    DestroyEvents m_destroyEvents;
    /** Flag calling for the end of the simulation. */
    bool m_stop;
    /** The event priority queue. */
    Ptr<Scheduler> m_events;
 
    /** Next event unique id. */
    uint32_t m_uid;
    /** Unique id of the current event. */
    uint32_t m_currentUid;
    /** Timestamp of the current event. */
    uint64_t m_currentTs;
    /** Execution context of the current event. */
    uint32_t m_currentContext;
    /** The event count. */
    uint64_t m_eventCount;
    /**
     * Number of events that have been inserted but not yet scheduled,
     * not counting the "destroy" events; this is used for validation.
     */
    int m_unscheduledEvents;
 
    uint32_t m_myId;        /**< MPI rank. */
    uint32_t m_systemCount; /**< MPI communicator size. */
 
    /**
     * The time for which it is safe for this task to execute events
     * without danger of out-of-order events.
     */
    Time m_safeTime;
 
    /**
     * Null Message performance tuning parameter.  Controls when Null
     * messages are sent.  When value is 1 the minimum number of Null
     * messages are sent conserving bandwidth.  The delay in arrival of
     * lookahead information is the greatest resulting in maximum
     * unnecessary blocking of the receiver.  When the value is near 0
     * Null Messages are sent with high frequency, costing more
     * bandwidth and Null Message processing time, but there is minimum
     * unnecessary block of the receiver.
     */
    double m_schedulerTune;
 
    /** Singleton instance. */
    static NullMessageSimulatorImpl* g_instance;
};
 
} // namespace ns3
 
#endif /* NULLMESSAGE_SIMULATOR_IMPL_H */