Task.h

Go to the documentation of this file.

/** @file Task.h
* @author Gabor Madl
* @date Created 02/2005
* @brief Specifies basic elements in the DRE Semantic Domain.
*
*
* =================================================================
* 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_TASK
#define DREAM_TASK

/** Namespace used in the DREAM core */
namespace DREAM
{
        class Node;
        class Task;
}

#include <iostream>
#include <fstream>
#include "Thread.h"
#include "Scheduler.h"
#include "Exception.h"

namespace DREAM
{
/** State of the Task as specified by the DRE Semantic Domain. */
typedef enum task_state {idle, enabled, preempted, executing, error} State;

/** Generic Node class used to build the dependency graph.
*This class is the base class for every element in the DRE Semantic Domain.
*/
class Node
{
public:

        /** Constructor.
        * @param id specifies the name of the Node.
        * @param thread_ptr defines the mapping of the Node to a platform processor.
        * @param executed is used to check unexecuted tasks in a frame.
        */
        Node (const std::string& id, DREAM::Thread* thread_ptr, bool executed);

        /** Copy constructor for Nodes.
        * @param node is the pointer to the Node to be copied.
        */
        Node (const DREAM::Node& node);

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

        /** Adds a dependent Node to the current Node.
        * @param node_ptr is a pointer to the dependent Node to be added.
        */
        virtual void add_dependent (DREAM::Node* node_ptr);

        /** Generic nodes do not have best case execution times.
        * Inherited classes may implement this feature.
        */
        virtual uint bcet () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Generic nodes do not have best case execution times.
        * Inherited classes may implement this feature.
        */
        virtual void bcet (uint bcet)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

#ifdef DREAM_BRANCHING
        /** Generic nodes do not have branching points.
        * Inherited classes may implement this feature.
        */
        virtual void branching_point ()
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;
#endif

        /** Generic nodes do not have context.
        * Inherited classes may implement this feature.
        */
        virtual DREAM::Context context () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Generic nodes do not have context.
        * Inherited classes may implement this feature.
        */
        virtual void context (DREAM::Context context)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Generic nodes do not have deadline clocks.
        * Inherited classes may implement this feature.
        */
        virtual double clock_dl () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Generic nodes do not have deadline clocks.
        * Inherited classes may implement this feature.
        */
        virtual double clock_dl_reset () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Measures time spent executing.
        * @return The value of clock_exec_.
        */
        virtual double clock_exec () const;

        /** Reset execution clock value - clock_exec_. */
        virtual void clock_exec_reset ();

        /** Models the passing of time.
        * Increments local clock clock_exec_.
        * @param clock_step specifies by how much do we have to increment the time.
        */
        virtual void clock_step (double clock_step);

        /** Generic nodes do not consume events.
        * Inherited classes may implement this feature.
        */
        virtual void consume ()
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Generic nodes do not have deadlines.
        * Inherited classes may implement this feature.
        */
        virtual uint deadline () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Generic nodes do not have deadlines.
        * Inherited classes may implement this feature.
        */
        virtual void deadline (uint deadline)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Deploys a Node to a Thread.
        * This function updates the thread_ptr in the Node.
        * @param thread_ptr is the Thread where the Node will be deployed.
        */
        virtual void deploy (DREAM::Thread* thread_ptr);

        /** Generic Nodes do not execute.
        * No Exception is thrown.
        */
        virtual void execute ()
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        {};

        /** Checks whether the Node has already been executed.
        * @return The executed_ flag.
        */
        virtual bool executed () const;

        /** Sets the Node to be executed.
        * @param executed sets the executed_ flag.
        */
        virtual void executed (bool executed);

        /** Returns a dependent from the list.
        * @param id specifies which dependent are we looking for.
        * @return the dependent Node.
        */
        virtual DREAM::Node* get_dependent (const std::string& id) const;

        /** Returns the whole map for manipulation.
        * @return The dependent_map_.
        */
        virtual const DREAM::NODE_MAP* get_dependent_map () const;

        /** Returns a pointer to the source Node. 
        * @param task_map contains the Tasks in the model.
        * @param channel_map contains the Channels in the model.
        * @param timer_map contains the Timers in the model.
        */
        virtual const DREAM::Node* get_source (DREAM::NODE_MAP* task_map, DREAM::NODE_MAP* channel_map, 
                DREAM::NODE_MAP* timer_map) const
                        throw (DREAM::Exception);

        /** Returns the name of the Node.
        * @return The id_ of the Node.
        */
        virtual std::string id () const;

        /** Generic nodes do not have deadlines.
        * Inherited classes may implement this feature.
        */
        virtual bool isidle () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Generic nodes do not generate events.
        * No Exception is thrown.
        */
        virtual double next_event ();

#ifdef DREAM_BRANCHING
        /** Generic nodes do not have clocks.
        * Inherited classes may implement this feature.
        */
        virtual void next_et (double next_et)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;
#endif

        /** Publishes an event to dependent tasks.
        * This virtual function models synchronous event propagation.
        * The derived classes call the consume () function of all the dependent Nodes.
        */
        virtual void publish ();

        /** Generic nodes cannot be preempted.
        * Inherited classes may implement this feature.
        */
        virtual void preempt ()
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Generic nodes do not have priorities.
        * Inherited classes may implement this feature.
        */
        virtual uint priority () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Generic nodes do not have priorities.
        * Inherited classes may implement this feature.
        */
        virtual void priority (uint priority)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Returns the remote_dep_ flag of the Node. */
        virtual bool remote_dep () const;

        /** Sets the remote_dep_ flag of the Node. */
        virtual void remote_dep (bool flag);

        /** Removes a dependent from the list.
        * @param id specifies the dependent to be removed.
        */
        virtual void remove_dependent (const std::string& id);

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

        /** Returns a pointer to the Scheduler.
        * Used in output generation
        */
        virtual DREAM::Scheduler* scheduler () const;

        /** Generic nodes do not have subpriorities.
        * Inherited classes may implement this feature.
        */
        virtual uint subpriority () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Generic nodes do not have subpriorities.
        * Inherited classes may implement this feature.
        */
        virtual void subpriority (uint subpriority)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Generic nodes do not take transitions.
        * Inherited classes may implement this feature.
        */
        virtual void take_transitions ()
#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 does not work for generic nodes.
        * Inherited classes may implement this feature.
        * @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 does not work for generic nodes.
        * Inherited classes may implement this feature.
        * @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 does not work for generic nodes.
        * Inherited classes may implement this feature.
        * @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 does not work for generic nodes.
        * Inherited classes may implement this feature.
        * @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
        {};

        /** Generic nodes do not have worst case execution times.
        * Inherited classes may implement this feature.
        */
        virtual uint wcet () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Generic nodes do not have worst case execution times.
        * Inherited classes may implement this feature.
        */
        virtual void wcet (uint wcet)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

protected:

        /** Execution clock. */
        double clock_exec_;

        /** Dependent tasks. */
        DREAM::NodeList* dependent_map_;

        /** Executed flag is used to check unreachable tasks. */
        bool executed_;

        /** ID. */
        std::string id_;

        /** Pointer to the Thread. */
        DREAM::Thread* thread_ptr_;

        /** If this flag is true, the Node has dependents on remote CPUs and has to check branching points during the trace-based verification. */
        bool remote_dep_;
};

/** Timer model.
* This class is the implementation of the Timer in the DRE Semantic Domain.
*/
class Timer : public DREAM::Node
{
public:
        /** Constructor.
        * @param id specifies the name of the Timer.
        * @param thread_ptr defines the mapping of the Timer to a platform processor.
        * @param period specifies the period of the Timer.
        */
        Timer (const std::string& id, DREAM::Thread* thread_ptr, uint period);
        
        /** Constructor.
        * @param id specifies the name of the Timer.
        * @param thread_ptr defines the mapping of the Timer to a platform processor.
        * @param period specifies the worst case period of the Timer.
        * @param bcperiod specifies the best case period of the Timer.
        */
        Timer (const std::string& id, DREAM::Thread* thread_ptr, uint period, uint bcperiod);
        
        /** Copy constructor for Channels. */
        Timer (const DREAM::Timer& timer);

        /** Destructor. */
        virtual ~Timer ();
        
        /** Returns the best case period.
        * bcet () name is used to provide a unique interface for DREAM::Node inherited classes.
        * @return the best case period bcperiod_.
        */
        virtual uint bcet () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

#ifdef DREAM_BRANCHING
        /** Sets the new execution time if branching points were found. */
        virtual void branching_point ()
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;
#endif

        /** Returns whether the Timer uses the best case or worst case period for the simulation.
        * @return the context of the Timer.
        */
        virtual DREAM::Context context () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Sets the Timer to use the specified context (e.g. in the simulation).
        * @param context is the context assumed.
        */
        virtual void context (DREAM::Context context)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Reset execution clock value - clock_exec_.*/
        virtual void clock_exec_reset ();
        
        /** Models the passing of time - increments local clock clock_exec_.
        * @param clock_step specifies by how much do we have to increment the time.
        */
        virtual void clock_step (double clock_step);
        
        /** Tells when the Timer will generate the next event.
        * @return Time remaining till the next event generation (when clock_exec_ == period_).
        */
        virtual double next_event ();

#ifdef DREAM_BRANCHING
        /** Sets the next execution time when the context is branchingpoint. */
        virtual void next_et (double next_et)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;
#endif

        /** Returns the priority of the Timer.
        * The Timer's priority is the priority of its highest priority dependent Task. The function is used by the Uppaal
        * interpreter.
        * @return priority_ of the Thread which owns the Timer.
        */
        virtual uint priority () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Publishes an event to dependent tasks.
        * This function models synchronous event propagation by calling
        * the consume () functions of all the dependent Nodes.
        */
        virtual void publish ();
        
        /** Takes state transitions.
        * This function implements the state transitions of a Timer as specified by the DRE Semantic Domain.
        * Transitions are triggered when clock_exec_ reaches the period.
        */
        virtual void take_transitions ()
#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 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.
        */
        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
        ;

        /** Returns the period of the Timer.
        * wcet () name is used to provide a unique interface for DREAM::Node inherited classes.
        * @return the period of the Timer period_.
        */
        virtual uint wcet () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

private:
        /** Best case period.
        * This construct can be used to model event generators which publish events in a certain interval.
        */
        uint bcperiod_;

        /** Specifies whether best case, worst case, or a random value is used for the execution time during the simulation. */
        DREAM::Context context_;

        /** The execution time. 
        * This value is from the interval [bcet, wcet] and is set according to the context.
        */
        double et_;

#ifdef DREAM_BRANCHING
        /** The next execution time when the context is branchingpoint. 
        * This value is from the interval [bcet, wcet].
        */
        double next_et_;
#endif

        /** Period of the Timer. */
        uint period_;
};

/** Real-time event Channel .
* This class is the implementation of the Channel in the DRE Semantic Domain.
*/
class Channel : public DREAM::Node
{
public:
        /** Constructor.
        * @param id specifies the name of the event channel.
        * @param thread_ptr defines the mapping of the Channel to a platform processor.
        * @param delay is the delay of the event channel.
        * @param buffersize specifies the size of the event channel buffer. Use '0' for no limit.
        */
        Channel (const std::string& id, DREAM::Thread* thread_ptr, uint delay, uint buffersize);

        /** Constructor.
        * @param id specifies the name of the event channel.
        * @param thread_ptr defines the mapping of the Channel to a platform processor.
        * @param delay is the worst case delay of the event channel.
        * @param bcdelay is the best case delay of the event channel.
        * @param buffersize specifies the size of the event channel buffer. Use '0' for no limit.
        */
        Channel (const std::string& id, DREAM::Thread* thread_ptr, uint delay, uint bcdelay, uint buffersize);

        /** Copy constructor for Channels.
        * @param channel is a pointer to the channel to be copied.
        */
        Channel (const DREAM::Channel& channel);

        /** Destructor */
        virtual ~Channel ();

        /** Adds a dependent Node to the current Channel.
        * This function also ensures that Channels cannot have more than 1 dependents.
        * @param node_ptr is the pointer to the dependent Node to be added.
        */
        virtual void add_dependent (DREAM::Node* node_ptr)
                throw (DREAM::Exception);

        /** Returns the best case delay.
        * bcet () name is used to provide a unique interface for DREAM::Node inherited classes.
        */
        virtual uint bcet () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

#ifdef DREAM_BRANCHING
        /** Sets the new execution time if branching points were found. */
        virtual void branching_point ()
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;
#endif

        /** Returns whether the Channel uses the best case or worst case delay for the simulation.
        * @return the context of the Channel.
        */
        virtual DREAM::Context context () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Sets the Channel to use the specified context (e.g. in the simulation).
        * @param context is the context assumed.
        */
        virtual void context (DREAM::Context context)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Reset execution clock value - clock_exec_. */
        virtual void clock_exec_reset ();
        
        /** Models the passing of time.
        * Increments local clock clock_exec_.
        * @param clock_step specifies by how much do we have to increment the time.
        */
        virtual void clock_step (double clock_step);
        
        /** Consumes an event received from an event source.
        * This function is called by the publish () function of the event source and triggers state transitions.
        * The take_transitions () function will take the enabled transitions.
        */
        virtual void consume ()
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Returns true if all the dependents are idle. */
        virtual bool idle_dependents () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Tells when the Channel will generate the next event.
        * @return Time remaining till the next event generation (when clock_exec_ == delay_ and buffer_ != 0).
        */
        virtual double next_event ();
        
#ifdef DREAM_BRANCHING
        /** Sets the next execution time when the context is branchingpoint. */
        virtual void next_et (double next_et)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;
#endif

        /** Publishes an event to dependent tasks.
        * This function models synchronous event propagation by calling
        * the consume () functions of all the dependent Nodes.
        */
        virtual void publish ()
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;
        
        /** Resets Timer (when restarting the simulation). */
        virtual void reset ();

        /** Takes state transitions.
        * This function implements the state transitions of a Channel as specified by the DRE Semantic Domain.
        * Transitions can be triggered by events coming from other Tasks, Timers or Schedulers.
        */
        virtual void take_transitions ()
#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 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
        ;

        /** Returns delay_.
        * wcet () name is used to provide a unique interface for DREAM::Node inherited classes.
        */
        virtual uint wcet () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

private:
        /** Best case delay.
        * This construct can be used to model event channels which have delays within a given interval.
        */
        uint bcdelay_;

        /** Specifies whether best case, worst case, or a random value is used for the execution time during the simulation. */
        DREAM::Context context_;

        /** Buffer of the event channel storing events. */
        uint buffer_;

        /** Specifies the size of the buffer.
        * If the buffer is full new events get lost.
        */
        uint buffersize_;

        /** Worst case delay of the event channel. */
        uint delay_;

        /** The execution time. 
        * This value is from the interval [bcet, wcet] and is set according to the context.
        */
        double et_;

#ifdef DREAM_BRANCHING
        /** The next execution time when the context is branchingpoint. 
        * This value is from the interval [bcet, wcet].
        */
        double next_et_;
#endif

        /** Reference to the event source. */
        DREAM::Node* source_ptr_;

        /** State of the Channel as specified by the DRE Semantic Domain. */
        enum State {idle, wait} state_;
};

/** Real-time Task.
* This class is the implementation of the Task in the DRE Semantic Domain.
*/
class Task : public DREAM::Node
{
public:
        /** Constructor.
        * @param id specifies the name of the Task.
        * @param thread_ptr defines the mapping of the Task to a platform processor.
        * @param wcet is the worst case execution time parameter of the Task.
        * @param deadline is the deadline of the task - deadlines are counted from the time when the task becomes enabled.
        */
        Task (const std::string& id, DREAM::Thread* thread_ptr, uint wcet, uint deadline);

        /** Constructor.
        * @param id specifies the name of the Task.
        * @param thread_ptr defines the mapping of the Task to a platform processor.
        * @param wcet is the worst case execution time parameter of the Task.
        * @param deadline is the deadline of the task - deadlines are counted from the time when the task becomes enabled.
        * @param subpriority is the subpriority of the task. Subpriorities can be used to model the queueing policies (FIFO, MUF etc.)
        */
        Task (const std::string& id, DREAM::Thread* thread_ptr, uint wcet, uint deadline, uint subpriority);

        /** Constructor.
        * @param id specifies the name of the Task.
        * @param thread_ptr defines the mapping of the Task to a platform processor.
        * @param bcet is the best case execution time parameter of the Task.
        * @param wcet is the worst case execution time parameter of the Task.
        * @param deadline is the deadline of the task - deadlines are counted from the time when the task becomes enabled.
        * @param subpriority is the subpriority of the task. Subpriorities can be used to model the queueing policies (FIFO, MUF etc.)
        */
        Task (const std::string& id, DREAM::Thread* thread_ptr, uint wcet, uint bcet, uint deadline, uint subpriority);

        /** Copy constructor for Tasks. 
        * Used in genetic algorithms.
        */
        Task (const DREAM::Task& task);

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

        /** Operator overloading.
        * The Task will be copied except for the thread_ptr_.
        * @param task is the Task to be copied.
        */
        virtual void operator= (const DREAM::Task& task);

        /** Operator overloading.
        * @param task is the Task to be compared with this class.
        */
        virtual bool operator== (const DREAM::Task& task);

        /** Returns the best case execution time of the task.
        * @return the best case execution time bcet_. */
        virtual uint bcet () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Sets the best case execution time of the task .
        * @param bcet is the best case execution time parameter of the Task.
        */
        virtual void bcet (uint bcet)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

#ifdef DREAM_BRANCHING
        /** Sets the new execution time if branching points were found. */
        virtual void branching_point ()
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;
#endif

        /** Returns whether the Task uses the best case or worst case time for the simulation.
        * @return the context of the Timer.
        */
        virtual DREAM::Context context () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Sets the Task to use the specified context (e.g. in the simulation).
        * @param context is the context assumed.
        */
        virtual void context (DREAM::Context context)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Returns the value of the deadline clock - clock_dl_. */
        virtual double clock_dl () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Resets deadline clock value - clock_dl_. */
        virtual void clock_dl_reset ();

        /** Resets execution clock value - clock_exec_. */
        virtual void clock_exec_reset ();

        /** Models the passing of time - increments local clock.
        * @param clock_step specifies by how much do we have to increment the time.
        */
        virtual void clock_step (double clock_step);

        /** Consumes an event received from an event source.
        * This function is called by the publish () function of the event source and triggers state transitions.
        * The take_transitions () function will take the enabled transitions.
        */
        virtual void consume ()
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
        ;

        /** Returns the deadline of the task.
        * @return deadline of the clock deadline_. */
        virtual uint deadline () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Sets the deadline of the task.
        * Deadlines are counted from the time when the task becomes enabled.
        * @param deadline is the deadline of the task.
        */
        virtual void deadline (uint deadline)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Schedules the Task for execution.
        * This function will schedule the Task for execution.
        */
        virtual void execute ()
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Returns true if the Task is idle (used by Channels). */
        virtual bool isidle () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Tells when the Task will generate the next event.
        * @return Time remaining till the next event generation.
        */
        virtual double next_event ();

#ifdef DREAM_BRANCHING
        /** Sets the next execution time when the context is branchingpoint. */
        virtual void next_et (double next_et)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;
#endif

        /** Models the preemption of the task.
        * This function will take the state transition to the preempted state as specified by the DRE Semantic Domain.
        * It does not require calling the take_transition () function.
        */
        virtual void preempt ()
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Returns the priority of the Task - the priority of the Thread which executes it. */
        virtual uint priority () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
        ;

        /** Sets the priority of the Task.
        * This function looks up whether there is a Thread with the requested priority on the actual CPU. If yes,
        * it redeploys the Task to that Thread. If not, returns with an Exception. This function is used by the
        * genetic algorithm when assigning priorities.
        * @param priority is the priority of the task.
        */
        virtual void priority (uint priority)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;
        
        /** Publishes an event to dependent tasks.
        * This function models synchronous event propagation by calling
        * the consume () functions of all the dependent Nodes.
        */
        virtual void publish ()
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Resets task (after a frame overrun or when restarting the simulation). */
        virtual void reset ();

        /** Returns the sub-priority of the Task - subpriority_. */
        virtual uint subpriority () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Sets the subpriority of the Task.
        * @param subpriority is the subpriority of the task. Subpriorities can be used to model the queueing policies (FixedPriority, FIFO, MUF etc.)
        */
        virtual void subpriority (uint subpriority)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Takes state transitions.
        * This function implements the state transitions of a Task as specified by the DRE Semantic Domain.
        * Transitions can be triggered by events coming from other Tasks, Timers, event Channels or Schedulers.
        */
        virtual void take_transitions ()
#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
        ;

        /** Returns the worst case execution time of the task.
        * @return the worst case execution time wcet_.
        */
        virtual uint wcet () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Sets the worst case execution time of the task.
        * @param wcet is the worst case execution time parameter of the Task.
        */
        virtual void wcet (uint wcet)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

#ifndef DREAM_RACE_CONDITION_ZERO
        /** Returns true if all of the sources of the task are zero-delay channels */
        virtual bool zero_delay_race_condition (DREAM::System* system_ptr)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;
#endif

protected:

        /** Constructor.
        * This contructor is only to be used by the copy constructors of derived classes.
        * @param id specifies the name of the Task.
        * @param thread_ptr defines the mapping of the Task to a platform processor.
        * @param bcet is the best case execution time parameter of the Task.
        * @param wcet is the worst case execution time parameter of the Task.
        * @param deadline is the deadline of the task - deadlines are counted from the time when the task becomes enabled.
        * @param subpriority is the subpriority of the task. Subpriorities can be used to model the queueing policies (FIFO, MUF etc.)
        * @param context specifies the context of the Task.
        * @param et specifies the actual execution time of the Task.
        * @param state specifies the state of the Task.
        * @param clock_dl specifies the deadline clock of the Task.
        */
        Task (const std::string& id, DREAM::Thread* thread_ptr, uint wcet, uint bcet, uint deadline, uint subpriority,
                        DREAM::Context context, double et, DREAM::State state, double clock_dl);

        /** Best case execution time. */
        uint bcet_;

        /** Specifies whether best case, worst case, or a random value is used for the execution time during the simulation. */
        DREAM::Context context_;

        /** Deadline clock. */
        double clock_dl_;

        /** Deadline. */
        uint deadline_;

        /** The execution time. 
        * This value is from the interval [bcet, wcet] and is set according to the context.
        */
        double et_;

#ifdef DREAM_BRANCHING
        /** The next execution time when the context is branchingpoint. 
        * This value is from the interval [bcet, wcet].
        */
        double next_et_;
#endif

        /** State of the Task as specified by the DRE Semantic Domain. */
        DREAM::State state_;

        /** Sub-priority.
        * Subpriorities can be used to model the queueing policies (FIFO, MUF etc.)
        */
        uint subpriority_;

        /** Worst case execution time. */
        uint wcet_;

#ifndef DREAM_RACE_CONDITION_ZERO
        /** This variable is used to speed up the search whether all sources are zero-delay */
        uint zero_delay_race_condition_;
#endif
};

/** Power Aware Real-time Task.
* This class extends real-time tasks with variable speed to express voltage scaling as well as power consumption.
*
class PowerAwareTask : public DREAM::Task
{
public:
        /** Constructor.
        * @param id specifies the name of the PowerAwareTask.
        * @param thread_ptr defines the mapping of the PowerAwareTask to a platform processor.
        * @param wcet is the worst case execution time parameter of the PowerAwareTask.
        * @param deadline is the deadline of the task - deadlines are counted from the time when the task becomes enabled.
        *
        PowerAwareTask (const std::string& id, DREAM::Thread* thread_ptr, uint wcet, uint deadline);

        /** Constructor.
        * @param id specifies the name of the PowerAwareTask.
        * @param thread_ptr defines the mapping of the PowerAwareTask to a platform processor.
        * @param wcet is the worst case execution time parameter of the PowerAwareTask.
        * @param deadline is the deadline of the task - deadlines are counted from the time when the task becomes enabled.
        * @param subpriority is the subpriority of the task. Subpriorities can be used to model the queueing policies (FIFO, MUF etc.)
        *
        PowerAwareTask (const std::string& id, DREAM::Thread* thread_ptr, uint wcet, uint deadline, uint subpriority);

        /** Constructor.
        * @param id specifies the name of the PowerAwareTask.
        * @param thread_ptr defines the mapping of the PowerAwareTask to a platform processor.
        * @param bcet is the best case execution time parameter of the PowerAwareTask.
        * @param wcet is the worst case execution time parameter of the PowerAwareTask.
        * @param deadline is the deadline of the task - deadlines are counted from the time when the task becomes enabled.
        * @param subpriority is the subpriority of the task. Subpriorities can be used to model the queueing policies (FIFO, MUF etc.)
        *
        PowerAwareTask (const std::string& id, DREAM::Thread* thread_ptr, uint wcet, uint bcet, uint deadline, uint subpriority);

        /** Copy constructor for Tasks. 
        * Used in genetic algorithms.
        *
        PowerAwareTask (const DREAM::PowerAwareTask& powerawaretask);

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

        /** Operator overloading.
        * The Task will be copied except for the thread_ptr_.
        * @param powerawaretask is the Task to be copied.
        *
        virtual void operator= (const DREAM::PowerAwareTask& powerawaretask);

        /** Operator overloading.
        * @param powerawaretask is the Task to be compared with this class.
        *
        virtual bool operator== (const DREAM::PowerAwareTask& powerawaretask);

        /** Models the passing of time - increments local clock.
        * The speed of the scheduler influences this function. If slower QoSLevels are used the execution clock is incremented at 
        * a slower rate than the deadline clock which simply measures the time elapsed.
        * @param clock_step specifies by how much do we have to increment the time.
        *
        virtual void clock_step (double clock_step);

        /** Tells when the PowerAwareTask will generate the next event.
        * The PowerAwareTask will only generate an event if it is executing, otherwise it returns 0. The speed of the scheduler influences this function.
        * If slower QoSLevels are used events will be generated later proportionally. Note that the speed can change during execution.
        * @return Time remaining till the next event generation.
        *
        virtual double next_event ();

};*/

#ifdef DREAM_RACE_CONDITION
/** 
* This data structure is used by the model checker to introduce priority inversions into the model. 
* The priority inversions are used to check for race conditions. This class implements a DREAM::AVLTree (AVL-tree)
* within a LinkedList and iterator data structures to achieve better verification performance.
*/
class PriorityInversionList
{
public:
        /** Constructor. */
        PriorityInversionList (DREAM::System* system_ptr);

        /** Destructor. */
        ~PriorityInversionList ();

        /** This function first checks whether the task_avltree parameter is already in the list, if not it inserts it in the data structure. */
        void add (const DREAM::TASK_AVLTREE* task_avltree_ptr, DREAM::Task* task_ptr)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** Clears the AVLTree, and frees up memory. */
        void destroy ();

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

        /** This function increments the task_id_list_iter value if there are more elements in the AVL tree corresponding to
        * task_avltree_list_iter, otherwise it calls itself recursively for the next tree.
        */
        bool increment (TASK_AVLTREE_LIST::iterator task_avltree_list_iter,
                TASK_ID_LIST::iterator task_id_list_iter);

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

private:
        /** The function returns true if the parameter task_avltree can be found in the data structure. */
        DREAM::Task* find (const DREAM::TASK_AVLTREE* task_avltree_ptr, DREAM::Task* task_ptr)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                throw (DREAM::Exception)
#endif
        ;

        /** task_avltree_list_ stores priority inversions introduced at simulation time. */
        TASK_AVLTREE_LIST task_avltree_list_;

        /** task_id_ list, used in the inversion () function. */
        TASK_ID_LIST task_id_list_;

        /** Pointer to the system.
        * Used by the find () method to check for race conditions.
        */
        DREAM::System* system_ptr_;
};
#endif

}

#endif

---