Performance improvements

src/lib/rls/rls_pdu.cpp

@@ -13,43 +13,54 @@
 namespace rls
 {
 
-void EncodeRlsMessage(const RlsMessage &msg, OctetString &stream)
+int EncodeRlsMessage(const RlsMessage &msg, uint8_t *buffer)
 {
-    stream.appendOctet(0x03); // (Just for old RLS compatibility)
+    buffer[0] = 0x03; // (Just for old RLS compatibility)
+
+    buffer[1] = cons::Major;
+    buffer[2] = cons::Minor;
+    buffer[3] = cons::Patch;
+    buffer[4] = static_cast<uint8_t>(msg.msgType);
+
+    octet8::SetTo(octet8{msg.sti}, buffer + 5);
 
-    stream.appendOctet(cons::Major);
-    stream.appendOctet(cons::Minor);
-    stream.appendOctet(cons::Patch);
-    stream.appendOctet(static_cast<uint8_t>(msg.msgType));
-    stream.appendOctet8(msg.sti);
     if (msg.msgType == EMessageType::HEARTBEAT)
     {
         auto &m = (const RlsHeartBeat &)msg;
-        stream.appendOctet4(m.simPos.x);
-        stream.appendOctet4(m.simPos.y);
-        stream.appendOctet4(m.simPos.z);
+        octet4::SetTo(octet4{m.simPos.x}, buffer + 13);
+        octet4::SetTo(octet4{m.simPos.y}, buffer + 17);
+        octet4::SetTo(octet4{m.simPos.z}, buffer + 21);
+        return 25;
     }
     else if (msg.msgType == EMessageType::HEARTBEAT_ACK)
     {
         auto &m = (const RlsHeartBeatAck &)msg;
-        stream.appendOctet4(m.dbm);
+        octet4::SetTo(octet4{m.dbm}, buffer + 13);
+        return 17;
     }
     else if (msg.msgType == EMessageType::PDU_TRANSMISSION)
     {
         auto &m = (const RlsPduTransmission &)msg;
-        stream.appendOctet(static_cast<uint8_t>(m.pduType));
-        stream.appendOctet4(m.pduId);
-        stream.appendOctet4(m.payload);
-        stream.appendOctet4(m.pdu.length());
-        stream.append(m.pdu);
+        buffer[13] = static_cast<uint8_t>(m.pduType);
+        octet4::SetTo(octet4{m.pduId}, buffer + 14);
+        octet4::SetTo(octet4{m.payload}, buffer + 18);
+        octet4::SetTo(octet4{m.pdu.length()}, buffer + 22);
+        std::memcpy(buffer + 26, m.pdu.data(), static_cast<size_t>(m.pdu.length()));
+        return 26 + m.pdu.length();
     }
     else if (msg.msgType == EMessageType::PDU_TRANSMISSION_ACK)
     {
         auto &m = (const RlsPduTransmissionAck &)msg;
-        stream.appendOctet4(static_cast<uint32_t>(m.pduIds.size()));
+        octet4::SetTo(octet4{m.pduIds.size()}, buffer + 13);
+        buffer += 17;
         for (auto pduId : m.pduIds)
-            stream.appendOctet4(pduId);
+        {
+            octet4::SetTo(octet4{pduId}, buffer);
+            buffer += 4;
+        }
+        return 17 + static_cast<int>(m.pduIds.size()) * 4;
     }
+    return 0;
 }
 
 std::unique_ptr<RlsMessage> DecodeRlsMessage(const OctetView &stream)

src/lib/rls/rls_pdu.hpp

@@ -88,7 +88,7 @@ struct RlsPduTransmissionAck : RlsMessage
     }
 };
 
-void EncodeRlsMessage(const RlsMessage &msg, OctetString &stream);
+int EncodeRlsMessage(const RlsMessage &msg, uint8_t *buffer);
 std::unique_ptr<RlsMessage> DecodeRlsMessage(const OctetView &stream);
 
 } // namespace rls
\ No newline at end of file

src/ue/rls/udp_layer.cpp

@@ -9,6 +9,7 @@
 #include <utils/common.hpp>
 #include <utils/constants.hpp>
 
+static constexpr const int SEND_BUFFER = 16384;
 static constexpr const int LOOP_PERIOD = 1000;
 static constexpr const int HEARTBEAT_THRESHOLD = 2000; // (LOOP_PERIOD + RECEIVE_TIMEOUT)'dan büyük olmalı
 
@@ -16,7 +17,8 @@ namespace nr::ue
 {
 
 RlsUdpLayer::RlsUdpLayer(TaskBase *base)
-    : m_base{base}, m_server{}, m_searchSpace{}, m_cells{}, m_cellIdToSti{}, m_lastLoop{}, m_cellIdCounter{}
+    : m_base{base}, m_sendBuffer{new uint8_t[SEND_BUFFER]}, m_server{}, m_searchSpace{}, m_cells{}, m_cellIdToSti{},
+      m_lastLoop{}, m_cellIdCounter{}
 {
     m_logger = base->logBase->makeUniqueLogger(base->config->getLoggerPrefix() + "rls-udp");
 
@@ -49,10 +51,8 @@ void RlsUdpLayer::onQuit()
 
 void RlsUdpLayer::sendRlsPdu(const InetAddress &address, const rls::RlsMessage &msg)
 {
-    OctetString stream;
-    rls::EncodeRlsMessage(msg, stream);
-
-    m_server->send(address, stream);
+    int n = rls::EncodeRlsMessage(msg, m_sendBuffer.get());
+    m_server->send(address, m_sendBuffer.get(), static_cast<size_t>(n));
 }
 
 void RlsUdpLayer::send(int cellId, const rls::RlsMessage &msg)

src/ue/rls/udp_layer.hpp

@@ -35,6 +35,7 @@ class RlsUdpLayer
   private:
     TaskBase *m_base;
     std::unique_ptr<Logger> m_logger;
+    std::unique_ptr<uint8_t[]> m_sendBuffer;
     std::unique_ptr<udp::UdpServerTask> m_server;
     std::vector<InetAddress> m_searchSpace;
     std::unordered_map<uint64_t, CellInfo> m_cells;

src/utils/octet.hpp

@@ -168,6 +168,10 @@ struct octet4
     {
     }
 
+    inline explicit octet4(size_t value) noexcept : value(static_cast<uint32_t>(value))
+    {
+    }
+
     inline octet4(uint8_t octet0, uint8_t octet1, uint8_t octet2, uint8_t octet3) noexcept
         : value{(static_cast<uint32_t>(octet0) << 24U) | (static_cast<uint32_t>(octet1) << 16U) |
                 ((static_cast<uint32_t>(octet2) << 8U)) | (static_cast<uint32_t>(octet3))}

src/utils/octet_string.hpp

@@ -12,6 +12,7 @@
 
 #include <cstddef>
 #include <cstdint>
+#include <cstring>
 #include <memory>
 #include <vector>
 #include <array>