mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2026-04-19 06:45:32 +02:00
Code Issues Projects Releases Packages Wiki Activity

MDEV-13073. This patch is a followup of the previous one to convert the trailing underscore identifier to mariadb standard. For identifier representing class private members the underscore is replaced with a m_ prefix. Otherwise _ is just removed.

Browse source
This commit is contained in:
Andrei Elkin 2017-11-27 21:06:17 +02:00 • committed by Monty
commit 529120e1cb
6 changed files with 204 additions and 204 deletions
Download patch file Download diff file Expand all files Collapse all files

6
sql/semisync.h
View file

@ -33,13 +33,13 @@ public:
static const unsigned long k_trace_detail;
static const unsigned long k_trace_net_wait;
unsigned long trace_level_; /* the level for tracing */
unsigned long m_trace_level; /* the level for tracing */
Trace()
:trace_level_(0L)
:m_trace_level(0L)
{}
Trace(unsigned long trace_level)
:trace_level_(trace_level)
:m_trace_level(trace_level)
{}
};

282
sql/semisync_master.cc
View file

@ -74,29 +74,29 @@ static ulonglong timespec_to_usec(const struct timespec *ts)
Active_tranx::Active_tranx(mysql_mutex_t *lock,
ulong trace_level)
: Trace(trace_level), allocator_(max_connections),
num_entries_(max_connections << 1), /* Transaction hash table size
: Trace(trace_level), m_allocator(max_connections),
m_num_entries(max_connections << 1), /* Transaction hash table size
* is set to double the size
* of max_connections */
lock_(lock)
m_lock(lock)
{
/* No transactions are in the list initially. */
trx_front_ = NULL;
trx_rear_ = NULL;
m_trx_front = NULL;
m_trx_rear = NULL;
/* Create the hash table to find a transaction's ending event. */
trx_htb_ = new Tranx_node *[num_entries_];
for (int idx = 0; idx < num_entries_; ++idx)
trx_htb_[idx] = NULL;
m_trx_htb = new Tranx_node *[m_num_entries];
for (int idx = 0; idx < m_num_entries; ++idx)
m_trx_htb[idx] = NULL;
sql_print_information("Semi-sync replication initialized for transactions.");
}
Active_tranx::~Active_tranx()
{
delete [] trx_htb_;
trx_htb_ = NULL;
num_entries_ = 0;
delete [] m_trx_htb;
m_trx_htb = NULL;
m_num_entries = 0;
}
unsigned int Active_tranx::calc_hash(const unsigned char *key,
@ -121,7 +121,7 @@ unsigned int Active_tranx::get_hash_value(const char *log_file_name,
unsigned int hash2 = calc_hash((const unsigned char *)(&log_file_pos),
sizeof(log_file_pos));
return (hash1 + hash2) % num_entries_;
return (hash1 + hash2) % m_num_entries;
}
int Active_tranx::compare(const char *log_file_name1, my_off_t log_file_pos1,
@ -148,7 +148,7 @@ int Active_tranx::insert_tranx_node(const char *log_file_name,
DBUG_ENTER("Active_tranx:insert_tranx_node");
ins_node = allocator_.allocate_node();
ins_node = m_allocator.allocate_node();
if (!ins_node)
{
sql_print_error("%s: transaction node allocation failed for: (%s, %lu)",
@ -159,25 +159,25 @@ int Active_tranx::insert_tranx_node(const char *log_file_name,
}
/* insert the binlog position in the active transaction list. */
strncpy(ins_node->log_name_, log_file_name, FN_REFLEN-1);
ins_node->log_name_[FN_REFLEN-1] = 0; /* make sure it ends properly */
ins_node->log_pos_ = log_file_pos;
strncpy(ins_node->log_name, log_file_name, FN_REFLEN-1);
ins_node->log_name[FN_REFLEN-1] = 0; /* make sure it ends properly */
ins_node->log_pos = log_file_pos;
if (!trx_front_)
if (!m_trx_front)
{
/* The list is empty. */
trx_front_ = trx_rear_ = ins_node;
m_trx_front = m_trx_rear = ins_node;
}
else
{
int cmp = compare(ins_node, trx_rear_);
int cmp = compare(ins_node, m_trx_rear);
if (cmp > 0)
{
/* Compare with the tail first. If the transaction happens later in
* binlog, then make it the new tail.
*/
trx_rear_->next_ = ins_node;
trx_rear_ = ins_node;
m_trx_rear->next = ins_node;
m_trx_rear = ins_node;
}
else
{
@ -186,20 +186,20 @@ int Active_tranx::insert_tranx_node(const char *log_file_name,
*/
sql_print_error("%s: binlog write out-of-order, tail (%s, %lu), "
"new node (%s, %lu)", "Active_tranx:insert_tranx_node",
trx_rear_->log_name_, (ulong)trx_rear_->log_pos_,
ins_node->log_name_, (ulong)ins_node->log_pos_);
m_trx_rear->log_name, (ulong)m_trx_rear->log_pos,
ins_node->log_name, (ulong)ins_node->log_pos);
result = -1;
goto l_end;
}
}
hash_val = get_hash_value(ins_node->log_name_, ins_node->log_pos_);
ins_node->hash_next_ = trx_htb_[hash_val];
trx_htb_[hash_val] = ins_node;
hash_val = get_hash_value(ins_node->log_name, ins_node->log_pos);
ins_node->hash_next = m_trx_htb[hash_val];
m_trx_htb[hash_val] = ins_node;
DBUG_PRINT("semisync", ("%s: insert (%s, %lu) in entry(%u)",
"Active_tranx:insert_tranx_node",
ins_node->log_name_, (ulong)ins_node->log_pos_,
ins_node->log_name, (ulong)ins_node->log_pos,
hash_val));
l_end:
@ -212,14 +212,14 @@ bool Active_tranx::is_tranx_end_pos(const char *log_file_name,
DBUG_ENTER("Active_tranx::is_tranx_end_pos");
unsigned int hash_val = get_hash_value(log_file_name, log_file_pos);
Tranx_node *entry = trx_htb_[hash_val];
Tranx_node *entry = m_trx_htb[hash_val];
while (entry != NULL)
{
if (compare(entry, log_file_name, log_file_pos) == 0)
break;
entry = entry->hash_next_;
entry = entry->hash_next;
}
DBUG_PRINT("semisync", ("%s: probe (%s, %lu) in entry(%u)",
@ -238,13 +238,13 @@ int Active_tranx::clear_active_tranx_nodes(const char *log_file_name,
if (log_file_name != NULL)
{
new_front = trx_front_;
new_front = m_trx_front;
while (new_front)
{
if (compare(new_front, log_file_name, log_file_pos) > 0)
break;
new_front = new_front->next_;
new_front = new_front->next;
}
}
else
@ -258,54 +258,54 @@ int Active_tranx::clear_active_tranx_nodes(const char *log_file_name,
/* No active transaction nodes after the call. */
/* Clear the hash table. */
memset(trx_htb_, 0, num_entries_ * sizeof(Tranx_node *));
allocator_.free_all_nodes();
memset(m_trx_htb, 0, m_num_entries * sizeof(Tranx_node *));
m_allocator.free_all_nodes();
/* Clear the active transaction list. */
if (trx_front_ != NULL)
if (m_trx_front != NULL)
{
trx_front_ = NULL;
trx_rear_ = NULL;
m_trx_front = NULL;
m_trx_rear = NULL;
}
DBUG_PRINT("semisync", ("%s: cleared all nodes",
"Active_tranx::::clear_active_tranx_nodes"));
}
else if (new_front != trx_front_)
else if (new_front != m_trx_front)
{
Tranx_node *curr_node, *next_node;
/* Delete all transaction nodes before the confirmation point. */
int n_frees = 0;
curr_node = trx_front_;
curr_node = m_trx_front;
while (curr_node != new_front)
{
next_node = curr_node->next_;
next_node = curr_node->next;
n_frees++;
/* Remove the node from the hash table. */
unsigned int hash_val = get_hash_value(curr_node->log_name_, curr_node->log_pos_);
Tranx_node **hash_ptr = &(trx_htb_[hash_val]);
unsigned int hash_val = get_hash_value(curr_node->log_name, curr_node->log_pos);
Tranx_node **hash_ptr = &(m_trx_htb[hash_val]);
while ((*hash_ptr) != NULL)
{
if ((*hash_ptr) == curr_node)
{
(*hash_ptr) = curr_node->hash_next_;
(*hash_ptr) = curr_node->hash_next;
break;
}
hash_ptr = &((*hash_ptr)->hash_next_);
hash_ptr = &((*hash_ptr)->hash_next);
}
curr_node = next_node;
}
trx_front_ = new_front;
allocator_.free_nodes_before(trx_front_);
m_trx_front = new_front;
m_allocator.free_nodes_before(m_trx_front);
DBUG_PRINT("semisync", ("%s: cleared %d nodes back until pos (%s, %lu)",
"Active_tranx::::clear_active_tranx_nodes",
n_frees,
trx_front_->log_name_, (ulong)trx_front_->log_pos_));
m_trx_front->log_name, (ulong)m_trx_front->log_pos));
}
DBUG_RETURN(0);
@ -336,26 +336,26 @@ int Active_tranx::clear_active_tranx_nodes(const char *log_file_name,
******************************************************************************/
Repl_semi_sync_master::Repl_semi_sync_master()
: active_tranxs_(NULL),
init_done_(false),
reply_file_name_inited_(false),
reply_file_pos_(0L),
wait_file_name_inited_(false),
wait_file_pos_(0),
master_enabled_(false),
wait_timeout_(0L),
state_(0),
wait_point_(0)
: m_active_tranxs(NULL),
m_init_done(false),
m_reply_file_name_inited(false),
m_reply_file_pos(0L),
m_wait_file_name_inited(false),
m_wait_file_pos(0),
m_master_enabled(false),
m_wait_timeout(0L),
m_state(0),
m_wait_point(0)
{
strcpy(reply_file_name_, "");
strcpy(wait_file_name_, "");
strcpy(m_reply_file_name, "");
strcpy(m_wait_file_name, "");
}
int Repl_semi_sync_master::init_object()
{
int result;
init_done_ = true;
m_init_done = true;
/* References to the parameter works after set_options(). */
set_wait_timeout(rpl_semi_sync_master_timeout);
@ -398,15 +398,15 @@ int Repl_semi_sync_master::enable_master()
if (!get_master_enabled())
{
active_tranxs_ = new Active_tranx(&LOCK_binlog, trace_level_);
if (active_tranxs_ != NULL)
m_active_tranxs = new Active_tranx(&LOCK_binlog, m_trace_level);
if (m_active_tranxs != NULL)
{
commit_file_name_inited_ = false;
reply_file_name_inited_ = false;
wait_file_name_inited_ = false;
m_commit_file_name_inited = false;
m_reply_file_name_inited = false;
m_wait_file_name_inited = false;
set_master_enabled(true);
state_ = true;
m_state = true;
sql_print_information("Semi-sync replication enabled on the master.");
}
else
@ -433,13 +433,13 @@ int Repl_semi_sync_master::disable_master()
*/
switch_off();
assert(active_tranxs_ != NULL);
delete active_tranxs_;
active_tranxs_ = NULL;
assert(m_active_tranxs != NULL);
delete m_active_tranxs;
m_active_tranxs = NULL;
reply_file_name_inited_ = false;
wait_file_name_inited_ = false;
commit_file_name_inited_ = false;
m_reply_file_name_inited = false;
m_wait_file_name_inited = false;
m_commit_file_name_inited = false;
set_master_enabled(false);
sql_print_information("Semi-sync replication disabled on the master.");
@ -452,14 +452,14 @@ int Repl_semi_sync_master::disable_master()
void Repl_semi_sync_master::cleanup()
{
if (init_done_)
if (m_init_done)
{
mysql_mutex_destroy(&LOCK_binlog);
mysql_cond_destroy(&COND_binlog_send);
init_done_= 0;
m_init_done= 0;
}
delete active_tranxs_;
delete m_active_tranxs;
}
void Repl_semi_sync_master::lock()
@ -592,10 +592,10 @@ int Repl_semi_sync_master::report_reply_binlog(uint32 server_id,
* sync replication slaves. So, if any one of them get the transaction,
* the transaction session in the primary can move forward.
*/
if (reply_file_name_inited_)
if (m_reply_file_name_inited)
{
cmp = Active_tranx::compare(log_file_name, log_file_pos,
reply_file_name_, reply_file_pos_);
m_reply_file_name, m_reply_file_pos);
/* If the requested position is behind the sending binlog position,
* would not adjust sending binlog position.
@ -614,13 +614,13 @@ int Repl_semi_sync_master::report_reply_binlog(uint32 server_id,
if (need_copy_send_pos)
{
strmake_buf(reply_file_name_, log_file_name);
reply_file_pos_ = log_file_pos;
reply_file_name_inited_ = true;
strmake_buf(m_reply_file_name, log_file_name);
m_reply_file_pos = log_file_pos;
m_reply_file_name_inited = true;
/* Remove all active transaction nodes before this point. */
assert(active_tranxs_ != NULL);
active_tranxs_->clear_active_tranx_nodes(log_file_name, log_file_pos);
assert(m_active_tranxs != NULL);
m_active_tranxs->clear_active_tranx_nodes(log_file_name, log_file_pos);
DBUG_PRINT("semisync", ("%s: Got reply at (%s, %lu)",
"Repl_semi_sync_master::report_reply_binlog",
@ -632,15 +632,15 @@ int Repl_semi_sync_master::report_reply_binlog(uint32 server_id,
/* Let us check if some of the waiting threads doing a trx
* commit can now proceed.
*/
cmp = Active_tranx::compare(reply_file_name_, reply_file_pos_,
wait_file_name_, wait_file_pos_);
cmp = Active_tranx::compare(m_reply_file_name, m_reply_file_pos,
m_wait_file_name, m_wait_file_pos);
if (cmp >= 0)
{
/* Yes, at least one waiting thread can now proceed:
* let us release all waiting threads with a broadcast
*/
can_release_threads = true;
wait_file_name_inited_ = false;
m_wait_file_name_inited = false;
}
}
@ -811,9 +811,9 @@ int Repl_semi_sync_master::commit_trx(const char* trx_wait_binlog_name,
while (is_on() && !thd_killed(current_thd))
{
if (reply_file_name_inited_)
if (m_reply_file_name_inited)
{
int cmp = Active_tranx::compare(reply_file_name_, reply_file_pos_,
int cmp = Active_tranx::compare(m_reply_file_name, m_reply_file_pos,
trx_wait_binlog_name,
trx_wait_binlog_pos);
if (cmp >= 0)
@ -823,8 +823,8 @@ int Repl_semi_sync_master::commit_trx(const char* trx_wait_binlog_name,
*/
DBUG_PRINT("semisync", ("%s: Binlog reply is ahead (%s, %lu),",
"Repl_semi_sync_master::commit_trx",
reply_file_name_,
(ulong)reply_file_pos_));
m_reply_file_name,
(ulong)m_reply_file_pos));
break;
}
}
@ -832,37 +832,37 @@ int Repl_semi_sync_master::commit_trx(const char* trx_wait_binlog_name,
/* Let us update the info about the minimum binlog position of waiting
* threads.
*/
if (wait_file_name_inited_)
if (m_wait_file_name_inited)
{
int cmp = Active_tranx::compare(trx_wait_binlog_name,
trx_wait_binlog_pos,
wait_file_name_, wait_file_pos_);
m_wait_file_name, m_wait_file_pos);
if (cmp <= 0)
{
/* This thd has a lower position, let's update the minimum info. */
strmake_buf(wait_file_name_, trx_wait_binlog_name);
wait_file_pos_ = trx_wait_binlog_pos;
strmake_buf(m_wait_file_name, trx_wait_binlog_name);
m_wait_file_pos = trx_wait_binlog_pos;
rpl_semi_sync_master_wait_pos_backtraverse++;
DBUG_PRINT("semisync", ("%s: move back wait position (%s, %lu),",
"Repl_semi_sync_master::commit_trx",
wait_file_name_, (ulong)wait_file_pos_));
m_wait_file_name, (ulong)m_wait_file_pos));
}
}
else
{
strmake_buf(wait_file_name_, trx_wait_binlog_name);
wait_file_pos_ = trx_wait_binlog_pos;
wait_file_name_inited_ = true;
strmake_buf(m_wait_file_name, trx_wait_binlog_name);
m_wait_file_pos = trx_wait_binlog_pos;
m_wait_file_name_inited = true;
DBUG_PRINT("semisync", ("%s: init wait position (%s, %lu),",
"Repl_semi_sync_master::commit_trx",
wait_file_name_, (ulong)wait_file_pos_));
m_wait_file_name, (ulong)m_wait_file_pos));
}
/* Calcuate the waiting period. */
long diff_secs = (long) (wait_timeout_ / TIME_THOUSAND);
long diff_nsecs = (long) ((wait_timeout_ % TIME_THOUSAND) * TIME_MILLION);
long diff_secs = (long) (m_wait_timeout / TIME_THOUSAND);
long diff_nsecs = (long) ((m_wait_timeout % TIME_THOUSAND) * TIME_MILLION);
long nsecs = start_ts.tv_nsec + diff_nsecs;
abstime.tv_sec = start_ts.tv_sec + diff_secs + nsecs/TIME_BILLION;
abstime.tv_nsec = nsecs % TIME_BILLION;
@ -879,8 +879,8 @@ int Repl_semi_sync_master::commit_trx(const char* trx_wait_binlog_name,
DBUG_PRINT("semisync", ("%s: wait %lu ms for binlog sent (%s, %lu)",
"Repl_semi_sync_master::commit_trx",
wait_timeout_,
wait_file_name_, (ulong)wait_file_pos_));
m_wait_timeout,
m_wait_file_name, (ulong)m_wait_file_pos));
wait_result = cond_timewait(&abstime);
rpl_semi_sync_master_wait_sessions--;
@ -891,7 +891,7 @@ int Repl_semi_sync_master::commit_trx(const char* trx_wait_binlog_name,
sql_print_warning("Timeout waiting for reply of binlog (file: %s, pos: %lu), "
"semi-sync up to file %s, position %lu.",
trx_wait_binlog_name, (ulong)trx_wait_binlog_pos,
reply_file_name_, (ulong)reply_file_pos_);
m_reply_file_name, (ulong)m_reply_file_pos);
rpl_semi_sync_master_wait_timeouts++;
/* switch semi-sync off */
@ -921,11 +921,11 @@ int Repl_semi_sync_master::commit_trx(const char* trx_wait_binlog_name,
/*
At this point, the binlog file and position of this transaction
must have been removed from Active_tranx.
active_tranxs_ may be NULL if someone disabled semi sync during
m_active_tranxs may be NULL if someone disabled semi sync during
cond_timewait()
*/
assert(thd_killed(current_thd) || !active_tranxs_ ||
!active_tranxs_->is_tranx_end_pos(trx_wait_binlog_name,
assert(thd_killed(current_thd) || !m_active_tranxs ||
!m_active_tranxs->is_tranx_end_pos(trx_wait_binlog_name,
trx_wait_binlog_pos));
l_end:
@ -967,15 +967,15 @@ int Repl_semi_sync_master::switch_off()
DBUG_ENTER("Repl_semi_sync_master::switch_off");
state_ = false;
m_state = false;
/* Clear the active transaction list. */
assert(active_tranxs_ != NULL);
result = active_tranxs_->clear_active_tranx_nodes(NULL, 0);
assert(m_active_tranxs != NULL);
result = m_active_tranxs->clear_active_tranx_nodes(NULL, 0);
rpl_semi_sync_master_off_times++;
wait_file_name_inited_ = false;
reply_file_name_inited_ = false;
m_wait_file_name_inited = false;
m_reply_file_name_inited = false;
sql_print_information("Semi-sync replication switched OFF.");
cond_broadcast(); /* wake up all waiting threads */
@ -993,13 +993,13 @@ int Repl_semi_sync_master::try_switch_on(int server_id,
/* If the current sending event's position is larger than or equal to the
* 'largest' commit transaction binlog position, the slave is already
* catching up now and we can switch semi-sync on here.
* If commit_file_name_inited_ indicates there are no recent transactions,
* If m_commit_file_name_inited indicates there are no recent transactions,
* we can enable semi-sync immediately.
*/
if (commit_file_name_inited_)
if (m_commit_file_name_inited)
{
int cmp = Active_tranx::compare(log_file_name, log_file_pos,
commit_file_name_, commit_file_pos_);
m_commit_file_name, m_commit_file_pos);
semi_sync_on = (cmp >= 0);
}
else
@ -1010,7 +1010,7 @@ int Repl_semi_sync_master::try_switch_on(int server_id,
if (semi_sync_on)
{
/* Switch semi-sync replication on. */
state_ = true;
m_state = true;
sql_print_information("Semi-sync replication switched ON with slave (server_id: %d) "
"at (%s, %lu)",
@ -1066,10 +1066,10 @@ int Repl_semi_sync_master::update_sync_header(THD* thd, unsigned char *packet,
/* semi-sync is ON */
sync = false; /* No sync unless a transaction is involved. */
if (reply_file_name_inited_)
if (m_reply_file_name_inited)
{
cmp = Active_tranx::compare(log_file_name, log_file_pos,
reply_file_name_, reply_file_pos_);
m_reply_file_name, m_reply_file_pos);
if (cmp <= 0)
{
/* If we have already got the reply for the event, then we do
@ -1079,10 +1079,10 @@ int Repl_semi_sync_master::update_sync_header(THD* thd, unsigned char *packet,
}
}
if (wait_file_name_inited_)
if (m_wait_file_name_inited)
{
cmp = Active_tranx::compare(log_file_name, log_file_pos,
wait_file_name_, wait_file_pos_);
m_wait_file_name, m_wait_file_pos);
}
else
{
@ -1097,17 +1097,17 @@ int Repl_semi_sync_master::update_sync_header(THD* thd, unsigned char *packet,
/*
* We only wait if the event is a transaction's ending event.
*/
assert(active_tranxs_ != NULL);
sync = active_tranxs_->is_tranx_end_pos(log_file_name,
assert(m_active_tranxs != NULL);
sync = m_active_tranxs->is_tranx_end_pos(log_file_name,
log_file_pos);
}
}
else
{
if (commit_file_name_inited_)
if (m_commit_file_name_inited)
{
int cmp = Active_tranx::compare(log_file_name, log_file_pos,
commit_file_name_, commit_file_pos_);
m_commit_file_name, m_commit_file_pos);
sync = (cmp >= 0);
}
else
@ -1151,35 +1151,35 @@ int Repl_semi_sync_master::write_tranx_in_binlog(const char* log_file_name,
/* Update the 'largest' transaction commit position seen so far even
* though semi-sync is switched off.
* It is much better that we update commit_file_* here, instead of
* It is much better that we update m_commit_file* here, instead of
* inside commit_trx(). This is mostly because update_sync_header()
* will watch for commit_file_* to decide whether to switch semi-sync
* will watch for m_commit_file* to decide whether to switch semi-sync
* on. The detailed reason is explained in function update_sync_header().
*/
if (commit_file_name_inited_)
if (m_commit_file_name_inited)
{
int cmp = Active_tranx::compare(log_file_name, log_file_pos,
commit_file_name_, commit_file_pos_);
m_commit_file_name, m_commit_file_pos);
if (cmp > 0)
{
/* This is a larger position, let's update the maximum info. */
strncpy(commit_file_name_, log_file_name, FN_REFLEN-1);
commit_file_name_[FN_REFLEN-1] = 0; /* make sure it ends properly */
commit_file_pos_ = log_file_pos;
strncpy(m_commit_file_name, log_file_name, FN_REFLEN-1);
m_commit_file_name[FN_REFLEN-1] = 0; /* make sure it ends properly */
m_commit_file_pos = log_file_pos;
}
}
else
{
strncpy(commit_file_name_, log_file_name, FN_REFLEN-1);
commit_file_name_[FN_REFLEN-1] = 0; /* make sure it ends properly */
commit_file_pos_ = log_file_pos;
commit_file_name_inited_ = true;
strncpy(m_commit_file_name, log_file_name, FN_REFLEN-1);
m_commit_file_name[FN_REFLEN-1] = 0; /* make sure it ends properly */
m_commit_file_pos = log_file_pos;
m_commit_file_name_inited = true;
}
if (is_on())
{
assert(active_tranxs_ != NULL);
if(active_tranxs_->insert_tranx_node(log_file_name, log_file_pos))
assert(m_active_tranxs != NULL);
if(m_active_tranxs->insert_tranx_node(log_file_name, log_file_pos))
{
/*
if insert tranx_node failed, print a warning message
@ -1254,13 +1254,13 @@ int Repl_semi_sync_master::after_reset_master()
if (rpl_semi_sync_master_clients == 0 &&
!rpl_semi_sync_master_wait_no_slave)
state_ = 0;
m_state = 0;
else
state_ = get_master_enabled()? 1 : 0;
m_state = get_master_enabled()? 1 : 0;
wait_file_name_inited_ = false;
reply_file_name_inited_ = false;
commit_file_name_inited_ = false;
m_wait_file_name_inited = false;
m_reply_file_name_inited = false;
m_commit_file_name_inited = false;
rpl_semi_sync_master_yes_transactions = 0;
rpl_semi_sync_master_no_transactions = 0;
@ -1306,7 +1306,7 @@ void Repl_semi_sync_master::set_export_stats()
{
lock();
rpl_semi_sync_master_status = state_;
rpl_semi_sync_master_status = m_state;
rpl_semi_sync_master_avg_trx_wait_time=
((rpl_semi_sync_master_trx_wait_num) ?
(ulong)((double)rpl_semi_sync_master_trx_wait_time /

88
sql/semisync_master.h
View file

@ -28,10 +28,10 @@ extern PSI_cond_key key_COND_binlog_send;
#endif
struct Tranx_node {
char log_name_[FN_REFLEN];
my_off_t log_pos_;
struct Tranx_node *next_; /* the next node in the sorted list */
struct Tranx_node *hash_next_; /* the next node during hash collision */
char log_name[FN_REFLEN];
my_off_t log_pos;
struct Tranx_node *next; /* the next node in the sorted list */
struct Tranx_node *hash_next; /* the next node during hash collision */
};
/**
@ -123,10 +123,10 @@ public:
}
trx_node= &(current_block->nodes[++last_node]);
trx_node->log_name_[0] = '\0';
trx_node->log_pos_= 0;
trx_node->next_= 0;
trx_node->hash_next_= 0;
trx_node->log_name[0] = '\0';
trx_node->log_pos= 0;
trx_node->next= 0;
trx_node->hash_next= 0;
return trx_node;
}
@ -299,14 +299,14 @@ class Active_tranx
:public Trace {
private:
Tranx_node_allocator allocator_;
Tranx_node_allocator m_allocator;
/* These two record the active transaction list in sort order. */
Tranx_node *trx_front_, *trx_rear_;
Tranx_node *m_trx_front, *m_trx_rear;
Tranx_node **trx_htb_; /* A hash table on active transactions. */
Tranx_node **m_trx_htb; /* A hash table on active transactions. */
int num_entries_; /* maximum hash table entries */
mysql_mutex_t *lock_; /* mutex lock */
int m_num_entries; /* maximum hash table entries */
mysql_mutex_t *m_lock; /* mutex lock */
inline void assert_lock_owner();
@ -316,16 +316,16 @@ private:
int compare(const char *log_file_name1, my_off_t log_file_pos1,
const Tranx_node *node2) {
return compare(log_file_name1, log_file_pos1,
node2->log_name_, node2->log_pos_);
node2->log_name, node2->log_pos);
}
int compare(const Tranx_node *node1,
const char *log_file_name2, my_off_t log_file_pos2) {
return compare(node1->log_name_, node1->log_pos_,
return compare(node1->log_name, node1->log_pos,
log_file_name2, log_file_pos2);
}
int compare(const Tranx_node *node1, const Tranx_node *node2) {
return compare(node1->log_name_, node1->log_pos_,
node2->log_name_, node2->log_pos_);
return compare(node1->log_name, node1->log_pos,
node2->log_name, node2->log_pos);
}
public:
@ -369,11 +369,11 @@ public:
class Repl_semi_sync_master
:public Repl_semi_sync_base {
private:
Active_tranx *active_tranxs_; /* active transaction list: the list will
Active_tranx *m_active_tranxs; /* active transaction list: the list will
be cleared when semi-sync switches off. */
/* True when init_object has been called */
bool init_done_;
bool m_init_done;
/* This cond variable is signaled when enough binlog has been sent to slave,
* so that a waiting trx can return the 'ok' to the client for a commit.
@ -383,32 +383,32 @@ class Repl_semi_sync_master
/* Mutex that protects the following state variables and the active
* transaction list.
* Under no cirumstances we can acquire mysql_bin_log.LOCK_log if we are
* already holding LOCK_binlog_ because it can cause deadlocks.
* already holding m_LOCK_binlog because it can cause deadlocks.
*/
mysql_mutex_t LOCK_binlog;
/* This is set to true when reply_file_name_ contains meaningful data. */
bool reply_file_name_inited_;
/* This is set to true when m_reply_file_name contains meaningful data. */
bool m_reply_file_name_inited;
/* The binlog name up to which we have received replies from any slaves. */
char reply_file_name_[FN_REFLEN];
char m_reply_file_name[FN_REFLEN];
/* The position in that file up to which we have the reply from any slaves. */
my_off_t reply_file_pos_;
my_off_t m_reply_file_pos;
/* This is set to true when we know the 'smallest' wait position. */
bool wait_file_name_inited_;
bool m_wait_file_name_inited;
/* NULL, or the 'smallest' filename that a transaction is waiting for
* slave replies.
*/
char wait_file_name_[FN_REFLEN];
char m_wait_file_name[FN_REFLEN];
/* The smallest position in that file that a trx is waiting for: the trx
* can proceed and send an 'ok' to the client when the master has got the
* reply from the slave indicating that it already got the binlog events.
*/
my_off_t wait_file_pos_;
my_off_t m_wait_file_pos;
/* This is set to true when we know the 'largest' transaction commit
* position in the binlog file.
@ -417,22 +417,22 @@ class Repl_semi_sync_master
* switch off. Binlog-dump thread can use the three fields to detect when
* slaves catch up on replication so that semi-sync can switch on again.
*/
bool commit_file_name_inited_;
bool m_commit_file_name_inited;
/* The 'largest' binlog filename that a commit transaction is seeing. */
char commit_file_name_[FN_REFLEN];
char m_commit_file_name[FN_REFLEN];
/* The 'largest' position in that file that a commit transaction is seeing. */
my_off_t commit_file_pos_;
my_off_t m_commit_file_pos;
/* All global variables which can be set by parameters. */
volatile bool master_enabled_; /* semi-sync is enabled on the master */
unsigned long wait_timeout_; /* timeout period(ms) during tranx wait */
volatile bool m_master_enabled; /* semi-sync is enabled on the master */
unsigned long m_wait_timeout; /* timeout period(ms) during tranx wait */
bool state_; /* whether semi-sync is switched */
bool m_state; /* whether semi-sync is switched */
/*Waiting for ACK before/after innodb commit*/
ulong wait_point_;
ulong m_wait_point;
void lock();
void unlock();
@ -441,11 +441,11 @@ class Repl_semi_sync_master
/* Is semi-sync replication on? */
bool is_on() {
return (state_);
return (m_state);
}
void set_master_enabled(bool enabled) {
master_enabled_ = enabled;
m_master_enabled = enabled;
}
/* Switch semi-sync off because of timeout in transaction waiting. */
@ -462,28 +462,28 @@ class Repl_semi_sync_master
void cleanup();
bool get_master_enabled() {
return master_enabled_;
return m_master_enabled;
}
void set_trace_level(unsigned long trace_level) {
trace_level_ = trace_level;
if (active_tranxs_)
active_tranxs_->trace_level_ = trace_level;
m_trace_level = trace_level;
if (m_active_tranxs)
m_active_tranxs->m_trace_level = trace_level;
}
/* Set the transaction wait timeout period, in milliseconds. */
void set_wait_timeout(unsigned long wait_timeout) {
wait_timeout_ = wait_timeout;
m_wait_timeout = wait_timeout;
}
/*set the ACK point, after binlog sync or after transaction commit*/
void set_wait_point(unsigned long ack_point)
{
wait_point_ = ack_point;
m_wait_point = ack_point;
}
ulong wait_point() //no cover line
{
return wait_point_; //no cover line
return m_wait_point; //no cover line
}
/* Initialize this class after MySQL parameters are initialized. this
@ -549,7 +549,7 @@ class Repl_semi_sync_master
/*Wait after the transaction is rollback*/
int wait_after_rollback(THD *thd, bool all);
/*Store the current binlog position in active_tranxs_. This position should
/*Store the current binlog position in m_active_tranxs. This position should
* be acked by slave*/
int report_binlog_update(THD *thd, const char *log_file,my_off_t log_pos);

2
sql/semisync_master_ack_receiver.h
View file

@ -78,7 +78,7 @@ public:
void set_trace_level(unsigned long trace_level)
{
trace_level_= trace_level;
m_trace_level= trace_level;
}
private:
enum status {ST_UP, ST_DOWN, ST_STOPPING};

8
sql/semisync_slave.cc
View file

@ -41,7 +41,7 @@ int Repl_semi_sync_slave::init_object()
{
int result= 0;
init_done_ = true;
m_init_done = true;
/* References to the parameter works after set_options(). */
set_slave_enabled(rpl_semi_sync_slave_enabled);
@ -134,9 +134,9 @@ void Repl_semi_sync_slave::kill_connection(MYSQL *mysql)
char kill_buffer[30];
MYSQL *kill_mysql = NULL;
kill_mysql = mysql_init(kill_mysql);
mysql_options(kill_mysql, MYSQL_OPT_CONNECT_TIMEOUT, &kill_conn_timeout_);
mysql_options(kill_mysql, MYSQL_OPT_READ_TIMEOUT, &kill_conn_timeout_);
mysql_options(kill_mysql, MYSQL_OPT_WRITE_TIMEOUT, &kill_conn_timeout_);
mysql_options(kill_mysql, MYSQL_OPT_CONNECT_TIMEOUT, &m_kill_conn_timeout);
mysql_options(kill_mysql, MYSQL_OPT_READ_TIMEOUT, &m_kill_conn_timeout);
mysql_options(kill_mysql, MYSQL_OPT_WRITE_TIMEOUT, &m_kill_conn_timeout);
bool ret= (!mysql_real_connect(kill_mysql, mysql->host,
mysql->user, mysql->passwd,0, mysql->port, mysql->unix_socket, 0));

22
sql/semisync_slave.h
View file

@ -32,11 +32,11 @@ class Master_info;
class Repl_semi_sync_slave
:public Repl_semi_sync_base {
public:
Repl_semi_sync_slave() :slave_enabled_(false) {}
Repl_semi_sync_slave() :m_slave_enabled(false) {}
~Repl_semi_sync_slave() {}
void set_trace_level(unsigned long trace_level) {
trace_level_ = trace_level;
m_trace_level = trace_level;
}
/* Initialize this class after MySQL parameters are initialized. this
@ -45,23 +45,23 @@ public:
int init_object();
bool get_slave_enabled() {
return slave_enabled_;
return m_slave_enabled;
}
void set_slave_enabled(bool enabled) {
slave_enabled_ = enabled;
m_slave_enabled = enabled;
}
bool is_delay_master(){
return delay_master_;
return m_delay_master;
}
void set_delay_master(bool enabled) {
delay_master_ = enabled;
m_delay_master = enabled;
}
void set_kill_conn_timeout(unsigned int timeout) {
kill_conn_timeout_ = timeout;
m_kill_conn_timeout = timeout;
}
/* A slave reads the semi-sync packet header and separate the metadata
@ -95,10 +95,10 @@ public:
private:
/* True when init_object has been called */
bool init_done_;
bool slave_enabled_; /* semi-sycn is enabled on the slave */
bool delay_master_;
unsigned int kill_conn_timeout_;
bool m_init_done;
bool m_slave_enabled; /* semi-sycn is enabled on the slave */
bool m_delay_master;
unsigned int m_kill_conn_timeout;
};