/[svn]/linuxsampler/trunk/src/common/Thread.h
ViewVC logotype

Diff of /linuxsampler/trunk/src/common/Thread.h

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 56 by schoenebeck, Tue Apr 27 09:21:58 2004 UTC revision 1482 by schoenebeck, Thu Nov 15 01:15:12 2007 UTC
# Line 3  Line 3 
3   *   LinuxSampler - modular, streaming capable sampler                     *   *   LinuxSampler - modular, streaming capable sampler                     *
4   *                                                                         *   *                                                                         *
5   *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *   *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *
6     *   Copyright (C) 2005 - 2007 Christian Schoenebeck                       *
7   *                                                                         *   *                                                                         *
8   *   This program is free software; you can redistribute it and/or modify  *   *   This program is free software; you can redistribute it and/or modify  *
9   *   it under the terms of the GNU General Public License as published by  *   *   it under the terms of the GNU General Public License as published by  *
# Line 20  Line 21 
21   *   MA  02111-1307  USA                                                   *   *   MA  02111-1307  USA                                                   *
22   ***************************************************************************/   ***************************************************************************/
23    
24  #ifndef __THREAD_H__  #ifndef __LS_THREAD_H__
25  #define __THREAD_H__  #define __LS_THREAD_H__
26    
27    //FIXME: this is a temorary solution because of problems with condition variables we use a polling lock in SignalStartThread()
28    #if defined(WIN32)
29    #define WIN32_SIGNALSTARTTHREAD_WORKAROUND 1
30    #endif
31    
32  #include <iostream>  #include <iostream>
33  #include <stdio.h>  #include <stdio.h>
34  #include <stdlib.h>  #include <stdlib.h>
35    
36    #if defined(WIN32)
37    #include <windows.h>
38    #else
39  #include <sched.h>  #include <sched.h>
40  #include <sys/mman.h>  #include <sys/mman.h>
41  #include <memory.h>  #include <memory.h>
42  #include <pthread.h>  #include <pthread.h>
43    #endif
44  #include <errno.h>  #include <errno.h>
45    
46    #include "Condition.h"
47    
48    namespace LinuxSampler {
49    
50  /// Abstract base class for classes that need to run in an own thread.  /// Abstract base class for classes that need to run in an own thread.
51  class Thread {  class Thread {
52      public:      public:
53          Thread(bool RealTime, int PriorityMax, int PriorityDelta);          Thread(bool LockMemory, bool RealTime, int PriorityMax, int PriorityDelta);
54          virtual ~Thread();          virtual ~Thread();
55          virtual int  StartThread();          virtual int  StartThread();
56          virtual int  StopThread();          virtual int  StopThread();
57            virtual int  SignalStartThread();
58          virtual int  SignalStopThread();          virtual int  SignalStopThread();
59          virtual bool IsRunning() { return Running; }          virtual bool IsRunning();
60          virtual int  SetSchedulingPriority(); //FIXME: should be private          virtual int  SetSchedulingPriority(); //FIXME: should be private
61            virtual int  LockMemory();            //FIXME: should be private
62          virtual void EnableDestructor();      //FIXME: should be private          virtual void EnableDestructor();      //FIXME: should be private
63          virtual int  Destructor();            //FIXME: should be private          virtual int  Destructor();            //FIXME: should be private
64          virtual int  Main() = 0; ///< This method needs to be implemented by the descendant and is the entry point for the new thread. FIXME: should be protected          virtual int  Main() = 0; ///< This method needs to be implemented by the descendant and is the entry point for the new thread. FIXME: should be protected
65    
66            /**
67             * Allocates an aligned block of memory. Allocated memory blocks
68             * need to be freed using freeAlignedMem().
69             *
70             * @param boundary - the alignement boundary, usually a power of 2
71             *                   e.g. 4 but it can be an arbitrary number
72             *                   between 1 and 128
73             * @param size     - size in bytes to be allocated
74             * @returns  pointer to the allocated memory block
75             */
76            static void* allocAlignedMem(size_t boundary, size_t size) {
77                unsigned char *ptr = (unsigned char *)malloc(size+boundary);
78                size_t offset = boundary - ((size_t)ptr % boundary);
79                ptr[offset-1] = (unsigned char)offset;
80                return (ptr + offset);
81            }
82    
83            /**
84             * Frees an aligned block of memory allocated with allocAlignedMem()
85             *
86             * @param ptr - pointer to the memory block
87             */
88            static void freeAlignedMem(void *ptr) {
89                unsigned char *p = (unsigned char *)ptr;
90                p -= p[-1];
91                free(p);
92            }
93    
94            /**
95             * Locks a region of memory in physical RAM.
96             *
97             * @param addr - address of the memory block
98             * @param size - size of the memory block
99             * @return true if the locking succeded, otherwise false
100             */
101            static bool lockMemory(void *addr, size_t size) {
102                #if defined(WIN32)
103                return VirtualLock(addr, size);
104                #else
105                return !mlock(addr, size);
106                #endif
107            }
108    
109            /**
110             * Unlocks a region of memory in physical RAM.
111             *
112             * @param addr - address of the memory block
113             * @param size - size of the memory block
114             * @return true if the unlocking succeded, otherwise false
115             */
116            static bool unlockMemory(void *addr, size_t size) {
117                #if defined(WIN32)
118                return VirtualUnlock(addr, size);
119                #else
120                return !munlock(addr, size);
121                #endif
122            }
123    
124      private:      private:
125        #if defined(WIN32)
126            HANDLE hThread;
127            DWORD lpThreadId;
128            #if defined(WIN32_SIGNALSTARTTHREAD_WORKAROUND)
129            bool win32isRunning;
130            #endif
131        #else
132            pthread_attr_t  __thread_attr;
133          pthread_t       __thread_id;          pthread_t       __thread_id;
134          pthread_key_t   __thread_destructor_key;          pthread_key_t   __thread_destructor_key;
135          pthread_mutex_t __thread_state_mutex;      #endif
136          pthread_cond_t  __thread_exit_condition;          Condition       RunningCondition;
137          int             PriorityMax;          int             PriorityMax;
138          int             PriorityDelta;          int             PriorityDelta;
         bool            Running;  
139          bool            isRealTime;          bool            isRealTime;
140            bool            bLockedMemory;
141  };  };
142    
143  // Callback functions for the POSIX thread API  } // namespace LinuxSampler
 void* __pthread_launcher(void* thread);  
 void  __pthread_destructor(void* thread);  
144    
145  #endif // __THREAD_H__  #endif // __LS_THREAD_H__

Legend:
Removed from v.56  
changed lines
  Added in v.1482

  ViewVC Help
Powered by ViewVC