XMLParser.cpp

Go to the documentation of this file.

/** @file XMLParser.cpp
* @author Gabor Madl
* @date Created 06/2005
* @brief XML Parser library.
*
*
* =================================================================
* 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 "XMLParser.h"

namespace DREAM
{

void XMLParser::parse (char* xmlFile, DREAM::System* system)
        throw (DREAM::Exception)
{
        const char* path = getenv ("DREAM_ROOT");
        if (path == "NULL")
                throw DREAM::XMLException ("Environment variable DREAM_ROOT is not set.");

        std::cout << std::endl << "Parsing XML system description file \"" << xmlFile << "\"" << std::endl << std::endl;
        system_ptr_ = system;

        xmlTextReaderPtr reader = xmlReaderForFile (xmlFile, NULL, 0);

        if (reader != NULL)
        {
                std::string schema = path;
                schema += "/xsd/dream.xsd";

                int schema_init = xmlTextReaderSchemaValidate (reader, schema.c_str ());

                if (schema_init < 0)
                {
                        // We need to clean up the parser explicitly to avoid memory leaks...
                        xmlFreeTextReader (reader);
                        xmlCleanupParser ();
                        std::string message;
                        message << "XSD schema \"" << schema << "\" cannot be accessed.";
                        throw DREAM::XMLException (message);
                }

                if (xmlTextReaderIsValid (reader) != 1)
                {
                        // We need to clean up the parser explicitly to avoid memory leaks...
                        xmlFreeTextReader (reader);
                        xmlCleanupParser ();
                        std::string message;
                        message << "DREAM input XML \"" << xmlFile << "\" does not validate with XSD schema \"" << schema << "\".";
                        throw DREAM::XMLException (message);
                }

                int retval = xmlTextReaderRead (reader);

                try
                {
                        while (retval == 1)
                        {
                                // If we found an opening tag
                                if (xmlTextReaderNodeType (reader) == 1)
                                        process_node (reader);
                                retval = xmlTextReaderRead (reader);
                        }
                }
                catch (DREAM::XMLException* &ex)
                {
                        // We need to clean up the parser explicitly to avoid memory leaks...
                        xmlFreeTextReader (reader);
                        xmlCleanupParser ();
                        std::for_each (node_map_.begin (), node_map_.end (), delete_pair ());
                        std::for_each (thread_map_.begin (), thread_map_.end (), delete_pair ());
                        throw ex;
                }

                xmlFreeTextReader (reader);
                xmlCleanupParser ();

                if (retval != 0)
                {
                        std::string message;
                        message << "Error while parsing " << xmlFile << "...";
                        throw DREAM::XMLException (message);
                }
        }
        else
        {
                std::string message;
                message << "Unable to open " << xmlFile << " for reading...";
                throw DREAM::XMLException (message);
        }
}

void XMLParser::check_mapping ()
        throw (DREAM::Exception)
{
        DREAM::NODE_MAP::const_iterator node_iter;
        std::string message;
        bool correct=true;

        for (node_iter = node_map_.begin (); node_iter != node_map_.end (); node_iter++)
        {
                if (!node_iter->second->scheduler ())
                {
                        correct=false;
                        message << "DREAM Node " << node_iter->first << " is not assigned to any threads.\n";
                        delete node_iter->second;
                }
        }

        DREAM::THREAD_STR_MAP::const_iterator thread_iter;

        for (thread_iter = thread_map_.begin (); thread_iter != thread_map_.end (); thread_iter++)
        {
                if (!thread_iter->second->scheduler ())
                {
                        correct=false;
                        message << "DREAM Thread " << thread_iter->first << " is not assigned to any CPUs.\n";
                        delete thread_iter->second;
                }
        }

        if (!correct)
        {
                message << "Incorrect model.";
                throw DREAM::XMLException (message);
        }
}

DREAM::Node* XMLParser::find_node (const std::string& name)
        throw (DREAM::Exception)
{
        DREAM::NODE_MAP::iterator node_iter;

        for (node_iter = node_map_.begin (); node_iter != node_map_.end (); node_iter++)
        {
                if (node_iter->first == name)
                        return node_iter->second;
        }

        std::string message;
        message << "Node \"" << name << "\" is not declared but used.";
        throw DREAM::XMLException (message);
}

DREAM::Thread* XMLParser::find_thread (const std::string& name)
        throw (DREAM::Exception)
{
        DREAM::THREAD_STR_MAP::iterator thread_iter;

        for (thread_iter = thread_map_.begin (); thread_iter != thread_map_.end (); thread_iter++)
        {
                if (thread_iter->first == name)
                        return thread_iter->second;
        }

        std::string message;
        message << "Thread \"" << name << "\" is not declared but used.";
        throw DREAM::XMLException        (message);
}

void XMLParser::set_system (DREAM::System* system_ptr)
{
        system_ptr_ = system_ptr;
}

void XMLParser::process_node (xmlTextReaderPtr reader)
        throw (DREAM::Exception)
{
        const xmlChar *name_ptr = xmlTextReaderConstName (reader);
        if (name_ptr == NULL)
                throw DREAM::XMLException ("Empty XML node encountered while parsing...");

        std::string type = (const char*) name_ptr;

        if (type == "Node")
                std::cout << "Parsing nodes...\n";
        else if (type == "Task")
                process_task (reader);
        else if (type == "Channel")
                process_channel (reader);
        else if (type == "Timer")
                process_timer (reader);

        else if (type == "Dependency")
                std::cout << "Parsing dependencies...\n";
        else if (type == "TimerToTask")
                process_timer_to_task (reader);
        else if (type == "TaskToTask")
                process_task_to_task (reader);
        else if (type == "TaskToChannel")
                process_task_to_channel (reader);
        else if (type == "ChannelToTask")
                process_channel_to_task (reader);

        else if (type == "Thread")
                process_thread (reader);
        else if (type == "TaskMapping")
                process_task_mapping (reader);
        else if (type == "ChannelMapping")
                process_channel_mapping (reader);
        else if (type == "TimerMapping")
                process_timer_mapping (reader);

        else if (type == "CPU")
                process_CPU (reader);
        else if (type == "ThreadMapping")
                process_thread_mapping (reader);

//      xmlFree (name_ptr);
}

void XMLParser::process_task (xmlTextReaderPtr reader)
        throw (DREAM::Exception)
{
        DREAM::Task* task_ptr = NULL;

        xmlChar* name_ptr = xmlTextReaderGetAttribute (reader, (const xmlChar*) "name");
        if (name_ptr == NULL)
        {
                xmlFree (name_ptr);
                throw DREAM::XMLException ("<Task ... name=\"\" .../> is an empty attribute");
        }
        std::string name = (const char*) name_ptr;

        xmlChar* deadline_ptr = xmlTextReaderGetAttribute (reader, (const xmlChar*) "deadline");
        if (deadline_ptr == NULL)
        {
                xmlFree (name_ptr);
                xmlFree (deadline_ptr);
                throw DREAM::XMLException ("<Task ... deadline=\"\" .../> is an empty attribute");
        }
        std::string deadline = (const char*) deadline_ptr;

        xmlChar* wcet_ptr = xmlTextReaderGetAttribute (reader, (const xmlChar*) "wcet");
        if (wcet_ptr == NULL)
        {
                xmlFree (name_ptr);
                xmlFree (deadline_ptr);
                xmlFree (wcet_ptr);
                throw DREAM::XMLException ("<Task ... wcet=\"\" .../> is an empty attribute");
        }
        std::string wcet = (const char*) wcet_ptr;

        xmlChar* subpriority_ptr = xmlTextReaderGetAttribute (reader, (const xmlChar*) "subpriority");
        xmlChar* bcet_ptr;

        if (subpriority_ptr == NULL)
                task_ptr = new DREAM::Task (name.c_str (), NULL, chartouint (wcet.c_str ()), chartouint (deadline.c_str ()));
        else
        {
                std::string subpriority = (const char*) subpriority_ptr;
                bcet_ptr = xmlTextReaderGetAttribute (reader, (const xmlChar*) "bcet");

                if (bcet_ptr == NULL)
                        task_ptr = new DREAM::Task (name.c_str (), NULL, chartouint (wcet.c_str ()), chartouint (deadline.c_str ()), chartouint (subpriority.c_str ()));
                else
                {
                        std::string bcet = (const char*) bcet_ptr;
                        task_ptr = new DREAM::Task (name.c_str (), NULL, chartouint (wcet.c_str ()), chartouint (bcet.c_str ()), chartouint (deadline.c_str ()), chartouint (subpriority.c_str ()));
                }
                xmlFree (bcet_ptr);
        }

        node_map_.insert (DREAM::NODE_PAIR (name.c_str (), task_ptr));

        xmlFree (name_ptr);
        xmlFree (deadline_ptr);
        xmlFree (wcet_ptr);
        xmlFree (subpriority_ptr);
}

void XMLParser::process_channel (xmlTextReaderPtr reader)
        throw (DREAM::Exception)
{
        DREAM::Channel* channel_ptr = NULL;

        xmlChar* name_ptr = xmlTextReaderGetAttribute (reader, (const xmlChar*) "name");
        if (name_ptr == NULL)
        {
                xmlFree (name_ptr);
                throw DREAM::XMLException ("<Channel ... name=\"\" .../> is an empty attribute");
        }
        std::string name = (const char*) name_ptr;

        xmlChar* buffersize_ptr = xmlTextReaderGetAttribute (reader, (const xmlChar*) "buffersize");
        if (buffersize_ptr == NULL)
        {
                xmlFree (name_ptr);
                xmlFree (buffersize_ptr);
                throw DREAM::XMLException ("<Channel ... buffersize=\"\" .../> is an empty attribute");
        }
        std::string buffersize = (const char*) buffersize_ptr;

        xmlChar* delay_ptr = xmlTextReaderGetAttribute (reader, (const xmlChar*) "delay");
        std::string delay;
        if (delay_ptr == NULL)
                delay = "0";
                // throw DREAM::XMLException ("<Channel ... delay=\"\" .../> is an empty attribute");
        else
                delay = (const char*) delay_ptr;

        xmlChar* bcdelay_ptr = xmlTextReaderGetAttribute (reader, (const xmlChar*) "bcdelay");
        
        if (bcdelay_ptr == NULL)
                channel_ptr = new DREAM::Channel (name.c_str (), NULL, chartouint (delay.c_str ()), chartouint (buffersize.c_str ()));
        else
        {
                std::string bcdelay = (const char*) bcdelay_ptr;
                channel_ptr = new DREAM::Channel (name.c_str (), NULL, chartouint (delay.c_str ()), chartouint (bcdelay.c_str ()), chartouint (buffersize.c_str ()));
        }

        node_map_.insert (DREAM::NODE_PAIR (name.c_str (), channel_ptr));

        xmlFree (name_ptr);
        xmlFree (buffersize_ptr);
        xmlFree (delay_ptr);
        xmlFree (bcdelay_ptr);
}

void XMLParser::process_timer (xmlTextReaderPtr reader)
        throw (DREAM::Exception)
{
        DREAM::Timer* timer_ptr = NULL;

        xmlChar* name_ptr = xmlTextReaderGetAttribute (reader, (const xmlChar*) "name");
        if (name_ptr == NULL)
        {
                xmlFree (name_ptr);
                throw DREAM::XMLException ("<Timer ... name=\"\" .../> is an empty attribute");
        }
        std::string name = (const char*) name_ptr;

        xmlChar* period_ptr = xmlTextReaderGetAttribute (reader, (const xmlChar*) "period");
        if (period_ptr == NULL)
        {
                xmlFree (name_ptr);
                xmlFree (period_ptr);
                throw DREAM::XMLException ("<Timer ... period=\"\" .../> is an empty attribute");
        }
        std::string period = (const char*) period_ptr;

        xmlChar* bcperiod_ptr = xmlTextReaderGetAttribute (reader, (const xmlChar*) "bcperiod");

        if (bcperiod_ptr == NULL)
                timer_ptr = new DREAM::Timer (name.c_str (), NULL, chartouint (period.c_str ()));
        else
        {
                std::string bcperiod = (const char*) bcperiod_ptr;
                timer_ptr = new DREAM::Timer (name.c_str (), NULL, chartouint (period.c_str ()), chartouint (bcperiod.c_str ()));
        }

        node_map_.insert (DREAM::NODE_PAIR (name.c_str (), timer_ptr));

        xmlFree (name_ptr);
        xmlFree (period_ptr);
        xmlFree (bcperiod_ptr);
}

void XMLParser::process_thread (xmlTextReaderPtr reader)
        throw (DREAM::Exception)
{
        DREAM::Thread* thread_ptr = NULL;

        xmlChar* name_ptr = xmlTextReaderGetAttribute (reader, (const xmlChar*) "name");
        if (name_ptr == NULL)
        {
                xmlFree (name_ptr);
                throw DREAM::XMLException ("<Thread ... name=\"\" .../> is an empty attribute");
        }
        std::string name = (const char*) name_ptr;

        std::cout << "Parsing thread \"" << name << "\"...\n";
        
        xmlChar* numberofthreads_ptr = xmlTextReaderGetAttribute (reader, (const xmlChar*) "numberofthreads");
        std::string numberofthreads;
        if (numberofthreads_ptr == NULL)
                numberofthreads = "1";
                // throw DREAM::XMLException ("<Thread ... numberofthreads=\"\" .../> is an empty attribute");
        else
                numberofthreads = (const char*) numberofthreads_ptr;

        xmlChar* priority_ptr = xmlTextReaderGetAttribute (reader, (const xmlChar*) "priority");
        std::string priority;
        if (priority_ptr == NULL)
                priority = "1";
                // throw DREAM::XMLException ("<Thread ... priority=\"\" .../> is an empty attribute");
        else
                priority = (const char*) priority_ptr;

        xmlChar* queueingpolicy_ptr = xmlTextReaderGetAttribute (reader, (const xmlChar*) "queueingpolicy");
        if (queueingpolicy_ptr == NULL)
        {
                xmlFree (name_ptr);
                xmlFree (numberofthreads_ptr);
                xmlFree (priority_ptr);
                xmlFree (queueingpolicy_ptr);
                throw DREAM::XMLException ("<Thread ... queueingpolicy=\"\" .../> is an empty attribute");
        }
        std::string policy = (const char*) queueingpolicy_ptr;

        if (policy == "FixedPriority")
                thread_ptr = new DREAM::Thread (NULL, chartouint (priority.c_str ()), chartouint (numberofthreads.c_str ()));
        else
        {
                std::string message;
                throw DREAM::XMLException
                         (message << "Unknown scheduling policy specified for thread \"" << name << "\"...");
        }

        current_thread_ = thread_ptr;

        thread_map_.insert (THREAD_STR_PAIR (name.c_str (), thread_ptr));

        xmlFree (name_ptr);
        xmlFree (numberofthreads_ptr);
        xmlFree (priority_ptr);
        xmlFree (queueingpolicy_ptr);
}

void XMLParser::process_timer_to_task (xmlTextReaderPtr reader)
        throw (DREAM::Exception)
{
        xmlChar* timer_ptr = xmlTextReaderGetAttribute (reader, (const xmlChar*) "timer");
        if (timer_ptr == NULL)
        {
                xmlFree (timer_ptr);
                throw DREAM::XMLException ("<TimerToTask ... timer=\"\" .../> is an empty attribute");
        }
        std::string timer = (const char*) timer_ptr;

        xmlChar* task_ptr = xmlTextReaderGetAttribute (reader, (const xmlChar*) "task");
        if (task_ptr == NULL)
        {
                xmlFree (timer_ptr);
                xmlFree (task_ptr);
                throw DREAM::XMLException ("<TimerToTask ... task=\"\" .../> is an empty attribute");
        }
        std::string task = (const char*) task_ptr;

        try
        {
                find_node (timer.c_str ())->add_dependent (find_node (task.c_str ()));
        }
        catch (DREAM::XMLException* &ex)
        {
                // We need to clean up the parser explicitly to avoid memory leaks...
                xmlFree (timer_ptr);
                xmlFree (task_ptr);
                throw ex;
        }

        xmlFree (timer_ptr);
        xmlFree (task_ptr);
}
        
void XMLParser::process_task_to_task (xmlTextReaderPtr reader)
        throw (DREAM::Exception)
{
        xmlChar* sourcetask_ptr = xmlTextReaderGetAttribute (reader, (const xmlChar*) "sourcetask");
        if (sourcetask_ptr == NULL)
        {
                xmlFree (sourcetask_ptr);
                throw DREAM::XMLException ("<TaskToTask ... sourcetask=\"\" .../> is an empty attribute");
        }
        std::string sourcetask = (const char*) sourcetask_ptr;

        xmlChar* destinationtask_ptr = xmlTextReaderGetAttribute (reader, (const xmlChar*) "destinationtask");
        if (destinationtask_ptr == NULL)
        {
                xmlFree (sourcetask_ptr);
                xmlFree (destinationtask_ptr);
                throw DREAM::XMLException ("<TaskToTask ... destinationtask=\"\" .../> is an empty attribute");
        }
        std::string destinationtask = (const char*) destinationtask_ptr;

        try
        {
                find_node (sourcetask.c_str ())->add_dependent (find_node (destinationtask.c_str ()));
        }
        catch (DREAM::XMLException* &ex)
        {
                // We need to clean up the parser explicitly to avoid memory leaks...
                xmlFree (sourcetask_ptr);
                xmlFree (destinationtask_ptr);
                throw ex;
        }

        xmlFree (sourcetask_ptr);
        xmlFree (destinationtask_ptr);
}

void XMLParser::process_task_to_channel (xmlTextReaderPtr reader)
        throw (DREAM::Exception)
{
        xmlChar* task_ptr = xmlTextReaderGetAttribute (reader, (const xmlChar*) "task");
        if (task_ptr == NULL)
        {
                xmlFree (task_ptr);
                throw DREAM::XMLException ("<TaskToChannel ... task=\"\" .../> is an empty attribute");
        }
        std::string task = (const char*) task_ptr;

        xmlChar* channel_ptr = xmlTextReaderGetAttribute (reader, (const xmlChar*) "channel");
        if (channel_ptr == NULL)
        {
                xmlFree (task_ptr);
                xmlFree (channel_ptr);
                throw DREAM::XMLException ("<TaskToChannel ... channel=\"\" .../> is an empty attribute");
        }
        std::string channel = (const char*) channel_ptr;

        try
        {
                find_node (task.c_str ())->add_dependent (find_node (channel.c_str ()));
        }
        catch (DREAM::XMLException* &ex)
        {
                // We need to clean up the parser explicitly to avoid memory leaks...
                xmlFree (task_ptr);
                xmlFree (channel_ptr);
                throw ex;
        }

        xmlFree (task_ptr);
        xmlFree (channel_ptr);
}
        
void XMLParser::process_channel_to_task (xmlTextReaderPtr reader)
        throw (DREAM::Exception)
{
        xmlChar* channel_ptr = xmlTextReaderGetAttribute (reader, (const xmlChar*) "channel");
        if (channel_ptr == NULL)
        {
                xmlFree (channel_ptr);
                throw DREAM::XMLException ("<ChannelToTask ... channel=\"\" .../> is an empty attribute");
        }
        std::string channel = (const char*) channel_ptr;

        xmlChar* task_ptr = xmlTextReaderGetAttribute (reader, (const xmlChar*) "task");
        if (task_ptr == NULL)
        {
                xmlFree (channel_ptr);
                xmlFree (task_ptr);
                throw DREAM::XMLException ("<ChannelToTask ... task=\"\" .../> is an empty attribute");
        }
        std::string task = (const char*) task_ptr;

        try
        {
                find_node (channel.c_str ())->add_dependent (find_node (task.c_str ()));
        }
        catch (DREAM::XMLException* &ex)
        {
                // We need to clean up the parser explicitly to avoid memory leaks...
                xmlFree (task_ptr);
                xmlFree (channel_ptr);
                throw ex;
        }

        xmlFree (channel_ptr);
        xmlFree (task_ptr);
}

void XMLParser::process_task_mapping (xmlTextReaderPtr reader)
        throw (DREAM::Exception)
{
        xmlChar* task_ptr = xmlTextReaderGetAttribute (reader, (const xmlChar*) "task");
        if (task_ptr == NULL)
        {
                xmlFree (task_ptr);
                throw DREAM::XMLException ("<TaskMapping ... task=\"\" .../> is an empty attribute");
        }
        std::string task = (const char*) task_ptr;

        try
        {
                find_node (task.c_str ())->deploy (current_thread_);
        }
        catch (DREAM::XMLException* &ex)
        {
                // We need to clean up the parser explicitly to avoid memory leaks...
                xmlFree (task_ptr);
                throw ex;
        }

        xmlFree (task_ptr);
}

void XMLParser::process_channel_mapping (xmlTextReaderPtr reader)
        throw (DREAM::Exception)
{
        xmlChar* channel_ptr = xmlTextReaderGetAttribute (reader, (const xmlChar*) "channel");
        if (channel_ptr == NULL)
        {
                xmlFree (channel_ptr);
                throw DREAM::XMLException ("<ChannelMapping ... channel=\"\" .../> is an empty attribute");
        }
        std::string channel = (const char*) channel_ptr;

        try
        {
                find_node (channel.c_str ())->deploy (current_thread_);
        }
        catch (DREAM::XMLException* &ex)
        {
                // We need to clean up the parser explicitly to avoid memory leaks...
                xmlFree (channel_ptr);
                throw ex;
        }

        xmlFree (channel_ptr);
}

void XMLParser::process_timer_mapping (xmlTextReaderPtr reader)
        throw (DREAM::Exception)
{
        xmlChar* timer_ptr = xmlTextReaderGetAttribute (reader, (const xmlChar*) "timer");
        if (timer_ptr == NULL)
        {
                xmlFree (timer_ptr);
                throw DREAM::XMLException ("<TimerMapping ... timer=\"\" .../> is an empty attribute");
        }
        std::string timer = (const char*) timer_ptr;

        try
        {
                find_node (timer.c_str ())->deploy (current_thread_);
        }
        catch (DREAM::XMLException* &ex)
        {
                // We need to clean up the parser explicitly to avoid memory leaks...
                xmlFree (timer_ptr);
                throw ex;
        }

        xmlFree (timer_ptr);
}

void XMLParser::process_CPU (xmlTextReaderPtr reader)
        throw (DREAM::Exception)
{
        DREAM::Scheduler* scheduler_ptr = NULL;

        xmlChar* name_ptr = xmlTextReaderGetAttribute (reader, (const xmlChar*) "name");
        if (name_ptr == NULL)
        {
                xmlFree (name_ptr);
                throw DREAM::XMLException ("<CPU ... name=\"\" .../> is an empty attribute");
        }
        std::string name = (const char*) name_ptr;

        xmlChar* numberofCPUs_ptr = xmlTextReaderGetAttribute (reader, (const xmlChar*) "numberofCPUs");
        std::string numberofCPUs;
        if (numberofCPUs_ptr == NULL)
                numberofCPUs = "1";
                // throw DREAM::XMLException ("<CPU ... numberofCPUs=\"\" .../> is an empty attribute");
        else
                numberofCPUs = (const char*) numberofCPUs_ptr;

        xmlChar* schedulingpolicy_ptr = xmlTextReaderGetAttribute (reader, (const xmlChar*) "schedulingpolicy");
        if (schedulingpolicy_ptr == NULL)
        {
                xmlFree (name_ptr);
                xmlFree (numberofCPUs_ptr);
                xmlFree (schedulingpolicy_ptr);
                throw DREAM::XMLException ("<CPU ... schedulingpolicy=\"\" .../> is an empty attribute");
        }

        std::cout << "Parsing CPU \"" << name << "\"...\n";

        std::string policy = (const char*) schedulingpolicy_ptr;

        if (policy == "FixedPriority")
                scheduler_ptr = new DREAM::FixedPriorityScheduler (name.c_str (), system_ptr_, chartouint (numberofCPUs.c_str ()));
        else if (policy == "NonConcurrent")
                scheduler_ptr = new DREAM::NonConcurrentScheduler (name.c_str (), system_ptr_);
        else
        {
                xmlFree (name_ptr);
                xmlFree (numberofCPUs_ptr);
                xmlFree (schedulingpolicy_ptr);
                std::string message;
                throw DREAM::XMLException
                         (message << "Unknown scheduling policy specified for CPU \"" << name << "\"...");
        }

        current_scheduler_ = scheduler_ptr;

        if (system_ptr_)
                system_ptr_->add_scheduler (scheduler_ptr);
        else
        {
                xmlFree (name_ptr);
                xmlFree (numberofCPUs_ptr);
                xmlFree (schedulingpolicy_ptr);
                throw DREAM::XMLException ("XMLParseHandler::processCPU (): System pointer was not set before parsing.");
        }

        xmlFree (name_ptr);
        xmlFree (numberofCPUs_ptr);
        xmlFree (schedulingpolicy_ptr);
}
        
void XMLParser::process_thread_mapping (xmlTextReaderPtr reader)
        throw (DREAM::Exception)
{
        xmlChar* thread_ptr = xmlTextReaderGetAttribute (reader, (const xmlChar*) "thread");
        if (thread_ptr == NULL)
        {
                xmlFree (thread_ptr);
                throw DREAM::XMLException ("<ThreadMapping ... thread=\"\" .../> is an empty attribute");
        }
        std::string thread = (const char*) thread_ptr;

        try
        {
                find_thread (thread.c_str ())->deploy (current_scheduler_);
        }
        catch (DREAM::XMLException* &ex)
        {
                // We need to clean up the parser explicitly to avoid memory leaks...
                xmlFree (thread_ptr);
                throw ex;
        }

        xmlFree (thread_ptr);
}
        
};

---