From e470a6d73ea1c01eca0b1fe8d35be016dd9f5532 Mon Sep 17 00:00:00 2001 From: Jason Rhinelander Date: Tue, 12 May 2020 16:42:35 -0300 Subject: [PATCH] C++17 niceties - class template argument deduction lets us write `std::unique_lock foo{mutex}` instead of `std::unique_lock foo{mutex}` which makes the `unique_lock` and `shared_lock` functions unnecessary. - Replace GNU-specific warn_unused_result attribute with C++17-standard [[nodiscard]] - Remove pre-C++17 workaround code for fold expressions, void_t --- llarp/nodedb.cpp | 2 +- llarp/profiling.cpp | 4 +-- llarp/router/outbound_session_maker.cpp | 4 +-- llarp/router/router.cpp | 2 +- llarp/util/meta/traits.hpp | 17 ++--------- llarp/util/str.hpp | 9 +----- llarp/util/thread/barrier.hpp | 2 +- llarp/util/thread/thread_pool.cpp | 10 +++---- llarp/util/thread/threading.hpp | 39 +++---------------------- 9 files changed, 19 insertions(+), 70 deletions(-) diff --git a/llarp/nodedb.cpp b/llarp/nodedb.cpp index dcc749ff5..719ab0414 100644 --- a/llarp/nodedb.cpp +++ b/llarp/nodedb.cpp @@ -484,7 +484,7 @@ llarp_nodedb::LoadAll() size_t llarp_nodedb::num_loaded() const { - auto l = llarp::util::shared_lock(access); + std::shared_lock l{access}; return entries.size(); } diff --git a/llarp/profiling.cpp b/llarp/profiling.cpp index 377c1cb5c..18e9e425a 100644 --- a/llarp/profiling.cpp +++ b/llarp/profiling.cpp @@ -217,7 +217,7 @@ namespace llarp bool Profiling::Save(const char* fname) { - auto lock = util::shared_lock(m_ProfilesMutex); + std::shared_lock lock{m_ProfilesMutex}; size_t sz = (m_Profiles.size() * (RouterProfile::MaxSize + 32 + 8)) + 8; std::vector tmp(sz, 0); @@ -243,7 +243,7 @@ namespace llarp bool Profiling::BEncode(llarp_buffer_t* buf) const { - auto lock = util::shared_lock(m_ProfilesMutex); + std::shared_lock lock{m_ProfilesMutex}; return BEncodeNoLock(buf); } diff --git a/llarp/router/outbound_session_maker.cpp b/llarp/router/outbound_session_maker.cpp index 10ba1d7d1..fc220d093 100644 --- a/llarp/router/outbound_session_maker.cpp +++ b/llarp/router/outbound_session_maker.cpp @@ -170,7 +170,7 @@ namespace llarp void OutboundSessionMaker::DoEstablish(const RouterID& router) { - auto l = util::unique_lock(_mutex); + std::unique_lock l{_mutex}; auto itr = pendingSessions.find(router); @@ -193,7 +193,7 @@ namespace llarp OutboundSessionMaker::GotRouterContact(const RouterID& router, const RouterContact& rc) { { - auto l = util::unique_lock(_mutex); + std::unique_lock l{_mutex}; // in case other request found RC for this router after this request was // made diff --git a/llarp/router/router.cpp b/llarp/router/router.cpp index c31fa5667..4f980c602 100644 --- a/llarp/router/router.cpp +++ b/llarp/router/router.cpp @@ -150,7 +150,7 @@ namespace llarp return true; }; - auto l = util::shared_lock(nodedb()->access); + std::shared_lock l{nodedb()->access}; return pick_router(nodedb()->entries); } diff --git a/llarp/util/meta/traits.hpp b/llarp/util/meta/traits.hpp index bfed577f7..8802c04bd 100644 --- a/llarp/util/meta/traits.hpp +++ b/llarp/util/meta/traits.hpp @@ -10,19 +10,6 @@ namespace llarp { namespace traits { -#ifdef __cpp_lib_void_t - using std::void_t; -#else - /// C++17 void_t backport - template - struct void_t_impl - { - using type = void; - }; - template - using void_t = typename void_t_impl::type; -#endif - /// Represents the empty type struct Bottom { @@ -46,7 +33,7 @@ namespace llarp // - has dereference operator // - has arrow operator template - struct is_pointy())>, void>> + struct is_pointy())>, void>> : public std::true_type { }; @@ -65,7 +52,7 @@ namespace llarp T, std::conditional_t< false, - void_t< typename T::value_type, + std::void_t< typename T::value_type, typename T::size_type, typename T::iterator, typename T::const_iterator, diff --git a/llarp/util/str.hpp b/llarp/util/str.hpp index 5a00b3f90..17d395f91 100644 --- a/llarp/util/str.hpp +++ b/llarp/util/str.hpp @@ -24,10 +24,7 @@ namespace llarp /// Trim leading and trailing (ascii) whitespace from the given string; /// returns a std::string_view of the trimmed part of the string. -#ifdef __GNUG__ - [[gnu::warn_unused_result]] -#endif - std::string_view + [[nodiscard]] std::string_view TrimWhitespace(std::string_view str); template @@ -35,11 +32,7 @@ namespace llarp stringify(T&&... stuff) { std::ostringstream o; -#ifdef __cpp_fold_expressions (o << ... << std::forward(stuff)); -#else - (void)std::initializer_list{(o << std::forward(stuff), 0)...}; -#endif return o.str(); } diff --git a/llarp/util/thread/barrier.hpp b/llarp/util/thread/barrier.hpp index f88a5d94f..bef9f467d 100644 --- a/llarp/util/thread/barrier.hpp +++ b/llarp/util/thread/barrier.hpp @@ -25,7 +25,7 @@ namespace llarp bool Block() { - std::unique_lock lock{mutex}; + std::unique_lock lock{mutex}; if (pending == 1) { pending = 0; diff --git a/llarp/util/thread/thread_pool.cpp b/llarp/util/thread/thread_pool.cpp index 99b5c04bb..86411a799 100644 --- a/llarp/util/thread/thread_pool.cpp +++ b/llarp/util/thread/thread_pool.cpp @@ -64,7 +64,7 @@ namespace llarp void ThreadPool::waitThreads() { - std::unique_lock lock(m_gateMutex); + std::unique_lock lock{m_gateMutex}; m_numThreadsCV.wait(lock, [this] { return allThreadsReady(); }); } @@ -72,7 +72,7 @@ namespace llarp ThreadPool::releaseThreads() { { - std::lock_guard lock(m_gateMutex); + std::lock_guard lock{m_gateMutex}; m_numThreadsReady = 0; ++m_gateCount; } @@ -82,7 +82,7 @@ namespace llarp void ThreadPool::interrupt() { - std::lock_guard lock(m_gateMutex); + std::lock_guard lock{m_gateMutex}; size_t count = m_idleThreads; @@ -96,14 +96,14 @@ namespace llarp ThreadPool::worker() { // Lock will be valid until the end of the statement - size_t gateCount = (std::lock_guard(m_gateMutex), m_gateCount); + size_t gateCount = (std::lock_guard{m_gateMutex}, m_gateCount); util::SetThreadName(m_name); for (;;) { { - std::unique_lock lock(m_gateMutex); + std::unique_lock lock{m_gateMutex}; ++m_numThreadsReady; m_numThreadsCV.notify_one(); diff --git a/llarp/util/thread/threading.hpp b/llarp/util/thread/threading.hpp index c1d9a5846..9f3a41a81 100644 --- a/llarp/util/thread/threading.hpp +++ b/llarp/util/thread/threading.hpp @@ -96,45 +96,14 @@ namespace llarp /// Basic RAII lock type for the default mutex type. using Lock = std::lock_guard; - /// Returns a unique lock around the given lockable (typically a mutex) - /// which gives exclusive control and is unlockable/relockable. Any extra - /// argument (e.g. std::defer_lock) is forwarded to the unique_lock - /// constructor. - template -#ifdef __GNUG__ - [[gnu::warn_unused_result]] -#endif - std::unique_lock - unique_lock(Mutex& lockable, Args&&... args) - { - return std::unique_lock(lockable, std::forward(args)...); - } - - /// Returns a shared lock around the given lockable (typically a mutex) - /// which gives "reader" access (i.e. which can be shared with other reader - /// locks but not unique locks). Any extra argument (e.g. std::defer_lock) - /// is forwarded to the std::shared_lock constructor. - template -#ifdef __GNUG__ - [[gnu::warn_unused_result]] -#endif - std::shared_lock - shared_lock(Mutex& lockable, Args&&... args) - { - return std::shared_lock(lockable, std::forward(args)...); - } - /// Obtains multiple unique locks simultaneously and atomically. Returns a /// tuple of all the held locks. template -#ifdef __GNUG__ - [[gnu::warn_unused_result]] -#endif - std::tuple...> + [[nodiscard]] auto unique_locks(Mutex&... lockables) { std::lock(lockables...); - return std::make_tuple(std::unique_lock(lockables, std::adopt_lock)...); + return std::make_tuple(std::unique_lock{lockables, std::adopt_lock}...); } class Semaphore @@ -162,7 +131,7 @@ namespace llarp void wait() EXCLUDES(m_mutex) { - auto lock = unique_lock(m_mutex); + std::unique_lock lock{m_mutex}; m_cv.wait(lock, [this] { return m_count > 0; }); m_count--; } @@ -170,7 +139,7 @@ namespace llarp bool waitFor(std::chrono::microseconds timeout) EXCLUDES(m_mutex) { - auto lock = unique_lock(m_mutex); + std::unique_lock lock{m_mutex}; if (!m_cv.wait_for(lock, timeout, [this] { return m_count > 0; })) return false;