refactor engine: remove most of LOG_TRACE() from engine/

This is to avoid the cost of a no-op `LOG_TRACE` on hot paths.
commit_hash:c9b52bd7a6bdec6feb62e10a152dfc7a2a795c76

Author: koshkovka

core/src/engine/ev/thread.cpp

@@ -161,7 +161,6 @@ void Thread::UpdateTimersWatcher(struct ev_loop* loop, ev_timer*, int) noexcept
 
 void Thread::UpdateLoopWatcherImpl() {
     while (AsyncPayloadBase* payload = func_queue_.TryPopBlocking()) {
-        LOG_TRACE() << "Thread::UpdateLoopWatcherImpl(), " << compiler::GetTypeName(typeid(*payload));
         try {
             payload->PerformAndRelease();
         } catch (const std::exception& ex) {

core/src/engine/ev/watcher/async_watcher.cpp

@@ -35,11 +35,7 @@ void AsyncWatcher::OnEvent(struct ev_loop*, ev_async* async, int events) noexcep
 
 void AsyncWatcher::Send() { ev_async_.Send(); }
 
-void AsyncWatcher::CallCb() {
-    LOG_TRACE() << "CallCb (1) watcher=" << this;
-
-    cb_();
-}
+void AsyncWatcher::CallCb() { cb_(); }
 
 }  // namespace engine::ev
 

core/src/engine/ev/watcher/io_watcher.cpp

@@ -104,11 +104,8 @@ void IoWatcher::CallWriteCb(std::error_code ec) {
 }
 
 void IoWatcher::Cancel() {
-    LOG_TRACE() << "IoWatcher::Cancel (1)";
     CancelSingle(watcher_write_, cb_write_);
-    LOG_TRACE() << "IoWatcher::Cancel (2)";
     CancelSingle(watcher_read_, cb_read_);
-    LOG_TRACE() << "IoWatcher::Cancel (3)";
 }
 
 void IoWatcher::CancelSingle(Watcher<ev_io>& watcher, Callback& cb) {

core/src/engine/ev/watcher/timer_watcher.cpp

@@ -16,7 +16,6 @@ TimerWatcher::TimerWatcher(ThreadControl& thread_control)
 TimerWatcher::~TimerWatcher() { Cancel(); }
 
 void TimerWatcher::SingleshotAsync(std::chrono::milliseconds timeout, Callback cb) {
-    LOG_TRACE() << "TimerWatcher::SingleshotAsync";
     Cancel();
     {
         const std::lock_guard lock{mutex_};
@@ -41,7 +40,6 @@ void TimerWatcher::OnEventTimeout(struct ev_loop*, ev_timer* timer, int events)
 }
 
 void TimerWatcher::CallTimeoutCb(std::error_code ec) {
-    LOG_TRACE() << "TimerWatcher::CallTimeoutCb  watcher=" << this;
     Callback cb;
     {
         const std::lock_guard lock{mutex_};
@@ -54,7 +52,6 @@ void TimerWatcher::CallTimeoutCb(std::error_code ec) {
 }
 
 void TimerWatcher::Cancel() {
-    LOG_TRACE() << "TimerWatcher::Cancel() (1) watcher=" << this;
     bool need_call_cb = false;
     {
         const std::lock_guard lock{mutex_};
@@ -63,12 +60,9 @@ void TimerWatcher::Cancel() {
         }
     }
     if (need_call_cb) {
-        LOG_TRACE() << "TimerWatcher::Cancel() (2) watcher=" << this;
         ev_timer_.Stop();
-        LOG_TRACE() << "TimerWatcher::Cancel() (2.1) watcher=" << this;
         CallTimeoutCb(std::make_error_code(std::errc::operation_canceled));
     }
-    LOG_TRACE() << "TimerWatcher::Cancel() (3) watcher=" << this;
 }
 
 }  // namespace engine::ev

core/src/engine/impl/wait_list_light.cpp

@@ -33,7 +33,6 @@ namespace {
 Awaiter* const kSignaled = reinterpret_cast<Awaiter*>(1);
 
 void DoNotify(AwaiterWithContext awaiter) {
-    LOG_TRACE() << "NotifyOne awaiter=" << fmt::to_string(awaiter) << " use_count=" << awaiter.awaiter->UseCount();
     impl::Notify(boost::intrusive_ptr<Awaiter>{awaiter.awaiter, /*add_ref=*/false}, awaiter.context);
 }
 
@@ -54,7 +53,6 @@ void WaitListLight::GetSignalOrAppend(boost::intrusive_ptr<Awaiter>& awaiter, st
     UASSERT(awaiter);
 
     const AwaiterWithContext new_awaiter{awaiter.get(), context};
-    LOG_TRACE() << "Append awaiter=" << fmt::to_string(new_awaiter) << " use_count=" << awaiter->UseCount();
 
     AwaiterWithContext expected{};
     // seq_cst is important for the "Append-Check-Wakeup" sequence.
@@ -122,7 +120,6 @@ void WaitListLight::Remove(Awaiter& awaiter, std::uintptr_t context) noexcept {
         return;
     }
 
-    LOG_TRACE() << "Remove awaiter=" << fmt::to_string(expected) << " use_count=" << awaiter.UseCount();
     intrusive_ptr_release(&awaiter);
 }
 

core/src/engine/single_consumer_event.cpp

@@ -45,20 +45,15 @@ bool SingleConsumerEvent::WaitForEventUntil(Deadline deadline) {
     }
 
     impl::TaskContext& current = current_task::GetCurrentTaskContext();
-    LOG_TRACE() << "WaitForEventUntil()";
     EventWaitStrategy wait_manager{*this, current};
 
     while (true) {
         if (GetIsSignaled()) {
-            LOG_TRACE() << "success";
             return true;
         }
 
-        LOG_TRACE() << "iteration()";
-
         const auto wakeup_source = current.Sleep(wait_manager, deadline);
         if (!impl::HasWaitSucceeded(wakeup_source)) {
-            LOG_TRACE() << "failure";
             return false;
         }
     }

core/src/engine/task/context_timer.cpp

@@ -135,7 +135,6 @@ void ContextTimer::Impl::DoArmTimerInEvThread() {
     using LibEvDuration = std::chrono::duration<double>;
     const auto time_left = std::chrono::duration_cast<LibEvDuration>(params_.deadline.TimeLeft()).count();
 
-    LOG_TRACE() << "time_left=" << time_left;
     if (time_left <= 0.0) {
         // Optimization for small deadlines or high load
         DoOnTimer();

core/src/engine/task/task_processor.cpp

@@ -419,8 +419,6 @@ void TaskProcessor::CheckWaitTime(impl::TaskContext& context) {
     const auto wait_timepoint = context.GetQueueWaitTimepoint();
     if (wait_timepoint != std::chrono::steady_clock::time_point()) {
         const auto wait_time = std::chrono::steady_clock::now() - wait_timepoint;
-        const auto wait_time_us = std::chrono::duration_cast<std::chrono::microseconds>(wait_time);
-        LOG_TRACE() << "queue wait time = " << wait_time_us.count() << "us";
 
         SetTaskQueueWaitTimeOverloaded(max_wait_time.count() && wait_time >= max_wait_time);