comparison data/model/Dense3DModelPeakCache.cpp @ 1778:59d9dcfd67c2

Replace the model used for the cache part of the peak-cache model with a simple vector of vectors. Avoids unnecessary locking in a class that is not thread-safe in any case. Also record whether the final column is actually truncated, rather than risk possible backward seeks to re-read it in the case where it simply might be

 #include "base/HitCount.h"
 
 Dense3DModelPeakCache::Dense3DModelPeakCache(ModelId sourceId,
                                              int columnsPerPeak) :
     m_source(sourceId),
-    m_columnsPerPeak(columnsPerPeak)
+    m_columnsPerPeak(columnsPerPeak),
+    m_finalColumnIncomplete(false)
 {
     auto source = ModelById::getAs<DenseThreeDimensionalModel>(m_source);
     if (!source) {
         SVCERR << "WARNING: Dense3DModelPeakCache constructed for unknown or wrong-type source model id " << m_source << endl;
         m_source = {};
         return;
     }
-
-    m_cache.reset(new EditableDenseThreeDimensionalModel
-                  (source->getSampleRate(),
-                   source->getResolution() * m_columnsPerPeak,
-                   source->getHeight(),
-                   false));
 
     connect(source.get(), SIGNAL(modelChanged(ModelId)),
             this, SLOT(sourceModelChanged(ModelId)));
 }
 

 
 Dense3DModelPeakCache::Column
 Dense3DModelPeakCache::getColumn(int column) const
 {
     if (!haveColumn(column)) fillColumn(column);
-    return m_cache->getColumn(column);
+    return m_cache.at(column);
 }
 
 float
 Dense3DModelPeakCache::getValueAt(int column, int n) const
 {
     if (!haveColumn(column)) fillColumn(column);
-    return m_cache->getValueAt(column, n);
+    return m_cache.at(column).at(n);
 }
 
 void
 Dense3DModelPeakCache::sourceModelChanged(ModelId)
 {
-    if (m_coverage.size() > 0) {
-        // The last peak may have come from an incomplete read, which
-        // may since have been filled, so reset it
+    if (m_finalColumnIncomplete && m_coverage.size() > 0) {
+        // The last peak came from an incomplete read, which may since
+        // have been filled, so reset it
         m_coverage[m_coverage.size()-1] = false;
+        m_finalColumnIncomplete = false;
     }
-    m_coverage.resize(getWidth(), false); // retaining data
 }
 
 bool
 Dense3DModelPeakCache::haveColumn(int column) const
 {

 Dense3DModelPeakCache::fillColumn(int column) const
 {
     Profiler profiler("Dense3DModelPeakCache::fillColumn");
 
     if (!in_range_for(m_coverage, column)) {
-        if (m_coverage.size() > 0) {
+        if (m_finalColumnIncomplete && m_coverage.size() > 0) {
             // The last peak may have come from an incomplete read, which
             // may since have been filled, so reset it
             m_coverage[m_coverage.size()-1] = false;
+            m_finalColumnIncomplete = false;
         }
         m_coverage.resize(column + 1, false);
+        m_cache.resize(column + 1, {});
+    }
+    
+    auto source = ModelById::getAs<DenseThreeDimensionalModel>(m_source);
+    if (!source) {
+        return;
+    }
+    
+    int sourceWidth = source->getWidth();
+    int sourceColumn = column * m_columnsPerPeak;
+    if (sourceColumn >= sourceWidth) {
+        return;
     }
 
-    auto source = ModelById::getAs<DenseThreeDimensionalModel>(m_source);
-    if (!source) return;
+    Column peak = source->getColumn(sourceColumn);
+    int n = int(peak.size());
     
-    int sourceWidth = source->getWidth();
-    
-    Column peak;
-    int n = 0;
-    for (int i = 0; i < m_columnsPerPeak; ++i) {
+    for (int i = 1; i < m_columnsPerPeak; ++i) {
 
-        int sourceColumn = column * m_columnsPerPeak + i;
-        if (sourceColumn >= sourceWidth) break;
+        ++sourceColumn;
+        if (sourceColumn >= sourceWidth) {
+            m_finalColumnIncomplete = true;
+            break;
+        }
         
         Column here = source->getColumn(sourceColumn);
-
-//        cerr << "Dense3DModelPeakCache::fillColumn(" << column << "): source col "
-//             << sourceColumn << " of " << sourceWidth
-//             << " returned " << here.size() << " elts" << endl;
-        
-        if (i == 0) {
-            peak = here;
-            n = int(peak.size());
-        } else {
-            int m = std::min(n, int(here.size()));
-            for (int j = 0; j < m; ++j) {
-                peak[j] = std::max(here[j], peak[j]);
-            }
+        int m = std::min(n, int(here.size()));
+        for (int j = 0; j < m; ++j) {
+            peak[j] = std::max(here[j], peak[j]);
         }
     }
 
-    m_cache->setColumn(column, peak);
+    m_cache[column] = peak;
     m_coverage[column] = true;
 }