mirror of
https://github.com/Alexays/Waybar.git
synced 2026-04-02 12:54:41 +00:00
4c71b2bf9f
- Replaced pass-by-value std::string parameters with const std::string& or std::string_view to prevent SSO overallocations. - Refactored static mapping functions in UPower to return std::string_view instead of constructing std::string literals, enabling perfect cache locality. - Optimized string concatenation in hot loops (network IPs, inhibitor lists, sway window marks) by using std::string::append() and pre-reserving capacity instead of overloaded operator+ which produces temporary heap instances. These optimizations reduce high-frequency memory churn and overall heap fragmentation within the main rendering loops. Signed-off-by: Austin Horstman <khaneliman12@gmail.com>
101 lines
2.7 KiB
C++
101 lines
2.7 KiB
C++
#pragma once
|
|
|
|
#include <glibmm/dispatcher.h>
|
|
#include <sigc++/signal.h>
|
|
|
|
#include <cstddef>
|
|
#include <functional>
|
|
#include <mutex>
|
|
#include <queue>
|
|
#include <thread>
|
|
#include <tuple>
|
|
#include <type_traits>
|
|
#include <utility>
|
|
|
|
#ifdef __OpenBSD__
|
|
#define SIGRTMIN SIGUSR1 - 1
|
|
#define SIGRTMAX SIGUSR1 + 1
|
|
#endif
|
|
|
|
namespace waybar {
|
|
|
|
/**
|
|
* Thread-safe signal wrapper.
|
|
* Uses Glib::Dispatcher to pass events to another thread and locked queue to pass the arguments.
|
|
*/
|
|
template <typename... Args>
|
|
struct SafeSignal : sigc::signal<void(std::decay_t<Args>...)> {
|
|
public:
|
|
SafeSignal() { dp_.connect(sigc::mem_fun(*this, &SafeSignal::handle_event)); }
|
|
|
|
void set_max_queued_events(std::size_t max_queued_events) {
|
|
std::unique_lock lock(mutex_);
|
|
max_queued_events_ = max_queued_events;
|
|
trim_queue_locked();
|
|
}
|
|
|
|
template <typename... EmitArgs>
|
|
void emit(EmitArgs&&... args) {
|
|
if (main_tid_ == std::this_thread::get_id()) {
|
|
/*
|
|
* Bypass the queue if the method is called the main thread.
|
|
* Ensures that events emitted from the main thread are processed synchronously and saves a
|
|
* few CPU cycles on locking/queuing.
|
|
* As a downside, this makes main thread events prioritized over the other threads and
|
|
* disrupts chronological order.
|
|
*/
|
|
signal_t::emit(std::forward<EmitArgs>(args)...);
|
|
} else {
|
|
{
|
|
std::unique_lock lock(mutex_);
|
|
if (max_queued_events_ != 0 && queue_.size() >= max_queued_events_) {
|
|
queue_.pop();
|
|
}
|
|
queue_.emplace(std::forward<EmitArgs>(args)...);
|
|
}
|
|
dp_.emit();
|
|
}
|
|
}
|
|
|
|
template <typename... EmitArgs>
|
|
inline void operator()(EmitArgs&&... args) {
|
|
emit(std::forward<EmitArgs>(args)...);
|
|
}
|
|
|
|
protected:
|
|
using signal_t = sigc::signal<void(std::decay_t<Args>...)>;
|
|
using slot_t = decltype(std::declval<signal_t>().make_slot());
|
|
using arg_tuple_t = std::tuple<std::decay_t<Args>...>;
|
|
// ensure that unwrapped methods are not accessible
|
|
using signal_t::emit_reverse;
|
|
using signal_t::make_slot;
|
|
|
|
void trim_queue_locked() {
|
|
if (max_queued_events_ == 0) {
|
|
return;
|
|
}
|
|
while (queue_.size() > max_queued_events_) {
|
|
queue_.pop();
|
|
}
|
|
}
|
|
|
|
void handle_event() {
|
|
for (std::unique_lock lock(mutex_); !queue_.empty(); lock.lock()) {
|
|
auto args = queue_.front();
|
|
queue_.pop();
|
|
lock.unlock();
|
|
std::apply(cached_fn_, args);
|
|
}
|
|
}
|
|
|
|
Glib::Dispatcher dp_;
|
|
std::mutex mutex_;
|
|
std::queue<arg_tuple_t> queue_;
|
|
std::size_t max_queued_events_ = 4096;
|
|
const std::thread::id main_tid_ = std::this_thread::get_id();
|
|
// cache functor for signal emission to avoid recreating it on each event
|
|
const slot_t cached_fn_ = make_slot();
|
|
};
|
|
|
|
} // namespace waybar
|