comparison base/MatrixFile.cpp @ 97:22494cc28c9f

* Reduce number of allocations and deallocations by keeping a spare buffer
  around (we were generally deallocating and then immediately allocating again,
  so it's much better not to have to bother as very large allocations can tie
  up the system)

     m_fd(-1),
     m_mode(mode),
     m_width(0),
     m_height(0),
     m_headerSize(2 * sizeof(size_t)),
-    m_defaultCacheWidth(256),
+    m_defaultCacheWidth(512),
     m_prevX(0),
-    m_requestToken(-1)
+    m_requestToken(-1),
+    m_spareData(0)
 {
     m_cache.data = 0;
 
     QDir tempDir(TempDirectory::instance()->getPath());
     QString fileName(tempDir.filePath(QString("%1.mfc").arg(fileBase)));

         m_height = header[1];
         seekTo(0, 0);
     }
 
     m_fileName = fileName;
-    
-    //!!! why isn't this signal being delivered?
-    connect(&m_readThread, SIGNAL(cancelled(int)), 
-            this, SLOT(requestCancelled(int)));
 
     m_readThread.start();
 
     QMutexLocker locker(&m_refcountMutex);
     ++m_refcount[fileName];

     }
 
     m_readThread.finish();
     m_readThread.wait();
 
-    if (requestData) delete[] requestData;
-    if (m_cache.data) delete[] m_cache.data;
+    if (requestData) free(requestData);
+    if (m_cache.data) free(m_cache.data);
+    if (m_spareData) free(m_spareData);
 
     if (m_fd >= 0) {
         if (::close(m_fd) < 0) {
             ::perror("MatrixFile::~MatrixFile: close failed");
         }

                 m_cache.x = (request.start - m_headerSize) / (m_height * sizeof(float));
                 m_cache.width = request.size / (m_height * sizeof(float));
                 
                 std::cerr << "actual: " << m_cache.x << ", " << m_cache.width << std::endl;
 
-                if (m_cache.data) delete[] m_cache.data;
+                if (m_cache.data) {
+                    if (m_spareData) free(m_spareData);
+                    m_spareData = (char *)m_cache.data;
+                }
                 m_cache.data = (float *)request.data;
 
                 m_readThread.done(m_requestToken);
                 m_requestToken = -1;
             }

         // crude way to avoid leaking the data
         while (!m_readThread.isCancelled(m_requestToken)) {
             usleep(10000);
         }
 
-        delete[] ((float *)request.data);
+        if (m_spareData) free(m_spareData);
+        m_spareData = request.data;
         m_readThread.done(m_requestToken);
 
         m_requestToken = -1;
     }
 
     request.fd = m_fd;
     request.mutex = &m_fdMutex;
     request.start = m_headerSize + rx * m_height * sizeof(float);
     request.size = rw * m_height * sizeof(float);
-    request.data = (char *)(new float[rw * m_height]);
+    request.data = (char *)realloc(m_spareData, rw * m_height * sizeof(float));
     MUNLOCK(request.data, rw * m_height * sizeof(float));
+    m_spareData = 0;
 
     m_requestingX = rx;
     m_requestingWidth = rw;
 
     int token = m_readThread.request(request);
     std::cerr << "MatrixFile::primeCache: request token is "
               << token << " (x = " << rx << ", w = " << rw << ", left = " << goingLeft << ")" << std::endl;
 
     m_requestToken = token;
-}
-
-void
-MatrixFile::requestCancelled(int token)
-{
-    std::cerr << "MatrixFile::requestCancelled(" << token << ")" << std::endl;
-
-    FileReadThread::Request request;
-    if (m_readThread.getRequest(token, request)) {
-        delete[] ((float *)request.data);
-        m_readThread.done(token);
-    }
 }
 
 bool
 MatrixFile::seekTo(size_t x, size_t y)
 {