Move averargeQ time to Stripe.

10 files changed, 92 insertions, 60 deletions

diff --git a/storage/src/tests/common/metricstest.cpp b/storage/src/tests/common/metricstest.cpp
index 7e46456948e..9d2f566f770 100644
--- a/storage/src/tests/common/metricstest.cpp
+++ b/storage/src/tests/common/metricstest.cpp
@@ -111,10 +111,8 @@ void MetricsTest::setUp() {
     uint16_t diskCount = _node->getPartitions().size();
     documentapi::LoadTypeSet::SP loadTypes(_node->getLoadTypes());
 
-    _filestorMetrics.reset(new FileStorMetrics(
-            _node->getLoadTypes()->getMetricLoadTypes()));
-    _filestorMetrics->initDiskMetrics(
-            diskCount, loadTypes->getMetricLoadTypes(), 1);
+    _filestorMetrics.reset(new FileStorMetrics(_node->getLoadTypes()->getMetricLoadTypes()));
+    _filestorMetrics->initDiskMetrics(diskCount, loadTypes->getMetricLoadTypes(), 1, 1);
     _topSet->registerMetric(*_filestorMetrics);
 
     _bucketManagerMetrics.reset(new BucketManagerMetrics);
@@ -156,7 +154,7 @@ void MetricsTest::createFakeLoad()
     for (uint32_t i=0; i<_filestorMetrics->disks.size(); ++i) {
         FileStorDiskMetrics& disk(*_filestorMetrics->disks[i]);
         disk.queueSize.addValue(4 * n);
-        disk.averageQueueWaitingTime[documentapi::LoadType::DEFAULT].addValue(10 * n);
+        //disk.averageQueueWaitingTime[documentapi::LoadType::DEFAULT].addValue(10 * n);
         disk.pendingMerges.addValue(4 * n);
         for (uint32_t j=0; j<disk.threads.size(); ++j) {
             FileStorThreadMetrics& thread(*disk.threads[j]);
diff --git a/storage/src/tests/persistence/filestorage/filestormanagertest.cpp b/storage/src/tests/persistence/filestorage/filestormanagertest.cpp
index 2c47c2c258d..3bdc622aa66 100644
--- a/storage/src/tests/persistence/filestorage/filestormanagertest.cpp
+++ b/storage/src/tests/persistence/filestorage/filestormanagertest.cpp
@@ -611,7 +611,7 @@ FileStorManagerTest::testHandlerPriority()
 
     documentapi::LoadTypeSet loadTypes("raw:");
     FileStorMetrics metrics(loadTypes.getMetricLoadTypes());
-    metrics.initDiskMetrics(_node->getPartitions().size(), loadTypes.getMetricLoadTypes(), 1);
+    metrics.initDiskMetrics(_node->getPartitions().size(), loadTypes.getMetricLoadTypes(), 1, 1);
 
     FileStorHandler filestorHandler(messageSender, metrics, _node->getPartitions(), _node->getComponentRegister());
     filestorHandler.setGetNextMessageTimeout(50);
@@ -723,7 +723,7 @@ FileStorManagerTest::testHandlerPausedMultiThread()
 
     documentapi::LoadTypeSet loadTypes("raw:");
     FileStorMetrics metrics(loadTypes.getMetricLoadTypes());
-    metrics.initDiskMetrics(_node->getPartitions().size(), loadTypes.getMetricLoadTypes(), 1);
+    metrics.initDiskMetrics(_node->getPartitions().size(), loadTypes.getMetricLoadTypes(), 1, 1);
 
     FileStorHandler filestorHandler(messageSender, metrics, _node->getPartitions(), _node->getComponentRegister());
     filestorHandler.setGetNextMessageTimeout(50);
@@ -773,7 +773,7 @@ FileStorManagerTest::testHandlerPause()
 
     documentapi::LoadTypeSet loadTypes("raw:");
     FileStorMetrics metrics(loadTypes.getMetricLoadTypes());
-    metrics.initDiskMetrics(_node->getPartitions().size(), loadTypes.getMetricLoadTypes(), 1);
+    metrics.initDiskMetrics(_node->getPartitions().size(), loadTypes.getMetricLoadTypes(), 1, 1);
 
     FileStorHandler filestorHandler(messageSender, metrics, _node->getPartitions(), _node->getComponentRegister());
     filestorHandler.setGetNextMessageTimeout(50);
@@ -835,10 +835,9 @@ FileStorManagerTest::testRemapSplit()
 
     documentapi::LoadTypeSet loadTypes("raw:");
     FileStorMetrics metrics(loadTypes.getMetricLoadTypes());
-    metrics.initDiskMetrics(_node->getPartitions().size(), loadTypes.getMetricLoadTypes(), 1);
+    metrics.initDiskMetrics(_node->getPartitions().size(), loadTypes.getMetricLoadTypes(), 1, 1);
 
-    FileStorHandler filestorHandler(messageSender, metrics, _node->getPartitions(),
-                                    _node->getComponentRegister());
+    FileStorHandler filestorHandler(messageSender, metrics, _node->getPartitions(), _node->getComponentRegister());
     filestorHandler.setGetNextMessageTimeout(50);
 
     std::string content("Here is some content which is in all documents");
@@ -899,7 +898,7 @@ FileStorManagerTest::testHandlerMulti()
 
     documentapi::LoadTypeSet loadTypes("raw:");
     FileStorMetrics metrics(loadTypes.getMetricLoadTypes());
-    metrics.initDiskMetrics(_node->getPartitions().size(), loadTypes.getMetricLoadTypes(), 1);
+    metrics.initDiskMetrics(_node->getPartitions().size(), loadTypes.getMetricLoadTypes(), 1, 1);
 
     FileStorHandler filestorHandler(messageSender, metrics, _node->getPartitions(), _node->getComponentRegister());
     filestorHandler.setGetNextMessageTimeout(50);
@@ -960,7 +959,7 @@ FileStorManagerTest::testHandlerTimeout()
 
     documentapi::LoadTypeSet loadTypes("raw:");
     FileStorMetrics metrics(loadTypes.getMetricLoadTypes());
-    metrics.initDiskMetrics(_node->getPartitions().size(), loadTypes.getMetricLoadTypes(), 1);
+    metrics.initDiskMetrics(_node->getPartitions().size(), loadTypes.getMetricLoadTypes(),1,  1);
 
     FileStorHandler filestorHandler(messageSender, metrics, _node->getPartitions(), _node->getComponentRegister());
     filestorHandler.setGetNextMessageTimeout(50);
@@ -1023,7 +1022,7 @@ FileStorManagerTest::testPriority()
 
     documentapi::LoadTypeSet loadTypes("raw:");
     FileStorMetrics metrics(loadTypes.getMetricLoadTypes());
-    metrics.initDiskMetrics(_node->getPartitions().size(), loadTypes.getMetricLoadTypes(), 2);
+    metrics.initDiskMetrics(_node->getPartitions().size(), loadTypes.getMetricLoadTypes(),1,  2);
 
     FileStorHandler filestorHandler(messageSender, metrics, _node->getPartitions(), _node->getComponentRegister());
     std::unique_ptr<DiskThread> thread(createThread(
@@ -1111,7 +1110,7 @@ FileStorManagerTest::testSplit1()
     ForwardingMessageSender messageSender(*dummyManager);
     documentapi::LoadTypeSet loadTypes("raw:");
     FileStorMetrics metrics(loadTypes.getMetricLoadTypes());
-    metrics.initDiskMetrics(_node->getPartitions().size(), loadTypes.getMetricLoadTypes(), 1);
+    metrics.initDiskMetrics(_node->getPartitions().size(), loadTypes.getMetricLoadTypes(), 1, 1);
     FileStorHandler filestorHandler(messageSender, metrics, _node->getPartitions(), _node->getComponentRegister());
     std::unique_ptr<DiskThread> thread(createThread(
             *config, *_node, _node->getPersistenceProvider(),
@@ -1279,7 +1278,7 @@ FileStorManagerTest::testSplitSingleGroup()
     ForwardingMessageSender messageSender(*dummyManager);
     documentapi::LoadTypeSet loadTypes("raw:");
     FileStorMetrics metrics(loadTypes.getMetricLoadTypes());
-    metrics.initDiskMetrics(_node->getPartitions().size(), loadTypes.getMetricLoadTypes(), 1);
+    metrics.initDiskMetrics(_node->getPartitions().size(), loadTypes.getMetricLoadTypes(),1,  1);
     FileStorHandler filestorHandler(messageSender, metrics, _node->getPartitions(), _node->getComponentRegister());
     spi::Context context(defaultLoadType, spi::Priority(0), spi::Trace::TraceLevel(0));
     for (uint32_t j=0; j<1; ++j) {
@@ -1418,7 +1417,7 @@ FileStorManagerTest::testSplitEmptyTargetWithRemappedOps()
     ForwardingMessageSender messageSender(*dummyManager);
     documentapi::LoadTypeSet loadTypes("raw:");
     FileStorMetrics metrics(loadTypes.getMetricLoadTypes());
-    metrics.initDiskMetrics(_node->getPartitions().size(), loadTypes.getMetricLoadTypes(), 1);
+    metrics.initDiskMetrics(_node->getPartitions().size(), loadTypes.getMetricLoadTypes(), 1, 1);
     FileStorHandler filestorHandler(messageSender, metrics, _node->getPartitions(), _node->getComponentRegister());
     std::unique_ptr<DiskThread> thread(createThread(
             *config, *_node, _node->getPersistenceProvider(),
@@ -1495,7 +1494,7 @@ FileStorManagerTest::testNotifyOnSplitSourceOwnershipChanged()
     ForwardingMessageSender messageSender(*dummyManager);
     documentapi::LoadTypeSet loadTypes("raw:");
     FileStorMetrics metrics(loadTypes.getMetricLoadTypes());
-    metrics.initDiskMetrics(_node->getPartitions().size(), loadTypes.getMetricLoadTypes(), 1);
+    metrics.initDiskMetrics(_node->getPartitions().size(), loadTypes.getMetricLoadTypes(), 1, 1);
     FileStorHandler filestorHandler(messageSender, metrics, _node->getPartitions(), _node->getComponentRegister());
     std::unique_ptr<DiskThread> thread(createThread(
             *config, *_node, _node->getPersistenceProvider(),
@@ -1544,7 +1543,7 @@ FileStorManagerTest::testJoin()
 
     documentapi::LoadTypeSet loadTypes("raw:");
     FileStorMetrics metrics(loadTypes.getMetricLoadTypes());
-    metrics.initDiskMetrics(_node->getPartitions().size(), loadTypes.getMetricLoadTypes(), 1);
+    metrics.initDiskMetrics(_node->getPartitions().size(), loadTypes.getMetricLoadTypes(), 1, 1);
     FileStorHandler filestorHandler(messageSender, metrics, _node->getPartitions(), _node->getComponentRegister());
     std::unique_ptr<DiskThread> thread(createThread(
             *config, *_node, _node->getPersistenceProvider(),
diff --git a/storage/src/tests/persistence/persistencequeuetest.cpp b/storage/src/tests/persistence/persistencequeuetest.cpp
index 1a0b549ceed..f31623eed61 100644
--- a/storage/src/tests/persistence/persistencequeuetest.cpp
+++ b/storage/src/tests/persistence/persistencequeuetest.cpp
@@ -73,8 +73,7 @@ PersistenceQueueTest::testFetchNextUnlockedMessageIfBucketLocked()
 
     documentapi::LoadTypeSet loadTypes("raw:");
     FileStorMetrics metrics(loadTypes.getMetricLoadTypes());
-    metrics.initDiskMetrics(_node->getPartitions().size(),
-                            loadTypes.getMetricLoadTypes(), 1);
+    metrics.initDiskMetrics(_node->getPartitions().size(), loadTypes.getMetricLoadTypes(), 1, 1);
 
     FileStorHandler filestorHandler(messageSender, metrics, _node->getPartitions(), _node->getComponentRegister());
     uint32_t stripeId = filestorHandler.getNextStripeId(0);
diff --git a/storage/src/tests/persistence/persistencetestutils.cpp b/storage/src/tests/persistence/persistencetestutils.cpp
index 2e382444d4c..396cc0d70de 100644
--- a/storage/src/tests/persistence/persistencetestutils.cpp
+++ b/storage/src/tests/persistence/persistencetestutils.cpp
@@ -51,8 +51,7 @@ PersistenceTestEnvironment::PersistenceTestEnvironment(DiskCount numDisks, const
       _metrics(_component.getLoadTypes()->getMetricLoadTypes())
 {
     _node.setupDummyPersistence();
-    _metrics.initDiskMetrics(
-            numDisks, _node.getLoadTypes()->getMetricLoadTypes(), 1);
+    _metrics.initDiskMetrics(numDisks, _node.getLoadTypes()->getMetricLoadTypes(), 1, 1);
     _handler.reset(new FileStorHandler(_messageKeeper, _metrics,
                                        _node.getPersistenceProvider().getPartitionStates().getList(),
                                        _node.getComponentRegister()));
diff --git a/storage/src/tests/storageserver/statereportertest.cpp b/storage/src/tests/storageserver/statereportertest.cpp
index 3a71444e74c..f4bf7685225 100644
--- a/storage/src/tests/storageserver/statereportertest.cpp
+++ b/storage/src/tests/storageserver/statereportertest.cpp
@@ -103,10 +103,8 @@ void StateReporterTest::setUp() {
     uint16_t diskCount = _node->getPartitions().size();
     documentapi::LoadTypeSet::SP loadTypes(_node->getLoadTypes());
 
-    _filestorMetrics.reset(new FileStorMetrics(
-            _node->getLoadTypes()->getMetricLoadTypes()));
-    _filestorMetrics->initDiskMetrics(
-            diskCount, loadTypes->getMetricLoadTypes(), 1);
+    _filestorMetrics.reset(new FileStorMetrics(_node->getLoadTypes()->getMetricLoadTypes()));
+    _filestorMetrics->initDiskMetrics(diskCount, loadTypes->getMetricLoadTypes(), 1, 1);
     _topSet->registerMetric(*_filestorMetrics);
 
     _metricManager->init(_config->getConfigId(), _node->getThreadPool());
diff --git a/storage/src/vespa/storage/persistence/filestorage/filestorhandlerimpl.cpp b/storage/src/vespa/storage/persistence/filestorage/filestorhandlerimpl.cpp
index e36f982a354..f88570164d5 100644
--- a/storage/src/vespa/storage/persistence/filestorage/filestorhandlerimpl.cpp
+++ b/storage/src/vespa/storage/persistence/filestorage/filestorhandlerimpl.cpp
@@ -41,6 +41,10 @@ FileStorHandlerImpl::FileStorHandlerImpl(uint32_t numStripes, MessageSender& sen
     for (uint32_t i=0; i<_diskInfo.size(); ++i) {
         _diskInfo[i].metrics = metrics.disks[i].get();
         assert(_diskInfo[i].metrics != 0);
+        uint32_t j(0);
+        for (Stripe & stripe : _diskInfo[i].getStripes()) {
+            stripe.setMetrics(metrics.disks[i]->stripes[j++].get());
+        }
     }
 
     if (_diskInfo.size() == 0) {
@@ -924,7 +928,7 @@ FileStorHandlerImpl::Stripe::getNextMessage(uint32_t timeout, Disk & disk)
             iter++;
         }
         if (iter != end) {
-            return getMessage(guard, disk, idx, iter);
+            return getMessage(guard, idx, iter);
         }
         if (attempt == 0) {
             guard.wait(timeout);
@@ -934,7 +938,7 @@ FileStorHandlerImpl::Stripe::getNextMessage(uint32_t timeout, Disk & disk)
 }
 
 FileStorHandler::LockedMessage &
-FileStorHandlerImpl::Stripe::getNextMessage(Disk & disk, FileStorHandler::LockedMessage& lck)
+FileStorHandlerImpl::Stripe::getNextMessage(FileStorHandler::LockedMessage& lck)
 {
     const document::Bucket & bucket = lck.second->getBucket();
     vespalib::MonitorGuard guard(_lock);
@@ -949,7 +953,7 @@ FileStorHandlerImpl::Stripe::getNextMessage(Disk & disk, FileStorHandler::Locked
 
     api::StorageMessage & m(*range.first->_command);
 
-    uint64_t waitTime(range.first->_timer.stop(disk.metrics->averageQueueWaitingTime[m.getLoadType()]));
+    uint64_t waitTime(range.first->_timer.stop(_metrics->averageQueueWaitingTime[m.getLoadType()]));
 
     if (!messageTimedOutInQueue(m, waitTime)) {
         std::shared_ptr<api::StorageMessage> msg = std::move(range.first->_command);
@@ -970,10 +974,10 @@ FileStorHandlerImpl::Stripe::getNextMessage(Disk & disk, FileStorHandler::Locked
 }
 
 FileStorHandler::LockedMessage
-FileStorHandlerImpl::Stripe::getMessage(vespalib::MonitorGuard & guard, Disk & disk, PriorityIdx & idx, PriorityIdx::iterator iter) {
+FileStorHandlerImpl::Stripe::getMessage(vespalib::MonitorGuard & guard, PriorityIdx & idx, PriorityIdx::iterator iter) {
 
     api::StorageMessage & m(*iter->_command);
-    uint64_t waitTime(iter->_timer.stop(disk.metrics->averageQueueWaitingTime[m.getLoadType()]));
+    uint64_t waitTime(iter->_timer.stop(_metrics->averageQueueWaitingTime[m.getLoadType()]));
 
     std::shared_ptr<api::StorageMessage> msg = std::move(iter->_command);
     document::Bucket bucket(iter->_bucket);
diff --git a/storage/src/vespa/storage/persistence/filestorage/filestorhandlerimpl.h b/storage/src/vespa/storage/persistence/filestorage/filestorhandlerimpl.h
index c653af9b6bc..4d601ebfe6a 100644
--- a/storage/src/vespa/storage/persistence/filestorage/filestorhandlerimpl.h
+++ b/storage/src/vespa/storage/persistence/filestorage/filestorhandlerimpl.h
@@ -34,6 +34,7 @@
 namespace storage {
 
 class FileStorDiskMetrics;
+class FileStorStripeMetrics;
 class StorBucketDatabase;
 class AbortBucketOperationsCommand;
 
@@ -118,20 +119,22 @@ public:
         void failOperations(const document::Bucket & bucket, const api::ReturnCode & code);
 
         FileStorHandler::LockedMessage getNextMessage(uint32_t timeout, Disk & disk);
-        FileStorHandler::LockedMessage & getNextMessage(Disk & disk, FileStorHandler::LockedMessage& lock);
+        FileStorHandler::LockedMessage & getNextMessage(FileStorHandler::LockedMessage& lock);
         void dumpQueue(std::ostream & os) const;
         void dumpActiveHtml(std::ostream & os) const;
         void dumpQueueHtml(std::ostream & os) const;
         vespalib::Monitor & exposeLock() { return _lock; }
         PriorityQueue & exposeQueue() { return _queue; }
         BucketIdx & exposeBucketIdx() { return bmi::get<2>(_queue); }
+        void setMetrics(FileStorStripeMetrics * metrics) { _metrics = metrics; }
     private:
         bool hasActive(vespalib::MonitorGuard & monitor, const AbortBucketOperationsCommand& cmd) const;
-        FileStorHandler::LockedMessage getMessage(vespalib::MonitorGuard & guard, Disk & t,
-                                                  PriorityIdx & idx, PriorityIdx::iterator iter);
+        FileStorHandler::LockedMessage getMessage(vespalib::MonitorGuard & guard, PriorityIdx & idx,
+                                                  PriorityIdx::iterator iter);
         typedef vespalib::hash_map<document::Bucket, LockEntry, document::Bucket::hash> LockedBuckets;
         const FileStorHandlerImpl  &_owner;
         MessageSender              &_messageSender;
+        FileStorStripeMetrics      *_metrics;
         vespalib::Monitor           _lock;
         PriorityQueue               _queue;
         LockedBuckets               _lockedBuckets;
@@ -170,7 +173,7 @@ public:
             return _stripes[stripeId].getNextMessage(timeout, *this);
         }
         FileStorHandler::LockedMessage & getNextMessage(uint32_t stripeId, FileStorHandler::LockedMessage & lck) {
-            return _stripes[stripeId].getNextMessage(*this, lck);
+            return _stripes[stripeId].getNextMessage(lck);
         }
         std::shared_ptr<FileStorHandler::BucketLockInterface>
         lock(const document::Bucket & bucket) {
@@ -188,6 +191,7 @@ public:
         Stripe & stripe(const document::Bucket & bucket) {
             return _stripes[bucket.getBucketId().getRawId()%_stripes.size()];
         }
+        std::vector<Stripe> & getStripes() { return _stripes; }
     private:
         uint32_t              _nextStripeId;
         std::vector<Stripe>   _stripes;
diff --git a/storage/src/vespa/storage/persistence/filestorage/filestormanager.cpp b/storage/src/vespa/storage/persistence/filestorage/filestormanager.cpp
index 094f6b44389..710ad53c1a8 100644
--- a/storage/src/vespa/storage/persistence/filestorage/filestormanager.cpp
+++ b/storage/src/vespa/storage/persistence/filestorage/filestormanager.cpp
@@ -112,9 +112,10 @@ FileStorManager::configure(std::unique_ptr<vespa::config::content::StorFilestorC
         _disks.resize(_component.getDiskCount());
 
         size_t numThreads = _config->numThreads;
-        _metrics->initDiskMetrics(_disks.size(), _component.getLoadTypes()->getMetricLoadTypes(), numThreads);
+        size_t numStripes = std::min(numThreads, numThreads);
+        _metrics->initDiskMetrics(_disks.size(), _component.getLoadTypes()->getMetricLoadTypes(), numStripes, numThreads);
 
-        _filestorHandler.reset(new FileStorHandler(std::min(numThreads, numThreads), *this, *_metrics, _partitions, _compReg));
+        _filestorHandler.reset(new FileStorHandler(numStripes, *this, *_metrics, _partitions, _compReg));
         for (uint32_t i=0; i<_component.getDiskCount(); ++i) {
             if (_partitions[i].isUp()) {
                 LOG(spam, "Setting up disk %u", i);
diff --git a/storage/src/vespa/storage/persistence/filestorage/filestormetrics.cpp b/storage/src/vespa/storage/persistence/filestorage/filestormetrics.cpp
index cc7a26e8894..9bf8eab8df6 100644
--- a/storage/src/vespa/storage/persistence/filestorage/filestormetrics.cpp
+++ b/storage/src/vespa/storage/persistence/filestorage/filestormetrics.cpp
@@ -92,7 +92,7 @@ FileStorThreadMetrics::Visitor::clone(std::vector<Metric::UP>& ownerList,
 }
 
 FileStorThreadMetrics::FileStorThreadMetrics(const std::string& name, const std::string& desc, const LoadTypeSet& lt)
-    : MetricSet(name, "filestor partofsum thread", desc, NULL, "thread"),
+    : MetricSet(name, "filestor partofsum thread", desc, nullptr, "thread"),
       operations("operations", "", "Number of operations processed.", this),
       failedOperations("failedoperations", "", "Number of operations throwing exceptions.", this),
       put(lt, *&Op("put", "Put"), this),
@@ -146,18 +146,27 @@ FileStorThreadMetrics::FileStorThreadMetrics(const std::string& name, const std:
                    "batches of size > 1)", this)
 { }
 
-FileStorThreadMetrics::~FileStorThreadMetrics() { }
+FileStorThreadMetrics::~FileStorThreadMetrics() = default;
+
+FileStorStripeMetrics::FileStorStripeMetrics(const std::string& name, const std::string& description,
+                                             const LoadTypeSet& loadTypes)
+    : MetricSet(name, "partofsum stripe", description, nullptr, "stripe"),
+      averageQueueWaitingTime(loadTypes,
+                              metrics::DoubleAverageMetric("averagequeuewait", "",
+                                                           "Average time an operation spends in input queue."),
+                              this)
+{
+}
+
+FileStorStripeMetrics::~FileStorStripeMetrics() = default;
 
 FileStorDiskMetrics::FileStorDiskMetrics(const std::string& name,
                                          const std::string& description,
-                                         const LoadTypeSet& loadTypes,
                                          MetricSet* owner)
     : MetricSet(name, "partofsum disk", description, owner, "disk"),
-      sum("allthreads", "sum", "", this),
+      sumThreads("allthreads", "sum", "", this),
+      sumStripes("allstripes", "sum", "", this),
       queueSize("queuesize", "", "Size of input message queue.", this),
-      averageQueueWaitingTime(loadTypes, metrics::DoubleAverageMetric(
-              "averagequeuewait", "",
-              "Average time an operation spends in input queue."), this),
       pendingMerges("pendingmerge", "", "Number of buckets currently being merged.", this),
       waitingForLockHitRate("waitingforlockrate", "",
               "Amount of times a filestor thread has needed to wait for "
@@ -168,10 +177,10 @@ FileStorDiskMetrics::FileStorDiskMetrics(const std::string& name,
     waitingForLockHitRate.unsetOnZeroValue();
 }
 
-FileStorDiskMetrics::~FileStorDiskMetrics() { }
+FileStorDiskMetrics::~FileStorDiskMetrics() = default;
 
 void
-FileStorDiskMetrics::initDiskMetrics(const LoadTypeSet& loadTypes, uint32_t threadsPerDisk)
+FileStorDiskMetrics::initDiskMetrics(const LoadTypeSet& loadTypes, uint32_t numStripes, uint32_t threadsPerDisk)
 {
     threads.clear();
     threads.resize(threadsPerDisk);
@@ -180,9 +189,20 @@ FileStorDiskMetrics::initDiskMetrics(const LoadTypeSet& loadTypes, uint32_t thre
         std::ostringstream name;
         name << "thread" << i;
         desc << "Thread " << i << '/' << threadsPerDisk;
-        threads[i] = std::shared_ptr<FileStorThreadMetrics>(new FileStorThreadMetrics(name.str(), desc.str(), loadTypes));
+        threads[i] = std::make_shared<FileStorThreadMetrics>(name.str(), desc.str(), loadTypes);
         registerMetric(*threads[i]);
-        sum.addMetricToSum(*threads[i]);
+        sumThreads.addMetricToSum(*threads[i]);
+    }
+    stripes.clear();
+    stripes.resize(numStripes);
+    for (uint32_t i=0; i<numStripes; ++i) {
+        std::ostringstream desc;
+        std::ostringstream name;
+        name << "stripe" << i;
+        desc << "Stripe " << i << '/' << numStripes;
+        stripes[i] = std::make_shared<FileStorStripeMetrics>(name.str(), desc.str(), loadTypes);
+        registerMetric(*stripes[i]);
+        sumStripes.addMetricToSum(*stripes[i]);
     }
 }
 
@@ -194,9 +214,9 @@ FileStorMetrics::FileStorMetrics(const LoadTypeSet&)
       diskEvents("diskevents", "", "Number of disk events received.", this)
 { }
 
-FileStorMetrics::~FileStorMetrics() { }
+FileStorMetrics::~FileStorMetrics() = default;
 
-void FileStorMetrics::initDiskMetrics(uint16_t numDisks, const LoadTypeSet& loadTypes, uint32_t threadsPerDisk)
+void FileStorMetrics::initDiskMetrics(uint16_t numDisks, const LoadTypeSet& loadTypes, uint32_t numStripes, uint32_t threadsPerDisk)
 {
     if (!disks.empty()) {
         throw vespalib::IllegalStateException("Can't initialize disks twice", VESPA_STRLOC);
@@ -210,9 +230,9 @@ void FileStorMetrics::initDiskMetrics(uint16_t numDisks, const LoadTypeSet& load
         std::ostringstream name;
         name << "disk_" << i;
         desc << "Disk " << i;
-        disks[i] = FileStorDiskMetrics::SP(new FileStorDiskMetrics( name.str(), desc.str(), loadTypes, this));
+        disks[i] = std::make_shared<FileStorDiskMetrics>( name.str(), desc.str(), this);
         sum.addMetricToSum(*disks[i]);
-        disks[i]->initDiskMetrics(loadTypes, threadsPerDisk);
+        disks[i]->initDiskMetrics(loadTypes, numStripes, threadsPerDisk);
     }
 }
 
diff --git a/storage/src/vespa/storage/persistence/filestorage/filestormetrics.h b/storage/src/vespa/storage/persistence/filestorage/filestormetrics.h
index d4dadf94184..c8dbbb81eab 100644
--- a/storage/src/vespa/storage/persistence/filestorage/filestormetrics.h
+++ b/storage/src/vespa/storage/persistence/filestorage/filestormetrics.h
@@ -106,24 +106,34 @@ struct FileStorThreadMetrics : public metrics::MetricSet
     ~FileStorThreadMetrics();
 };
 
+class FileStorStripeMetrics : public metrics::MetricSet
+{
+public:
+    using SP = std::shared_ptr<FileStorStripeMetrics>;
+    metrics::LoadMetric<metrics::DoubleAverageMetric> averageQueueWaitingTime;
+    FileStorStripeMetrics(const std::string& name, const std::string& description,
+                          const metrics::LoadTypeSet& loadTypes);
+    ~FileStorStripeMetrics();
+};
+
 class FileStorDiskMetrics : public metrics::MetricSet
 {
 public:
-    typedef std::shared_ptr<FileStorDiskMetrics> SP;
+    using SP = std::shared_ptr<FileStorDiskMetrics>;
 
     std::vector<FileStorThreadMetrics::SP> threads;
-    metrics::SumMetric<MetricSet> sum;
+    std::vector<FileStorStripeMetrics::SP> stripes;
+    metrics::SumMetric<MetricSet> sumThreads;
+    metrics::SumMetric<MetricSet> sumStripes;
     metrics::LongAverageMetric queueSize;
-    metrics::LoadMetric<metrics::DoubleAverageMetric> averageQueueWaitingTime;
     metrics::LongAverageMetric pendingMerges;
     metrics::DoubleAverageMetric waitingForLockHitRate;
     metrics::DoubleAverageMetric lockWaitTime;
 
-    FileStorDiskMetrics(const std::string& name, const std::string& description,
-                        const metrics::LoadTypeSet& loadTypes, MetricSet* owner);
+    FileStorDiskMetrics(const std::string& name, const std::string& description, MetricSet* owner);
     ~FileStorDiskMetrics();
 
-    void initDiskMetrics(const metrics::LoadTypeSet& loadTypes, uint32_t threadsPerDisk);
+    void initDiskMetrics(const metrics::LoadTypeSet& loadTypes, uint32_t numStripes, uint32_t threadsPerDisk);
 };
 
 struct FileStorMetrics : public metrics::MetricSet
@@ -137,7 +147,7 @@ struct FileStorMetrics : public metrics::MetricSet
     FileStorMetrics(const metrics::LoadTypeSet&);
     ~FileStorMetrics();
 
-    void initDiskMetrics(uint16_t numDisks, const metrics::LoadTypeSet& loadTypes, uint32_t threadsPerDisk);
+    void initDiskMetrics(uint16_t numDisks, const metrics::LoadTypeSet& loadTypes, uint32_t numStripes, uint32_t threadsPerDisk);
 };
 
 }