Thread.cpp

Go to the documentation of this file.

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

namespace DREAM
{

/////////////////////////////////////////////////////////////////////////////
//
// NodeList
//
/////////////////////////////////////////////////////////////////////////////

NodeList::NodeList ()
{
}

NodeList::~NodeList ()
{
}

inline void NodeList::add (DREAM::Node* node_ptr)
{
        node_map_.insert (DREAM::NODE_PAIR (node_ptr->id (), node_ptr));
}

inline void NodeList::clear ()
{
        node_map_.clear ();
}

inline DREAM::Node* NodeList::find (const std::string& id) const
{
        DREAM::NODE_MAP::const_iterator node_iter = node_map_.find (id);
        return node_iter != node_map_.end () ? node_iter->second : NULL;
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
DREAM::NODE_MAP* NodeList::get_map ()
        throw (DREAM::Exception)
#else
inline DREAM::NODE_MAP* NodeList::get_map ()
#endif
{
        return &node_map_;
}

inline void NodeList::publish () const
{
        std::for_each (node_map_.begin (), node_map_.end (), consume_pair ());
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
void NodeList::erase (const std::string& id)
        throw (DREAM::Exception)
#else
inline void NodeList::erase (const std::string& id)
#endif
{
        DREAM::NODE_MAP::iterator node_iter = node_map_.find (id);

        if (node_iter != node_map_.end ())
                node_map_.erase (id);
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        else
                throw DREAM::Exception ("NodeList::erase () called with invalid Node id.");
#endif
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
void NodeList::take_transitions ()
        throw (DREAM::Exception)
#else
inline void NodeList::take_transitions ()
#endif
{
#ifndef DREAM_UNUSED_THREADS
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        if (node_map_.empty ())
        throw DREAM::Exception ("Thread::take_transitions () called for empty node_map_ list. No nodes are assigned to the Thread.");
#endif
#endif

        // Nodes might dequeue themselves from the exec_map therefore a simple
        // for_each won't do the job...
        NODE_MAP::iterator node_iter_next, node_iter = node_map_.begin ();
        
        while (node_iter != node_map_.end ())
        {
                node_iter_next = node_iter;
                node_iter->second->take_transitions ();
                node_iter = ++node_iter_next;
        }
}

/////////////////////////////////////////////////////////////////////////////
//
// Thread
//
/////////////////////////////////////////////////////////////////////////////

Thread::Thread (DREAM::Scheduler* scheduler_ptr, uint priority, uint threads)
: scheduler_ptr_ (scheduler_ptr),
priority_ (priority),
threads_ (threads),
availablethreads_ (threads)
{
        if (scheduler_ptr)
                scheduler_ptr->add_thread (this);
}

Thread::~Thread ()
{
        std::for_each (node_map_.begin (), node_map_.end (), delete_pair ());
}

inline void Thread::add_error (DREAM::Task* task_ptr)
{
        scheduler_ptr_->add_error (task_ptr);
}

inline uint Thread::availablethreads () const
{
        return availablethreads_;
}

void Thread::deploy (DREAM::Scheduler* scheduler_ptr)
        throw (DREAM::Exception)
{
        if (scheduler_ptr_)
                throw DREAM::Exception ("Thread::deploy (): Thread already assigned to a CPU.");

        scheduler_ptr_ = scheduler_ptr;
        scheduler_ptr->add_thread (this);
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
void Thread::dequeue (DREAM::Node* node_ptr)
        throw (DREAM::Exception)
#else
inline void Thread::dequeue (DREAM::Node* node_ptr)
#endif
{
        DREAM::NODE_MAP::iterator exec_iter = exec_map_.find (node_ptr->id ());

        if (exec_iter != exec_map_.end ())
                exec_map_.erase (node_ptr->id ());
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        else
        {
                std::string message;
                message << "Thread::dequeue () called with invalid Node id: " << node_ptr->id ();
                throw DREAM::Exception (message);
        }
#endif

#ifdef DREAM_VERBOSE2
        if (Option::verbose1_ && Option::verbose2_)
        {
                std::string message;
                trace (message << node_ptr->id () << " is taken out of the execution queue");
        }
#endif
}

#ifdef DREAM_RACE_CONDITION
inline void Thread::enqueue (DREAM::Channel* channel_ptr)
{
        exec_map_.insert (DREAM::NODE_PAIR (channel_ptr->id (), channel_ptr));
        
#ifdef DREAM_VERBOSE2
        if (Option::verbose1_ && Option::verbose2_)
        {
                std::string message;
                trace (message << channel_ptr->id () << " enabled");
        }
#endif
}

inline void Thread::enqueue (DREAM::Task* task_ptr)
{
        exec_map_.insert (DREAM::NODE_PAIR (task_ptr->id (), task_ptr));
        recent_avltree_.insert (task_ptr->id (), task_ptr);
        
#ifdef DREAM_VERBOSE2
        if (Option::verbose1_ && Option::verbose2_)
        {
                std::string message;
                trace (message << task_ptr->id () << " enabled");
        }
#endif
}
#else
inline void Thread::enqueue (DREAM::Node* node_ptr)
{
        exec_map_.insert (DREAM::NODE_PAIR (node_ptr->id (), node_ptr));
        
#ifdef DREAM_VERBOSE2
        if (Option::verbose1_ && Option::verbose2_)
        {
                std::string message;
                trace (message << node_ptr->id () << " enabled");
        }
#endif
}
#endif

void Thread::freethread ()
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
        if (availablethreads_ < threads_)
        {
                ++availablethreads_;
                scheduler_ptr_->freeCPU ();
        }
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        else
        {
                std::string message;
                message << "Lane with priority \"" << priority_ << "\" deployed on Scheduler \"" << scheduler_ptr_->id () << "\" cannot free unused threads...";
                throw DREAM::Exception (message);
        }
#endif
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
DREAM::NODE_MAP* Thread::get_exec_map ()
        throw (DREAM::Exception)
#else
inline DREAM::NODE_MAP* Thread::get_exec_map ()
#endif
{
        return &exec_map_;
}

#ifdef DREAM_RACE_CONDITION
inline const DREAM::TASK_AVLTREE* Thread::get_recent_avltree () const
{
        return &recent_avltree_;
}
#endif

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
double Thread::next_event () const
        throw (DREAM::Exception)
#else
inline double Thread::next_event () const
#endif
{
#ifndef DREAM_UNUSED_THREADS
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        if (node_map_.empty ())
                throw DREAM::Exception ("Thread::next_event () called for empty node_map_ list. No nodes are assigned to the Thread.");
#endif
#endif

        double time_step = 0.0;

        for (DREAM::NODE_MAP::const_iterator node_iter = node_map_.begin (); node_iter != node_map_.end (); node_iter++)
        {
                double temp = node_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;
}


inline uint Thread::priority () const
{
        return priority_;
}

#ifdef DREAM_RACE_CONDITION
bool Thread::recent (DREAM::Task* task_ptr) const
{
        if (recent_avltree_.size () < 2)
                return false;

        TASK_AVLTREE::const_iterator iter;
        
        for (iter = recent_avltree_.begin (); iter != recent_avltree_.end (); iter++)
        {
                if (iter->second == task_ptr)
                        return true;
        }

        return false;
}
#endif

void Thread::reset ()
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        if (node_map_.empty ())
                throw DREAM::Exception ("Thread::reset () called for empty node_map_ list.");
#endif

        exec_map_.clear ();

        availablethreads_ = threads ();

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

inline bool Thread::schedulable () const
{
        return ((0 < availablethreads_) && (! exec_map_.empty ())) ? true : false;
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
const DREAM::Scheduler* Thread::scheduler () const
        throw (DREAM::Exception)
#else
inline const DREAM::Scheduler* Thread::scheduler () const
#endif
{
        return scheduler_ptr_;
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
DREAM::Scheduler* Thread::scheduler ()
        throw (DREAM::Exception)
#else
inline DREAM::Scheduler* Thread::scheduler ()
#endif
{
        return scheduler_ptr_;
}

inline uint Thread::threads () const
{
        return threads_;
}

#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
void Thread::time_step (double time_step)
        throw (DREAM::Exception)
#else
inline void Thread::time_step (double time_step)
#endif
{
#ifndef DREAM_UNUSED_THREADS
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        if (node_map_.empty ())
                throw DREAM::Exception ("Thread::time_step () called for empty node_map_ list. No nodes are assigned to the Thread.");
#endif
#endif

#ifdef DREAM_RACE_CONDITION
        recent_avltree_.clear ();
#endif

        for (DREAM::NODE_MAP::const_iterator node_iter = node_map_.begin (); node_iter != node_map_.end (); node_iter++)
                node_iter->second->clock_step (time_step);
}


inline void Thread::trace (const std::string& output) const
{
        scheduler_ptr_->trace (output);
}

void Thread::usethread ()
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
        if (availablethreads_ > 0)
                --availablethreads_;
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        else
        {
                std::string message;
                message << "Lane with priority \"" << priority_ << "\" deployed on Scheduler \"" << scheduler_ptr_->id () << "\" has no more available threads...";
                throw DREAM::Exception (message);
        }
#endif
}

void Thread::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::NODE_MAP::iterator node_iter;

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

void Thread::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::NODE_MAP::iterator node_iter;

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

void Thread::visitor_task_avltree (DREAM::TASK_AVLTREE* task_avltree)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
        DREAM::NODE_MAP::iterator node_iter;

        for (node_iter = node_map_.begin (); node_iter != node_map_.end (); node_iter++)
        {
                std::string check = node_iter->first;
                node_iter->second->visitor_task_avltree (task_avltree);
        }
}

void Thread::visitor_update_task_avltree (DREAM::TASK_AVLTREE* task_avltree)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (DREAM::Exception)
#endif
{
        DREAM::NODE_MAP::iterator node_iter;

        for (node_iter = node_map_.begin (); node_iter != node_map_.end (); node_iter++)
        {
                std::string check = node_iter->first;
                node_iter->second->visitor_update_task_avltree (task_avltree);
        }
}

void Thread::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::NODE_MAP::iterator node_iter;

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

}

---