blob: bb1c9be4e97f8e753c05197ad19891c0dc191f96 (
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
|
/*
* Copyright (C) 2005-2013 Team XBMC
* http://xbmc.org
*
* This Program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This Program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with XBMC; see the file COPYING. If not, see
* <http://www.gnu.org/licenses/>.
*
*/
// Thread.h: interface for the CThread class.
//
//////////////////////////////////////////////////////////////////////
#pragma once
#include <string>
#include <stdint.h>
#include "Event.h"
#include "threads/ThreadImpl.h"
#include "threads/ThreadLocal.h"
#include "commons/ilog.h"
#ifdef TARGET_DARWIN
#include <mach/mach.h>
#endif
class IRunnable
{
public:
virtual void Run()=0;
virtual ~IRunnable() {}
};
// minimum as mandated by XTL
#define THREAD_MINSTACKSIZE 0x10000
namespace XbmcThreads { class ThreadSettings; }
class CThread
{
static XbmcCommons::ILogger* logger;
protected:
CThread(const char* ThreadName);
public:
CThread(IRunnable* pRunnable, const char* ThreadName);
virtual ~CThread();
void Create(bool bAutoDelete = false, unsigned stacksize = 0);
void Sleep(unsigned int milliseconds);
int GetSchedRRPriority(void);
bool SetPrioritySched_RR(int iPriority);
bool IsAutoDelete() const;
virtual void StopThread(bool bWait = true);
bool IsRunning() const;
// -----------------------------------------------------------------------------------
// These are platform specific and can be found in ./platform/[platform]/ThreadImpl.cpp
// -----------------------------------------------------------------------------------
bool IsCurrentThread() const;
int GetMinPriority(void);
int GetMaxPriority(void);
int GetNormalPriority(void);
int GetPriority(void);
bool SetPriority(const int iPriority);
bool WaitForThreadExit(unsigned int milliseconds);
float GetRelativeUsage(); // returns the relative cpu usage of this thread since last call
int64_t GetAbsoluteUsage();
// -----------------------------------------------------------------------------------
static bool IsCurrentThread(const ThreadIdentifier tid);
static ThreadIdentifier GetCurrentThreadId();
static CThread* GetCurrentThread();
static inline void SetLogger(XbmcCommons::ILogger* logger_) { CThread::logger = logger_; }
static inline XbmcCommons::ILogger* GetLogger() { return CThread::logger; }
virtual void OnException(){} // signal termination handler
protected:
virtual void OnStartup(){};
virtual void OnExit(){};
virtual void Process();
volatile bool m_bStop;
enum WaitResponse { WAIT_INTERRUPTED = -1, WAIT_SIGNALED = 0, WAIT_TIMEDOUT = 1 };
/**
* This call will wait on a CEvent in an interruptible way such that if
* stop is called on the thread the wait will return with a response
* indicating what happened.
*/
inline WaitResponse AbortableWait(CEvent& event, int timeoutMillis = -1 /* indicates wait forever*/)
{
XbmcThreads::CEventGroup group(&event, &m_StopEvent, NULL);
CEvent* result = timeoutMillis < 0 ? group.wait() : group.wait(timeoutMillis);
return result == &event ? WAIT_SIGNALED :
(result == NULL ? WAIT_TIMEDOUT : WAIT_INTERRUPTED);
}
private:
static THREADFUNC staticThread(void *data);
void Action();
// -----------------------------------------------------------------------------------
// These are platform specific and can be found in ./platform/[platform]/ThreadImpl.cpp
// -----------------------------------------------------------------------------------
ThreadIdentifier ThreadId() const;
void SetThreadInfo();
void TermHandler();
void SetSignalHandlers();
void SpawnThread(unsigned stacksize);
// -----------------------------------------------------------------------------------
ThreadIdentifier m_ThreadId;
ThreadOpaque m_ThreadOpaque;
bool m_bAutoDelete;
CEvent m_StopEvent;
CEvent m_TermEvent;
CEvent m_StartEvent;
CCriticalSection m_CriticalSection;
IRunnable* m_pRunnable;
uint64_t m_iLastUsage;
uint64_t m_iLastTime;
float m_fLastUsage;
std::string m_ThreadName;
};
|
