comparison data/fft/FFTDataServer.cpp @ 200:2f2d282d45d0

* Somewhat better handling of running out of memory or disc space

 #include "model/DenseTimeValueModel.h"
 
 #include "system/System.h"
 
 #include "base/StorageAdviser.h"
+#include "base/Exceptions.h"
 #include "base/Profiler.h"
+
+#include <QMessageBox>
+#include <QApplication>
 
 
 //#define DEBUG_FFT_SERVER 1
 //#define DEBUG_FFT_SERVER_FILL 1
 

 
     if ((server = findServer(npn))) {
         return server;
     }
 
-    m_servers[n] = ServerCountPair
-        (new FFTDataServer(n,
-                           model,
-                           channel,
-                           windowType,
-                           windowSize,
-                           windowIncrement,
-                           fftSize,
-                           polar,
-                           fillFromColumn),
-         1);
-
-    return m_servers[n].first;
+    try {
+        server = new FFTDataServer(n,
+                                   model,
+                                   channel,
+                                   windowType,
+                                   windowSize,
+                                   windowIncrement,
+                                   fftSize,
+                                   polar,
+                                   fillFromColumn);
+    } catch (InsufficientDiscSpace) {
+        delete server;
+        server = 0;
+    }
+
+    if (server) {
+        m_servers[n] = ServerCountPair(server, 1);
+    }
+
+    return server;
 }
 
 FFTDataServer *
 FFTDataServer::getFuzzyInstance(const DenseTimeValueModel *model,
                                 int channel,

 
     int cells = m_width * m_height;
     int minimumSize = (cells / 1024) * sizeof(uint16_t); // kb
     int maximumSize = (cells / 1024) * sizeof(float); // kb
 
-    //!!! catch InsufficientDiscSpace
+    // This can throw InsufficientDiscSpace.  We don't catch it here -- we
+    // haven't allocated anything yet and can safely let the exception out.
+    // Caller needs to check for it.
     
-    StorageAdviser::Recommendation recommendation =
+    StorageAdviser::Recommendation recommendation = 
         StorageAdviser::recommend(criteria, minimumSize, maximumSize);
 
     std::cerr << "Recommendation was: " << recommendation << std::endl;
 
     m_memoryCache = ((recommendation & StorageAdviser::UseMemory) ||

 
     QString name = QString("%1-%2").arg(m_fileBaseName).arg(c);
 
     FFTCache *cache = 0;
 
-    if (m_memoryCache) {
-
-        cache = new FFTMemoryCache();
-
-    } else if (m_compactCache) {
-
-        cache = new FFTFileCache(name, MatrixFile::ReadWrite,
-                                 FFTFileCache::Compact);
-
-    } else {
-
-        cache = new FFTFileCache(name, MatrixFile::ReadWrite,
-                                 m_polar ? FFTFileCache::Polar :
-                                           FFTFileCache::Rectangular);
-    }
-
-//    FFTCache *cache = new FFTMemoryCache();
-
-    size_t width = m_cacheWidth;
-    if (c * m_cacheWidth + width > m_width) {
-        width = m_width - c * m_cacheWidth;
-    }
-
-    cache->resize(width, m_height);
-    cache->reset();
+    try {
+        
+        if (m_memoryCache) {
+
+            cache = new FFTMemoryCache();
+
+        } else if (m_compactCache) {
+
+            cache = new FFTFileCache(name, MatrixFile::ReadWrite,
+                                     FFTFileCache::Compact);
+
+        } else {
+
+            cache = new FFTFileCache(name, MatrixFile::ReadWrite,
+                                     m_polar ? FFTFileCache::Polar :
+                                               FFTFileCache::Rectangular);
+        }
+
+        size_t width = m_cacheWidth;
+        if (c * m_cacheWidth + width > m_width) {
+            width = m_width - c * m_cacheWidth;
+        }
+
+        cache->resize(width, m_height);
+        cache->reset();
+
+    } catch (std::bad_alloc) {
+        std::cerr << "ERROR: Memory allocation failed in FFTFileCache::resize:"
+                  << " abandoning this cache" << std::endl;
+        //!!! Shouldn't be using QtGui here.  Need a better way to report this.
+        QMessageBox::critical
+            (0, QApplication::tr("FFT cache resize failed"),
+             QApplication::tr
+             ("Failed to create or resize an FFT model slice.\n"
+              "There may be insufficient memory or disc space to continue."));
+        delete cache;
+        m_caches[c] = 0;
+        return 0;
+    }
 
     m_caches[c] = cache;
     m_lastUsedCache = c;
 
     return cache;

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

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

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

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

 {
     Profiler profiler("FFTDataServer::getValuesAt", false);
 
     size_t col;
     FFTCache *cache = getCache(x, col);
+    if (!cache) { real = 0; imaginary = 0; return; }
 
     if (!cache->haveSetColumnAt(col)) {
 #ifdef DEBUG_FFT_SERVER
         std::cerr << "FFTDataServer::getValuesAt(" << x << ", " << y << "): filling" << std::endl;
 #endif

         return false;
     }
 
     size_t col;
     FFTCache *cache = getCache(x, col);
+    if (!cache) return true;
 
     return cache->haveSetColumnAt(col);
 }    
 
 void

     size_t col;
 #ifdef DEBUG_FFT_SERVER_FILL
     std::cout << "FFTDataServer::fillColumn(" << x << ")" << std::endl;
 #endif
     FFTCache *cache = getCache(x, col);
+    if (!cache) return;
 
     QMutexLocker locker(&m_writeMutex);
 
     if (cache->haveSetColumnAt(col)) return;