You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ignite.apache.org by ni...@apache.org on 2020/12/30 08:04:36 UTC
[ignite] branch master updated: IGNITE-13845 Add checkpoint metrics
(#8572)
This is an automated email from the ASF dual-hosted git repository.
nizhikov pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/ignite.git
The following commit(s) were added to refs/heads/master by this push:
new 25da46c IGNITE-13845 Add checkpoint metrics (#8572)
25da46c is described below
commit 25da46c53e3b859db7863d3fef21388d08ad8c8c
Author: Nikita Amelchev <ns...@gmail.com>
AuthorDate: Wed Dec 30 11:04:14 2020 +0300
IGNITE-13845 Add checkpoint metrics (#8572)
---
.../cache/persistence/DataStorageMetricsImpl.java | 141 ++++++++++++++++++++-
.../cache/persistence/checkpoint/Checkpointer.java | 6 +
.../IgniteDataStorageMetricsSelfTest.java | 117 ++++++++++++++++-
3 files changed, 261 insertions(+), 3 deletions(-)
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/DataStorageMetricsImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/DataStorageMetricsImpl.java
index 80006d8..568a0bc 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/DataStorageMetricsImpl.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/DataStorageMetricsImpl.java
@@ -19,9 +19,11 @@ package org.apache.ignite.internal.processors.cache.persistence;
import java.util.Collection;
import org.apache.ignite.DataRegionMetrics;
import org.apache.ignite.internal.pagemem.wal.IgniteWriteAheadLogManager;
+import org.apache.ignite.internal.pagemem.wal.record.CheckpointRecord;
import org.apache.ignite.internal.processors.metric.GridMetricManager;
import org.apache.ignite.internal.processors.metric.MetricRegistry;
import org.apache.ignite.internal.processors.metric.impl.AtomicLongMetric;
+import org.apache.ignite.internal.processors.metric.impl.HistogramMetricImpl;
import org.apache.ignite.internal.processors.metric.impl.HitRateMetric;
import org.apache.ignite.internal.util.typedef.F;
import org.apache.ignite.internal.util.typedef.internal.U;
@@ -51,12 +53,21 @@ public class DataStorageMetricsImpl implements DataStorageMetricsMXBean {
private final HitRateMetric walBuffPollSpinsNum;
/** */
+ private final AtomicLongMetric lastCpBeforeLockDuration;
+
+ /** */
private final AtomicLongMetric lastCpLockWaitDuration;
/** */
+ private final AtomicLongMetric lastCpListenersExecuteDuration;
+
+ /** */
private final AtomicLongMetric lastCpMarkDuration;
/** */
+ private final AtomicLongMetric lastCpLockHoldDuration;
+
+ /** */
private final AtomicLongMetric lastCpPagesWriteDuration;
/** */
@@ -69,6 +80,15 @@ public class DataStorageMetricsImpl implements DataStorageMetricsMXBean {
private final AtomicLongMetric lastCpFsyncDuration;
/** */
+ private final AtomicLongMetric lastCpWalRecordFsyncDuration;
+
+ /** */
+ private final AtomicLongMetric lastCpWriteEntryDuration;
+
+ /** */
+ private final AtomicLongMetric lastCpSplitAndSortPagesDuration;
+
+ /** */
private final AtomicLongMetric lastCpTotalPages;
/** */
@@ -107,6 +127,39 @@ public class DataStorageMetricsImpl implements DataStorageMetricsMXBean {
/** */
private final AtomicLongMetric sparseStorageSize;
+ /** */
+ private final HistogramMetricImpl cpBeforeLockHistogram;
+
+ /** */
+ private final HistogramMetricImpl cpLockWaitHistogram;
+
+ /** */
+ private final HistogramMetricImpl cpListenersExecuteHistogram;
+
+ /** */
+ private final HistogramMetricImpl cpMarkHistogram;
+
+ /** */
+ private final HistogramMetricImpl cpLockHoldHistogram;
+
+ /** */
+ private final HistogramMetricImpl cpPagesWriteHistogram;
+
+ /** */
+ private final HistogramMetricImpl cpFsyncHistogram;
+
+ /** */
+ private final HistogramMetricImpl cpWalRecordFsyncHistogram;
+
+ /** */
+ private final HistogramMetricImpl cpWriteEntryHistogram;
+
+ /** */
+ private final HistogramMetricImpl cpSplitAndSortPagesHistogram;
+
+ /** */
+ private final HistogramMetricImpl cpHistogram;
+
/**
* @param mmgr Metrics manager.
* @param metricsEnabled Metrics enabled flag.
@@ -154,11 +207,20 @@ public class DataStorageMetricsImpl implements DataStorageMetricsMXBean {
rateTimeInterval,
subInts);
+ lastCpBeforeLockDuration = mreg.longMetric("LastCheckpointBeforeLockDuration",
+ "Duration of the checkpoint action before taken write lock in milliseconds.");
+
lastCpLockWaitDuration = mreg.longMetric("LastCheckpointLockWaitDuration",
"Duration of the checkpoint lock wait in milliseconds.");
+ lastCpListenersExecuteDuration = mreg.longMetric("LastCheckpointListenersExecuteDuration",
+ "Duration of the checkpoint execution listeners under write lock in milliseconds.");
+
lastCpMarkDuration = mreg.longMetric("LastCheckpointMarkDuration",
- "Duration of the checkpoint lock wait in milliseconds.");
+ "Duration of the checkpoint mark in milliseconds.");
+
+ lastCpLockHoldDuration = mreg.longMetric("LastCheckpointLockHoldDuration",
+ "Duration of the checkpoint lock hold in milliseconds.");
lastCpPagesWriteDuration = mreg.longMetric("LastCheckpointPagesWriteDuration",
"Duration of the checkpoint pages write in milliseconds.");
@@ -172,6 +234,16 @@ public class DataStorageMetricsImpl implements DataStorageMetricsMXBean {
lastCpFsyncDuration = mreg.longMetric("LastCheckpointFsyncDuration",
"Duration of the sync phase of the last checkpoint in milliseconds.");
+ lastCpWalRecordFsyncDuration = mreg.longMetric("LastCheckpointWalRecordFsyncDuration",
+ "Duration of the WAL fsync after logging CheckpointRecord on begin of the last checkpoint " +
+ "in milliseconds.");
+
+ lastCpWriteEntryDuration = mreg.longMetric("LastCheckpointWriteEntryDuration",
+ "Duration of entry buffer writing to file of the last checkpoint in milliseconds.");
+
+ lastCpSplitAndSortPagesDuration = mreg.longMetric("LastCheckpointSplitAndSortPagesDuration",
+ "Duration of splitting and sorting checkpoint pages of the last checkpoint in milliseconds.");
+
lastCpTotalPages = mreg.longMetric("LastCheckpointTotalPagesNumber",
"Total number of pages written during the last checkpoint.");
@@ -200,6 +272,42 @@ public class DataStorageMetricsImpl implements DataStorageMetricsMXBean {
mreg.register("WalTotalSize",
this::getWalTotalSize,
"Total size in bytes for storage wal files.");
+
+ long[] cpBounds = new long[] {100, 500, 1000, 5000, 30000};
+
+ cpBeforeLockHistogram = mreg.histogram("CheckpointBeforeLockHistogram", cpBounds,
+ "Histogram of checkpoint action before taken write lock durations in milliseconds.");
+
+ cpLockWaitHistogram = mreg.histogram("CheckpointLockWaitHistogram", cpBounds,
+ "Histogram of checkpoint lock wait durations in milliseconds.");
+
+ cpListenersExecuteHistogram = mreg.histogram("CheckpointListenersExecuteHistogram", cpBounds,
+ "Histogram of checkpoint execution listeners under write lock durations in milliseconds.");
+
+ cpMarkHistogram = mreg.histogram("CheckpointMarkHistogram", cpBounds,
+ "Histogram of checkpoint mark durations in milliseconds.");
+
+ cpLockHoldHistogram = mreg.histogram("CheckpointLockHoldHistogram", cpBounds,
+ "Histogram of checkpoint lock hold durations in milliseconds.");
+
+ cpPagesWriteHistogram = mreg.histogram("CheckpointPagesWriteHistogram", cpBounds,
+ "Histogram of checkpoint pages write durations in milliseconds.");
+
+ cpFsyncHistogram = mreg.histogram("CheckpointFsyncHistogram", cpBounds,
+ "Histogram of checkpoint fsync durations in milliseconds.");
+
+ cpWalRecordFsyncHistogram = mreg.histogram("CheckpointWalRecordFsyncHistogram", cpBounds,
+ "Histogram of the WAL fsync after logging CheckpointRecord on begin of checkpoint durations " +
+ "in milliseconds.");
+
+ cpWriteEntryHistogram = mreg.histogram("CheckpointWriteEntryHistogram", cpBounds,
+ "Histogram of entry buffer writing to file durations in milliseconds.");
+
+ cpSplitAndSortPagesHistogram = mreg.histogram("CheckpointSplitAndSortPagesHistogram", cpBounds,
+ "Histogram of splitting and sorting checkpoint pages durations in milliseconds.");
+
+ cpHistogram = mreg.histogram("CheckpointHistogram", cpBounds,
+ "Histogram of checkpoint durations in milliseconds.");
}
/** {@inheritDoc} */
@@ -596,20 +704,33 @@ public class DataStorageMetricsImpl implements DataStorageMetricsMXBean {
}
/**
+ * @param beforeLockDuration Checkpoint action before taken write lock duration.
* @param lockWaitDuration Lock wait duration.
+ * @param listenersExecuteDuration Execution listeners under write lock duration.
* @param markDuration Mark duration.
+ * @param lockHoldDuration Lock hold duration.
* @param pagesWriteDuration Pages write duration.
* @param fsyncDuration Total checkpoint fsync duration.
+ * @param walRecordFsyncDuration Duration of WAL fsync after logging {@link CheckpointRecord} on checkpoint begin.
+ * @param writeEntryDuration Duration of checkpoint entry buffer writing to file.
+ * @param splitAndSortPagesDuration Duration of splitting and sorting checkpoint pages.
* @param duration Total checkpoint duration.
+ * @param start Checkpoint start time.
* @param totalPages Total number of all pages in checkpoint.
* @param dataPages Total number of data pages in checkpoint.
* @param cowPages Total number of COW-ed pages in checkpoint.
*/
public void onCheckpoint(
+ long beforeLockDuration,
long lockWaitDuration,
+ long listenersExecuteDuration,
long markDuration,
+ long lockHoldDuration,
long pagesWriteDuration,
long fsyncDuration,
+ long walRecordFsyncDuration,
+ long writeEntryDuration,
+ long splitAndSortPagesDuration,
long duration,
long start,
long totalPages,
@@ -617,10 +738,16 @@ public class DataStorageMetricsImpl implements DataStorageMetricsMXBean {
long cowPages
) {
if (metricsEnabled) {
+ lastCpBeforeLockDuration.value(beforeLockDuration);
lastCpLockWaitDuration.value(lockWaitDuration);
+ lastCpListenersExecuteDuration.value(listenersExecuteDuration);
lastCpMarkDuration.value(markDuration);
+ lastCpLockHoldDuration.value(lockHoldDuration);
lastCpPagesWriteDuration.value(pagesWriteDuration);
lastCpFsyncDuration.value(fsyncDuration);
+ lastCpWalRecordFsyncDuration.value(walRecordFsyncDuration);
+ lastCpWriteEntryDuration.value(writeEntryDuration);
+ lastCpSplitAndSortPagesDuration.value(splitAndSortPagesDuration);
lastCpDuration.value(duration);
lastCpStart.value(start);
lastCpTotalPages.value(totalPages);
@@ -628,6 +755,18 @@ public class DataStorageMetricsImpl implements DataStorageMetricsMXBean {
lastCpCowPages.value(cowPages);
totalCheckpointTime.add(duration);
+
+ cpBeforeLockHistogram.value(beforeLockDuration);
+ cpLockWaitHistogram.value(lockWaitDuration);
+ cpListenersExecuteHistogram.value(listenersExecuteDuration);
+ cpMarkHistogram.value(markDuration);
+ cpLockHoldHistogram.value(lockHoldDuration);
+ cpPagesWriteHistogram.value(pagesWriteDuration);
+ cpFsyncHistogram.value(fsyncDuration);
+ cpWalRecordFsyncHistogram.value(walRecordFsyncDuration);
+ cpWriteEntryHistogram.value(writeEntryDuration);
+ cpSplitAndSortPagesHistogram.value(splitAndSortPagesDuration);
+ cpHistogram.value(duration);
}
}
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/checkpoint/Checkpointer.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/checkpoint/Checkpointer.java
index 63440b2..aa5e7fc 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/checkpoint/Checkpointer.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/checkpoint/Checkpointer.java
@@ -573,10 +573,16 @@ public class Checkpointer extends GridWorker {
private void updateMetrics(Checkpoint chp, CheckpointMetricsTracker tracker) {
if (persStoreMetrics.metricsEnabled()) {
persStoreMetrics.onCheckpoint(
+ tracker.beforeLockDuration(),
tracker.lockWaitDuration(),
+ tracker.listenersExecuteDuration(),
tracker.markDuration(),
+ tracker.lockHoldDuration(),
tracker.pagesWriteDuration(),
tracker.fsyncDuration(),
+ tracker.walCpRecordFsyncDuration(),
+ tracker.writeCheckpointEntryDuration(),
+ tracker.splitAndSortCpPagesDuration(),
tracker.totalDuration(),
tracker.checkpointStartTime(),
chp.pagesSize,
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/persistence/IgniteDataStorageMetricsSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/persistence/IgniteDataStorageMetricsSelfTest.java
index 8583395..a06cad1 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/persistence/IgniteDataStorageMetricsSelfTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/persistence/IgniteDataStorageMetricsSelfTest.java
@@ -18,7 +18,12 @@
package org.apache.ignite.internal.processors.cache.persistence;
import java.io.Serializable;
+import java.util.Arrays;
import java.util.Objects;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
import org.apache.ignite.DataRegionMetrics;
import org.apache.ignite.DataStorageMetrics;
import org.apache.ignite.IgniteCache;
@@ -33,16 +38,22 @@ import org.apache.ignite.configuration.DataStorageConfiguration;
import org.apache.ignite.configuration.IgniteConfiguration;
import org.apache.ignite.configuration.WALMode;
import org.apache.ignite.internal.IgniteEx;
+import org.apache.ignite.internal.processors.metric.MetricRegistry;
+import org.apache.ignite.internal.processors.metric.impl.AtomicLongMetric;
import org.apache.ignite.internal.util.tostring.GridToStringInclude;
import org.apache.ignite.internal.util.typedef.PAX;
import org.apache.ignite.internal.util.typedef.internal.S;
-import org.apache.ignite.testframework.GridTestUtils;
+import org.apache.ignite.spi.metric.HistogramMetric;
+import org.apache.ignite.testframework.ListeningTestLogger;
import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest;
import org.junit.Test;
import static org.apache.ignite.cache.CacheAtomicityMode.ATOMIC;
import static org.apache.ignite.cache.CacheMode.PARTITIONED;
import static org.apache.ignite.cache.CacheWriteSynchronizationMode.FULL_SYNC;
+import static org.apache.ignite.cluster.ClusterState.ACTIVE;
+import static org.apache.ignite.internal.processors.cache.persistence.DataStorageMetricsImpl.DATASTORAGE_METRIC_PREFIX;
+import static org.apache.ignite.testframework.GridTestUtils.waitForCondition;
/**
*
@@ -54,6 +65,9 @@ public class IgniteDataStorageMetricsSelfTest extends GridCommonAbstractTest {
/** */
private static final String NO_PERSISTENCE = "no-persistence";
+ /** */
+ private final ListeningTestLogger listeningLog = new ListeningTestLogger(log);
+
/** {@inheritDoc} */
@Override protected void afterTestsStopped() throws Exception {
cleanPersistenceDir();
@@ -96,6 +110,8 @@ public class IgniteDataStorageMetricsSelfTest extends GridCommonAbstractTest {
cacheConfiguration(GROUP1, "cache", PARTITIONED, ATOMIC, 1, null),
cacheConfiguration(null, "cache-np", PARTITIONED, ATOMIC, 1, NO_PERSISTENCE));
+ cfg.setGridLogger(listeningLog);
+
return cfg;
}
@@ -175,7 +191,7 @@ public class IgniteDataStorageMetricsSelfTest extends GridCommonAbstractTest {
ig.context().cache().context().database().waitForCheckpoint("test");
- assertTrue(GridTestUtils.waitForCondition(new PAX() {
+ assertTrue(waitForCondition(new PAX() {
@Override public boolean applyx() {
DataStorageMetrics pMetrics = ig.dataStorageMetrics();
@@ -191,6 +207,103 @@ public class IgniteDataStorageMetricsSelfTest extends GridCommonAbstractTest {
}
}
+ /** @throws Exception if failed. */
+ @Test
+ public void testCheckpointMetrics() throws Exception {
+ Pattern cpPtrn = Pattern.compile("^Checkpoint started .*" +
+ "checkpointBeforeLockTime=(\\d+)ms, " +
+ "checkpointLockWait=(\\d+)ms, " +
+ "checkpointListenersExecuteTime=(\\d+)ms, " +
+ "checkpointLockHoldTime=(\\d+)ms, " +
+ "walCpRecordFsyncDuration=(\\d+)ms, " +
+ "writeCheckpointEntryDuration=(\\d+)ms, " +
+ "splitAndSortCpPagesDuration=(\\d+)ms");
+
+ AtomicLong expLastCpBeforeLockDuration = new AtomicLong();
+ AtomicLong expLastCpLockWaitDuration = new AtomicLong();
+ AtomicLong expLastCpListenersExecuteDuration = new AtomicLong();
+ AtomicLong expLastCpLockHoldDuration = new AtomicLong();
+ AtomicLong expLastCpWalRecordFsyncDuration = new AtomicLong();
+ AtomicLong expLastCpWriteEntryDuration = new AtomicLong();
+ AtomicLong expLastCpSplitAndSortPagesDuration = new AtomicLong();
+ AtomicInteger cpCnt = new AtomicInteger();
+
+ listeningLog.registerListener(s -> {
+ Matcher matcher = cpPtrn.matcher(s);
+
+ if (!matcher.find())
+ return;
+
+ expLastCpBeforeLockDuration.set(Long.parseLong(matcher.group(1)));
+ expLastCpLockWaitDuration.set(Long.parseLong(matcher.group(2)));
+ expLastCpListenersExecuteDuration.set(Long.parseLong(matcher.group(3)));
+ expLastCpLockHoldDuration.set(Long.parseLong(matcher.group(4)));
+ expLastCpWalRecordFsyncDuration.set(Long.parseLong(matcher.group(5)));
+ expLastCpWriteEntryDuration.set(Long.parseLong(matcher.group(6)));
+ expLastCpSplitAndSortPagesDuration.set(Long.parseLong(matcher.group(7)));
+ cpCnt.incrementAndGet();
+ });
+
+ IgniteEx node = startGrid(0);
+
+ node.cluster().state(ACTIVE);
+
+ GridCacheDatabaseSharedManager db = (GridCacheDatabaseSharedManager)node.context().cache().context().database();
+
+ db.checkpointReadLock();
+
+ try {
+ waitForCondition(() -> cpCnt.get() > 0, getTestTimeout());
+
+ MetricRegistry mreg = node.context().metric().registry(DATASTORAGE_METRIC_PREFIX);
+
+ AtomicLongMetric lastCpBeforeLockDuration = mreg.findMetric("LastCheckpointBeforeLockDuration");
+ AtomicLongMetric lastCpLockWaitDuration = mreg.findMetric("LastCheckpointLockWaitDuration");
+ AtomicLongMetric lastCpListenersExecuteDuration = mreg.findMetric("LastCheckpointListenersExecuteDuration");
+ AtomicLongMetric lastCpLockHoldDuration = mreg.findMetric("LastCheckpointLockHoldDuration");
+ AtomicLongMetric lastCpWalRecordFsyncDuration = mreg.findMetric("LastCheckpointWalRecordFsyncDuration");
+ AtomicLongMetric lastCpWriteEntryDuration = mreg.findMetric("LastCheckpointWriteEntryDuration");
+ AtomicLongMetric lastCpSplitAndSortPagesDuration =
+ mreg.findMetric("LastCheckpointSplitAndSortPagesDuration");
+
+ HistogramMetric cpBeforeLockHistogram = mreg.findMetric("CheckpointBeforeLockHistogram");
+ HistogramMetric cpLockWaitHistogram = mreg.findMetric("CheckpointLockWaitHistogram");
+ HistogramMetric cpListenersExecuteHistogram = mreg.findMetric("CheckpointListenersExecuteHistogram");
+ HistogramMetric cpMarkHistogram = mreg.findMetric("CheckpointMarkHistogram");
+ HistogramMetric cpLockHoldHistogram = mreg.findMetric("CheckpointLockHoldHistogram");
+ HistogramMetric cpPagesWriteHistogram = mreg.findMetric("CheckpointPagesWriteHistogram");
+ HistogramMetric cpFsyncHistogram = mreg.findMetric("CheckpointFsyncHistogram");
+ HistogramMetric cpWalRecordFsyncHistogram = mreg.findMetric("CheckpointWalRecordFsyncHistogram");
+ HistogramMetric cpWriteEntryHistogram = mreg.findMetric("CheckpointWriteEntryHistogram");
+ HistogramMetric cpSplitAndSortPagesHistogram = mreg.findMetric("CheckpointSplitAndSortPagesHistogram");
+ HistogramMetric cpHistogram = mreg.findMetric("CheckpointHistogram");
+
+ waitForCondition(() -> cpCnt.get() == Arrays.stream(cpHistogram.value()).sum(), getTestTimeout());
+
+ assertEquals(cpCnt.get(), Arrays.stream(cpBeforeLockHistogram.value()).sum());
+ assertEquals(cpCnt.get(), Arrays.stream(cpLockWaitHistogram.value()).sum());
+ assertEquals(cpCnt.get(), Arrays.stream(cpListenersExecuteHistogram.value()).sum());
+ assertEquals(cpCnt.get(), Arrays.stream(cpMarkHistogram.value()).sum());
+ assertEquals(cpCnt.get(), Arrays.stream(cpLockHoldHistogram.value()).sum());
+ assertEquals(cpCnt.get(), Arrays.stream(cpPagesWriteHistogram.value()).sum());
+ assertEquals(cpCnt.get(), Arrays.stream(cpFsyncHistogram.value()).sum());
+ assertEquals(cpCnt.get(), Arrays.stream(cpWalRecordFsyncHistogram.value()).sum());
+ assertEquals(cpCnt.get(), Arrays.stream(cpWriteEntryHistogram.value()).sum());
+ assertEquals(cpCnt.get(), Arrays.stream(cpSplitAndSortPagesHistogram.value()).sum());
+
+ assertEquals(expLastCpBeforeLockDuration.get(), lastCpBeforeLockDuration.value());
+ assertEquals(expLastCpLockWaitDuration.get(), lastCpLockWaitDuration.value());
+ assertEquals(expLastCpListenersExecuteDuration.get(), lastCpListenersExecuteDuration.value());
+ assertEquals(expLastCpLockHoldDuration.get(), lastCpLockHoldDuration.value());
+ assertEquals(expLastCpWalRecordFsyncDuration.get(), lastCpWalRecordFsyncDuration.value());
+ assertEquals(expLastCpWriteEntryDuration.get(), lastCpWriteEntryDuration.value());
+ assertEquals(expLastCpSplitAndSortPagesDuration.get(), lastCpSplitAndSortPagesDuration.value());
+ }
+ finally {
+ db.checkpointReadUnlock();
+ }
+ }
+
/**
*
*/