b9c1b51e45
*** to conform to clang-format’s LLVM style. This kind of mass change has
*** two obvious implications:
Firstly, merging this particular commit into a downstream fork may be a huge
effort. Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit. The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):
find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;
The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.
Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit. There are alternatives available that will attempt
to look through this change and find the appropriate prior commit. YMMV.
llvm-svn: 280751
145 lines
4.2 KiB
C++
145 lines
4.2 KiB
C++
//===-- 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;
|
|
};
|