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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1482 - (show annotations) (download) (as text)
Thu Nov 15 01:15:12 2007 UTC (12 years, 2 months ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 5702 byte(s)
- bugfix: recent win32 commit broke the non-win code
- fixed API doc comments

1 /***************************************************************************
2 * *
3 * LinuxSampler - modular, streaming capable sampler *
4 * *
5 * 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 *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
12 * *
13 * This program is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
17 * *
18 * You should have received a copy of the GNU General Public License *
19 * along with this program; if not, write to the Free Software *
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
21 * MA 02111-1307 USA *
22 ***************************************************************************/
23
24 #ifndef __LS_THREAD_H__
25 #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>
33 #include <stdio.h>
34 #include <stdlib.h>
35
36 #if defined(WIN32)
37 #include <windows.h>
38 #else
39 #include <sched.h>
40 #include <sys/mman.h>
41 #include <memory.h>
42 #include <pthread.h>
43 #endif
44 #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.
51 class Thread {
52 public:
53 Thread(bool LockMemory, bool RealTime, int PriorityMax, int PriorityDelta);
54 virtual ~Thread();
55 virtual int StartThread();
56 virtual int StopThread();
57 virtual int SignalStartThread();
58 virtual int SignalStopThread();
59 virtual bool IsRunning();
60 virtual int SetSchedulingPriority(); //FIXME: should be private
61 virtual int LockMemory(); //FIXME: should be private
62 virtual void EnableDestructor(); //FIXME: should be private
63 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
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:
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;
134 pthread_key_t __thread_destructor_key;
135 #endif
136 Condition RunningCondition;
137 int PriorityMax;
138 int PriorityDelta;
139 bool isRealTime;
140 bool bLockedMemory;
141 };
142
143 } // namespace LinuxSampler
144
145 #endif // __LS_THREAD_H__

  ViewVC Help
Powered by ViewVC