UTThread.h

Go to the documentation of this file.

//==================================================================================================
// Copyright (C) 2010  Brian Tietz    sdbtietz at yahoo dot com
//
// This program is free software; you can redistribute it and/or modify it under the terms of the
// GNU General Public License as published by the Free Software Foundation, version 2.0 of the
// License.
//
// This program 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.
//
// For commercial software, the copyright holder (Brian Tietz, email sdbtietz at yahoo dot com)
// reserves the right and is willing to waive the proprietary source code disclosure aspects of that
// license as applied to the UT library in exchange for either substantial contributions to the
// development of the UT library or other forms of compensation.  Any such waiver must be
// established in writing between the copyright holder and the commercial entity obtaining such a
// waiver.
//==================================================================================================


#ifndef _UT_THREAD_H_
#define _UT_THREAD_H_


//==================================================================================================
//=== Project headers
//==================================================================================================
#include "UTLists.h"
#include "UTMutex.h"


//==================================================================================================
//=== Types and constants
//==================================================================================================

typedef uint8 thread_priority_t;

const thread_priority_t eTHREADPRI_idle                 = 1;
const thread_priority_t eTHREADPRI_very_low_min         = 2;
const thread_priority_t eTHREADPRI_very_low             = 13;
const thread_priority_t eTHREADPRI_low_min              = 25;
const thread_priority_t eTHREADPRI_low                  = 37;
const thread_priority_t eTHREADPRI_normal_min           = 50;
const thread_priority_t eTHREADPRI_normal               = 62;
const thread_priority_t eTHREADPRI_above_normal_min     = 75;
const thread_priority_t eTHREADPRI_above_normal         = 87;
const thread_priority_t eTHREADPRI_gui_min              = 100;
const thread_priority_t eTHREADPRI_gui                  = 112;
const thread_priority_t eTHREADPRI_above_gui_min        = 125;
const thread_priority_t eTHREADPRI_above_gui            = 137;
const thread_priority_t eTHREADPRI_high_min             = 150;
const thread_priority_t eTHREADPRI_high                 = 167;
const thread_priority_t eTHREADPRI_very_high_min        = 175;
const thread_priority_t eTHREADPRI_very_high            = 187;
const thread_priority_t eTHREADPRI_time_critical_min    = 200;
const thread_priority_t eTHREADPRI_real_time_min        = 225;
const thread_priority_t eTHREADPRI_kernel_real_time_min = 240;


//==================================================================================================
//=== Forward name declarations
//==================================================================================================
struct PlatformThreadInfo_t;
class MessageLoop_t;


//==================================================================================================
//=== Global functions
//==================================================================================================

extern UT_EXPORT thread_id_t current_thread_id();


//==================================================================================================
class UT_EXPORT Thread_t
//==================================================================================================
: private LinkedListNode_t<Thread_t>
{
    //----------------------------------------------------------------------------------------------
    public:
    //----------------------------------------------------------------------------------------------
                                    Thread_t(thread_priority_t priority = eTHREADPRI_normal);

    virtual                         ~Thread_t();

    virtual void                    Start(int32 stack_size = 0);

    void                            SetPriority(thread_priority_t priority);

    inline thread_id_t              ThreadId() const;

    inline thread_priority_t        Priority() const;

    virtual void                    WaitForThreadToExit();

    virtual void                    Main() = 0;

    static void                     RegisterMainThread(Thread_t* main_thread);

    static thread_id_t              MainThreadId();

    inline bool                     IsMainThread() const;

    inline static int               CountThreads();

    static inline bool              IsThreadingSafe();

    // \cond DOXYGEN_DOCUMENT_NEVER
    static void                     ThreadingIsSafe(bool safe);
                                        // Internal to UT library, public because it's called from
                                        // main
    // \endcond

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    void                            SetPriorityInternal();
                                        // Sets the thread priority to m_priority, ms_mutex must be
                                        // locked, this must be in ms_threads.

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    thread_id_t                     m_thread_id;
    thread_priority_t               m_priority;
    PlatformThreadInfo_t*           m_info;
    bool                            m_thread_running;

    static Mutex_t                  ms_mutex;
    static bool                     ms_threading_is_safe;
    static LinkedList_t<Thread_t>   ms_threads;
    static Thread_t*                ms_main_thread;

    friend class LinkedList_t<Thread_t>;
    friend class LinkedListNode_t<Thread_t>;
    friend class PhysMemCache_t;
    friend class SystemTimeManager_t;
};




//==================================================================================================
//==================================================================================================
//===
//=== Inline function implementations: class Thread_t
//===
//==================================================================================================
//==================================================================================================
inline thread_id_t
Thread_t::ThreadId() const
{
    return m_thread_id;
}


inline thread_priority_t
Thread_t::Priority() const
{
    return m_priority;
}


inline bool
Thread_t::IsMainThread() const
{
    return (ms_main_thread == this);
}


inline int
Thread_t::CountThreads()
{
    return ms_threads.CountItems();
}


inline bool
Thread_t::IsThreadingSafe()
{
    return ms_threading_is_safe;
}


#endif // _UT_THREAD_H_