libs/ardour/ardour/dsp_load_calculator.h

   1 /*
   2  * Copyright (C) 2015 Tim Mayberry <mojofunk@gmail.com>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17  */
  18
  19 #ifndef ARDOUR_DSP_LOAD_CALCULATOR_H
  20 #define ARDOUR_DSP_LOAD_CALCULATOR_H
  21
  22 #include <stdint.h>
  23 #include <cassert>
  24 #include <algorithm>
  25
  26 namespace ARDOUR {
  27
  28 class DSPLoadCalculator {
  29 public:
  30         DSPLoadCalculator()
  31             : m_max_time_us(0)
  32             , m_start_timestamp_us(0)
  33             , m_stop_timestamp_us(0)
  34             , m_dsp_load(0)
  35         {
  36
  37         }
  38
  39         void set_max_time(double samplerate, uint32_t period_size) {
  40                 m_max_time_us = (1e6 / samplerate) * period_size;
  41         }
  42
  43         void set_max_time_us(uint64_t max_time_us) {
  44                 assert(max_time_us != 0);
  45                 m_max_time_us = max_time_us;
  46         }
  47
  48         int64_t get_max_time_us() const { return m_max_time_us; }
  49
  50         void set_start_timestamp_us(int64_t start_timestamp_us)
  51         {
  52                 m_start_timestamp_us = start_timestamp_us;
  53         }
  54
  55         void set_stop_timestamp_us(int64_t stop_timestamp_us)
  56         {
  57                 m_stop_timestamp_us = stop_timestamp_us;
  58
  59                 /* querying the performance counter can fail occasionally (-1).
  60                  * Also on some multi-core systems, timers are CPU specific and not
  61                  * synchronized. We assume they differ more than a few milliseconds
  62                  * (4 * nominal cycle time) and simply ignore cases where the
  63                  * execution switches cores.
  64                  */
  65                 if (m_start_timestamp_us < 0 || m_stop_timestamp_us < 0 ||
  66                     m_start_timestamp_us > m_stop_timestamp_us ||
  67                     elapsed_time_us() > max_timer_error_us()) {
  68                         return;
  69                 }
  70
  71                 if (elapsed_time_us() > m_max_time_us) {
  72                         m_dsp_load = 1.0f;
  73                 } else {
  74                         const float load = elapsed_time_us() / (float)m_max_time_us;
  75                         if (load > m_dsp_load) {
  76                                 m_dsp_load = load;
  77                         } else {
  78                                 const float alpha = 0.2f * (m_max_time_us * 1e-6f);
  79                                 m_dsp_load = m_dsp_load + alpha * (load - m_dsp_load) + 1e-12;
  80                         }
  81                 }
  82         }
  83
  84         int64_t elapsed_time_us()
  85         {
  86                 return m_stop_timestamp_us - m_start_timestamp_us;
  87         }
  88
  89         /**
  90          * @return a decimal value between 0.0 and 1.0 representing the percentage
  91          * of time spent between start and stop in proportion to the max expected time
  92          * in microseconds(us).
  93          */
  94         float get_dsp_load() const
  95         {
  96                 if (m_dsp_load > m_max_time_us) {
  97                         return 1.0f;
  98                 }
  99                 if (m_dsp_load < 0.0f) {
 100                         return 0.0f;
 101                 }
 102                 return m_dsp_load;
 103         }
 104
 105         /**
 106          * The maximum error in timestamp values that will be tolerated before the
 107          * current dsp load sample will be ignored
 108          */
 109         int64_t max_timer_error_us() { return 4 * m_max_time_us; }
 110
 111 private: // data
 112         int64_t m_max_time_us;
 113         int64_t m_start_timestamp_us;
 114         int64_t m_stop_timestamp_us;
 115         float m_dsp_load;
 116 };
 117
 118 } // namespace ARDOUR
 119
 120 #endif // ARDOUR_DSP_LOAD_CALCULATOR_H