forked from CMU-Perceptual-Computing-Lab/openpose
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathsubThread.hpp
More file actions
157 lines (133 loc) · 4.54 KB
/
subThread.hpp
File metadata and controls
157 lines (133 loc) · 4.54 KB
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
#ifndef OPENPOSE_THREAD_SUB_THREAD_HPP
#define OPENPOSE_THREAD_SUB_THREAD_HPP
#include <openpose/core/common.hpp>
#include <openpose/thread/worker.hpp>
namespace op
{
template<typename TDatums, typename TWorker = std::shared_ptr<Worker<TDatums>>>
class SubThread
{
public:
explicit SubThread(const std::vector<TWorker>& tWorkers);
// Destructor
virtual ~SubThread();
void initializationOnThread();
virtual bool work() = 0;
protected:
inline size_t getTWorkersSize() const
{
return mTWorkers.size();
}
bool workTWorkers(TDatums& tDatums, const bool inputIsRunning);
private:
std::vector<TWorker> mTWorkers;
DELETE_COPY(SubThread);
};
}
// Implementation
namespace op
{
template<typename TDatums, typename TWorker>
SubThread<TDatums, TWorker>::SubThread(const std::vector<TWorker>& tWorkers) :
mTWorkers{tWorkers}
{
}
template<typename TDatums, typename TWorker>
SubThread<TDatums, TWorker>::~SubThread()
{
}
template<typename TDatums, typename TWorker>
bool SubThread<TDatums, TWorker>::workTWorkers(TDatums& tDatums, const bool inputIsRunning)
{
try
{
// If !inputIsRunning -> try to close TWorkers
if (!inputIsRunning)
{
for (auto& tWorkers : mTWorkers)
{
tWorkers->tryStop();
if (tWorkers->isRunning())
break;
}
}
// If (at least) last TWorker still working -> make TWorkers work
if ((*mTWorkers.crbegin())->isRunning())
{
// Iterate over all workers and check whether some of them stopped
auto allRunning = true;
auto lastOneStopped = false;
for (auto& worker : mTWorkers)
{
if (lastOneStopped)
worker->tryStop();
if (!worker->checkAndWork(tDatums))
{
allRunning = false;
lastOneStopped = true;
}
else
lastOneStopped = false;
}
if (allRunning)
return true;
else
{
// If last one still running -> try to stop workers
// If last one stopped -> return false
auto lastRunning = (*mTWorkers.crbegin())->isRunning();
if (lastRunning)
{
// Check last one that stopped
auto lastIndexNotRunning = 0ull;
for (auto i = mTWorkers.size() - 1 ; i > 0 ; i--)
{
if (!mTWorkers[i]->checkAndWork(tDatums))
{
lastIndexNotRunning = i;
break;
}
}
// Stop workers before last index stopped
for (auto i = 0ull; i < lastIndexNotRunning ; i++)
mTWorkers[i]->stop();
// Try stopping workers after last index stopped
lastRunning = false;
for (auto i = lastIndexNotRunning+1; i < mTWorkers.size() ; i++)
{
mTWorkers[i]->tryStop();
if (mTWorkers[i]->isRunning())
{
lastRunning = true;
break;
}
}
}
return lastRunning;
}
}
else
return false;
}
catch (const std::exception& e)
{
error(e.what(), __LINE__, __FUNCTION__, __FILE__);
return false;
}
}
template<typename TDatums, typename TWorker>
void SubThread<TDatums, TWorker>::initializationOnThread()
{
try
{
for (auto& tWorker : mTWorkers)
tWorker->initializationOnThread();
}
catch (const std::exception& e)
{
error(e.what(), __LINE__, __FUNCTION__, __FILE__);
}
}
COMPILE_TEMPLATE_DATUM(SubThread);
}
#endif // OPENPOSE_THREAD_SUB_THREAD_HPP