Common.h

Go to the documentation of this file.

/** @file Common.h
* @author Gabor Madl
* @date Created 08/2005
* @brief Common declarations used in DREAM.
*
*
* =================================================================
* 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.
* =================================================================
*/

#if (_MSC_VER >= 1400)                          // VC8+
#pragma warning (disable:4996)          // Disable all deprecation warnings
#endif 

#if (_MSC_VER >= 1300)                          // VC7+
#define snprintf _snprintf
#endif 

#ifndef DREAM_COMMON
#define DREAM_COMMON

/** Specifies verbose output */
#define DREAM_VERBOSE

/* Specifies extremely verbose output */
// #define DREAM_VERBOSE2

/** Enables the dynamic checking of events. If disabled, the model checking method is faster but inaccurate. 
* The example/test/model_check_branching1 example tests this functionality.
*/
#define DREAM_BRANCHING

/** Enables the checking of race conditions (except between zero-time events). If disabled, the model checking method is faster but inaccurate.
* The example/test/model_check_branching2 example tests this functionality and the DREAM_BRANCHING functionality as well.
*/
#define DREAM_RACE_CONDITION

/** Enables the checking of race conditions combinations. If disabled, the model checking method is faster but inaccurate.
* The example/test/model_check_branching3 example tests this functionality, the DREAM_BRANCHING and DREAM_RACE_CONDITION functionalities.
*/
#define DREAM_RACE_CONDITION_COMBINATION

/* Enables the checking of race conditions between zero-time events as well. This turns the analysis slower and finds problems that are often
* irrelevant in real systems (race conditions can be managed within a single CPU).
*/
// #define DREAM_RACE_CONDITION_ZERO

/* Disables error condition on non-executing tasks */
// #define DREAM_NON_EXECUTING_TASKS

/* Define the following if you encounter strange behavior and would like more extensive error checking (might slow down performance a little). */
// #define DREAM_ENHANCED_EXCEPTION_CHECKING

#include "../datastructures/AVLTree.h"
#include "../datastructures/AVLTree.cpp"
#include "../datastructures/LinkedList.h"
#include "../datastructures/LinkedList.cpp"

#include <iostream>
#include <iomanip>
#include <string>
#include <vector>
#include <map>
#include <time.h>

namespace DREAM
{
class Node;
class Task;
class Thread;
class Scheduler;
class QoSLevel;

/** Unsigned int type definition.
* Redefining the basic type allows easy portability to 8 or 16 bit machines. 
*/
typedef unsigned int uint;
typedef unsigned char uchar;
#define char_size 32
#define double_size 128
#define maxuint 4294967295

#ifdef DREAM_BRANCHING
/** Enum type definition for best case, worst case, or a random value. */
typedef enum context_enum {bestcase, worstcase, randomcase, branchingpoint, repeat} Context;
#else
typedef enum context_enum {bestcase, worstcase, randomcase, repeat} Context;
#endif

/** NODE_MAP type definition. */
typedef std::map<std::string, DREAM::Node*> NODE_MAP;

/** NODE_PAIR type definition. */
typedef std::pair<std::string, DREAM::Node*> NODE_PAIR;

/** TASK_MAP type definition. */
typedef std::map<std::string, DREAM::Task*> TASK_MAP;

/** TASK_PAIR type definition. */
typedef std::pair<std::string, DREAM::Task*> TASK_PAIR;

/** TASK_UINT_MAP type definition. */
typedef std::map<uint, DREAM::Task*> TASK_UINT_MAP;

/** TASK_UINT_PAIR type definition. */
typedef std::pair<uint, DREAM::Task*> TASK_UINT_PAIR;

/** THREAD_MAP type definition. */
typedef std::map<uint, DREAM::Thread*> THREAD_MAP;

/** THREAD_PAIR type definition. */
typedef std::pair<uint, DREAM::Thread*> THREAD_PAIR;

/** THREAD_STR_MAP type definition. Used in XML parser but not core. */
typedef std::map<std::string, DREAM::Thread*> THREAD_STR_MAP;

/** THREAD_STR_PAIR type definition. Used in XML parser but not core. */
typedef std::pair<std::string, DREAM::Thread*> THREAD_STR_PAIR;

/** SCHEDULER_MAP type definition. */
typedef std::map<std::string, DREAM::Scheduler*> SCHEDULER_MAP;

/** SCHEDULER_PAIR type definition. */
typedef std::pair<std::string, DREAM::Scheduler*> SCHEDULER_PAIR;

/** QOS_AVLTREE type definition. 
* The AVLTree is sorted based on the QoSLevel speeds.
*/
typedef DREAM::AVLTree<double, DREAM::QoSLevel*> QOS_AVLTREE;

/** NODE_AVLTREE type definition. */
typedef DREAM::AVLTree<std::string, DREAM::Node*> NODE_AVLTREE;

/** TASK_AVLTREE type definition. */
typedef DREAM::AVLTree<std::string, DREAM::Task*> TASK_AVLTREE;

/** TASK_AVLTREE_LIST type definition. */
typedef DREAM::LinkedList<DREAM::TASK_AVLTREE*> TASK_AVLTREE_LIST;

/** TASK_ID_LIST type definition. */
typedef DREAM::LinkedList<std::string> TASK_ID_LIST;

/** Randomize function with a value between 0 and the parameter size. */
double random (uint size);

/** Operator overloading for appending std::string to std:string. */
std::string& operator<< (std::string& out, const std::string& parameter)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (std::bad_exception)
#endif
        ;

/** Operator overloading for appending std::string to std:string. */
std::string& operator<< (std::string& out, const char *)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (std::bad_exception)
#endif
        ;

/** Operator overloading for appending uint to std:string. */
std::string& operator<< (std::string& out, uint parameter)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (std::bad_exception)
#endif
        ;

/** Operator overloading for appending double to std:string. */
std::string& operator<< (std::string& out, double parameter)
#ifdef DREAM_ENHANCED_EXCEPTION_CHECKING
        throw (std::bad_exception)
#endif
        ;

/** struct to be used in std::for_each to clear elements from vectors. */
struct clear_vector
{
        template <typename T> inline
        void operator () (T& object)
        {
                object.clear ();
        }
};

/** struct to be used in std::for_each to delete elements from vectors. */
struct delete_item
{
        template <typename T> inline
        void operator () (T* object)
        {
                delete object->item ();
        }
};

/** struct to be used in std::for_each to delete elements from vectors. */
struct delete_object
{
        template <typename T> inline
        void operator () (T* object)
        {
                delete object;
        }
};

/** struct to be used in std::for_each to call consume () on std::pair->second. */
struct consume_pair
{
        template <typename T> inline
        void operator () (T& object)
        {
                object.second->consume ();
        }
};

/** struct to be used in std::for_each to delete std::pairs. */
struct delete_pair
{
        template <typename T> inline
        void operator () (T& object)
        {
                delete object.second;
        }
};

/** struct to be used in std::for_each to call reset () on std::pair->second. */
struct reset_pair
{
        template <typename T> inline
        void operator () (T& object)
        {
                object.second->reset ();
        }
};

/* struct to be used in std::for_each to call schedule () on std::pair->second. */
/*struct schedule_pair
{
        template <typename T> inline
        void operator () (T& object)
        {
                object.second->schedule ();
        }
};
*/
/** struct to be used in std::for_each to call stop () on std::pair->second. */
struct stop_pair
{
        template <typename T> inline
        void operator () (T& object)
        {
                object.second->stop ();
        }
};

/** struct to be used in std::for_each to call take_transitions () on std::pair->second. */
struct transition_pair
{
        template <typename T> inline
        void operator () (T& object)
        {
                object.second->take_transitions ();
        }
};

};

/** Global options */
struct Option
{
        /** Specifies the number of repetitions for genetic algorithms */
        static DREAM::uint number_of_repetitions_;

        /** Specifies the size of the optimization space used in genetic algorithms */
        static DREAM::uint optimization_space_;

        /** Specifies the simulation time for all simulation-base methods */
        static DREAM::uint simulation_time_;

        /** Specifies whether branching is checked during model checking */
        static bool branching_;

        /** Specifies whether race conditions are checked during model checking */
        static bool race_condition_;

        /** Specifies whether race condition combinations are checked during model checking */
        static bool race_condition_combination_;

        /** Specifies whether race conditions between zero time events are checked during model checking */
        static bool race_condition_zero_;

        /** Specifies whether race conditions between zero time events are checked during model checking */
        static bool non_executing_tasks_;

        /** Specifies whether verbose output is enabled. */
        static bool verbose1_;

#ifdef DREAM_VERBOSE2
        /** Specifies whether even more verbose output is enabled. */
        static bool verbose2_;
#endif
};

#endif

---