System.h

Go to the documentation of this file.

/** @file System.h
* @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.
* =================================================================
*/

#ifndef DREAM_SYSTEM
#define DREAM_SYSTEM

#include "Scheduler.h"

namespace DREAM
{

class PriorityInversionList;

/** Distributed Real-time Embedded system model.
* This class implements the DRE model of computation for analyzing the distributed real-time scheduling of
* embedded systems.
*/
class System
{
public:
        /** Constructor. */
        System ();

        /** Destructor. */
        virtual ~System ();

        /** Adds a Scheduler into the overall model of computation.
        * @param scheduler_ptr specifies the Scheduler to be added.
        */
        void add_scheduler (DREAM::Scheduler* scheduler_ptr);

#ifdef DREAM_RACE_CONDITION
        /** Clears the priority list and frees up memory. */
        void destroy_priority_list ();
#endif

        /** Returns the number of CPUs in the system. */
        uint CPUs () const;

#ifdef DREAM_RACE_CONDITION
        /** This function returns which Task to execute given the parameter AVL tree. */
        DREAM::Task* find_current (const DREAM::TASK_AVLTREE* task_avltree_ptr, DREAM::Task* task_ptr) const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** This function introduces a single priority inversion in the priority_list_ptr_.
        * The function returns false if all permutations of priority inversions have been checked.
        */
        virtual bool inversion ();
#endif

        /** Returns the time of the next event. */
        virtual double next_event (bool deterministic) const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Resets Schedulers (when restarting the simulation). */
        virtual void reset ();

        /** Returns relevant_event_. */
        virtual bool relevant_event () const;

        /** Tasks call this function when publishing to signal that their event has to be considered for model checking. */
        virtual void relevant_event (bool value);

        /** Returns the Scheduler map.
        * Used in output generation.
        * @return a pointer to the scheduler_map_.
        */
        virtual const DREAM::SCHEDULER_MAP* scheduler_map ()
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Starts deterministic simulation.
        * This simulation will simulate a deterministic trace of the system.
        * @param verbose specifies whether messages will be generated.
        * @param deterministic specifies whether deterministic schedule is assumed.
        * @param endtoend updates the pointer's target with the end-to-end execution time of the model (unless the pointer is NULL).
        */
        virtual void simulate (bool verbose, bool deterministic, double* endtoend = NULL);

        /** This function builds the error list.
        * The function is used by genetic algorithms.
        * @param task_avltree stores the list of Tasks from the Scheduler error list.
        */
        virtual void visitor_error_avltree (DREAM::TASK_AVLTREE* task_avltree)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** This function is part of the IF system description generator.
        * @param task_map stores the Task pointers.
        * @param channel_map stores the Channel pointers.
        * @param timer_map stores the Timer pointers.
        * @param f_stream is the output stream to be written to.
        */
        virtual void 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
        ;

        /** This function fills the IDs (names) of tasks, channels and timers to the parameter lists.
        * The function is used to generate output for model checkers.
        * @param task_map stores the Task pointers.
        * @param channel_map stores the Channel pointers.
        * @param timer_map stores the Timer pointers.
        */
        virtual void 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
        ;

        /** This function builds the task list for manipulation.
        * The function is used by genetic algorithms.
        * @param task_avltree stores the Task pointers.
        */
        virtual void visitor_task_avltree (DREAM::TASK_AVLTREE* task_avltree)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** This function updates task values in the system.
        * The function is used by genetic algorithms.
        * @param task_avltree stores the Task pointers.
        */
        virtual void visitor_update_task_avltree (DREAM::TASK_AVLTREE* task_avltree)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** This function is part of the Uppaal system description generator.
        * @param task_map stores the Task pointers.
        * @param channel_map stores the Channel pointers.
        * @param timer_map stores the Timer pointers.
        * @param f_stream is the output stream to be written to.
        */
        virtual void 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
        ;

private:

        /** Flag to signal end of event loop. */
        bool active_;

        /** List of all the Schedulers in the model of computation. */
        DREAM::SCHEDULER_MAP scheduler_map_;

        /** Clock for the System. */
        double time_;

#ifdef DREAM_RACE_CONDITION
        /** Queue that stores tasks that need to be checked for race conditions.
        * The model checker implements the checks by introducing artificial priority inversions at simulation time.
        */
        DREAM::PriorityInversionList* priority_list_ptr_;
#endif

        /** This variable is set to true if branching points have to be considered for the actual event. */
        bool relevant_event_;
};

}

#endif

---