comparison data/fft/FFTMemoryCache.cpp @ 537:3cc4b7cd2aa5

* Merge from one-fftdataserver-per-fftmodel branch.  This bit of
reworking (which is not described very accurately by the title of
the branch) turns the MatrixFile object into something that either
reads or writes, but not both, and separates the FFT file cache
reader and writer implementations separately.  This allows the
FFT data server to have a single thread owning writers and one reader
per "customer" thread, and for all locking to be vastly simplified
and concentrated in the data server alone (because none of the
classes it makes use of is used in more than one thread at a time).
The result is faster and more trustworthy code.

 
 #include "FFTMemoryCache.h"
 #include "system/System.h"
 
 #include <iostream>
+#include <cstdlib>
 
 //#define DEBUG_FFT_MEMORY_CACHE 1
 
-FFTMemoryCache::FFTMemoryCache(StorageType storageType) :
-    m_width(0),
-    m_height(0),
+FFTMemoryCache::FFTMemoryCache(FFTCache::StorageType storageType,
+                               size_t width, size_t height) :
+    m_width(width),
+    m_height(height),
     m_magnitude(0),
     m_phase(0),
     m_fmagnitude(0),
     m_fphase(0),
     m_freal(0),

     m_factor(0),
     m_storageType(storageType)
 {
 #ifdef DEBUG_FFT_MEMORY_CACHE
     std::cerr << "FFTMemoryCache[" << this << "]::FFTMemoryCache (type "
-              << m_storageType << ")" << std::endl;
-#endif
+              << m_storageType << "), size " << m_width << "x" << m_height << std::endl;
+#endif
+
+    initialise();
 }
 
 FFTMemoryCache::~FFTMemoryCache()
 {
 #ifdef DEBUG_FFT_MEMORY_CACHE

     if (m_fimag) free(m_fimag);
     if (m_factor) free(m_factor);
 }
 
 void
-FFTMemoryCache::resize(size_t width, size_t height)
-{
-    Profiler profiler("FFTMemoryCache::resize");
-
-#ifdef DEBUG_FFT_MEMORY_CACHE
-    std::cerr << "FFTMemoryCache[" << this << "]::resize(" << width << "x" << height << " = " << width*height << ")" << std::endl;
-#endif
-    
-    if (m_width == width && m_height == height) return;
-
-    if (m_storageType == Compact) {
-        resize(m_magnitude, width, height);
-        resize(m_phase, width, height);
-    } else if (m_storageType == Polar) {
-        resize(m_fmagnitude, width, height);
-        resize(m_fphase, width, height);
+FFTMemoryCache::initialise()
+{
+    Profiler profiler("FFTMemoryCache::initialise");
+
+    size_t width = m_width, height = m_height;
+
+#ifdef DEBUG_FFT_MEMORY_CACHE
+    std::cerr << "FFTMemoryCache[" << this << "]::initialise(" << width << "x" << height << " = " << width*height << ")" << std::endl;
+#endif
+
+    if (m_storageType == FFTCache::Compact) {
+        initialise(m_magnitude);
+        initialise(m_phase);
+    } else if (m_storageType == FFTCache::Polar) {
+        initialise(m_fmagnitude);
+        initialise(m_fphase);
     } else {
-        resize(m_freal, width, height);
-        resize(m_fimag, width, height);
+        initialise(m_freal);
+        initialise(m_fimag);
     }
 
     m_colset.resize(width);
 
     m_factor = (float *)realloc(m_factor, width * sizeof(float));

     std::cerr << "done, width = " << m_width << " height = " << m_height << std::endl;
 #endif
 }
 
 void
-FFTMemoryCache::resize(uint16_t **&array, size_t width, size_t height)
-{
-    for (size_t i = width; i < m_width; ++i) {
-	free(array[i]);
-    }
-
-    if (width != m_width) {
-	array = (uint16_t **)realloc(array, width * sizeof(uint16_t *));
-	if (!array) throw std::bad_alloc();
-	MUNLOCK(array, width * sizeof(uint16_t *));
-    }
-
-    for (size_t i = m_width; i < width; ++i) {
-	array[i] = 0;
-    }
-
-    for (size_t i = 0; i < width; ++i) {
-	array[i] = (uint16_t *)realloc(array[i], height * sizeof(uint16_t));
+FFTMemoryCache::initialise(uint16_t **&array)
+{
+    array = (uint16_t **)malloc(m_width * sizeof(uint16_t *));
+    if (!array) throw std::bad_alloc();
+    MUNLOCK(array, m_width * sizeof(uint16_t *));
+
+    for (size_t i = 0; i < m_width; ++i) {
+	array[i] = (uint16_t *)malloc(m_height * sizeof(uint16_t));
 	if (!array[i]) throw std::bad_alloc();
-	MUNLOCK(array[i], height * sizeof(uint16_t));
-    }
-}
-
-void
-FFTMemoryCache::resize(float **&array, size_t width, size_t height)
-{
-    for (size_t i = width; i < m_width; ++i) {
-	free(array[i]);
-    }
-
-    if (width != m_width) {
-	array = (float **)realloc(array, width * sizeof(float *));
-	if (!array) throw std::bad_alloc();
-	MUNLOCK(array, width * sizeof(float *));
-    }
-
-    for (size_t i = m_width; i < width; ++i) {
-	array[i] = 0;
-    }
-
-    for (size_t i = 0; i < width; ++i) {
-	array[i] = (float *)realloc(array[i], height * sizeof(float));
+	MUNLOCK(array[i], m_height * sizeof(uint16_t));
+    }
+}
+
+void
+FFTMemoryCache::initialise(float **&array)
+{
+    array = (float **)malloc(m_width * sizeof(float *));
+    if (!array) throw std::bad_alloc();
+    MUNLOCK(array, m_width * sizeof(float *));
+
+    for (size_t i = 0; i < m_width; ++i) {
+	array[i] = (float *)malloc(m_height * sizeof(float));
 	if (!array[i]) throw std::bad_alloc();
-	MUNLOCK(array[i], height * sizeof(float));
-    }
-}
-
-void
-FFTMemoryCache::reset()
-{
-    switch (m_storageType) {
-
-    case Compact:
-        for (size_t x = 0; x < m_width; ++x) {
-            for (size_t y = 0; y < m_height; ++y) {
-                m_magnitude[x][y] = 0;
-                m_phase[x][y] = 0;
-            }
-            m_factor[x] = 1.0;
-        }
-        break;
-        
-    case Polar:
-        for (size_t x = 0; x < m_width; ++x) {
-            for (size_t y = 0; y < m_height; ++y) {
-                m_fmagnitude[x][y] = 0;
-                m_fphase[x][y] = 0;
-            }
-            m_factor[x] = 1.0;
-        }
-        break;
-
-    case Rectangular:
-        for (size_t x = 0; x < m_width; ++x) {
-            for (size_t y = 0; y < m_height; ++y) {
-                m_freal[x][y] = 0;
-                m_fimag[x][y] = 0;
-            }
-            m_factor[x] = 1.0;
-        }
-        break;        
-    }
-}	    
+	MUNLOCK(array[i], m_height * sizeof(float));
+    }
+}
 
 void
 FFTMemoryCache::setColumnAt(size_t x, float *mags, float *phases, float factor)
 {
     Profiler profiler("FFTMemoryCache::setColumnAt: from polar");
 
     setNormalizationFactor(x, factor);
 
-    if (m_storageType == Rectangular) {
+    if (m_storageType == FFTCache::Rectangular) {
         Profiler subprof("FFTMemoryCache::setColumnAt: polar to cart");
         for (size_t y = 0; y < m_height; ++y) {
             m_freal[x][y] = mags[y] * cosf(phases[y]);
             m_fimag[x][y] = mags[y] * sinf(phases[y]);
         }

             setMagnitudeAt(x, y, mags[y]);
             setPhaseAt(x, y, phases[y]);
         }
     }
 
+    m_colsetMutex.lock();
     m_colset.set(x);
+    m_colsetMutex.unlock();
 }
 
 void
 FFTMemoryCache::setColumnAt(size_t x, float *reals, float *imags)
 {

 
     float max = 0.0;
 
     switch (m_storageType) {
 
-    case Rectangular:
+    case FFTCache::Rectangular:
         for (size_t y = 0; y < m_height; ++y) {
             m_freal[x][y] = reals[y];
             m_fimag[x][y] = imags[y];
             float mag = sqrtf(reals[y] * reals[y] + imags[y] * imags[y]);
             if (mag > max) max = mag;
         }
         break;
 
-    case Compact:
-    case Polar:
+    case FFTCache::Compact:
+    case FFTCache::Polar:
     {
         Profiler subprof("FFTMemoryCache::setColumnAt: cart to polar");
         for (size_t y = 0; y < m_height; ++y) {
             float mag = sqrtf(reals[y] * reals[y] + imags[y] * imags[y]);
             float phase = atan2f(imags[y], reals[y]);

         }
         break;
     }
     };
 
-    if (m_storageType == Rectangular) {
+    if (m_storageType == FFTCache::Rectangular) {
         m_factor[x] = max;
+        m_colsetMutex.lock();
         m_colset.set(x);
+        m_colsetMutex.unlock();
     } else {
         setColumnAt(x, reals, imags, max);
     }
 }
 
 size_t
-FFTMemoryCache::getCacheSize(size_t width, size_t height, StorageType type)
+FFTMemoryCache::getCacheSize(size_t width, size_t height, FFTCache::StorageType type)
 {
     size_t sz = 0;
 
     switch (type) {
 
-    case Compact:
+    case FFTCache::Compact:
         sz = (height * 2 + 1) * width * sizeof(uint16_t);
 
-    case Polar:
-    case Rectangular:
+    case FFTCache::Polar:
+    case FFTCache::Rectangular:
         sz = (height * 2 + 1) * width * sizeof(float);
     }
 
     return sz;
 }