reduce number of jobs we put onto the logic thread

Makefile

@@ -16,7 +16,7 @@ BUILD_TYPE ?= Debug
 PYTHON ?= python
 PYTHON3 ?= python3
 
-FORMAT ?= clang-format
+FORMAT ?= clang-format-8
 
 SETCAP ?= which setcap && setcap cap_net_admin,cap_net_bind_service=+eip
 

llarp/handlers/tun.cpp

@@ -978,17 +978,25 @@ namespace llarp
     TunEndpoint::tunifBeforeWrite(llarp_tun_io *tun)
     {
       // called in the isolated network thread
-      auto *self   = static_cast< TunEndpoint * >(tun->user);
-      auto sendpkt = [self, tun](net::IPPacket &pkt) -> bool {
-        if(!llarp_ev_tun_async_write(tun, pkt.Buffer()))
+      auto *self      = static_cast< TunEndpoint * >(tun->user);
+      auto _pkts      = std::move(self->m_TunPkts);
+      self->m_TunPkts = std::vector< net::IPPacket >();
+
+      LogicCall(self->EndpointLogic(), [tun, self, pkts = std::move(_pkts)]() {
+        for(auto &pkt : pkts)
         {
-          llarp::LogWarn(self->Name(), " packet dropped");
-          return true;
+          self->m_UserToNetworkPktQueue.Emplace(pkt);
         }
-        return false;
-      };
-      LogicCall(self->EndpointLogic(),
-                std::bind(&TunEndpoint::FlushToUser, self, sendpkt));
+        self->Flush();
+        self->FlushToUser([self, tun](net::IPPacket &pkt) -> bool {
+          if(!llarp_ev_tun_async_write(tun, pkt.Buffer()))
+          {
+            llarp::LogWarn(self->Name(), " packet dropped");
+            return true;
+          }
+          return false;
+        });
+      });
     }
 
     void
@@ -996,14 +1004,10 @@ namespace llarp
     {
       // called for every packet read from user in isolated network thread
       auto *self = static_cast< TunEndpoint * >(tun->user);
-      std::vector< byte_t > pkt;
-      pkt.resize(b.sz);
-      std::copy_n(b.base, b.sz, pkt.data());
-      LogicCall(self->RouterLogic(), [self, buffer = std::move(pkt)]() {
-        const llarp_buffer_t pbuf(buffer);
-        self->m_UserToNetworkPktQueue.EmplaceIf(
-            [&pbuf](net::IPPacket &p) -> bool { return p.Load(pbuf); });
-      });
+      net::IPPacket pkt;
+      if(not pkt.Load(b))
+        return;
+      self->m_TunPkts.emplace_back(pkt);
     }
 
     TunEndpoint::~TunEndpoint() = default;

llarp/handlers/tun.hpp

@@ -185,6 +185,9 @@ namespace llarp
       using PacketQueue_t = llarp::util::CoDelQueue<
           net::IPPacket, net::IPPacket::GetTime, net::IPPacket::PutTime,
           net::IPPacket::CompareOrder, net::IPPacket::GetNow >;
+
+      /// queue packet for send on net thread from user
+      std::vector< net::IPPacket > m_TunPkts;
       /// queue for sending packets over the network from us
       PacketQueue_t m_UserToNetworkPktQueue;
       /// queue for sending packets to user from network

llarp/service/endpoint.cpp

@@ -1047,20 +1047,29 @@ namespace llarp
       const auto& sessions = m_state->m_SNodeSessions;
       auto& queue          = m_state->m_InboundTrafficQueue;
 
-      LogicCall(EndpointLogic(), [&]() {
+      auto epPump = [&]() {
         // send downstream packets to user for snode
         for(const auto& item : sessions)
           item.second.first->FlushDownstream();
         // send downstream traffic to user for hidden service
         util::Lock lock(&m_state->m_InboundTrafficQueueMutex);
-        while(queue.size())
+        while(not queue.empty())
         {
           const auto& msg = queue.top();
           const llarp_buffer_t buf(msg->payload);
           HandleInboundPacket(msg->tag, buf, msg->proto);
           queue.pop();
         }
-      });
+      };
+
+      if(NetworkIsIsolated())
+      {
+        LogicCall(EndpointLogic(), epPump);
+      }
+      else
+      {
+        epPump();
+      }
 
       auto router = Router();
       // TODO: locking on this container
@@ -1069,14 +1078,16 @@ namespace llarp
       // TODO: locking on this container
       for(const auto& item : sessions)
         item.second.first->FlushUpstream();
-      util::Lock lock(&m_state->m_SendQueueMutex);
-      // send outbound traffic
-      for(const auto& item : m_state->m_SendQueue)
       {
-        item.second->SendRoutingMessage(*item.first, router);
-        MarkConvoTagActive(item.first->T.T);
+        util::Lock lock(&m_state->m_SendQueueMutex);
+        // send outbound traffic
+        for(const auto& item : m_state->m_SendQueue)
+        {
+          item.second->SendRoutingMessage(*item.first, router);
+          MarkConvoTagActive(item.first->T.T);
+        }
+        m_state->m_SendQueue.clear();
       }
-      m_state->m_SendQueue.clear();
       router->PumpLL();
     }
 

llarp/service/protocol.cpp

@@ -407,11 +407,8 @@ namespace llarp
         LogError("convotag missmatch: ", T, " != ", msg->tag);
         return false;
       }
-      msg->handler            = handler;
-      const PathID_t fromPath = F;
-      LogicCall(logic, [=]() {
-        ProtocolMessage::ProcessAsync(recvPath, fromPath, msg);
-      });
+      msg->handler = handler;
+      ProtocolMessage::ProcessAsync(recvPath, F, msg);
       return true;
     }