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
|
#ifndef RFISTRATEGYFOREACHBASELINEACTION_H
#define RFISTRATEGYFOREACHBASELINEACTION_H
#include "options.h"
#include "../imagesets/imageset.h"
#include <condition_variable>
#include <memory>
#include <mutex>
#include <set>
#include <stack>
#include <string>
#include <thread>
#include <utility>
class BaselineIterator {
public:
BaselineIterator(std::mutex* ioMutex, const Options& options);
~BaselineIterator();
void Run(imagesets::ImageSet& imageSet, class LuaThreadGroup& lua,
class ScriptData& scriptData);
private:
bool IsSequenceSelected(imagesets::ImageSetIndex& index);
imagesets::ImageSetIndex GetNextIndex();
static std::string memToStr(double memSize);
void SetExceptionOccured();
void SetFinishedBaselines();
// void SetProgress(ProgressListener &progress, int no, int count, const
// std::string& taskName, int threadId);
size_t BaselineProgress() {
std::lock_guard<std::mutex> lock(_mutex);
return _baselineProgress;
}
void IncBaselineProgress() {
std::lock_guard<std::mutex> lock(_mutex);
++_baselineProgress;
}
void WaitForReadBufferAvailable(size_t maxSize) {
std::unique_lock<std::mutex> lock(_mutex);
while (_baselineBuffer.size() > maxSize && !_exceptionOccured)
_dataProcessed.wait(lock);
}
std::unique_ptr<imagesets::BaselineData> GetNextBaseline() {
std::unique_lock<std::mutex> lock(_mutex);
while (_baselineBuffer.size() == 0 && !_exceptionOccured &&
!_finishedBaselines)
_dataAvailable.wait(lock);
if ((_finishedBaselines && _baselineBuffer.size() == 0) ||
_exceptionOccured) {
return nullptr;
} else {
std::unique_ptr<imagesets::BaselineData> next =
std::move(_baselineBuffer.top());
_baselineBuffer.pop();
_dataProcessed.notify_one();
return next;
}
}
size_t GetBaselinesInBufferCount() {
std::lock_guard<std::mutex> lock(_mutex);
return _baselineBuffer.size();
}
struct ProcessingThread {
ProcessingThread(BaselineIterator& parent, size_t threadIndex)
: _parent(parent), _threadIndex(threadIndex) {}
BaselineIterator& _parent;
size_t _threadIndex;
void operator()();
};
struct ReaderThread {
explicit ReaderThread(BaselineIterator& parent) : _parent(parent) {}
void operator()();
BaselineIterator& _parent;
};
const Options& _options;
LuaThreadGroup* _lua;
imagesets::ImageSet* _imageSet;
size_t _sequenceCount, _nextIndex;
size_t _threadCount;
imagesets::ImageSetIndex _loopIndex;
std::unique_ptr<class WriteThread> _writeThread;
std::mutex _mutex, *_ioMutex;
std::condition_variable _dataAvailable, _dataProcessed;
std::stack<std::unique_ptr<imagesets::BaselineData>> _baselineBuffer;
bool _finishedBaselines;
bool _exceptionOccured;
size_t _baselineProgress;
class ScriptData* _globalScriptData;
};
#endif
|
