Merge pull request #1797 from jagerman/random-optimizations

Random optimizations

llarp/ev/ev.hpp

@@ -75,11 +75,11 @@ namespace llarp
     virtual bool
     running() const = 0;
 
+    // Returns a current steady clock time value representing the current time with event loop tick
+    // granularity.  That is, the value is typically only updated at the beginning of an event loop
+    // tick.
     virtual llarp_time_t
-    time_now() const
-    {
-      return llarp::time_now_ms();
-    }
+    time_now() const = 0;
 
     // Calls a function/lambda/etc.  If invoked from within the event loop itself this calls the
     // given lambda immediately; otherwise it passes it to `call_soon()` to be queued to run at the

llarp/ev/ev_libuv.hpp

@@ -31,6 +31,12 @@ namespace llarp::uv
     bool
     running() const override;
 
+    llarp_time_t
+    time_now() const override
+    {
+      return m_Impl->now();
+    }
+
     void
     call_later(llarp_time_t delay_ms, std::function<void(void)> callback) override;
 

llarp/exit/session.cpp

@@ -137,6 +137,9 @@ namespace llarp
     void
     BaseSession::CallPendingCallbacks(bool success)
     {
+      if (m_PendingCallbacks.empty())
+        return;
+
       if (success)
       {
         auto self = shared_from_this();

llarp/iwp/session.cpp

@@ -97,9 +97,8 @@ namespace llarp
 
       m_RemoteRC = msg->rc;
       GotLIM = util::memFn(&Session::GotRenegLIM, this);
-      auto self = shared_from_this();
-      assert(self.use_count() > 1);
-      SendOurLIM([self](ILinkSession::DeliveryStatus st) {
+      assert(shared_from_this().use_count() > 1);
+      SendOurLIM([self = shared_from_this()](ILinkSession::DeliveryStatus st) {
         if (st == ILinkSession::DeliveryStatus::eDeliverySuccess)
         {
           self->m_State = State::Ready;
@@ -259,17 +258,18 @@ namespace llarp
           }
         }
       }
-      auto self = shared_from_this();
-      assert(self.use_count() > 1);
+      assert(shared_from_this().use_count() > 1);
       if (not m_EncryptNext.empty())
       {
-        m_Parent->QueueWork([self, data = m_EncryptNext] { self->EncryptWorker(data); });
+        m_Parent->QueueWork(
+            [self = shared_from_this(), data = m_EncryptNext] { self->EncryptWorker(data); });
         m_EncryptNext.clear();
       }
 
       if (not m_DecryptNext.empty())
       {
-        m_Parent->QueueWork([self, data = m_DecryptNext] { self->DecryptWorker(data); });
+        m_Parent->QueueWork(
+            [self = shared_from_this(), data = m_DecryptNext] { self->DecryptWorker(data); });
         m_DecryptNext.clear();
       }
     }