/ray/src/lib/threads/thread.h

Go to the documentation of this file.

/*
 * lib/threads/thread.h
 * 
 * Implementing thread class for multi-threaded applications. 
 * 
 * Copyright (c) 2004 by Wolfgang Wieser ] wwieser (a) gmx <*> de [ 
 * 
 * This file may be distributed and/or modified under the terms of the 
 * GNU General Public License version 2 as published by the Free Software 
 * Foundation. (See COPYING.GPL for details.)
 * 
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 * 
 */

#ifndef _ThreadLibrary_Thread_H_
#define _ThreadLibrary_Thread_H_ 1

#include <lib/sconfig.h>    /* MUST be first */

#include <lib/tl/linkedlist.h>
#include <lib/threads/mutex.h>

#include <glib/gthread.h>

// As defined below. 
class ExecutionThread;


class ThreadKernel
{
    friend class ExecutionThread;
    private:
        static ThreadKernel *kernel;
        
        struct TNode : LinkedListBase<TNode>
        {
            // Actual thread structure. 
            GThread *thread;
            // Associated ExecutionThread class or NULL if not existant. 
            ExecutionThread *execthread;
            
            TNode() : LinkedListBase<TNode>() { thread=NULL; execthread=NULL; }
            ~TNode() {}
        };
        
        static inline void unregister(ExecutionThread *et)
            {  kernel->_unregister(et);  }
    private:
        GPrivate *phook;
        
        RecursiveMutex mutex;
        
        LinkedList<TNode> threadlist;
        int nrunning;
        
        static void PhookNotifier(gpointer ptr);
        void _PhookNotifier(gpointer ptr);
        
        static void *ThreadFuncWrapper(void *ptr);
        void *_ThreadFuncWrapper(void *ptr);
        
        void _unregister(ExecutionThread *et);
        int _NRunningThreads();
        
        ThreadKernel(const ThreadKernel &);
        void operator=(const ThreadKernel &);
        ThreadKernel();
    public:
        ~ThreadKernel();
        
        static void init();
        
        static void cleanup();
        
        inline static int NRunningThreads()
            {  return(kernel ? kernel->_NRunningThreads() : -1);  }
};


class ExecutionThread
{
    friend class ThreadKernel;
    private:
        ThreadKernel::TNode *handle;
        
        ExecutionThread(const ExecutionThread &);
        void operator=(const ExecutionThread &);
    protected:
        virtual void run();
        
        void exit();
        
        void yield();
        
    public:
        ExecutionThread();
        virtual ~ExecutionThread();
        
        int start();
        
        inline bool running()
            {  return(g_atomic_pointer_get(&handle));  }
};


#endif  /* _ThreadLibrary_Thread_H_ */

---