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
158
159
160
161
|
/* Copyright (c) 2022, 2025, Oracle and/or its affiliates.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License, version 2.0,
as published by the Free Software Foundation.
This program is designed to work with certain software (including
but not limited to OpenSSL) that is licensed under separate terms,
as designated in a particular file or component or in included license
documentation. The authors of MySQL hereby grant you an additional
permission to link the program and your derivative works with the
separately licensed software that they have either included with
the program or referenced in the documentation.
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, version 2.0, for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
#ifndef BINLOG_BCG_TICKET_H
#define BINLOG_BCG_TICKET_H
#include <cstdint>
#include <functional>
#include <limits>
#include <memory>
#include <ostream>
#include "sql/memory/aligned_atomic.h"
namespace binlog {
class AtomicBgcTicket;
class BgcTicketGuard;
/// @brief Represents the Binlog Group Commit Ticket - BGC Ticket.
/// @details Context: BGC ticket is granted to sessions with the same View,
/// which may be changed with the View Change Event (server connecting to /
/// disconnecting from group). When View Change Event is generated, it is
/// granted a separate ticket value (value+1). All sessions that should be
/// executed after View Change Event are assigned with a ticket value + 2.
/// Implementation: Ticket is composed of 1 synchronization bit, used for
/// critical section implementation and 63 bits that represent a ticket value.
/// This class contains operation common for BGC tickets, such as: value
/// extraction, changing synchronization bit between 0 and 1, ticket comparison,
/// formatting, incrementation, internal constants. After reachning the maximum
/// value for a ticket, ticket value is wrapped up to the first valid ticket
/// value.
/// @see Bgc_ticket_manager
class BgcTicket {
public:
using ValueType = std::uint64_t;
/// @brief Default value of ticket, which means it is not being used.
static constexpr BgcTicket::ValueType kTicketUnset = 0;
/// @brief Constructor
/// @param[in] ticket Pattern to copy from
explicit BgcTicket(const ValueType &ticket = first_ticket_value);
friend class AtomicBgcTicket;
/// @brief "Less than" operator
/// @param[in] lhs Left hand side BgcTicket argument (const ref)
/// @param[in] rhs Right hand side BgcTicket argument (const ref)
friend bool operator<(const BgcTicket &lhs, const BgcTicket &rhs);
/// @brief "Greater than" operator
/// @param[in] lhs Left hand side BgcTicket argument (const ref)
/// @param[in] rhs Right hand side BgcTicket argument (const ref)
/// @retval true lhs > rhs
/// @retval false rhs <= lhs
friend bool operator>(const BgcTicket &lhs, const BgcTicket &rhs);
/// @brief Comparison operator (>=)
/// @param[in] lhs Left hand side BgcTicket argument (const ref)
/// @param[in] rhs Right hand side BgcTicket argument (const ref)
/// @retval true lhs >= rhs
/// @retval false !(rhs >= lhs)
friend bool operator>=(const BgcTicket &lhs, const BgcTicket &rhs);
/// @brief Comparison operator
/// @details Comparison without (!) first bit, meaning that if some thread
/// locked on lhs or rhs, tickets can still be equal
/// @param[in] lhs Left hand side BgcTicket argument (const ref)
/// @param[in] rhs Right hand side BgcTicket argument (const ref)
/// @retval true lhs == rhs
/// @retval false rhs != lhs
friend bool operator==(const BgcTicket &lhs, const BgcTicket &rhs);
/// @brief Comparison operator
/// @details Comparison without (!) first bit
/// @param[in] lhs Left hand side BgcTicket argument (const ref)
/// @param[in] rhs Right hand side BgcTicket argument (const ref)
/// @retval true lhs != rhs
/// @retval false rhs == lhs
friend bool operator!=(const BgcTicket &lhs, const BgcTicket &rhs);
/// @brief Obtain ticket value (1st bit cleared out)
/// @return Ticket value
ValueType get_value() const;
/// @brief Obtain ticket, may be in use or not (cannot be easily compared)
/// @details Cannot be easily compared, use comparison operator from BgcTicket
/// instead
/// @returns Internal value of the ticket (value+sync bit)
const ValueType &get() const { return m_ticket; }
/// @brief sets synchronization bit to 1, only 1 thread can operate on this
/// ticket
void set_in_use();
/// @brief sets synchronization bit to 0, other thread may "lock" this ticket
/// for writing
void set_used();
/// @brief checks whether this ticket is "locked" for writing
/// @retval true Ticket is in use
/// @retval false Ticket is not in use
bool is_in_use() const;
/// @brief Returns incremented ticket, this remain unchanged
/// @returns Incremented ticket
BgcTicket next() const;
/// @brief Increments this ticket value
void set_next();
/// @brief Checks whether the ticket value differs from kTicketUnset
/// @retval true Ticket value is set
/// @retval false Ticket value is unset
bool is_set() const;
/// @brief Stream operator impl for BgcTicket class
/// @param[in] os Reference to stream obj
/// @param[in] arg Constant reference to BgcTicket object
/// @returns Reference to changed stream obj
friend std::ostream &operator<<(std::ostream &os, const BgcTicket &arg);
public:
/// 64-bit mask with all 0s except for the most significant bit, to extract
/// synchronization bit
static constexpr ValueType set_bit = 1ULL << 63;
/// 64-bit mask with all 0s except for the most significant bit, to clear out
/// synchronization bit - get ticket value
static constexpr ValueType clear_bit = set_bit - 1;
/// Maximum allowed value for a ticket, after which will wrap around to
/// first_ticket_value
static constexpr ValueType max_ticket_value =
std::numeric_limits<ValueType>::max() & clear_bit;
/// Minimum allowed value for a ticket
static constexpr ValueType first_ticket_value = 1;
protected:
ValueType m_ticket; ///< 1 bit for synchronization, 63 bits - ticket value
};
} // namespace binlog
#endif // BINLOG_BCG_TICKET_H
|
