comparison base/MatrixFileCache.cpp @ 93:27d726916ab3

* Remove mmap-based code again.  We can be more efficient with read().

 
 #include <QFileInfo>
 #include <QFile>
 #include <QDir>
 
-//#define HAVE_MMAP 1
-
-#ifdef HAVE_MMAP
-#include <sys/mman.h>
-#endif
-
 std::map<QString, int> MatrixFileCache::m_refcount;
 QMutex MatrixFileCache::m_refcountMutex;
 
 //!!! This class is a work in progress -- it does only as much as we
 // need for the current SpectrogramLayer.  Slated for substantial

     m_autoRegionWidth(256),
     m_off(-1),
     m_rx(0),
     m_rw(0),
     m_userRegion(false),
-    m_region(0),
-    m_mmapped(false),
-    m_mmapSize(0),
-    m_mmapOff(0),
-    m_preferMmap(false)
+    m_region(0)
 {
     // Ensure header size is a multiple of the size of our data (for
     // alignment purposes)
     size_t hs = ((m_headerSize / sizeof(float)) * sizeof(float));
     if (hs != m_headerSize) m_headerSize = hs + sizeof(float);

 }
 
 MatrixFileCache::~MatrixFileCache()
 {
     if (m_rw > 0) {
-        if (m_mmapped) {
-#ifdef HAVE_MMAP
-            ::munmap(m_region, m_mmapSize);
-#endif
-        } else {
-            delete[] m_region;
-        }
+        delete[] m_region;
     }
 
     if (m_fd >= 0) {
         if (::close(m_fd) < 0) {
             ::perror("MatrixFileCache::~MatrixFileCache: close failed");

 
     off_t off = m_headerSize + (w * h * sizeof(float));
 
     if (w * h > m_width * m_height) {
 
-#ifdef HAVE_MMAP
+/*!!!
         // If we're going to mmap the file, we need to ensure it's long
         // enough beforehand
         
         if (m_preferMmap) {
         

             float f(0);
             if (::write(m_fd, &f, sizeof(float)) != sizeof(float)) {
                 ::perror("WARNING: MatrixFileCache::resize: write failed");
             }
         }
-#endif
-
+*/
     } else {
         
         if (::ftruncate(m_fd, off) < 0) {
             ::perror("WARNING: MatrixFileCache::resize: ftruncate failed");
         }

 {
     if (m_rw == 0) return 0;
 
     float *region = m_region;
 
-    if (m_mmapOff > 0) {
-        char *cr = (char *)m_region;
-        cr += m_mmapOff;
-        region = (float *)cr;
-    }
-
     float *ptr = &(region[(x - m_rx) * m_height + y]);
     
 //    std::cerr << "getRegionPtr(" << x << "," << y << "): region is " << m_region << ", returning " << ptr << std::endl;
     return ptr;
 }

 {
     if (!user && m_userRegion) return false;
     if (m_rw > 0 && x >= m_rx && x + width <= m_rx + m_rw) return true;
 
     if (m_rw > 0) {
-        if (m_mmapped) {
-#ifdef HAVE_MMAP
-            ::munmap(m_region, m_mmapSize);
-            std::cerr << "unmapped " << m_mmapSize << " at " << m_region << std::endl;
-#endif
-        } else {
-            delete[] m_region;
-        }
+        delete[] m_region;
         m_region = 0;
-        m_mmapped = false;
-        m_mmapSize = 0;
-        m_mmapOff = 0;
         m_rw = 0;
     }
 
     if (width == 0) {
         return true;
     }
-
-#ifdef HAVE_MMAP
-
-    if (m_preferMmap) {
-
-        size_t mmapSize = m_height * width * sizeof(float);
-        off_t offset = m_headerSize + (x * m_height) * sizeof(float);
-        int pagesize = getpagesize();
-        off_t aligned = (offset / pagesize) * pagesize;
-        size_t mmapOff = offset - aligned;
-        mmapSize += mmapOff;
-        
-        m_region = (float *)
-            ::mmap(0, mmapSize, PROT_READ, MAP_PRIVATE, m_fd, aligned);
-        
-        if (m_region == MAP_FAILED) {
-            
-            ::perror("Mmap failed");
-            std::cerr << "ERROR: MatrixFileCache::setRegion(" << x << ", "
-                      << width << "): Mmap(0, " << mmapSize
-                      << ", " << PROT_READ << ", " << MAP_SHARED << ", " << m_fd 
-                      << ", " << aligned << ") failed, falling back to "
-                      << "non-mmapping code for this cache" << std::endl;
-            m_preferMmap = false;
-            
-        } else {
-
-            std::cerr << "mmap succeeded (offset " << aligned << ", size " << mmapSize << ", m_mmapOff " << mmapOff << ") = " << m_region << std::endl;
-            
-            m_mmapped = true;
-            m_mmapSize = mmapSize;
-            m_mmapOff = mmapOff;
-            m_rx = x;
-            m_rw = width;
-            if (user) m_userRegion = true;
-            MUNLOCK(m_region, m_mmapSize);
-            return true;
-        }
-    }
-#endif
 
     if (!seekTo(x, 0)) return false;
 
     m_region = new float[width * m_height];
     MUNLOCK(m_region, width * m_height * sizeof(float));