Narrowing conversion fixes

src/gnb/gtp/utils.cpp

@@ -78,16 +78,16 @@ TokenBucket::TokenBucket(long byteCapacity) : byteCapacity(byteCapacity)
     }
 }
 
-bool TokenBucket::tryConsume(int64_t numberTokens)
+bool TokenBucket::tryConsume(uint64_t numberTokens)
 {
     if (byteCapacity > 0)
     {
         refill();
-        if (availableTokens < numberTokens)
+        if (availableTokens < static_cast<double>(numberTokens))
             return false;
         else
         {
-            availableTokens -= numberTokens;
+            availableTokens -= static_cast<double>(numberTokens);
             return true;
         }
     }
@@ -95,7 +95,7 @@ bool TokenBucket::tryConsume(int64_t numberTokens)
         return true;
 }
 
-void TokenBucket::updateCapacity(int64_t newByteCapacity)
+void TokenBucket::updateCapacity(uint64_t newByteCapacity)
 {
     byteCapacity = newByteCapacity;
     if (newByteCapacity > 0)
@@ -108,13 +108,13 @@ void TokenBucket::refill()
     if (currentTimeMillis > lastRefillTimestamp)
     {
         int64_t millisSinceLastRefill = currentTimeMillis - lastRefillTimestamp;
-        double refill = millisSinceLastRefill * refillTokensPerOneMillis;
+        double refill = static_cast<double>(millisSinceLastRefill) * refillTokensPerOneMillis;
         availableTokens = std::min(static_cast<double>(byteCapacity), availableTokens + refill);
         lastRefillTimestamp = currentTimeMillis;
     }
 }
 
-bool RateLimiter::allowDownlinkPacket(uint64_t pduSession, int64_t packetSize)
+bool RateLimiter::allowDownlinkPacket(uint64_t pduSession, uint64_t packetSize)
 {
     int ueId = GetUeId(pduSession);
 
@@ -135,7 +135,7 @@ bool RateLimiter::allowDownlinkPacket(uint64_t pduSession, int64_t packetSize)
     return true;
 }
 
-bool RateLimiter::allowUplinkPacket(uint64_t pduSession, int64_t packetSize)
+bool RateLimiter::allowUplinkPacket(uint64_t pduSession, uint64_t packetSize)
 {
     int ueId = GetUeId(pduSession);
 
@@ -156,7 +156,7 @@ bool RateLimiter::allowUplinkPacket(uint64_t pduSession, int64_t packetSize)
     return true;
 }
 
-void RateLimiter::updateUeUplinkLimit(int ueId, int64_t limit)
+void RateLimiter::updateUeUplinkLimit(int ueId, uint64_t limit)
 {
     if (limit <= 0)
     {
@@ -175,7 +175,7 @@ void RateLimiter::updateUeUplinkLimit(int ueId, int64_t limit)
     }
 }
 
-void RateLimiter::updateUeDownlinkLimit(int ueId, int64_t limit)
+void RateLimiter::updateUeDownlinkLimit(int ueId, uint64_t limit)
 {
     if (limit <= 0)
     {
@@ -194,7 +194,7 @@ void RateLimiter::updateUeDownlinkLimit(int ueId, int64_t limit)
     }
 }
 
-void RateLimiter::updateSessionUplinkLimit(uint64_t pduSession, int64_t limit)
+void RateLimiter::updateSessionUplinkLimit(uint64_t pduSession, uint64_t limit)
 {
     if (limit <= 0)
     {
@@ -213,7 +213,7 @@ void RateLimiter::updateSessionUplinkLimit(uint64_t pduSession, int64_t limit)
     }
 }
 
-void RateLimiter::updateSessionDownlinkLimit(uint64_t pduSession, int64_t limit)
+void RateLimiter::updateSessionDownlinkLimit(uint64_t pduSession, uint64_t limit)
 {
     if (limit <= 0)
     {

src/gnb/gtp/utils.hpp

@@ -32,17 +32,6 @@ inline int GetPsi(uint64_t sessionResInd)
     return static_cast<int>(sessionResInd & 0xFFFFFFFFuLL);
 }
 
-class IRateLimiter
-{
-  public:
-    virtual bool allowDownlinkPacket(uint64_t pduSession, int64_t packetSize) = 0;
-    virtual bool allowUplinkPacket(uint64_t pduSession, int64_t packetSize) = 0;
-    virtual void updateUeUplinkLimit(int ueId, int64_t limit) = 0;
-    virtual void updateUeDownlinkLimit(int ueId, int64_t limit) = 0;
-    virtual void updateSessionUplinkLimit(uint64_t pduSession, int64_t limit) = 0;
-    virtual void updateSessionDownlinkLimit(uint64_t pduSession, int64_t limit) = 0;
-};
-
 class PduSessionTree
 {
     std::unordered_map<uint32_t, uint64_t> mapByDownTeid;
@@ -61,20 +50,32 @@ class TokenBucket
 {
     static constexpr const int64_t REFILL_PERIOD = 1000L;
 
-    int64_t byteCapacity;
+    uint64_t byteCapacity;
     double refillTokensPerOneMillis;
     double availableTokens;
     int64_t lastRefillTimestamp;
 
   public:
     explicit TokenBucket(long byteCapacity);
-    bool tryConsume(int64_t numberTokens);
-    void updateCapacity(int64_t newByteCapacity);
+
+    bool tryConsume(uint64_t numberTokens);
+    void updateCapacity(uint64_t newByteCapacity);
 
   private:
     void refill();
 };
 
+class IRateLimiter
+{
+  public:
+    virtual bool allowDownlinkPacket(uint64_t pduSession, uint64_t packetSize) = 0;
+    virtual bool allowUplinkPacket(uint64_t pduSession, uint64_t packetSize) = 0;
+    virtual void updateUeUplinkLimit(int ueId, uint64_t limit) = 0;
+    virtual void updateUeDownlinkLimit(int ueId, uint64_t limit) = 0;
+    virtual void updateSessionUplinkLimit(uint64_t pduSession, uint64_t limit) = 0;
+    virtual void updateSessionDownlinkLimit(uint64_t pduSession, uint64_t limit) = 0;
+};
+
 class RateLimiter : public IRateLimiter
 {
     std::unordered_map<int, std::unique_ptr<TokenBucket>> downlinkByUe;
@@ -83,12 +84,12 @@ class RateLimiter : public IRateLimiter
     std::unordered_map<uint64_t, std::unique_ptr<TokenBucket>> uplinkBySession;
 
   public:
-    bool allowDownlinkPacket(uint64_t pduSession, int64_t packetSize) override;
-    bool allowUplinkPacket(uint64_t pduSession, int64_t packetSize) override;
-    void updateUeUplinkLimit(int ueId, int64_t limit) override;
-    void updateUeDownlinkLimit(int ueId, int64_t limit) override;
-    void updateSessionUplinkLimit(uint64_t pduSession, int64_t limit) override;
-    void updateSessionDownlinkLimit(uint64_t pduSession, int64_t limit) override;
+    bool allowDownlinkPacket(uint64_t pduSession, uint64_t packetSize) override;
+    bool allowUplinkPacket(uint64_t pduSession, uint64_t packetSize) override;
+    void updateUeUplinkLimit(int ueId, uint64_t limit) override;
+    void updateUeDownlinkLimit(int ueId, uint64_t limit) override;
+    void updateSessionUplinkLimit(uint64_t pduSession, uint64_t limit) override;
+    void updateSessionDownlinkLimit(uint64_t pduSession, uint64_t limit) override;
 };
 
 } // namespace nr::gnb