changeset 6941:461afaee9791 streaming

added metrics for memory reservations
author Alain Mazy <am@orthanc.team>
date Wed, 10 Jun 2026 11:12:26 +0200
parents fe54bdb94d40
children 768842647d82
files OrthancFramework/Sources/DataSource/DataSourceMemoryBudget.cpp OrthancFramework/Sources/DataSource/DataSourceMemoryBudget.h OrthancFramework/Sources/DataSource/DataSourceReader.cpp OrthancFramework/Sources/DataSource/DataSourceReader.h OrthancServer/Sources/ServerContext.cpp
diffstat 5 files changed, 169 insertions(+), 15 deletions(-) [+]
line wrap: on
line diff
--- a/OrthancFramework/Sources/DataSource/DataSourceMemoryBudget.cpp	Wed Jun 10 11:05:08 2026 +0200
+++ b/OrthancFramework/Sources/DataSource/DataSourceMemoryBudget.cpp	Wed Jun 10 11:12:26 2026 +0200
@@ -25,11 +25,65 @@
 #include "../PrecompiledHeaders.h"
 #include "DataSourceMemoryBudget.h"
 
+#include "../Constants.h"
+#include "../MetricsRegistry.h"
+#include "../OrthancException.h"
+
+#include <math.h>
 
 namespace Orthanc
 {
   namespace Internals
   {
+    DataSourceMemoryBudget::MetricsConfiguration::MetricsConfiguration(const boost::shared_ptr<MetricsRegistry>& metrics,
+                                                                       const std::string& capacityMaxSizeMegabytesName,
+                                                                       const std::string& capacityCurrentSizeMegabytesName,
+                                                                       const std::string& capacityCountName,
+                                                                       const std::string& capacityMaxUsageSinceStartMegabytesName) :
+      maxMemoryUsageSinceStart_(0)
+    {
+      if (metrics.get() == NULL)
+      {
+        throw OrthancException(ErrorCode_NullPointer);
+      }
+      else if (capacityMaxSizeMegabytesName.empty() ||
+               capacityCurrentSizeMegabytesName.empty() ||
+               capacityCountName.empty() ||
+               capacityMaxUsageSinceStartMegabytesName.empty())
+      {
+        throw OrthancException(ErrorCode_ParameterOutOfRange);
+      }
+      else
+      {
+        metrics_ = metrics;
+        capacityMaxSizeMegabytesName_ = capacityMaxSizeMegabytesName;
+        capacityCurrentSizeMegabytesName_ = capacityCurrentSizeMegabytesName;
+        capacityCountName_ = capacityCountName;
+        capacityMaxUsageSinceStartMegabytesName_ = capacityMaxUsageSinceStartMegabytesName;
+
+        Update(0, 0, 0);
+      }
+    }
+
+    void DataSourceMemoryBudget::MetricsConfiguration::Update(uint64_t maximumMemorySize, uint64_t currentMemorySize, unsigned int currentReservationCount)
+    {
+      maxMemoryUsageSinceStart_ = std::max(currentMemorySize, maxMemoryUsageSinceStart_);
+
+      metrics_->SetFloatValue(capacityMaxSizeMegabytesName_, static_cast<float>(maximumMemorySize) / static_cast<float>(MEGABYTE)); // will be updated when we set the capacity
+      metrics_->SetFloatValue(capacityCurrentSizeMegabytesName_, static_cast<float>(currentMemorySize) / static_cast<float>(MEGABYTE));
+      metrics_->SetIntegerValue(capacityCountName_, currentReservationCount);
+      metrics_->SetFloatValue(capacityMaxUsageSinceStartMegabytesName_, static_cast<float>(maxMemoryUsageSinceStart_) / static_cast<float>(MEGABYTE));
+    }
+
+
+    void DataSourceMemoryBudget::SetMetricsConfiguration(const MetricsConfiguration& configuration)
+    {
+      metricsConfiguration_ = configuration;
+      
+      boost::mutex::scoped_lock lock(mutex_);
+      metricsConfiguration_.Update(maximumMemory_, currentMemory_, reservations_);
+    }
+
     DataSourceMemoryBudget::DataSourceMemoryBudget(uint64_t maximumMemory) :
       maximumMemory_(maximumMemory),
       currentMemory_(0),
@@ -50,6 +104,8 @@
 
       currentMemory_ += memory;
       reservations_++;
+      
+      metricsConfiguration_.Update(maximumMemory_, currentMemory_, reservations_);
     }
 
 
@@ -62,7 +118,9 @@
 
       assert(reservations_ > 0);
       reservations_--;
-
+      
+      metricsConfiguration_.Update(maximumMemory_, currentMemory_, reservations_);
+      
       cond_.notify_all();
     }
 
--- a/OrthancFramework/Sources/DataSource/DataSourceMemoryBudget.h	Wed Jun 10 11:05:08 2026 +0200
+++ b/OrthancFramework/Sources/DataSource/DataSourceMemoryBudget.h	Wed Jun 10 11:12:26 2026 +0200
@@ -39,25 +39,56 @@
 
 namespace Orthanc
 {
+  class MetricsRegistry;
+
   namespace Internals
   {
-    // This is basically a semaphore with the uint64_t data type
+    // This is basically a semaphore with the uint64_t data type (with metrics !)
     class ORTHANC_PUBLIC DataSourceMemoryBudget : public boost::noncopyable
     {
+    public:
+      class MetricsConfiguration
+      {
+      private:
+        boost::shared_ptr<MetricsRegistry>  metrics_;
+        std::string                         capacityMaxSizeMegabytesName_;
+        std::string                         capacityCurrentSizeMegabytesName_;
+        std::string                         capacityCountName_;
+        std::string                         capacityMaxUsageSinceStartMegabytesName_;
+        uint64_t                            maxMemoryUsageSinceStart_;
+
+      public:
+        MetricsConfiguration()
+        {
+        }
+
+        MetricsConfiguration(const boost::shared_ptr<MetricsRegistry>& metrics,
+                             const std::string& capacityMaxSizeMegabytesName,
+                             const std::string& capacityCurrentSizeMegabytesName,
+                             const std::string& capacityCountName,
+                             const std::string& capacityMaxUsageSinceStartMegabytesName);
+
+        void Update(uint64_t maximumMemorySize, uint64_t currentMemorySize, unsigned int currentReservationCount);
+      };
+
+
     private:
       boost::mutex               mutex_;
       boost::condition_variable  cond_;
       const uint64_t             maximumMemory_;
       uint64_t                   currentMemory_;
       unsigned int               reservations_;
+      MetricsConfiguration       metricsConfiguration_;
 
     public:
-      explicit DataSourceMemoryBudget(uint64_t maximumMemory);
+      explicit DataSourceMemoryBudget(uint64_t maximumMemory); //, const MetricsConfiguration& metricsConfiguration);
 
       void Acquire(size_t memory) ORTHANC_NOEXCEPT;
 
       void Release(size_t memory) ORTHANC_NOEXCEPT;
 
+      void SetMetricsConfiguration(const MetricsConfiguration& configuration);
+
       uint64_t GetCurrentMemory() ORTHANC_NOEXCEPT;
 
       class ORTHANC_PUBLIC Lock : public boost::noncopyable
--- a/OrthancFramework/Sources/DataSource/DataSourceReader.cpp	Wed Jun 10 11:05:08 2026 +0200
+++ b/OrthancFramework/Sources/DataSource/DataSourceReader.cpp	Wed Jun 10 11:12:26 2026 +0200
@@ -42,7 +42,11 @@
                                                                const std::string& cacheSizeMegabytesName,
                                                                const std::string& cacheCountName,
                                                                const std::string& cacheHitCountName,
-                                                               const std::string& cacheMissCountName)
+                                                               const std::string& cacheMissCountName,
+                                                               const std::string& capacityMaxSizeMegabytesName,
+                                                               const std::string& capacityCurrentSizeMegabytesName,
+                                                               const std::string& capacityCountName,
+                                                               const std::string& capacityMaxUsageSinceStartMegabytesName)
   {
     if (metrics.get() == NULL)
     {
@@ -51,7 +55,11 @@
     else if (cacheSizeMegabytesName.empty() ||
              cacheCountName.empty() ||
              cacheHitCountName.empty() ||
-             cacheMissCountName.empty())
+             cacheMissCountName.empty() || 
+             capacityMaxSizeMegabytesName.empty() ||
+             capacityCurrentSizeMegabytesName.empty() ||
+             capacityCountName.empty() ||
+             capacityMaxUsageSinceStartMegabytesName.empty())
     {
       throw OrthancException(ErrorCode_ParameterOutOfRange);
     }
@@ -62,11 +70,19 @@
       cacheCountName_ = cacheCountName;
       cacheHitCountName_ = cacheHitCountName;
       cacheMissCountName_ = cacheMissCountName;
+      capacityMaxSizeMegabytesName_ = capacityMaxSizeMegabytesName;
+      capacityCurrentSizeMegabytesName_ = capacityCurrentSizeMegabytesName;
+      capacityCountName_ = capacityCountName;
+      capacityMaxUsageSinceStartMegabytesName_ = capacityMaxUsageSinceStartMegabytesName;
 
       metrics_->SetFloatValue(cacheSizeMegabytesName_, 0);
       metrics_->SetIntegerValue(cacheCountName_, 0);
       metrics_->SetIntegerValue(cacheHitCountName_, 0);
       metrics_->SetIntegerValue(cacheMissCountName_, 0);
+      metrics_->SetFloatValue(capacityMaxSizeMegabytesName_, 0); // will be updated when we set the capacity
+      metrics_->SetFloatValue(capacityCurrentSizeMegabytesName_, 0);
+      metrics_->SetIntegerValue(capacityCountName_, 0);
+      metrics_->SetFloatValue(capacityMaxUsageSinceStartMegabytesName_, 0);
     }
   }
 
@@ -273,10 +289,28 @@
     cache_ = boost::make_shared<SharedObjectCache>(capacity);
   }
 
+  void DataSourceReader::SetMetricsConfiguration(const MetricsConfiguration& configuration)
+  {
+    metricsConfiguration_ = configuration;
+    if (budget_.get())
+    {
+      budget_->SetMetricsConfiguration(Internals::DataSourceMemoryBudget::MetricsConfiguration(configuration.metrics_,
+                                                                                               configuration.capacityMaxSizeMegabytesName_,
+                                                                                               configuration.capacityCurrentSizeMegabytesName_,
+                                                                                               configuration.capacityCountName_,
+                                                                                               configuration.capacityMaxUsageSinceStartMegabytesName_));
+    }
+  }
+
 
   void DataSourceReader::SetCapacity(uint64_t maximumMemory)
   {
     budget_ = boost::make_shared<Internals::DataSourceMemoryBudget>(maximumMemory);
+    budget_->SetMetricsConfiguration(Internals::DataSourceMemoryBudget::MetricsConfiguration(metricsConfiguration_.metrics_,
+                                                                                             metricsConfiguration_.capacityMaxSizeMegabytesName_,
+                                                                                             metricsConfiguration_.capacityCurrentSizeMegabytesName_,
+                                                                                             metricsConfiguration_.capacityCountName_,
+                                                                                             metricsConfiguration_.capacityMaxUsageSinceStartMegabytesName_));
   }
 
 
--- a/OrthancFramework/Sources/DataSource/DataSourceReader.h	Wed Jun 10 11:05:08 2026 +0200
+++ b/OrthancFramework/Sources/DataSource/DataSourceReader.h	Wed Jun 10 11:12:26 2026 +0200
@@ -47,12 +47,16 @@
   public:
     class MetricsConfiguration
     {
-    private:
+    protected:
       boost::shared_ptr<MetricsRegistry>  metrics_;
       std::string                         cacheSizeMegabytesName_;
       std::string                         cacheCountName_;
       std::string                         cacheHitCountName_;
       std::string                         cacheMissCountName_;
+      std::string                         capacityMaxSizeMegabytesName_;
+      std::string                         capacityCurrentSizeMegabytesName_;
+      std::string                         capacityCountName_;
+      std::string                         capacityMaxUsageSinceStartMegabytesName_;
 
     public:
       MetricsConfiguration()
@@ -63,13 +67,19 @@
                            const std::string& cacheSizeMegabytesName,
                            const std::string& cacheCountName,
                            const std::string& cacheHitCountName,
-                           const std::string& cacheMissCountName);
+                           const std::string& cacheMissCountName,
+                           const std::string& capacityMaxSizeMegabytesName,
+                           const std::string& capacityCurrentSizeMegabytesName,
+                           const std::string& capacityCountName,
+                           const std::string& capacityMaxUsageSinceStartMegabytesName);
 
       void SetCacheStatistics(SharedObjectCache& cache);
 
       void IncrementCacheHitCount();
 
       void IncrementCacheMissCount();
+      
+      friend DataSourceReader;
     };
 
   private:
@@ -88,10 +98,7 @@
 
     ~DataSourceReader();
 
-    void SetMetricsConfiguration(const MetricsConfiguration& configuration)
-    {
-      metricsConfiguration_ = configuration;
-    }
+    void SetMetricsConfiguration(const MetricsConfiguration& configuration);
 
     void CreateCache(size_t capacity);
 
--- a/OrthancServer/Sources/ServerContext.cpp	Wed Jun 10 11:05:08 2026 +0200
+++ b/OrthancServer/Sources/ServerContext.cpp	Wed Jun 10 11:12:26 2026 +0200
@@ -82,16 +82,28 @@
 static const char* const METRICS_STORAGE_AREA_CACHE_HIT_COUNT = "orthanc_storage_cache_hit_count";
 static const char* const METRICS_STORAGE_AREA_CACHE_MISS_COUNT = "orthanc_storage_cache_miss_count";
 static const char* const METRICS_STORAGE_AREA_CACHE_SIZE_MB = "orthanc_storage_cache_size_mb";
+static const char* const METRICS_STORAGE_AREA_MEMORY_CAPACITY_MB = "orthanc_storage_memory_capacity_mb";
+static const char* const METRICS_STORAGE_AREA_MEMORY_USAGE_MB = "orthanc_storage_memory_usage_mb";
+static const char* const METRICS_STORAGE_AREA_MEMORY_MAX_USAGE_MB = "orthanc_storage_memory_max_usage_mb";
+static const char* const METRICS_STORAGE_AREA_MEMORY_COUNT = "orthanc_storage_memory_count";
 
 static const char* const METRICS_DICOM_CACHE_COUNT = "orthanc_dicom_cache_count";
 static const char* const METRICS_DICOM_CACHE_HIT_COUNT = "orthanc_dicom_cache_hit_count";
 static const char* const METRICS_DICOM_CACHE_MISS_COUNT = "orthanc_dicom_cache_miss_count";
 static const char* const METRICS_DICOM_CACHE_SIZE_MB = "orthanc_dicom_cache_size_mb";
+static const char* const METRICS_DICOM_MEMORY_CAPACITY_MB = "orthanc_dicom_memory_capacity_mb";
+static const char* const METRICS_DICOM_MEMORY_USAGE_MB = "orthanc_dicom_memory_usage_mb";
+static const char* const METRICS_DICOM_MEMORY_MAX_USAGE_MB = "orthanc_dicom_memory_max_usage_mb";
+static const char* const METRICS_DICOM_MEMORY_COUNT = "orthanc_dicom_memory_count";
 
 static const char* const METRICS_TRANSCODER_CACHE_COUNT = "orthanc_transcoder_cache_count";
 static const char* const METRICS_TRANSCODER_CACHE_HIT_COUNT = "orthanc_transcoder_cache_hit_count";
 static const char* const METRICS_TRANSCODER_CACHE_MISS_COUNT = "orthanc_transcoder_cache_miss_count";
 static const char* const METRICS_TRANSCODER_CACHE_SIZE_MB = "orthanc_transcoder_cache_size_mb";
+static const char* const METRICS_TRANSCODER_MEMORY_CAPACITY_MB = "orthanc_transcoder_memory_capacity_mb";
+static const char* const METRICS_TRANSCODER_MEMORY_USAGE_MB = "orthanc_transcoder_memory_usage_mb";
+static const char* const METRICS_TRANSCODER_MEMORY_MAX_USAGE_MB = "orthanc_transcoder_memory_max_usage_mb";
+static const char* const METRICS_TRANSCODER_MEMORY_COUNT = "orthanc_transcoder_memory_count";
 
 
 
@@ -678,7 +690,11 @@
                                                  METRICS_STORAGE_AREA_CACHE_SIZE_MB,
                                                  METRICS_STORAGE_AREA_CACHE_COUNT,
                                                  METRICS_STORAGE_AREA_CACHE_HIT_COUNT,
-                                                 METRICS_STORAGE_AREA_CACHE_MISS_COUNT));
+                                                 METRICS_STORAGE_AREA_CACHE_MISS_COUNT,
+                                                 METRICS_STORAGE_AREA_MEMORY_CAPACITY_MB,
+                                                 METRICS_STORAGE_AREA_MEMORY_USAGE_MB,
+                                                 METRICS_STORAGE_AREA_MEMORY_COUNT,
+                                                 METRICS_STORAGE_AREA_MEMORY_MAX_USAGE_MB));
 
         //storageAreaReader_->SetCapacity(1);  // To test on highest pressure
         storageAreaReader_->SetCapacity(256 * MEGABYTE); // TODO-Streaming - Parameter
@@ -700,7 +716,11 @@
                                                  METRICS_DICOM_CACHE_SIZE_MB,
                                                  METRICS_DICOM_CACHE_COUNT,
                                                  METRICS_DICOM_CACHE_HIT_COUNT,
-                                                 METRICS_DICOM_CACHE_MISS_COUNT));
+                                                 METRICS_DICOM_CACHE_MISS_COUNT,
+                                                 METRICS_DICOM_MEMORY_CAPACITY_MB,
+                                                 METRICS_DICOM_MEMORY_USAGE_MB,
+                                                 METRICS_DICOM_MEMORY_COUNT,
+                                                 METRICS_DICOM_MEMORY_MAX_USAGE_MB));
 
         //dicomReader_->SetCapacity(1);  // To test on highest pressure
         dicomReader_->SetCapacity(256 * MEGABYTE); // TODO-Streaming - Parameter
@@ -723,7 +743,11 @@
                                                  METRICS_TRANSCODER_CACHE_SIZE_MB,
                                                  METRICS_TRANSCODER_CACHE_COUNT,
                                                  METRICS_TRANSCODER_CACHE_HIT_COUNT,
-                                                 METRICS_TRANSCODER_CACHE_MISS_COUNT));
+                                                 METRICS_TRANSCODER_CACHE_MISS_COUNT,
+                                                 METRICS_TRANSCODER_MEMORY_CAPACITY_MB,
+                                                 METRICS_TRANSCODER_MEMORY_USAGE_MB,
+                                                 METRICS_TRANSCODER_MEMORY_COUNT,
+                                                 METRICS_TRANSCODER_MEMORY_MAX_USAGE_MB));
 
         //transcoderReader_->SetCapacity(1);  // To test on highest pressure
         transcoderReader_->SetCapacity(256 * MEGABYTE); // TODO-Streaming - Parameter
@@ -740,7 +764,7 @@
         }
 
         std::unique_ptr<ThreadPool> pool(new ThreadPool);
-        pool->SetCountThreads(loaderThreads);  // TODO-Streaming - Check
+        pool->SetCountThreads(loaderThreads);  // TODO-Streaming - Check - clarify the difference between SequentialLoader and DataSourceReader
         pool->SetLoggingThreadName("READER");
         pool->SetDequeueTimeout(100);
         pool->Start();