comparison data/fft/FFTDataServer.cpp @ 183:146eb9e35baa

* Improve output from Profiler class and make it incur less (no) overhead in
  release builds with NO_TIMING defined
* Fix a lock contention issue in spectrogram
* Marginal optimisations elsewhere

 #include "model/DenseTimeValueModel.h"
 
 #include "system/System.h"
 
 #include "base/StorageAdviser.h"
+#include "base/Profiler.h"
 
 
 #define DEBUG_FFT_SERVER 1
 //#define DEBUG_FFT_SERVER_FILL 1
 

     m_windower(windowType, windowSize),
     m_windowSize(windowSize),
     m_windowIncrement(windowIncrement),
     m_fftSize(fftSize),
     m_polar(polar),
+    m_width(0),
+    m_height(0),
+    m_cacheWidth(0),
     m_memoryCache(false),
     m_compactCache(false),
     m_lastUsedCache(-1),
     m_fftInput(0),
     m_exiting(false),

 FFTDataServer::suspend()
 {
 #ifdef DEBUG_FFT_SERVER
     std::cerr << "FFTDataServer(" << this << "): suspend" << std::endl;
 #endif
+    Profiler profiler("FFTDataServer::suspend", false);
+
     QMutexLocker locker(&m_writeMutex);
     m_suspended = true;
     for (CacheVector::iterator i = m_caches.begin(); i != m_caches.end(); ++i) {
         if (*i) (*i)->suspend();
     }

 FFTDataServer::suspendWrites()
 {
 #ifdef DEBUG_FFT_SERVER
     std::cerr << "FFTDataServer(" << this << "): suspendWrites" << std::endl;
 #endif
+    Profiler profiler("FFTDataServer::suspendWrites", false);
+
     m_suspended = true;
 }
 
 void
 FFTDataServer::resume()
 {
 #ifdef DEBUG_FFT_SERVER
     std::cerr << "FFTDataServer(" << this << "): resume" << std::endl;
 #endif
+    Profiler profiler("FFTDataServer::resume", false);
+
     m_suspended = false;
     if (m_fillThread) {
         if (m_fillThread->isFinished()) {
             delete m_fillThread;
             m_fillThread = 0;

 }
 
 FFTCache *
 FFTDataServer::getCacheAux(size_t c)
 {
+    Profiler profiler("FFTDataServer::getCacheAux", false);
+
     QMutexLocker locker(&m_writeMutex);
 
     if (m_lastUsedCache == -1) {
         m_fillThread->start();
     }

 }
 
 float
 FFTDataServer::getMagnitudeAt(size_t x, size_t y)
 {
+    Profiler profiler("FFTDataServer::getMagnitudeAt", false);
+
     size_t col;
     FFTCache *cache = getCache(x, col);
 
     if (!cache->haveSetColumnAt(col)) {
+        std::cerr << "FFTDataServer::getMagnitudeAt: calling fillColumn(" 
+                  << x << ")" << std::endl;
         fillColumn(x);
     }
     return cache->getMagnitudeAt(col, y);
 }
 
 float
 FFTDataServer::getNormalizedMagnitudeAt(size_t x, size_t y)
 {
+    Profiler profiler("FFTDataServer::getNormalizedMagnitudeAt", false);
+
     size_t col;
     FFTCache *cache = getCache(x, col);
 
     if (!cache->haveSetColumnAt(col)) {
         fillColumn(x);

 }
 
 float
 FFTDataServer::getMaximumMagnitudeAt(size_t x)
 {
+    Profiler profiler("FFTDataServer::getMaximumMagnitudeAt", false);
+
     size_t col;
     FFTCache *cache = getCache(x, col);
 
     if (!cache->haveSetColumnAt(col)) {
         fillColumn(x);

 }
 
 float
 FFTDataServer::getPhaseAt(size_t x, size_t y)
 {
+    Profiler profiler("FFTDataServer::getPhaseAt", false);
+
     size_t col;
     FFTCache *cache = getCache(x, col);
 
     if (!cache->haveSetColumnAt(col)) {
         fillColumn(x);

 }
 
 void
 FFTDataServer::getValuesAt(size_t x, size_t y, float &real, float &imaginary)
 {
+    Profiler profiler("FFTDataServer::getValuesAt", false);
+
     size_t col;
     FFTCache *cache = getCache(x, col);
 
     if (!cache->haveSetColumnAt(col)) {
 #ifdef DEBUG_FFT_SERVER

 }
 
 bool
 FFTDataServer::isColumnReady(size_t x)
 {
+    Profiler profiler("FFTDataServer::isColumnReady", false);
+
     if (!haveCache(x)) {
         if (m_lastUsedCache == -1) {
-            if (m_suspended) resume();
+            if (m_suspended) {
+                std::cerr << "FFTDataServer::isColumnReady(" << x << "): no cache, calling resume" << std::endl;
+                resume();
+            }
             m_fillThread->start();
         }
         return false;
     }
 

 }    
 
 void
 FFTDataServer::fillColumn(size_t x)
 {
+    Profiler profiler("FFTDataServer::fillColumn", false);
+
     size_t col;
 #ifdef DEBUG_FFT_SERVER_FILL
     std::cout << "FFTDataServer::fillColumn(" << x << ")" << std::endl;
 #endif
     FFTCache *cache = getCache(x, col);

     cache->setColumnAt(col,
                        m_workbuffer,
                        m_workbuffer + m_fftSize/2,
                        factor);
 
-    if (m_suspended) resume();
+    if (m_suspended) {
+//        std::cerr << "FFTDataServer::fillColumn(" << x << "): calling resume" << std::endl;
+//        resume();
+    }
 }    
 
 size_t
 FFTDataServer::getFillCompletion() const 
 {