blob: 68fa642a735d4595d5bd80dde3a5c63043ea3dba (
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
|
// Copyright (C) 2016 The Qt Company Ltd.
// Copyright (C) 2016 Olivier Goffart <ogoffart@woboq.com>
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
#ifndef QREADWRITELOCK_P_H
#define QREADWRITELOCK_P_H
//
// W A R N I N G
// -------------
//
// This file is not part of the Qt API. It exists for the convenience
// of the implementation. This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//
#include <QtCore/private/qlocking_p.h>
#include <QtCore/private/qwaitcondition_p.h>
#include <QtCore/qreadwritelock.h>
#include <QtCore/qvarlengtharray.h>
QT_REQUIRE_CONFIG(thread);
QT_BEGIN_NAMESPACE
namespace QReadWriteLockStates {
enum {
StateMask = 0x3,
StateLockedForRead = 0x1,
StateLockedForWrite = 0x2,
};
enum StateForWaitCondition {
LockedForRead,
LockedForWrite,
Unlocked,
RecursivelyLocked
};
}
class QReadWriteLockPrivate
{
public:
explicit QReadWriteLockPrivate(bool isRecursive = false)
: recursive(isRecursive) {}
alignas(QtPrivate::IdealMutexAlignment) std::condition_variable writerCond;
std::condition_variable readerCond;
alignas(QtPrivate::IdealMutexAlignment) std::mutex mutex;
int readerCount = 0;
int writerCount = 0;
int waitingReaders = 0;
int waitingWriters = 0;
const bool recursive;
//Called with the mutex locked
bool lockForWrite(std::unique_lock<std::mutex> &lock, QDeadlineTimer timeout);
bool lockForRead(std::unique_lock<std::mutex> &lock, QDeadlineTimer timeout);
void unlock();
//memory management
int id = 0;
void release();
static QReadWriteLockPrivate *allocate();
// Recursive mutex handling
Qt::HANDLE currentWriter = {};
struct Reader {
Qt::HANDLE handle;
int recursionLevel;
};
QVarLengthArray<Reader, 16> currentReaders;
// called with the mutex unlocked
bool recursiveLockForWrite(QDeadlineTimer timeout);
bool recursiveLockForRead(QDeadlineTimer timeout);
void recursiveUnlock();
static QReadWriteLockStates::StateForWaitCondition
stateForWaitCondition(const QReadWriteLock *lock);
};
Q_DECLARE_TYPEINFO(QReadWriteLockPrivate::Reader, Q_PRIMITIVE_TYPE);\
/*! \internal Helper for QWaitCondition::wait */
inline QReadWriteLockStates::StateForWaitCondition
QReadWriteLockPrivate::stateForWaitCondition(const QReadWriteLock *q)
{
using namespace QReadWriteLockStates;
QReadWriteLockPrivate *d = q->d_ptr.loadAcquire();
switch (quintptr(d) & StateMask) {
case StateLockedForRead: return LockedForRead;
case StateLockedForWrite: return LockedForWrite;
}
if (!d)
return Unlocked;
const auto lock = qt_scoped_lock(d->mutex);
if (d->writerCount > 1)
return RecursivelyLocked;
else if (d->writerCount == 1)
return LockedForWrite;
return LockedForRead;
}
QT_END_NAMESPACE
#endif // QREADWRITELOCK_P_H
|
