blob: 504d8303de1d8f2bba4899a518589c76d2144572 (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
|
//===-- MIUtilThreadBaseStd.h -----------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// Copyright: None.
//--
#pragma once
// Third party headers:
#ifdef _MSC_VER
#include <eh.h>
#endif // _MSC_VER
#include <thread>
#include <mutex>
// In-house headers:
#include "MIDataTypes.h"
#include "MIUtilString.h"
//++ ============================================================================
// Details: MI common code utility class. Handle thread mutual exclusion.
// Embed Mutexes in your Active Object and then use them through Locks.
// Gotchas: None.
// Authors: Aidan Dodds 10/03/2014.
// Changes: None.
//--
class CMIUtilThreadMutex
{
// Methods:
public:
/* ctor */ CMIUtilThreadMutex(void){};
//
void
Lock(void); // Wait until mutex can be obtained
void
Unlock(void); // Release the mutex
bool
TryLock(void); // Gain the lock if available
// Overrideable:
public:
// From CMICmnBase
/* dtor */ virtual ~CMIUtilThreadMutex(void){};
// Attributes:
private:
std::recursive_mutex m_mutex;
};
//++ ============================================================================
// Details: MI common code utility class. Thread object.
// Gotchas: None.
// Authors: Aidan Dodds 10/03/2014.
// Changes: None.
//--
class CMIUtilThread
{
// Typedef:
public:
typedef MIuint (*FnThreadProc)(void *vpThisClass);
// Methods:
public:
/* ctor */ CMIUtilThread(void);
//
bool
Start(FnThreadProc vpFn, void *vpArg); // Start execution of this thread
bool
Join(void); // Wait for this thread to stop
bool
IsActive(void); // Returns true if this thread is running
void
Finish(void); // Finish this thread
// Overrideable:
public:
/* dtor */ virtual ~CMIUtilThread(void);
// Methods:
private:
CMIUtilThreadMutex m_mutex;
std::thread *m_pThread;
bool m_bIsActive;
};
//++ ============================================================================
// Details: MI common code utility class. Base class for a worker thread active
// object. Runs an 'captive thread'.
// Gotchas: None.
// Authors: Aidan Dodds 10/03/2014..
// Changes: None.
//--
class CMIUtilThreadActiveObjBase
{
// Methods:
public:
/* ctor */ CMIUtilThreadActiveObjBase(void);
//
bool
Acquire(void); // Obtain a reference to this object
bool
Release(void); // Release a reference to this object
bool
ThreadIsActive(void); // Return true if this object is running
bool
ThreadJoin(void); // Wait for this thread to stop running
bool
ThreadKill(void); // Force this thread to stop, regardless of references
bool
ThreadExecute(void); // Start this objects execution in another thread
void ThreadManage(void);
// Overrideable:
public:
/* dtor */ virtual ~CMIUtilThreadActiveObjBase(void);
//
// Each thread object must supple a unique name that can be used to locate it
virtual const CMIUtilString &ThreadGetName(void) const = 0;
// Statics:
protected:
static MIuint
ThreadEntry(void *vpThisClass); // Thread entry point
// Overrideable:
protected:
virtual bool
ThreadRun(bool &vrIsAlive) = 0; // Call the main worker method
virtual bool
ThreadFinish(void) = 0; // Finish of what you were doing
// Attributes:
protected:
volatile MIuint m_references; // Stores the current lifetime state of this thread, 0 = running, > 0 = shutting down
volatile bool m_bHasBeenKilled; // Set to true when this thread has been killed
CMIUtilThread m_thread; // The execution thread
CMIUtilThreadMutex
m_mutex; // This mutex allows us to safely communicate with this thread object across the interface from multiple threads
};
//++ ============================================================================
// Details: MI common code utility class. Handle thread resource locking.
// Put Locks inside all the methods of your Active Object that access
// data shared with the captive thread.
// Gotchas: None.
// Authors: Aidan Dodds 10/03/2014.
// Changes: None.
//--
class CMIUtilThreadLock
{
// Methods:
public:
/* ctor */
CMIUtilThreadLock(CMIUtilThreadMutex &vMutex)
: m_rMutex(vMutex)
{
m_rMutex.Lock();
}
// Overrideable:
public:
/* dtor */
virtual ~CMIUtilThreadLock(void) { m_rMutex.Unlock(); }
// Attributes:
private:
CMIUtilThreadMutex &m_rMutex;
};
|
