Scheduler.cpp

Go to the documentation of this file.

/** @file Scheduler.cpp
* @author Gabor Madl
* @date Created 02/2005
* @brief Scheduler model implementation.
*
*
* =================================================================
* 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 "Scheduler.h"

namespace DREAM
{

/////////////////////////////////////////////////////////////////////////////
//
// QoSLevel
//
/////////////////////////////////////////////////////////////////////////////

QoSLevel::QoSLevel (const double speed, const double power)
: speed_ (speed), power_ (power)
{
}

inline double QoSLevel::power () const
{
        return power_;
}

inline double QoSLevel::speed () const
{
        return speed_;
}

/////////////////////////////////////////////////////////////////////////////
//
// Scheduler
//
/////////////////////////////////////////////////////////////////////////////


Scheduler::Scheduler (const std::string& id, DREAM::System* system_ptr, uint CPUs)
: id_ (id),
CPUs_ (CPUs),
availableCPUs_ (CPUs),
time_ (0),
system_ptr_ (system_ptr),
verbose_ (false)
{
}

Scheduler::~Scheduler ()
{
        std::for_each (thread_map_.begin (), thread_map_.end (), delete_pair ());
}

void Scheduler::add (DREAM::Node* node_ptr, uint priority)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
        DREAM::THREAD_MAP::iterator thread_iter = thread_map_.find (priority);

        if (thread_iter != thread_map_.end ())
        {
                thread_iter->second->add (node_ptr);
        }
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        else
        {
                std::string message;
                message << "Thread pool in Scheduler \"" << id_ << "\" does not have a lane with priority \"" << thread_iter->second->priority () << "\"...";
                throw DREAM::Exception (message);
        }
#endif
}

void Scheduler::add_error (DREAM::Task* task_ptr)
{
        std::string message;
        trace (message << "MISSED DEADLINE: Node " << task_ptr->id () << " W(t) = " << task_ptr->wcet () << " D(t) = " << task_ptr->deadline () << " S(t) = " <<        task_ptr->subpriority ());
        error_avltree_.insert (task_ptr->id (), task_ptr);
}

void Scheduler::add_thread (DREAM::Thread* thread_ptr)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
        DREAM::THREAD_MAP::iterator thread_iter = thread_map_.find (thread_ptr->priority ());
        std::string message;

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        if (thread_iter != thread_map_.end ())
        {
                std::string message;
                message << "Thread pool in Scheduler \"" << id_ << "\" already has a lane with priority \"" << thread_ptr->priority () << "\"...";
                throw DREAM::Exception (message);
        }
#endif

        thread_map_.insert (DREAM::THREAD_PAIR (thread_ptr->priority (), thread_ptr));
}

#ifndef DREAM_NON_EXECUTING_TASKS
void Scheduler::check_executed (const DREAM::NODE_MAP* node_map)
{
        DREAM::NODE_MAP::const_iterator node_iter;

        for (node_iter = node_map->begin (); node_iter != node_map->end (); node_iter++)
        {
                // Check nodes which were not executed
                if (! (node_iter->second->executed ()) )
                        add_error ((DREAM::Task*) node_iter->second);
        }
}
#endif

inline uint Scheduler::CPUs () const
{
        return 0;
}

void Scheduler::freeCPU ()
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
        if (availableCPUs_ < CPUs_)
                ++availableCPUs_;
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        else
        {
                std::string message;
                message << "Scheduler \"" << id_ << "\" cannot free unused CPUs...";
                throw DREAM::Exception (message);
        }
#endif
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
DREAM::Thread* Scheduler::get_thread (uint priority) const
        throw (DREAM::Exception)
#else
DREAM::Thread* Scheduler::get_thread (uint priority) const
#endif
{
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        if (thread_map_.empty ())
                throw DREAM::Exception ("Scheduler::get_thread () called for empty thread_map_. No Threads are managed by the Scheduler.");
#endif

        DREAM::THREAD_MAP::const_iterator thread_iter = thread_map_.find (priority);

        if (thread_iter != thread_map_.end ())
                return thread_iter->second;
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        else
                throw DREAM::Exception ("Scheduler::get_thread () called with invalid priority.");
#else
        else
                return NULL;
#endif
}

bool Scheduler::highestpriority (const DREAM::Node* node_ptr) const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw DREAM::BaseClassException ("Generic Scheduler does not have priority lanes. Inherited classes may implement this function.");
#else
        return false;
#endif
}

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

bool Scheduler::lowestpriority (const DREAM::Node* node_ptr) const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw DREAM::BaseClassException ("Generic Scheduler does not have priority lanes. Inherited classes may implement this function.");
#else
        return false;
#endif
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
double Scheduler::next_event (bool deterministic) const
        throw (DREAM::Exception)
#else
inline double Scheduler::next_event (bool deterministic) const
#endif
{
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        if (thread_map_.empty ())
                throw DREAM::Exception ("Scheduler::next_event () called for empty thread_map_. No Threads are managed by the Scheduler.");
#endif

        double time_step = 0.0;

        for (DREAM::THREAD_MAP::const_iterator thread_iter = thread_map_.begin (); thread_iter != thread_map_.end (); thread_iter++)
        {
                double temp = thread_iter->second->next_event ();
                
                if (0.0 < temp && temp < time_step)
                        time_step = temp;
                else if (time_step == 0.0)
                        time_step = temp;
        }

        return time_step;
}


bool Scheduler::nonpreemptive () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw DREAM::BaseClassException ("Generic Scheduler is neither preemptive nor nonpreemptive. Inherited classes may implement this function.");
#else
        return false;
#endif
}


inline double Scheduler::power () const
{
        return qos_current_->power ();
}


void Scheduler::qos_add (DREAM::QoSLevel* qos_current)
{
        qos_avltree_.insert (qos_current->speed (), qos_current);
}


void Scheduler::qos_power (const double power, DREAM::QoSLevel* low, DREAM::QoSLevel* high)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
        QOS_AVLTREE::iterator avltree_iter;

        for (avltree_iter = qos_avltree_.begin (); avltree_iter != qos_avltree_.end (); avltree_iter++)
        {
                if (power >= avltree_iter->second->power ())
                        break;
        }

        high = avltree_iter->second;
        if (power == avltree_iter->second->speed ())
                low = avltree_iter->second;
        else
        {
                if (avltree_iter != qos_avltree_.begin ())
                {
                        --avltree_iter;
                        low = avltree_iter->second;
                }
        }
}


void Scheduler::qos_speed (const double speed, DREAM::QoSLevel* low, DREAM::QoSLevel* high)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
        QOS_AVLTREE::iterator avltree_iter;

        for (avltree_iter = qos_avltree_.begin (); avltree_iter != qos_avltree_.end (); avltree_iter++)
        {
                if (speed >= avltree_iter->second->speed ())
                        break;
        }

        high = avltree_iter->second;
        if (speed == avltree_iter->second->speed ())
                low = avltree_iter->second;
        else
        {
                if (avltree_iter != qos_avltree_.begin ())
                {
                        --avltree_iter;
                        low = avltree_iter->second;
                }
        }
}


void Scheduler::erase (DREAM::Node* node_ptr, uint priority)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
        DREAM::THREAD_MAP::iterator thread_iter = thread_map_.find (priority);

        if (thread_iter != thread_map_.end ())
        {
                thread_iter->second->erase (node_ptr->id ());
        }
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        else
        {
                std::string message;
                message << "Thread pool in Scheduler \"" << id_ << "\" does not have a lane with priority \"" << thread_iter->second->priority () << "\"...";
                throw DREAM::Exception (message);
        }
#endif
}

void Scheduler::reset ()
{
        time_ = 0;
        availableCPUs_ = CPUs_;
        error_avltree_.clear ();

        std::for_each (thread_map_.begin (), thread_map_.end (), reset_pair ());
}

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

void Scheduler::simulate (bool verbose, bool deterministic)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        std::string message;
        throw DREAM::BaseClassException
                 (message << "Scheduler \"" << id_ << "\" does not simulate. Use the inherited classes which implement this feature.");
#endif
}

inline double Scheduler::speed () const
{
        return qos_current_->speed ();
}

void Scheduler::stop ()
{
        DREAM::THREAD_MAP::iterator thread_iter;
        
#ifndef DREAM_NON_EXECUTING_TASKS
        if (!Option::non_executing_tasks_)
        {
                for (thread_iter = thread_map_.begin (); thread_iter != thread_map_.end (); thread_iter++)
                {
                        check_executed (thread_iter->second->get_map ());
                }
        }
#endif

        active_ = false;
}

const DREAM::System* Scheduler::system () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
        return system_ptr_;
}

DREAM::System* Scheduler::system ()
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
        return system_ptr_;
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
void Scheduler::take_transitions ()
        throw (DREAM::Exception)
#else
inline void Scheduler::take_transitions ()
#endif
{
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        if (thread_map_.empty ())
                throw DREAM::Exception ("Scheduler::take_transitions () called for empty thread_map_. No Threads are managed by the Scheduler.");
#endif

        DREAM::THREAD_MAP::iterator thread_iter;
        
        std::for_each (thread_map_.begin (), thread_map_.end (), transition_pair ());
}

const DREAM::THREAD_MAP* Scheduler::thread_map () const
{
        return &thread_map_;
}

uint Scheduler::threadpoolsize () const
{
        return thread_map_.size ();
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
double Scheduler::time () const
        throw (DREAM::Exception)
#else
inline double Scheduler::time () const
#endif
{
        return time_;
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
void Scheduler::time_step (double time_step)
        throw (DREAM::Exception)
#else
inline void Scheduler::time_step (double time_step)
#endif
{
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        if (thread_map_.empty ())
                throw DREAM::Exception ("Scheduler::time_step () called for empty thread_map_. No Threads are managed by the Scheduler.");
#endif

        time_ += time_step;

        for (DREAM::THREAD_MAP::iterator thread_iter = thread_map_.begin (); thread_iter != thread_map_.end (); thread_iter++)
        {
                thread_iter->second->time_step (time_step);
        }
}

void Scheduler::trace (const std::string& output) const
{
        if (verbose_)
        {
                std::string message;
                message << time_ << ": " << id_ << " " << output;
                std::cout << message << std::endl;
        }
}

inline void Scheduler::verbose (bool verbose)
{
        verbose_ = verbose;
}

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

        for (task_iter = error_avltree_.begin (); task_iter != error_avltree_.end (); task_iter++)
        {
                task_avltree->insert (task_iter->first, task_iter->second);
        }
}

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

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

void Scheduler::visitor_map (DREAM::NODE_MAP* task_map, DREAM::NODE_MAP* channel_map, DREAM::NODE_MAP* timer_map)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
        DREAM::THREAD_MAP::iterator thread_iter;

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

void Scheduler::visitor_task_avltree (DREAM::TASK_AVLTREE* task_avltree)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
        DREAM::THREAD_MAP::iterator thread_iter;

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

void Scheduler::visitor_update_task_avltree (DREAM::TASK_AVLTREE* task_avltree)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
        DREAM::THREAD_MAP::iterator thread_iter;

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

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

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

/////////////////////////////////////////////////////////////////////////////
//
// NonConcurrentScheduler
//
/////////////////////////////////////////////////////////////////////////////

NonConcurrentScheduler::NonConcurrentScheduler (const std::string& id, DREAM::System* system_ptr)
: DREAM::Scheduler (id, system_ptr, 1)
{
}

NonConcurrentScheduler::~NonConcurrentScheduler ()
{
}

void NonConcurrentScheduler::schedule (bool israndom)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
        std::for_each (thread_map_.begin (), thread_map_.end (), transition_pair ());
}

/////////////////////////////////////////////////////////////////////////////
//
// FixedPriorityScheduler
//
/////////////////////////////////////////////////////////////////////////////

FixedPriorityScheduler::FixedPriorityScheduler (const std::string& id, DREAM::System* system_ptr, uint CPUs)
: DREAM::Scheduler (id, system_ptr, CPUs)
{
}

FixedPriorityScheduler::~FixedPriorityScheduler ()
{
}

inline uint FixedPriorityScheduler::CPUs () const
{
        return CPUs_;
}

bool FixedPriorityScheduler::highestpriority (const DREAM::Node* node_ptr) const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
        DREAM::THREAD_MAP::const_iterator thread_iter;

        for (thread_iter = thread_map_.begin (); thread_iter != thread_map_.end (); thread_iter++)
        {
                if (thread_iter->first < node_ptr->priority ())
                        return false;
        }

        return true;
}

bool FixedPriorityScheduler::lowestpriority (const DREAM::Node* node_ptr) const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
        DREAM::THREAD_MAP::const_iterator thread_iter;

        for (thread_iter = thread_map_.begin (); thread_iter != thread_map_.end (); thread_iter++)
        {
                if (thread_iter->first > node_ptr->priority ())
                        return false;
        }

        return true;
}

bool FixedPriorityScheduler::nonpreemptive () const
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
        return (thread_map_.size () == 1) ? true : false;
}

void FixedPriorityScheduler::schedule (bool deterministic)
        throw (DREAM::Exception)
{
        while (0 < availableCPUs_)
        {
                uint priority = maxuint;
                uint subpriority = maxuint;

                DREAM::THREAD_MAP::const_iterator thread_iter;
                for (thread_iter = thread_map_.begin (); thread_iter != thread_map_.end (); thread_iter++)
                        if (thread_iter->second->schedulable ())
                                if ((priority == maxuint) || (thread_iter->first < priority))
                                        priority = thread_iter->first;

                if (priority == maxuint)
                {
                        // No schedulable threads
#ifdef DREAM_VERBOSE2
                        if (Option::verbose1_ && Option::verbose2_)
                                trace ("No schedulable threads");
#endif
                        return;
                }

                DREAM::Thread* thread_ptr = 
                        thread_map_.find (priority)->second;

                const DREAM::NODE_MAP* exec_map_ptr =
                        thread_ptr->get_exec_map ();

                // thread might be a priority lane with multiple threads
                while ((0 < thread_ptr->availablethreads ()) && (0 < availableCPUs_))
                {

                        // Nodes can get deleted from the map while processed
                        DREAM::NODE_MAP::const_iterator exec_iter;
                        exec_iter = exec_map_ptr->begin ();

                        while (exec_iter != exec_map_ptr->end ())
                        {
                                DREAM::Node* node_ptr = exec_iter->second;

                                DREAM::NODE_MAP::const_iterator exec_iter_next = exec_iter;

                                if (subpriority == maxuint)
                                        subpriority = node_ptr->subpriority ();

                                // Pick highest subpriority node
                                // Lower number - higher priority
                                if (node_ptr->subpriority () < subpriority)
                                        subpriority = node_ptr->subpriority ();

                                exec_iter = ++exec_iter_next;
                        }

                        DREAM::TASK_AVLTREE task_avltree;

                        for (exec_iter = exec_map_ptr->begin (); exec_iter != exec_map_ptr->end (); exec_iter++)
                                if (exec_iter->second->subpriority () == subpriority)
                                        task_avltree.insert (exec_iter->first, static_cast <DREAM::Task*> (exec_iter->second));

                        // Check if the solution is unique
                        uint size = task_avltree.size ();

                        DREAM::Task *exec_ptr;

                        // Let's pick a random high sub-priority task...
                        if (size > 1)
                                if (!deterministic)
                                        exec_ptr = task_avltree[ (uint) random (task_avltree.size ())];
                                else
                                        throw DREAM::Exception ("Same sub-priorities found in deterministic schedule. The method does not deal with this problem...");
                        else
                                exec_ptr = task_avltree.begin ()->second;

#ifdef DREAM_RACE_CONDITION
                        if (Option::race_condition_)
                        {
                                if (thread_ptr->recent (exec_ptr))
                                {
                                        const DREAM::TASK_AVLTREE* task_avltree_ptr = thread_ptr->get_recent_avltree ();

                                        DREAM::TASK_AVLTREE::const_iterator task_iter;
                                        bool comma = false;
                                        std::string message;
                                        message << "Race condition between ";

                                        for (task_iter = task_avltree_ptr->begin (); task_iter != task_avltree_ptr->end (); task_iter++)
                                        {
                                                if (!comma)
                                                        comma = true;
                                                else
                                                        message << ", ";

                                                message << task_iter->first << "";
                                        }

                                        thread_ptr->trace (message);

                                        // Check which task should actually execute now
                                        if (deterministic)
#ifndef DREAM_RACE_CONDITION_ZERO
                                                if (!exec_ptr->zero_delay_race_condition (system_ptr_))
                                                        exec_ptr = thread_ptr->scheduler ()->system ()->find_current (task_avltree_ptr, exec_ptr);
                                                else
                                                {
                                                        std::string message2;
                                                        trace (message2 << "Ignoring race condition between zero-time events");
                                                }
#else
                                                exec_ptr = thread_ptr->scheduler ()->system ()->find_current (task_avltree_ptr, exec_ptr);
#endif
                                        else
                                        {
#ifndef DREAM_RACE_CONDITION_ZERO
                                                if (!exec_ptr->zero_delay_race_condition (system_ptr_))
                                                        exec_ptr = (*task_avltree_ptr) [ (uint) random (task_avltree_ptr->size ())];
                                                else
                                                {
                                                        std::string message2;
                                                        trace (message2 << "Ignoring race condition between zero-time events");
                                                }
#else
                                                exec_ptr = (*task_avltree_ptr) [ (uint) random (task_avltree_ptr->size ())];
#endif
                                        }
                                }
                        }
#endif

#ifdef DREAM_VERBOSE2
                        if (Option::verbose1_ && Option::verbose2_)
                        {
                                std::string message3;
                                if (size > 1)
                                        trace (message3 << "Node " << exec_ptr->id () << " S(t) = " << exec_ptr->subpriority () << " scheduled for execution non-deterministically");
                                else
                                        trace (message3 << "Node " << exec_ptr->id () << " S(t) = " << exec_ptr->subpriority () << " scheduled for execution");
                        }
#endif

                        thread_ptr->usethread ();
                        --availableCPUs_;
                        exec_ptr->execute ();
                }
        }
}

void FixedPriorityScheduler::simulate (bool verbose, bool deterministic)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
        if (verbose)
                if (deterministic)
                        std::cout << std::endl << "DREAM http://dre.sourceforge.net" << std::endl
                                << "Deterministic discrete event simulation." << std::endl << std::endl;
                else
                        std::cout << std::endl << "DREAM http://dre.sourceforge.net" << std::endl
                                << "Non-deterministic discrete event simulation." << std::endl << std::endl;

        verbose_ = verbose;
        active_ = true;
        double step;

        while (active_)
        {
                step = next_event (deterministic);

                time_step (step);

                take_transitions ();

                schedule (deterministic);

                if (time_ >= Option::simulation_time_)
                {
                        stop ();
                        trace ("Simulation ended");
                }
        }

        verbose_ = false;
}

}

---