blob: cfff7d459b4276aa9c9791d3d9ae37c12c41f735 (
plain)
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
|
//===-- MIUtilThreadBaseStd.h -----------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#pragma once
// Third party headers:
#ifdef _MSC_VER
#include <eh.h>
#endif // _MSC_VER
#include <mutex>
#include <thread>
// 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.
//--
class CMIUtilThreadMutex {
// Methods:
public:
/* ctor */ CMIUtilThreadMutex() {}
//
void Lock(); // Wait until mutex can be obtained
void Unlock(); // Release the mutex
bool TryLock(); // Gain the lock if available
// Overrideable:
public:
// From CMICmnBase
/* dtor */ virtual ~CMIUtilThreadMutex() {}
// Attributes:
private:
std::recursive_mutex m_mutex;
};
//++
//============================================================================
// Details: MI common code utility class. Thread object.
//--
class CMIUtilThread {
// Typedef:
public:
typedef MIuint (*FnThreadProc)(void *vpThisClass);
// Methods:
public:
/* ctor */ CMIUtilThread();
//
bool Start(FnThreadProc vpFn, void *vpArg); // Start execution of this thread
bool Join(); // Wait for this thread to stop
bool IsActive(); // Returns true if this thread is running
void Finish(); // Finish this thread
// Overrideable:
public:
/* dtor */ virtual ~CMIUtilThread();
// 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'.
//--
class CMIUtilThreadActiveObjBase {
// Methods:
public:
/* ctor */ CMIUtilThreadActiveObjBase();
//
bool Acquire(); // Obtain a reference to this object
bool Release(); // Release a reference to this object
bool ThreadIsActive(); // Return true if this object is running
bool ThreadJoin(); // Wait for this thread to stop running
bool ThreadKill(); // Force this thread to stop, regardless of references
bool ThreadExecute(); // Start this objects execution in another thread
void ThreadManage();
// Overrideable:
public:
/* dtor */ virtual ~CMIUtilThreadActiveObjBase();
//
// Each thread object must supple a unique name that can be used to locate it
virtual const CMIUtilString &ThreadGetName() 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() = 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.
//--
class CMIUtilThreadLock {
// Methods:
public:
/* ctor */
CMIUtilThreadLock(CMIUtilThreadMutex &vMutex) : m_rMutex(vMutex) {
m_rMutex.Lock();
}
// Overrideable:
public:
/* dtor */
virtual ~CMIUtilThreadLock() { m_rMutex.Unlock(); }
// Attributes:
private:
CMIUtilThreadMutex &m_rMutex;
};
|
