Task.cpp

Go to the documentation of this file.

/** @file Task.cpp
* @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.
* =================================================================
*/

#include "Task.h"

namespace DREAM
{

/////////////////////////////////////////////////////////////////////////////
//
// Node
//
/////////////////////////////////////////////////////////////////////////////

Node::Node (const std::string& id, DREAM::Thread* thread_ptr, bool executed = false)
        : id_ (id),
                thread_ptr_ (thread_ptr),
                executed_ (executed),
                clock_exec_ (0),
                remote_dep_ (false)
{
        dependent_map_ = new DREAM::NodeList ();
        if (thread_ptr)
                thread_ptr->add (this);
}

Node::Node (const DREAM::Node& node)
        : id_ (node.id_),
                thread_ptr_ (node.thread_ptr_),
                executed_ (node.executed_),
                clock_exec_ (node.clock_exec_),
                remote_dep_ (false)
{
        dependent_map_ = new DREAM::NodeList ();
        if (node.thread_ptr_)
                node.thread_ptr_->add (this);
}

Node::~Node ()
{
        delete dependent_map_;
}

inline void Node::add_dependent (DREAM::Node* node_ptr)
{
        dependent_map_->add (node_ptr);
}

uint Node::bcet () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        std::string message;
        message << "Node \"" << id_ << "\" does not have best case execution time. Use the inherited classes which implement this feature.";
        throw DREAM::BaseClassException (message);
#else
        return 0;
#endif
}

void Node::bcet (uint bcet)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        std::string message;
        message << "Node \"" << id_ << "\" does not have best case execution time. Use the inherited classes which implement this feature.";
        throw DREAM::BaseClassException (message);
#endif
}

#ifdef DREAM_BRANCHING
void Node::branching_point ()
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        std::string message;
        message << "Node \"" << id_ << "\" does not have branching points. Use the inherited classes which implement this feature.";
        throw DREAM::BaseClassException (message);
#endif
}
#endif

DREAM::Context Node::context () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        std::string message;
        message << "Node \"" << id_ << "\" does not have context. Use the inherited classes which implement this feature.";
        throw DREAM::BaseClassException (message);
#else
        return DREAM::randomcase;
#endif
}

void Node::context (DREAM::Context context)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        std::string message;
        message << "Node \"" << id_ << "\" does not have context. Use the inherited classes which implement this feature.";
        throw DREAM::BaseClassException (message);
#endif
}

double Node::clock_dl () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        std::string message;
        message << "Node \"" << id_ << "\" does not have deadline clock. Use the inherited classes which implement this feature.";
        throw DREAM::BaseClassException (message);
#else
        return 0;
#endif
}

double Node::clock_dl_reset () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        std::string message;
        message << "Node \"" << id_ << "\" does not have deadline clock. Use the inherited classes which implement this feature.";
        throw DREAM::BaseClassException (message);
#else
        return 0;
#endif
}

inline double Node::clock_exec () const
{
        return clock_exec_;
}

inline void Node::clock_exec_reset ()
{
        clock_exec_ = 0;
}

inline void Node::clock_step (double clock_step)
{
        clock_exec_ += clock_step;
}

void Node::consume ()
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        std::string message;
        message << "Node \"" << id_ << "\" does not consume events. Use the inherited classes which implement this feature.";
        throw DREAM::BaseClassException (message);
#endif
}

uint Node::deadline () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        std::string message;
        message << "Node \"" << id_ << "\" does not have deadline. Use the inherited classes which implement this feature.";
        throw DREAM::BaseClassException (message);
#else
        return 0;
#endif
}

void Node::deadline (uint deadline)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        std::string message;
        message << "Node\"" << id_ << "\" does not have deadline. Use the inherited classes which implement this feature.";
        throw DREAM::BaseClassException (message);
#endif
}

void Node::deploy (DREAM::Thread* thread_ptr)
{
        if (thread_ptr_)
                thread_ptr_->erase (id_);

        thread_ptr_ = thread_ptr;
        thread_ptr->add (this);
}

inline bool Node::executed () const
{
        return executed_;
}

inline void Node::executed (bool executed)
{
        executed_ = executed;
}

inline Node* Node::get_dependent (const std::string& id) const
{
        return dependent_map_->find (id);
}

inline const NODE_MAP* Node::get_dependent_map () const
{
        return dependent_map_->get_map ();
}

const DREAM::Node* Node::get_source (DREAM::NODE_MAP* task_map, DREAM::NODE_MAP* channel_map, DREAM::NODE_MAP* timer_map) const
        throw (DREAM::Exception)
{
        DREAM::Node* node_ptr = NULL;

        // Figure out if the Node is subscribed to a Channel
        for (DREAM::NODE_MAP::const_iterator node_iter = channel_map->begin (); node_iter != channel_map->end (); node_iter++)
        {
                if (node_iter->second->get_dependent (id_))
                        return NULL;
        };

        // Figure out if the Node is subscribed to a Task
        for (DREAM::NODE_MAP::const_iterator node_iter = task_map->begin (); node_iter != task_map->end (); node_iter++)
        {
                if (node_iter->second->get_dependent (id_))
                {
                        if (!node_ptr)
                                node_ptr = node_iter->second;
                        else
                                throw DREAM::Exception ("Node::get_source () found multiple non-channel sources.");
                }
        };

        // Figure out if the Task is subscribed to a Timer
        for (DREAM::NODE_MAP::const_iterator node_iter = timer_map->begin (); node_iter != timer_map->end (); node_iter++)
        {
                if (node_iter->second->get_dependent (id_))
                {
                        if (!node_ptr)
                                node_ptr = node_iter->second;
                        else
                                throw DREAM::Exception ("Node::get_source () found multiple non-channel sources.");
                }
        };

        if (!node_ptr)
                throw DREAM::Exception ("Node::get_source () construction failed. Most likely the input models are semantically incorrect.");

        return node_ptr;
}

inline std::string Node::id () const
{
        return id_;
}

bool Node::isidle () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        std::string message;
        message << "Node\"" << id_ << "\" cannot be checked for idleness. Use the inherited classes which implement this feature.";
        throw DREAM::BaseClassException (message);
#else
        return false;
#endif
}

inline double Node::next_event ()
{
        return 0.0;
}

#ifdef DREAM_BRANCHING
void Node::next_et (double next_et)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        std::string message;
        message << "Node\"" << id_ << "\" does not have clocks. Use the inherited classes which implement this feature.";
        throw DREAM::BaseClassException (message);
#endif
}
#endif

void Node::preempt ()
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        std::string message;
        message << "Node\"" << id_ << "\" cannot be preempted. Use the inherited classes which implement this feature.";
        throw DREAM::BaseClassException (message);
#endif
}

uint Node::priority () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        std::string message;
        message << "Node\"" << id_ << "\" does not have priority. Use the inherited classes which implement this feature.";
        throw DREAM::BaseClassException (message);
#else
        return 0;
#endif
}

void Node::priority (uint priority)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        std::string message;
        message << "Node\"" << id_ << "\" does not have priority. Use the inherited classes which implement this feature.";
        throw DREAM::BaseClassException (message);
#endif
}

inline void Node::publish ()
{
        if (thread_ptr_)
        {
#ifdef DREAM_VERBOSE2
                if (Option::verbose1_ && Option::verbose2_)
                {
                        std::string message;
                        thread_ptr_->trace (message << id_ << " is publishing...");
                }
#endif
                dependent_map_->publish ();
                thread_ptr_->scheduler ()->system ()->relevant_event (true);
        }
}

inline void Node::remove_dependent (const std::string& id)
{
        dependent_map_->erase (id);
}

inline bool Node::remote_dep () const
{
        return remote_dep_;
}

inline void Node::remote_dep (bool flag)
{
        remote_dep_ = flag;
}

inline void Node::reset ()
{
        clock_exec_reset ();
//      executed (0);
}

inline DREAM::Scheduler* Node::scheduler () const
{
        return thread_ptr_? thread_ptr_->scheduler () : NULL;
}

uint Node::subpriority () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        std::string message;
        message << "Node\"" << id_ << "\" does not have subpriority. Use the inherited classes which implement this feature.";
        throw DREAM::BaseClassException (message);
#else
        return 0;
#endif
}

void Node::subpriority (uint subpriority)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        std::string message;
        message << "Node\"" << id_ << "\" does not have subpriority. Use the inherited classes which implement this feature.";
        throw DREAM::BaseClassException (message);
#endif
}

void Node::take_transitions ()
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        std::string message;
        message << "Node\"" << id_ << "\" does not take transitions. Use the inherited classes which implement this feature.";
        throw DREAM::BaseClassException (message);
#endif
}

uint Node::wcet () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        std::string message;
        message << "Node\"" << id_ << "\" does not have worst case execution time. Use the inherited classes which implement this feature.";
        throw DREAM::BaseClassException (message);
#else
        return 0;
#endif
}

void Node::wcet (uint wcet)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        std::string message;
        message << "Node\"" << id_ << "\" does not have worst case execution time. Use the inherited classes which implement this feature.";
        throw DREAM::BaseClassException (message);
#endif
}

/////////////////////////////////////////////////////////////////////////////
//
// Timer
//
/////////////////////////////////////////////////////////////////////////////

Timer::Timer (const std::string& id, DREAM::Thread* thread_ptr, uint period)
        : DREAM::Node (id, thread_ptr, true),
                period_ (period),
                bcperiod_ (period),
                context_ (randomcase),
                et_ (period)
#ifdef DREAM_BRANCHING
                ,next_et_ (0.0)
#endif
{
        if (period == 0)
                throw DREAM::Exception ("Timer period has to be greater than 0.");
}

Timer::Timer (const std::string& id, DREAM::Thread* thread_ptr, uint period, uint bcperiod)
        : DREAM::Node (id, thread_ptr, true),
                period_ (period),
                bcperiod_ (bcperiod),
                context_ (randomcase),
                et_ (bcperiod + random (period - bcperiod))
#ifdef DREAM_BRANCHING
                ,next_et_ (0.0)
#endif
{
        if ((period == 0) || (bcperiod == 0))
                throw DREAM::Exception ("Timer period has to be greater than 0.");
        if (period <= bcperiod)
                throw DREAM::Exception ("Timer best case period has to be smaller than the period.");
}

Timer::Timer (const DREAM::Timer& timer)
        : DREAM::Node (timer.id_, timer.thread_ptr_, true),
                period_ (timer.period_),
                bcperiod_ (timer.bcperiod_),
                context_ (timer.context_),
                et_ (timer.et_)
#ifdef DREAM_BRANCHING
                ,next_et_ (timer.bcperiod_)
#endif
{
        if ((timer.period_ == 0) || (timer.bcperiod_ == 0))
                throw DREAM::Exception ("Timer period has to be greater than 0.");
}


Timer::~Timer ()
{
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
uint Timer::bcet () const
        throw (DREAM::Exception)
#else
inline uint Timer::bcet () const
#endif
{
        return bcperiod_;
}

#ifdef DREAM_BRANCHING
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
void Timer::branching_point ()
        throw (DREAM::Exception)
#else
inline void Timer::branching_point ()
#endif
{
        if (context_ == branchingpoint)
                if (et_ == next_et_)
                {
                        context_ = bestcase;
                        et_ = bcperiod_;
                        next_et_ = 0.0;
                }
                else
                {
                        et_ = next_et_;
                }
}
#endif

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
DREAM::Context Timer::context () const
        throw (DREAM::Exception)
#else
inline DREAM::Context Timer::context () const
#endif
{
        return context_;
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
void Timer::context (DREAM::Context context)
        throw (DREAM::Exception)
#else
inline void Timer::context (DREAM::Context context)
#endif
{
        context_ = context;
}

inline void Timer::clock_exec_reset ()
{
        clock_exec_ = 0;

        // Calculate new period
        if (context_ == worstcase)
                et_ = period_;
        else if (context_ == randomcase)
                et_ = bcperiod_ + random (period_ - bcperiod_);
        else if (context_ == bestcase)
                et_ = bcperiod_;
}

void Timer::clock_step (double clock_step)
{
        // Increment clock value
        clock_exec_ += clock_step;

#ifdef DREAM_BRANCHING
        // IF statement optimization
        if (bcperiod_ < clock_exec_)
        {
                if (next_et_ < clock_exec_)
                {
                        if ((clock_exec_ < period_) && remote_dep_ && Option::branching_)
                        {
                                // Encountered a possible branching point
                                // Check whether it is relevant
                                if (thread_ptr_->scheduler ()->system ()->relevant_event ())
                                {
                                        // Let's blow up the state space a little more...
                                        std::string message;
                                        thread_ptr_->trace (message << "Branching point " << id_ << " bcperiod: " << bcperiod_ << " period: " << period_ << " next_et: " << clock_exec_);

                                        if (context_ == worstcase)
                                                context_ = branchingpoint;

                                        next_et_ = clock_exec_;
                                }
                        }
                }
        }
#endif
}

inline double Timer::next_event ()
{
        return (et_ - clock_exec_);
}

#ifdef DREAM_BRANCHING
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
void Timer::next_et (double next_et)
        throw (DREAM::Exception)
#else
inline void Timer::next_et (double next_et)
#endif
{
        next_et_ = next_et;
}
#endif

uint Timer::priority () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
        uint priority = maxuint;

        NODE_MAP* node_map = dependent_map_->get_map ();

        for (DREAM::NODE_MAP::const_iterator node_iter = node_map->begin (); node_iter != node_map->end (); node_iter++)
        {
                if (priority == maxuint) priority = node_iter->second->priority ();
                else
                {
                        if (priority > node_iter->second->priority ())                  // Remember, smaller value means higher priority
                                priority = node_iter->second->priority ();
                }
        }

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        if (priority == maxuint)
        {
                std::string message;
                message << "Timer \"" << id_ << "\" has no dependents";
                throw DREAM::Exception (message);
        }
#endif

        return priority;
}

inline void Timer::publish ()
{
        if (thread_ptr_)
        {
#ifdef DREAM_VERBOSE2
                if (Option::verbose1_ && Option::verbose2_)
                {
                        std::string message;
                        message << id_ << " is publishing...";
                        thread_ptr_->trace (message);
                }
#endif
                dependent_map_->publish ();
                thread_ptr_->scheduler ()->system ()->relevant_event (true);
        }
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
void Timer::take_transitions ()
        throw (DREAM::Exception)
#else
inline void Timer::take_transitions ()
#endif
{
#ifdef DREAM_VERBOSE2
//      if (Option::verbose1_ && Option::verbose2_)
//      {
//              std::string message;
//              thread_ptr_->trace (message << id_ << " is taking transitions.");
//      }
#endif

        // Check whether the clock_exec_ has reached the period
        if (clock_exec_ == et_)
        {
                publish ();
                clock_exec_reset ();
        }

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        if (clock_exec_ > et_)
        {
                std::string message;
                message << "Execution clock value in Timer \"" << id_ << "\" is greater than the period. Most likely the period was set during simulation time. Please report bug at http://sourceforge.net/projects/dre!";
                throw DREAM::Exception (message);
        }
#endif
}

void Timer::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
{
        f_stream << "/*\n * Timer - " << id_ << "\n *\n */\n" << std::endl;

        f_stream << "process timer_" << id_ << " (1);\n\n"
                << "var ce clock;\nconst period_" << id_ << "=" << period_ << ";\n\n"
                << "state start #start ;\n"
                << "\tdeadline eager;\n"
                << "\tset ce := 0;\n"
                << "\tnextstate timer;\n"
                << "endstate;\n\n"
                << "state timer;\n"
                << "\tdeadline eager;\n"
                << "\twhen ce = period_" << id_ << ";\n";

        const DREAM::NODE_MAP* node_map = get_dependent_map ();
        const DREAM::NODE_MAP* node_map2;

        // Check dependents
        DREAM::NODE_MAP::const_iterator task_iter, task_iter2, find_iter;

        for (task_iter = node_map->begin (); task_iter != node_map->end (); task_iter++)
        {
                find_iter = task_map->find (task_iter->first);
                if (find_iter != task_map->end ())
                        f_stream << "\toutput event () to {task_" << find_iter->first << "}0;\n";
                else
                {
                        find_iter = channel_map->find (task_iter->first);

                        // Dependent is a channel - need to find dependent tasks...
                        if (find_iter->second)
                                node_map2 = find_iter->second->get_dependent_map ();

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                        else
                        {
                                std::string message;
                                message << "Channel " << task_iter->first << " has no Task dependents. Incorrect model.";
                                throw DREAM::Exception (message);
                        }
#endif

                        for (task_iter2 = node_map2->begin (); task_iter2 != node_map2->end (); task_iter2++)
                        {
                                find_iter = node_map2->find (task_iter2->first);
                                if (find_iter != node_map2->end ())
                                {
                                        if (task_iter->second->wcet () != 0)
                                                f_stream << "\toutput event () via {" << task_iter->first << "}0 to {task_" << find_iter->first << "}0;\n";
                                        else
                                                f_stream << "\toutput event () /* via {" << task_iter->first << "}0 */ to {task_" << find_iter->first << "}0;\n";
                                }

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                                else
                                {
                                        std::string message;
                                        message << "Node " << task_iter2->first << " could not be found as a Channel dependent in the Task list when generating IF input. Incorrect model.";
                                        throw DREAM::Exception (message);
                                }
#endif

                        }
                }
        }

        f_stream << "\tset ce := 0;\n"
                << "\t\tnextstate timer;\n"
                << "endstate;\n\nendprocess;\n" << std::endl;

}

void Timer::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
{
        timer_map->insert (DREAM::NODE_PAIR (id_, this));
}

void Timer::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
{
        f_stream << id_ << " := Timer (" << period_ << ", " << bcperiod_ << ", " << "publish" << id_ << ");" << std::endl;
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
uint Timer::wcet () const
        throw (DREAM::Exception)
#else
inline uint Timer::wcet () const
#endif
{
        return period_;
}

/////////////////////////////////////////////////////////////////////////////
//
// Channel
//
/////////////////////////////////////////////////////////////////////////////

Channel::Channel (const std::string& id, DREAM::Thread* thread_ptr, uint delay, uint buffersize)
        : DREAM::Node (id, thread_ptr, true),
                state_ (idle),
                delay_ (delay),
                bcdelay_ (delay),
                buffersize_ (buffersize),
                context_ (randomcase),
                et_ (delay),
#ifdef DREAM_BRANCHING
                next_et_ (0.0),
#endif
                buffer_ (0)
{
}

Channel::Channel (const std::string& id, DREAM::Thread* thread_ptr, uint delay, uint bcdelay, uint buffersize)
        : DREAM::Node (id, thread_ptr, true),
                state_ (idle),
                delay_ (delay),
                bcdelay_ (bcdelay),
                buffersize_ (buffersize),
                context_ (randomcase),
                et_ (bcdelay + random (delay - bcdelay)),
#ifdef DREAM_BRANCHING
                next_et_ (0.0),
#endif
                buffer_ (0)
{
        if (delay <= bcdelay)
                throw DREAM::Exception ("Channel best case delay has to be smaller than the delay.");
}

Channel::Channel (const DREAM::Channel& channel)
        : DREAM::Node (channel.id_, channel.thread_ptr_, true),
                state_ (channel.state_),
                delay_ (channel.delay_),
                bcdelay_ (channel.bcdelay_),
                buffersize_ (channel.buffersize_),
                context_ (channel.context_),
                et_ (channel.et_),
#ifdef DREAM_BRANCHING
                next_et_ (channel.bcdelay_),
#endif
                buffer_ (channel.buffer_)
{
}

Channel::~Channel ()
{
}

void Channel::add_dependent (DREAM::Node* node_ptr)
        throw (DREAM::Exception)
{
        if (dependent_map_->get_map ()->size () > 0) 
                throw DREAM::Exception ("Channel::add_dependent (): Channels cannot have more than 1 dependents.");

        dependent_map_->add (node_ptr);
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
uint Channel::bcet () const
        throw (DREAM::Exception)
#else
inline uint Channel::bcet () const
#endif
{
        return bcdelay_;
}

#ifdef DREAM_BRANCHING
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
void Channel::branching_point ()
        throw (DREAM::Exception)
#else
inline void Channel::branching_point ()
#endif
{
        if (context_ == branchingpoint)
                if (et_ == next_et_)
                {
                        context_ = bestcase;
                        et_ = bcdelay_;
                        next_et_ = 0.0;
                }
                else
                {
                        et_ = next_et_;
                }
}
#endif

inline void Channel::clock_exec_reset ()
{
        clock_exec_ = 0;

        // Calculate new delay
        if (context_ == worstcase)
                et_ = delay_;
        else if (context_ == randomcase)
                et_ = bcdelay_ + random (delay_ - bcdelay_);
        else if (context_ == bestcase)
                et_ = bcdelay_;
}

inline void Channel::clock_step (double clock_step)
{
        // Increment clock value
        if (buffer_ != 0) clock_exec_ += clock_step;

#ifdef DREAM_BRANCHING
        // IF statement optimization
        if (bcdelay_ < clock_exec_)
        {
                if ((clock_exec_ < delay_) && remote_dep_ && Option::branching_)
                {
                        if (next_et_ < clock_exec_)
                        {
                                // Encountered a branching point
                                // Check whether it is relevant
                                if (thread_ptr_->scheduler ()->system ()->relevant_event ())
                                {
                                        // Let's blow up the state space a little more...
                                        std::string message;
                                        thread_ptr_->trace (message << "Branching point " << id_ << " bcdelay: " << bcdelay_ << " wcdelay: " << delay_ << " next_et: " << clock_exec_);
                                        if (context_ == worstcase)
                                                context_ = branchingpoint;

                                        next_et_ = clock_exec_;
                                }
                        }
                }
        }
#endif
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
void Channel::consume ()
        throw (DREAM::Exception)
#else
inline void Channel::consume ()
#endif
{
        if ((buffer_ < buffersize_) || (buffersize_ == 0))
        {
                thread_ptr_->enqueue (this);

                ++buffer_;

                if (state_ == idle)
                {
                        state_ = wait;
                        clock_exec_reset ();
                }

                take_transitions ();
        }
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
DREAM::Context Channel::context () const
        throw (DREAM::Exception)
#else
inline DREAM::Context Channel::context () const
#endif
{
        return context_;
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
void Channel::context (DREAM::Context context)
        throw (DREAM::Exception)
#else
inline void Channel::context (DREAM::Context context)
#endif
{
        context_ = context;
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
bool Channel::idle_dependents () const
        throw (DREAM::Exception)
#else
inline bool Channel::idle_dependents () const
#endif
{
        for (DREAM::NODE_MAP::const_iterator dependent_iter = dependent_map_->get_map ()->begin ();
                dependent_iter != dependent_map_->get_map ()->end ();
                dependent_iter++)
                        if (! dependent_iter->second->isidle ())
                                return false;

        return true;
}

inline double Channel::next_event ()
{
        // If there are buffered events we publish when the delay is passed
        // Otherwise we have no clue...
        return (buffer_ && state_ == wait) ? (et_ - clock_exec_) : 0.0;
}

#ifdef DREAM_BRANCHING
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
void Channel::next_et (double next_et)
        throw (DREAM::Exception)
#else
inline void Channel::next_et (double next_et)
#endif
{
        next_et_ = next_et;
}
#endif

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
void Channel::publish ()
        throw (DREAM::Exception)
#else
inline void Channel::publish ()
#endif
{
#ifdef DREAM_VERBOSE2
                if (Option::verbose1_ && Option::verbose2_)
                {
                        std::string message;
                        message << id_ << " is publishing...";
                        thread_ptr_->trace (message);
                }
#endif

        dependent_map_->publish ();
        thread_ptr_->scheduler ()->system ()->relevant_event (true);
}

inline void Channel::reset ()
{
        buffer_ = 0;
        state_ = idle;
        clock_exec_reset ();
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
void Channel::take_transitions ()
        throw (DREAM::Exception)
#else
inline void Channel::take_transitions ()
#endif
{
#ifdef DREAM_VERBOSE2
//      if (Option::verbose1_ && Option::verbose2_)
//      {
//              std::string message;
//              thread_ptr_->trace (message << id_ << " is taking transitions.");
//      }
#endif

        switch (state_)
        {
                case idle:
                        // IF statement optimization
                        if (0 < buffer_)
                                if (idle_dependents ())
                                {
                                        state_ = wait;
                                        clock_exec_reset ();
                                        take_transitions ();
                                }
                        break;
                case wait:
                        // IF statement optimization
                        if (clock_exec_ == et_)
                        {
                                if (idle_dependents ())
                                {
                                        state_ = idle;
                                        if (--buffer_ == 0)
                                                thread_ptr_->dequeue (this);
                                        publish ();
                                }
                                else
                                        state_ = idle;
                        }
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                        else if (clock_exec_ > et_)
                        {
                                std::string message;
                                message << "Execution time in Channel \"" << id_ << "\" is greater than the delay. Please report bug at http://sourceforge.net/projects/dre!";
                                throw DREAM::Exception (message);
                        }
#endif
        }
}

void Channel::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
{
        channel_map->insert (DREAM::NODE_PAIR (id_, this));
}

void Channel::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
{
        if (delay_ == 0)
                f_stream << id_ << " := Buffer (" << buffersize_ << ", ";
        else
                f_stream << id_ << " := Channel (" << delay_ << ", " << bcdelay_ << ", " << buffersize_ << ", ";

        DREAM::NODE_MAP* dependent_map = dependent_map_->get_map ();
        
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        if (dependent_map->size () > 1)
                throw DREAM::Exception ("Channel::visitor_uppaal () called for a Channel with multiple dependents, This is an invalid modeling construct for the Uppaal models. Please use multiple channels with only ONE dependent each!");
#endif

        DREAM::NODE_MAP::const_iterator dependent_iter, task_iter;
        dependent_iter = dependent_map->begin ();

        uint i = 0;

        // Figure out the index of the dependent from the list...
        for (task_iter = task_map->begin (); task_iter != task_map->end (); task_iter++)
        {
                if (task_iter->first == dependent_iter->first) break;
                ++i;
        }

        std::string dependent = task_iter->first;
        
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        if (task_iter == task_map->end ())
                throw DREAM::Exception ("Channel::visitor_uppaal () called for a Channel with a non-task dependent. Invalid modeling construct. Please report bug at http://sourceforge.net/projects/dre!");
#endif

        f_stream << i << ", ";

        if (get_source (task_map, channel_map, timer_map))
        {
                f_stream << "publish" << get_source (task_map, channel_map, timer_map)->id ()
                        << ", start" << dependent
                        << ", publish" << dependent << ");" << std::endl;
        }
        else
        {
                f_stream << ", start" << dependent
                        << ", publish" << dependent << ");" << std::endl;
        }
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
uint Channel::wcet () const
        throw (DREAM::Exception)
#else
inline uint Channel::wcet () const
#endif
{
        return delay_;
}

/////////////////////////////////////////////////////////////////////////////
//
// Task
//
/////////////////////////////////////////////////////////////////////////////

Task::Task (const std::string& id, DREAM::Thread* thread_ptr, uint wcet, uint deadline)
        : DREAM::Node (id, thread_ptr),
                wcet_ (wcet),
                bcet_ (wcet),
                context_ (randomcase),
                et_ (wcet),
                deadline_ (deadline),
                state_ (idle),
                clock_dl_ (0.0)
#ifdef DREAM_BRANCHING
                ,next_et_ (0.0)
#endif
#ifndef DREAM_RACE_CONDITION_ZERO
                ,zero_delay_race_condition_ (2)
#endif
{
}

Task::Task (const std::string& id, DREAM::Thread* thread_ptr, uint wcet, uint deadline, uint subpriority)
        : DREAM::Node (id, thread_ptr),
                wcet_ (wcet),
                bcet_ (wcet),
                context_ (randomcase),
                et_ (wcet),
                deadline_ (deadline),
                subpriority_ (subpriority),
                state_ (idle),
                clock_dl_ (0.0)
#ifdef DREAM_BRANCHING
                ,next_et_ (0.0)
#endif
#ifndef DREAM_RACE_CONDITION_ZERO
                ,zero_delay_race_condition_ (2)
#endif
{
}

Task::Task (const std::string& id, DREAM::Thread* thread_ptr, uint wcet, uint bcet, uint deadline, uint subpriority)
        : DREAM::Node (id, thread_ptr),
                wcet_ (wcet),
                bcet_ (bcet),
                context_ (randomcase),
                et_ (bcet + random (wcet - bcet)),
                deadline_ (deadline),
                subpriority_ (subpriority),
                state_ (idle),
                clock_dl_ (0.0)
#ifdef DREAM_BRANCHING
                ,next_et_ (0.0)
#endif
#ifndef DREAM_RACE_CONDITION_ZERO
                ,zero_delay_race_condition_ (2)
#endif
{
        if (wcet <= bcet)
                throw DREAM::Exception ("Task best case execution time has to be smaller than the worst case execution time.");
}

// Note: this is a protected function.
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)
        : DREAM::Node (id, thread_ptr),
                wcet_ (wcet),
                bcet_ (bcet),
                context_ (context),
                et_ (et),
                deadline_ (deadline),
                subpriority_ (subpriority),
                state_ (state),
                clock_dl_ (clock_dl)
#ifdef DREAM_BRANCHING
                ,next_et_ (0.0)
#endif
#ifndef DREAM_RACE_CONDITION_ZERO
                ,zero_delay_race_condition_ (2)
#endif
{
        if (wcet <= bcet)
                throw DREAM::Exception ("Task best case execution time has to be smaller than the worst case execution time.");
}

Task::Task (const DREAM::Task& task)
        : DREAM::Node (task.id_, task.thread_ptr_),
                wcet_ (task.wcet_),
                bcet_ (task.bcet_),
                context_ (task.context_),
                et_ (task.et_),
                deadline_ (task.deadline_),
                subpriority_ (task.subpriority_),
                state_ (task.state_),
                clock_dl_ (task.clock_dl_)
#ifdef DREAM_BRANCHING
                ,next_et_ (task.next_et_)
#endif
#ifndef DREAM_RACE_CONDITION_ZERO
                ,zero_delay_race_condition_ (task.zero_delay_race_condition_)
#endif
{
}

Task::~Task ()
{
}

void Task::operator= (const DREAM::Task& task)
{
        id_ = task.id_;
        // Do not try to redeploy! This will crash in VC7.1 STL map implementations.
        // deploy (task.thread_ptr_);
        wcet_ = task.wcet_;
        bcet_ = task.bcet_;
        context_ = task.context_;
        deadline_ = task.deadline_;
        subpriority_ = task.subpriority_;
        state_ = task.state_;
        clock_dl_ = task.clock_dl_;
#ifdef DREAM_BRANCHING
        next_et_ = task.next_et_;
#endif
}

bool Task::operator== (const DREAM::Task& task)
{
        if (id_ == task.id_)
/*       (thread_ptr_ == task.thread_ptr_) &&
         (wcet_ == task.wcet_) &&
         (bcet_ == task.bcet_) &&
         (context_ == task.context_) &&
         (deadline_ == task.deadline_) &&
         (subpriority_ == task.subpriority_) &&
         (state_ == task.state_) &&
         (clock_dl_ == task.clock_dl_))*/
                return true;
        else
                return false;
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
uint Task::bcet () const
        throw (DREAM::Exception)
#else
inline uint Task::bcet () const
#endif
{
        return bcet_;
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
void Task::bcet (uint bcet)
        throw (DREAM::Exception)
#else
inline void Task::bcet (uint bcet)
#endif
{
        bcet_ = bcet;
}

#ifdef DREAM_BRANCHING
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
void Task::branching_point ()
        throw (DREAM::Exception)
#else
inline void Task::branching_point ()
#endif
{
        if (context_ == branchingpoint)
                if (et_ == next_et_)
                {
                        context_ = bestcase;
                        et_ = bcet_;
                        next_et_ = 0.0;
                }
                else
                {
                        et_ = next_et_;
                }
}
#endif

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
DREAM::Context Task::context () const
        throw (DREAM::Exception)
#else
inline DREAM::Context Task::context () const
#endif
{
        return context_;
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
void Task::context (DREAM::Context context)
        throw (DREAM::Exception)
#else
inline void Task::context (DREAM::Context context)
#endif
{
        context_ = context;
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
double Task::clock_dl () const
        throw (DREAM::Exception)
#else
inline double Task::clock_dl () const
#endif
{
        return clock_dl_;
}

inline void Task::clock_dl_reset ()
{
        clock_dl_ = 0;
}

inline void Task::clock_exec_reset ()
{
        clock_exec_ = 0;

        // Calculate new execution time
        if (context_ == worstcase)
                et_ = wcet_;
        else if (context_ == randomcase)
                et_ = bcet_ + random (wcet_ - bcet_);
        else if (context_ == bestcase)
                et_ = bcet_;
}

inline void Task::clock_step (double clock_step)
{
        if ((state_ == enabled) || (state_ == executing) || (state_ == preempted))
                clock_dl_ += clock_step;
        if (state_ == executing)
                clock_exec_ += clock_step;

#ifdef DREAM_BRANCHING
        // IF statement optimization
        if (bcet_ < clock_exec_)
        {
                if ((clock_exec_ < wcet_) && remote_dep_ && Option::branching_)
                {
                        if (clock_exec_ < et_)
                        {
                                // Encountered a branching point
                                // Check whether it is relevant
                                if (thread_ptr_->scheduler ()->system ()->relevant_event ())
                                {
                                        // Let's blow up the state space a little more...
                                        std::string message;
                                        thread_ptr_->trace (message << "Branching point " << id_ << " bcet: " << bcet_ << " wcet: " << wcet_ << " next_et: " << clock_exec_);

                                        if (context_ == worstcase)
                                                context_ = branchingpoint;

                                        next_et_ = clock_exec_;
                                }
                        }
                }
        }
#endif
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
void Task::consume ()
        throw (DREAM::Exception)
#else
inline void Task::consume ()
#endif
{
        if (state_ == idle)
        {
                thread_ptr_->enqueue (this);
                state_ = enabled;
                clock_dl_reset ();
        }
        else
        {
                // Error
                if (state_ != error)
                {
                        // It's either waiting or preempted
                        if (state_ != executing)
                                thread_ptr_->dequeue (this);
                        state_ = error;
                        thread_ptr_->add_error (this);
                }
        }
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
uint Task::deadline () const
        throw (DREAM::Exception)
#else
inline uint Task::deadline () const
#endif
{
        return deadline_;
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
void Task::deadline (uint deadline)
        throw (DREAM::Exception)
#else
inline void Task::deadline (uint deadline)
#endif
{
        deadline_ = deadline;
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
void Task::execute ()
        throw (DREAM::Exception)
#else
inline void Task::execute ()
#endif
{
        if ((state_ == enabled) || (state_ == preempted))
        {
                state_ = executing;
                thread_ptr_->dequeue (this);
                clock_exec_reset ();

                std::string message;
                if (bcet_ != wcet_)
                {
#ifdef DREAM_BRANCHING
                        if (context_ == branchingpoint)
                        {
                                thread_ptr_->trace (message << "Branching point is taken by " << id_);
                        }
#endif
                        thread_ptr_->trace (message << id_ << " p: " << priority () 
                                << " sp: " << subpriority_ << " exec time: " << et_ 
                                << " <-- [" << bcet_ << ", " << wcet_ << "]");
                }
                else
                {
                        thread_ptr_->trace (message << id_ << " p: " << priority () 
                                << " sp: " << subpriority_ << " exec time: " << et_ );
                }
        }
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        else
        {
                std::string message;
                message << "Task " << id_ << " scheduled for execution is not enabled. Please report bug at http://sourceforge.net/projects/dre!";
                throw DREAM::Exception (message);
        }
#endif
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
bool Task::isidle () const
        throw (DREAM::Exception)
#else
inline bool Task::isidle () const
#endif
{
        return (state_ == idle) ? true : false;
}

inline double Task::next_event ()
{
        // If the task executes the next event is publishing
        // Otherwise we have no clue...
        return (state_ == executing) ? et_ - clock_exec_ : 0.0;
}

#ifdef DREAM_BRANCHING
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
void Task::next_et (double next_et)
        throw (DREAM::Exception)
#else
inline void Task::next_et (double next_et)
#endif
{
        next_et_ = next_et;
}
#endif

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
void Task::preempt ()
        throw (DREAM::Exception)
#else
inline void Task::preempt ()
#endif
{
        if (state_ == executing) state_ = preempted;
        thread_ptr_->enqueue (this);
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
uint Task::priority () const
        throw (DREAM::Exception)
#else
inline uint Task::priority () const
#endif
{
        return thread_ptr_->priority ();
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
void Task::priority (uint priority)
        throw (DREAM::Exception)
#else
inline void Task::priority (uint priority)
#endif
{
        deploy (scheduler ()->get_thread (priority));
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
void Task::publish ()
        throw (DREAM::Exception)
#else
inline void Task::publish ()
#endif
{
        if (state_ == executing)
                state_ = idle;
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        else
        {
                std::string message;
                message << "Task::publish () called on \"" << id_ << "\" which is not executing. Please report bug at http://sourceforge.net/projects/dre!";
                throw DREAM::Exception (message);
        }
#endif

        dependent_map_->publish ();
        thread_ptr_->scheduler ()->system ()->relevant_event (true);
}

inline void Task::reset ()
{
        state_ = idle;
        executed (0);
        clock_dl_reset ();
        clock_exec_reset ();
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
uint Task::subpriority () const
        throw (DREAM::Exception)
#else
inline uint Task::subpriority () const
#endif
{
        return subpriority_;
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
void Task::subpriority (uint subpriority)
        throw (DREAM::Exception)
#else
inline void Task::subpriority (uint subpriority)
#endif
{
        subpriority_ = subpriority;
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
void Task::take_transitions ()
        throw (DREAM::Exception)
#else
inline void Task::take_transitions ()
#endif
{
#ifdef DREAM_VERBOSE2
//      if (Option::verbose1_ && Option::verbose2_)
//      {
//              std::string message;
//              thread_ptr_->trace (message << id_ << " is taking transitions.");
//      }
#endif

        if ((clock_dl_ < deadline_) || (deadline_ == 0))                                // 0 deadline is used for no deadline
        {
                // Check whether the clock_exec_ has reached the execution time
                // IF statement optimization
                if (clock_exec_ == et_)
                {
                        if (state_ == executing)
                        {
                                publish ();
                                clock_exec_reset ();
                                clock_dl_reset ();
                                executed (1);

                                thread_ptr_->freethread ();

#ifdef DREAM_VERBOSE2
                                if (Option::verbose1_ && Option::verbose2_)
                                {
                                        std::string message;
                                        thread_ptr_->trace (message << id_ << " has finished the execution");
                                }
#endif

                        }
                }
        }
        else
        {
                // Check for errors
                if (state_ != error)
                {
                        if (state_ != executing)
                                thread_ptr_->dequeue (this);
                        // Error
                        state_ = error;
                        thread_ptr_->add_error (this);
                }
        }

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        if (clock_exec_ > et_)
        {
                std::string message;
                message << "Execution clock value \"" << clock_exec_ << "\" in Task \"" << id_ << "\" is greater than the actual execution time \"" << et_ 
                        << "\" (bcet: \"" << bcet_ << "\" wcet: \"" << wcet_ 
                        << "\"). Most likely the execution time was set during simulation. Please report bug at http://sourceforge.net/projects/dre!";
                throw DREAM::Exception (message);
        }
#endif
}

void Task::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
{
        if ((scheduler ()->nonpreemptive ())|| (scheduler ()->highestpriority (this)))
        {
                DREAM::NODE_MAP::const_iterator task_iter, task_iter2;
                uint i = 0;

                // Figure out our index from the list...
                for (task_iter = task_map->begin (); task_iter->first != id (); task_iter++)
                {
                        ++i;
                }

                f_stream << "/*\n * Task " << i << " - " << id_ << "\n *\n */\n" << std::endl;

                f_stream << "process task_" << id_ << " (1);\n" << std::endl;

                f_stream << "var ce clock public;\nvar cd clock public;\n" << std::endl;

                f_stream << "state initial #start ;\n\tdeadline eager;\n\tinput event ();\n\tset cd := 0;\n"
                        << "\ttask ({common}0).en[" << i << "] := true;\n\t\tnextstate wait;\nendstate;\n" << std::endl;

                f_stream << "state wait;\n\tdeadline eager;\n\tprovided ({common}0).exec[" << i << "];\n\tset ce := 0;\n"
                        << "\t\tnextstate run;\nendstate;\n" << std::endl;

                f_stream << "state run;\n\tdeadline delayable;\n\twhen ce <= wcet" << i << " and ce >= bcet" << i << ";\n"
                        << "\t\ttask ({common}0).en[" << i << "] := false;\n\t\treset ce;\n\t\treset cd;" << std::endl;

                const DREAM::NODE_MAP* node_map = get_dependent_map ();
                const DREAM::NODE_MAP* node_map2;

                // Check dependents
                DREAM::NODE_MAP::const_iterator find_iter;

                for (task_iter = node_map->begin (); task_iter != node_map->end (); task_iter++)
                {
                        find_iter = task_map->find (task_iter->first);
                        if (find_iter != task_map->end ())
                                f_stream << "\t\toutput event () to {task_" << find_iter->first << "}0;\n";
                        else
                        {
                                find_iter = channel_map->find (task_iter->first);

                                // Dependent is a channel - need to find dependent tasks...
                                if (find_iter->second)
                                        node_map2 = find_iter->second->get_dependent_map ();

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                                else
                                {
                                        std::string message;
                                        message << "Task " << task_iter->first << " has no Channel dependents. Incorrect model.";
                                        throw DREAM::Exception (message);
                                }
#endif

                                for (task_iter2 = node_map2->begin (); task_iter2 != node_map2->end (); task_iter2++)
                                {
                                        find_iter = node_map2->find (task_iter2->first);

                                        if (find_iter != node_map2->end ())
                                        {
                                                if (task_iter->second->wcet () != 0)
                                                        f_stream << "\t\toutput event () via {" << task_iter->first << "}0 to {task_" << find_iter->first << "}0;\n";
                                                else
                                                        f_stream << "\t\toutput event () /* via {" << task_iter->first << "}0 */ to {task_" << find_iter->first << "}0;\n";
                                        }

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                                        else
                                        {
                                                std::string message;
                                                message << "Node " << task_iter2->first << " could not be found as a Task dependent in the Task list when generating IF input. Incorrect model.";
                                                throw DREAM::Exception (message);
                                        }
#endif

                                }
                        }
                }
                        
                f_stream << "\t\t\tnextstate initial;\n\tdeadline eager;\n\tprovided ({common}0).exec[" << i << "] = false;\n"
                        // Faster << "\t\tnextstate wait;\nendstate;\n\nendprocess;\n" << std::endl;
                        << "\twhen ce = 0;\n\t\tnextstate wait;\nendstate;\n\nendprocess;\n" << std::endl;
        }
        else
        {
                DREAM::NODE_MAP::const_iterator task_iter, task_iter2;
                uint i = 0;

                // Figure out our index from the list...
                for (task_iter = task_map->begin (); task_iter->first != id (); task_iter++)
                {
                        ++i;
                }

                f_stream << "/*\n * Task " << i << " - " << id_ << "\n *\n */\n" << std::endl;

                f_stream << "process task_" << id_ << " (1);\n" << std::endl;

                f_stream << "var ce clock public;\nvar cd clock public;\nvar et integer public;\nvar pre integer public;\n" << std::endl;

                f_stream << "state initial #start ;\n\tdeadline eager;\n\tinput event ();\n\tset cd := 0;\n\ttask et := 0;\n\ttask pre := 0;\n"
                        << "\ttask ({common}0).en[" << i << "] := true;\n\t\tnextstate wait;\nendstate;\n" << std::endl;

                f_stream << "state wait;\n\tdeadline eager;\n\tprovided ({common}0).exec[" << i << "];\n\tset ce := 0;\n"
                        << "\t\tnextstate run;\nendstate;\n" << std::endl;

                /* f_stream << "state run;\n\tdeadline delayable;\n\twhen ce <= wcet" << i << " - et and ce >= bcet" 
                        << i << " - et - pre;\n" */

                f_stream << "state run;\n\tdeadline delayable;\n\twhen ce >= bcet" << i << " - et - pre;\n"
                        << "\t\ttask ({common}0).en[" << i << "] := false;\n\t\treset ce;\n\t\treset cd;" << std::endl;

                const DREAM::NODE_MAP* node_map = get_dependent_map ();
                const DREAM::NODE_MAP* node_map2;

                // Check dependents
                DREAM::NODE_MAP::const_iterator find_iter;

                for (task_iter = node_map->begin (); task_iter != node_map->end (); task_iter++)
                {
                        find_iter = task_map->find (task_iter->first);
                        if (find_iter != task_map->end ())
                                f_stream << "\t\toutput event () to {task_" << find_iter->first << "}0;\n";
                        else
                        {
                                find_iter = channel_map->find (task_iter->first);

                                // Dependent is a channel - need to find dependent tasks...
                                if (find_iter->second)
                                        node_map2 = find_iter->second->get_dependent_map ();

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                                else
                                {
                                        std::string message;
                                        message << "Task " << task_iter->first << " has no Channel dependents. Incorrect model.";
                                        throw DREAM::Exception (message);
                                }
#endif

                                for (task_iter2 = node_map2->begin (); task_iter2 != node_map2->end (); task_iter2++)
                                {
                                        find_iter = node_map2->find (task_iter2->first);
                                                if (find_iter != node_map2->end ())
                                                {
                                                        if (task_iter->second->wcet () != 0)
                                                                f_stream << "\t\toutput event () via {" << task_iter->first << "}0 to {task_" << find_iter->first << "}0;\n";
                                                        else
                                                                f_stream << "\t\toutput event () /* via {" << task_iter->first << "}0 */ to {task_" << find_iter->first << "}0;\n";
                                                }

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                                                else
                                                {
                                                        std::string message;
                                                        message << "Node " << task_iter2->first << " could not be found as a Task dependent in the Task list when generating IF input. Incorrect model.";
                                                        throw DREAM::Exception (message);
                                                }
#endif
                                }
                        }
                }
                        
                /* f_stream << "\t\t\tnextstate initial;\n\tdeadline eager;\n\twhen ce < wcet" << i << " - et and ce >= pr;" << std::endl;
                f_stream << "\t\tnextstate pass;\n"; */

                f_stream << "\t\t\tnextstate initial;\n\tdeadline eager;\n\twhen ce >= wcet" << i << " - et;\n"
                        << "\t\ttask ({common}0).en[" << i << "] := false;\n\t\treset ce;\n\t\treset cd;" << std::endl;

                /* f_stream << "\t\t\tnextstate initial;\n\tdeadline eager;\n\tprovided et + pr < wcet" << i << ";\n\twhen ce >= pr;\n"
                        << "\t\tnextstate pass;\n\tprovided et + pr >= wcet" << i << ";\n"
                        << "\t\ttask ({common}0).en[" << i << "] := false;\n\t\treset ce;\n\t\treset cd;" << std::endl; */

                for (task_iter = node_map->begin (); task_iter != node_map->end (); task_iter++)
                {
                        find_iter = task_map->find (task_iter->first);
                        if (find_iter != task_map->end ())
                                f_stream << "\t\toutput event () to {task_" << find_iter->first << "}0;\n";
                        else
                        {
                                find_iter = channel_map->find (task_iter->first);

                                // Dependent is a channel - need to find dependent tasks...
                                if (find_iter->second)
                                        node_map2 = find_iter->second->get_dependent_map ();

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                                else
                                {
                                        std::string message;
                                        message << "Task " << task_iter->first << " has no Channel dependents. Incorrect model.";
                                        throw DREAM::Exception (message);
                                }
#endif

                                for (task_iter2 = node_map2->begin (); task_iter2 != node_map2->end (); task_iter2++)
                                {
                                        find_iter = node_map2->find (task_iter2->first);
                                                if (find_iter != node_map2->end ())
                                                {
                                                        if (task_iter->second->wcet () != 0)
                                                                f_stream << "\t\toutput event () via {" << task_iter->first << "}0 to {task_" << find_iter->first << "}0;\n";
                                                        else
                                                                f_stream << "\t\toutput event () /* via {" << task_iter->first << "}0 */ to {task_" << find_iter->first << "}0;\n";
                                                }

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                                                else
                                                {
                                                        std::string message;
                                                        message << "Node " << task_iter2->first << " could not be found as a Channel dependent in the Task list when generating IF input. Incorrect model.";
                                                        throw DREAM::Exception (message);
                                                }
#endif
                                }
                        }
                }

                f_stream << "\t\t\tnextstate initial;\n\tprovided et + pr < wcet" << i << ";\n\twhen ce >= pr;\n\t\tnextstate pass;\n"
                        << "\tprovided ({common}0).exec[" << i << "] = false and et = 0;\n"

                        /* << "\t\tnextstate wait;\n\tprovided ({common}0).exec[" << i << "] = false and et > 0;\n"
                        << "\ttask pre := pre + pr;\n\t\tnextstate wait;\n"
                        << "\nendstate;\n\nstate pass #unstable ;\n\tset ce := 0;\n\ttask et := et + pr;\n\t\tnextstate run;\nendstate;\n" */

                        << "\twhen ce = 0;\n\t\tnextstate wait;\n\tprovided ({common}0).exec[" << i << "] = false and et = 0;\n"
                        << "\twhen ce > 0;\n\ttask pre := pre + pr;\n\t\tnextstate wait;\n"
                        << "\tprovided ({common}0).exec[" << i << "] = false and et > 0;\n\ttask pre := pre + pr;\n\t\tnextstate wait;\n"
                        << "\nendstate;\n\nstate pass #unstable ;\n\tset ce := 0;\n\ttask et := et + pr;\n\t\tnextstate run;\nendstate;\n"
                        << "\nendprocess;\n" << std::endl;

                        /* Faster << "\t\tnextstate wait;\n\tprovided ({common}0).exec[" << i << "] = false and et > 0;\n\ttask pre := pre + pr;\n\t\tnextstate wait;\n"
                        << "\nendstate;\n\nstate pass #unstable ;\n\tset ce := 0;\n\ttask et := et + pr;\n\t\tnextstate run;\nendstate;\n"
                        << "\nendprocess;\n" << std::endl; */
        }
}

void Task::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
{
        task_map->insert (DREAM::NODE_PAIR (id_, this));
}

void Task::visitor_task_avltree (DREAM::TASK_AVLTREE* task_avltree)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
        task_avltree->insert (id_, this);
}

void Task::visitor_update_task_avltree (DREAM::TASK_AVLTREE* task_avltree)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
        DREAM::TASK_AVLTREE::iterator task_iter;

        // Update task from parameter list.
        for (task_iter = task_avltree->begin ();
                task_iter != task_avltree->end (); task_iter++)
        {
                if (this == (*task_iter)->second)
                // Pointer refers to the same object...
                        break;
                if ((*this) == * ((*task_iter)->second))
                {
                         (*this) = * ((*task_iter)->second);
                        break;
                }
        }
}

void Task::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
{
        if ((scheduler ()->nonpreemptive ())|| (scheduler ()->highestpriority (this)))
                f_stream << id () << " := NonpTask (";
        else
                f_stream << id () << " := Task (";

        DREAM::NODE_MAP::const_iterator task_iter;
        uint i = 0;

        // Figure out our index from the list...
        for (task_iter = task_map->begin (); task_iter->first != id_; task_iter++)
        {
                ++i;
        }

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        if (task_iter == task_map->end ())
                throw DREAM::Exception ("Task::visitor_uppaal () called for a nonexistent Task. Please report bug at http://sourceforge.net/projects/dre!");
#endif

        if ((scheduler ()->nonpreemptive ())|| (scheduler ()->highestpriority (this)))
                f_stream << i << ", " << wcet_ << ", " << bcet_ << ", " << deadline_ << ", ";
        else
                f_stream << i << ", " << wcet_ << ", " << bcet_ << ", " << deadline_ << ", 1, ";
        
        if (get_source (task_map, channel_map, timer_map))
                // Source is something other than a Channel
                f_stream << "publish" << get_source (task_map, channel_map, timer_map)->id () ;
        else
                // Source (s) is (are) Channel (s)
                f_stream << "start" << id ();

        if ((scheduler ()->nonpreemptive ())|| (scheduler ()->highestpriority (this)))
                f_stream << ", run" << id () << ", publish" << id () << ");" << std::endl;
        else
                f_stream << ", run" << id () << ", publish" << id () << ", preempt"
                << scheduler ()->id () << ");" << std::endl;
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
uint Task::wcet () const
        throw (DREAM::Exception)
#else
inline uint Task::wcet () const
#endif
{
        return wcet_;
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
void Task::wcet (uint wcet)
        throw (DREAM::Exception)
#else
inline void Task::wcet (uint wcet)
#endif
{
        wcet_ = wcet;
}

#ifndef DREAM_RACE_CONDITION_ZERO
bool Task::zero_delay_race_condition (DREAM::System* system_ptr)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
        if (!Option::race_condition_zero_)
        {
                if (zero_delay_race_condition_ == 0)
                        return false;
                else if (zero_delay_race_condition_ == 1)
                        return true;

                DREAM::NODE_MAP task_map;
                DREAM::NODE_MAP channel_map;
                DREAM::NODE_MAP timer_map;

                system_ptr->visitor_map (&task_map, &channel_map, &timer_map);

                const DREAM::Node* source_task = get_source (&task_map, &channel_map, &timer_map);
                                
                if ((source_task) && (scheduler ()) && (source_task->scheduler ()))
                {
                        if (scheduler () == source_task->scheduler ())
                        {
                                // No race conditions as task_ptr is triggered by an event from the local machine.
                                // Skip the checking of the whole list...
                                zero_delay_race_condition_ = 1;
                                return true;
                        }
                        else
                        {
                                zero_delay_race_condition_ = 0;
                                return false;
                        }
                }
                else
                {
                        // Let's see whether all sources are Channels with zero-time delay
                        DREAM::NODE_MAP::const_iterator node_iter;
                        bool found = false;
                        bool allzero = true;

                        for (node_iter = channel_map.begin (); node_iter != channel_map.end (); node_iter++)
                        {
                                if (node_iter->second->get_dependent (id_))
                                {
                                        found = true;
                                        if (node_iter->second->wcet () != 0)
                                                allzero = false;
                                }
                        }

                        if (found && allzero)
                        {
                                zero_delay_race_condition_ = 1;
                                return true;
                        }
                        else
                        {
                                zero_delay_race_condition_ = 0;
                                return false;
                        }
                }
        }
        else
                return false;
}
#endif

/////////////////////////////////////////////////////////////////////////////
//
// PowerAwareTask
//
/////////////////////////////////////////////////////////////////////////////
/*
PowerAwareTask::PowerAwareTask (const std::string& id, DREAM::Thread* thread_ptr, uint wcet, uint deadline)
        : DREAM::Task (id, thread_ptr, wcet, deadline)
{
}

PowerAwareTask::PowerAwareTask (const std::string& id, DREAM::Thread* thread_ptr, uint wcet, uint deadline, uint subpriority)
        : DREAM::Task (id, thread_ptr, wcet, deadline, subpriority)
{
}

PowerAwareTask::PowerAwareTask (const std::string& id, DREAM::Thread* thread_ptr, uint wcet, uint bcet, uint deadline, uint subpriority)
        : DREAM::Task (id, thread_ptr, wcet, bcet, deadline, subpriority)
{
        if (wcet <= bcet)
                throw DREAM::Exception ("PowerAwareTask best case execution time has to be smaller than the worst case execution time.");
}

PowerAwareTask::PowerAwareTask (const DREAM::PowerAwareTask& powerawaretask)
        : DREAM::Task (powerawaretask.id_, powerawaretask.thread_ptr_, powerawaretask.wcet_, powerawaretask.bcet_
                , powerawaretask.deadline_,     powerawaretask.subpriority_, powerawaretask.context_, powerawaretask.et_
                , powerawaretask.state_, powerawaretask.clock_dl_)
{
}

PowerAwareTask::~PowerAwareTask ()
{
}

void PowerAwareTask::operator= (const DREAM::PowerAwareTask& powerawaretask)
{
        id_ = powerawaretask.id_;
        // Do not try to redeploy! This will crash in VC7.1 STL map implementations.
        // deploy (task.thread_ptr_);
        wcet_ = powerawaretask.wcet_;
        bcet_ = powerawaretask.bcet_;
        context_ = powerawaretask.context_;
        deadline_ = powerawaretask.deadline_;
        subpriority_ = powerawaretask.subpriority_;
        state_ = powerawaretask.state_;
        clock_dl_ = powerawaretask.clock_dl_;
}

bool PowerAwareTask::operator== (const DREAM::PowerAwareTask& powerawaretask)
{
        if (id_ == powerawaretask.id_)
/*       (thread_ptr_ == powerawaretask.thread_ptr_) &&
         (wcet_ == powerawaretask.wcet_) &&
         (bcet_ == powerawaretask.bcet_) &&
         (context_ == powerawaretask.context_) &&
         (deadline_ == powerawaretask.deadline_) &&
         (subpriority_ == powerawaretask.subpriority_) &&
         (state_ == powerawaretask.state_) &&
         (clock_dl_ == powerawaretask.clock_dl_))*
                return true;
        else
                return false;
}

inline void PowerAwareTask::clock_step (double clock_step)
{
        if ((state_ == enabled) || (state_ == executing) || (state_ == preempted) )
                clock_dl_ += clock_step;
        if (state_ == executing)
                clock_exec_ += clock_step * thread_ptr_->scheduler ()->speed ();
}

inline double PowerAwareTask::next_event ()
{
        // If the task executes the next event is publishing
        if (state_ == executing)
                return (et_ - clock_exec_ * thread_ptr_->scheduler ()->speed ());
        // Otherwise we have no clue...
        else
                return 0.0;
}
*/
/////////////////////////////////////////////////////////////////////////////
//
// PriorityInversionList
//
/////////////////////////////////////////////////////////////////////////////

#ifdef DREAM_RACE_CONDITION
PriorityInversionList::PriorityInversionList (DREAM::System* system_ptr)
: system_ptr_ (system_ptr)
{
}

PriorityInversionList::~PriorityInversionList ()
{
        task_avltree_list_.destroy ();
}

void PriorityInversionList::add (const DREAM::TASK_AVLTREE* task_avltree_ptr, DREAM::Task* task_ptr)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
        DREAM::TASK_AVLTREE* new_avltree = NULL;

        if (!find (task_avltree_ptr, task_ptr))
        {
                // Task not present in priority inversion list

                // Create copy of task_avltree
                new_avltree = new DREAM::TASK_AVLTREE ();
                task_avltree_list_.push_back (new_avltree);

                new_avltree->assign (task_avltree_ptr->begin (), task_avltree_ptr->end ());
                task_id_list_.push_back (new_avltree->begin ()->first);
        }
}

void PriorityInversionList::destroy ()
// link issue: void PriorityInversionList::destroy ()
{
        // Free up memory
        task_avltree_list_.destroy ();
        task_id_list_.clear ();
}

DREAM::Task* PriorityInversionList::find (const DREAM::TASK_AVLTREE* task_avltree_ptr, DREAM::Task* task_ptr)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        if (!task_ptr)
                throw DREAM::Exception ("Illegal use of PriorityInversionList::find (). Please report bug at http://sourceforge.net/projects/dre!");
#endif

        TASK_AVLTREE_LIST::const_iterator main_iter;
        TASK_ID_LIST::const_iterator id_iter;
        bool found = false;
        id_iter = NULL;

        // Iterate through the LinkedList, see if we can find task_avltree_ptr in the data structure already
        // Main loop
        for (main_iter = task_avltree_list_.begin (); main_iter != task_avltree_list_.end (); main_iter++)
        {
                // Iterate with the task id list as well
                if (id_iter == NULL)
                        id_iter = task_id_list_.begin ();
                else
                        ++id_iter;

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
                if (id_iter == task_id_list_.end ())
                        throw DREAM::Exception ("PriorityInversionList::find () task_avltree_ptr_ and task_id_list_ lists are out of sync. Please report bug at http://sourceforge.net/projects/dre!");
#endif

                // Let's see whether the two trees have the same size
                if (main_iter->item ()->size () != task_avltree_ptr->size ())
                        // Trees do not match, keep iterating
                        break;

                // Let's see whether they contain the same elements
                DREAM::TASK_AVLTREE::const_iterator tree_iter;
                for (tree_iter = task_avltree_ptr->begin (); tree_iter != task_avltree_ptr->end (); tree_iter++)
                {
                        if (main_iter->item ()->find (tree_iter->first) == main_iter->item ()->end ())
                                // Trees do not match, keep iterating
                                break;

                        // Found the tree, return the element to be executed
                        return main_iter->item ()->find (id_iter->item ())->second;
                }
        }

        return NULL;
}

DREAM::Task* PriorityInversionList::find_current (const DREAM::TASK_AVLTREE* task_avltree_ptr, DREAM::Task* task_ptr)
// link issue: inline DREAM::Task* PriorityInversionList::find_current (const DREAM::TASK_AVLTREE* task_avltree_ptr, DREAM::Task* task_ptr)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
        add (task_avltree_ptr, task_ptr);
        return (find (task_avltree_ptr, task_ptr));
}

bool PriorityInversionList::increment (TASK_AVLTREE_LIST::iterator task_avltree_list_iter,
                TASK_ID_LIST::iterator task_id_list_iter)
{
        AVLTree <std::string, DREAM::Task*>* tree_ptr = task_avltree_list_iter->item ();
        AVLTreeNode <std::string, DREAM::Task*>* node_ptr = tree_ptr->find (task_id_list_iter->item ());
        TASK_AVLTREE::iterator iter;
        iter = node_ptr;

        if (iter != task_avltree_list_iter->item ()->last ())
        {
                // Iterate through current tree
                iter++;
                // Set the new element's id in the id list
                task_id_list_iter->item (iter->first);
                return true;
        }
        else
        {
                // End of tree found
#ifdef DREAM_RACE_CONDITION_COMBINATION
                if ((Option::race_condition_combination_) && (Option::race_condition_))
                {
                        // set task id to the first element of the AVL tree
                        task_id_list_iter->item (task_avltree_list_iter->item ()->begin ()->first);
                }
#endif
                // increment next id
                ++task_avltree_list_iter;
                ++task_id_list_iter;
                if ((task_avltree_list_iter != task_avltree_list_.end ()) && (task_id_list_iter != task_id_list_.end ()))
                {
                        return increment (task_avltree_list_iter, task_id_list_iter);
                }
                else
                        return false;
        }
}

bool PriorityInversionList::inversion ()
// link issue: inline bool PriorityInversionList::inversion ()
{
        if (task_avltree_list_.size () == 0)
                return false;

        TASK_AVLTREE_LIST::iterator tree_iter;
        TASK_ID_LIST::iterator id_iter;
        tree_iter = task_avltree_list_.begin ();
        id_iter = task_id_list_.begin ();

        return increment (tree_iter, id_iter);
}

#endif

}

---