simulation.h

Go to the documentation of this file.

#pragma once
#ifndef SYDEVS_SYSTEMS_SIMULATION_H_
#define SYDEVS_SYSTEMS_SIMULATION_H_
 
#include <sydevs/systems/system_node.h>
#include <sydevs/time/time_queue.h>
#include <sydevs/time/time_cache.h>
 
namespace sydevs {
namespace systems {
 
 
template<typename Node>
class simulation
{
public:
    simulation(const time_point& start_t, const time_point& end_t, bool can_end_early, int64 seed, std::ostream& stream);
 
    simulation(duration total_dt, int64 seed, std::ostream& stream);
 
    simulation(const simulation&)            = delete;   
    simulation& operator=(const simulation&) = delete;   
    simulation(simulation&&)                 = delete;   
    simulation& operator=(simulation&&)      = delete;   
    virtual ~simulation()                    = default;  
 
    const time_point& start_time() const;  
    const time_point& end_time() const;    
    bool can_end_early() const;            
 
    bool started() const;    
    bool finishing() const;  
    bool finished() const;   
 
    const discrete_event_time& time() const;  
    duration imminent_duration() const;       
 
    void process_next_event();                        
    int64 process_next_events();                      
    int64 process_events_until(const time_point& t);  
    int64 process_remaining_events();                 
 
    const timer& event_timer() const;  
 
private:
    node_interface& top_IO();
    discrete_event_time& event_time();
    void validate();
 
    void process_initialization_event();
    void process_planned_event();
    void process_finalization_event();
    void advance_time();
 
    const time_point start_t_;       // (must be declared before member variable external_context_)
    const time_point end_t_;
    bool can_end_early_;
    node_context external_context_;  // (must be declared before member variable top)
    bool started_;
    bool finishing_;
    bool finished_;
    time_queue t_queue_;
    time_cache t_cache_;
    timer event_timer_;
 
public:
    Node top;  
};
 
 
template<typename Node>
inline simulation<Node>::simulation(const time_point& start_t, const time_point& end_t, bool can_end_early, int64 seed, std::ostream& stream)
    : start_t_(start_t)
    , end_t_(end_t)
    , can_end_early_(can_end_early)
    , external_context_(start_t, seed, stream)
    , started_(false)
    , finishing_(false)
    , finished_(false)
    , t_queue_(start_t)
    , t_cache_(start_t)
    , event_timer_()
    , top("top", external_context_)
{
    validate();
}
 
 
template<typename Node>
inline simulation<Node>::simulation(duration total_dt, int64 seed, std::ostream& stream)
    : start_t_()
    , end_t_(total_dt.finite() ? time_point() + total_dt : 
                                 time_point() + duration(1, scale(std::numeric_limits<scale::level_type>::max() - 6)))
    , can_end_early_(!total_dt.finite())
    , external_context_(start_t_, seed, stream)
    , started_(false)
    , finishing_(false)
    , finished_(false)
    , t_queue_()
    , t_cache_()
    , event_timer_()
    , top("top", external_context_)
{
    validate();
}
 
 
template<typename Node>
inline const time_point& simulation<Node>::start_time() const
{
    return start_t_;
}
 
 
template<typename Node>
inline const time_point& simulation<Node>::end_time() const
{
    return end_t_;
}
 
    
template<typename Node>
inline bool simulation<Node>::can_end_early() const
{
    return can_end_early_;
}
 
 
template<typename Node>
inline bool simulation<Node>::started() const
{
    return started_;
}
 
 
template<typename Node>
inline bool simulation<Node>::finishing() const
{
    return finishing_;
}
 
    
template<typename Node>
inline bool simulation<Node>::finished() const
{
    return finished_;
}
 
 
template<typename Node>
inline const discrete_event_time& simulation<Node>::time() const
{
    return const_cast<node_context&>(external_context_).event_time();
}
 
 
template<typename Node>
inline duration simulation<Node>::imminent_duration() const
{
    return t_queue_.imminent_duration();
}
 
 
template<typename Node>
inline void simulation<Node>::process_next_event()
{
    if (!finished_) {
        if (!finishing_) {
            if (!started_) {
                process_initialization_event();
            }
            else {
                process_planned_event();
            }
            advance_time();        
        }
        else {
            process_finalization_event();
        }
    }
}
 
 
template<typename Node>
inline int64 simulation<Node>::process_next_events()
{
    int64 event_count = 0;
    auto t = event_time().t();
    while (!finished_ && event_time().t() == t) {
        process_next_event();
        ++event_count;
    }
    return event_count;
}
 
 
template<typename Node>
inline int64 simulation<Node>::process_events_until(const time_point& t)
{
    int64 event_count = 0;
    while (!finished_ && event_time().t() < t) {
        process_next_event();
        ++event_count;
    }
    return event_count;
}
 
 
template<typename Node>
inline int64 simulation<Node>::process_remaining_events()
{
    int64 event_count = 0;
    while (!finished_) {
        process_next_event();
        ++event_count;
    }
    return event_count;
}
 
 
template<typename Node>
inline const timer& simulation<Node>::event_timer() const
{
    return event_timer_;
}
 
 
template<typename Node>
inline node_interface& simulation<Node>::top_IO()
{
    return const_cast<node_interface&>(top.external_interface());
}
 
 
template<typename Node>
inline discrete_event_time& simulation<Node>::event_time()
{
    return external_context_.event_time();
}
 
 
template<typename Node>
inline void simulation<Node>::validate()
{
    static_assert(std::is_base_of<system_node, Node>::value, "Node must inherit from system_node");
 
    if (top_IO().flow_input_port_count() != 0 ||
        top_IO().message_input_port_count() != 0 ||
        top_IO().message_output_port_count() != 0 ||
        top_IO().flow_output_port_count() != 0) {
        throw std::invalid_argument("Node to be simulated must have no ports");
    }
}
 
 
template<typename Node>
inline void simulation<Node>::process_initialization_event()
{
    started_ = true;
    top_IO().print_event("initialization");
    top_IO().activate(flow, input);
    event_timer_.start();
    auto planned_dt = top.process_initialization_event();
    event_timer_.stop();
    top_IO().deactivate();
    if (planned_dt.finite()) {
        t_queue_.plan_event(0, planned_dt);
    }
    if (top.time_precision() != no_scale) {
        t_cache_.retain_event(0, top.time_precision());
    }
}
 
 
template<typename Node>
inline void simulation<Node>::process_planned_event()
{
    top_IO().print_event("planned");
    auto elapsed_dt = duration();
    if (top.time_precision() != no_scale) {
        elapsed_dt = t_cache_.duration_since(0).fixed_at(top.time_precision());
    }
    top_IO().activate(message, output);
    event_timer_.start();
    auto planned_dt = top.process_planned_event(elapsed_dt);
    event_timer_.stop();
    top_IO().deactivate();
    if (planned_dt.finite()) {
        t_queue_.plan_event(0, planned_dt);
    }
    else {
        t_queue_.pop_imminent_event(0);
    }
    if (top.time_precision() != no_scale) {
        t_cache_.retain_event(0, top.time_precision());
    }
}
 
 
template<typename Node>
inline void simulation<Node>::process_finalization_event()
{
    top_IO().print_event("finalization");
    auto elapsed_dt = duration();
    if (top.time_precision() != no_scale) {
        elapsed_dt = t_cache_.duration_since(0).fixed_at(top.time_precision());
    }
    top_IO().activate(flow, output);
    event_timer_.start();
    top.process_finalization_event(elapsed_dt);
    event_timer_.stop();
    top_IO().deactivate();
    finished_ = true;
}
 
 
template<typename Node>
inline void simulation<Node>::advance_time()
{
    if (!finishing_) {
        auto planned_dt = t_queue_.imminent_duration();
        if (planned_dt.finite() || !can_end_early_) {
            // The event time must advance.
            event_time().advance(planned_dt, end_t_);
            if (planned_dt > 0_s) {
                // The simulated time just advanced.
                external_context_.time_printed() = false;
                t_queue_.advance_time(event_time().t());
                t_cache_.advance_time(event_time().t());
            }
            if (event_time().t() >= end_t_) {
                // The end time has been reached.
                finishing_ = true;
            }
        }
        else {
            // The simulation must finish at the current event time.
            finishing_ = true;
        }
    }
}
 
 
}  // namespace
}  // namespace
 
#endif