mirror of
https://github.com/MariaDB/server.git
synced 2026-10-23 18:49:29 +03:00
fa4f6a6194
When calling buf_flush_ahead() with furious=false, the function updates the async target buf_flush_async_lsn and, if necessary notifies the page cleaner thread to start flushing more eagerly, to avoid a long stall later when checkpoint will be required. When many threads call buf_flush_ahead() with furious=false, if the update of buf_flush_async_lsn is gated inside buf_pool.flush_list_mutex, this can cause significant contention, just to deliver the new buf_flush_async_lsn value and a potential notification to the page cleaner thread. This commit enables, for the non furious case, lock-free update of buf_flush_async_lsn and lock-free check of the page cleaner idle flag, to avoid the contention on buf_pool.flush_list_mutex. The lock is acquired by the CAS-loop winner thread and only after the page cleaner is observed idle. The cleaner clears buf_flush_async_lsn via CAS, so a concurrent lock-free bump is preserved across the clear. Since the reads are not protected by the mutex, there is a chance that the decision to not signal the page cleaner thread is wrong. In the worst case though, under sustained redo-log pressure, eventually a wakeup signal will be delivered to the page cleaner thread anyway, so the risk of a long stall is limited. Similar reasoning applies to the possibly wrong decision taken by the page cleaner thread to go to idle: eventually it will be woken up.
74 lines
3.2 KiB
C++
74 lines
3.2 KiB
C++
/* Copyright (c) 2020, 2021, MariaDB
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; version 2 of the License.
|
|
|
|
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 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-1335 USA */
|
|
|
|
#pragma once
|
|
#ifdef __cplusplus
|
|
#include <atomic>
|
|
/**
|
|
A wrapper for std::atomic, defaulting to std::memory_order_relaxed.
|
|
|
|
When it comes to atomic loads or stores at std::memory_order_relaxed
|
|
on IA-32 or AMD64, this wrapper is only introducing some constraints
|
|
to the C++ compiler, to prevent some optimizations of loads or
|
|
stores.
|
|
|
|
On POWER and ARM, atomic loads and stores involve different instructions
|
|
from normal loads and stores and will thus incur some overhead.
|
|
|
|
Because atomic read-modify-write operations will always incur
|
|
overhead, we intentionally do not define
|
|
operator++(), operator--(), operator+=(), operator-=(), or similar,
|
|
to make the overhead stand out in the users of this code.
|
|
*/
|
|
template <typename Type> class Atomic_relaxed
|
|
{
|
|
std::atomic<Type> m;
|
|
public:
|
|
Atomic_relaxed(const Atomic_relaxed<Type> &rhs)
|
|
{ m.store(rhs, std::memory_order_relaxed); }
|
|
Atomic_relaxed(Type val) : m(val) {}
|
|
Atomic_relaxed() = default;
|
|
|
|
Type load(std::memory_order o= std::memory_order_relaxed) const
|
|
{ return m.load(o); }
|
|
void store(Type i, std::memory_order o= std::memory_order_relaxed)
|
|
{ m.store(i, o); }
|
|
operator Type() const { return m.load(); }
|
|
Type operator=(const Type i) { store(i); return i; }
|
|
Type operator=(const Atomic_relaxed<Type> &rhs) { return *this= Type{rhs}; }
|
|
Type operator+=(const Type i) { return fetch_add(i); }
|
|
Type fetch_add(const Type i, std::memory_order o= std::memory_order_relaxed)
|
|
{ return m.fetch_add(i, o); }
|
|
Type fetch_sub(const Type i, std::memory_order o= std::memory_order_relaxed)
|
|
{ return m.fetch_sub(i, o); }
|
|
Type fetch_xor(const Type i, std::memory_order o= std::memory_order_relaxed)
|
|
{ return m.fetch_xor(i, o); }
|
|
Type fetch_and(const Type i, std::memory_order o= std::memory_order_relaxed)
|
|
{ return m.fetch_and(i, o); }
|
|
Type fetch_or(const Type i, std::memory_order o= std::memory_order_relaxed)
|
|
{ return m.fetch_or(i, o); }
|
|
bool compare_exchange_strong(Type& i1, const Type i2,
|
|
std::memory_order o1= std::memory_order_relaxed,
|
|
std::memory_order o2= std::memory_order_relaxed)
|
|
{ return m.compare_exchange_strong(i1, i2, o1, o2); }
|
|
bool compare_exchange_weak(Type& i1, const Type i2,
|
|
std::memory_order o1= std::memory_order_relaxed,
|
|
std::memory_order o2= std::memory_order_relaxed)
|
|
{ return m.compare_exchange_weak(i1, i2, o1, o2); }
|
|
Type exchange(const Type i, std::memory_order o= std::memory_order_relaxed)
|
|
{ return m.exchange(i, o); }
|
|
};
|
|
#endif /* __cplusplus */
|