System.cpp

Go to the documentation of this file.

/** @file System.cpp
* @author Gabor Madl
* @date Created 05/2005
* @brief Distributed Real-time Embedded system model of computation.
*
*
* =================================================================
* DREAM License v2.0
* 
* DREAM - Distributed Real-time Embedded Analysis Method
* http://dre.sourceforge.net.
* Copyright (c) 2005-2007 Gabor Madl, All Rights Reserved.
* 
* This file is part of DREAM.
* 
* DREAM 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. No future versions of
* the GPL license may be automatically applied to DREAM. It is in
* the sole discretion of the copyright holder to determine whether
* DREAM may be released under a different license or terms. There
* are no restrictions on the use of DREAM for any purpose.
* 
* DREAM 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., 51 Franklin Street, Fifth Floor, Boston,
* MA 02110-1301, USA.
* 
* By submitting comments, suggestions, code, code snippets,
* techniques (including that of usage), and algorithms, submitters
* acknowledge that they have the right to do so, that any such
* submissions are given freely and unreservedly, and that they
* waive any claims to copyright or ownership. In addition,
* submitters acknowledge that any such submission might become
* part of the copyright maintained on the overall body of code,
* which comprises DREAM. By making a submission, submitter agrees
* to these terms. Furthermore, submitters acknowledge that the
* incorporation or modification of such submissions is entirely
* at the discretion of the moderators of the DREAM project.
* 
* DREAM links to the Libxml2 third party library. Please see 
* COPYING-libxml for the copyright information of Libxml2.
* =================================================================
*/

#include "System.h"

namespace DREAM
{

System::System ()
: active_ (true),
time_ (0),
relevant_event_ (false)
{
#ifdef DREAM_RACE_CONDITION
        priority_list_ptr_ = new DREAM::PriorityInversionList (this);
#endif
}

System::~System ()
{
        std::for_each (scheduler_map_.begin (), scheduler_map_.end (), delete_pair ());

#ifdef DREAM_RACE_CONDITION
        delete priority_list_ptr_;
#endif
}

void System::add_scheduler (DREAM::Scheduler* scheduler_ptr)
{
        scheduler_map_.insert (DREAM::SCHEDULER_PAIR (scheduler_ptr->id (), scheduler_ptr));
}

#ifdef DREAM_RACE_CONDITION
void System::destroy_priority_list ()
{
        priority_list_ptr_->destroy ();
}
#endif

uint System::CPUs () const
{
        DREAM::SCHEDULER_MAP::const_iterator scheduler_iter;
        uint CPUs = 0;

        for (scheduler_iter = scheduler_map_.begin (); scheduler_iter != scheduler_map_.end (); scheduler_iter++)
        {
                CPUs += scheduler_iter->second->CPUs ();
        }

        return CPUs;
}

#ifdef DREAM_RACE_CONDITION
DREAM::Task* System::find_current (const DREAM::TASK_AVLTREE* task_avltree_ptr, DREAM::Task* task_ptr) const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
        return (priority_list_ptr_->find_current (task_avltree_ptr, task_ptr));
}

bool System::inversion ()
{
        return priority_list_ptr_->inversion ();
}
#endif

double System::next_event (bool deterministic) const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
        DREAM::SCHEDULER_MAP::const_iterator scheduler_iter;
        double step, temp;

        step = 0.0;

        for (scheduler_iter = scheduler_map_.begin (); scheduler_iter != scheduler_map_.end (); scheduler_iter++)
        {
                temp = scheduler_iter->second->next_event (deterministic);

                if ((step == 0.0) || ((temp < step) && (0.0 < temp)))
                        step = temp;
        }

        return step;
}

inline bool System::relevant_event () const
{
        return relevant_event_;
}

inline void System::relevant_event (bool value)
{
        relevant_event_ = value;
}

void System::reset ()
{
        std::for_each (scheduler_map_.begin (), scheduler_map_.end (), reset_pair ());
        time_ = 0;
}

inline const DREAM::SCHEDULER_MAP* System::scheduler_map ()
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
        return &scheduler_map_;
}

void System::simulate (bool verbose, bool deterministic, double* endtoend)
{
        if (verbose)
                if (deterministic)
                        std::cout << std::endl << "Deterministic distributed discrete event simulation." << std::endl << std::endl;
                else
                        std::cout << std::endl << "Non-deterministic distributed discrete event simulation." << std::endl << std::endl;

        DREAM::SCHEDULER_MAP::iterator scheduler_iter;
        // Reduce number of calls on verbose...
        for (scheduler_iter = scheduler_map_.begin (); scheduler_iter != scheduler_map_.end (); scheduler_iter++)
                scheduler_iter->second->verbose (verbose);

        active_ = true;
        double step, temp, exec_time = 0.0;

        while (active_)
        {
                step = 0.0;

                for (scheduler_iter = scheduler_map_.begin (); scheduler_iter != scheduler_map_.end (); scheduler_iter++)
                {
                        temp = scheduler_iter->second->next_event (deterministic);

                        if ((step == 0.0) || ((0.0 < temp) && (temp < step)))
                                step = temp;
                }

                time_ += step;

                if (time_ < Option::simulation_time_)
                        exec_time += step;

                for (scheduler_iter = scheduler_map_.begin (); scheduler_iter != scheduler_map_.end (); scheduler_iter++)
                        scheduler_iter->second->time_step (step);

                relevant_event_ = false;

                std::for_each (scheduler_map_.begin (), scheduler_map_.end (), transition_pair ());

                for (scheduler_iter = scheduler_map_.begin (); scheduler_iter != scheduler_map_.end (); scheduler_iter++)
                        scheduler_iter->second->schedule (deterministic);

                if ((time_ >= Option::simulation_time_) || (step == 0.0))
                {
                        active_ = false;

                        std::for_each (scheduler_map_.begin (), scheduler_map_.end (), stop_pair ());

                        if (endtoend != NULL)
                                *endtoend = exec_time;

                        if (verbose)
                                std::cout << "Simulation ended. End-to-end execution time: " << exec_time << std::endl;
                }
        }
}

void System::visitor_error_avltree (DREAM::TASK_AVLTREE* task_avltree)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
        DREAM::SCHEDULER_MAP::iterator scheduler_iter;

        for (scheduler_iter = scheduler_map_.begin (); scheduler_iter != scheduler_map_.end (); scheduler_iter++)
        {
                scheduler_iter->second->visitor_error_avltree (task_avltree);
        }
}

void System::visitor_if (DREAM::NODE_MAP* task_map, DREAM::NODE_MAP* channel_map, DREAM::NODE_MAP* timer_map, std::ofstream& f_stream)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
        DREAM::SCHEDULER_MAP::iterator scheduler_iter;

        for (scheduler_iter = scheduler_map_.begin (); scheduler_iter != scheduler_map_.end (); scheduler_iter++)
        {
                scheduler_iter->second->visitor_if (task_map, channel_map, timer_map, f_stream);
        }
}

void System::visitor_map (DREAM::NODE_MAP* task_map, DREAM::NODE_MAP* channel_map, DREAM::NODE_MAP* timer_map)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
        DREAM::SCHEDULER_MAP::iterator scheduler_iter;

        for (scheduler_iter = scheduler_map_.begin (); scheduler_iter != scheduler_map_.end (); scheduler_iter++)
        {
                scheduler_iter->second->visitor_map (task_map, channel_map, timer_map);
        }
}

void System::visitor_task_avltree (DREAM::TASK_AVLTREE* task_avltree)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
        DREAM::SCHEDULER_MAP::iterator scheduler_iter;

        for (scheduler_iter = scheduler_map_.begin (); scheduler_iter != scheduler_map_.end (); scheduler_iter++)
        {
                scheduler_iter->second->visitor_task_avltree (task_avltree);
        }
}

void System::visitor_update_task_avltree (DREAM::TASK_AVLTREE* task_avltree)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
        DREAM::SCHEDULER_MAP::iterator scheduler_iter;

        for (scheduler_iter = scheduler_map_.begin (); scheduler_iter != scheduler_map_.end (); scheduler_iter++)
        {
                scheduler_iter->second->visitor_update_task_avltree (task_avltree);
        }
}

void System::visitor_uppaal (DREAM::NODE_MAP* task_map, DREAM::NODE_MAP* channel_map, DREAM::NODE_MAP* timer_map, std::ofstream& f_stream)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
        DREAM::SCHEDULER_MAP::iterator scheduler_iter;

        for (scheduler_iter = scheduler_map_.begin (); scheduler_iter != scheduler_map_.end (); scheduler_iter++)
        {
                scheduler_iter->second->visitor_uppaal (task_map, channel_map, timer_map, f_stream);
        }
}

}

---