blob: 3add4e45116eb93f08489cfbc8aa4522c85c1064 (
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
|
#pragma once
#include "xmrstak/backend/miner_work.hpp"
#include "xmrstak/misc/environment.hpp"
#include "xmrstak/misc/console.hpp"
#include "xmrstak/backend/pool_data.hpp"
#include <atomic>
#include <condition_variable>
namespace xmrstak
{
class RWLock {
public:
RWLock() : _status(0), _waiting_readers(0), _waiting_writers(0) {}
RWLock(const RWLock&) = delete;
RWLock(RWLock&&) = delete;
RWLock& operator = (const RWLock&) = delete;
RWLock& operator = (RWLock&&) = delete;
void rdlock() {
std::unique_lock<std::mutex> lck(_mtx);
_waiting_readers += 1;
_read_cv.wait(lck, [&]() { return _waiting_writers == 0 && _status >= 0; });
_waiting_readers -= 1;
_status += 1;
}
void wrlock() {
std::unique_lock<std::mutex> lck(_mtx);
_waiting_writers += 1;
_write_cv.wait(lck, [&]() { return _status == 0; });
_waiting_writers -= 1;
_status = -1;
}
void unlock() {
std::unique_lock<std::mutex> lck(_mtx);
if (_status == -1) {
_status = 0;
} else {
_status -= 1;
}
if (_waiting_writers > 0) {
if (_status == 0) {
_write_cv.notify_one();
}
} else {
_read_cv.notify_all();
}
}
private:
// -1 : one writer
// 0 : no reader and no writer
// n > 0 : n reader
int32_t _status;
int32_t _waiting_readers;
int32_t _waiting_writers;
std::mutex _mtx;
std::condition_variable _read_cv;
std::condition_variable _write_cv;
};
struct globalStates
{
static inline globalStates& inst()
{
auto& env = environment::inst();
if(env.pglobalStates == nullptr)
env.pglobalStates = new globalStates;
return *env.pglobalStates;
}
//pool_data is in-out winapi style
void switch_work(miner_work& pWork, pool_data& dat);
inline void calc_start_nonce(uint32_t& nonce, bool use_nicehash, uint32_t reserve_count)
{
if(use_nicehash)
nonce = (nonce & 0xFF000000) | iGlobalNonce.fetch_add(reserve_count);
else
nonce = iGlobalNonce.fetch_add(reserve_count);
}
void consume_work( miner_work& threadWork, uint64_t& currentJobId);
miner_work oGlobalWork;
std::atomic<uint64_t> iGlobalJobNo;
std::atomic<uint64_t> iConsumeCnt;
std::atomic<uint32_t> iGlobalNonce;
uint64_t iThreadCount;
size_t pool_id = invalid_pool_id;
private:
globalStates() : iThreadCount(0), iGlobalJobNo(0), iConsumeCnt(0)
{
}
RWLock jobLock;
};
} // namespace xmrstak
|
