linuxsampler 2.3.1
Thread.h
Go to the documentation of this file.
1/***************************************************************************
2 * *
3 * LinuxSampler - modular, streaming capable sampler *
4 * *
5 * Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6 * Copyright (C) 2005 - 2020 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
48namespace LinuxSampler {
49
64class Thread {
65 public:
66 Thread(bool LockMemory, bool RealTime, int PriorityMax, int PriorityDelta);
67 virtual ~Thread();
68 virtual int StartThread();
69 virtual int StopThread();
70 virtual int SignalStopThread();
71 virtual bool IsRunning();
72
83 static void* allocAlignedMem(size_t boundary, size_t size) {
84 unsigned char *ptr = (unsigned char *)malloc(size+boundary);
85 size_t offset = boundary - ((size_t)ptr % boundary);
86 ptr[offset-1] = (unsigned char)offset;
87 return (ptr + offset);
88 }
89
95 static void freeAlignedMem(void *ptr) {
96 unsigned char *p = (unsigned char *)ptr;
97 p -= p[-1];
98 free(p);
99 }
100
108 static bool lockMemory(void *addr, size_t size) {
109 #if defined(WIN32)
110 return VirtualLock(addr, size);
111 #else
112 return !mlock(addr, size);
113 #endif
114 }
115
123 static bool unlockMemory(void *addr, size_t size) {
124 #if defined(WIN32)
125 return VirtualUnlock(addr, size);
126 #else
127 return !munlock(addr, size);
128 #endif
129 }
130
131 static void pushCancelable(bool cancel);
132 static void popCancelable();
133
134 std::string name();
135 static std::string nameOfCaller();
136 static void setNameOfCaller(std::string name);
137
138 protected:
148 virtual int Main() = 0;
149
162
163 virtual int SignalStartThread();
165 virtual int LockMemory();
166 virtual void EnableDestructor();
167 virtual int onThreadEnd();
168
169 private:
170 enum state_t {
171 NOT_RUNNING,
172 RUNNING,
173 PENDING_JOIN,
174 DETACHED
175 };
176
177 #if defined(WIN32)
180 #if defined(WIN32_SIGNALSTARTTHREAD_WORKAROUND)
181 bool win32isRunning;
182 #endif
183 #else
184 pthread_attr_t __thread_attr;
185 pthread_t __thread_id;
186 pthread_key_t __thread_destructor_key;
187 #endif
188 Condition RunningCondition;
189 int PriorityMax;
190 int PriorityDelta;
191 bool isRealTime;
192 bool bLockedMemory;
193 state_t state;
194
195 #if defined(WIN32)
197 #else
198 static void* pthreadLauncher(void* thread);
199 static void pthreadDestructor(void* thread);
200 #endif
201};
202
203} // namespace LinuxSampler
204
205#endif // __LS_THREAD_H__
Wraps as a kind of pointer class some data object shared with other threads, to protect / synchronize...
Abstract base class for classes that need to run in an own thread.
Definition Thread.h:64
virtual int StopThread()
void TestCancel()
Synchronization point for potentially terminating the thread.
static void pushCancelable(bool cancel)
virtual int SignalStopThread()
virtual int LockMemory()
virtual int onThreadEnd()
static void popCancelable()
static void setNameOfCaller(std::string name)
virtual int Main()=0
This method needs to be implemented by the descending class and is the entry point for the new thread...
static bool lockMemory(void *addr, size_t size)
Locks a region of memory in physical RAM.
Definition Thread.h:108
std::string name()
Thread(bool LockMemory, bool RealTime, int PriorityMax, int PriorityDelta)
static bool unlockMemory(void *addr, size_t size)
Unlocks a region of memory in physical RAM.
Definition Thread.h:123
static std::string nameOfCaller()
virtual int SignalStartThread()
static void * allocAlignedMem(size_t boundary, size_t size)
Allocates an aligned block of memory.
Definition Thread.h:83
virtual bool IsRunning()
virtual void EnableDestructor()
static void freeAlignedMem(void *ptr)
Frees an aligned block of memory allocated with allocAlignedMem()
Definition Thread.h:95
virtual int SetSchedulingPriority()
virtual int StartThread()