This is an automated email from the ASF dual-hosted git repository.
tkalkirill pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/ignite-3.git
The following commit(s) were added to refs/heads/main by this push:
new d8285e06d7 IGNITE-23819 Fix the time output in "Checkpoint finished"
(#4819)
d8285e06d7 is described below
commit d8285e06d793fc694bff575478727ab84709a48d
Author: Kirill Tkalenko <[email protected]>
AuthorDate: Tue Dec 3 13:44:22 2024 +0300
IGNITE-23819 Fix the time output in "Checkpoint finished" (#4819)
---
.../checkpoint/CheckpointMetricsTracker.java | 242 ++++++++++++---------
.../persistence/checkpoint/CheckpointWorkflow.java | 6 +-
.../persistence/checkpoint/Checkpointer.java | 17 +-
.../persistence/checkpoint/Duration.java | 56 +++++
.../checkpoint/CheckpointMetricsTrackerTest.java | 83 +++----
.../checkpoint/CheckpointWorkflowTest.java | 19 +-
6 files changed, 262 insertions(+), 161 deletions(-)
diff --git
a/modules/page-memory/src/main/java/org/apache/ignite/internal/pagememory/persistence/checkpoint/CheckpointMetricsTracker.java
b/modules/page-memory/src/main/java/org/apache/ignite/internal/pagememory/persistence/checkpoint/CheckpointMetricsTracker.java
index 5d68995520..e8429ea3bc 100644
---
a/modules/page-memory/src/main/java/org/apache/ignite/internal/pagememory/persistence/checkpoint/CheckpointMetricsTracker.java
+++
b/modules/page-memory/src/main/java/org/apache/ignite/internal/pagememory/persistence/checkpoint/CheckpointMetricsTracker.java
@@ -52,241 +52,289 @@ public class CheckpointMetricsTracker {
private final long startTimestamp =
FastTimestamps.coarseCurrentTimeMillis();
- private final long startNanos = System.nanoTime();
+ private final Duration checkpointDuration = new Duration();
- private long writeLockWaitStartNanos;
+ private final Duration writeLockWaitDuration = new Duration();
- private long onMarkCheckpointBeginEndNanos;
+ private final Duration onMarkCheckpointBeginDuration = new Duration();
- private long onMarkCheckpointBeginStartNanos;
+ private final Duration writeLockHoldDuration = new Duration();
- private long writeLockReleaseNanos;
+ private final Duration pagesWriteDuration = new Duration();
- private long pagesWriteStartNanos;
+ private final Duration fsyncDuration = new Duration();
- private long fsyncStartNanos;
+ private final Duration replicatorLogSyncDuration = new Duration();
- private long replicatorLogSyncStartNanos;
-
- private long endNanos;
-
- private long splitAndSortPagesStartNanos;
-
- private long splitAndSortPagesEndNanos;
+ private final Duration splitAndSortCheckpointPagesDuration = new
Duration();
/**
- * Returns checkpoint start timestamp in mills.
+ * Increments counter if copy on write page was written.
*
* <p>Thread safe.
*/
- public long checkpointStartTime() {
- return startTimestamp;
+ public void onCopyOnWritePageWritten() {
+ COPY_ON_WRITE_PAGES_WRITTEN_UPDATER.incrementAndGet(this);
}
/**
- * Callback on checkpoint end.
+ * Returns written copy on write pages.
*
- * <p>Not thread safe.
+ * <p>Thread safe.
*/
- public void onCheckpointEnd() {
- endNanos = System.nanoTime();
+ public int copyOnWritePagesWritten() {
+ return copyOnWritePagesWritten;
}
/**
- * Increments counter if copy on write page was written.
+ * Increments counter if data page was written.
*
* <p>Thread safe.
*/
- public void onCopyOnWritePageWritten() {
- COPY_ON_WRITE_PAGES_WRITTEN_UPDATER.incrementAndGet(this);
+ public void onDataPageWritten() {
+ DATA_PAGES_WRITTEN_UPDATER.incrementAndGet(this);
}
/**
- * Increments counter if data page was written.
+ * Returns data pages written.
*
* <p>Thread safe.
*/
- public void onDataPageWritten() {
- DATA_PAGES_WRITTEN_UPDATER.incrementAndGet(this);
+ public int dataPagesWritten() {
+ return dataPagesWritten;
}
/**
- * Returns written copy on write pages.
+ * Returns checkpoint start timestamp in mills.
*
- * <p>Thread safe.
+ * <p>Not thread safe.</p>
*/
- public int copyOnWritePagesWritten() {
- return copyOnWritePagesWritten;
+ public long checkpointStartTime() {
+ return startTimestamp;
}
/**
- * Returns data pages written.
+ * Callback on checkpoint start.
*
- * <p>Thread safe.
+ * <p>Not thread safe.</p>
*/
- public int dataPagesWritten() {
- return dataPagesWritten;
+ public void onCheckpointStart() {
+ checkpointDuration.onStart();
}
/**
- * Callback before acquiring checkpoint write lock.
+ * Callback on checkpoint end.
+ *
+ * <p>Not thread safe.</p>
+ */
+ public void onCheckpointEnd() {
+ checkpointDuration.onEnd();
+ }
+
+ /**
+ * Returns total checkpoint duration.
*
* <p>Not thread safe.
*/
+ public long checkpointDuration(TimeUnit timeUnit) {
+ return checkpointDuration.duration(timeUnit);
+ }
+
+ /**
+ * Callback before acquiring checkpoint write lock.
+ *
+ * <p>Not thread safe.</p>
+ */
public void onWriteLockWaitStart() {
- writeLockWaitStartNanos = System.nanoTime();
+ writeLockWaitDuration.onStart();
}
/**
- * Callback after release checkpoint write lock.
+ * Callback after acquiring checkpoint write lock.
*
- * <p>Not thread safe.
+ * <p>Not thread safe.</p>
*/
- public void onWriteLockRelease() {
- writeLockReleaseNanos = System.nanoTime();
+ public void onWriteLockWaitEnd() {
+ writeLockWaitDuration.onEnd();
+ }
+
+ /**
+ * Returns total acquiring checkpoint write lock duration.
+ *
+ * <p>Not thread safe.</p>
+ */
+ public long writeLockWaitDuration(TimeUnit timeUnit) {
+ return writeLockWaitDuration.duration(timeUnit);
}
/**
* Callback before all {@link CheckpointListener#onMarkCheckpointBegin}.
*
- * <p>Not thread safe.
+ * <p>Not thread safe.</p>
*/
public void onMarkCheckpointBeginStart() {
- onMarkCheckpointBeginStartNanos = System.nanoTime();
+ onMarkCheckpointBeginDuration.onStart();
}
/**
* Callback after all {@link CheckpointListener#onMarkCheckpointBegin}.
*
- * <p>Not thread safe.
+ * <p>Not thread safe.</p>
*/
public void onMarkCheckpointBeginEnd() {
- onMarkCheckpointBeginEndNanos = System.nanoTime();
+ onMarkCheckpointBeginDuration.onEnd();
+ }
+
+ /**
+ * Returns execution all {@link CheckpointListener#onMarkCheckpointBegin}
under write lock duration in the given time unit.
+ *
+ * <p>Not thread safe.</p>
+ */
+ public long onMarkCheckpointBeginDuration(TimeUnit timeUnit) {
+ return onMarkCheckpointBeginDuration.duration(timeUnit);
}
/**
* Callback on start writes pages to {@link PageStore}s.
*
- * <p>Not thread safe.
+ * <p>Not thread safe.</p>
*/
public void onPagesWriteStart() {
- pagesWriteStartNanos = System.nanoTime();
+ pagesWriteDuration.onStart();
+ }
+
+ /**
+ * Callback on end writes pages to {@link PageStore}s.
+ *
+ * <p>Not thread safe.</p>
+ */
+ public void onPagesWriteEnd() {
+ pagesWriteDuration.onEnd();
+ }
+
+ /**
+ * Returns pages write duration in the given time unit.
+ *
+ * <p>Not thread safe.</p>
+ */
+ public long pagesWriteDuration(TimeUnit timeUnit) {
+ return pagesWriteDuration.duration(timeUnit);
}
/**
* Callback on start fsync {@link PageStore}s.
*
- * <p>Not thread safe.
+ * <p>Not thread safe.</p>
*/
public void onFsyncStart() {
- fsyncStartNanos = System.nanoTime();
+ fsyncDuration.onStart();
}
/**
- * Callback before split and sort checkpoint pages.
+ * Callback on end fsync {@link PageStore}s.
*
- * <p>Not thread safe.
+ * <p>Not thread safe.</p>
*/
- public void onSplitAndSortCheckpointPagesStart() {
- splitAndSortPagesStartNanos = System.nanoTime();
+ public void onFsyncEnd() {
+ fsyncDuration.onEnd();
}
/**
- * Callback after split and sort checkpoint pages.
+ * Returns checkpoint fsync duration in the given time unit.
*
- * <p>Not thread safe.
+ * <p>Not thread safe.</p>
*/
- public void onSplitAndSortCheckpointPagesEnd() {
- splitAndSortPagesEndNanos = System.nanoTime();
+ public long fsyncDuration(TimeUnit timeUnit) {
+ return fsyncDuration.duration(timeUnit);
}
/**
- * Callback at the start of the replication protocol write-ahead-log sync.
+ * Callback before split and sort checkpoint pages.
*
- * <p>Not thread safe.
+ * <p>Not thread safe.</p>
*/
- public void onReplicatorLogSyncStart() {
- replicatorLogSyncStartNanos = System.nanoTime();
+ public void onSplitAndSortCheckpointPagesStart() {
+ splitAndSortCheckpointPagesDuration.onStart();
}
/**
- * Returns total checkpoint duration.
+ * Callback after split and sort checkpoint pages.
*
- * <p>Not thread safe.
+ * <p>Not thread safe.</p>
*/
- public long totalDuration(TimeUnit timeUnit) {
- return timeUnit.convert(endNanos - startNanos, NANOSECONDS);
+ public void onSplitAndSortCheckpointPagesEnd() {
+ splitAndSortCheckpointPagesDuration.onEnd();
}
/**
- * Returns checkpoint write lock wait duration in the given time unit.
+ * Returns duration of splitting and sorting checkpoint pages in mills.
*
- * <p>Not thread safe.
+ * <p>Not thread safe.</p>
*/
- public long writeLockWaitDuration(TimeUnit timeUnit) {
- return timeUnit.convert(onMarkCheckpointBeginStartNanos -
writeLockWaitStartNanos, NANOSECONDS);
+ public long splitAndSortCheckpointPagesDuration(TimeUnit timeUnit) {
+ return splitAndSortCheckpointPagesDuration.duration(timeUnit);
}
/**
- * Returns checkpoint action before taken write lock duration in the given
time unit.
+ * Callback at the start of the replication protocol write-ahead-log sync.
*
- * <p>Not thread safe.
+ * <p>Not thread safe.</p>
*/
- public long beforeWriteLockDuration(TimeUnit timeUnit) {
- return timeUnit.convert(writeLockWaitStartNanos - startNanos,
NANOSECONDS);
+ public void onReplicatorLogSyncStart() {
+ replicatorLogSyncDuration.onStart();
}
/**
- * Returns execution all {@link CheckpointListener#onMarkCheckpointBegin}
under write lock duration in the given time unit.
+ * Callback at the end of the replication protocol write-ahead-log sync.
*
- * <p>Not thread safe.
+ * <p>Not thread safe.</p>
*/
- public long onMarkCheckpointBeginDuration(TimeUnit timeUnit) {
- return timeUnit.convert(onMarkCheckpointBeginEndNanos -
onMarkCheckpointBeginStartNanos, NANOSECONDS);
+ public void onReplicatorLogSyncEnd() {
+ replicatorLogSyncDuration.onEnd();
}
/**
- * Returns checkpoint write lock hold duration in the given time unit.
+ * Returns checkpoint replication protocol write-ahead-log sync duration
in the given time unit.
*
- * <p>Not thread safe.
+ * <p>Not thread safe.</p>
*/
- public long writeLockHoldDuration(TimeUnit timeUnit) {
- return timeUnit.convert(writeLockReleaseNanos -
onMarkCheckpointBeginStartNanos, NANOSECONDS);
+ public long replicatorLogSyncDuration(TimeUnit timeUnit) {
+ return replicatorLogSyncDuration.duration(timeUnit);
}
/**
- * Returns pages write duration in the given time unit.
+ * Callback after acquire checkpoint write lock.
*
- * <p>Not thread safe.
+ * <p>Not thread safe.</p>
*/
- public long pagesWriteDuration(TimeUnit timeUnit) {
- return timeUnit.convert(fsyncStartNanos - pagesWriteStartNanos,
NANOSECONDS);
+ public void onWriteLockHoldStart() {
+ writeLockHoldDuration.onStart();
}
/**
- * Returns checkpoint fsync duration in the given time unit.
+ * Callback after release checkpoint write lock.
*
- * <p>Not thread safe.
+ * <p>Not thread safe.</p>
*/
- public long fsyncDuration(TimeUnit timeUnit) {
- return timeUnit.convert(endNanos - fsyncStartNanos, NANOSECONDS);
+ public void onWriteLockHoldEnd() {
+ writeLockHoldDuration.onEnd();
}
/**
- * Returns duration of splitting and sorting checkpoint pages in mills.
+ * Returns checkpoint write lock hold duration in the given time unit.
*
- * <p>Not thread safe.
+ * <p>Not thread safe.</p>
*/
- public long splitAndSortCheckpointPagesDuration(TimeUnit timeUnit) {
- return timeUnit.convert(splitAndSortPagesEndNanos -
splitAndSortPagesStartNanos, NANOSECONDS);
+ public long writeLockHoldDuration(TimeUnit timeUnit) {
+ return writeLockHoldDuration.duration(timeUnit);
}
/**
- * Returns checkpoint replication protocol write-ahead-log sync duration
in the given time unit.
+ * Returns checkpoint action before taken write lock duration in the given
time unit.
*
- * <p>Not thread safe.
+ * <p>Not thread safe.</p>
*/
- public long replicatorLogSyncDuration(TimeUnit timeUnit) {
- return timeUnit.convert(endNanos - replicatorLogSyncStartNanos,
NANOSECONDS);
+ public long beforeWriteLockDuration(TimeUnit timeUnit) {
+ return timeUnit.convert(writeLockWaitDuration.startNanos() -
checkpointDuration.startNanos(), NANOSECONDS);
}
}
diff --git
a/modules/page-memory/src/main/java/org/apache/ignite/internal/pagememory/persistence/checkpoint/CheckpointWorkflow.java
b/modules/page-memory/src/main/java/org/apache/ignite/internal/pagememory/persistence/checkpoint/CheckpointWorkflow.java
index 2f8415a544..99a0059e4a 100644
---
a/modules/page-memory/src/main/java/org/apache/ignite/internal/pagememory/persistence/checkpoint/CheckpointWorkflow.java
+++
b/modules/page-memory/src/main/java/org/apache/ignite/internal/pagememory/persistence/checkpoint/CheckpointWorkflow.java
@@ -233,6 +233,10 @@ class CheckpointWorkflow {
checkpointReadWriteLock.writeLock();
+ tracker.onWriteLockWaitEnd();
+
+ tracker.onWriteLockHoldStart();
+
DataRegionsDirtyPages dirtyPages;
try {
@@ -265,7 +269,7 @@ class CheckpointWorkflow {
} finally {
checkpointReadWriteLock.writeUnlock();
- tracker.onWriteLockRelease();
+ tracker.onWriteLockHoldEnd();
onReleaseWriteLock.run();
}
diff --git
a/modules/page-memory/src/main/java/org/apache/ignite/internal/pagememory/persistence/checkpoint/Checkpointer.java
b/modules/page-memory/src/main/java/org/apache/ignite/internal/pagememory/persistence/checkpoint/Checkpointer.java
index cf1de7712e..3cac430c33 100644
---
a/modules/page-memory/src/main/java/org/apache/ignite/internal/pagememory/persistence/checkpoint/Checkpointer.java
+++
b/modules/page-memory/src/main/java/org/apache/ignite/internal/pagememory/persistence/checkpoint/Checkpointer.java
@@ -325,6 +325,8 @@ public class Checkpointer extends IgniteWorker {
try {
var tracker = new CheckpointMetricsTracker();
+ tracker.onCheckpointStart();
+
startCheckpointProgress();
try {
@@ -385,9 +387,6 @@ public class Checkpointer extends IgniteWorker {
chp.progress.reason()
);
}
-
- tracker.onPagesWriteStart();
- tracker.onFsyncStart();
}
// Must mark successful checkpoint only if there are no exceptions
or interrupts.
@@ -397,7 +396,7 @@ public class Checkpointer extends IgniteWorker {
if (chp.hasDelta()) {
if (log.isInfoEnabled()) {
- float totalDurationInSeconds =
tracker.totalDuration(MILLISECONDS) / 1000.0f;
+ float totalDurationInSeconds =
tracker.checkpointDuration(MILLISECONDS) / 1000.0f;
float avgWriteSpeedInBytes = ((long) pageSize *
chp.dirtyPagesSize) / totalDurationInSeconds;
log.info(
@@ -406,8 +405,8 @@ public class Checkpointer extends IgniteWorker {
chp.dirtyPagesSize,
tracker.pagesWriteDuration(MILLISECONDS),
tracker.fsyncDuration(MILLISECONDS),
- tracker.replicatorLogSyncDuration(MICROSECONDS),
- tracker.totalDuration(MILLISECONDS),
+ tracker.replicatorLogSyncDuration(MILLISECONDS),
+ tracker.checkpointDuration(MILLISECONDS),
WriteSpeedFormatter.formatWriteSpeed(avgWriteSpeedInBytes)
);
}
@@ -480,6 +479,8 @@ public class Checkpointer extends IgniteWorker {
// Wait and check for errors.
CompletableFuture.allOf(futures).join();
+ tracker.onPagesWriteEnd();
+
// Must re-check shutdown flag here because threads may have skipped
some pages because of it.
// If so, we should not finish checkpoint.
if (shutdownNow.getAsBoolean()) {
@@ -505,6 +506,8 @@ public class Checkpointer extends IgniteWorker {
syncUpdatedPageStores(updatedPartitions, currentCheckpointProgress);
+ tracker.onFsyncEnd();
+
compactor.triggerCompaction();
if (shutdownNow.getAsBoolean()) {
@@ -900,6 +903,8 @@ public class Checkpointer extends IgniteWorker {
tracker.onReplicatorLogSyncStart();
logSyncer.sync();
+
+ tracker.onReplicatorLogSyncEnd();
} catch (Exception e) {
log.error("Failed to sync write-ahead log during checkpoint", e);
diff --git
a/modules/page-memory/src/main/java/org/apache/ignite/internal/pagememory/persistence/checkpoint/Duration.java
b/modules/page-memory/src/main/java/org/apache/ignite/internal/pagememory/persistence/checkpoint/Duration.java
new file mode 100644
index 0000000000..46433716c6
--- /dev/null
+++
b/modules/page-memory/src/main/java/org/apache/ignite/internal/pagememory/persistence/checkpoint/Duration.java
@@ -0,0 +1,56 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.pagememory.persistence.checkpoint;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Class for getting the duration of an operation.
+ *
+ * <p>Not thread safe.</p>
+ */
+class Duration {
+ private long startNanos;
+
+ private long endNanos;
+
+ /** Callback before the operation starts. */
+ void onStart() {
+ startNanos = System.nanoTime();
+ }
+
+ /** Callback after the end of the operation. */
+ void onEnd() {
+ endNanos = System.nanoTime();
+ }
+
+ /** Returns the start time of the operation in nanos. */
+ long startNanos() {
+ return startNanos;
+ }
+
+ /** Returns the end time of the operation in nanos. */
+ long endNanos() {
+ return startNanos;
+ }
+
+ /** Returns the duration in the specified time unit. */
+ long duration(TimeUnit timeUnit) {
+ return timeUnit.convert(endNanos - startNanos, TimeUnit.NANOSECONDS);
+ }
+}
diff --git
a/modules/page-memory/src/test/java/org/apache/ignite/internal/pagememory/persistence/checkpoint/CheckpointMetricsTrackerTest.java
b/modules/page-memory/src/test/java/org/apache/ignite/internal/pagememory/persistence/checkpoint/CheckpointMetricsTrackerTest.java
index 8ad44189ca..39452dfc8b 100644
---
a/modules/page-memory/src/test/java/org/apache/ignite/internal/pagememory/persistence/checkpoint/CheckpointMetricsTrackerTest.java
+++
b/modules/page-memory/src/test/java/org/apache/ignite/internal/pagememory/persistence/checkpoint/CheckpointMetricsTrackerTest.java
@@ -32,27 +32,30 @@ import org.junit.jupiter.api.Test;
* For {@link CheckpointMetricsTracker} testing.
*/
public class CheckpointMetricsTrackerTest {
+ private final CheckpointMetricsTracker tracker = new
CheckpointMetricsTracker();
+
@Test
- void testStartAndEndCheckpoint() throws Exception {
- CheckpointMetricsTracker tracker = new CheckpointMetricsTracker();
+ void testCheckpoint() {
+ assertThat(tracker.checkpointDuration(NANOSECONDS), equalTo(0L));
- long checkpointStartTime = tracker.checkpointStartTime();
-
- assertThat(checkpointStartTime, allOf(greaterThan(0L),
lessThanOrEqualTo(coarseCurrentTimeMillis())));
+ tracker.onCheckpointStart();
waitForTimeChange();
tracker.onCheckpointEnd();
- assertThat(tracker.checkpointStartTime(),
equalTo(checkpointStartTime));
+ assertThat(tracker.checkpointDuration(NANOSECONDS),
greaterThanOrEqualTo(1L));
+ }
- assertThat(tracker.totalDuration(NANOSECONDS),
greaterThanOrEqualTo(1L));
+ @Test
+ void testCheckpointStartTime() {
+ long checkpointStartTime = tracker.checkpointStartTime();
+
+ assertThat(checkpointStartTime, allOf(greaterThan(0L),
lessThanOrEqualTo(coarseCurrentTimeMillis())));
}
@Test
void testCopyOnWritePageWritten() {
- CheckpointMetricsTracker tracker = new CheckpointMetricsTracker();
-
assertThat(tracker.copyOnWritePagesWritten(), equalTo(0));
tracker.onCopyOnWritePageWritten();
@@ -66,8 +69,6 @@ public class CheckpointMetricsTrackerTest {
@Test
void testDataPagesWritten() {
- CheckpointMetricsTracker tracker = new CheckpointMetricsTracker();
-
assertThat(tracker.dataPagesWritten(), equalTo(0));
tracker.onDataPageWritten();
@@ -80,9 +81,7 @@ public class CheckpointMetricsTrackerTest {
}
@Test
- void testSplitAndSortCheckpointPages() throws Exception {
- CheckpointMetricsTracker tracker = new CheckpointMetricsTracker();
-
+ void testSplitAndSortCheckpointPages() {
assertThat(tracker.splitAndSortCheckpointPagesDuration(NANOSECONDS),
equalTo(0L));
tracker.onSplitAndSortCheckpointPagesStart();
@@ -95,54 +94,46 @@ public class CheckpointMetricsTrackerTest {
}
@Test
- void testFsync() throws Exception {
- CheckpointMetricsTracker tracker = new CheckpointMetricsTracker();
-
+ void testFsync() {
assertThat(tracker.fsyncDuration(NANOSECONDS), equalTo(0L));
tracker.onFsyncStart();
waitForTimeChange();
- tracker.onCheckpointEnd();
+ tracker.onFsyncEnd();
assertThat(tracker.fsyncDuration(NANOSECONDS),
greaterThanOrEqualTo(1L));
}
@Test
- void testReplicatorLogSync() throws Exception {
- var tracker = new CheckpointMetricsTracker();
-
+ void testReplicatorLogSync() {
assertThat(tracker.replicatorLogSyncDuration(NANOSECONDS),
equalTo(0L));
tracker.onReplicatorLogSyncStart();
waitForTimeChange();
- tracker.onCheckpointEnd();
+ tracker.onReplicatorLogSyncEnd();
assertThat(tracker.replicatorLogSyncDuration(NANOSECONDS),
greaterThanOrEqualTo(1L));
}
@Test
- void testPagesWrite() throws Exception {
- CheckpointMetricsTracker tracker = new CheckpointMetricsTracker();
-
+ void testPagesWrite() {
assertThat(tracker.pagesWriteDuration(NANOSECONDS), equalTo(0L));
tracker.onPagesWriteStart();
waitForTimeChange();
- tracker.onFsyncStart();
+ tracker.onPagesWriteEnd();
assertThat(tracker.pagesWriteDuration(NANOSECONDS),
greaterThanOrEqualTo(1L));
}
@Test
- void testOnMarkCheckpointBegin() throws Exception {
- CheckpointMetricsTracker tracker = new CheckpointMetricsTracker();
-
+ void testOnMarkCheckpointBegin() {
assertThat(tracker.onMarkCheckpointBeginDuration(NANOSECONDS),
equalTo(0L));
tracker.onMarkCheckpointBeginStart();
@@ -155,40 +146,32 @@ public class CheckpointMetricsTrackerTest {
}
@Test
- void testWriteLock() throws Exception {
- CheckpointMetricsTracker tracker = new CheckpointMetricsTracker();
-
- assertThat(tracker.writeLockWaitDuration(NANOSECONDS), equalTo(0L));
+ void testWriteLockHold() {
assertThat(tracker.writeLockHoldDuration(NANOSECONDS), equalTo(0L));
- waitForTimeChange();
-
- tracker.onWriteLockWaitStart();
-
- long beforeWriteLockDuration =
tracker.beforeWriteLockDuration(NANOSECONDS);
-
- assertThat(beforeWriteLockDuration, greaterThanOrEqualTo(1L));
- assertThat(tracker.writeLockHoldDuration(NANOSECONDS), equalTo(0L));
+ tracker.onWriteLockHoldStart();
waitForTimeChange();
- tracker.onMarkCheckpointBeginStart();
+ tracker.onWriteLockHoldEnd();
+
+ assertThat(tracker.writeLockHoldDuration(NANOSECONDS),
greaterThanOrEqualTo(1L));
+ }
- long writeLockWaitDuration =
tracker.writeLockWaitDuration(NANOSECONDS);
+ @Test
+ void testWriteLockWait() {
+ assertThat(tracker.writeLockWaitDuration(NANOSECONDS), equalTo(0L));
- assertThat(tracker.beforeWriteLockDuration(NANOSECONDS),
equalTo(beforeWriteLockDuration));
- assertThat(writeLockWaitDuration, greaterThanOrEqualTo(1L));
+ tracker.onWriteLockWaitStart();
waitForTimeChange();
- tracker.onWriteLockRelease();
+ tracker.onWriteLockWaitEnd();
- assertThat(tracker.beforeWriteLockDuration(NANOSECONDS),
equalTo(beforeWriteLockDuration));
- assertThat(tracker.writeLockWaitDuration(NANOSECONDS),
equalTo(writeLockWaitDuration));
- assertThat(tracker.writeLockHoldDuration(NANOSECONDS),
greaterThanOrEqualTo(1L));
+ assertThat(tracker.writeLockWaitDuration(NANOSECONDS),
greaterThanOrEqualTo(1L));
}
- private static void waitForTimeChange() throws Exception {
+ private static void waitForTimeChange() {
long start = System.nanoTime();
while (System.nanoTime() == start) {
diff --git
a/modules/page-memory/src/test/java/org/apache/ignite/internal/pagememory/persistence/checkpoint/CheckpointWorkflowTest.java
b/modules/page-memory/src/test/java/org/apache/ignite/internal/pagememory/persistence/checkpoint/CheckpointWorkflowTest.java
index 2c6c00ccc0..3bd860e9b2 100644
---
a/modules/page-memory/src/test/java/org/apache/ignite/internal/pagememory/persistence/checkpoint/CheckpointWorkflowTest.java
+++
b/modules/page-memory/src/test/java/org/apache/ignite/internal/pagememory/persistence/checkpoint/CheckpointWorkflowTest.java
@@ -216,7 +216,6 @@ public class CheckpointWorkflowTest extends
BaseIgniteAbstractTest {
Runnable onReleaseWriteLock = mock(Runnable.class);
workflow.addCheckpointListener(new TestCheckpointListener(events) {
- /** {@inheritDoc} */
@Override
public void beforeCheckpointBegin(CheckpointProgress progress,
@Nullable Executor exec) throws IgniteInternalCheckedException {
super.beforeCheckpointBegin(progress, exec);
@@ -230,9 +229,11 @@ public class CheckpointWorkflowTest extends
BaseIgniteAbstractTest {
assertThat(checkpointStateArgumentCaptor.getAllValues(),
empty());
verify(tracker, never()).onWriteLockWaitStart();
+ verify(tracker, never()).onWriteLockWaitEnd();
+ verify(tracker, never()).onWriteLockHoldStart();
+ verify(tracker, never()).onWriteLockHoldEnd();
verify(tracker, never()).onMarkCheckpointBeginStart();
verify(tracker, never()).onMarkCheckpointBeginEnd();
- verify(tracker, never()).onWriteLockRelease();
verify(tracker, never()).onSplitAndSortCheckpointPagesStart();
verify(tracker, never()).onSplitAndSortCheckpointPagesEnd();
@@ -242,7 +243,6 @@ public class CheckpointWorkflowTest extends
BaseIgniteAbstractTest {
verify(onReleaseWriteLock, never()).run();
}
- /** {@inheritDoc} */
@Override
public void onMarkCheckpointBegin(CheckpointProgress progress,
@Nullable Executor exec) throws IgniteInternalCheckedException {
super.onMarkCheckpointBegin(progress, exec);
@@ -256,9 +256,11 @@ public class CheckpointWorkflowTest extends
BaseIgniteAbstractTest {
assertThat(checkpointStateArgumentCaptor.getAllValues(),
equalTo(List.of(LOCK_TAKEN)));
verify(tracker, times(1)).onWriteLockWaitStart();
+ verify(tracker, times(1)).onWriteLockWaitEnd();
+ verify(tracker, times(1)).onWriteLockHoldStart();
verify(tracker, times(1)).onMarkCheckpointBeginStart();
verify(tracker, never()).onMarkCheckpointBeginEnd();
- verify(tracker, never()).onWriteLockRelease();
+ verify(tracker, never()).onWriteLockHoldEnd();
verify(tracker, never()).onSplitAndSortCheckpointPagesStart();
verify(tracker, never()).onSplitAndSortCheckpointPagesEnd();
@@ -268,7 +270,6 @@ public class CheckpointWorkflowTest extends
BaseIgniteAbstractTest {
verify(onReleaseWriteLock, never()).run();
}
- /** {@inheritDoc} */
@Override
public void onCheckpointBegin(CheckpointProgress progress) throws
IgniteInternalCheckedException {
super.onCheckpointBegin(progress);
@@ -284,9 +285,11 @@ public class CheckpointWorkflowTest extends
BaseIgniteAbstractTest {
assertThat(pagesCountArgumentCaptor.getAllValues(),
equalTo(List.of(3)));
verify(tracker, times(1)).onWriteLockWaitStart();
+ verify(tracker, times(1)).onWriteLockWaitEnd();
+ verify(tracker, times(1)).onWriteLockHoldStart();
+ verify(tracker, times(1)).onWriteLockHoldEnd();
verify(tracker, times(1)).onMarkCheckpointBeginStart();
verify(tracker, times(1)).onMarkCheckpointBeginEnd();
- verify(tracker, times(1)).onWriteLockRelease();
verify(tracker, never()).onSplitAndSortCheckpointPagesStart();
verify(tracker, never()).onSplitAndSortCheckpointPagesEnd();
@@ -306,9 +309,11 @@ public class CheckpointWorkflowTest extends
BaseIgniteAbstractTest {
);
verify(tracker, times(1)).onWriteLockWaitStart();
+ verify(tracker, times(1)).onWriteLockWaitEnd();
+ verify(tracker, times(1)).onWriteLockHoldStart();
+ verify(tracker, times(1)).onWriteLockHoldEnd();
verify(tracker, times(1)).onMarkCheckpointBeginStart();
verify(tracker, times(1)).onMarkCheckpointBeginEnd();
- verify(tracker, times(1)).onWriteLockRelease();
verify(tracker, times(1)).onSplitAndSortCheckpointPagesStart();
verify(tracker, times(1)).onSplitAndSortCheckpointPagesEnd();
