From 15a2fe00fc9817874f4c1600d56a373c21b1ad1c Mon Sep 17 00:00:00 2001 From: Benedict Elliott Smith Date: Mon, 18 Jan 2021 13:36:58 +0000 Subject: [PATCH] [CASSANDRA-16923] CEP-10 Phase 1: Mockable System Clock Co-authored-by: Benedict Elliott Smith Co-authored-by: Aleksey Yeschenko Co-authored-by: Sam Tunnicliffe --- build.xml | 30 ++- checkstyle.xml | 48 +++++ checkstyle_suppressions.xml | 26 +++ .../apache/cassandra/audit/AuditLogEntry.java | 6 +- .../cassandra/auth/CassandraAuthorizer.java | 9 +- .../auth/CassandraNetworkAuthorizer.java | 5 +- .../cassandra/auth/CassandraRoleManager.java | 5 +- .../cassandra/auth/PasswordAuthenticator.java | 3 +- .../cassandra/batchlog/BatchlogManager.java | 6 +- .../cassandra/cache/AutoSavingCache.java | 14 +- .../cassandra/concurrent/SEPWorker.java | 5 +- .../concurrent/SharedExecutorPool.java | 5 +- src/java/org/apache/cassandra/cql3/Lists.java | 3 +- .../apache/cassandra/cql3/QueryProcessor.java | 5 +- .../cassandra/cql3/UntypedResultSet.java | 4 +- .../cassandra/cql3/functions/UDAggregate.java | 5 +- .../cassandra/cql3/functions/UDFunction.java | 9 +- .../cql3/statements/BatchStatement.java | 3 +- .../statements/ModificationStatement.java | 3 +- .../cql3/statements/SelectStatement.java | 3 +- .../cql3/statements/UseStatement.java | 4 +- .../cassandra/db/ColumnFamilyStore.java | 25 ++- .../apache/cassandra/db/CounterMutation.java | 5 +- .../db/CounterMutationVerbHandler.java | 4 +- .../db/ExpirationDateOverflowHandling.java | 4 +- .../org/apache/cassandra/db/Keyspace.java | 9 +- .../org/apache/cassandra/db/Memtable.java | 6 +- .../org/apache/cassandra/db/ReadCommand.java | 5 +- .../apache/cassandra/db/RepairedDataInfo.java | 6 +- .../cassandra/db/SizeEstimatesRecorder.java | 6 +- .../apache/cassandra/db/SystemKeyspace.java | 8 +- .../commitlog/AbstractCommitLogService.java | 7 +- .../db/commitlog/CommitLogSegment.java | 3 +- .../commitlog/PeriodicCommitLogService.java | 4 +- .../AbstractCompactionStrategy.java | 5 +- .../db/compaction/CompactionLogger.java | 4 +- .../db/compaction/CompactionManager.java | 9 +- .../db/compaction/CompactionTask.java | 23 ++- .../DateTieredCompactionStrategy.java | 5 +- .../db/compaction/LeveledGenerations.java | 8 +- .../TimeWindowCompactionStrategy.java | 5 +- .../cassandra/db/lifecycle/LogFile.java | 5 +- .../cassandra/db/marshal/TemporalType.java | 4 +- .../db/partitions/AtomicBTreePartition.java | 4 +- .../db/repair/PendingAntiCompaction.java | 9 +- .../apache/cassandra/db/view/TableViews.java | 8 +- .../cassandra/db/view/ViewBuilderTask.java | 4 +- .../db/virtual/AbstractVirtualTable.java | 6 +- .../cassandra/diag/DiagnosticEvent.java | 4 +- .../diag/LastEventIdBroadcaster.java | 6 +- .../apache/cassandra/gms/EndpointState.java | 6 +- .../gms/GossipDigestAckVerbHandler.java | 3 +- .../org/apache/cassandra/gms/Gossiper.java | 24 ++- .../cassandra/hadoop/cql3/CqlInputFormat.java | 4 +- src/java/org/apache/cassandra/hints/Hint.java | 3 +- .../cassandra/hints/HintsCleanupTrigger.java | 4 +- .../apache/cassandra/hints/HintsReader.java | 6 +- .../apache/cassandra/hints/HintsStore.java | 4 +- .../sasi/disk/PerSSTableIndexWriter.java | 10 +- .../index/sasi/plan/QueryController.java | 6 +- .../io/sstable/CQLSSTableWriter.java | 4 +- .../sstable/format/SSTableReaderBuilder.java | 12 +- .../io/sstable/format/big/BigTableWriter.java | 4 +- .../cassandra/locator/TokenMetadata.java | 5 +- .../cassandra/metrics/TableMetrics.java | 5 +- .../apache/cassandra/net/AsyncPromise.java | 5 +- .../cassandra/net/MessagingService.java | 5 +- .../cassandra/net/RequestCallbacks.java | 3 +- .../StartupClusterConnectivityChecker.java | 9 +- .../apache/cassandra/repair/RepairJob.java | 10 +- .../cassandra/repair/RepairRunnable.java | 14 +- .../org/apache/cassandra/repair/SyncTask.java | 6 +- .../cassandra/repair/ValidationManager.java | 6 +- .../repair/consistent/CoordinatorSession.java | 14 +- .../schema/MigrationCoordinator.java | 4 +- .../serializers/TimestampSerializer.java | 4 +- .../service/AbstractWriteResponseHandler.java | 5 +- .../service/ActiveRepairService.java | 3 +- .../apache/cassandra/service/ClientState.java | 6 +- .../apache/cassandra/service/GCInspector.java | 6 +- .../PendingRangeCalculatorService.java | 6 +- .../cassandra/service/StartupChecks.java | 3 +- .../cassandra/service/StorageProxy.java | 42 ++-- .../cassandra/service/StorageService.java | 8 +- .../service/TruncateResponseHandler.java | 6 +- .../service/pager/AggregationQueryPager.java | 6 +- .../service/pager/MultiPartitionPager.java | 4 +- .../service/paxos/AbstractPaxosCallback.java | 3 +- .../cassandra/service/paxos/PaxosState.java | 14 +- .../service/reads/DigestResolver.java | 5 +- .../cassandra/service/reads/ReadCallback.java | 3 +- .../reads/range/RangeCommandIterator.java | 6 +- .../reads/repair/BlockingPartitionRepair.java | 5 +- .../cassandra/streaming/StreamSession.java | 5 +- .../async/NettyStreamingMessageSender.java | 6 +- .../management/StreamEventJMXNotifier.java | 6 +- .../cassandra/tools/BootstrapMonitor.java | 4 +- .../apache/cassandra/tools/BulkLoader.java | 8 +- .../cassandra/tools/JsonTransformer.java | 6 +- .../apache/cassandra/tools/RepairRunner.java | 4 +- .../tools/SSTableExpiredBlockers.java | 4 +- .../tools/SSTableMetadataViewer.java | 7 +- .../cassandra/tools/StandaloneScrubber.java | 4 +- .../cassandra/tools/StandaloneSplitter.java | 3 +- .../cassandra/tools/nodetool/Snapshot.java | 3 +- .../cassandra/tracing/TraceStateImpl.java | 6 +- .../apache/cassandra/tracing/TracingImpl.java | 4 +- .../cassandra/transport/Dispatcher.java | 3 +- .../transport/ProtocolVersionTracker.java | 6 +- .../cassandra/transport/SimpleClient.java | 6 +- .../transport/messages/BatchMessage.java | 4 +- .../transport/messages/ExecuteMessage.java | 4 +- .../transport/messages/PrepareMessage.java | 4 +- .../transport/messages/QueryMessage.java | 4 +- .../cassandra/utils/ApproximateTime.java | 192 ------------------ .../org/apache/cassandra/utils/Clock.java | 110 ++++++++++ .../utils/DiagnosticSnapshotService.java | 5 +- .../apache/cassandra/utils/ExecutorUtils.java | 5 +- .../utils/ExpiringMemoizingSupplier.java | 4 +- .../apache/cassandra/utils/FBUtilities.java | 14 +- .../apache/cassandra/utils/GuidGenerator.java | 3 +- .../cassandra/utils/MonotonicClock.java | 13 +- .../apache/cassandra/utils/NoSpamLogger.java | 4 +- .../cassandra/utils/SlidingTimeRate.java | 171 ---------------- .../cassandra/utils/SystemTimeSource.java | 54 ----- .../apache/cassandra/utils/TimeSource.java | 58 ------ .../org/apache/cassandra/utils/UUIDGen.java | 6 +- .../utils/binlog/ExternalArchiver.java | 7 +- .../utils/concurrent/IntervalLock.java | 69 ------- .../utils/concurrent/SimpleCondition.java | 4 +- .../cassandra/utils/concurrent/WaitQueue.java | 10 +- .../progress/jmx/JMXProgressSupport.java | 4 +- .../LongSharedExecutorPoolTest.java | 18 +- .../cassandra/net/ConnectionBurnTest.java | 9 +- .../org/apache/cassandra/net/Reporters.java | 6 +- .../org/apache/cassandra/net/Verifier.java | 7 +- .../cassandra/transport/DriverBurnTest.java | 5 +- .../transport/SimpleClientPerfTest.java | 5 +- .../utils/memory/LongBufferPoolTest.java | 7 +- .../distributed/impl/Coordinator.java | 7 +- .../cassandra/distributed/impl/Instance.java | 10 +- ...stReplacementAbruptDownedInstanceTest.java | 5 +- .../apache/cassandra/cql3/CachingBench.java | 5 +- .../cassandra/cql3/GcCompactionBench.java | 6 +- .../db/compaction/LongCompactionsTest.java | 6 +- .../io/compress/CompressorPerformance.java | 10 +- .../streaming/LongStreamingTest.java | 17 +- .../test/microbench/BatchStatementBench.java | 3 +- .../test/microbench/MessageOutBench.java | 3 +- .../DebuggableThreadPoolExecutorTest.java | 6 +- .../cql3/CustomNowInSecondsTest.java | 8 +- .../cassandra/cql3/PstmtPersistenceTest.java | 5 +- .../validation/entities/CollectionsTest.java | 3 +- .../cql3/validation/entities/JsonTest.java | 3 +- .../entities/SecondaryIndexTest.java | 3 +- .../org/apache/cassandra/db/CleanupTest.java | 5 +- .../apache/cassandra/db/DirectoriesTest.java | 3 +- .../cassandra/db/RangeTombstoneListTest.java | 3 +- .../db/commitlog/BatchCommitLogTest.java | 9 +- .../CorruptedSSTablesCompactionsTest.java | 3 +- .../db/lifecycle/RealTransactionsTest.java | 7 +- .../db/monitoring/MonitoringTaskTest.java | 48 ++--- .../io/sstable/IndexSummaryTest.java | 5 +- .../SSTableCorruptionDetectionTest.java | 3 +- .../io/util/BufferedDataOutputStreamTest.java | 3 +- .../io/util/FileSegmentInputStreamTest.java | 3 +- .../cassandra/io/util/MmappedRegionsTest.java | 3 +- .../io/util/NIODataInputStreamTest.java | 3 +- .../io/util/RandomAccessReaderTest.java | 3 +- .../cassandra/locator/TokenMetadataTest.java | 2 +- ...cayingEstimatedHistogramReservoirTest.java | 3 +- .../cassandra/net/AsyncOneResponseTest.java | 5 +- .../net/AsyncStreamingInputPlusTest.java | 5 +- .../apache/cassandra/net/ConnectionTest.java | 12 +- .../cassandra/service/PaxosStateTest.java | 5 +- .../service/WriteResponseHandlerTest.java | 6 +- .../service/reads/DataResolverTest.java | 62 +++--- .../service/reads/ReadExecutorTest.java | 13 +- .../reads/range/RangeCommandIteratorTest.java | 11 +- .../reads/range/RangeCommandsTest.java | 7 +- .../reads/repair/AbstractReadRepairTest.java | 5 +- .../reads/repair/BlockingReadRepairTest.java | 5 +- .../DiagEventsBlockingReadRepairTest.java | 5 +- .../service/reads/repair/ReadRepairTest.java | 6 +- .../cassandra/tools/OfflineToolUtils.java | 5 +- .../triggers/TriggersSchemaTest.java | 7 +- .../cassandra/triggers/TriggersTest.java | 7 +- .../cassandra/utils/MonotonicClockTest.java | 5 +- .../cassandra/utils/SlidingTimeRateTest.java | 161 --------------- .../cassandra/utils/TestTimeSource.java | 72 ------- .../cassandra/utils/binlog/BinLogTest.java | 3 +- .../io/sstable/StressCQLSSTableWriter.java | 4 +- .../apache/cassandra/stress/StressAction.java | 6 +- .../stress/report/StressMetrics.java | 15 +- .../apache/cassandra/stress/report/Timer.java | 6 +- 195 files changed, 997 insertions(+), 1251 deletions(-) create mode 100644 checkstyle.xml create mode 100644 checkstyle_suppressions.xml delete mode 100644 src/java/org/apache/cassandra/utils/ApproximateTime.java create mode 100644 src/java/org/apache/cassandra/utils/Clock.java delete mode 100644 src/java/org/apache/cassandra/utils/SlidingTimeRate.java delete mode 100644 src/java/org/apache/cassandra/utils/SystemTimeSource.java delete mode 100644 src/java/org/apache/cassandra/utils/TimeSource.java delete mode 100644 src/java/org/apache/cassandra/utils/concurrent/IntervalLock.java delete mode 100644 test/unit/org/apache/cassandra/utils/SlidingTimeRateTest.java delete mode 100644 test/unit/org/apache/cassandra/utils/TestTimeSource.java diff --git a/build.xml b/build.xml index 97ea512e9b..dc3f547c56 100644 --- a/build.xml +++ b/build.xml @@ -534,6 +534,7 @@ + @@ -718,6 +719,7 @@ + @@ -869,7 +871,7 @@ - + @@ -2100,6 +2102,32 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/checkstyle_suppressions.xml b/checkstyle_suppressions.xml new file mode 100644 index 0000000000..13ce561f89 --- /dev/null +++ b/checkstyle_suppressions.xml @@ -0,0 +1,26 @@ + + + + + + + + diff --git a/src/java/org/apache/cassandra/audit/AuditLogEntry.java b/src/java/org/apache/cassandra/audit/AuditLogEntry.java index 4d3b86745e..3a015c5614 100644 --- a/src/java/org/apache/cassandra/audit/AuditLogEntry.java +++ b/src/java/org/apache/cassandra/audit/AuditLogEntry.java @@ -32,6 +32,8 @@ import org.apache.cassandra.service.ClientState; import org.apache.cassandra.service.QueryState; import org.apache.cassandra.utils.FBUtilities; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; + public class AuditLogEntry { private final InetAddressAndPort host = FBUtilities.getBroadcastAddressAndPort(); @@ -214,7 +216,7 @@ public class AuditLogEntry user = AuthenticatedUser.SYSTEM_USER.getName(); } - timestamp = System.currentTimeMillis(); + timestamp = currentTimeMillis(); } public Builder(AuditLogEntry entry) @@ -312,7 +314,7 @@ public class AuditLogEntry public AuditLogEntry build() { - timestamp = timestamp > 0 ? timestamp : System.currentTimeMillis(); + timestamp = timestamp > 0 ? timestamp : currentTimeMillis(); return new AuditLogEntry(type, source, user, timestamp, batch, keyspace, scope, operation, options, state); } } diff --git a/src/java/org/apache/cassandra/auth/CassandraAuthorizer.java b/src/java/org/apache/cassandra/auth/CassandraAuthorizer.java index 318b7f3d19..60d5a1fad0 100644 --- a/src/java/org/apache/cassandra/auth/CassandraAuthorizer.java +++ b/src/java/org/apache/cassandra/auth/CassandraAuthorizer.java @@ -40,6 +40,11 @@ import org.apache.cassandra.service.QueryState; import org.apache.cassandra.transport.messages.ResultMessage; import org.apache.cassandra.utils.ByteBufferUtil; +import static org.apache.cassandra.cql3.BatchQueryOptions.withoutPerStatementVariables; +import static org.apache.cassandra.cql3.QueryOptions.DEFAULT; +import static org.apache.cassandra.service.QueryState.forInternalCalls; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + /** * CassandraAuthorizer is an IAuthorizer implementation that keeps * user permissions internally in C* using the system_auth.role_permissions @@ -352,7 +357,7 @@ public class CassandraAuthorizer implements IAuthorizer ResultMessage.Rows select(SelectStatement statement, QueryOptions options) { - return statement.execute(QueryState.forInternalCalls(), options, System.nanoTime()); + return statement.execute(QueryState.forInternalCalls(), options, nanoTime()); } UntypedResultSet process(String query, ConsistencyLevel cl) throws RequestExecutionException @@ -366,7 +371,7 @@ public class CassandraAuthorizer implements IAuthorizer QueryProcessor.instance.processBatch(statement, QueryState.forInternalCalls(), BatchQueryOptions.withoutPerStatementVariables(options), - System.nanoTime()); + nanoTime()); } public static ConsistencyLevel authWriteConsistencyLevel() diff --git a/src/java/org/apache/cassandra/auth/CassandraNetworkAuthorizer.java b/src/java/org/apache/cassandra/auth/CassandraNetworkAuthorizer.java index 107cd857ea..4384f7ae91 100644 --- a/src/java/org/apache/cassandra/auth/CassandraNetworkAuthorizer.java +++ b/src/java/org/apache/cassandra/auth/CassandraNetworkAuthorizer.java @@ -35,6 +35,9 @@ import org.apache.cassandra.service.QueryState; import org.apache.cassandra.transport.messages.ResultMessage; import org.apache.cassandra.utils.ByteBufferUtil; +import static org.apache.cassandra.service.QueryState.forInternalCalls; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + public class CassandraNetworkAuthorizer implements INetworkAuthorizer { private SelectStatement authorizeUserStatement = null; @@ -50,7 +53,7 @@ public class CassandraNetworkAuthorizer implements INetworkAuthorizer @VisibleForTesting ResultMessage.Rows select(SelectStatement statement, QueryOptions options) { - return statement.execute(QueryState.forInternalCalls(), options, System.nanoTime()); + return statement.execute(forInternalCalls(), options, nanoTime()); } @VisibleForTesting diff --git a/src/java/org/apache/cassandra/auth/CassandraRoleManager.java b/src/java/org/apache/cassandra/auth/CassandraRoleManager.java index f4c78acffd..a79fb12ac8 100644 --- a/src/java/org/apache/cassandra/auth/CassandraRoleManager.java +++ b/src/java/org/apache/cassandra/auth/CassandraRoleManager.java @@ -48,6 +48,9 @@ import org.apache.cassandra.transport.messages.ResultMessage; import org.apache.cassandra.utils.ByteBufferUtil; import org.mindrot.jbcrypt.BCrypt; +import static org.apache.cassandra.service.QueryState.forInternalCalls; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + /** * Responsible for the creation, maintenance and deletion of roles * for the purposes of authentication and authorization. @@ -548,6 +551,6 @@ public class CassandraRoleManager implements IRoleManager @VisibleForTesting ResultMessage.Rows select(SelectStatement statement, QueryOptions options) { - return statement.execute(QueryState.forInternalCalls(), options, System.nanoTime()); + return statement.execute(forInternalCalls(), options, nanoTime()); } } \ No newline at end of file diff --git a/src/java/org/apache/cassandra/auth/PasswordAuthenticator.java b/src/java/org/apache/cassandra/auth/PasswordAuthenticator.java index 50b86f7288..098ed9f9a8 100644 --- a/src/java/org/apache/cassandra/auth/PasswordAuthenticator.java +++ b/src/java/org/apache/cassandra/auth/PasswordAuthenticator.java @@ -45,6 +45,7 @@ import org.apache.cassandra.utils.ByteBufferUtil; import org.mindrot.jbcrypt.BCrypt; import static org.apache.cassandra.auth.CassandraRoleManager.consistencyForRoleRead; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; /** * PasswordAuthenticator is an IAuthenticator implementation @@ -130,7 +131,7 @@ public class PasswordAuthenticator implements IAuthenticator @VisibleForTesting ResultMessage.Rows select(SelectStatement statement, QueryOptions options) { - return statement.execute(QueryState.forInternalCalls(), options, System.nanoTime()); + return statement.execute(QueryState.forInternalCalls(), options, nanoTime()); } public Set protectedResources() diff --git a/src/java/org/apache/cassandra/batchlog/BatchlogManager.java b/src/java/org/apache/cassandra/batchlog/BatchlogManager.java index 65ed71ec64..799acbc39e 100644 --- a/src/java/org/apache/cassandra/batchlog/BatchlogManager.java +++ b/src/java/org/apache/cassandra/batchlog/BatchlogManager.java @@ -83,6 +83,8 @@ import static java.util.concurrent.TimeUnit.MILLISECONDS; import static org.apache.cassandra.cql3.QueryProcessor.executeInternal; import static org.apache.cassandra.cql3.QueryProcessor.executeInternalWithPaging; import static org.apache.cassandra.net.Verb.MUTATION_REQ; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; public class BatchlogManager implements BatchlogManagerMBean { @@ -213,7 +215,7 @@ public class BatchlogManager implements BatchlogManagerMBean } setRate(DatabaseDescriptor.getBatchlogReplayThrottleInKB()); - UUID limitUuid = UUIDGen.maxTimeUUID(System.currentTimeMillis() - getBatchlogTimeout()); + UUID limitUuid = UUIDGen.maxTimeUUID(currentTimeMillis() - getBatchlogTimeout()); ColumnFamilyStore store = Keyspace.open(SchemaConstants.SYSTEM_KEYSPACE_NAME).getColumnFamilyStore(SystemKeyspace.BATCHES); int pageSize = calculatePageSize(store); // There cannot be any live content where token(id) <= token(lastReplayedUuid) as every processed batch is @@ -491,7 +493,7 @@ public class BatchlogManager implements BatchlogManagerMBean ReplicaPlan.ForTokenWrite replicaPlan = new ReplicaPlan.ForTokenWrite(keyspace, liveAndDown.replicationStrategy(), ConsistencyLevel.ONE, liveRemoteOnly.pending(), liveRemoteOnly.all(), liveRemoteOnly.all(), liveRemoteOnly.all()); - ReplayWriteResponseHandler handler = new ReplayWriteResponseHandler<>(replicaPlan, System.nanoTime()); + ReplayWriteResponseHandler handler = new ReplayWriteResponseHandler<>(replicaPlan, nanoTime()); Message message = Message.outWithFlag(MUTATION_REQ, mutation, MessageFlag.CALL_BACK_ON_FAILURE); for (Replica replica : liveRemoteOnly.all()) MessagingService.instance().sendWriteWithCallback(message, replica, handler, false); diff --git a/src/java/org/apache/cassandra/cache/AutoSavingCache.java b/src/java/org/apache/cassandra/cache/AutoSavingCache.java index 34f056a3c5..d18baabcfd 100644 --- a/src/java/org/apache/cassandra/cache/AutoSavingCache.java +++ b/src/java/org/apache/cassandra/cache/AutoSavingCache.java @@ -53,6 +53,8 @@ import org.apache.cassandra.utils.JVMStabilityInspector; import org.apache.cassandra.utils.Pair; import org.apache.cassandra.utils.UUIDGen; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + public class AutoSavingCache extends InstrumentingCache { public interface IStreamFactory @@ -158,7 +160,7 @@ public class AutoSavingCache extends InstrumentingCache loadSavedAsync() { final ListeningExecutorService es = MoreExecutors.listeningDecorator(Executors.newSingleThreadExecutor()); - final long start = System.nanoTime(); + final long start = nanoTime(); ListenableFuture cacheLoad = es.submit(new Callable() { @@ -175,7 +177,7 @@ public class AutoSavingCache extends InstrumentingCache 0) logger.info("Completed loading ({} ms; {} keys) {} cache", - TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start), + TimeUnit.NANOSECONDS.toMillis(nanoTime() - start), CacheService.instance.keyCache.size(), cacheType); es.shutdown(); @@ -188,7 +190,7 @@ public class AutoSavingCache extends InstrumentingCache extends InstrumentingCache extends InstrumentingCache cacheFilePaths = tempCacheFiles(); try (WrappedDataOutputStreamPlus writer = new WrappedDataOutputStreamPlus(streamFactory.getOutputStream(cacheFilePaths.left, cacheFilePaths.right))) @@ -401,7 +403,7 @@ public class AutoSavingCache extends InstrumentingCache tempCacheFiles() diff --git a/src/java/org/apache/cassandra/concurrent/SEPWorker.java b/src/java/org/apache/cassandra/concurrent/SEPWorker.java index de5185d227..efb1884827 100644 --- a/src/java/org/apache/cassandra/concurrent/SEPWorker.java +++ b/src/java/org/apache/cassandra/concurrent/SEPWorker.java @@ -30,6 +30,7 @@ import org.apache.cassandra.utils.JVMStabilityInspector; import static org.apache.cassandra.concurrent.SEPExecutor.TakeTaskPermitResult.RETURNED_WORK_PERMIT; import static org.apache.cassandra.concurrent.SEPExecutor.TakeTaskPermitResult.TOOK_PERMIT; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; final class SEPWorker extends AtomicReference implements Runnable { @@ -257,7 +258,7 @@ final class SEPWorker extends AtomicReference implements Runnabl sleep *= ThreadLocalRandom.current().nextDouble(); sleep = Math.max(10000, sleep); - long start = System.nanoTime(); + long start = nanoTime(); // place ourselves in the spinning collection; if we clash with another thread just exit Long target = start + sleep; @@ -269,7 +270,7 @@ final class SEPWorker extends AtomicReference implements Runnabl pool.spinning.remove(target, this); // finish timing and grab spinningTime (before we finish timing so it is under rather than overestimated) - long end = System.nanoTime(); + long end = nanoTime(); long spin = end - start; long stopCheck = pool.stopCheck.addAndGet(spin); maybeStop(stopCheck, end); diff --git a/src/java/org/apache/cassandra/concurrent/SharedExecutorPool.java b/src/java/org/apache/cassandra/concurrent/SharedExecutorPool.java index 7a07cf4406..bba8e8465e 100644 --- a/src/java/org/apache/cassandra/concurrent/SharedExecutorPool.java +++ b/src/java/org/apache/cassandra/concurrent/SharedExecutorPool.java @@ -28,6 +28,7 @@ import java.util.concurrent.atomic.AtomicLong; import java.util.concurrent.locks.LockSupport; import static org.apache.cassandra.concurrent.SEPWorker.Work; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; /** * A pool of worker threads that are shared between all Executors created with it. Each executor is treated as a distinct @@ -128,10 +129,10 @@ public class SharedExecutorPool terminateWorkers(); - long until = System.nanoTime() + unit.toNanos(timeout); + long until = nanoTime() + unit.toNanos(timeout); for (SEPExecutor executor : executors) { - executor.shutdown.await(until - System.nanoTime(), TimeUnit.NANOSECONDS); + executor.shutdown.await(until - nanoTime(), TimeUnit.NANOSECONDS); if (!executor.isTerminated()) throw new TimeoutException(executor.name + " not terminated"); } diff --git a/src/java/org/apache/cassandra/cql3/Lists.java b/src/java/org/apache/cassandra/cql3/Lists.java index 1d94d697a5..ece822dd12 100644 --- a/src/java/org/apache/cassandra/cql3/Lists.java +++ b/src/java/org/apache/cassandra/cql3/Lists.java @@ -18,6 +18,7 @@ package org.apache.cassandra.cql3; import static org.apache.cassandra.cql3.Constants.UNSET_VALUE; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; import java.nio.ByteBuffer; import java.util.ArrayList; @@ -536,7 +537,7 @@ public abstract class Lists { if (remainingInBatch == 0) { - long time = PrecisionTime.REFERENCE_TIME - (System.currentTimeMillis() - PrecisionTime.REFERENCE_TIME); + long time = PrecisionTime.REFERENCE_TIME - (currentTimeMillis() - PrecisionTime.REFERENCE_TIME); remainingInBatch = Math.min(PrecisionTime.MAX_NANOS, i) + 1; pt = PrecisionTime.getNext(time, remainingInBatch); } diff --git a/src/java/org/apache/cassandra/cql3/QueryProcessor.java b/src/java/org/apache/cassandra/cql3/QueryProcessor.java index 87829ab358..dc1b7a74d1 100644 --- a/src/java/org/apache/cassandra/cql3/QueryProcessor.java +++ b/src/java/org/apache/cassandra/cql3/QueryProcessor.java @@ -58,6 +58,7 @@ import org.apache.cassandra.transport.messages.ResultMessage; import org.apache.cassandra.utils.*; import static org.apache.cassandra.cql3.statements.RequestValidations.checkTrue; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; public class QueryProcessor implements QueryHandler { @@ -274,7 +275,7 @@ public class QueryProcessor implements QueryHandler QueryState queryState = QueryState.forInternalCalls(); QueryOptions options = QueryOptions.forInternalCalls(cl, values); CQLStatement statement = instance.parse(query, queryState, options); - ResultMessage result = instance.process(statement, queryState, options, System.nanoTime()); + ResultMessage result = instance.process(statement, queryState, options, nanoTime()); if (result instanceof ResultMessage.Rows) return UntypedResultSet.create(((ResultMessage.Rows)result).result); else @@ -339,7 +340,7 @@ public class QueryProcessor implements QueryHandler try { Prepared prepared = prepareInternal(query); - ResultMessage result = prepared.statement.execute(state, makeInternalOptions(prepared.statement, values, cl), System.nanoTime()); + ResultMessage result = prepared.statement.execute(state, makeInternalOptions(prepared.statement, values, cl), nanoTime()); if (result instanceof ResultMessage.Rows) return UntypedResultSet.create(((ResultMessage.Rows)result).result); else diff --git a/src/java/org/apache/cassandra/cql3/UntypedResultSet.java b/src/java/org/apache/cassandra/cql3/UntypedResultSet.java index f4ac99fdc4..05ebda9c4f 100644 --- a/src/java/org/apache/cassandra/cql3/UntypedResultSet.java +++ b/src/java/org/apache/cassandra/cql3/UntypedResultSet.java @@ -37,6 +37,8 @@ import org.apache.cassandra.transport.ProtocolVersion; import org.apache.cassandra.utils.AbstractIterator; import org.apache.cassandra.utils.FBUtilities; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + /** a utility for doing internal cql-based queries */ public abstract class UntypedResultSet implements Iterable { @@ -269,7 +271,7 @@ public abstract class UntypedResultSet implements Iterable if (pager.isExhausted()) return endOfData(); - try (PartitionIterator iter = pager.fetchPage(pageSize, cl, clientState, System.nanoTime())) + try (PartitionIterator iter = pager.fetchPage(pageSize, cl, clientState, nanoTime())) { currentPage = select.process(iter, nowInSec).rows.iterator(); } diff --git a/src/java/org/apache/cassandra/cql3/functions/UDAggregate.java b/src/java/org/apache/cassandra/cql3/functions/UDAggregate.java index b201f09f9d..92185d95e0 100644 --- a/src/java/org/apache/cassandra/cql3/functions/UDAggregate.java +++ b/src/java/org/apache/cassandra/cql3/functions/UDAggregate.java @@ -39,6 +39,7 @@ import org.apache.cassandra.transport.ProtocolVersion; import static com.google.common.collect.Iterables.any; import static com.google.common.collect.Iterables.transform; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; /** * Base class for user-defined-aggregates. @@ -182,7 +183,7 @@ public class UDAggregate extends AbstractFunction implements AggregateFunction, { maybeInit(protocolVersion); - long startTime = System.nanoTime(); + long startTime = nanoTime(); stateFunctionCount++; if (stateFunction instanceof UDFunction) { @@ -194,7 +195,7 @@ public class UDAggregate extends AbstractFunction implements AggregateFunction, { throw new UnsupportedOperationException("UDAs only support UDFs"); } - stateFunctionDuration += (System.nanoTime() - startTime) / 1000; + stateFunctionDuration += (nanoTime() - startTime) / 1000; } private void maybeInit(ProtocolVersion protocolVersion) diff --git a/src/java/org/apache/cassandra/cql3/functions/UDFunction.java b/src/java/org/apache/cassandra/cql3/functions/UDFunction.java index b62c18fbc6..550905f3b1 100644 --- a/src/java/org/apache/cassandra/cql3/functions/UDFunction.java +++ b/src/java/org/apache/cassandra/cql3/functions/UDFunction.java @@ -61,6 +61,7 @@ import org.apache.cassandra.utils.JVMStabilityInspector; import static com.google.common.collect.Iterables.any; import static com.google.common.collect.Iterables.transform; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; /** * Base class for User Defined Functions. @@ -356,7 +357,7 @@ public abstract class UDFunction extends AbstractFunction implements ScalarFunct if (!isCallableWrtNullable(parameters)) return null; - long tStart = System.nanoTime(); + long tStart = nanoTime(); parameters = makeEmptyParametersNull(parameters); try @@ -366,7 +367,7 @@ public abstract class UDFunction extends AbstractFunction implements ScalarFunct ? executeAsync(protocolVersion, parameters) : executeUserDefined(protocolVersion, parameters); - Tracing.trace("Executed UDF {} in {}\u03bcs", name(), (System.nanoTime() - tStart) / 1000); + Tracing.trace("Executed UDF {} in {}\u03bcs", name(), (nanoTime() - tStart) / 1000); return result; } catch (InvalidRequestException e) @@ -395,7 +396,7 @@ public abstract class UDFunction extends AbstractFunction implements ScalarFunct if (!calledOnNullInput && firstParam == null || !isCallableWrtNullable(parameters)) return null; - long tStart = System.nanoTime(); + long tStart = nanoTime(); parameters = makeEmptyParametersNull(parameters); try @@ -404,7 +405,7 @@ public abstract class UDFunction extends AbstractFunction implements ScalarFunct Object result = DatabaseDescriptor.enableUserDefinedFunctionsThreads() ? executeAggregateAsync(protocolVersion, firstParam, parameters) : executeAggregateUserDefined(protocolVersion, firstParam, parameters); - Tracing.trace("Executed UDF {} in {}\u03bcs", name(), (System.nanoTime() - tStart) / 1000); + Tracing.trace("Executed UDF {} in {}\u03bcs", name(), (nanoTime() - tStart) / 1000); return result; } catch (InvalidRequestException e) diff --git a/src/java/org/apache/cassandra/cql3/statements/BatchStatement.java b/src/java/org/apache/cassandra/cql3/statements/BatchStatement.java index 80bd437779..054541c8e1 100644 --- a/src/java/org/apache/cassandra/cql3/statements/BatchStatement.java +++ b/src/java/org/apache/cassandra/cql3/statements/BatchStatement.java @@ -51,6 +51,7 @@ import org.apache.cassandra.utils.Pair; import static java.util.function.Predicate.isEqual; import static org.apache.cassandra.cql3.statements.RequestValidations.checkFalse; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; /** * A BATCH statement parsed from a CQL query. @@ -550,7 +551,7 @@ public class BatchStatement implements CQLStatement if (hasConditions) return executeInternalWithConditions(batchOptions, queryState); - executeInternalWithoutCondition(queryState, batchOptions, System.nanoTime()); + executeInternalWithoutCondition(queryState, batchOptions, nanoTime()); return new ResultMessage.Void(); } diff --git a/src/java/org/apache/cassandra/cql3/statements/ModificationStatement.java b/src/java/org/apache/cassandra/cql3/statements/ModificationStatement.java index 4ff9928928..ca7d6d0ef2 100644 --- a/src/java/org/apache/cassandra/cql3/statements/ModificationStatement.java +++ b/src/java/org/apache/cassandra/cql3/statements/ModificationStatement.java @@ -62,6 +62,7 @@ import org.apache.cassandra.utils.UUIDGen; import static org.apache.cassandra.cql3.statements.RequestValidations.checkFalse; import static org.apache.cassandra.cql3.statements.RequestValidations.checkNull; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; /* * Abstract parent class of individual modifications, i.e. INSERT, UPDATE and DELETE. @@ -622,7 +623,7 @@ public abstract class ModificationStatement implements CQLStatement { return hasConditions() ? executeInternalWithCondition(queryState, options) - : executeInternalWithoutCondition(queryState, options, System.nanoTime()); + : executeInternalWithoutCondition(queryState, options, nanoTime()); } public ResultMessage executeInternalWithoutCondition(QueryState queryState, QueryOptions options, long queryStartNanoTime) diff --git a/src/java/org/apache/cassandra/cql3/statements/SelectStatement.java b/src/java/org/apache/cassandra/cql3/statements/SelectStatement.java index 25499b2171..956e50b73b 100644 --- a/src/java/org/apache/cassandra/cql3/statements/SelectStatement.java +++ b/src/java/org/apache/cassandra/cql3/statements/SelectStatement.java @@ -80,6 +80,7 @@ import static org.apache.cassandra.cql3.statements.RequestValidations.checkNotNu import static org.apache.cassandra.cql3.statements.RequestValidations.checkNull; import static org.apache.cassandra.cql3.statements.RequestValidations.checkTrue; import static org.apache.cassandra.utils.ByteBufferUtil.UNSET_BYTE_BUFFER; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; /** * Encapsulates a completely parsed SELECT query, including the target @@ -436,7 +437,7 @@ public class SelectStatement implements CQLStatement public ResultMessage.Rows executeLocally(QueryState state, QueryOptions options) throws RequestExecutionException, RequestValidationException { - return executeInternal(state, options, options.getNowInSeconds(state), System.nanoTime()); + return executeInternal(state, options, options.getNowInSeconds(state), nanoTime()); } public ResultMessage.Rows executeInternal(QueryState state, QueryOptions options, int nowInSec, long queryStartNanoTime) throws RequestExecutionException, RequestValidationException diff --git a/src/java/org/apache/cassandra/cql3/statements/UseStatement.java b/src/java/org/apache/cassandra/cql3/statements/UseStatement.java index 3013d9f997..ae6eeb0bb1 100644 --- a/src/java/org/apache/cassandra/cql3/statements/UseStatement.java +++ b/src/java/org/apache/cassandra/cql3/statements/UseStatement.java @@ -29,6 +29,8 @@ import org.apache.cassandra.service.QueryState; import org.apache.commons.lang3.builder.ToStringBuilder; import org.apache.commons.lang3.builder.ToStringStyle; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + public class UseStatement extends CQLStatement.Raw implements CQLStatement { private final String keyspace; @@ -62,7 +64,7 @@ public class UseStatement extends CQLStatement.Raw implements CQLStatement { // In production, internal queries are exclusively on the system keyspace and 'use' is thus useless // but for some unit tests we need to set the keyspace (e.g. for tests with DROP INDEX) - return execute(state, options, System.nanoTime()); + return execute(state, options, nanoTime()); } @Override diff --git a/src/java/org/apache/cassandra/db/ColumnFamilyStore.java b/src/java/org/apache/cassandra/db/ColumnFamilyStore.java index 11fb56bfe6..497466ae96 100644 --- a/src/java/org/apache/cassandra/db/ColumnFamilyStore.java +++ b/src/java/org/apache/cassandra/db/ColumnFamilyStore.java @@ -96,6 +96,8 @@ import org.apache.cassandra.utils.memory.MemtableAllocator; import static java.util.concurrent.TimeUnit.NANOSECONDS; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.apache.cassandra.utils.Throwables.maybeFail; import static org.apache.cassandra.utils.Throwables.merge; @@ -1056,7 +1058,7 @@ public class ColumnFamilyStore implements ColumnFamilyStoreMBean if (logger.isTraceEnabled()) logger.trace("Flush task {}@{} starts executing, waiting on barrier", hashCode(), name); - long start = System.nanoTime(); + long start = nanoTime(); // mark writes older than the barrier as blocking progress, permitting them to exceed our memory limit // if they are stuck waiting on it, then wait for them all to complete @@ -1064,7 +1066,7 @@ public class ColumnFamilyStore implements ColumnFamilyStoreMBean writeBarrier.await(); if (logger.isTraceEnabled()) - logger.trace("Flush task for task {}@{} waited {} ms at the barrier", hashCode(), name, TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start)); + logger.trace("Flush task for task {}@{} waited {} ms at the barrier", hashCode(), name, TimeUnit.NANOSECONDS.toMillis(nanoTime() - start)); // mark all memtables as flushing, removing them from the live memtable list for (Memtable memtable : memtables) @@ -1331,7 +1333,7 @@ public class ColumnFamilyStore implements ColumnFamilyStoreMBean public void apply(PartitionUpdate update, UpdateTransaction indexer, OpOrder.Group opGroup, CommitLogPosition commitLogPosition) { - long start = System.nanoTime(); + long start = nanoTime(); try { Memtable mt = data.getMemtableFor(opGroup, commitLogPosition); @@ -1342,7 +1344,7 @@ public class ColumnFamilyStore implements ColumnFamilyStoreMBean if (metric.topWritePartitionSize.isEnabled()) // dont compute datasize if not needed metric.topWritePartitionSize.addSample(key.getKey(), update.dataSize()); StorageHook.instance.reportWrite(metadata.id, update); - metric.writeLatency.addNano(System.nanoTime() - start); + metric.writeLatency.addNano(nanoTime() - start); // CASSANDRA-11117 - certain resolution paths on memtable put can result in very // large time deltas, either through a variety of sentinel timestamps (used for empty values, ensuring // a minimal write, etc). This limits the time delta to the max value the histogram @@ -1526,8 +1528,9 @@ public class ColumnFamilyStore implements ColumnFamilyStoreMBean // skip snapshot creation during scrub, SEE JIRA 5891 if(!disableSnapshot) { - Instant creationTime = Instant.now(); - String snapshotName = "pre-scrub-" + creationTime.toEpochMilli(); + long epochMilli = currentTimeMillis(); + Instant creationTime = Instant.ofEpochMilli(epochMilli); + String snapshotName = "pre-scrub-" + epochMilli; snapshotWithoutFlush(snapshotName, creationTime); } @@ -1732,9 +1735,9 @@ public class ColumnFamilyStore implements ColumnFamilyStoreMBean return new RefViewFragment(view.sstables, view.memtables, refs); if (failingSince <= 0) { - failingSince = System.nanoTime(); + failingSince = nanoTime(); } - else if (System.nanoTime() - failingSince > TimeUnit.MILLISECONDS.toNanos(100)) + else if (nanoTime() - failingSince > TimeUnit.MILLISECONDS.toNanos(100)) { List released = new ArrayList<>(); for (SSTableReader reader : view.sstables) @@ -1742,7 +1745,7 @@ public class ColumnFamilyStore implements ColumnFamilyStoreMBean released.add(reader); NoSpamLogger.log(logger, NoSpamLogger.Level.WARN, 1, TimeUnit.SECONDS, "Spinning trying to capture readers {}, released: {}, ", view.sstables, released); - failingSince = System.nanoTime(); + failingSince = nanoTime(); } } } @@ -2314,7 +2317,7 @@ public class ColumnFamilyStore implements ColumnFamilyStoreMBean } } - long now = System.currentTimeMillis(); + long now = currentTimeMillis(); // make sure none of our sstables are somehow in the future (clock drift, perhaps) for (ColumnFamilyStore cfs : concatWithIndexes()) for (SSTableReader sstable : cfs.getLiveSSTables()) @@ -2791,7 +2794,7 @@ public class ColumnFamilyStore implements ColumnFamilyStoreMBean { double allDroppable = 0; long allColumns = 0; - int localTime = (int)(System.currentTimeMillis()/1000); + int localTime = (int)(currentTimeMillis() / 1000); for (SSTableReader sstable : getSSTables(SSTableSet.LIVE)) { diff --git a/src/java/org/apache/cassandra/db/CounterMutation.java b/src/java/org/apache/cassandra/db/CounterMutation.java index fe1e46e0b1..3ac1c5d2c0 100644 --- a/src/java/org/apache/cassandra/db/CounterMutation.java +++ b/src/java/org/apache/cassandra/db/CounterMutation.java @@ -50,6 +50,7 @@ import static java.util.concurrent.TimeUnit.*; import static org.apache.cassandra.net.MessagingService.VERSION_30; import static org.apache.cassandra.net.MessagingService.VERSION_3014; import static org.apache.cassandra.net.MessagingService.VERSION_40; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; public class CounterMutation implements IMutation { @@ -150,12 +151,12 @@ public class CounterMutation implements IMutation private void grabCounterLocks(Keyspace keyspace, List locks) throws WriteTimeoutException { - long startTime = System.nanoTime(); + long startTime = nanoTime(); AbstractReplicationStrategy replicationStrategy = keyspace.getReplicationStrategy(); for (Lock lock : LOCKS.bulkGet(getCounterLockKeys())) { - long timeout = getTimeout(NANOSECONDS) - (System.nanoTime() - startTime); + long timeout = getTimeout(NANOSECONDS) - (nanoTime() - startTime); try { if (!lock.tryLock(timeout, NANOSECONDS)) diff --git a/src/java/org/apache/cassandra/db/CounterMutationVerbHandler.java b/src/java/org/apache/cassandra/db/CounterMutationVerbHandler.java index a30ce665be..e4c7669806 100644 --- a/src/java/org/apache/cassandra/db/CounterMutationVerbHandler.java +++ b/src/java/org/apache/cassandra/db/CounterMutationVerbHandler.java @@ -26,6 +26,8 @@ import org.apache.cassandra.net.Message; import org.apache.cassandra.net.MessagingService; import org.apache.cassandra.service.StorageProxy; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + public class CounterMutationVerbHandler implements IVerbHandler { public static final CounterMutationVerbHandler instance = new CounterMutationVerbHandler(); @@ -34,7 +36,7 @@ public class CounterMutationVerbHandler implements IVerbHandler public void doVerb(final Message message) { - long queryStartNanoTime = System.nanoTime(); + long queryStartNanoTime = nanoTime(); final CounterMutation cm = message.payload; logger.trace("Applying forwarded {}", cm); diff --git a/src/java/org/apache/cassandra/db/ExpirationDateOverflowHandling.java b/src/java/org/apache/cassandra/db/ExpirationDateOverflowHandling.java index 81e3d1e24b..7f81b5c413 100644 --- a/src/java/org/apache/cassandra/db/ExpirationDateOverflowHandling.java +++ b/src/java/org/apache/cassandra/db/ExpirationDateOverflowHandling.java @@ -32,6 +32,8 @@ import org.apache.cassandra.schema.TableMetadata; import org.apache.cassandra.service.ClientWarn; import org.apache.cassandra.utils.NoSpamLogger; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; + public class ExpirationDateOverflowHandling { private static final Logger logger = LoggerFactory.getLogger(ExpirationDateOverflowHandling.class); @@ -75,7 +77,7 @@ public class ExpirationDateOverflowHandling return; // Check for localExpirationTime overflow (CASSANDRA-14092) - int nowInSecs = (int)(System.currentTimeMillis() / 1000); + int nowInSecs = (int)(currentTimeMillis() / 1000); if (ttl + nowInSecs < 0) { switch (policy) diff --git a/src/java/org/apache/cassandra/db/Keyspace.java b/src/java/org/apache/cassandra/db/Keyspace.java index e5cf7413be..08acf6b04d 100644 --- a/src/java/org/apache/cassandra/db/Keyspace.java +++ b/src/java/org/apache/cassandra/db/Keyspace.java @@ -75,6 +75,7 @@ import org.apache.cassandra.utils.concurrent.OpOrder; import static java.util.concurrent.TimeUnit.MILLISECONDS; import static java.util.concurrent.TimeUnit.NANOSECONDS; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; import static org.apache.cassandra.utils.MonotonicClock.approxTime; /** @@ -285,7 +286,7 @@ public class Keyspace */ public static String getTimestampedSnapshotName(String clientSuppliedName) { - String snapshotName = Long.toString(System.currentTimeMillis()); + String snapshotName = Long.toString(currentTimeMillis()); if (clientSuppliedName != null && !clientSuppliedName.equals("")) { snapshotName = snapshotName + "-" + clientSuppliedName; @@ -547,7 +548,7 @@ public class Keyspace if (requiresViewUpdate) { - mutation.viewLockAcquireStart.compareAndSet(0L, System.currentTimeMillis()); + mutation.viewLockAcquireStart.compareAndSet(0L, currentTimeMillis()); // the order of lock acquisition doesn't matter (from a deadlock perspective) because we only use tryLock() Collection tableIds = mutation.getTableIds(); @@ -625,7 +626,7 @@ public class Keyspace } } - long acquireTime = System.currentTimeMillis() - mutation.viewLockAcquireStart.get(); + long acquireTime = currentTimeMillis() - mutation.viewLockAcquireStart.get(); // Metrics are only collected for droppable write operations // Bulk non-droppable operations (e.g. commitlog replay, hint delivery) are not measured if (isDroppable) @@ -669,7 +670,7 @@ public class Keyspace cfs.getWriteHandler().write(upd, ctx, indexTransaction); if (requiresViewUpdate) - baseComplete.set(System.currentTimeMillis()); + baseComplete.set(currentTimeMillis()); } if (future != null) { diff --git a/src/java/org/apache/cassandra/db/Memtable.java b/src/java/org/apache/cassandra/db/Memtable.java index 73c64169f7..6e23cec17c 100644 --- a/src/java/org/apache/cassandra/db/Memtable.java +++ b/src/java/org/apache/cassandra/db/Memtable.java @@ -75,6 +75,8 @@ import org.apache.cassandra.utils.memory.MemtablePool; import org.apache.cassandra.utils.memory.NativePool; import org.apache.cassandra.utils.memory.SlabPool; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + public class Memtable implements Comparable { private static final Logger logger = LoggerFactory.getLogger(Memtable.class); @@ -137,7 +139,7 @@ public class Memtable implements Comparable // actually only store DecoratedKey. private final ConcurrentNavigableMap partitions = new ConcurrentSkipListMap<>(); public final ColumnFamilyStore cfs; - private final long creationNano = System.nanoTime(); + private final long creationNano = nanoTime(); // The smallest timestamp for all partitions stored in this memtable private long minTimestamp = Long.MAX_VALUE; @@ -261,7 +263,7 @@ public class Memtable implements Comparable public boolean isExpired() { int period = cfs.metadata().params.memtableFlushPeriodInMs; - return period > 0 && (System.nanoTime() - creationNano >= TimeUnit.MILLISECONDS.toNanos(period)); + return period > 0 && (nanoTime() - creationNano >= TimeUnit.MILLISECONDS.toNanos(period)); } /** diff --git a/src/java/org/apache/cassandra/db/ReadCommand.java b/src/java/org/apache/cassandra/db/ReadCommand.java index 4ea589a340..fd4636e8b3 100644 --- a/src/java/org/apache/cassandra/db/ReadCommand.java +++ b/src/java/org/apache/cassandra/db/ReadCommand.java @@ -72,6 +72,7 @@ import org.apache.cassandra.utils.ObjectSizes; import static com.google.common.collect.Iterables.any; import static com.google.common.collect.Iterables.filter; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.apache.cassandra.utils.MonotonicClock.approxTime; import static org.apache.cassandra.db.partitions.UnfilteredPartitionIterators.MergeListener.NOOP; @@ -397,7 +398,7 @@ public abstract class ReadCommand extends AbstractReadQuery // iterators created inside the try as long as we do close the original resultIterator), or by closing the result. public UnfilteredPartitionIterator executeLocally(ReadExecutionController executionController) { - long startTimeNanos = System.nanoTime(); + long startTimeNanos = nanoTime(); COMMAND.set(this); try @@ -568,7 +569,7 @@ public abstract class ReadCommand extends AbstractReadQuery @Override public void onClose() { - recordLatency(metric, System.nanoTime() - startTimeNanos); + recordLatency(metric, nanoTime() - startTimeNanos); metric.tombstoneScannedHistogram.update(tombstones); metric.liveScannedHistogram.update(liveRows); diff --git a/src/java/org/apache/cassandra/db/RepairedDataInfo.java b/src/java/org/apache/cassandra/db/RepairedDataInfo.java index f80b113097..32a4061085 100644 --- a/src/java/org/apache/cassandra/db/RepairedDataInfo.java +++ b/src/java/org/apache/cassandra/db/RepairedDataInfo.java @@ -36,6 +36,8 @@ import org.apache.cassandra.metrics.TableMetrics; import org.apache.cassandra.tracing.Tracing; import org.apache.cassandra.utils.ByteBufferUtil; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + @NotThreadSafe class RepairedDataInfo { @@ -281,7 +283,7 @@ class RepairedDataInfo return null; long countBeforeOverreads = repairedCounter.counted(); - long overreadStartTime = System.nanoTime(); + long overreadStartTime = nanoTime(); if (currentPartition != null) consumePartition(currentPartition, repairedCounter); @@ -291,7 +293,7 @@ class RepairedDataInfo // we're not actually providing any more rows, just consuming the repaired data long rows = repairedCounter.counted() - countBeforeOverreads; - long nanos = System.nanoTime() - overreadStartTime; + long nanos = nanoTime() - overreadStartTime; metrics.repairedDataTrackingOverreadRows.update(rows); metrics.repairedDataTrackingOverreadTime.update(nanos, TimeUnit.NANOSECONDS); Tracing.trace("Read {} additional rows of repaired data for tracking in {}ps", rows, TimeUnit.NANOSECONDS.toMicros(nanos)); diff --git a/src/java/org/apache/cassandra/db/SizeEstimatesRecorder.java b/src/java/org/apache/cassandra/db/SizeEstimatesRecorder.java index fe38d64d07..c5e9653225 100644 --- a/src/java/org/apache/cassandra/db/SizeEstimatesRecorder.java +++ b/src/java/org/apache/cassandra/db/SizeEstimatesRecorder.java @@ -37,6 +37,8 @@ import org.apache.cassandra.utils.FBUtilities; import org.apache.cassandra.utils.Pair; import org.apache.cassandra.utils.concurrent.Refs; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + /** * A very simplistic/crude partition count/size estimator. * @@ -89,7 +91,7 @@ public class SizeEstimatesRecorder extends SchemaChangeListener implements Runna boolean rangesAreEqual = primaryRanges.equals(localPrimaryRanges); for (ColumnFamilyStore table : keyspace.getColumnFamilyStores()) { - long start = System.nanoTime(); + long start = nanoTime(); // compute estimates for primary ranges for backwards compatability Map, Pair> estimates = computeSizeEstimates(table, primaryRanges); @@ -103,7 +105,7 @@ public class SizeEstimatesRecorder extends SchemaChangeListener implements Runna } SystemKeyspace.updateTableEstimates(table.metadata.keyspace, table.metadata.name, SystemKeyspace.TABLE_ESTIMATES_TYPE_LOCAL_PRIMARY, estimates); - long passed = System.nanoTime() - start; + long passed = nanoTime() - start; if (logger.isTraceEnabled()) logger.trace("Spent {} milliseconds on estimating {}.{} size", TimeUnit.NANOSECONDS.toMillis(passed), diff --git a/src/java/org/apache/cassandra/db/SystemKeyspace.java b/src/java/org/apache/cassandra/db/SystemKeyspace.java index e07101c2a2..a418c6d795 100644 --- a/src/java/org/apache/cassandra/db/SystemKeyspace.java +++ b/src/java/org/apache/cassandra/db/SystemKeyspace.java @@ -73,6 +73,8 @@ import static java.util.Collections.singletonMap; import static org.apache.cassandra.cql3.QueryProcessor.executeInternal; import static org.apache.cassandra.cql3.QueryProcessor.executeOnceInternal; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; public final class SystemKeyspace { @@ -1008,13 +1010,13 @@ public final class SystemKeyspace // seconds-since-epoch isn't a foolproof new generation // (where foolproof is "guaranteed to be larger than the last one seen at this ip address"), // but it's as close as sanely possible - generation = (int) (System.currentTimeMillis() / 1000); + generation = (int) (currentTimeMillis() / 1000); } else { // Other nodes will ignore gossip messages about a node that have a lower generation than previously seen. final int storedGeneration = result.one().getInt("gossip_generation") + 1; - final int now = (int) (System.currentTimeMillis() / 1000); + final int now = (int) (currentTimeMillis() / 1000); if (storedGeneration >= now) { logger.warn("Using stored Gossip Generation {} as it is greater than current system time {}. See CASSANDRA-3654 if you experience problems", @@ -1177,7 +1179,7 @@ public final class SystemKeyspace public static PaxosState loadPaxosState(DecoratedKey key, TableMetadata metadata, int nowInSec) { String req = "SELECT * FROM system.%s WHERE row_key = ? AND cf_id = ?"; - UntypedResultSet results = QueryProcessor.executeInternalWithNow(nowInSec, System.nanoTime(), format(req, PAXOS), key.getKey(), metadata.id.asUUID()); + UntypedResultSet results = QueryProcessor.executeInternalWithNow(nowInSec, nanoTime(), format(req, PAXOS), key.getKey(), metadata.id.asUUID()); if (results.isEmpty()) return new PaxosState(key, metadata); UntypedResultSet.Row row = results.one(); diff --git a/src/java/org/apache/cassandra/db/commitlog/AbstractCommitLogService.java b/src/java/org/apache/cassandra/db/commitlog/AbstractCommitLogService.java index a65ef00a11..24838a986e 100644 --- a/src/java/org/apache/cassandra/db/commitlog/AbstractCommitLogService.java +++ b/src/java/org/apache/cassandra/db/commitlog/AbstractCommitLogService.java @@ -33,6 +33,9 @@ import org.apache.cassandra.utils.MonotonicClock; import org.apache.cassandra.utils.NoSpamLogger; import org.apache.cassandra.utils.concurrent.WaitQueue; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + public abstract class AbstractCommitLogService { /** @@ -45,7 +48,7 @@ public abstract class AbstractCommitLogService private volatile boolean shutdown = false; // all Allocations written before this time will be synced - protected volatile long lastSyncedAt = System.currentTimeMillis(); + protected volatile long lastSyncedAt = currentTimeMillis(); // counts of total written, and pending, log messages private final AtomicLong written = new AtomicLong(0); @@ -292,7 +295,7 @@ public abstract class AbstractCommitLogService */ public void syncBlocking() { - long requestTime = System.nanoTime(); + long requestTime = nanoTime(); requestExtraSync(); awaitSyncAt(requestTime, null); } diff --git a/src/java/org/apache/cassandra/db/commitlog/CommitLogSegment.java b/src/java/org/apache/cassandra/db/commitlog/CommitLogSegment.java index 3e7e3ab491..55461a32b1 100644 --- a/src/java/org/apache/cassandra/db/commitlog/CommitLogSegment.java +++ b/src/java/org/apache/cassandra/db/commitlog/CommitLogSegment.java @@ -48,6 +48,7 @@ import org.apache.cassandra.utils.IntegerInterval; import org.apache.cassandra.utils.concurrent.OpOrder; import org.apache.cassandra.utils.concurrent.WaitQueue; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; import static org.apache.cassandra.utils.FBUtilities.updateChecksumInt; /* @@ -78,7 +79,7 @@ public abstract class CommitLogSegment if (CommitLogDescriptor.isValid(file.getName())) maxId = Math.max(CommitLogDescriptor.fromFileName(file.getName()).id, maxId); } - replayLimitId = idBase = Math.max(System.currentTimeMillis(), maxId + 1); + replayLimitId = idBase = Math.max(currentTimeMillis(), maxId + 1); } // The commit log entry overhead in bytes (int: length + int: head checksum + int: tail checksum) diff --git a/src/java/org/apache/cassandra/db/commitlog/PeriodicCommitLogService.java b/src/java/org/apache/cassandra/db/commitlog/PeriodicCommitLogService.java index e94c616e44..0644f32162 100644 --- a/src/java/org/apache/cassandra/db/commitlog/PeriodicCommitLogService.java +++ b/src/java/org/apache/cassandra/db/commitlog/PeriodicCommitLogService.java @@ -21,6 +21,8 @@ import java.util.concurrent.TimeUnit; import org.apache.cassandra.config.DatabaseDescriptor; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + class PeriodicCommitLogService extends AbstractCommitLogService { private static final long blockWhenSyncLagsNanos = TimeUnit.MILLISECONDS.toNanos(DatabaseDescriptor.getPeriodicCommitLogSyncBlock()); @@ -33,7 +35,7 @@ class PeriodicCommitLogService extends AbstractCommitLogService protected void maybeWaitForSync(CommitLogSegment.Allocation alloc) { - long expectedSyncTime = System.nanoTime() - blockWhenSyncLagsNanos; + long expectedSyncTime = nanoTime() - blockWhenSyncLagsNanos; if (lastSyncedAt < expectedSyncTime) { pending.incrementAndGet(); diff --git a/src/java/org/apache/cassandra/db/compaction/AbstractCompactionStrategy.java b/src/java/org/apache/cassandra/db/compaction/AbstractCompactionStrategy.java index 0b37c225c4..c0c4a95554 100644 --- a/src/java/org/apache/cassandra/db/compaction/AbstractCompactionStrategy.java +++ b/src/java/org/apache/cassandra/db/compaction/AbstractCompactionStrategy.java @@ -44,6 +44,9 @@ import org.apache.cassandra.io.sstable.metadata.MetadataCollector; import org.apache.cassandra.io.sstable.metadata.StatsMetadata; import org.apache.cassandra.schema.CompactionParams; +import static org.apache.cassandra.io.sstable.Component.DATA; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; + /** * Pluggable compaction strategy determines how SSTables get merged. * @@ -388,7 +391,7 @@ public abstract class AbstractCompactionStrategy // since we use estimations to calculate, there is a chance that compaction will not drop tombstones actually. // if that happens we will end up in infinite compaction loop, so first we check enough if enough time has // elapsed since SSTable created. - if (System.currentTimeMillis() < sstable.getCreationTimeFor(Component.DATA) + tombstoneCompactionInterval * 1000) + if (currentTimeMillis() < sstable.getCreationTimeFor(DATA) + tombstoneCompactionInterval * 1000) return false; double droppableRatio = sstable.getEstimatedDroppableTombstoneRatio(gcBefore); diff --git a/src/java/org/apache/cassandra/db/compaction/CompactionLogger.java b/src/java/org/apache/cassandra/db/compaction/CompactionLogger.java index f473be7059..a533f95199 100644 --- a/src/java/org/apache/cassandra/db/compaction/CompactionLogger.java +++ b/src/java/org/apache/cassandra/db/compaction/CompactionLogger.java @@ -45,6 +45,8 @@ import org.apache.cassandra.db.ColumnFamilyStore; import org.apache.cassandra.io.sstable.format.SSTableReader; import org.apache.cassandra.utils.NoSpamLogger; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; + public class CompactionLogger { public interface Strategy @@ -220,7 +222,7 @@ public class CompactionLogger return; node.put("keyspace", cfs.keyspace.getName()); node.put("table", cfs.getTableName()); - node.put("time", System.currentTimeMillis()); + node.put("time", currentTimeMillis()); } private JsonNode startStrategies() diff --git a/src/java/org/apache/cassandra/db/compaction/CompactionManager.java b/src/java/org/apache/cassandra/db/compaction/CompactionManager.java index c3e4f59c55..f099fb6e21 100644 --- a/src/java/org/apache/cassandra/db/compaction/CompactionManager.java +++ b/src/java/org/apache/cassandra/db/compaction/CompactionManager.java @@ -86,6 +86,7 @@ import org.apache.cassandra.utils.concurrent.Refs; import static java.util.Collections.singleton; import static org.apache.cassandra.service.ActiveRepairService.NO_PENDING_REPAIR; import static org.apache.cassandra.service.ActiveRepairService.UNREPAIRED_SSTABLE; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; /** *

@@ -1267,7 +1268,7 @@ public class CompactionManager implements CompactionManagerMBean return; } - long start = System.nanoTime(); + long start = nanoTime(); long totalkeysWritten = 0; @@ -1325,7 +1326,7 @@ public class CompactionManager implements CompactionManagerMBean if (!finished.isEmpty()) { String format = "Cleaned up to %s. %s to %s (~%d%% of original) for %,d keys. Time: %,dms."; - long dTime = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start); + long dTime = TimeUnit.NANOSECONDS.toMillis(nanoTime() - start); long startsize = sstable.onDiskLength(); long endsize = 0; for (SSTableReader newSstable : finished) @@ -2247,10 +2248,10 @@ public class CompactionManager implements CompactionManagerMBean public void waitForCessation(Iterable cfss, Predicate sstablePredicate) { - long start = System.nanoTime(); + long start = nanoTime(); long delay = TimeUnit.MINUTES.toNanos(1); - while (System.nanoTime() - start < delay) + while (nanoTime() - start < delay) { if (CompactionManager.instance.isCompacting(cfss, sstablePredicate)) Uninterruptibles.sleepUninterruptibly(1, TimeUnit.MILLISECONDS); diff --git a/src/java/org/apache/cassandra/db/compaction/CompactionTask.java b/src/java/org/apache/cassandra/db/compaction/CompactionTask.java index 19a0698967..9f654e2f30 100644 --- a/src/java/org/apache/cassandra/db/compaction/CompactionTask.java +++ b/src/java/org/apache/cassandra/db/compaction/CompactionTask.java @@ -47,6 +47,9 @@ import org.apache.cassandra.service.ActiveRepairService; import org.apache.cassandra.utils.FBUtilities; import org.apache.cassandra.utils.concurrent.Refs; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + public class CompactionTask extends AbstractCompactionTask { protected static final Logger logger = LoggerFactory.getLogger(CompactionTask.class); @@ -117,11 +120,11 @@ public class CompactionTask extends AbstractCompactionTask if (DatabaseDescriptor.isSnapshotBeforeCompaction()) { - Instant creationTime = Instant.now(); - cfs.snapshotWithoutFlush(creationTime.toEpochMilli() + "-compact-" + cfs.name, creationTime); + long epochMilli = currentTimeMillis(); + Instant creationTime = Instant.ofEpochMilli(epochMilli); + cfs.snapshotWithoutFlush(epochMilli + "-compact-" + cfs.name, creationTime); } - try (CompactionController controller = getCompactionController(transaction.originals())) { @@ -155,8 +158,8 @@ public class CompactionTask extends AbstractCompactionTask logger.info("Compacting ({}) {}", taskId, ssTableLoggerMsg); RateLimiter limiter = CompactionManager.instance.getRateLimiter(); - long start = System.nanoTime(); - long startTime = System.currentTimeMillis(); + long start = nanoTime(); + long startTime = currentTimeMillis(); long totalKeysWritten = 0; long estimatedKeys = 0; long inputSizeBytes; @@ -206,10 +209,10 @@ public class CompactionTask extends AbstractCompactionTask lastBytesScanned = bytesScanned; - if (System.nanoTime() - lastCheckObsoletion > TimeUnit.MINUTES.toNanos(1L)) + if (nanoTime() - lastCheckObsoletion > TimeUnit.MINUTES.toNanos(1L)) { controller.maybeRefreshOverlaps(); - lastCheckObsoletion = System.nanoTime(); + lastCheckObsoletion = nanoTime(); } } @@ -232,7 +235,7 @@ public class CompactionTask extends AbstractCompactionTask { // log a bunch of statistics about the result and save to system table compaction_history - long durationInNano = System.nanoTime() - start; + long durationInNano = nanoTime() - start; long dTime = TimeUnit.NANOSECONDS.toMillis(durationInNano); long startsize = inputSizeBytes; long endsize = SSTableReader.getTotalBytes(newSStables); @@ -267,7 +270,7 @@ public class CompactionTask extends AbstractCompactionTask logger.trace("CF Total Bytes Compacted: {}", FBUtilities.prettyPrintMemory(CompactionTask.addToTotalBytesCompacted(endsize))); logger.trace("Actual #keys: {}, Estimated #keys:{}, Err%: {}", totalKeysWritten, estimatedKeys, ((double)(totalKeysWritten - estimatedKeys)/totalKeysWritten)); } - cfs.getCompactionStrategyManager().compactionLogger.compaction(startTime, transaction.originals(), System.currentTimeMillis(), newSStables); + cfs.getCompactionStrategyManager().compactionLogger.compaction(startTime, transaction.originals(), currentTimeMillis(), newSStables); // update the metrics cfs.metric.compactionBytesWritten.inc(endsize); @@ -298,7 +301,7 @@ public class CompactionTask extends AbstractCompactionTask mergeSummary.append(String.format("%d:%d, ", rows, count)); mergedRows.put(rows, count); } - SystemKeyspace.updateCompactionHistory(keyspaceName, columnFamilyName, System.currentTimeMillis(), startSize, endSize, mergedRows); + SystemKeyspace.updateCompactionHistory(keyspaceName, columnFamilyName, currentTimeMillis(), startSize, endSize, mergedRows); return mergeSummary.toString(); } diff --git a/src/java/org/apache/cassandra/db/compaction/DateTieredCompactionStrategy.java b/src/java/org/apache/cassandra/db/compaction/DateTieredCompactionStrategy.java index ab2b6ae328..40f744bb87 100644 --- a/src/java/org/apache/cassandra/db/compaction/DateTieredCompactionStrategy.java +++ b/src/java/org/apache/cassandra/db/compaction/DateTieredCompactionStrategy.java @@ -38,6 +38,7 @@ import org.apache.cassandra.schema.CompactionParams; import org.apache.cassandra.utils.Pair; import static com.google.common.collect.Iterables.filter; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; /** * @deprecated in favour of {@link TimeWindowCompactionStrategy} @@ -116,11 +117,11 @@ public class DateTieredCompactionStrategy extends AbstractCompactionStrategy Set expired = Collections.emptySet(); // we only check for expired sstables every 10 minutes (by default) due to it being an expensive operation - if (System.currentTimeMillis() - lastExpiredCheck > options.expiredSSTableCheckFrequency) + if (currentTimeMillis() - lastExpiredCheck > options.expiredSSTableCheckFrequency) { // Find fully expired SSTables. Those will be included no matter what. expired = CompactionController.getFullyExpiredSSTables(cfs, uncompacting, cfs.getOverlappingLiveSSTables(uncompacting), gcBefore); - lastExpiredCheck = System.currentTimeMillis(); + lastExpiredCheck = currentTimeMillis(); } Set candidates = Sets.newHashSet(filterSuspectSSTables(uncompacting)); diff --git a/src/java/org/apache/cassandra/db/compaction/LeveledGenerations.java b/src/java/org/apache/cassandra/db/compaction/LeveledGenerations.java index 2cc1b1a77d..ff231e7cf8 100644 --- a/src/java/org/apache/cassandra/db/compaction/LeveledGenerations.java +++ b/src/java/org/apache/cassandra/db/compaction/LeveledGenerations.java @@ -42,6 +42,8 @@ import org.apache.cassandra.config.Config; import org.apache.cassandra.io.sstable.format.SSTableReader; import org.apache.cassandra.utils.FBUtilities; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + /** * Handles the leveled manifest generations * @@ -68,7 +70,7 @@ class LeveledGenerations */ private final Map allSSTables = new HashMap<>(); private final Set l0 = new HashSet<>(); - private static long lastOverlapCheck = System.nanoTime(); + private static long lastOverlapCheck = nanoTime(); // note that since l0 is broken out, levels[0] represents L1: private final TreeSet [] levels = new TreeSet[MAX_LEVEL_COUNT - 1]; @@ -310,10 +312,10 @@ class LeveledGenerations */ private void maybeVerifyLevels() { - if (!strictLCSChecksTest || System.nanoTime() - lastOverlapCheck <= TimeUnit.NANOSECONDS.convert(5, TimeUnit.SECONDS)) + if (!strictLCSChecksTest || nanoTime() - lastOverlapCheck <= TimeUnit.NANOSECONDS.convert(5, TimeUnit.SECONDS)) return; logger.info("LCS verifying levels"); - lastOverlapCheck = System.nanoTime(); + lastOverlapCheck = nanoTime(); for (int i = 1; i < levelCount(); i++) { SSTableReader prev = null; diff --git a/src/java/org/apache/cassandra/db/compaction/TimeWindowCompactionStrategy.java b/src/java/org/apache/cassandra/db/compaction/TimeWindowCompactionStrategy.java index 968def333c..d3b30210d4 100644 --- a/src/java/org/apache/cassandra/db/compaction/TimeWindowCompactionStrategy.java +++ b/src/java/org/apache/cassandra/db/compaction/TimeWindowCompactionStrategy.java @@ -45,6 +45,7 @@ import org.apache.cassandra.schema.CompactionParams; import org.apache.cassandra.utils.Pair; import static com.google.common.collect.Iterables.filter; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; public class TimeWindowCompactionStrategy extends AbstractCompactionStrategy { @@ -117,12 +118,12 @@ public class TimeWindowCompactionStrategy extends AbstractCompactionStrategy // Find fully expired SSTables. Those will be included no matter what. Set expired = Collections.emptySet(); - if (System.currentTimeMillis() - lastExpiredCheck > options.expiredSSTableCheckFrequency) + if (currentTimeMillis() - lastExpiredCheck > options.expiredSSTableCheckFrequency) { logger.debug("TWCS expired check sufficiently far in the past, checking for fully expired SSTables"); expired = CompactionController.getFullyExpiredSSTables(cfs, uncompacting, options.ignoreOverlaps ? Collections.emptySet() : cfs.getOverlappingLiveSSTables(uncompacting), gcBefore, options.ignoreOverlaps); - lastExpiredCheck = System.currentTimeMillis(); + lastExpiredCheck = currentTimeMillis(); } else { diff --git a/src/java/org/apache/cassandra/db/lifecycle/LogFile.java b/src/java/org/apache/cassandra/db/lifecycle/LogFile.java index a91af734c8..1fc371f7d2 100644 --- a/src/java/org/apache/cassandra/db/lifecycle/LogFile.java +++ b/src/java/org/apache/cassandra/db/lifecycle/LogFile.java @@ -41,6 +41,7 @@ import org.apache.cassandra.io.sstable.format.SSTableReader; import org.apache.cassandra.io.sstable.format.big.BigFormat; import org.apache.cassandra.utils.Throwables; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; import static org.apache.cassandra.utils.Throwables.merge; /** @@ -274,12 +275,12 @@ final class LogFile implements AutoCloseable void commit() { - addRecord(LogRecord.makeCommit(System.currentTimeMillis())); + addRecord(LogRecord.makeCommit(currentTimeMillis())); } void abort() { - addRecord(LogRecord.makeAbort(System.currentTimeMillis())); + addRecord(LogRecord.makeAbort(currentTimeMillis())); } private boolean isLastRecordValidWithType(Type type) diff --git a/src/java/org/apache/cassandra/db/marshal/TemporalType.java b/src/java/org/apache/cassandra/db/marshal/TemporalType.java index 4e2ac5a554..945dae04f4 100644 --- a/src/java/org/apache/cassandra/db/marshal/TemporalType.java +++ b/src/java/org/apache/cassandra/db/marshal/TemporalType.java @@ -21,6 +21,8 @@ import java.nio.ByteBuffer; import org.apache.cassandra.cql3.Duration; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; + /** * Base type for temporal types (timestamp, date ...). * @@ -38,7 +40,7 @@ public abstract class TemporalType extends AbstractType */ public ByteBuffer now() { - return fromTimeInMillis(System.currentTimeMillis()); + return fromTimeInMillis(currentTimeMillis()); } /** diff --git a/src/java/org/apache/cassandra/db/partitions/AtomicBTreePartition.java b/src/java/org/apache/cassandra/db/partitions/AtomicBTreePartition.java index 801d9e2338..c5e9fe4c7f 100644 --- a/src/java/org/apache/cassandra/db/partitions/AtomicBTreePartition.java +++ b/src/java/org/apache/cassandra/db/partitions/AtomicBTreePartition.java @@ -39,6 +39,8 @@ import org.apache.cassandra.utils.concurrent.OpOrder; import org.apache.cassandra.utils.memory.HeapAllocator; import org.apache.cassandra.utils.memory.MemtableAllocator; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + /** * A thread-safe and atomic Partition implementation. * @@ -305,7 +307,7 @@ public final class AtomicBTreePartition extends AbstractBTreePartition while (TRACKER_PESSIMISTIC_LOCKING != (oldTrackerValue = wasteTracker)) { // Note this time value has an arbitrary offset, but is a constant rate 32 bit counter (that may wrap) - int time = (int) (System.nanoTime() >>> CLOCK_SHIFT); + int time = (int) (nanoTime() >>> CLOCK_SHIFT); int delta = oldTrackerValue - time; if (oldTrackerValue == TRACKER_NEVER_WASTED || delta >= 0 || delta < -EXCESS_WASTE_OFFSET) delta = -EXCESS_WASTE_OFFSET; diff --git a/src/java/org/apache/cassandra/db/repair/PendingAntiCompaction.java b/src/java/org/apache/cassandra/db/repair/PendingAntiCompaction.java index e0ee68d955..0d8928289f 100644 --- a/src/java/org/apache/cassandra/db/repair/PendingAntiCompaction.java +++ b/src/java/org/apache/cassandra/db/repair/PendingAntiCompaction.java @@ -57,6 +57,7 @@ import org.apache.cassandra.utils.concurrent.Refs; import static org.apache.cassandra.service.ActiveRepairService.NO_PENDING_REPAIR; import static org.apache.cassandra.service.ActiveRepairService.UNREPAIRED_SSTABLE; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; /** * Performs an anti compaction on a set of tables and token ranges, isolating the unrepaired sstables @@ -218,7 +219,7 @@ public class PendingAntiCompaction logger.debug("acquiring sstables for pending anti compaction on session {}", sessionID); // try to modify after cancelling running compactions. This will attempt to cancel in flight compactions including the given sstables for // up to a minute, after which point, null will be returned - long start = System.currentTimeMillis(); + long start = currentTimeMillis(); long delay = TimeUnit.SECONDS.toMillis(acquireRetrySeconds); // Note that it is `predicate` throwing SSTableAcquisitionException if it finds a conflicting sstable // and we only retry when runWithCompactionsDisabled throws when uses the predicate, not when acquireTuple is. @@ -238,10 +239,10 @@ public class PendingAntiCompaction sessionID, e.getMessage(), acquireSleepMillis, - TimeUnit.SECONDS.convert(delay + start - System.currentTimeMillis(), TimeUnit.MILLISECONDS)); + TimeUnit.SECONDS.convert(delay + start - currentTimeMillis(), TimeUnit.MILLISECONDS)); Uninterruptibles.sleepUninterruptibly(acquireSleepMillis, TimeUnit.MILLISECONDS); - if (System.currentTimeMillis() - start > delay) + if (currentTimeMillis() - start > delay) logger.warn("{} Timed out waiting to acquire sstables", sessionID, e); } @@ -250,7 +251,7 @@ public class PendingAntiCompaction logger.error("Got exception disabling compactions for session {}", sessionID, t); throw t; } - } while (System.currentTimeMillis() - start < delay); + } while (currentTimeMillis() - start < delay); return null; } } diff --git a/src/java/org/apache/cassandra/db/view/TableViews.java b/src/java/org/apache/cassandra/db/view/TableViews.java index cc58dc19e7..3afd128299 100644 --- a/src/java/org/apache/cassandra/db/view/TableViews.java +++ b/src/java/org/apache/cassandra/db/view/TableViews.java @@ -41,6 +41,8 @@ import org.apache.cassandra.service.StorageProxy; import org.apache.cassandra.utils.FBUtilities; import org.apache.cassandra.utils.btree.BTreeSet; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + /** * Groups all the views for a given table. @@ -146,13 +148,13 @@ public class TableViews extends AbstractCollection // Read modified rows int nowInSec = FBUtilities.nowInSeconds(); - long queryStartNanoTime = System.nanoTime(); + long queryStartNanoTime = nanoTime(); SinglePartitionReadCommand command = readExistingRowsCommand(update, views, nowInSec); if (command == null) return; ColumnFamilyStore cfs = Keyspace.openAndGetStore(update.metadata()); - long start = System.nanoTime(); + long start = nanoTime(); Collection mutations; try (ReadExecutionController orderGroup = command.executionController(); UnfilteredRowIterator existings = UnfilteredPartitionIterators.getOnlyElement(command.executeLocally(orderGroup), command); @@ -160,7 +162,7 @@ public class TableViews extends AbstractCollection { mutations = Iterators.getOnlyElement(generateViewUpdates(views, updates, existings, nowInSec, false)); } - Keyspace.openAndGetStore(update.metadata()).metric.viewReadTime.update(System.nanoTime() - start, TimeUnit.NANOSECONDS); + Keyspace.openAndGetStore(update.metadata()).metric.viewReadTime.update(nanoTime() - start, TimeUnit.NANOSECONDS); if (!mutations.isEmpty()) StorageProxy.mutateMV(update.partitionKey().getKey(), mutations, writeCommitLog, baseComplete, queryStartNanoTime); diff --git a/src/java/org/apache/cassandra/db/view/ViewBuilderTask.java b/src/java/org/apache/cassandra/db/view/ViewBuilderTask.java index c84c6978dc..3c9c037365 100644 --- a/src/java/org/apache/cassandra/db/view/ViewBuilderTask.java +++ b/src/java/org/apache/cassandra/db/view/ViewBuilderTask.java @@ -63,6 +63,8 @@ import org.apache.cassandra.utils.FBUtilities; import org.apache.cassandra.utils.UUIDGen; import org.apache.cassandra.utils.concurrent.Refs; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + public class ViewBuilderTask extends CompactionInfo.Holder implements Callable { private static final Logger logger = LoggerFactory.getLogger(ViewBuilderTask.class); @@ -115,7 +117,7 @@ public class ViewBuilderTask extends CompactionInfo.Holder implements Callable StorageProxy.mutateMV(key.getKey(), m, true, noBase, System.nanoTime())); + mutations.forEachRemaining(m -> StorageProxy.mutateMV(key.getKey(), m, true, noBase, nanoTime())); } } diff --git a/src/java/org/apache/cassandra/db/virtual/AbstractVirtualTable.java b/src/java/org/apache/cassandra/db/virtual/AbstractVirtualTable.java index 96fb7f9527..b20ac434ce 100644 --- a/src/java/org/apache/cassandra/db/virtual/AbstractVirtualTable.java +++ b/src/java/org/apache/cassandra/db/virtual/AbstractVirtualTable.java @@ -38,6 +38,8 @@ import org.apache.cassandra.dht.AbstractBounds; import org.apache.cassandra.exceptions.InvalidRequestException; import org.apache.cassandra.schema.TableMetadata; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; + /** * An abstract virtual table implementation that builds the resultset on demand. */ @@ -81,7 +83,7 @@ public abstract class AbstractVirtualTable implements VirtualTable if (null == partition) return EmptyIterators.unfilteredPartition(metadata); - long now = System.currentTimeMillis(); + long now = currentTimeMillis(); UnfilteredRowIterator rowIterator = partition.toRowIterator(metadata(), clusteringIndexFilter, columnFilter, now); return new SingletonUnfilteredPartitionIterator(rowIterator); } @@ -96,7 +98,7 @@ public abstract class AbstractVirtualTable implements VirtualTable Iterator iterator = data.getPartitions(dataRange); - long now = System.currentTimeMillis(); + long now = currentTimeMillis(); return new AbstractUnfilteredPartitionIterator() { diff --git a/src/java/org/apache/cassandra/diag/DiagnosticEvent.java b/src/java/org/apache/cassandra/diag/DiagnosticEvent.java index 5de703bd71..229710c05e 100644 --- a/src/java/org/apache/cassandra/diag/DiagnosticEvent.java +++ b/src/java/org/apache/cassandra/diag/DiagnosticEvent.java @@ -20,6 +20,8 @@ package org.apache.cassandra.diag; import java.io.Serializable; import java.util.Map; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; + /** * Base class for internally emitted events used for diagnostics and testing. */ @@ -28,7 +30,7 @@ public abstract class DiagnosticEvent /** * Event creation time. */ - public final long timestamp = System.currentTimeMillis(); + public final long timestamp = currentTimeMillis(); /** * Name of allocating thread. diff --git a/src/java/org/apache/cassandra/diag/LastEventIdBroadcaster.java b/src/java/org/apache/cassandra/diag/LastEventIdBroadcaster.java index 8e991e6ec3..e82b40cbcb 100644 --- a/src/java/org/apache/cassandra/diag/LastEventIdBroadcaster.java +++ b/src/java/org/apache/cassandra/diag/LastEventIdBroadcaster.java @@ -33,6 +33,8 @@ import org.apache.cassandra.concurrent.ScheduledExecutors; import org.apache.cassandra.utils.MBeanWrapper; import org.apache.cassandra.utils.progress.jmx.JMXBroadcastExecutor; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; + /** * Broadcaster for notifying JMX clients on newly available data. Periodically sends {@link Notification}s * containing a list of event types and greatest event IDs. Consumers may use this information to @@ -100,7 +102,7 @@ final class LastEventIdBroadcaster extends NotificationBroadcasterSupport implem { // ensure monotonic properties of ids if (summary.compute(key, (k, v) -> v == null ? id : id.compareTo(v) > 0 ? id : v) == id) { - summary.put("last_updated_at", System.currentTimeMillis()); + summary.put("last_updated_at", currentTimeMillis()); scheduleBroadcast(); } } @@ -132,7 +134,7 @@ final class LastEventIdBroadcaster extends NotificationBroadcasterSupport implem Notification notification = new Notification("event_last_id_summary", "LastEventIdBroadcaster", notificationSerialNumber.incrementAndGet(), - System.currentTimeMillis(), + currentTimeMillis(), "Event last IDs summary"); notification.setUserData(summary); sendNotification(notification); diff --git a/src/java/org/apache/cassandra/gms/EndpointState.java b/src/java/org/apache/cassandra/gms/EndpointState.java index b8d56263e7..9a69de341d 100644 --- a/src/java/org/apache/cassandra/gms/EndpointState.java +++ b/src/java/org/apache/cassandra/gms/EndpointState.java @@ -33,6 +33,8 @@ import org.apache.cassandra.io.util.DataInputPlus; import org.apache.cassandra.io.util.DataOutputPlus; import org.apache.cassandra.utils.CassandraVersion; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + /** * This abstraction represents both the HeartBeatState and the ApplicationState in an EndpointState * instance. Any state for a given endpoint can be retrieved from this instance. @@ -66,7 +68,7 @@ public class EndpointState { hbState = initialHbState; applicationState = new AtomicReference>(new EnumMap<>(states)); - updateTimestamp = System.nanoTime(); + updateTimestamp = nanoTime(); isAlive = true; } @@ -173,7 +175,7 @@ public class EndpointState void updateTimestamp() { - updateTimestamp = System.nanoTime(); + updateTimestamp = nanoTime(); } public boolean isAlive() diff --git a/src/java/org/apache/cassandra/gms/GossipDigestAckVerbHandler.java b/src/java/org/apache/cassandra/gms/GossipDigestAckVerbHandler.java index 0242d837e1..5fbe7ce0e3 100644 --- a/src/java/org/apache/cassandra/gms/GossipDigestAckVerbHandler.java +++ b/src/java/org/apache/cassandra/gms/GossipDigestAckVerbHandler.java @@ -29,6 +29,7 @@ import org.apache.cassandra.net.Message; import org.apache.cassandra.net.MessagingService; import static org.apache.cassandra.net.Verb.GOSSIP_DIGEST_ACK2; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; public class GossipDigestAckVerbHandler extends GossipVerbHandler { @@ -68,7 +69,7 @@ public class GossipDigestAckVerbHandler extends GossipVerbHandler endpointShadowStateMap = new ConcurrentHashMap<>(); - private volatile long lastProcessedMessageAt = System.currentTimeMillis(); + private volatile long lastProcessedMessageAt = currentTimeMillis(); /** * This property is initially set to {@code true} which means that we have no information about the other nodes. @@ -448,7 +450,7 @@ public class Gossiper implements IFailureDetectionEventListener, GossiperMBean { Long downtime = unreachableEndpoints.get(ep); if (downtime != null) - return TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - downtime); + return TimeUnit.NANOSECONDS.toMillis(nanoTime() - downtime); else return 0L; } @@ -620,7 +622,7 @@ public class Gossiper implements IFailureDetectionEventListener, GossiperMBean */ private void quarantineEndpoint(InetAddressAndPort endpoint) { - quarantineEndpoint(endpoint, System.currentTimeMillis()); + quarantineEndpoint(endpoint, currentTimeMillis()); } /** @@ -643,7 +645,7 @@ public class Gossiper implements IFailureDetectionEventListener, GossiperMBean { // remember, quarantineEndpoint will effectively already add QUARANTINE_DELAY, so this is 2x logger.debug(""); - quarantineEndpoint(endpoint, System.currentTimeMillis() + QUARANTINE_DELAY); + quarantineEndpoint(endpoint, currentTimeMillis() + QUARANTINE_DELAY); GossiperDiagnostics.replacementQuarantine(this, endpoint); } @@ -777,7 +779,7 @@ public class Gossiper implements IFailureDetectionEventListener, GossiperMBean if (epState == null) { - epState = new EndpointState(new HeartBeatState((int) ((System.currentTimeMillis() + 60000) / 1000), 9999)); + epState = new EndpointState(new HeartBeatState((int) ((currentTimeMillis() + 60000) / 1000), 9999)); } else { @@ -851,7 +853,7 @@ public class Gossiper implements IFailureDetectionEventListener, GossiperMBean if (logger.isTraceEnabled()) logger.trace("Sending a GossipDigestSyn to {} ...", to); if (firstSynSendAt == 0) - firstSynSendAt = System.nanoTime(); + firstSynSendAt = nanoTime(); MessagingService.instance().send(message, to); boolean isSeed = seeds.contains(to); @@ -985,8 +987,8 @@ public class Gossiper implements IFailureDetectionEventListener, GossiperMBean if (logger.isTraceEnabled()) logger.trace("Performing status check ..."); - long now = System.currentTimeMillis(); - long nowNano = System.nanoTime(); + long now = currentTimeMillis(); + long nowNano = nanoTime(); long pending = ((JMXEnabledThreadPoolExecutor) Stage.GOSSIP.executor()).metrics.pendingTasks.getValue(); if (pending > 0 && lastProcessedMessageAt < now - 1000) @@ -1307,7 +1309,7 @@ public class Gossiper implements IFailureDetectionEventListener, GossiperMBean { localState.markDead(); liveEndpoints.remove(addr); - unreachableEndpoints.put(addr, System.nanoTime()); + unreachableEndpoints.put(addr, nanoTime()); } /** @@ -1448,7 +1450,7 @@ public class Gossiper implements IFailureDetectionEventListener, GossiperMBean { int localGeneration = localEpStatePtr.getHeartBeatState().getGeneration(); int remoteGeneration = remoteState.getHeartBeatState().getGeneration(); - long localTime = System.currentTimeMillis()/1000; + long localTime = currentTimeMillis() / 1000; if (logger.isTraceEnabled()) logger.trace("{} local generation {}, remote generation {}", ep, localGeneration, remoteGeneration); @@ -2125,7 +2127,7 @@ public class Gossiper implements IFailureDetectionEventListener, GossiperMBean public static long computeExpireTime() { - return System.currentTimeMillis() + Gossiper.aVeryLongTime; + return currentTimeMillis() + aVeryLongTime; } @Nullable diff --git a/src/java/org/apache/cassandra/hadoop/cql3/CqlInputFormat.java b/src/java/org/apache/cassandra/hadoop/cql3/CqlInputFormat.java index 1ea8eda925..57fb238873 100644 --- a/src/java/org/apache/cassandra/hadoop/cql3/CqlInputFormat.java +++ b/src/java/org/apache/cassandra/hadoop/cql3/CqlInputFormat.java @@ -54,7 +54,7 @@ import org.apache.cassandra.dht.*; import org.apache.cassandra.hadoop.*; import org.apache.cassandra.utils.*; -import static java.util.stream.Collectors.toMap; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; /** * Hadoop InputFormat allowing map/reduce against Cassandra rows within one ColumnFamily. @@ -242,7 +242,7 @@ public class CqlInputFormat extends org.apache.hadoop.mapreduce.InputFormat 0; - Collections.shuffle(splits, new Random(System.nanoTime())); + Collections.shuffle(splits, new Random(nanoTime())); return splits; } diff --git a/src/java/org/apache/cassandra/hints/Hint.java b/src/java/org/apache/cassandra/hints/Hint.java index b6459a15de..11ac5157d2 100644 --- a/src/java/org/apache/cassandra/hints/Hint.java +++ b/src/java/org/apache/cassandra/hints/Hint.java @@ -39,6 +39,7 @@ import org.assertj.core.util.VisibleForTesting; import static org.apache.cassandra.db.TypeSizes.sizeof; import static org.apache.cassandra.db.TypeSizes.sizeofUnsignedVInt; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; /** * Encapsulates the hinted mutation, its creation time, and the gc grace seconds param for each table involved. @@ -135,7 +136,7 @@ public final class Hint */ public boolean isLive() { - return isLive(creationTime, System.currentTimeMillis(), ttl()); + return isLive(creationTime, currentTimeMillis(), ttl()); } static boolean isLive(long creationTime, long now, int hintTTL) diff --git a/src/java/org/apache/cassandra/hints/HintsCleanupTrigger.java b/src/java/org/apache/cassandra/hints/HintsCleanupTrigger.java index 67fb3e559d..4d10711470 100644 --- a/src/java/org/apache/cassandra/hints/HintsCleanupTrigger.java +++ b/src/java/org/apache/cassandra/hints/HintsCleanupTrigger.java @@ -25,6 +25,8 @@ import org.apache.cassandra.concurrent.ScheduledExecutors; import org.apache.cassandra.config.DatabaseDescriptor; import org.apache.cassandra.service.StorageService; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; + /** * Delete the expired orphaned hints files. * An orphaned file is considered as no associating endpoint with its host ID. @@ -62,7 +64,7 @@ final class HintsCleanupTrigger implements Runnable // Interrupt the dispatch if any. At this step, it is certain that the hintsStore is orphaned. dispatchExecutor.interruptDispatch(hintsStore.hostId); - Runnable cleanup = () -> hintsStore.deleteExpiredHints(System.currentTimeMillis()); + Runnable cleanup = () -> hintsStore.deleteExpiredHints(currentTimeMillis()); ScheduledExecutors.optionalTasks.execute(cleanup); } } diff --git a/src/java/org/apache/cassandra/hints/HintsReader.java b/src/java/org/apache/cassandra/hints/HintsReader.java index 9a5f75a076..7514fd4269 100644 --- a/src/java/org/apache/cassandra/hints/HintsReader.java +++ b/src/java/org/apache/cassandra/hints/HintsReader.java @@ -36,6 +36,8 @@ import org.apache.cassandra.io.FSReadError; import org.apache.cassandra.service.StorageService; import org.apache.cassandra.utils.AbstractIterator; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; + /** * A paged non-compressed hints reader that provides two iterators: * - a 'raw' ByteBuffer iterator that doesn't deserialize the hints, but returns the pre-encoded hints verbatim @@ -164,7 +166,7 @@ class HintsReader implements AutoCloseable, Iterable final class HintsIterator extends AbstractIterator { private final InputPosition offset; - private final long now = System.currentTimeMillis(); + private final long now = currentTimeMillis(); HintsIterator(InputPosition offset) { @@ -270,7 +272,7 @@ class HintsReader implements AutoCloseable, Iterable final class BuffersIterator extends AbstractIterator { private final InputPosition offset; - private final long now = System.currentTimeMillis(); + private final long now = currentTimeMillis(); BuffersIterator(InputPosition offset) { diff --git a/src/java/org/apache/cassandra/hints/HintsStore.java b/src/java/org/apache/cassandra/hints/HintsStore.java index 76c13d1823..1e72f8be40 100644 --- a/src/java/org/apache/cassandra/hints/HintsStore.java +++ b/src/java/org/apache/cassandra/hints/HintsStore.java @@ -38,6 +38,8 @@ import org.apache.cassandra.schema.Schema; import org.apache.cassandra.service.StorageService; import org.apache.cassandra.utils.SyncUtil; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; + /** * Encapsulates the state of a peer's hints: the queue of hints files for dispatch, and the current writer (if any). * @@ -247,7 +249,7 @@ final class HintsStore private HintsWriter openWriter() { - lastUsedTimestamp = Math.max(System.currentTimeMillis(), lastUsedTimestamp + 1); + lastUsedTimestamp = Math.max(currentTimeMillis(), lastUsedTimestamp + 1); HintsDescriptor descriptor = new HintsDescriptor(hostId, lastUsedTimestamp, writerParams); try diff --git a/src/java/org/apache/cassandra/index/sasi/disk/PerSSTableIndexWriter.java b/src/java/org/apache/cassandra/index/sasi/disk/PerSSTableIndexWriter.java index 0af4ba2aef..1f01a9cb75 100644 --- a/src/java/org/apache/cassandra/index/sasi/disk/PerSSTableIndexWriter.java +++ b/src/java/org/apache/cassandra/index/sasi/disk/PerSSTableIndexWriter.java @@ -52,6 +52,8 @@ import com.google.common.util.concurrent.Uninterruptibles; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + public class PerSSTableIndexWriter implements SSTableFlushObserver { private static final Logger logger = LoggerFactory.getLogger(PerSSTableIndexWriter.class); @@ -251,7 +253,7 @@ public class PerSSTableIndexWriter implements SSTableFlushObserver final String segmentFile = filename(isFinal); return () -> { - long start = System.nanoTime(); + long start = nanoTime(); try { @@ -266,7 +268,7 @@ public class PerSSTableIndexWriter implements SSTableFlushObserver finally { if (!isFinal) - logger.info("Flushed index segment {}, took {} ms.", segmentFile, TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start)); + logger.info("Flushed index segment {}, took {} ms.", segmentFile, TimeUnit.NANOSECONDS.toMillis(nanoTime() - start)); } }; } @@ -276,7 +278,7 @@ public class PerSSTableIndexWriter implements SSTableFlushObserver logger.info("Scheduling index flush to {}", outputFile); getExecutor().submit((Runnable) () -> { - long start1 = System.nanoTime(); + long start1 = nanoTime(); OnDiskIndex[] parts = new OnDiskIndex[segments.size() + 1]; @@ -324,7 +326,7 @@ public class PerSSTableIndexWriter implements SSTableFlushObserver } finally { - logger.info("Index flush to {} took {} ms.", outputFile, TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start1)); + logger.info("Index flush to {} took {} ms.", outputFile, TimeUnit.NANOSECONDS.toMillis(nanoTime() - start1)); for (int segment = 0; segment < segmentNumber; segment++) { diff --git a/src/java/org/apache/cassandra/index/sasi/plan/QueryController.java b/src/java/org/apache/cassandra/index/sasi/plan/QueryController.java index db16c52127..60538e107e 100644 --- a/src/java/org/apache/cassandra/index/sasi/plan/QueryController.java +++ b/src/java/org/apache/cassandra/index/sasi/plan/QueryController.java @@ -49,6 +49,8 @@ import org.apache.cassandra.io.util.FileUtils; import org.apache.cassandra.schema.TableMetadata; import org.apache.cassandra.utils.Pair; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + public class QueryController { private final long executionQuota; @@ -65,7 +67,7 @@ public class QueryController this.command = command; this.range = command.dataRange(); this.executionQuota = TimeUnit.MILLISECONDS.toNanos(timeQuotaMs); - this.executionStart = System.nanoTime(); + this.executionStart = nanoTime(); } public TableMetadata metadata() @@ -154,7 +156,7 @@ public class QueryController public void checkpoint() { - long executionTime = (System.nanoTime() - executionStart); + long executionTime = (nanoTime() - executionStart); if (executionTime >= executionQuota) throw new TimeQuotaExceededException( diff --git a/src/java/org/apache/cassandra/io/sstable/CQLSSTableWriter.java b/src/java/org/apache/cassandra/io/sstable/CQLSSTableWriter.java index 0ac189c9e7..fa8a60fa9b 100644 --- a/src/java/org/apache/cassandra/io/sstable/CQLSSTableWriter.java +++ b/src/java/org/apache/cassandra/io/sstable/CQLSSTableWriter.java @@ -54,6 +54,8 @@ import org.apache.cassandra.service.ClientState; import org.apache.cassandra.transport.ProtocolVersion; import org.apache.cassandra.utils.ByteBufferUtil; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; + /** * Utility to write SSTables. *

@@ -239,7 +241,7 @@ public class CQLSSTableWriter implements Closeable List keys = insert.buildPartitionKeyNames(options); SortedSet> clusterings = insert.createClustering(options); - long now = System.currentTimeMillis(); + long now = currentTimeMillis(); // Note that we asks indexes to not validate values (the last 'false' arg below) because that triggers a 'Keyspace.open' // and that forces a lot of initialization that we don't want. UpdateParameters params = new UpdateParameters(insert.metadata, diff --git a/src/java/org/apache/cassandra/io/sstable/format/SSTableReaderBuilder.java b/src/java/org/apache/cassandra/io/sstable/format/SSTableReaderBuilder.java index 8fe1deff9e..e8266f8eda 100644 --- a/src/java/org/apache/cassandra/io/sstable/format/SSTableReaderBuilder.java +++ b/src/java/org/apache/cassandra/io/sstable/format/SSTableReaderBuilder.java @@ -47,6 +47,10 @@ import java.nio.file.Paths; import java.util.Set; import java.util.concurrent.TimeUnit; +import static org.apache.cassandra.io.sstable.format.SSTableReader.OpenReason.NORMAL; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + public abstract class SSTableReaderBuilder { private static final Logger logger = LoggerFactory.getLogger(SSTableReaderBuilder.class); @@ -270,7 +274,7 @@ public abstract class SSTableReaderBuilder StatsMetadata statsMetadata, SerializationHeader header) { - super(descriptor, metadataRef, System.currentTimeMillis(), components, statsMetadata, SSTableReader.OpenReason.NORMAL, header); + super(descriptor, metadataRef, currentTimeMillis(), components, statsMetadata, NORMAL, header); } @Override @@ -338,7 +342,7 @@ public abstract class SSTableReaderBuilder StatsMetadata statsMetadata, SerializationHeader header) { - super(descriptor, metadataRef, System.currentTimeMillis(), components, statsMetadata, SSTableReader.OpenReason.NORMAL, header); + super(descriptor, metadataRef, currentTimeMillis(), components, statsMetadata, NORMAL, header); this.validationMetadata = validationMetadata; this.isOffline = isOffline; } @@ -353,9 +357,9 @@ public abstract class SSTableReaderBuilder try { // load index and filter - long start = System.nanoTime(); + long start = nanoTime(); load(validationMetadata, isOffline, components, DatabaseDescriptor.getDiskOptimizationStrategy(), statsMetadata); - logger.trace("INDEX LOAD TIME for {}: {} ms.", descriptor, TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start)); + logger.trace("INDEX LOAD TIME for {}: {} ms.", descriptor, TimeUnit.NANOSECONDS.toMillis(nanoTime() - start)); } catch (IOException t) { diff --git a/src/java/org/apache/cassandra/io/sstable/format/big/BigTableWriter.java b/src/java/org/apache/cassandra/io/sstable/format/big/BigTableWriter.java index 4607d99590..281a11d704 100644 --- a/src/java/org/apache/cassandra/io/sstable/format/big/BigTableWriter.java +++ b/src/java/org/apache/cassandra/io/sstable/format/big/BigTableWriter.java @@ -50,6 +50,8 @@ import org.apache.cassandra.schema.TableMetadataRef; import org.apache.cassandra.utils.*; import org.apache.cassandra.utils.concurrent.Transactional; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; + public class BigTableWriter extends SSTableWriter { private static final Logger logger = LoggerFactory.getLogger(BigTableWriter.class); @@ -384,7 +386,7 @@ public class BigTableWriter extends SSTableWriter private SSTableReader openFinal(SSTableReader.OpenReason openReason) { if (maxDataAge < 0) - maxDataAge = System.currentTimeMillis(); + maxDataAge = currentTimeMillis(); StatsMetadata stats = statsMetadata(); // finalize in-memory state for the reader diff --git a/src/java/org/apache/cassandra/locator/TokenMetadata.java b/src/java/org/apache/cassandra/locator/TokenMetadata.java index 390413aecd..f811a4fb29 100644 --- a/src/java/org/apache/cassandra/locator/TokenMetadata.java +++ b/src/java/org/apache/cassandra/locator/TokenMetadata.java @@ -48,6 +48,7 @@ import org.apache.cassandra.utils.Pair; import org.apache.cassandra.utils.SortedBiMultiValMap; import static org.apache.cassandra.config.CassandraRelevantProperties.LINE_SEPARATOR; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; public class TokenMetadata { @@ -855,7 +856,7 @@ public class TokenMetadata public void calculatePendingRanges(AbstractReplicationStrategy strategy, String keyspaceName) { // avoid race between both branches - do not use a lock here as this will block any other unrelated operations! - long startedAt = System.currentTimeMillis(); + long startedAt = currentTimeMillis(); synchronized (pendingRanges) { TokenMetadataDiagnostics.pendingRangeCalculationStarted(this, keyspaceName); @@ -899,7 +900,7 @@ public class TokenMetadata if (logger.isDebugEnabled()) logger.debug("Starting pending range calculation for {}", keyspaceName); - long took = System.currentTimeMillis() - startedAt; + long took = currentTimeMillis() - startedAt; if (logger.isDebugEnabled()) logger.debug("Pending range calculation for {} completed (took: {}ms)", keyspaceName, took); diff --git a/src/java/org/apache/cassandra/metrics/TableMetrics.java b/src/java/org/apache/cassandra/metrics/TableMetrics.java index 6b7193c6c7..426f34dd12 100644 --- a/src/java/org/apache/cassandra/metrics/TableMetrics.java +++ b/src/java/org/apache/cassandra/metrics/TableMetrics.java @@ -18,6 +18,7 @@ package org.apache.cassandra.metrics; import static org.apache.cassandra.metrics.CassandraMetricsRegistry.Metrics; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import java.nio.ByteBuffer; import java.util.*; @@ -1291,12 +1292,12 @@ public class TableMetrics private Context(Timer [] all) { this.all = all; - start = System.nanoTime(); + start = nanoTime(); } public void close() { - long duration = System.nanoTime() - start; + long duration = nanoTime() - start; for (Timer t : all) t.update(duration, TimeUnit.NANOSECONDS); } diff --git a/src/java/org/apache/cassandra/net/AsyncPromise.java b/src/java/org/apache/cassandra/net/AsyncPromise.java index 36bc304a6b..d8bb24f783 100644 --- a/src/java/org/apache/cassandra/net/AsyncPromise.java +++ b/src/java/org/apache/cassandra/net/AsyncPromise.java @@ -36,6 +36,7 @@ import io.netty.util.internal.ThrowableUtil; import org.apache.cassandra.utils.concurrent.WaitQueue; import static java.util.concurrent.atomic.AtomicReferenceFieldUpdater.*; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; /** * Netty's DefaultPromise uses a mutex to coordinate notifiers AND waiters between the eventLoop and the other threads. @@ -406,7 +407,7 @@ public class AsyncPromise implements Promise public boolean await(long timeout, TimeUnit unit) throws InterruptedException { return await(unit.toNanos(timeout), - (signal, nanos) -> signal.awaitUntil(nanos + System.nanoTime())); + (signal, nanos) -> signal.awaitUntil(nanos + nanoTime())); } public boolean await(long timeoutMillis) throws InterruptedException @@ -417,7 +418,7 @@ public class AsyncPromise implements Promise public boolean awaitUninterruptibly(long timeout, TimeUnit unit) { return await(unit.toNanos(timeout), - (signal, nanos) -> signal.awaitUntilUninterruptibly(nanos + System.nanoTime())); + (signal, nanos) -> signal.awaitUntilUninterruptibly(nanos + nanoTime())); } public boolean awaitUninterruptibly(long timeoutMillis) diff --git a/src/java/org/apache/cassandra/net/MessagingService.java b/src/java/org/apache/cassandra/net/MessagingService.java index 4d712e86d5..747d740d4b 100644 --- a/src/java/org/apache/cassandra/net/MessagingService.java +++ b/src/java/org/apache/cassandra/net/MessagingService.java @@ -44,6 +44,7 @@ import org.apache.cassandra.utils.FBUtilities; import static java.util.Collections.synchronizedList; import static java.util.concurrent.TimeUnit.MINUTES; import static org.apache.cassandra.concurrent.Stage.MUTATION; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.apache.cassandra.utils.Throwables.maybeFail; /** @@ -449,7 +450,7 @@ public final class MessagingService extends MessagingServiceMBeanImpl for (OutboundConnections pool : channelManagers.values()) closing.add(pool.close(true)); - long deadline = System.nanoTime() + units.toNanos(timeout); + long deadline = nanoTime() + units.toNanos(timeout); maybeFail(() -> new FutureCombiner(closing).get(timeout, units), () -> { List inboundExecutors = new ArrayList<>(); @@ -473,7 +474,7 @@ public final class MessagingService extends MessagingServiceMBeanImpl for (OutboundConnections pool : channelManagers.values()) closing.add(pool.close(false)); - long deadline = System.nanoTime() + units.toNanos(timeout); + long deadline = nanoTime() + units.toNanos(timeout); maybeFail(() -> new FutureCombiner(closing).get(timeout, units), () -> { if (shutdownExecutors) diff --git a/src/java/org/apache/cassandra/net/RequestCallbacks.java b/src/java/org/apache/cassandra/net/RequestCallbacks.java index c102ee1a42..9adec9b0c0 100644 --- a/src/java/org/apache/cassandra/net/RequestCallbacks.java +++ b/src/java/org/apache/cassandra/net/RequestCallbacks.java @@ -48,6 +48,7 @@ import static java.lang.String.format; import static java.util.concurrent.TimeUnit.MILLISECONDS; import static java.util.concurrent.TimeUnit.NANOSECONDS; import static org.apache.cassandra.concurrent.Stage.INTERNAL_RESPONSE; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.apache.cassandra.utils.MonotonicClock.preciseTime; /** @@ -199,7 +200,7 @@ public class RequestCallbacks implements OutboundMessageCallbacks { if (!executor.isTerminated()) { - long wait = deadlineNanos - System.nanoTime(); + long wait = deadlineNanos - nanoTime(); if (wait <= 0 || !executor.awaitTermination(wait, NANOSECONDS)) throw new TimeoutException(); } diff --git a/src/java/org/apache/cassandra/net/StartupClusterConnectivityChecker.java b/src/java/org/apache/cassandra/net/StartupClusterConnectivityChecker.java index b901338006..073db339f2 100644 --- a/src/java/org/apache/cassandra/net/StartupClusterConnectivityChecker.java +++ b/src/java/org/apache/cassandra/net/StartupClusterConnectivityChecker.java @@ -47,6 +47,7 @@ import org.apache.cassandra.utils.FBUtilities; import static org.apache.cassandra.net.Verb.PING_REQ; import static org.apache.cassandra.net.ConnectionType.LARGE_MESSAGES; import static org.apache.cassandra.net.ConnectionType.SMALL_MESSAGES; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; public class StartupClusterConnectivityChecker { @@ -125,7 +126,7 @@ public class StartupClusterConnectivityChecker new CountDownLatch(Math.max(datacenterToPeers.get(datacenter).size() - 1, 0))); } - long startNanos = System.nanoTime(); + long startNanos = nanoTime(); // set up a listener to react to new nodes becoming alive (in gossip), and account for all the nodes that are already alive Set alivePeers = Collections.newSetFromMap(new ConcurrentHashMap<>()); @@ -150,7 +151,7 @@ public class StartupClusterConnectivityChecker boolean succeeded = true; for (CountDownLatch countDownLatch : dcToRemainingPeers.values()) { - long remainingNanos = Math.max(1, timeoutNanos - (System.nanoTime() - startNanos)); + long remainingNanos = Math.max(1, timeoutNanos - (nanoTime() - startNanos)); //noinspection UnstableApiUsage succeeded &= Uninterruptibles.awaitUninterruptibly(countDownLatch, remainingNanos, TimeUnit.NANOSECONDS); } @@ -164,12 +165,12 @@ public class StartupClusterConnectivityChecker if (succeeded) { logger.info("Ensured sufficient healthy connections with {} after {} milliseconds", - numDown.keySet(), TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startNanos)); + numDown.keySet(), TimeUnit.NANOSECONDS.toMillis(nanoTime() - startNanos)); } else { logger.warn("Timed out after {} milliseconds, was waiting for remaining peers to connect: {}", - TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startNanos), numDown); + TimeUnit.NANOSECONDS.toMillis(nanoTime() - startNanos), numDown); } return succeeded; diff --git a/src/java/org/apache/cassandra/repair/RepairJob.java b/src/java/org/apache/cassandra/repair/RepairJob.java index fb66be7738..9661064447 100644 --- a/src/java/org/apache/cassandra/repair/RepairJob.java +++ b/src/java/org/apache/cassandra/repair/RepairJob.java @@ -46,6 +46,8 @@ import org.apache.cassandra.utils.FBUtilities; import org.apache.cassandra.utils.MerkleTrees; import org.apache.cassandra.utils.Pair; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; + /** * RepairJob runs repair on given ColumnFamily. */ @@ -207,7 +209,7 @@ public class RepairJob extends AbstractFuture implements Runnable boolean pullRepair, PreviewKind previewKind) { - long startedAt = System.currentTimeMillis(); + long startedAt = currentTimeMillis(); List syncTasks = new ArrayList<>(); // We need to difference all trees one against another for (int i = 0; i < trees.size() - 1; ++i) @@ -262,7 +264,7 @@ public class RepairJob extends AbstractFuture implements Runnable } trees.get(trees.size() - 1).trees.release(); logger.info("Created {} sync tasks based on {} merkle tree responses for {} (took: {}ms)", - syncTasks.size(), trees.size(), desc.parentSessionId, System.currentTimeMillis() - startedAt); + syncTasks.size(), trees.size(), desc.parentSessionId, currentTimeMillis() - startedAt); return syncTasks; } @@ -302,7 +304,7 @@ public class RepairJob extends AbstractFuture implements Runnable boolean isIncremental, PreviewKind previewKind) { - long startedAt = System.currentTimeMillis(); + long startedAt = currentTimeMillis(); List syncTasks = new ArrayList<>(); // We need to difference all trees one against another DifferenceHolder diffHolder = new DifferenceHolder(trees); @@ -353,7 +355,7 @@ public class RepairJob extends AbstractFuture implements Runnable } } logger.info("Created {} optimised sync tasks based on {} merkle tree responses for {} (took: {}ms)", - syncTasks.size(), trees.size(), desc.parentSessionId, System.currentTimeMillis() - startedAt); + syncTasks.size(), trees.size(), desc.parentSessionId, currentTimeMillis() - startedAt); logger.trace("Optimised sync tasks for {}: {}", desc.parentSessionId, syncTasks); return syncTasks; } diff --git a/src/java/org/apache/cassandra/repair/RepairRunnable.java b/src/java/org/apache/cassandra/repair/RepairRunnable.java index 4f76a8d6b1..f536da67af 100644 --- a/src/java/org/apache/cassandra/repair/RepairRunnable.java +++ b/src/java/org/apache/cassandra/repair/RepairRunnable.java @@ -96,6 +96,10 @@ import org.apache.cassandra.utils.progress.ProgressEventNotifier; import org.apache.cassandra.utils.progress.ProgressEventType; import org.apache.cassandra.utils.progress.ProgressListener; +import static org.apache.cassandra.service.QueryState.forInternalCalls; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + public class RepairRunnable implements Runnable, ProgressEventNotifier { private static final Logger logger = LoggerFactory.getLogger(RepairRunnable.class); @@ -109,7 +113,7 @@ public class RepairRunnable implements Runnable, ProgressEventNotifier private final AtomicInteger progressCounter = new AtomicInteger(); private final int totalProgress; - private final long creationTimeMillis = System.currentTimeMillis(); + private final long creationTimeMillis = currentTimeMillis(); private final UUID parentSession = UUIDGen.getTimeUUID(); private final List listeners = new ArrayList<>(); @@ -217,7 +221,7 @@ public class RepairRunnable implements Runnable, ProgressEventNotifier private void complete(String msg) { - long durationMillis = System.currentTimeMillis() - creationTimeMillis; + long durationMillis = currentTimeMillis() - creationTimeMillis; if (msg == null) { String duration = DurationFormatUtils.formatDurationWords(durationMillis, true, true); @@ -804,7 +808,7 @@ public class RepairRunnable implements Runnable, ProgressEventNotifier int si = 0; UUID uuid; - long tlast = System.currentTimeMillis(), tcur; + long tlast = currentTimeMillis(), tcur; TraceState.Status status; long minWaitMillis = 125; @@ -825,11 +829,11 @@ public class RepairRunnable implements Runnable, ProgressEventNotifier shouldDouble = false; } ByteBuffer tminBytes = ByteBufferUtil.bytes(UUIDGen.minTimeUUID(tlast - 1000)); - ByteBuffer tmaxBytes = ByteBufferUtil.bytes(UUIDGen.maxTimeUUID(tcur = System.currentTimeMillis())); + ByteBuffer tmaxBytes = ByteBufferUtil.bytes(UUIDGen.maxTimeUUID(tcur = currentTimeMillis())); QueryOptions options = QueryOptions.forInternalCalls(ConsistencyLevel.ONE, Lists.newArrayList(sessionIdBytes, tminBytes, tmaxBytes)); - ResultMessage.Rows rows = statement.execute(QueryState.forInternalCalls(), options, System.nanoTime()); + ResultMessage.Rows rows = statement.execute(forInternalCalls(), options, nanoTime()); UntypedResultSet result = UntypedResultSet.create(rows.result); for (UntypedResultSet.Row r : result) diff --git a/src/java/org/apache/cassandra/repair/SyncTask.java b/src/java/org/apache/cassandra/repair/SyncTask.java index a63f037162..5b23397387 100644 --- a/src/java/org/apache/cassandra/repair/SyncTask.java +++ b/src/java/org/apache/cassandra/repair/SyncTask.java @@ -35,6 +35,8 @@ import org.apache.cassandra.locator.InetAddressAndPort; import org.apache.cassandra.streaming.PreviewKind; import org.apache.cassandra.tracing.Tracing; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; + public abstract class SyncTask extends AbstractFuture implements Runnable { private static Logger logger = LoggerFactory.getLogger(SyncTask.class); @@ -70,7 +72,7 @@ public abstract class SyncTask extends AbstractFuture implements Runna */ public final void run() { - startTime = System.currentTimeMillis(); + startTime = currentTimeMillis(); // choose a repair method based on the significance of the difference @@ -97,6 +99,6 @@ public abstract class SyncTask extends AbstractFuture implements Runna protected void finished() { if (startTime != Long.MIN_VALUE) - Keyspace.open(desc.keyspace).getColumnFamilyStore(desc.columnFamily).metric.repairSyncTime.update(System.currentTimeMillis() - startTime, TimeUnit.MILLISECONDS); + Keyspace.open(desc.keyspace).getColumnFamilyStore(desc.columnFamily).metric.repairSyncTime.update(currentTimeMillis() - startTime, TimeUnit.MILLISECONDS); } } diff --git a/src/java/org/apache/cassandra/repair/ValidationManager.java b/src/java/org/apache/cassandra/repair/ValidationManager.java index 1b6ef561d8..7077dd3626 100644 --- a/src/java/org/apache/cassandra/repair/ValidationManager.java +++ b/src/java/org/apache/cassandra/repair/ValidationManager.java @@ -39,6 +39,8 @@ import org.apache.cassandra.utils.FBUtilities; import org.apache.cassandra.utils.MerkleTree; import org.apache.cassandra.utils.MerkleTrees; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + public class ValidationManager { private static final Logger logger = LoggerFactory.getLogger(ValidationManager.class); @@ -107,7 +109,7 @@ public class ValidationManager // Create Merkle trees suitable to hold estimated partitions for the given ranges. // We blindly assume that a partition is evenly distributed on all sstables for now. - long start = System.nanoTime(); + long start = nanoTime(); long partitionCount = 0; long estimatedTotalBytes = 0; try (ValidationPartitionIterator vi = getValidationIterator(cfs.getRepairManager(), validator)) @@ -140,7 +142,7 @@ public class ValidationManager } if (logger.isDebugEnabled()) { - long duration = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start); + long duration = TimeUnit.NANOSECONDS.toMillis(nanoTime() - start); logger.debug("Validation of {} partitions (~{}) finished in {} msec, for {}", partitionCount, FBUtilities.prettyPrintMemory(estimatedTotalBytes), diff --git a/src/java/org/apache/cassandra/repair/consistent/CoordinatorSession.java b/src/java/org/apache/cassandra/repair/consistent/CoordinatorSession.java index 0c2c3b6471..83d15b8408 100644 --- a/src/java/org/apache/cassandra/repair/consistent/CoordinatorSession.java +++ b/src/java/org/apache/cassandra/repair/consistent/CoordinatorSession.java @@ -53,6 +53,8 @@ import org.apache.cassandra.repair.messages.PrepareConsistentRequest; import org.apache.cassandra.repair.messages.RepairMessage; import org.apache.cassandra.service.ActiveRepairService; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; + /** * Coordinator side logic and state of a consistent repair session. Like {@link ActiveRepairService.ParentRepairSession}, * there is only one {@code CoordinatorSession} per user repair command, regardless of the number of tables and token @@ -290,7 +292,7 @@ public class CoordinatorSession extends ConsistentSession { logger.info("Beginning coordination of incremental repair session {}", sessionID); - sessionStart = System.currentTimeMillis(); + sessionStart = currentTimeMillis(); ListenableFuture prepareResult = prepare(); // run repair sessions normally @@ -300,7 +302,7 @@ public class CoordinatorSession extends ConsistentSession { if (success) { - repairStart = System.currentTimeMillis(); + repairStart = currentTimeMillis(); if (logger.isDebugEnabled()) { logger.debug("Incremental repair {} prepare phase completed in {}", sessionID, formatDuration(sessionStart, repairStart)); @@ -323,7 +325,7 @@ public class CoordinatorSession extends ConsistentSession { if (results == null || results.isEmpty() || Iterables.any(results, r -> r == null)) { - finalizeStart = System.currentTimeMillis(); + finalizeStart = currentTimeMillis(); if (logger.isDebugEnabled()) { logger.debug("Incremental repair {} validation/stream phase completed in {}", sessionID, formatDuration(repairStart, finalizeStart)); @@ -352,12 +354,12 @@ public class CoordinatorSession extends ConsistentSession { if (logger.isDebugEnabled()) { - logger.debug("Incremental repair {} finalization phase completed in {}", sessionID, formatDuration(finalizeStart, System.currentTimeMillis())); + logger.debug("Incremental repair {} finalization phase completed in {}", sessionID, formatDuration(finalizeStart, currentTimeMillis())); } finalizeCommit(); if (logger.isDebugEnabled()) { - logger.debug("Incremental repair {} phase completed in {}", sessionID, formatDuration(sessionStart, System.currentTimeMillis())); + logger.debug("Incremental repair {} phase completed in {}", sessionID, formatDuration(sessionStart, currentTimeMillis())); } } else @@ -379,7 +381,7 @@ public class CoordinatorSession extends ConsistentSession { if (logger.isDebugEnabled()) { - logger.debug("Incremental repair {} phase failed in {}", sessionID, formatDuration(sessionStart, System.currentTimeMillis())); + logger.debug("Incremental repair {} phase failed in {}", sessionID, formatDuration(sessionStart, currentTimeMillis())); } hasFailure.set(true); fail(); diff --git a/src/java/org/apache/cassandra/schema/MigrationCoordinator.java b/src/java/org/apache/cassandra/schema/MigrationCoordinator.java index 824b83f30a..9f12fe0c16 100644 --- a/src/java/org/apache/cassandra/schema/MigrationCoordinator.java +++ b/src/java/org/apache/cassandra/schema/MigrationCoordinator.java @@ -61,6 +61,8 @@ import org.apache.cassandra.net.Verb; import org.apache.cassandra.utils.FBUtilities; import org.apache.cassandra.utils.concurrent.WaitQueue; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + public class MigrationCoordinator { private static final Logger logger = LoggerFactory.getLogger(MigrationCoordinator.class); @@ -581,7 +583,7 @@ public class MigrationCoordinator signal = WaitQueue.all(signals); } - return signal.awaitUntil(System.nanoTime() + TimeUnit.MILLISECONDS.toNanos(waitMillis)); + return signal.awaitUntil(nanoTime() + TimeUnit.MILLISECONDS.toNanos(waitMillis)); } catch (InterruptedException e) { diff --git a/src/java/org/apache/cassandra/serializers/TimestampSerializer.java b/src/java/org/apache/cassandra/serializers/TimestampSerializer.java index ab048d0e62..80091b904c 100644 --- a/src/java/org/apache/cassandra/serializers/TimestampSerializer.java +++ b/src/java/org/apache/cassandra/serializers/TimestampSerializer.java @@ -35,6 +35,8 @@ import java.util.List; import java.util.TimeZone; import java.util.regex.Pattern; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; + public class TimestampSerializer extends TypeSerializer { @@ -139,7 +141,7 @@ public class TimestampSerializer extends TypeSerializer public static long dateStringToTimestamp(String source) throws MarshalException { if (source.equalsIgnoreCase("now")) - return System.currentTimeMillis(); + return currentTimeMillis(); // Milliseconds since epoch? if (timestampPattern.matcher(source).matches()) diff --git a/src/java/org/apache/cassandra/service/AbstractWriteResponseHandler.java b/src/java/org/apache/cassandra/service/AbstractWriteResponseHandler.java index 4f384a40a2..cd43338470 100644 --- a/src/java/org/apache/cassandra/service/AbstractWriteResponseHandler.java +++ b/src/java/org/apache/cassandra/service/AbstractWriteResponseHandler.java @@ -45,6 +45,7 @@ import org.apache.cassandra.schema.Schema; import org.apache.cassandra.utils.concurrent.SimpleCondition; import static java.util.concurrent.TimeUnit.NANOSECONDS; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; public abstract class AbstractWriteResponseHandler implements RequestCallback @@ -130,7 +131,7 @@ public abstract class AbstractWriteResponseHandler implements RequestCallback long requestTimeout = writeType == WriteType.COUNTER ? DatabaseDescriptor.getCounterWriteRpcTimeout(NANOSECONDS) : DatabaseDescriptor.getWriteRpcTimeout(NANOSECONDS); - return requestTimeout - (System.nanoTime() - queryStartNanoTime); + return requestTimeout - (nanoTime() - queryStartNanoTime); } /** @@ -287,7 +288,7 @@ public abstract class AbstractWriteResponseHandler implements RequestCallback } else { - replicaPlan.keyspace().metric.idealCLWriteLatency.addNano(System.nanoTime() - queryStartNanoTime); + replicaPlan.keyspace().metric.idealCLWriteLatency.addNano(nanoTime() - queryStartNanoTime); } } } diff --git a/src/java/org/apache/cassandra/service/ActiveRepairService.java b/src/java/org/apache/cassandra/service/ActiveRepairService.java index cc470fd381..e172ed3eb9 100644 --- a/src/java/org/apache/cassandra/service/ActiveRepairService.java +++ b/src/java/org/apache/cassandra/service/ActiveRepairService.java @@ -96,6 +96,7 @@ import org.apache.cassandra.utils.UUIDGen; import static com.google.common.collect.Iterables.concat; import static com.google.common.collect.Iterables.transform; import static org.apache.cassandra.net.Verb.PREPARE_MSG; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; /** * ActiveRepairService is the starting point for manual "active" repairs. @@ -511,7 +512,7 @@ public class ActiveRepairService implements IEndpointStateChangeSubscriber, IFai // end up skipping replicas if (options.isIncremental() && options.isGlobal() && ! force) { - return System.currentTimeMillis(); + return currentTimeMillis(); } else { diff --git a/src/java/org/apache/cassandra/service/ClientState.java b/src/java/org/apache/cassandra/service/ClientState.java index 0afff9c557..24099c35ae 100644 --- a/src/java/org/apache/cassandra/service/ClientState.java +++ b/src/java/org/apache/cassandra/service/ClientState.java @@ -50,6 +50,8 @@ import org.apache.cassandra.schema.SchemaKeyspace; import org.apache.cassandra.utils.FBUtilities; import org.apache.cassandra.utils.JVMStabilityInspector; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; + /** * State related to a client connection. */ @@ -198,7 +200,7 @@ public class ClientState { while (true) { - long current = System.currentTimeMillis() * 1000; + long current = currentTimeMillis() * 1000; long last = lastTimestampMicros.get(); long tstamp = last >= current ? last + 1 : current; if (lastTimestampMicros.compareAndSet(last, tstamp)) @@ -252,7 +254,7 @@ public class ClientState { while (true) { - long current = Math.max(System.currentTimeMillis() * 1000, minTimestampToUse); + long current = Math.max(currentTimeMillis() * 1000, minTimestampToUse); long last = lastTimestampMicros.get(); long tstamp = last >= current ? last + 1 : current; // Note that if we ended up picking minTimestampMicrosToUse (it was "in the future"), we don't diff --git a/src/java/org/apache/cassandra/service/GCInspector.java b/src/java/org/apache/cassandra/service/GCInspector.java index 02fd72016c..55f1a2ef76 100644 --- a/src/java/org/apache/cassandra/service/GCInspector.java +++ b/src/java/org/apache/cassandra/service/GCInspector.java @@ -50,6 +50,8 @@ import org.apache.cassandra.db.lifecycle.LifecycleTransaction; import org.apache.cassandra.utils.MBeanWrapper; import org.apache.cassandra.utils.StatusLogger; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + public class GCInspector implements NotificationListener, GCInspectorMXBean { public static final String MBEAN_NAME = "org.apache.cassandra.service:type=GCInspector"; @@ -113,7 +115,7 @@ public class GCInspector implements NotificationListener, GCInspectorMXBean State() { count = maxRealTimeElapsed = sumSquaresRealTimeElapsed = totalRealTimeElapsed = totalBytesReclaimed = 0; - startNanos = System.nanoTime(); + startNanos = nanoTime(); } } @@ -318,7 +320,7 @@ public class GCInspector implements NotificationListener, GCInspectorMXBean { State state = getTotalSinceLastCheck(); double[] r = new double[7]; - r[0] = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - state.startNanos); + r[0] = TimeUnit.NANOSECONDS.toMillis(nanoTime() - state.startNanos); r[1] = state.maxRealTimeElapsed; r[2] = state.totalRealTimeElapsed; r[3] = state.sumSquaresRealTimeElapsed; diff --git a/src/java/org/apache/cassandra/service/PendingRangeCalculatorService.java b/src/java/org/apache/cassandra/service/PendingRangeCalculatorService.java index 1c6b18347e..549dc3893e 100644 --- a/src/java/org/apache/cassandra/service/PendingRangeCalculatorService.java +++ b/src/java/org/apache/cassandra/service/PendingRangeCalculatorService.java @@ -34,6 +34,8 @@ import java.util.concurrent.atomic.AtomicInteger; import com.google.common.annotations.VisibleForTesting; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; + public class PendingRangeCalculatorService { public static final PendingRangeCalculatorService instance = new PendingRangeCalculatorService(); @@ -71,12 +73,12 @@ public class PendingRangeCalculatorService try { PendingRangeCalculatorServiceDiagnostics.taskStarted(instance, updateJobs); - long start = System.currentTimeMillis(); + long start = currentTimeMillis(); List keyspaces = Schema.instance.getNonLocalStrategyKeyspaces(); for (String keyspaceName : keyspaces) calculatePendingRanges(Keyspace.open(keyspaceName).getReplicationStrategy(), keyspaceName); if (logger.isTraceEnabled()) - logger.trace("Finished PendingRangeTask for {} keyspaces in {}ms", keyspaces.size(), System.currentTimeMillis() - start); + logger.trace("Finished PendingRangeTask for {} keyspaces in {}ms", keyspaces.size(), currentTimeMillis() - start); PendingRangeCalculatorServiceDiagnostics.taskFinished(instance, updateJobs); } finally diff --git a/src/java/org/apache/cassandra/service/StartupChecks.java b/src/java/org/apache/cassandra/service/StartupChecks.java index dadb0c5b8d..4f9b82f9d3 100644 --- a/src/java/org/apache/cassandra/service/StartupChecks.java +++ b/src/java/org/apache/cassandra/service/StartupChecks.java @@ -60,6 +60,7 @@ import static java.lang.String.format; import static org.apache.cassandra.config.CassandraRelevantProperties.COM_SUN_MANAGEMENT_JMXREMOTE_PORT; import static org.apache.cassandra.config.CassandraRelevantProperties.JAVA_VERSION; import static org.apache.cassandra.config.CassandraRelevantProperties.JAVA_VM_NAME; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; /** * Verifies that the system and environment is in a fit state to be started. @@ -169,7 +170,7 @@ public class StartupChecks private static final long EARLIEST_LAUNCH_DATE = 1215820800000L; public void execute() throws StartupException { - long now = System.currentTimeMillis(); + long now = currentTimeMillis(); if (now < EARLIEST_LAUNCH_DATE) throw new StartupException(StartupException.ERR_WRONG_MACHINE_STATE, String.format("current machine time is %s, but that is seemingly incorrect. exiting now.", diff --git a/src/java/org/apache/cassandra/service/StorageProxy.java b/src/java/org/apache/cassandra/service/StorageProxy.java index 3ad1050ba2..0f29875a5e 100644 --- a/src/java/org/apache/cassandra/service/StorageProxy.java +++ b/src/java/org/apache/cassandra/service/StorageProxy.java @@ -147,6 +147,8 @@ import static org.apache.cassandra.net.Verb.TRUNCATE_REQ; import static org.apache.cassandra.service.BatchlogResponseHandler.BatchlogCleanup; import static org.apache.cassandra.service.paxos.PrepareVerbHandler.doPrepare; import static org.apache.cassandra.service.paxos.ProposeVerbHandler.doPropose; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; public class StorageProxy implements StorageProxyMBean { @@ -288,7 +290,7 @@ public class StorageProxy implements StorageProxyMBean long queryStartNanoTime) throws UnavailableException, IsBootstrappingException, RequestFailureException, RequestTimeoutException, InvalidRequestException, CasWriteUnknownResultException { - final long startTimeForMetrics = System.nanoTime(); + final long startTimeForMetrics = nanoTime(); try { TableMetadata metadata = Schema.instance.validateTable(keyspaceName, cfName); @@ -380,7 +382,7 @@ public class StorageProxy implements StorageProxyMBean } finally { - final long latency = System.nanoTime() - startTimeForMetrics; + final long latency = nanoTime() - startTimeForMetrics; casWriteMetrics.addNano(latency); writeMetricsMap.get(consistencyForPaxos).addNano(latency); } @@ -448,7 +450,7 @@ public class StorageProxy implements StorageProxyMBean consistencyForCommit.validateForCasCommit(latestRs); long timeoutNanos = DatabaseDescriptor.getCasContentionTimeout(NANOSECONDS); - while (System.nanoTime() - queryStartNanoTime < timeoutNanos) + while (nanoTime() - queryStartNanoTime < timeoutNanos) { // for simplicity, we'll do a single liveness check at the start of each attempt ReplicaPlan.ForPaxosWrite replicaPlan = ReplicaPlans.forPaxos(keyspace, key, consistencyForPaxos); @@ -535,7 +537,7 @@ public class StorageProxy implements StorageProxyMBean PrepareCallback summary = null; int contentions = 0; - while (System.nanoTime() - queryStartNanoTime < timeoutNanos) + while (nanoTime() - queryStartNanoTime < timeoutNanos) { // We want a timestamp that is guaranteed to be unique for that node (so that the ballot is globally unique), but if we've got a prepare rejected // already we also want to make sure we pick a timestamp that has a chance to be promised, i.e. one that is greater that the most recently known @@ -806,7 +808,7 @@ public class StorageProxy implements StorageProxyMBean * * @param mutations the mutations to be applied across the replicas * @param consistencyLevel the consistency level for the operation - * @param queryStartNanoTime the value of System.nanoTime() when the query started to be processed + * @param queryStartNanoTime the value of nanoTime() when the query started to be processed */ public static void mutate(List mutations, ConsistencyLevel consistencyLevel, long queryStartNanoTime) throws UnavailableException, OverloadedException, WriteTimeoutException, WriteFailureException @@ -814,7 +816,7 @@ public class StorageProxy implements StorageProxyMBean Tracing.trace("Determining replicas for mutation"); final String localDataCenter = DatabaseDescriptor.getEndpointSnitch().getLocalDatacenter(); - long startTime = System.nanoTime(); + long startTime = nanoTime(); List> responseHandlers = new ArrayList<>(mutations.size()); WriteType plainWriteType = mutations.size() <= 1 ? WriteType.SIMPLE : WriteType.UNLOGGED_BATCH; @@ -882,7 +884,7 @@ public class StorageProxy implements StorageProxyMBean } finally { - long latency = System.nanoTime() - startTime; + long latency = nanoTime() - startTime; writeMetrics.addNano(latency); writeMetricsMap.get(consistencyLevel).addNano(latency); updateCoordinatorWriteLatencyTableMetric(mutations, latency); @@ -938,7 +940,7 @@ public class StorageProxy implements StorageProxyMBean * @param mutations the mutations to be applied across the replicas * @param writeCommitLog if commitlog should be written * @param baseComplete time from epoch in ms that the local base mutation was(or will be) completed - * @param queryStartNanoTime the value of System.nanoTime() when the query started to be processed + * @param queryStartNanoTime the value of nanoTime() when the query started to be processed */ public static void mutateMV(ByteBuffer dataKey, Collection mutations, boolean writeCommitLog, AtomicLong baseComplete, long queryStartNanoTime) throws UnavailableException, OverloadedException, WriteTimeoutException @@ -946,7 +948,7 @@ public class StorageProxy implements StorageProxyMBean Tracing.trace("Determining replicas for mutation"); final String localDataCenter = DatabaseDescriptor.getEndpointSnitch().getLocalDatacenter(); - long startTime = System.nanoTime(); + long startTime = nanoTime(); try @@ -1041,7 +1043,7 @@ public class StorageProxy implements StorageProxyMBean } finally { - viewWriteMetrics.addNano(System.nanoTime() - startTime); + viewWriteMetrics.addNano(nanoTime() - startTime); } } @@ -1082,7 +1084,7 @@ public class StorageProxy implements StorageProxyMBean * @param mutations the Mutations to be applied across the replicas * @param consistency_level the consistency level for the operation * @param requireQuorumForRemove at least a quorum of nodes will see update before deleting batchlog - * @param queryStartNanoTime the value of System.nanoTime() when the query started to be processed + * @param queryStartNanoTime the value of nanoTime() when the query started to be processed */ public static void mutateAtomically(Collection mutations, ConsistencyLevel consistency_level, @@ -1091,7 +1093,7 @@ public class StorageProxy implements StorageProxyMBean throws UnavailableException, OverloadedException, WriteTimeoutException { Tracing.trace("Determining replicas for atomic batch"); - long startTime = System.nanoTime(); + long startTime = nanoTime(); List wrappers = new ArrayList<>(mutations.size()); @@ -1162,7 +1164,7 @@ public class StorageProxy implements StorageProxyMBean } finally { - long latency = System.nanoTime() - startTime; + long latency = nanoTime() - startTime; writeMetrics.addNano(latency); writeMetricsMap.get(consistency_level).addNano(latency); updateCoordinatorWriteLatencyTableMetric(mutations, latency); @@ -1273,7 +1275,7 @@ public class StorageProxy implements StorageProxyMBean * given the list of write endpoints (either standardWritePerformer for * standard writes or counterWritePerformer for counter writes). * @param callback an optional callback to be run if and when the write is - * @param queryStartNanoTime the value of System.nanoTime() when the query started to be processed + * @param queryStartNanoTime the value of nanoTime() when the query started to be processed */ public static AbstractWriteResponseHandler performWrite(IMutation mutation, ConsistencyLevel consistencyLevel, @@ -1330,7 +1332,7 @@ public class StorageProxy implements StorageProxyMBean ReplicaPlan.ForTokenWrite replicaPlan = ReplicaPlans.forWrite(keyspace, consistencyLevel, liveAndDown, ReplicaPlans.writeAll); AbstractReplicationStrategy replicationStrategy = replicaPlan.replicationStrategy(); AbstractWriteResponseHandler writeHandler = replicationStrategy.getWriteResponseHandler(replicaPlan, () -> { - long delay = Math.max(0, System.currentTimeMillis() - baseComplete.get()); + long delay = Math.max(0, currentTimeMillis() - baseComplete.get()); viewWriteMetrics.viewWriteLatency.update(delay, MILLISECONDS); }, writeType, queryStartNanoTime); BatchlogResponseHandler batchHandler = new ViewWriteMetricsWrapped(writeHandler, batchConsistencyLevel.blockFor(replicationStrategy), cleanup, queryStartNanoTime); @@ -1747,7 +1749,7 @@ public class StorageProxy implements StorageProxyMBean if (group.queries.size() > 1) throw new InvalidRequestException("SERIAL/LOCAL_SERIAL consistency may only be requested for one partition at a time"); - long start = System.nanoTime(); + long start = nanoTime(); SinglePartitionReadCommand command = group.queries.get(0); TableMetadata metadata = command.metadata(); DecoratedKey key = command.partitionKey(); @@ -1824,7 +1826,7 @@ public class StorageProxy implements StorageProxyMBean } finally { - long latency = System.nanoTime() - start; + long latency = nanoTime() - start; readMetrics.addNano(latency); casReadMetrics.addNano(latency); readMetricsMap.get(consistencyLevel).addNano(latency); @@ -1838,7 +1840,7 @@ public class StorageProxy implements StorageProxyMBean private static PartitionIterator readRegular(SinglePartitionReadCommand.Group group, ConsistencyLevel consistencyLevel, long queryStartNanoTime) throws UnavailableException, ReadFailureException, ReadTimeoutException { - long start = System.nanoTime(); + long start = nanoTime(); try { PartitionIterator result = fetchRows(group.queries, consistencyLevel, queryStartNanoTime); @@ -1876,7 +1878,7 @@ public class StorageProxy implements StorageProxyMBean } finally { - long latency = System.nanoTime() - start; + long latency = nanoTime() - start; readMetrics.addNano(latency); readMetricsMap.get(consistencyLevel).addNano(latency); // TODO avoid giving every command the same latency number. Can fix this in CASSADRA-5329 @@ -2480,7 +2482,7 @@ public class StorageProxy implements StorageProxyMBean logger.debug("Discarding hint for endpoint not part of ring: {}", target); } logger.trace("Adding hints for {}", validTargets); - HintsService.instance.write(hostIds, Hint.create(mutation, System.currentTimeMillis())); + HintsService.instance.write(hostIds, Hint.create(mutation, currentTimeMillis())); validTargets.forEach(HintsService.instance.metrics::incrCreatedHints); // Notify the handler only for CL == ANY if (responseHandler != null && responseHandler.replicaPlan.consistencyLevel() == ConsistencyLevel.ANY) diff --git a/src/java/org/apache/cassandra/service/StorageService.java b/src/java/org/apache/cassandra/service/StorageService.java index 0e663c02a9..0299facb2c 100644 --- a/src/java/org/apache/cassandra/service/StorageService.java +++ b/src/java/org/apache/cassandra/service/StorageService.java @@ -134,6 +134,8 @@ import static org.apache.cassandra.index.SecondaryIndexManager.isIndexColumnFami import static org.apache.cassandra.net.NoPayload.noPayload; import static org.apache.cassandra.net.Verb.REPLICATION_DONE_REQ; import static org.apache.cassandra.schema.MigrationManager.evolveSystemKeyspace; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; /** * This abstraction contains the token/identifier of this node @@ -392,7 +394,7 @@ public class StorageService extends NotificationBroadcasterSupport implements IE setGossipTokens(tokens); Gossiper.instance.forceNewerGeneration(); - Gossiper.instance.start((int) (System.currentTimeMillis() / 1000)); + Gossiper.instance.start((int) (currentTimeMillis() / 1000)); gossipActive = true; } } @@ -725,7 +727,7 @@ public class StorageService extends NotificationBroadcasterSupport implements IE initialized = true; gossipActive = true; Gossiper.instance.register(this); - Gossiper.instance.start((int) (System.currentTimeMillis() / 1000)); // needed for node-ring gathering. + Gossiper.instance.start((int) (currentTimeMillis() / 1000)); // needed for node-ring gathering. Gossiper.instance.addLocalApplicationState(ApplicationState.NET_VERSION, valueFactory.networkVersion()); MessagingService.instance().listen(); } @@ -1703,7 +1705,7 @@ public class StorageService extends NotificationBroadcasterSupport implements IE if (existing != null) { long nanoDelay = schemaDelay * 1000000L; - if (Gossiper.instance.getEndpointStateForEndpoint(existing).getUpdateTimestamp() > (System.nanoTime() - nanoDelay)) + if (Gossiper.instance.getEndpointStateForEndpoint(existing).getUpdateTimestamp() > (nanoTime() - nanoDelay)) throw new UnsupportedOperationException("Cannot replace a live node... "); collisions.add(existing); } diff --git a/src/java/org/apache/cassandra/service/TruncateResponseHandler.java b/src/java/org/apache/cassandra/service/TruncateResponseHandler.java index 60e8d0bbe8..f6c15067bb 100644 --- a/src/java/org/apache/cassandra/service/TruncateResponseHandler.java +++ b/src/java/org/apache/cassandra/service/TruncateResponseHandler.java @@ -34,6 +34,8 @@ import org.apache.cassandra.net.Message; import org.apache.cassandra.utils.concurrent.SimpleCondition; import static java.util.concurrent.TimeUnit.NANOSECONDS; +import static org.apache.cassandra.config.DatabaseDescriptor.getTruncateRpcTimeout; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; public class TruncateResponseHandler implements RequestCallback { @@ -51,12 +53,12 @@ public class TruncateResponseHandler implements RequestCallback @@ -71,9 +73,9 @@ public final class AggregationQueryPager implements QueryPager public PartitionIterator fetchPageInternal(int pageSize, ReadExecutionController executionController) { if (limits.isGroupByLimit()) - return new GroupByPartitionIterator(pageSize, executionController, System.nanoTime()); + return new GroupByPartitionIterator(pageSize, executionController, nanoTime()); - return new AggregationPartitionIterator(pageSize, executionController, System.nanoTime()); + return new AggregationPartitionIterator(pageSize, executionController, nanoTime()); } @Override diff --git a/src/java/org/apache/cassandra/service/pager/MultiPartitionPager.java b/src/java/org/apache/cassandra/service/pager/MultiPartitionPager.java index ca16967b6c..7e64e03675 100644 --- a/src/java/org/apache/cassandra/service/pager/MultiPartitionPager.java +++ b/src/java/org/apache/cassandra/service/pager/MultiPartitionPager.java @@ -30,6 +30,8 @@ import org.apache.cassandra.exceptions.RequestValidationException; import org.apache.cassandra.exceptions.RequestExecutionException; import org.apache.cassandra.service.ClientState; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + /** * Pager over a list of SinglePartitionReadQuery. * @@ -158,7 +160,7 @@ public class MultiPartitionPager implements public PartitionIterator fetchPageInternal(int pageSize, ReadExecutionController executionController) throws RequestValidationException, RequestExecutionException { int toQuery = Math.min(remaining, pageSize); - return new PagersIterator(toQuery, null, null, executionController, System.nanoTime()); + return new PagersIterator(toQuery, null, null, executionController, nanoTime()); } private class PagersIterator extends AbstractIterator implements PartitionIterator diff --git a/src/java/org/apache/cassandra/service/paxos/AbstractPaxosCallback.java b/src/java/org/apache/cassandra/service/paxos/AbstractPaxosCallback.java index ab24f50efb..5624df4f2c 100644 --- a/src/java/org/apache/cassandra/service/paxos/AbstractPaxosCallback.java +++ b/src/java/org/apache/cassandra/service/paxos/AbstractPaxosCallback.java @@ -29,6 +29,7 @@ import org.apache.cassandra.exceptions.WriteTimeoutException; import org.apache.cassandra.net.RequestCallback; import static java.util.concurrent.TimeUnit.NANOSECONDS; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; public abstract class AbstractPaxosCallback implements RequestCallback { @@ -54,7 +55,7 @@ public abstract class AbstractPaxosCallback implements RequestCallback { try { - long timeout = DatabaseDescriptor.getWriteRpcTimeout(NANOSECONDS) - (System.nanoTime() - queryStartNanoTime); + long timeout = DatabaseDescriptor.getWriteRpcTimeout(NANOSECONDS) - (nanoTime() - queryStartNanoTime); if (!latch.await(timeout, NANOSECONDS)) throw new WriteTimeoutException(WriteType.CAS, consistency, getResponseCount(), targets); } diff --git a/src/java/org/apache/cassandra/service/paxos/PaxosState.java b/src/java/org/apache/cassandra/service/paxos/PaxosState.java index 6e02435168..391d55f13f 100644 --- a/src/java/org/apache/cassandra/service/paxos/PaxosState.java +++ b/src/java/org/apache/cassandra/service/paxos/PaxosState.java @@ -30,6 +30,8 @@ import org.apache.cassandra.db.*; import org.apache.cassandra.tracing.Tracing; import org.apache.cassandra.utils.UUIDGen; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + public class PaxosState { private static final Striped LOCKS = Striped.lazyWeakLock(DatabaseDescriptor.getConcurrentWriters() * 1024); @@ -55,7 +57,7 @@ public class PaxosState public static PrepareResponse prepare(Commit toPrepare) { - long start = System.nanoTime(); + long start = nanoTime(); try { Lock lock = LOCKS.get(toPrepare.update.partitionKey()); @@ -89,14 +91,14 @@ public class PaxosState } finally { - Keyspace.open(toPrepare.update.metadata().keyspace).getColumnFamilyStore(toPrepare.update.metadata().id).metric.casPrepare.addNano(System.nanoTime() - start); + Keyspace.open(toPrepare.update.metadata().keyspace).getColumnFamilyStore(toPrepare.update.metadata().id).metric.casPrepare.addNano(nanoTime() - start); } } public static Boolean propose(Commit proposal) { - long start = System.nanoTime(); + long start = nanoTime(); try { Lock lock = LOCKS.get(proposal.update.partitionKey()); @@ -124,13 +126,13 @@ public class PaxosState } finally { - Keyspace.open(proposal.update.metadata().keyspace).getColumnFamilyStore(proposal.update.metadata().id).metric.casPropose.addNano(System.nanoTime() - start); + Keyspace.open(proposal.update.metadata().keyspace).getColumnFamilyStore(proposal.update.metadata().id).metric.casPropose.addNano(nanoTime() - start); } } public static void commit(Commit proposal) { - long start = System.nanoTime(); + long start = nanoTime(); try { // There is no guarantee we will see commits in the right order, because messages @@ -155,7 +157,7 @@ public class PaxosState } finally { - Keyspace.open(proposal.update.metadata().keyspace).getColumnFamilyStore(proposal.update.metadata().id).metric.casCommit.addNano(System.nanoTime() - start); + Keyspace.open(proposal.update.metadata().keyspace).getColumnFamilyStore(proposal.update.metadata().id).metric.casCommit.addNano(nanoTime() - start); } } } diff --git a/src/java/org/apache/cassandra/service/reads/DigestResolver.java b/src/java/org/apache/cassandra/service/reads/DigestResolver.java index 475c8c283f..f66edea5ca 100644 --- a/src/java/org/apache/cassandra/service/reads/DigestResolver.java +++ b/src/java/org/apache/cassandra/service/reads/DigestResolver.java @@ -38,6 +38,7 @@ import org.apache.cassandra.service.reads.repair.NoopReadRepair; import org.apache.cassandra.utils.ByteBufferUtil; import static com.google.common.collect.Iterables.any; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; public class DigestResolver, P extends ReplicaPlan.ForRead> extends ResponseResolver { @@ -102,7 +103,7 @@ public class DigestResolver, P extends ReplicaPlan.ForRea public boolean responsesMatch() { - long start = System.nanoTime(); + long start = nanoTime(); // validate digests against each other; return false immediately on mismatch. ByteBuffer digest = null; @@ -126,7 +127,7 @@ public class DigestResolver, P extends ReplicaPlan.ForRea } if (logger.isTraceEnabled()) - logger.trace("responsesMatch: {} ms.", TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start)); + logger.trace("responsesMatch: {} ms.", TimeUnit.NANOSECONDS.toMillis(nanoTime() - start)); return true; } diff --git a/src/java/org/apache/cassandra/service/reads/ReadCallback.java b/src/java/org/apache/cassandra/service/reads/ReadCallback.java index 15f1559d04..4a836776eb 100644 --- a/src/java/org/apache/cassandra/service/reads/ReadCallback.java +++ b/src/java/org/apache/cassandra/service/reads/ReadCallback.java @@ -48,6 +48,7 @@ import org.apache.cassandra.tracing.Tracing; import org.apache.cassandra.utils.concurrent.SimpleCondition; import static java.util.concurrent.TimeUnit.MILLISECONDS; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; public class ReadCallback, P extends ReplicaPlan.ForRead> implements RequestCallback { @@ -91,7 +92,7 @@ public class ReadCallback, P extends ReplicaPlan.ForRead< public boolean await(long timePastStart, TimeUnit unit) { - long time = unit.toNanos(timePastStart) - (System.nanoTime() - queryStartNanoTime); + long time = unit.toNanos(timePastStart) - (nanoTime() - queryStartNanoTime); try { return condition.await(time, TimeUnit.NANOSECONDS); diff --git a/src/java/org/apache/cassandra/service/reads/range/RangeCommandIterator.java b/src/java/org/apache/cassandra/service/reads/range/RangeCommandIterator.java index dd8b01da72..60309bd231 100644 --- a/src/java/org/apache/cassandra/service/reads/range/RangeCommandIterator.java +++ b/src/java/org/apache/cassandra/service/reads/range/RangeCommandIterator.java @@ -52,6 +52,8 @@ import org.apache.cassandra.tracing.Tracing; import org.apache.cassandra.utils.AbstractIterator; import org.apache.cassandra.utils.CloseableIterator; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + class RangeCommandIterator extends AbstractIterator implements PartitionIterator { private static final Logger logger = LoggerFactory.getLogger(RangeCommandIterator.class); @@ -90,7 +92,7 @@ class RangeCommandIterator extends AbstractIterator implements Part this.totalRangeCount = totalRangeCount; this.queryStartNanoTime = queryStartNanoTime; - startTime = System.nanoTime(); + startTime = nanoTime(); enforceStrictLiveness = command.metadata().enforceStrictLiveness(); } @@ -262,7 +264,7 @@ class RangeCommandIterator extends AbstractIterator implements Part } finally { - long latency = System.nanoTime() - startTime; + long latency = nanoTime() - startTime; rangeMetrics.addNano(latency); Keyspace.openAndGetStore(command.metadata()).metric.coordinatorScanLatency.update(latency, TimeUnit.NANOSECONDS); } diff --git a/src/java/org/apache/cassandra/service/reads/repair/BlockingPartitionRepair.java b/src/java/org/apache/cassandra/service/reads/repair/BlockingPartitionRepair.java index edcf14d31c..194ad5baee 100644 --- a/src/java/org/apache/cassandra/service/reads/repair/BlockingPartitionRepair.java +++ b/src/java/org/apache/cassandra/service/reads/repair/BlockingPartitionRepair.java @@ -53,6 +53,7 @@ import org.apache.cassandra.schema.TableId; import org.apache.cassandra.tracing.Tracing; import static org.apache.cassandra.net.Verb.*; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; public class BlockingPartitionRepair extends AbstractFuture implements RequestCallback @@ -146,7 +147,7 @@ public class BlockingPartitionRepair public void sendInitialRepairs() { - mutationsSentTime = System.nanoTime(); + mutationsSentTime = nanoTime(); Replicas.assertFull(pendingRepairs.keySet()); for (Map.Entry entry: pendingRepairs.entrySet()) @@ -177,7 +178,7 @@ public class BlockingPartitionRepair public boolean awaitRepairsUntil(long timeoutAt, TimeUnit timeUnit) { long timeoutAtNanos = timeUnit.toNanos(timeoutAt); - long remaining = timeoutAtNanos - System.nanoTime(); + long remaining = timeoutAtNanos - nanoTime(); try { return latch.await(remaining, TimeUnit.NANOSECONDS); diff --git a/src/java/org/apache/cassandra/streaming/StreamSession.java b/src/java/org/apache/cassandra/streaming/StreamSession.java index 3a32834719..bbbe79d196 100644 --- a/src/java/org/apache/cassandra/streaming/StreamSession.java +++ b/src/java/org/apache/cassandra/streaming/StreamSession.java @@ -52,6 +52,7 @@ import org.apache.cassandra.utils.NoSpamLogger; import static com.google.common.collect.Iterables.all; import static org.apache.cassandra.net.MessagingService.current_version; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; /** * Handles the streaming a one or more streams to and from a specific remote node. @@ -790,14 +791,14 @@ public class StreamSession implements IEndpointStateChangeSubscriber // send back file received message messageSender.sendMessage(new ReceivedMessage(message.header.tableId, message.header.sequenceNumber)); StreamHook.instance.reportIncomingStream(message.header.tableId, message.stream, this, message.header.sequenceNumber); - long receivedStartNanos = System.nanoTime(); + long receivedStartNanos = nanoTime(); try { receivers.get(message.header.tableId).received(message.stream); } finally { - long latencyNanos = System.nanoTime() - receivedStartNanos; + long latencyNanos = nanoTime() - receivedStartNanos; metrics.incomingProcessTime.update(latencyNanos, TimeUnit.NANOSECONDS); long latencyMs = TimeUnit.NANOSECONDS.toMillis(latencyNanos); int timeout = DatabaseDescriptor.getInternodeStreamingTcpUserTimeoutInMS(); diff --git a/src/java/org/apache/cassandra/streaming/async/NettyStreamingMessageSender.java b/src/java/org/apache/cassandra/streaming/async/NettyStreamingMessageSender.java index fba56f58eb..a63db2277c 100644 --- a/src/java/org/apache/cassandra/streaming/async/NettyStreamingMessageSender.java +++ b/src/java/org/apache/cassandra/streaming/async/NettyStreamingMessageSender.java @@ -63,6 +63,8 @@ import org.apache.cassandra.streaming.messages.StreamMessage; import org.apache.cassandra.utils.FBUtilities; import org.apache.cassandra.utils.JVMStabilityInspector; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + /** * Responsible for sending {@link StreamMessage}s to a given peer. We manage an array of netty {@link Channel}s * for sending {@link OutgoingStreamMessage} instances; all other {@link StreamMessage} types are sent via @@ -377,7 +379,7 @@ public class NettyStreamingMessageSender implements StreamingMessageSender boolean acquirePermit(int logInterval) { long logIntervalNanos = TimeUnit.MINUTES.toNanos(logInterval); - long timeOfLastLogging = System.nanoTime(); + long timeOfLastLogging = nanoTime(); while (true) { if (closed) @@ -388,7 +390,7 @@ public class NettyStreamingMessageSender implements StreamingMessageSender return true; // log a helpful message to operators in case they are wondering why a given session might not be making progress. - long now = System.nanoTime(); + long now = nanoTime(); if (now - timeOfLastLogging > logIntervalNanos) { timeOfLastLogging = now; diff --git a/src/java/org/apache/cassandra/streaming/management/StreamEventJMXNotifier.java b/src/java/org/apache/cassandra/streaming/management/StreamEventJMXNotifier.java index 3e12c2ac92..e504dae591 100644 --- a/src/java/org/apache/cassandra/streaming/management/StreamEventJMXNotifier.java +++ b/src/java/org/apache/cassandra/streaming/management/StreamEventJMXNotifier.java @@ -23,6 +23,8 @@ import javax.management.NotificationBroadcasterSupport; import org.apache.cassandra.streaming.*; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; + /** */ public class StreamEventJMXNotifier extends NotificationBroadcasterSupport implements StreamEventHandler @@ -53,14 +55,14 @@ public class StreamEventJMXNotifier extends NotificationBroadcasterSupport imple break; case FILE_PROGRESS: ProgressInfo progress = ((StreamEvent.ProgressEvent) event).progress; - long current = System.currentTimeMillis(); + long current = currentTimeMillis(); if (current - progressLastSent >= PROGRESS_NOTIFICATION_INTERVAL || progress.isCompleted()) { notif = new Notification(StreamEvent.ProgressEvent.class.getCanonicalName(), StreamManagerMBean.OBJECT_NAME, seq.getAndIncrement()); notif.setUserData(ProgressInfoCompositeData.toCompositeData(event.planId, progress)); - progressLastSent = System.currentTimeMillis(); + progressLastSent = currentTimeMillis(); } else { diff --git a/src/java/org/apache/cassandra/tools/BootstrapMonitor.java b/src/java/org/apache/cassandra/tools/BootstrapMonitor.java index 97191927f9..67d2925a36 100644 --- a/src/java/org/apache/cassandra/tools/BootstrapMonitor.java +++ b/src/java/org/apache/cassandra/tools/BootstrapMonitor.java @@ -27,6 +27,8 @@ import org.apache.cassandra.utils.progress.ProgressEvent; import org.apache.cassandra.utils.progress.ProgressEventType; import org.apache.cassandra.utils.progress.jmx.JMXNotificationProgressListener; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; + public class BootstrapMonitor extends JMXNotificationProgressListener { private final SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss,SSS"); @@ -74,7 +76,7 @@ public class BootstrapMonitor extends JMXNotificationProgressListener public void progress(String tag, ProgressEvent event) { ProgressEventType type = event.getType(); - String message = String.format("[%s] %s", format.format(System.currentTimeMillis()), event.getMessage()); + String message = String.format("[%s] %s", format.format(currentTimeMillis()), event.getMessage()); if (type == ProgressEventType.PROGRESS) { message = message + " (progress: " + (int)event.getProgressPercentage() + "%)"; diff --git a/src/java/org/apache/cassandra/tools/BulkLoader.java b/src/java/org/apache/cassandra/tools/BulkLoader.java index c1de1ffa8a..bb29bbe194 100644 --- a/src/java/org/apache/cassandra/tools/BulkLoader.java +++ b/src/java/org/apache/cassandra/tools/BulkLoader.java @@ -43,6 +43,8 @@ import org.apache.cassandra.utils.JVMStabilityInspector; import org.apache.cassandra.utils.NativeSSTableLoaderClient; import org.apache.cassandra.utils.OutputHandler; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + public class BulkLoader { public static void main(String args[]) throws BulkLoadException @@ -131,7 +133,7 @@ public class BulkLoader public ProgressIndicator() { - start = lastTime = System.nanoTime(); + start = lastTime = nanoTime(); } public void onSuccess(StreamState finalState) @@ -157,7 +159,7 @@ public class BulkLoader progressInfo = ((StreamEvent.ProgressEvent) event).progress; } - long time = System.nanoTime(); + long time = nanoTime(); long deltaTime = time - lastTime; StringBuilder sb = new StringBuilder(); @@ -230,7 +232,7 @@ public class BulkLoader private void printSummary(int connectionsPerHost) { - long end = System.nanoTime(); + long end = nanoTime(); long durationMS = ((end - start) / (1000000)); StringBuilder sb = new StringBuilder(); diff --git a/src/java/org/apache/cassandra/tools/JsonTransformer.java b/src/java/org/apache/cassandra/tools/JsonTransformer.java index 341512c27b..ed0830dfa3 100644 --- a/src/java/org/apache/cassandra/tools/JsonTransformer.java +++ b/src/java/org/apache/cassandra/tools/JsonTransformer.java @@ -58,6 +58,8 @@ import org.apache.cassandra.schema.TableMetadata; import org.apache.cassandra.transport.ProtocolVersion; import org.apache.cassandra.utils.ByteBufferUtil; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; + public final class JsonTransformer { @@ -282,7 +284,7 @@ public final class JsonTransformer json.writeFieldName("expires_at"); json.writeString(dateString(TimeUnit.SECONDS, liveInfo.localExpirationTime())); json.writeFieldName("expired"); - json.writeBoolean(liveInfo.localExpirationTime() < (System.currentTimeMillis() / 1000)); + json.writeBoolean(liveInfo.localExpirationTime() < (currentTimeMillis() / 1000)); } json.writeEndObject(); objectIndenter.setCompact(false); @@ -497,7 +499,7 @@ public final class JsonTransformer json.writeFieldName("expires_at"); json.writeString(dateString(TimeUnit.SECONDS, cell.localDeletionTime())); json.writeFieldName("expired"); - json.writeBoolean(!cell.isLive((int) (System.currentTimeMillis() / 1000))); + json.writeBoolean(!cell.isLive((int) (currentTimeMillis() / 1000))); } json.writeEndObject(); objectIndenter.setCompact(false); diff --git a/src/java/org/apache/cassandra/tools/RepairRunner.java b/src/java/org/apache/cassandra/tools/RepairRunner.java index 593bc2613a..e7ac8316e5 100644 --- a/src/java/org/apache/cassandra/tools/RepairRunner.java +++ b/src/java/org/apache/cassandra/tools/RepairRunner.java @@ -35,6 +35,8 @@ import org.apache.cassandra.utils.progress.ProgressEvent; import org.apache.cassandra.utils.progress.ProgressEventType; import org.apache.cassandra.utils.progress.jmx.JMXNotificationProgressListener; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; + public class RepairRunner extends JMXNotificationProgressListener { private final SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss,SSS"); @@ -189,6 +191,6 @@ public class RepairRunner extends JMXNotificationProgressListener private void printMessage(String message) { - out.println(String.format("[%s] %s", this.format.format(System.currentTimeMillis()), message)); + out.println(String.format("[%s] %s", this.format.format(currentTimeMillis()), message)); } } diff --git a/src/java/org/apache/cassandra/tools/SSTableExpiredBlockers.java b/src/java/org/apache/cassandra/tools/SSTableExpiredBlockers.java index 56c57d94e2..62a018c78b 100644 --- a/src/java/org/apache/cassandra/tools/SSTableExpiredBlockers.java +++ b/src/java/org/apache/cassandra/tools/SSTableExpiredBlockers.java @@ -35,6 +35,8 @@ import org.apache.cassandra.io.sstable.Component; import org.apache.cassandra.io.sstable.Descriptor; import org.apache.cassandra.io.sstable.format.SSTableReader; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; + /** * During compaction we can drop entire sstables if they only contain expired tombstones and if it is guaranteed * to not cover anything in other sstables. An expired sstable can be blocked from getting dropped if its newest @@ -87,7 +89,7 @@ public class SSTableExpiredBlockers System.exit(1); } - int gcBefore = (int)(System.currentTimeMillis()/1000) - metadata.params.gcGraceSeconds; + int gcBefore = (int)(currentTimeMillis() / 1000) - metadata.params.gcGraceSeconds; Multimap blockers = checkForExpiredSSTableBlockers(sstables, gcBefore); for (SSTableReader blocker : blockers.keySet()) { diff --git a/src/java/org/apache/cassandra/tools/SSTableMetadataViewer.java b/src/java/org/apache/cassandra/tools/SSTableMetadataViewer.java index a4da97cde5..8c1f5db4bc 100755 --- a/src/java/org/apache/cassandra/tools/SSTableMetadataViewer.java +++ b/src/java/org/apache/cassandra/tools/SSTableMetadataViewer.java @@ -21,6 +21,7 @@ import static org.apache.cassandra.tools.Util.BLUE; import static org.apache.cassandra.tools.Util.CYAN; import static org.apache.cassandra.tools.Util.RESET; import static org.apache.cassandra.tools.Util.WHITE; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; import static org.apache.commons.lang3.time.DurationFormatUtils.formatDurationWords; import java.io.DataInputStream; @@ -232,9 +233,9 @@ public class SSTableMetadataViewer cellCount++; double percentComplete = Math.min(1.0, cellCount / totalCells); if (lastPercent != (int) (percentComplete * 100) && - (System.currentTimeMillis() - lastPercentTime) > 1000) + (currentTimeMillis() - lastPercentTime) > 1000) { - lastPercentTime = System.currentTimeMillis(); + lastPercentTime = currentTimeMillis(); lastPercent = (int) (percentComplete * 100); if (color) out.printf("\r%sAnalyzing SSTable... %s%s %s(%%%s)", BLUE, CYAN, @@ -371,7 +372,7 @@ public class SSTableMetadataViewer field("maxClusteringValues", Arrays.toString(maxValues)); } field("Estimated droppable tombstones", - stats.getEstimatedDroppableTombstoneRatio((int) (System.currentTimeMillis() / 1000) - this.gc)); + stats.getEstimatedDroppableTombstoneRatio((int) (currentTimeMillis() / 1000) - this.gc)); field("SSTable Level", stats.sstableLevel); field("Repaired at", stats.repairedAt, toDateString(stats.repairedAt, TimeUnit.MILLISECONDS)); field("Pending repair", stats.pendingRepair); diff --git a/src/java/org/apache/cassandra/tools/StandaloneScrubber.java b/src/java/org/apache/cassandra/tools/StandaloneScrubber.java index bd71c64f5a..4dfa4abdce 100644 --- a/src/java/org/apache/cassandra/tools/StandaloneScrubber.java +++ b/src/java/org/apache/cassandra/tools/StandaloneScrubber.java @@ -55,6 +55,8 @@ import org.apache.cassandra.utils.JVMStabilityInspector; import org.apache.cassandra.utils.OutputHandler; import org.apache.cassandra.utils.Pair; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; + public class StandaloneScrubber { public static final String REINSERT_OVERFLOWED_TTL_OPTION_DESCRIPTION = "Rewrites rows with overflowed expiration date affected by CASSANDRA-14092 with " + @@ -108,7 +110,7 @@ public class StandaloneScrubber options.keyspaceName, options.cfName)); - String snapshotName = "pre-scrub-" + System.currentTimeMillis(); + String snapshotName = "pre-scrub-" + currentTimeMillis(); OutputHandler handler = new OutputHandler.SystemOutput(options.verbose, options.debug); Directories.SSTableLister lister = cfs.getDirectories().sstableLister(Directories.OnTxnErr.THROW).skipTemporary(true); diff --git a/src/java/org/apache/cassandra/tools/StandaloneSplitter.java b/src/java/org/apache/cassandra/tools/StandaloneSplitter.java index e15e5bccd5..e3c80f1243 100644 --- a/src/java/org/apache/cassandra/tools/StandaloneSplitter.java +++ b/src/java/org/apache/cassandra/tools/StandaloneSplitter.java @@ -38,6 +38,7 @@ import org.apache.cassandra.io.sstable.*; import org.apache.cassandra.utils.JVMStabilityInspector; import static org.apache.cassandra.tools.BulkLoader.CmdLineOptions; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; public class StandaloneSplitter { @@ -115,7 +116,7 @@ public class StandaloneSplitter // Do not load sstables since they might be broken Keyspace keyspace = Keyspace.openWithoutSSTables(ksName); ColumnFamilyStore cfs = keyspace.getColumnFamilyStore(cfName); - String snapshotName = "pre-split-" + System.currentTimeMillis(); + String snapshotName = "pre-split-" + currentTimeMillis(); List sstables = new ArrayList<>(); for (Map.Entry> fn : parsedFilenames.entrySet()) diff --git a/src/java/org/apache/cassandra/tools/nodetool/Snapshot.java b/src/java/org/apache/cassandra/tools/nodetool/Snapshot.java index f57708abeb..ef308f7b7b 100644 --- a/src/java/org/apache/cassandra/tools/nodetool/Snapshot.java +++ b/src/java/org/apache/cassandra/tools/nodetool/Snapshot.java @@ -18,6 +18,7 @@ package org.apache.cassandra.tools.nodetool; import static com.google.common.collect.Iterables.toArray; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; import static org.apache.commons.lang3.StringUtils.join; import io.airlift.airline.Arguments; import io.airlift.airline.Command; @@ -44,7 +45,7 @@ public class Snapshot extends NodeToolCmd private String table = null; @Option(title = "tag", name = {"-t", "--tag"}, description = "The name of the snapshot") - private String snapshotName = Long.toString(System.currentTimeMillis()); + private String snapshotName = Long.toString(currentTimeMillis()); @Option(title = "ktlist", name = { "-kt", "--kt-list", "-kc", "--kc.list" }, description = "The list of Keyspace.table to take snapshot.(you must not specify only keyspace)") private String ktList = null; diff --git a/src/java/org/apache/cassandra/tracing/TraceStateImpl.java b/src/java/org/apache/cassandra/tracing/TraceStateImpl.java index 48f193c5b6..d9077e26ab 100644 --- a/src/java/org/apache/cassandra/tracing/TraceStateImpl.java +++ b/src/java/org/apache/cassandra/tracing/TraceStateImpl.java @@ -39,6 +39,10 @@ import org.apache.cassandra.service.StorageProxy; import org.apache.cassandra.utils.JVMStabilityInspector; import org.apache.cassandra.utils.WrappedRunnable; +import static java.util.Collections.singletonList; +import static org.apache.cassandra.db.ConsistencyLevel.ANY; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + /** * ThreadLocal state for a tracing session. The presence of an instance of this class as a ThreadLocal denotes that an * operation is being traced. @@ -118,7 +122,7 @@ public class TraceStateImpl extends TraceState { try { - StorageProxy.mutate(Collections.singletonList(mutation), ConsistencyLevel.ANY, System.nanoTime()); + StorageProxy.mutate(singletonList(mutation), ANY, nanoTime()); } catch (OverloadedException e) { diff --git a/src/java/org/apache/cassandra/tracing/TracingImpl.java b/src/java/org/apache/cassandra/tracing/TracingImpl.java index c786fa22d2..9192aca87d 100644 --- a/src/java/org/apache/cassandra/tracing/TracingImpl.java +++ b/src/java/org/apache/cassandra/tracing/TracingImpl.java @@ -28,6 +28,8 @@ import org.apache.cassandra.concurrent.Stage; import org.apache.cassandra.locator.InetAddressAndPort; import org.apache.cassandra.utils.WrappedRunnable; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; + /** * A trace session context. Able to track and store trace sessions. A session is usually a user initiated query, and may @@ -55,7 +57,7 @@ class TracingImpl extends Tracing final TraceStateImpl state = getStateImpl(); assert state != null; - final long startedAt = System.currentTimeMillis(); + final long startedAt = currentTimeMillis(); final ByteBuffer sessionId = state.sessionIdBytes; final String command = state.traceType.toString(); final int ttl = state.ttl; diff --git a/src/java/org/apache/cassandra/transport/Dispatcher.java b/src/java/org/apache/cassandra/transport/Dispatcher.java index 29d4748d4f..1b141cd8aa 100644 --- a/src/java/org/apache/cassandra/transport/Dispatcher.java +++ b/src/java/org/apache/cassandra/transport/Dispatcher.java @@ -44,6 +44,7 @@ import org.apache.cassandra.utils.JVMStabilityInspector; import org.apache.cassandra.utils.NoSpamLogger; import static org.apache.cassandra.concurrent.SharedExecutorPool.SHARED; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; public class Dispatcher { @@ -85,7 +86,7 @@ public class Dispatcher */ static Message.Response processRequest(ServerConnection connection, Message.Request request, Overload backpressure) { - long queryStartNanoTime = System.nanoTime(); + long queryStartNanoTime = nanoTime(); if (connection.getVersion().isGreaterOrEqualTo(ProtocolVersion.V4)) ClientWarn.instance.captureWarnings(); diff --git a/src/java/org/apache/cassandra/transport/ProtocolVersionTracker.java b/src/java/org/apache/cassandra/transport/ProtocolVersionTracker.java index f2893778c7..3d6e9003c7 100644 --- a/src/java/org/apache/cassandra/transport/ProtocolVersionTracker.java +++ b/src/java/org/apache/cassandra/transport/ProtocolVersionTracker.java @@ -26,6 +26,8 @@ import com.github.benmanes.caffeine.cache.Cache; import com.github.benmanes.caffeine.cache.Caffeine; import com.github.benmanes.caffeine.cache.LoadingCache; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; + /** * This class tracks the last 100 connections per protocol version */ @@ -47,13 +49,13 @@ public class ProtocolVersionTracker for (ProtocolVersion version : ProtocolVersion.values()) { clientsByProtocolVersion.put(version, Caffeine.newBuilder().maximumSize(capacity) - .build(key -> System.currentTimeMillis())); + .build(key -> currentTimeMillis())); } } void addConnection(InetAddress addr, ProtocolVersion version) { - clientsByProtocolVersion.get(version).put(addr, System.currentTimeMillis()); + clientsByProtocolVersion.get(version).put(addr, currentTimeMillis()); } List getAll() diff --git a/src/java/org/apache/cassandra/transport/SimpleClient.java b/src/java/org/apache/cassandra/transport/SimpleClient.java index 87e54a1ae3..7e8e3e2029 100644 --- a/src/java/org/apache/cassandra/transport/SimpleClient.java +++ b/src/java/org/apache/cassandra/transport/SimpleClient.java @@ -54,6 +54,8 @@ import static org.apache.cassandra.transport.CQLMessageHandler.envelopeSize; import static org.apache.cassandra.transport.Flusher.MAX_FRAMED_PAYLOAD_SIZE; import static org.apache.cassandra.utils.concurrent.NonBlockingRateLimiter.NO_OP_LIMITER; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; + public class SimpleClient implements Closeable { @@ -316,10 +318,10 @@ public class SimpleClient implements Closeable } lastWriteFuture = channel.writeAndFlush(requests); - long deadline = System.currentTimeMillis() + TimeUnit.SECONDS.toMillis(TIMEOUT_SECONDS); + long deadline = currentTimeMillis() + TimeUnit.SECONDS.toMillis(TIMEOUT_SECONDS); for (int i = 0; i < requests.size(); i++) { - Message.Response msg = responseHandler.responses.poll(deadline - System.currentTimeMillis(), TimeUnit.MILLISECONDS); + Message.Response msg = responseHandler.responses.poll(deadline - currentTimeMillis(), TimeUnit.MILLISECONDS); if (msg == null) throw new RuntimeException("timeout"); if (msg instanceof ErrorMessage) diff --git a/src/java/org/apache/cassandra/transport/messages/BatchMessage.java b/src/java/org/apache/cassandra/transport/messages/BatchMessage.java index 59b5b53492..3a5cffa684 100644 --- a/src/java/org/apache/cassandra/transport/messages/BatchMessage.java +++ b/src/java/org/apache/cassandra/transport/messages/BatchMessage.java @@ -46,6 +46,8 @@ import org.apache.cassandra.transport.ProtocolVersion; import org.apache.cassandra.utils.JVMStabilityInspector; import org.apache.cassandra.utils.MD5Digest; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; + public class BatchMessage extends Message.Request { public static final Message.Codec codec = new Message.Codec() @@ -223,7 +225,7 @@ public class BatchMessage extends Message.Request // (and no value would be really correct, so we prefer passing a clearly wrong one). BatchStatement batch = new BatchStatement(batchType, VariableSpecifications.empty(), statements, Attributes.none()); - long queryTime = System.currentTimeMillis(); + long queryTime = currentTimeMillis(); Message.Response response = handler.processBatch(batch, state, batchOptions, getCustomPayload(), queryStartNanoTime); if (queries != null) QueryEvents.instance.notifyBatchSuccess(batchType, statements, queries, values, options, state, queryTime, response); diff --git a/src/java/org/apache/cassandra/transport/messages/ExecuteMessage.java b/src/java/org/apache/cassandra/transport/messages/ExecuteMessage.java index 05186fb4dd..9c9fe2a292 100644 --- a/src/java/org/apache/cassandra/transport/messages/ExecuteMessage.java +++ b/src/java/org/apache/cassandra/transport/messages/ExecuteMessage.java @@ -37,6 +37,8 @@ import org.apache.cassandra.transport.ProtocolVersion; import org.apache.cassandra.utils.JVMStabilityInspector; import org.apache.cassandra.utils.MD5Digest; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; + public class ExecuteMessage extends Message.Request { public static final Message.Codec codec = new Message.Codec() @@ -139,7 +141,7 @@ public class ExecuteMessage extends Message.Request // by wrapping the QueryOptions. QueryOptions queryOptions = QueryOptions.addColumnSpecifications(options, prepared.statement.getBindVariables()); - long requestStartTime = System.currentTimeMillis(); + long requestStartTime = currentTimeMillis(); Message.Response response = handler.processPrepared(statement, state, queryOptions, getCustomPayload(), queryStartNanoTime); diff --git a/src/java/org/apache/cassandra/transport/messages/PrepareMessage.java b/src/java/org/apache/cassandra/transport/messages/PrepareMessage.java index fa77c6829a..5bf058c0d4 100644 --- a/src/java/org/apache/cassandra/transport/messages/PrepareMessage.java +++ b/src/java/org/apache/cassandra/transport/messages/PrepareMessage.java @@ -32,6 +32,8 @@ import org.apache.cassandra.transport.Message; import org.apache.cassandra.transport.ProtocolVersion; import org.apache.cassandra.utils.JVMStabilityInspector; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; + public class PrepareMessage extends Message.Request { public static final Message.Codec codec = new Message.Codec() @@ -110,7 +112,7 @@ public class PrepareMessage extends Message.Request ClientState clientState = state.getClientState().cloneWithKeyspaceIfSet(keyspace); QueryHandler queryHandler = ClientState.getCQLQueryHandler(); - long queryTime = System.currentTimeMillis(); + long queryTime = currentTimeMillis(); ResultMessage.Prepared response = queryHandler.prepare(query, clientState, getCustomPayload()); QueryEvents.instance.notifyPrepareSuccess(() -> queryHandler.getPrepared(response.statementId), query, state, queryTime, response); return response; diff --git a/src/java/org/apache/cassandra/transport/messages/QueryMessage.java b/src/java/org/apache/cassandra/transport/messages/QueryMessage.java index 4d5d1e142b..9a296e442b 100644 --- a/src/java/org/apache/cassandra/transport/messages/QueryMessage.java +++ b/src/java/org/apache/cassandra/transport/messages/QueryMessage.java @@ -35,6 +35,8 @@ import org.apache.cassandra.transport.ProtocolException; import org.apache.cassandra.transport.ProtocolVersion; import org.apache.cassandra.utils.JVMStabilityInspector; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; + /** * A CQL query */ @@ -107,7 +109,7 @@ public class QueryMessage extends Message.Request if (traceRequest) traceQuery(state); - long queryStartTime = System.currentTimeMillis(); + long queryStartTime = currentTimeMillis(); QueryHandler queryHandler = ClientState.getCQLQueryHandler(); statement = queryHandler.parse(query, state, options); diff --git a/src/java/org/apache/cassandra/utils/ApproximateTime.java b/src/java/org/apache/cassandra/utils/ApproximateTime.java deleted file mode 100644 index 32b6e44317..0000000000 --- a/src/java/org/apache/cassandra/utils/ApproximateTime.java +++ /dev/null @@ -1,192 +0,0 @@ -/* - * 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.cassandra.utils; - -import java.util.concurrent.CancellationException; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.Future; -import java.util.concurrent.TimeUnit; - -import com.google.common.annotations.VisibleForTesting; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -import org.apache.cassandra.concurrent.ScheduledExecutors; -import org.apache.cassandra.config.Config; - -import static java.util.concurrent.TimeUnit.MILLISECONDS; -import static org.apache.cassandra.utils.ApproximateTime.Measurement.ALMOST_NOW; -import static org.apache.cassandra.utils.ApproximateTime.Measurement.ALMOST_SAME_TIME; - -/** - * This class provides approximate time utilities: - * - An imprecise nanoTime (monotonic) and currentTimeMillis (non-monotonic), that are faster than their regular counterparts - * They have a configured approximate precision (default of 10ms), which is the cadence they will be updated if the system is healthy - * - A mechanism for converting between nanoTime and currentTimeMillis measurements. - * These conversions may have drifted, and they offer no absolute guarantees on precision - */ -public class ApproximateTime -{ - private static final Logger logger = LoggerFactory.getLogger(ApproximateTime.class); - private static final int ALMOST_NOW_UPDATE_INTERVAL_MS = Math.max(1, Integer.parseInt(System.getProperty(Config.PROPERTY_PREFIX + "approximate_time_precision_ms", "2"))); - private static final String CONVERSION_UPDATE_INTERVAL_PROPERTY = Config.PROPERTY_PREFIX + "NANOTIMETOMILLIS_TIMESTAMP_UPDATE_INTERVAL"; - private static final long ALMOST_SAME_TIME_UPDATE_INTERVAL_MS = Long.getLong(CONVERSION_UPDATE_INTERVAL_PROPERTY, 10000); - - public static class AlmostSameTime - { - final long millis; - final long nanos; - final long error; // maximum error of millis measurement (in nanos) - - private AlmostSameTime(long millis, long nanos, long error) - { - this.millis = millis; - this.nanos = nanos; - this.error = error; - } - - public long toCurrentTimeMillis(long nanoTime) - { - return millis + TimeUnit.NANOSECONDS.toMillis(nanoTime - nanos); - } - - public long toNanoTime(long currentTimeMillis) - { - return nanos + MILLISECONDS.toNanos(currentTimeMillis - millis); - } - } - - public enum Measurement { ALMOST_NOW, ALMOST_SAME_TIME } - - private static volatile Future almostNowUpdater; - private static volatile Future almostSameTimeUpdater; - - private static volatile long almostNowMillis; - private static volatile long almostNowNanos; - - private static volatile AlmostSameTime almostSameTime = new AlmostSameTime(0L, 0L, Long.MAX_VALUE); - private static double failedAlmostSameTimeUpdateModifier = 1.0; - - private static final Runnable refreshAlmostNow = () -> { - almostNowMillis = System.currentTimeMillis(); - almostNowNanos = System.nanoTime(); - }; - - private static final Runnable refreshAlmostSameTime = () -> { - final int tries = 3; - long[] samples = new long[2 * tries + 1]; - samples[0] = System.nanoTime(); - for (int i = 1 ; i < samples.length ; i += 2) - { - samples[i] = System.currentTimeMillis(); - samples[i + 1] = System.nanoTime(); - } - - int best = 1; - // take sample with minimum delta between calls - for (int i = 3 ; i < samples.length - 1 ; i += 2) - { - if ((samples[i+1] - samples[i-1]) < (samples[best+1]-samples[best-1])) - best = i; - } - - long millis = samples[best]; - long nanos = (samples[best+1] / 2) + (samples[best-1] / 2); - long error = (samples[best+1] / 2) - (samples[best-1] / 2); - - AlmostSameTime prev = almostSameTime; - AlmostSameTime next = new AlmostSameTime(millis, nanos, error); - - if (next.error > prev.error && next.error > prev.error * failedAlmostSameTimeUpdateModifier) - { - failedAlmostSameTimeUpdateModifier *= 1.1; - return; - } - - failedAlmostSameTimeUpdateModifier = 1.0; - almostSameTime = next; - }; - - static - { - start(ALMOST_NOW); - start(ALMOST_SAME_TIME); - } - - public static synchronized void stop(Measurement measurement) - { - switch (measurement) - { - case ALMOST_NOW: - almostNowUpdater.cancel(true); - try { almostNowUpdater.get(); } catch (Throwable t) { } - almostNowUpdater = null; - break; - case ALMOST_SAME_TIME: - almostSameTimeUpdater.cancel(true); - try { almostSameTimeUpdater.get(); } catch (Throwable t) { } - almostSameTimeUpdater = null; - break; - } - } - - public static synchronized void start(Measurement measurement) - { - switch (measurement) - { - case ALMOST_NOW: - if (almostNowUpdater != null) - throw new IllegalStateException("Already running"); - refreshAlmostNow.run(); - logger.info("Scheduling approximate time-check task with a precision of {} milliseconds", ALMOST_NOW_UPDATE_INTERVAL_MS); - almostNowUpdater = ScheduledExecutors.scheduledFastTasks.scheduleWithFixedDelay(refreshAlmostNow, ALMOST_NOW_UPDATE_INTERVAL_MS, ALMOST_NOW_UPDATE_INTERVAL_MS, MILLISECONDS); - break; - case ALMOST_SAME_TIME: - if (almostSameTimeUpdater != null) - throw new IllegalStateException("Already running"); - refreshAlmostSameTime.run(); - logger.info("Scheduling approximate time conversion task with an interval of {} milliseconds", ALMOST_SAME_TIME_UPDATE_INTERVAL_MS); - almostSameTimeUpdater = ScheduledExecutors.scheduledFastTasks.scheduleWithFixedDelay(refreshAlmostSameTime, ALMOST_SAME_TIME_UPDATE_INTERVAL_MS, ALMOST_SAME_TIME_UPDATE_INTERVAL_MS, MILLISECONDS); - break; - } - } - - - /** - * Request an immediate refresh; this shouldn't generally be invoked, except perhaps by tests - */ - @VisibleForTesting - public static synchronized void refresh(Measurement measurement) - { - stop(measurement); - start(measurement); - } - - /** no guarantees about relationship to nanoTime; non-monotonic (tracks currentTimeMillis as closely as possible) */ - public static long currentTimeMillis() - { - return almostNowMillis; - } - - /** no guarantees about relationship to currentTimeMillis; monotonic */ - public static long nanoTime() - { - return almostNowNanos; - } -} diff --git a/src/java/org/apache/cassandra/utils/Clock.java b/src/java/org/apache/cassandra/utils/Clock.java new file mode 100644 index 0000000000..9dd6dd4918 --- /dev/null +++ b/src/java/org/apache/cassandra/utils/Clock.java @@ -0,0 +1,110 @@ +/* + * 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.cassandra.utils; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * Wrapper around time related functions that are either implemented by using the default JVM calls + * or by using a custom implementation for testing purposes. + * + * See {@link Global#instance} for how to use a custom implementation. + * + * Please note that {@link java.time.Clock} wasn't used, as it would not be possible to provide an + * implementation for {@link #nanoTime()} with the exact same properties of {@link System#nanoTime()}. + */ +public interface Clock +{ + public static class Global + { + private static final Logger logger = LoggerFactory.getLogger(Clock.class); + + /** + * Static singleton object that will be instantiated by default with a system clock + * implementation. Set cassandra.clock system property to a FQCN to use a + * different implementation instead. + */ + private static final Clock instance; + + static + { + String classname = System.getProperty("cassandra.clock"); + Clock clock = new Default(); + if (classname != null) + { + try + { + logger.debug("Using custom clock implementation: {}", classname); + clock = (Clock) Class.forName(classname).newInstance(); + } + catch (Exception e) + { + logger.error("Failed to load clock implementation {}", classname, e); + } + } + instance = clock; + } + + /** + * Semantically equivalent to {@link System#nanoTime()} + */ + public static long nanoTime() + { + return instance.nanoTime(); + } + + /** + * Semantically equivalent to {@link System#currentTimeMillis()} + */ + public static long currentTimeMillis() + { + return instance.currentTimeMillis(); + } + } + + public static class Default implements Clock + { + /** + * {@link System#nanoTime()} + */ + public long nanoTime() + { + return System.nanoTime(); + } + + /** + * {@link System#currentTimeMillis()} + */ + public long currentTimeMillis() + { + return System.currentTimeMillis(); + } + } + + /** + * Semantically equivalent to {@link System#nanoTime()} + */ + public long nanoTime(); + + /** + * Semantically equivalent to {@link System#currentTimeMillis()} + */ + public long currentTimeMillis(); + +} diff --git a/src/java/org/apache/cassandra/utils/DiagnosticSnapshotService.java b/src/java/org/apache/cassandra/utils/DiagnosticSnapshotService.java index d1f33ed351..0c80d06b0b 100644 --- a/src/java/org/apache/cassandra/utils/DiagnosticSnapshotService.java +++ b/src/java/org/apache/cassandra/utils/DiagnosticSnapshotService.java @@ -37,7 +37,8 @@ import org.apache.cassandra.net.MessagingService; import org.apache.cassandra.net.Verb; import org.apache.cassandra.schema.TableId; import org.apache.cassandra.schema.TableMetadata; -import org.hsqldb.Table; + +import static org.apache.cassandra.utils.Clock.Global.nanoTime; /** * Provides a means to take snapshots when triggered by anomalous events or when the breaking of invariants is @@ -119,7 +120,7 @@ public class DiagnosticSnapshotService private void maybeTriggerSnapshot(TableMetadata metadata, String prefix, Iterable endpoints) { - long now = System.nanoTime(); + long now = nanoTime(); AtomicLong cached = lastSnapshotTimes.computeIfAbsent(metadata.id, u -> new AtomicLong(0)); long last = cached.get(); long interval = Long.getLong("cassandra.diagnostic_snapshot_interval_nanos", SNAPSHOT_INTERVAL_NANOS); diff --git a/src/java/org/apache/cassandra/utils/ExecutorUtils.java b/src/java/org/apache/cassandra/utils/ExecutorUtils.java index 21933a3123..9ef1df8d57 100644 --- a/src/java/org/apache/cassandra/utils/ExecutorUtils.java +++ b/src/java/org/apache/cassandra/utils/ExecutorUtils.java @@ -27,6 +27,7 @@ import java.util.concurrent.TimeoutException; import org.apache.cassandra.concurrent.InfiniteLoopExecutor; import static java.util.concurrent.TimeUnit.NANOSECONDS; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; public class ExecutorUtils { @@ -92,7 +93,7 @@ public class ExecutorUtils public static void awaitTermination(long timeout, TimeUnit unit, Collection executors) throws InterruptedException, TimeoutException { - long deadline = System.nanoTime() + unit.toNanos(timeout); + long deadline = nanoTime() + unit.toNanos(timeout); awaitTerminationUntil(deadline, executors); } @@ -100,7 +101,7 @@ public class ExecutorUtils { for (Object executor : executors) { - long wait = deadline - System.nanoTime(); + long wait = deadline - nanoTime(); if (executor instanceof ExecutorService) { if (wait <= 0 || !((ExecutorService)executor).awaitTermination(wait, NANOSECONDS)) diff --git a/src/java/org/apache/cassandra/utils/ExpiringMemoizingSupplier.java b/src/java/org/apache/cassandra/utils/ExpiringMemoizingSupplier.java index 1736ae251e..2cba64dcb0 100644 --- a/src/java/org/apache/cassandra/utils/ExpiringMemoizingSupplier.java +++ b/src/java/org/apache/cassandra/utils/ExpiringMemoizingSupplier.java @@ -25,6 +25,8 @@ import java.util.function.Supplier; import com.google.common.annotations.VisibleForTesting; import com.google.common.base.Preconditions; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + /** * An implementation similar to Guava's Suppliers.memoizeWithExpiration(Supplier) * but allowing for memoization to be skipped. @@ -59,7 +61,7 @@ public class ExpiringMemoizingSupplier implements Supplier // the extra memory consumption and indirection are more // expensive than the extra volatile reads. long nanos = this.expirationNanos; - long now = System.nanoTime(); + long now = nanoTime(); if (nanos == 0L || now - nanos >= 0L) { synchronized(this) { if (nanos == this.expirationNanos) { diff --git a/src/java/org/apache/cassandra/utils/FBUtilities.java b/src/java/org/apache/cassandra/utils/FBUtilities.java index c2a3c83312..bb417a5df9 100644 --- a/src/java/org/apache/cassandra/utils/FBUtilities.java +++ b/src/java/org/apache/cassandra/utils/FBUtilities.java @@ -69,6 +69,8 @@ import org.apache.cassandra.locator.InetAddressAndPort; import static org.apache.cassandra.config.CassandraRelevantProperties.LINE_SEPARATOR; import static org.apache.cassandra.config.CassandraRelevantProperties.USER_HOME; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; public class FBUtilities @@ -426,12 +428,12 @@ public class FBUtilities { // we use microsecond resolution for compatibility with other client libraries, even though // we can't actually get microsecond precision. - return System.currentTimeMillis() * 1000; + return currentTimeMillis() * 1000; } public static int nowInSeconds() { - return (int) (System.currentTimeMillis() / 1000); + return (int) (currentTimeMillis() / 1000); } public static List waitOnFutures(Iterable> futures) @@ -451,7 +453,7 @@ public class FBUtilities { long endNanos = 0; if (timeout > 0) - endNanos = System.nanoTime() + units.toNanos(timeout); + endNanos = nanoTime() + units.toNanos(timeout); List results = new ArrayList<>(); Throwable fail = null; for (Future f : futures) @@ -464,7 +466,7 @@ public class FBUtilities } else { - long waitFor = Math.max(1, endNanos - System.nanoTime()); + long waitFor = Math.max(1, endNanos - nanoTime()); results.add(f.get(waitFor, TimeUnit.NANOSECONDS)); } } @@ -556,10 +558,10 @@ public class FBUtilities public List get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException { List result = new ArrayList<>(futures.size()); - long deadline = System.nanoTime() + TimeUnit.NANOSECONDS.convert(timeout, unit); + long deadline = nanoTime() + TimeUnit.NANOSECONDS.convert(timeout, unit); for (Future current : futures) { - long remaining = deadline - System.nanoTime(); + long remaining = deadline - nanoTime(); if (remaining <= 0) throw new TimeoutException(); diff --git a/src/java/org/apache/cassandra/utils/GuidGenerator.java b/src/java/org/apache/cassandra/utils/GuidGenerator.java index aa3ee5b82a..46843b4e4f 100644 --- a/src/java/org/apache/cassandra/utils/GuidGenerator.java +++ b/src/java/org/apache/cassandra/utils/GuidGenerator.java @@ -22,6 +22,7 @@ import java.security.SecureRandom; import java.util.Random; import static org.apache.cassandra.config.CassandraRelevantProperties.JAVA_SECURITY_EGD; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; public class GuidGenerator { @@ -90,7 +91,7 @@ public class GuidGenerator public static ByteBuffer guidAsBytes() { - return guidAsBytes(myRand, s_id, System.currentTimeMillis()); + return guidAsBytes(myRand, s_id, currentTimeMillis()); } /* diff --git a/src/java/org/apache/cassandra/utils/MonotonicClock.java b/src/java/org/apache/cassandra/utils/MonotonicClock.java index 5a1aa3c036..93d5ac5259 100644 --- a/src/java/org/apache/cassandra/utils/MonotonicClock.java +++ b/src/java/org/apache/cassandra/utils/MonotonicClock.java @@ -29,6 +29,7 @@ import org.apache.cassandra.concurrent.ScheduledExecutors; import org.apache.cassandra.config.Config; import static java.util.concurrent.TimeUnit.MILLISECONDS; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; /** * Wrapper around time related functions that are either implemented by using the default JVM calls @@ -38,6 +39,8 @@ import static java.util.concurrent.TimeUnit.MILLISECONDS; * * Please note that {@link java.time.Clock} wasn't used, as it would not be possible to provide an * implementation for {@link #now()} with the exact same properties of {@link System#nanoTime()}. + * + * TODO better rationalise MonotonicClock/Clock */ public interface MonotonicClock { @@ -75,9 +78,7 @@ public interface MonotonicClock private static MonotonicClock precise() { - String sclock = System.getProperty("cassandra.clock"); - if (sclock == null) - sclock = System.getProperty("cassandra.monotonic_clock.precise"); + String sclock = System.getProperty("cassandra.monotonic_clock.precise"); if (sclock != null) { @@ -204,7 +205,7 @@ public interface MonotonicClock { final int tries = 3; long[] samples = new long[2 * tries + 1]; - samples[0] = System.nanoTime(); + samples[0] = nanoTime(); for (int i = 1 ; i < samples.length ; i += 2) { samples[i] = millisSinceEpoch.getAsLong(); @@ -241,13 +242,13 @@ public interface MonotonicClock { private SystemClock() { - super(System::currentTimeMillis); + super(Clock.Global::currentTimeMillis); } @Override public long now() { - return System.nanoTime(); + return nanoTime(); } @Override diff --git a/src/java/org/apache/cassandra/utils/NoSpamLogger.java b/src/java/org/apache/cassandra/utils/NoSpamLogger.java index ac9168af7e..5a05a478eb 100644 --- a/src/java/org/apache/cassandra/utils/NoSpamLogger.java +++ b/src/java/org/apache/cassandra/utils/NoSpamLogger.java @@ -25,6 +25,8 @@ import org.slf4j.Logger; import com.google.common.annotations.VisibleForTesting; +import static org.apache.cassandra.utils.Clock.Global; + /** * Logging that limits each log statement to firing based on time since the statement last fired. * @@ -58,7 +60,7 @@ public class NoSpamLogger { public long nanoTime() { - return System.nanoTime(); + return Global.nanoTime(); } }; diff --git a/src/java/org/apache/cassandra/utils/SlidingTimeRate.java b/src/java/org/apache/cassandra/utils/SlidingTimeRate.java deleted file mode 100644 index 0e00054d02..0000000000 --- a/src/java/org/apache/cassandra/utils/SlidingTimeRate.java +++ /dev/null @@ -1,171 +0,0 @@ -/* - * 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.cassandra.utils; - -import java.util.concurrent.ConcurrentNavigableMap; -import java.util.concurrent.ConcurrentSkipListMap; -import java.util.concurrent.TimeUnit; -import java.util.concurrent.atomic.AtomicInteger; -import java.util.concurrent.atomic.AtomicLong; -import java.util.concurrent.locks.ReadWriteLock; -import java.util.concurrent.locks.ReentrantReadWriteLock; - -import com.google.common.annotations.VisibleForTesting; -import com.google.common.base.Preconditions; - -/** - * Concurrent rate computation over a sliding time window. - * - * Currently not used in the Cassandra 4.0 code base. If you decide to use it, please check CASSANDRA-16713. - * There still might be a bug, flaky test to be fixed before using it again. - */ -public class SlidingTimeRate -{ - private final ConcurrentSkipListMap counters = new ConcurrentSkipListMap<>(); - private final AtomicLong lastCounterTimestamp = new AtomicLong(0); - private final ReadWriteLock pruneLock = new ReentrantReadWriteLock(); - private final long sizeInMillis; - private final long precisionInMillis; - private final TimeSource timeSource; - - /** - * Creates a sliding rate whose time window is of the given size, with the given precision and time unit. - *

- * The precision defines how accurate the rate computation is, as it will be computed over window size +/- - * precision. - *

- */ - public SlidingTimeRate(TimeSource timeSource, long size, long precision, TimeUnit unit) - { - Preconditions.checkArgument(size > precision, "Size should be greater than precision."); - Preconditions.checkArgument(TimeUnit.MILLISECONDS.convert(precision, unit) >= 1, "Precision must be greater than or equal to 1 millisecond."); - this.sizeInMillis = TimeUnit.MILLISECONDS.convert(size, unit); - this.precisionInMillis = TimeUnit.MILLISECONDS.convert(precision, unit); - this.timeSource = timeSource; - } - - /** - * Updates the rate. - */ - public void update(int delta) - { - pruneLock.readLock().lock(); - try - { - while (true) - { - long now = timeSource.currentTimeMillis(); - long lastTimestamp = lastCounterTimestamp.get(); - boolean isWithinPrecisionRange = (now - lastTimestamp) < precisionInMillis; - AtomicInteger lastCounter = counters.get(lastTimestamp); - // If there's a valid counter for the current last timestamp, and we're in the precision range, - // update such counter: - if (lastCounter != null && isWithinPrecisionRange) - { - lastCounter.addAndGet(delta); - - break; - } - // Else if there's no counter or we're past the precision range, try to create a new counter, - // but only the thread updating the last timestamp will create a new counter: - else if (lastCounterTimestamp.compareAndSet(lastTimestamp, now)) - { - AtomicInteger existing = counters.putIfAbsent(now, new AtomicInteger(delta)); - if (existing != null) - { - existing.addAndGet(delta); - } - - break; - } - } - } - finally - { - pruneLock.readLock().unlock(); - } - } - - /** - * Gets the current rate in the given time unit from the beginning of the time window to the - * provided point in time ago. - */ - public double get(long toAgo, TimeUnit unit) - { - pruneLock.readLock().lock(); - try - { - long toAgoInMillis = TimeUnit.MILLISECONDS.convert(toAgo, unit); - Preconditions.checkArgument(toAgoInMillis < sizeInMillis, "Cannot get rate in the past!"); - - long now = timeSource.currentTimeMillis(); - long sum = 0; - ConcurrentNavigableMap tailCounters = counters - .tailMap(now - sizeInMillis, true) - .headMap(now - toAgoInMillis, true); - for (AtomicInteger i : tailCounters.values()) - { - sum += i.get(); - } - - double rateInMillis = sum == 0 - ? sum - : sum / (double) Math.max(1000, (now - toAgoInMillis) - tailCounters.firstKey()); - double multiplier = TimeUnit.MILLISECONDS.convert(1, unit); - return rateInMillis * multiplier; - } - finally - { - pruneLock.readLock().unlock(); - } - } - - /** - * Gets the current rate in the given time unit. - */ - public double get(TimeUnit unit) - { - return get(0, unit); - } - - /** - * Prunes the time window of old unused updates. - */ - public void prune() - { - pruneLock.writeLock().lock(); - try - { - long now = timeSource.currentTimeMillis(); - counters.headMap(now - sizeInMillis, false).clear(); - } - finally - { - pruneLock.writeLock().unlock(); - } - } - - @VisibleForTesting - public int size() - { - return counters.values().stream().reduce(new AtomicInteger(), (v1, v2) -> { - v1.addAndGet(v2.get()); - return v1; - }).get(); - } -} diff --git a/src/java/org/apache/cassandra/utils/SystemTimeSource.java b/src/java/org/apache/cassandra/utils/SystemTimeSource.java deleted file mode 100644 index fef525e39c..0000000000 --- a/src/java/org/apache/cassandra/utils/SystemTimeSource.java +++ /dev/null @@ -1,54 +0,0 @@ -/* - * 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.cassandra.utils; - -import java.util.concurrent.TimeUnit; - -import com.google.common.util.concurrent.Uninterruptibles; - -/** - * Time source backed by JVM clock. - */ -public class SystemTimeSource implements TimeSource -{ - @Override - public long currentTimeMillis() - { - return System.currentTimeMillis(); - } - - @Override - public long nanoTime() - { - return System.nanoTime(); - } - - @Override - public TimeSource sleepUninterruptibly(long sleepFor, TimeUnit unit) - { - Uninterruptibles.sleepUninterruptibly(sleepFor, unit); - return this; - } - - @Override - public TimeSource sleep(long sleepFor, TimeUnit unit) throws InterruptedException - { - TimeUnit.NANOSECONDS.sleep(TimeUnit.NANOSECONDS.convert(sleepFor, unit)); - return this; - } -} diff --git a/src/java/org/apache/cassandra/utils/TimeSource.java b/src/java/org/apache/cassandra/utils/TimeSource.java deleted file mode 100644 index 5d8acec703..0000000000 --- a/src/java/org/apache/cassandra/utils/TimeSource.java +++ /dev/null @@ -1,58 +0,0 @@ -/* - * 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.cassandra.utils; - -import java.util.concurrent.TimeUnit; - -public interface TimeSource -{ - /** - * - * @return the current time in milliseconds - */ - long currentTimeMillis(); - - /** - * - * @return Returns the current time value in nanoseconds. - * - *

This method can only be used to measure elapsed time and is - * not related to any other notion of system or wall-clock time. - */ - long nanoTime(); - - /** - * Sleep for the given amount of time uninterruptibly. - * - * @param sleepFor given amout. - * @param unit time unit - * @return The time source itself after the given sleep period. - */ - TimeSource sleepUninterruptibly(long sleepFor, TimeUnit unit); - - /** - * Sleep for the given amount of time. This operation could interrupted. - * Hence after returning from this method, it is not guaranteed - * that the request amount of time has passed. - * - * @param sleepFor given amout. - * @param unit time unit - * @return The time source itself after the given sleep period. - */ - TimeSource sleep(long sleepFor, TimeUnit unit) throws InterruptedException; -} diff --git a/src/java/org/apache/cassandra/utils/UUIDGen.java b/src/java/org/apache/cassandra/utils/UUIDGen.java index c83e292c27..7cb84592cf 100644 --- a/src/java/org/apache/cassandra/utils/UUIDGen.java +++ b/src/java/org/apache/cassandra/utils/UUIDGen.java @@ -43,6 +43,8 @@ import com.google.common.primitives.Ints; import org.apache.cassandra.config.DatabaseDescriptor; import org.apache.cassandra.locator.InetAddressAndPort; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; + /** * The goods are here: www.ietf.org/rfc/rfc4122.txt. */ @@ -323,7 +325,7 @@ public class UUIDGen while (true) { //Generate a candidate value for new lastNanos - newLastNanos = (System.currentTimeMillis() - START_EPOCH) * 10000; + newLastNanos = (currentTimeMillis() - START_EPOCH) * 10000; long originalLastNanos = lastNanos.get(); if (newLastNanos > originalLastNanos) { @@ -402,7 +404,7 @@ public class UUIDGen // Identify the process on the load: we use both the PID and class loader hash. long pid = NativeLibrary.getProcessID(); if (pid < 0) - pid = new Random(System.currentTimeMillis()).nextLong(); + pid = new Random(currentTimeMillis()).nextLong(); updateWithLong(hasher, pid); ClassLoader loader = UUIDGen.class.getClassLoader(); diff --git a/src/java/org/apache/cassandra/utils/binlog/ExternalArchiver.java b/src/java/org/apache/cassandra/utils/binlog/ExternalArchiver.java index e53c5b0a83..0e7cc04e2f 100644 --- a/src/java/org/apache/cassandra/utils/binlog/ExternalArchiver.java +++ b/src/java/org/apache/cassandra/utils/binlog/ExternalArchiver.java @@ -40,6 +40,9 @@ import net.openhft.chronicle.queue.impl.single.SingleChronicleQueue; import org.apache.cassandra.concurrent.NamedThreadFactory; import org.apache.cassandra.utils.FBUtilities; +import static java.util.concurrent.TimeUnit.MILLISECONDS; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; + /** * Archives binary log files immediately when they are rolled using a configure archive command. * @@ -184,12 +187,12 @@ public class ExternalArchiver implements BinLogArchiver public DelayFile(File file, long delay, TimeUnit delayUnit, int retries) { this.file = file; - this.delayTime = System.currentTimeMillis() + TimeUnit.MILLISECONDS.convert(delay, delayUnit); + this.delayTime = currentTimeMillis() + MILLISECONDS.convert(delay, delayUnit); this.retries = retries; } public long getDelay(TimeUnit unit) { - return unit.convert(delayTime - System.currentTimeMillis(), TimeUnit.MILLISECONDS); + return unit.convert(delayTime - currentTimeMillis(), TimeUnit.MILLISECONDS); } public int compareTo(Delayed o) diff --git a/src/java/org/apache/cassandra/utils/concurrent/IntervalLock.java b/src/java/org/apache/cassandra/utils/concurrent/IntervalLock.java deleted file mode 100644 index 382a2dc436..0000000000 --- a/src/java/org/apache/cassandra/utils/concurrent/IntervalLock.java +++ /dev/null @@ -1,69 +0,0 @@ -/* - * 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.cassandra.utils.concurrent; - -import java.util.concurrent.atomic.AtomicLong; -import java.util.concurrent.locks.ReentrantReadWriteLock; - -import com.google.common.annotations.VisibleForTesting; - -import org.apache.cassandra.utils.TimeSource; - -/** - * This class extends ReentrantReadWriteLock to provide a write lock that can only be acquired at provided intervals. - */ -public class IntervalLock extends ReentrantReadWriteLock -{ - private final AtomicLong lastAcquire = new AtomicLong(); - private final TimeSource timeSource; - - public IntervalLock(TimeSource timeSource) - { - this.timeSource = timeSource; - } - - /** - * Try acquiring a write lock if the given interval is passed since the last call to this method. - * - * @param interval In millis. - * @return True if acquired and locked, false otherwise. - */ - public boolean tryIntervalLock(long interval) - { - long now = timeSource.currentTimeMillis(); - boolean acquired = (now - lastAcquire.get() >= interval) && writeLock().tryLock(); - if (acquired) - lastAcquire.set(now); - - return acquired; - } - - /** - * Release the last acquired interval lock. - */ - public void releaseIntervalLock() - { - writeLock().unlock(); - } - - @VisibleForTesting - public long getLastIntervalAcquire() - { - return lastAcquire.get(); - } -} diff --git a/src/java/org/apache/cassandra/utils/concurrent/SimpleCondition.java b/src/java/org/apache/cassandra/utils/concurrent/SimpleCondition.java index 61ec640d1b..844cfda28e 100644 --- a/src/java/org/apache/cassandra/utils/concurrent/SimpleCondition.java +++ b/src/java/org/apache/cassandra/utils/concurrent/SimpleCondition.java @@ -22,6 +22,8 @@ import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicReferenceFieldUpdater; import java.util.concurrent.locks.Condition; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + // fulfils the Condition interface without spurious wakeup problems // (or lost notify problems either: that is, even if you call await() // _after_ signal(), it will work as desired.) @@ -49,7 +51,7 @@ public class SimpleCondition implements Condition public boolean await(long time, TimeUnit unit) throws InterruptedException { - long start = System.nanoTime(); + long start = nanoTime(); long until = start + unit.toNanos(time); return awaitUntil(until); } diff --git a/src/java/org/apache/cassandra/utils/concurrent/WaitQueue.java b/src/java/org/apache/cassandra/utils/concurrent/WaitQueue.java index 3647623095..295af1bbd8 100644 --- a/src/java/org/apache/cassandra/utils/concurrent/WaitQueue.java +++ b/src/java/org/apache/cassandra/utils/concurrent/WaitQueue.java @@ -26,6 +26,8 @@ import java.util.function.BooleanSupplier; import com.codahale.metrics.Timer; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + /** *

A relatively easy to use utility for general purpose thread signalling.

*

Usage on a thread awaiting a state change using a WaitQueue q is:

@@ -258,7 +260,7 @@ public final class WaitQueue * isSignalled() will be true on exit, and the method will return true; if timedout, the method will return * false and isCancelled() will be true; if interrupted an InterruptedException will be thrown and isCancelled() * will be true. - * @param nanos System.nanoTime() to wait until + * @param nanos nanoTime() to wait until * @return true if signalled, false if timed out * @throws InterruptedException */ @@ -268,7 +270,7 @@ public final class WaitQueue * Wait until signalled, or the provided time is reached, or the thread is interrupted. If signalled, * isSignalled() will be true on exit, and the method will return true; if timedout, the method will return * false and isCancelled() will be true - * @param nanos System.nanoTime() to wait until + * @param nanos nanoTime() to wait until * @return true if signalled, false if timed out */ public boolean awaitUntilUninterruptibly(long nanos); @@ -306,7 +308,7 @@ public final class WaitQueue public boolean awaitUntil(long until) throws InterruptedException { long now; - while (until > (now = System.nanoTime()) && !isSignalled()) + while (until > (now = nanoTime()) && !isSignalled()) { checkInterrupted(); long delta = until - now; @@ -318,7 +320,7 @@ public final class WaitQueue public boolean awaitUntilUninterruptibly(long until) { long now; - while (until > (now = System.nanoTime()) && !isSignalled()) + while (until > (now = nanoTime()) && !isSignalled()) { long delta = until - now; LockSupport.parkNanos(delta); diff --git a/src/java/org/apache/cassandra/utils/progress/jmx/JMXProgressSupport.java b/src/java/org/apache/cassandra/utils/progress/jmx/JMXProgressSupport.java index 12efd0dfa3..1d5023db04 100644 --- a/src/java/org/apache/cassandra/utils/progress/jmx/JMXProgressSupport.java +++ b/src/java/org/apache/cassandra/utils/progress/jmx/JMXProgressSupport.java @@ -26,6 +26,8 @@ import javax.management.NotificationBroadcasterSupport; import org.apache.cassandra.utils.progress.ProgressEvent; import org.apache.cassandra.utils.progress.ProgressListener; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; + /** * ProgressListener that translates ProgressEvent to JMX Notification message. */ @@ -46,7 +48,7 @@ public class JMXProgressSupport implements ProgressListener Notification notification = new Notification("progress", tag, notificationSerialNumber.getAndIncrement(), - System.currentTimeMillis(), + currentTimeMillis(), event.getMessage()); Map userData = new HashMap<>(); userData.put("type", event.getType().ordinal()); diff --git a/test/burn/org/apache/cassandra/concurrent/LongSharedExecutorPoolTest.java b/test/burn/org/apache/cassandra/concurrent/LongSharedExecutorPoolTest.java index fd7920af15..b5f5718f67 100644 --- a/test/burn/org/apache/cassandra/concurrent/LongSharedExecutorPoolTest.java +++ b/test/burn/org/apache/cassandra/concurrent/LongSharedExecutorPoolTest.java @@ -31,6 +31,8 @@ import org.apache.commons.math3.distribution.WeibullDistribution; import org.junit.Ignore; import org.junit.Test; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + public class LongSharedExecutorPoolTest { @@ -134,11 +136,11 @@ public class LongSharedExecutorPoolTest // (beyond max queued size), and longer operations for (float multiplier = 0f ; multiplier < 2.01f ; ) { - if (System.nanoTime() > until) + if (nanoTime() > until) { System.out.println(String.format("Completed %.0fK batches with %.1fM events", runs * 0.001f, events * 0.000001f)); events = 0; - until = System.nanoTime() + intervalNanos; + until = nanoTime() + intervalNanos; multiplier += loadIncrement; System.out.println(String.format("Running for %ds with load multiplier %.1f", TimeUnit.NANOSECONDS.toSeconds(intervalNanos), multiplier)); } @@ -150,20 +152,20 @@ public class LongSharedExecutorPoolTest else if (pending.size() == executorCount) timeout = pending.first().timeout; else timeout = (long) (Math.random() * pending.last().timeout); - while (!pending.isEmpty() && timeout > System.nanoTime()) + while (!pending.isEmpty() && timeout > nanoTime()) { Batch first = pending.first(); boolean complete = false; try { for (Result result : first.results.descendingSet()) - result.future.get(timeout - System.nanoTime(), TimeUnit.NANOSECONDS); + result.future.get(timeout - nanoTime(), TimeUnit.NANOSECONDS); complete = true; } catch (TimeoutException e) { } - if (!complete && System.nanoTime() > first.timeout) + if (!complete && nanoTime() > first.timeout) { for (Result result : first.results) if (!result.future.isDone()) @@ -190,7 +192,7 @@ public class LongSharedExecutorPoolTest TreeSet results = new TreeSet<>(); int count = (int) (workCount[executorIndex].sample() * multiplier); long targetTotalElapsed = 0; - long start = System.nanoTime(); + long start = nanoTime(); long baseTime; if (Math.random() > 0.5) baseTime = 2 * (long) (workTime.sample() * multiplier); else baseTime = 0; @@ -205,11 +207,11 @@ public class LongSharedExecutorPoolTest time = maxWorkTime; targetTotalElapsed += time; Future future = executor.submit(new WaitTask(time)); - results.add(new Result(future, System.nanoTime() + time)); + results.add(new Result(future, nanoTime() + time)); } long end = start + (long) Math.ceil(targetTotalElapsed / (double) threadCounts[executorIndex]) + TimeUnit.MILLISECONDS.toNanos(100L); - long now = System.nanoTime(); + long now = nanoTime(); if (runs++ > executorCount && now > end) throw new AssertionError(); events += results.size(); diff --git a/test/burn/org/apache/cassandra/net/ConnectionBurnTest.java b/test/burn/org/apache/cassandra/net/ConnectionBurnTest.java index eba8b65923..23601c310c 100644 --- a/test/burn/org/apache/cassandra/net/ConnectionBurnTest.java +++ b/test/burn/org/apache/cassandra/net/ConnectionBurnTest.java @@ -64,6 +64,7 @@ import org.apache.cassandra.utils.memory.BufferPools; import static java.lang.Math.min; import static org.apache.cassandra.net.MessagingService.current_version; import static org.apache.cassandra.net.ConnectionType.LARGE_MESSAGES; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.apache.cassandra.utils.MonotonicClock.approxTime; import static org.apache.cassandra.utils.MonotonicClock.preciseTime; @@ -259,7 +260,7 @@ public class ConnectionBurnTest Reporters reporters = new Reporters(endpoints, connections); try { - long deadline = System.nanoTime() + runForNanos; + long deadline = nanoTime() + runForNanos; Verb._TEST_2.unsafeSetHandler(() -> message -> {}); Verb._TEST_2.unsafeSetSerializer(() -> serializer); inbound.sockets.open().get(); @@ -345,7 +346,7 @@ public class ConnectionBurnTest executor.execute(() -> { Thread.currentThread().setName("Test-Reconnect"); ThreadLocalRandom random = ThreadLocalRandom.current(); - while (deadline > System.nanoTime()) + while (deadline > nanoTime()) { try { @@ -411,7 +412,7 @@ public class ConnectionBurnTest }; int count = 0; - while (deadline > System.nanoTime()) + while (deadline > nanoTime()) { try @@ -465,7 +466,7 @@ public class ConnectionBurnTest } }); - while (deadline > System.nanoTime() && failed.getCount() > 0) + while (deadline > nanoTime() && failed.getCount() > 0) { reporters.update(); reporters.print(); diff --git a/test/burn/org/apache/cassandra/net/Reporters.java b/test/burn/org/apache/cassandra/net/Reporters.java index 9ab46438a3..1f4f823c2e 100644 --- a/test/burn/org/apache/cassandra/net/Reporters.java +++ b/test/burn/org/apache/cassandra/net/Reporters.java @@ -30,12 +30,14 @@ import com.google.common.collect.ImmutableList; import org.apache.cassandra.locator.InetAddressAndPort; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + class Reporters { final Collection endpoints; final Connection[] connections; final List reporters; - final long start = System.nanoTime(); + final long start = nanoTime(); Reporters(Collection endpoints, Connection[] connections) { @@ -66,7 +68,7 @@ class Reporters void print() { - System.out.println("==" + prettyPrintElapsed(System.nanoTime() - start) + "==\n"); + System.out.println("==" + prettyPrintElapsed(nanoTime() - start) + "==\n"); for (Reporter reporter : reporters) { diff --git a/test/burn/org/apache/cassandra/net/Verifier.java b/test/burn/org/apache/cassandra/net/Verifier.java index 219e613e23..60b014afa6 100644 --- a/test/burn/org/apache/cassandra/net/Verifier.java +++ b/test/burn/org/apache/cassandra/net/Verifier.java @@ -65,6 +65,7 @@ import static org.apache.cassandra.net.Verifier.EventType.SEND_FRAME; import static org.apache.cassandra.net.Verifier.EventType.SENT_FRAME; import static org.apache.cassandra.net.Verifier.EventType.SERIALIZE; import static org.apache.cassandra.net.Verifier.ExpiredMessageEvent.ExpirationType.ON_SENT; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.apache.cassandra.utils.MonotonicClock.approxTime; /** @@ -1110,7 +1111,7 @@ public class Verifier throw new IllegalStateException(); } - now = System.nanoTime(); + now = nanoTime(); if (m.expiresAtNanos > now) { // we fix the conversion AlmostSameTime for an entire run, which should suffice to guarantee these comparisons @@ -1356,7 +1357,7 @@ public class Verifier public Event await(long id, long timeout, TimeUnit unit) throws InterruptedException { - return await(id, System.nanoTime() + unit.toNanos(timeout)); + return await(id, nanoTime() + unit.toNanos(timeout)); } public Event await(long id, long deadlineNanos) throws InterruptedException @@ -1370,7 +1371,7 @@ public class Verifier readerWaiting = Thread.currentThread(); while (null == (result = chunk.get(id))) { - long waitNanos = deadlineNanos - System.nanoTime(); + long waitNanos = deadlineNanos - nanoTime(); if (waitNanos <= 0) return null; LockSupport.parkNanos(waitNanos); diff --git a/test/burn/org/apache/cassandra/transport/DriverBurnTest.java b/test/burn/org/apache/cassandra/transport/DriverBurnTest.java index 8aaf87e7f2..56558672b9 100644 --- a/test/burn/org/apache/cassandra/transport/DriverBurnTest.java +++ b/test/burn/org/apache/cassandra/transport/DriverBurnTest.java @@ -45,6 +45,7 @@ import static org.apache.cassandra.transport.BurnTestUtil.SizeCaps; import static org.apache.cassandra.transport.BurnTestUtil.generateQueryMessage; import static org.apache.cassandra.transport.BurnTestUtil.generateQueryStatement; import static org.apache.cassandra.transport.BurnTestUtil.generateRows; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.assertj.core.api.Assertions.assertThat; public class DriverBurnTest extends CQLTester @@ -385,10 +386,10 @@ public class DriverBurnTest extends CQLTester for (int j = 0; j < perThread; j++) { - long startNanos = System.nanoTime(); + long startNanos = nanoTime(); ResultSetFuture future = session.executeAsync(request); future.addListener(() -> { - long diff = System.nanoTime() - startNanos; + long diff = nanoTime() - startNanos; if (measure.get()) { lock.lock(); diff --git a/test/burn/org/apache/cassandra/transport/SimpleClientPerfTest.java b/test/burn/org/apache/cassandra/transport/SimpleClientPerfTest.java index 0427ad9ae9..a050245d04 100644 --- a/test/burn/org/apache/cassandra/transport/SimpleClientPerfTest.java +++ b/test/burn/org/apache/cassandra/transport/SimpleClientPerfTest.java @@ -54,6 +54,7 @@ import org.apache.cassandra.utils.Throwables; import static org.apache.cassandra.transport.BurnTestUtil.SizeCaps; import static org.apache.cassandra.transport.BurnTestUtil.generateQueryMessage; import static org.apache.cassandra.transport.BurnTestUtil.generateRows; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; @RunWith(Parameterized.class) public class SimpleClientPerfTest @@ -219,9 +220,9 @@ public class SimpleClientPerfTest try { limiter.acquire(); - long nanoStart = System.nanoTime(); + long nanoStart = nanoTime(); client.execute(messages); - long elapsed = System.nanoTime() - nanoStart; + long elapsed = nanoTime() - nanoStart; lock.lock(); try diff --git a/test/burn/org/apache/cassandra/utils/memory/LongBufferPoolTest.java b/test/burn/org/apache/cassandra/utils/memory/LongBufferPoolTest.java index fc603c9d76..d9e837289e 100644 --- a/test/burn/org/apache/cassandra/utils/memory/LongBufferPoolTest.java +++ b/test/burn/org/apache/cassandra/utils/memory/LongBufferPoolTest.java @@ -39,6 +39,7 @@ import org.apache.cassandra.config.DatabaseDescriptor; import org.apache.cassandra.io.compress.BufferType; import org.apache.cassandra.utils.DynamicList; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.junit.Assert.*; /** @@ -186,7 +187,7 @@ public class LongBufferPoolTest this.threadCount = threadCount; this.duration = duration; this.poolSize = Math.toIntExact(poolSize); - until = System.nanoTime() + duration; + until = nanoTime() + duration; latch = new CountDownLatch(threadCount); sharedRecycle = new SPSCQueue[threadCount]; makingProgress = new AtomicBoolean[threadCount]; @@ -348,7 +349,7 @@ public class LongBufferPoolTest } else if (!recycleFromNeighbour()) { - if (++spinCount > 1000 && System.nanoTime() > until) + if (++spinCount > 1000 && nanoTime() > until) return; // otherwise, free one of our other neighbour's buffers if can; and otherwise yield Thread.yield(); @@ -568,7 +569,7 @@ public class LongBufferPoolTest { try { - while (System.nanoTime() < until) + while (nanoTime() < until) { checkpoint(); for (int i = 0 ; i < 100 ; i++) diff --git a/test/distributed/org/apache/cassandra/distributed/impl/Coordinator.java b/test/distributed/org/apache/cassandra/distributed/impl/Coordinator.java index 02f01c4411..852b3e88a0 100644 --- a/test/distributed/org/apache/cassandra/distributed/impl/Coordinator.java +++ b/test/distributed/org/apache/cassandra/distributed/impl/Coordinator.java @@ -49,6 +49,11 @@ import org.apache.cassandra.transport.messages.ResultMessage; import org.apache.cassandra.utils.ByteBufferUtil; import org.apache.cassandra.utils.FBUtilities; +import static java.lang.Integer.MAX_VALUE; +import static org.apache.cassandra.cql3.QueryOptions.create; +import static org.apache.cassandra.service.QueryState.forInternalCalls; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + public class Coordinator implements ICoordinator { final Instance instance; @@ -156,7 +161,7 @@ public class Coordinator implements ICoordinator prepared.validate(clientState); assert prepared instanceof SelectStatement : "Only SELECT statements can be executed with paging"; - long nanoTime = System.nanoTime(); + long nanoTime = nanoTime(); SelectStatement selectStatement = (SelectStatement) prepared; QueryState queryState = new QueryState(clientState); diff --git a/test/distributed/org/apache/cassandra/distributed/impl/Instance.java b/test/distributed/org/apache/cassandra/distributed/impl/Instance.java index 2a6b63826a..4dc5ffdc1e 100644 --- a/test/distributed/org/apache/cassandra/distributed/impl/Instance.java +++ b/test/distributed/org/apache/cassandra/distributed/impl/Instance.java @@ -144,12 +144,13 @@ import static org.apache.cassandra.distributed.api.Feature.NETWORK; import static org.apache.cassandra.distributed.impl.DistributedTestSnitch.fromCassandraInetAddressAndPort; import static org.apache.cassandra.distributed.impl.DistributedTestSnitch.toCassandraInetAddressAndPort; import static org.apache.cassandra.net.Verb.BATCH_STORE_REQ; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; public class Instance extends IsolatedExecutor implements IInvokableInstance { public final IInstanceConfig config; private volatile boolean initialized = false; - private final long startedAt = System.nanoTime(); + private final long startedAt; // should never be invoked directly, so that it is instantiated on other class loader; // only visible for inheritance @@ -160,6 +161,11 @@ public class Instance extends IsolatedExecutor implements IInvokableInstance Object clusterId = Objects.requireNonNull(config.get(Constants.KEY_DTEST_API_CLUSTER_ID), "cluster_id is not defined"); ClusterIDDefiner.setId("cluster-" + clusterId); InstanceIDDefiner.setInstanceId(config.num()); + // Defer initialisation of Clock.Global until cluster/instance identifiers are set. + // Otherwise, the instance classloader's logging classes are setup ahead of time and + // the patterns/file paths are not set correctly. This will be addressed in a subsequent + // commit to extend the functionality of the @Shared annotation to app classes. + startedAt = nanoTime(); FBUtilities.setBroadcastInetAddressAndPort(InetAddressAndPort.getByAddressOverrideDefaults(config.broadcastAddress().getAddress(), config.broadcastAddress().getPort())); @@ -566,7 +572,7 @@ public class Instance extends IsolatedExecutor implements IInvokableInstance StorageService.instance.registerDaemon(CassandraDaemon.getInstanceForTesting()); if (config.has(GOSSIP)) { - MigrationManager.setUptimeFn(() -> TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startedAt)); + MigrationManager.setUptimeFn(() -> TimeUnit.NANOSECONDS.toMillis(nanoTime() - startedAt)); try { StorageService.instance.initServer(); diff --git a/test/distributed/org/apache/cassandra/distributed/test/hostreplacement/HostReplacementAbruptDownedInstanceTest.java b/test/distributed/org/apache/cassandra/distributed/test/hostreplacement/HostReplacementAbruptDownedInstanceTest.java index 11a30e5762..d7b8f99a75 100644 --- a/test/distributed/org/apache/cassandra/distributed/test/hostreplacement/HostReplacementAbruptDownedInstanceTest.java +++ b/test/distributed/org/apache/cassandra/distributed/test/hostreplacement/HostReplacementAbruptDownedInstanceTest.java @@ -44,6 +44,7 @@ import static org.apache.cassandra.distributed.shared.ClusterUtils.replaceHostAn import static org.apache.cassandra.distributed.shared.ClusterUtils.stopAbrupt; import static org.apache.cassandra.distributed.test.hostreplacement.HostReplacementTest.setupCluster; import static org.apache.cassandra.distributed.test.hostreplacement.HostReplacementTest.validateRows; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; public class HostReplacementAbruptDownedInstanceTest extends TestBaseImpl { @@ -82,14 +83,14 @@ public class HostReplacementAbruptDownedInstanceTest extends TestBaseImpl // peers.forEach(p -> validateRows(p.coordinator(), expectedState)); // now create a new node to replace the other node - long startNanos = System.nanoTime(); + long startNanos = nanoTime(); IInvokableInstance replacingNode = replaceHostAndStart(cluster, nodeToRemove, properties -> { // since node2 was killed abruptly its possible that node2's gossip state has an old schema version // if this happens then bootstrap will fail waiting for a schema version it will never see; to avoid // this, setting this property to log the warning rather than fail bootstrap properties.set(BOOTSTRAP_SKIP_SCHEMA_CHECK, true); }); - logger.info("Host replacement of {} with {} took {}", nodeToRemove, replacingNode, Duration.ofNanos(System.nanoTime() - startNanos)); + logger.info("Host replacement of {} with {} took {}", nodeToRemove, replacingNode, Duration.ofNanos(nanoTime() - startNanos)); peers.forEach(p -> awaitRingJoin(p, replacingNode)); // make sure all nodes are healthy diff --git a/test/long/org/apache/cassandra/cql3/CachingBench.java b/test/long/org/apache/cassandra/cql3/CachingBench.java index f5f9ada28c..92b63b6bfd 100644 --- a/test/long/org/apache/cassandra/cql3/CachingBench.java +++ b/test/long/org/apache/cassandra/cql3/CachingBench.java @@ -48,6 +48,7 @@ import org.apache.cassandra.io.sstable.format.SSTableReader; import org.apache.cassandra.io.util.FileUtils; import org.apache.cassandra.utils.FBUtilities; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.assertj.core.api.Assertions.assertThat; public class CachingBench extends CQLTester @@ -183,9 +184,9 @@ public class CachingBench extends CQLTester if (ii % (FLUSH_FREQ * 10) == 0) { System.out.println("C"); - long startTime = System.nanoTime(); + long startTime = nanoTime(); getCurrentColumnFamilyStore().enableAutoCompaction(!CONCURRENT_COMPACTIONS); - long endTime = System.nanoTime(); + long endTime = nanoTime(); compactionTimeNanos += endTime - startTime; getCurrentColumnFamilyStore().disableAutoCompaction(); } diff --git a/test/long/org/apache/cassandra/cql3/GcCompactionBench.java b/test/long/org/apache/cassandra/cql3/GcCompactionBench.java index 009c9e2cb7..155335e6f5 100644 --- a/test/long/org/apache/cassandra/cql3/GcCompactionBench.java +++ b/test/long/org/apache/cassandra/cql3/GcCompactionBench.java @@ -46,6 +46,8 @@ import org.apache.cassandra.io.sstable.format.SSTableReader; import org.apache.cassandra.schema.CompactionParams.TombstoneOption; import org.apache.cassandra.utils.FBUtilities; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + public class GcCompactionBench extends CQLTester { private static final String SIZE_TIERED_STRATEGY = "SizeTieredCompactionStrategy', 'min_sstable_size' : '0"; @@ -183,9 +185,9 @@ public class GcCompactionBench extends CQLTester if (ii % (FLUSH_FREQ * 10) == 0) { System.out.println("C"); - long startTime = System.nanoTime(); + long startTime = nanoTime(); getCurrentColumnFamilyStore().enableAutoCompaction(true); - long endTime = System.nanoTime(); + long endTime = nanoTime(); compactionTimeNanos += endTime - startTime; getCurrentColumnFamilyStore().disableAutoCompaction(); } diff --git a/test/long/org/apache/cassandra/db/compaction/LongCompactionsTest.java b/test/long/org/apache/cassandra/db/compaction/LongCompactionsTest.java index fe8cdc2fd9..9b4fe73bf6 100644 --- a/test/long/org/apache/cassandra/db/compaction/LongCompactionsTest.java +++ b/test/long/org/apache/cassandra/db/compaction/LongCompactionsTest.java @@ -40,6 +40,8 @@ import org.apache.cassandra.schema.CompactionParams; import org.apache.cassandra.schema.KeyspaceParams; import org.apache.cassandra.utils.ByteBufferUtil; import org.apache.cassandra.utils.FBUtilities; + +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.junit.Assert.assertEquals; public class LongCompactionsTest @@ -122,7 +124,7 @@ public class LongCompactionsTest // give garbage collection a bit of time to catch up Thread.sleep(1000); - long start = System.nanoTime(); + long start = nanoTime(); final int gcBefore = (int) (System.currentTimeMillis() / 1000) - Schema.instance.getTableMetadata(KEYSPACE1, "Standard1").params.gcGraceSeconds; try (LifecycleTransaction txn = store.getTracker().tryModify(sstables, OperationType.COMPACTION)) { @@ -134,7 +136,7 @@ public class LongCompactionsTest sstableCount, partitionsPerSSTable, rowsPerPartition, - TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start))); + TimeUnit.NANOSECONDS.toMillis(nanoTime() - start))); } @Test diff --git a/test/long/org/apache/cassandra/io/compress/CompressorPerformance.java b/test/long/org/apache/cassandra/io/compress/CompressorPerformance.java index b3cdaa1fc2..19a8ec36f2 100644 --- a/test/long/org/apache/cassandra/io/compress/CompressorPerformance.java +++ b/test/long/org/apache/cassandra/io/compress/CompressorPerformance.java @@ -26,6 +26,8 @@ import java.nio.ByteBuffer; import java.util.Collections; import java.util.concurrent.ThreadLocalRandom; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + public class CompressorPerformance { @@ -71,7 +73,7 @@ public class CompressorPerformance int checksum = 0; int count = 100; - long time = System.nanoTime(); + long time = nanoTime(); long uncompressedBytes = 0; long compressedBytes = 0; for (int i=0; i%s compress %.3f ns/b %.3f mb/s uncompress %.3f ns/b %.3f mb/s ratio %.2f:1.%s\n", compressor.getClass().getSimpleName(), in, diff --git a/test/long/org/apache/cassandra/streaming/LongStreamingTest.java b/test/long/org/apache/cassandra/streaming/LongStreamingTest.java index e37045aead..186476078c 100644 --- a/test/long/org/apache/cassandra/streaming/LongStreamingTest.java +++ b/test/long/org/apache/cassandra/streaming/LongStreamingTest.java @@ -44,6 +44,7 @@ import org.apache.cassandra.service.StorageService; import org.apache.cassandra.utils.FBUtilities; import org.apache.cassandra.utils.OutputHandler; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.junit.Assert.assertEquals; public class LongStreamingTest @@ -99,13 +100,13 @@ public class LongStreamingTest Assert.assertEquals(useSstableCompression, compressionParams.isEnabled()); - long start = System.nanoTime(); + long start = nanoTime(); for (int i = 0; i < 10_000_000; i++) writer.addRow(i, "test1", 24); writer.close(); - System.err.println(String.format("Writer finished after %d seconds....", TimeUnit.NANOSECONDS.toSeconds(System.nanoTime() - start))); + System.err.println(String.format("Writer finished after %d seconds....", TimeUnit.NANOSECONDS.toSeconds(nanoTime() - start))); File[] dataFiles = dataDir.listFiles((dir, name) -> name.endsWith("-Data.db")); long dataSize = 0l; @@ -132,10 +133,10 @@ public class LongStreamingTest } }, new OutputHandler.SystemOutput(false, false)); - start = System.nanoTime(); + start = nanoTime(); loader.stream().get(); - long millis = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start); + long millis = TimeUnit.NANOSECONDS.toMillis(nanoTime() - start); System.err.println(String.format("Finished Streaming in %.2f seconds: %.2f Mb/sec", millis/1000d, (dataSize / (1 << 20) / (millis / 1000d)) * 8)); @@ -159,19 +160,19 @@ public class LongStreamingTest } }, new OutputHandler.SystemOutput(false, false)); - start = System.nanoTime(); + start = nanoTime(); loader.stream().get(); - millis = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start); + millis = TimeUnit.NANOSECONDS.toMillis(nanoTime() - start); System.err.println(String.format("Finished Streaming in %.2f seconds: %.2f Mb/sec", millis/1000d, (dataSize / (1 << 20) / (millis / 1000d)) * 8)); //Compact them both - start = System.nanoTime(); + start = nanoTime(); Keyspace.open(KS).getColumnFamilyStore(TABLE).forceMajorCompaction(); - millis = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start); + millis = TimeUnit.NANOSECONDS.toMillis(nanoTime() - start); System.err.println(String.format("Finished Compacting in %.2f seconds: %.2f Mb/sec", millis / 1000d, diff --git a/test/microbench/org/apache/cassandra/test/microbench/BatchStatementBench.java b/test/microbench/org/apache/cassandra/test/microbench/BatchStatementBench.java index b79f154682..1fff65cd90 100644 --- a/test/microbench/org/apache/cassandra/test/microbench/BatchStatementBench.java +++ b/test/microbench/org/apache/cassandra/test/microbench/BatchStatementBench.java @@ -63,6 +63,7 @@ import org.openjdk.jmh.runner.options.Options; import org.openjdk.jmh.runner.options.OptionsBuilder; import static org.apache.cassandra.utils.ByteBufferUtil.bytes; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; @BenchmarkMode(Mode.Throughput) @@ -87,7 +88,7 @@ public class BatchStatementBench String table = "tbl"; int nowInSec = FBUtilities.nowInSeconds(); - long queryStartTime = System.nanoTime(); + long queryStartTime = nanoTime(); BatchStatement bs; BatchQueryOptions bqo; diff --git a/test/microbench/org/apache/cassandra/test/microbench/MessageOutBench.java b/test/microbench/org/apache/cassandra/test/microbench/MessageOutBench.java index a3446aadf7..5addfa8af6 100644 --- a/test/microbench/org/apache/cassandra/test/microbench/MessageOutBench.java +++ b/test/microbench/org/apache/cassandra/test/microbench/MessageOutBench.java @@ -50,6 +50,7 @@ import org.openjdk.jmh.annotations.State; import org.openjdk.jmh.annotations.Warmup; import static org.apache.cassandra.net.Verb.ECHO_REQ; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; @State(Scope.Thread) @Warmup(iterations = 4, time = 1, timeUnit = TimeUnit.SECONDS) @@ -96,7 +97,7 @@ public class MessageOutBench { try (DataOutputBuffer out = new DataOutputBuffer()) { - Message.serializer.serialize(Message.builder(msgOut).withCreatedAt(System.nanoTime()).withId(42).build(), + Message.serializer.serialize(Message.builder(msgOut).withCreatedAt(nanoTime()).withId(42).build(), out, messagingVersion); DataInputBuffer in = new DataInputBuffer(out.buffer(), false); Message.serializer.deserialize(in, addr, messagingVersion); diff --git a/test/unit/org/apache/cassandra/concurrent/DebuggableThreadPoolExecutorTest.java b/test/unit/org/apache/cassandra/concurrent/DebuggableThreadPoolExecutorTest.java index 58200c93a5..b3c29f472b 100644 --- a/test/unit/org/apache/cassandra/concurrent/DebuggableThreadPoolExecutorTest.java +++ b/test/unit/org/apache/cassandra/concurrent/DebuggableThreadPoolExecutorTest.java @@ -42,6 +42,8 @@ import org.apache.cassandra.tracing.TraceStateImpl; import org.apache.cassandra.tracing.Tracing; import org.apache.cassandra.utils.WrappedRunnable; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + public class DebuggableThreadPoolExecutorTest { @BeforeClass @@ -66,7 +68,7 @@ public class DebuggableThreadPoolExecutorTest Thread.sleep(50); } }; - long start = System.nanoTime(); + long start = nanoTime(); for (int i = 0; i < 10; i++) { executor.execute(runnable); @@ -74,7 +76,7 @@ public class DebuggableThreadPoolExecutorTest assert q.size() > 0 : q.size(); while (executor.getCompletedTaskCount() < 10) continue; - long delta = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start); + long delta = TimeUnit.NANOSECONDS.toMillis(nanoTime() - start); assert delta >= 9 * 50 : delta; } diff --git a/test/unit/org/apache/cassandra/cql3/CustomNowInSecondsTest.java b/test/unit/org/apache/cassandra/cql3/CustomNowInSecondsTest.java index 983acfaf97..8768b77ca9 100644 --- a/test/unit/org/apache/cassandra/cql3/CustomNowInSecondsTest.java +++ b/test/unit/org/apache/cassandra/cql3/CustomNowInSecondsTest.java @@ -34,6 +34,8 @@ import org.apache.cassandra.transport.ProtocolVersion; import org.apache.cassandra.transport.messages.ResultMessage; import static java.lang.String.format; +import static java.util.Collections.emptyMap; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.junit.Assert.assertEquals; public class CustomNowInSecondsTest extends CQLTester @@ -154,7 +156,7 @@ public class CustomNowInSecondsTest extends CQLTester new BatchStatement(BatchStatement.Type.UNLOGGED, VariableSpecifications.empty(), statements, Attributes.none()); // execute an BATCH message with now set to [now + 1 day], with ttl = 1, making its effective ttl = 1 day + 1. - QueryProcessor.instance.processBatch(batch, qs, batchQueryOptions(now + day), Collections.emptyMap(), System.nanoTime()); + QueryProcessor.instance.processBatch(batch, qs, batchQueryOptions(now + day), emptyMap(), nanoTime()); // verify that despite TTL having passed at now + 1 the rows are still there. assertEquals(2, executeSelect(format("SELECT * FROM %s.%s", ks, tbl), now + 1, false).size()); @@ -183,12 +185,12 @@ public class CustomNowInSecondsTest extends CQLTester if (prepared) { CQLStatement statement = QueryProcessor.parseStatement(query, cs); - return QueryProcessor.instance.processPrepared(statement, qs, queryOptions(nowInSeconds), Collections.emptyMap(), System.nanoTime()); + return QueryProcessor.instance.processPrepared(statement, qs, queryOptions(nowInSeconds), emptyMap(), nanoTime()); } else { CQLStatement statement = QueryProcessor.instance.parse(query, qs, queryOptions(nowInSeconds)); - return QueryProcessor.instance.process(statement, qs, queryOptions(nowInSeconds), Collections.emptyMap(), System.nanoTime()); + return QueryProcessor.instance.process(statement, qs, queryOptions(nowInSeconds), emptyMap(), nanoTime()); } } diff --git a/test/unit/org/apache/cassandra/cql3/PstmtPersistenceTest.java b/test/unit/org/apache/cassandra/cql3/PstmtPersistenceTest.java index eca6c2091b..da9fc2a551 100644 --- a/test/unit/org/apache/cassandra/cql3/PstmtPersistenceTest.java +++ b/test/unit/org/apache/cassandra/cql3/PstmtPersistenceTest.java @@ -36,6 +36,9 @@ import org.apache.cassandra.service.QueryState; import org.apache.cassandra.utils.ByteBufferUtil; import org.apache.cassandra.utils.MD5Digest; +import static java.util.Collections.emptyMap; +import static org.apache.cassandra.service.QueryState.forInternalCalls; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.junit.Assert.*; public class PstmtPersistenceTest extends CQLTester @@ -129,7 +132,7 @@ public class PstmtPersistenceTest extends CQLTester { QueryProcessor.Prepared prepared = handler.getPrepared(stmtId); Assert.assertNotNull(prepared); - handler.processPrepared(prepared.statement, QueryState.forInternalCalls(), options, Collections.emptyMap(), System.nanoTime()); + handler.processPrepared(prepared.statement, forInternalCalls(), options, emptyMap(), nanoTime()); } @Test diff --git a/test/unit/org/apache/cassandra/cql3/validation/entities/CollectionsTest.java b/test/unit/org/apache/cassandra/cql3/validation/entities/CollectionsTest.java index 54dd0c4c99..e37a294c86 100644 --- a/test/unit/org/apache/cassandra/cql3/validation/entities/CollectionsTest.java +++ b/test/unit/org/apache/cassandra/cql3/validation/entities/CollectionsTest.java @@ -31,6 +31,7 @@ import org.apache.cassandra.cql3.UntypedResultSet; import org.apache.cassandra.db.marshal.UTF8Type; import org.apache.cassandra.utils.FBUtilities; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.junit.Assert.assertEquals; public class CollectionsTest extends CQLTester @@ -695,7 +696,7 @@ public class CollectionsTest extends CQLTester public void testMapWithLargePartition() throws Throwable { Random r = new Random(); - long seed = System.nanoTime(); + long seed = nanoTime(); System.out.println("Seed " + seed); r.setSeed(seed); diff --git a/test/unit/org/apache/cassandra/cql3/validation/entities/JsonTest.java b/test/unit/org/apache/cassandra/cql3/validation/entities/JsonTest.java index e28e0cb120..f550fdfe0f 100644 --- a/test/unit/org/apache/cassandra/cql3/validation/entities/JsonTest.java +++ b/test/unit/org/apache/cassandra/cql3/validation/entities/JsonTest.java @@ -40,6 +40,7 @@ import java.text.SimpleDateFormat; import java.util.*; import java.util.concurrent.*; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.junit.Assert.assertEquals; import static org.junit.Assert.fail; @@ -1329,7 +1330,7 @@ public class JsonTest extends CQLTester for (int i = 0; i < numRows; i++) execute("INSERT INTO %s (k, v) VALUES (?, ?)", "" + i, "" + i); - long seed = System.nanoTime(); + long seed = nanoTime(); System.out.println("Seed " + seed); final Random rand = new Random(seed); diff --git a/test/unit/org/apache/cassandra/cql3/validation/entities/SecondaryIndexTest.java b/test/unit/org/apache/cassandra/cql3/validation/entities/SecondaryIndexTest.java index 9f228577e4..bfe48156bb 100644 --- a/test/unit/org/apache/cassandra/cql3/validation/entities/SecondaryIndexTest.java +++ b/test/unit/org/apache/cassandra/cql3/validation/entities/SecondaryIndexTest.java @@ -59,6 +59,7 @@ import static java.lang.String.format; import static org.apache.cassandra.Util.throwAssert; import static org.apache.cassandra.utils.ByteBufferUtil.EMPTY_BYTE_BUFFER; import static org.apache.cassandra.utils.ByteBufferUtil.bytes; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotNull; @@ -114,7 +115,7 @@ public class SecondaryIndexTest extends CQLTester "CREATE INDEX " + indexName + " ON %s(b)"); // IF NOT EXISTS should apply in cases where the new index differs from an existing one in name only - String otherIndexName = "index_" + System.nanoTime(); + String otherIndexName = "index_" + nanoTime(); assertEquals(1, getCurrentColumnFamilyStore().metadata().indexes.size()); createIndex("CREATE INDEX IF NOT EXISTS " + otherIndexName + " ON %s(b)"); assertEquals(1, getCurrentColumnFamilyStore().metadata().indexes.size()); diff --git a/test/unit/org/apache/cassandra/db/CleanupTest.java b/test/unit/org/apache/cassandra/db/CleanupTest.java index 996536126b..b028a4eb6f 100644 --- a/test/unit/org/apache/cassandra/db/CleanupTest.java +++ b/test/unit/org/apache/cassandra/db/CleanupTest.java @@ -56,6 +56,7 @@ import org.apache.cassandra.schema.KeyspaceParams; import org.apache.cassandra.service.StorageService; import org.apache.cassandra.utils.ByteBufferUtil; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; @@ -155,8 +156,8 @@ public class CleanupTest ColumnMetadata cdef = cfs.metadata().getColumn(COLUMN); String indexName = "birthdate_key_index"; - long start = System.nanoTime(); - while (!cfs.getBuiltIndexes().contains(indexName) && System.nanoTime() - start < TimeUnit.SECONDS.toNanos(10)) + long start = nanoTime(); + while (!cfs.getBuiltIndexes().contains(indexName) && nanoTime() - start < TimeUnit.SECONDS.toNanos(10)) Thread.sleep(10); RowFilter cf = RowFilter.create(); diff --git a/test/unit/org/apache/cassandra/db/DirectoriesTest.java b/test/unit/org/apache/cassandra/db/DirectoriesTest.java index 4c282a6bb3..ba499cee94 100644 --- a/test/unit/org/apache/cassandra/db/DirectoriesTest.java +++ b/test/unit/org/apache/cassandra/db/DirectoriesTest.java @@ -62,6 +62,7 @@ import org.apache.cassandra.service.snapshot.TableSnapshot; import org.apache.cassandra.utils.JVMStabilityInspector; import static org.assertj.core.api.Assertions.assertThat; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertSame; @@ -511,7 +512,7 @@ public class DirectoriesTest { final Directories directories = new Directories(cfm, toDataDirectories(tempDataDir)); assertEquals(cfDir(cfm), directories.getDirectoryForNewSSTables()); - final String n = Long.toString(System.nanoTime()); + final String n = Long.toString(nanoTime()); Callable directoryGetter = new Callable() { public File call() throws Exception { Descriptor desc = new Descriptor(cfDir(cfm), KS, cfm.name, 1, SSTableFormat.Type.BIG); diff --git a/test/unit/org/apache/cassandra/db/RangeTombstoneListTest.java b/test/unit/org/apache/cassandra/db/RangeTombstoneListTest.java index 8f61a0562d..bbe06a8482 100644 --- a/test/unit/org/apache/cassandra/db/RangeTombstoneListTest.java +++ b/test/unit/org/apache/cassandra/db/RangeTombstoneListTest.java @@ -35,6 +35,7 @@ import org.apache.cassandra.distributed.impl.IsolatedExecutor; import org.apache.cassandra.service.StorageService; import org.apache.cassandra.utils.ByteBufferUtil; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertSame; @@ -334,7 +335,7 @@ public class RangeTombstoneListTest int MAX_IT_DISTANCE = 10; int MAX_MARKEDAT = 10; - long seed = System.nanoTime(); + long seed = nanoTime(); Random rand = new Random(seed); for (int i = 0; i < TEST_COUNT; i++) diff --git a/test/unit/org/apache/cassandra/db/commitlog/BatchCommitLogTest.java b/test/unit/org/apache/cassandra/db/commitlog/BatchCommitLogTest.java index 7336e033d9..e9ec640e79 100644 --- a/test/unit/org/apache/cassandra/db/commitlog/BatchCommitLogTest.java +++ b/test/unit/org/apache/cassandra/db/commitlog/BatchCommitLogTest.java @@ -35,6 +35,7 @@ import org.apache.cassandra.db.RowUpdateBuilder; import org.apache.cassandra.security.EncryptionContext; import static org.junit.Assert.assertEquals; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; public class BatchCommitLogTest extends CommitLogTest { @@ -62,18 +63,18 @@ public class BatchCommitLogTest extends CommitLogTest .add("val", ByteBuffer.allocate(10 * 1024)) .build(); - long startNano = System.nanoTime(); + long startNano = nanoTime(); CommitLog.instance.add(m); - long delta = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startNano); + long delta = TimeUnit.NANOSECONDS.toMillis(nanoTime() - startNano); Assert.assertTrue("Expect batch commitlog sync immediately, but took " + delta, delta < CL_BATCH_SYNC_WINDOW); } @Test public void testBatchCLShutDownImmediately() throws InterruptedException { - long startNano = System.nanoTime(); + long startNano = nanoTime(); CommitLog.instance.shutdownBlocking(); - long delta = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startNano); + long delta = TimeUnit.NANOSECONDS.toMillis(nanoTime() - startNano); Assert.assertTrue("Expect batch commitlog shutdown immediately, but took " + delta, delta < CL_BATCH_SYNC_WINDOW); CommitLog.instance.start(); } diff --git a/test/unit/org/apache/cassandra/db/compaction/CorruptedSSTablesCompactionsTest.java b/test/unit/org/apache/cassandra/db/compaction/CorruptedSSTablesCompactionsTest.java index 95542a128d..d56c48b82c 100644 --- a/test/unit/org/apache/cassandra/db/compaction/CorruptedSSTablesCompactionsTest.java +++ b/test/unit/org/apache/cassandra/db/compaction/CorruptedSSTablesCompactionsTest.java @@ -32,6 +32,7 @@ import org.junit.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; @@ -71,7 +72,7 @@ public class CorruptedSSTablesCompactionsTest @BeforeClass public static void defineSchema() throws ConfigurationException { - long seed = System.nanoTime(); + long seed = nanoTime(); //long seed = 754271160974509L; // CASSANDRA-9530: use this seed to reproduce compaction failures if reading empty rows //long seed = 2080431860597L; // CASSANDRA-12359: use this seed to reproduce undetected corruptions diff --git a/test/unit/org/apache/cassandra/db/lifecycle/RealTransactionsTest.java b/test/unit/org/apache/cassandra/db/lifecycle/RealTransactionsTest.java index b7b7d4ac6f..01bfaaee7e 100644 --- a/test/unit/org/apache/cassandra/db/lifecycle/RealTransactionsTest.java +++ b/test/unit/org/apache/cassandra/db/lifecycle/RealTransactionsTest.java @@ -47,6 +47,7 @@ import org.apache.cassandra.io.sstable.format.SSTableWriter; import org.apache.cassandra.schema.KeyspaceParams; import org.apache.cassandra.utils.FBUtilities; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; @@ -155,7 +156,7 @@ public class RealTransactionsTest extends SchemaLoader CompactionIterator ci = new CompactionIterator(txn.opType(), scanners.scanners, controller, nowInSec, txn.opId()) ) { - long lastCheckObsoletion = System.nanoTime(); + long lastCheckObsoletion = nanoTime(); File directory = txn.originals().iterator().next().descriptor.directory; Descriptor desc = cfs.newSSTableDescriptor(directory); TableMetadataRef metadata = Schema.instance.getTableMetadataRef(desc); @@ -173,10 +174,10 @@ public class RealTransactionsTest extends SchemaLoader { rewriter.append(ci.next()); - if (System.nanoTime() - lastCheckObsoletion > TimeUnit.MINUTES.toNanos(1L)) + if (nanoTime() - lastCheckObsoletion > TimeUnit.MINUTES.toNanos(1L)) { controller.maybeRefreshOverlaps(); - lastCheckObsoletion = System.nanoTime(); + lastCheckObsoletion = nanoTime(); } } diff --git a/test/unit/org/apache/cassandra/db/monitoring/MonitoringTaskTest.java b/test/unit/org/apache/cassandra/db/monitoring/MonitoringTaskTest.java index dc8c3171d7..dc1f3e9454 100644 --- a/test/unit/org/apache/cassandra/db/monitoring/MonitoringTaskTest.java +++ b/test/unit/org/apache/cassandra/db/monitoring/MonitoringTaskTest.java @@ -22,7 +22,6 @@ import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.List; -import java.util.UUID; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; @@ -32,10 +31,11 @@ import org.junit.After; import org.junit.BeforeClass; import org.junit.Test; -import org.apache.cassandra.utils.ApproximateTime; - +import static java.lang.Thread.currentThread; +import static java.util.UUID.randomUUID; import static java.util.concurrent.TimeUnit.MILLISECONDS; import static java.util.concurrent.TimeUnit.NANOSECONDS; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.apache.cassandra.utils.MonotonicClock.approxTime; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; @@ -98,8 +98,8 @@ public class MonitoringTaskTest long timeout = operations.stream().map(Monitorable::timeoutNanos).reduce(0L, Long::max); Thread.sleep(NANOSECONDS.toMillis(timeout * 2 + approxTime.error())); - long start = System.nanoTime(); - while(System.nanoTime() - start <= MAX_SPIN_TIME_NANOS) + long start = nanoTime(); + while(nanoTime() - start <= MAX_SPIN_TIME_NANOS) { long numInProgress = operations.stream().filter(Monitorable::isInProgress).count(); if (numInProgress == 0) @@ -117,8 +117,8 @@ public class MonitoringTaskTest long timeout = operations.stream().map(Monitorable::slowTimeoutNanos).reduce(0L, Long::max); Thread.sleep(NANOSECONDS.toMillis(timeout * 2 + approxTime.error())); - long start = System.nanoTime(); - while(System.nanoTime() - start <= MAX_SPIN_TIME_NANOS) + long start = nanoTime(); + while(nanoTime() - start <= MAX_SPIN_TIME_NANOS) { long numSlow = operations.stream().filter(Monitorable::isSlow).count(); if (numSlow == operations.size()) @@ -129,7 +129,7 @@ public class MonitoringTaskTest @Test public void testAbort() throws InterruptedException { - Monitorable operation = new TestMonitor("Test abort", System.nanoTime(), false, timeout, slowTimeout); + Monitorable operation = new TestMonitor("Test abort", nanoTime(), false, timeout, slowTimeout); waitForOperationsToComplete(operation); assertTrue(operation.isAborted()); @@ -140,7 +140,7 @@ public class MonitoringTaskTest @Test public void testAbortIdemPotent() throws InterruptedException { - Monitorable operation = new TestMonitor("Test abort", System.nanoTime(), false, timeout, slowTimeout); + Monitorable operation = new TestMonitor("Test abort", nanoTime(), false, timeout, slowTimeout); waitForOperationsToComplete(operation); assertTrue(operation.abort()); @@ -153,7 +153,7 @@ public class MonitoringTaskTest @Test public void testAbortCrossNode() throws InterruptedException { - Monitorable operation = new TestMonitor("Test for cross node", System.nanoTime(), true, timeout, slowTimeout); + Monitorable operation = new TestMonitor("Test for cross node", nanoTime(), true, timeout, slowTimeout); waitForOperationsToComplete(operation); assertTrue(operation.isAborted()); @@ -164,7 +164,7 @@ public class MonitoringTaskTest @Test public void testComplete() throws InterruptedException { - Monitorable operation = new TestMonitor("Test complete", System.nanoTime(), false, timeout, slowTimeout); + Monitorable operation = new TestMonitor("Test complete", nanoTime(), false, timeout, slowTimeout); operation.complete(); waitForOperationsToComplete(operation); @@ -176,7 +176,7 @@ public class MonitoringTaskTest @Test public void testCompleteIdemPotent() throws InterruptedException { - Monitorable operation = new TestMonitor("Test complete", System.nanoTime(), false, timeout, slowTimeout); + Monitorable operation = new TestMonitor("Test complete", nanoTime(), false, timeout, slowTimeout); operation.complete(); waitForOperationsToComplete(operation); @@ -190,7 +190,7 @@ public class MonitoringTaskTest @Test public void testReportSlow() throws InterruptedException { - Monitorable operation = new TestMonitor("Test report slow", System.nanoTime(), false, timeout, slowTimeout); + Monitorable operation = new TestMonitor("Test report slow", nanoTime(), false, timeout, slowTimeout); waitForOperationsToBeReportedAsSlow(operation); assertTrue(operation.isSlow()); @@ -204,7 +204,7 @@ public class MonitoringTaskTest public void testNoReportSlowIfZeroSlowTimeout() throws InterruptedException { // when the slow timeout is set to zero then operation won't be reported as slow - Monitorable operation = new TestMonitor("Test report slow disabled", System.nanoTime(), false, timeout, 0); + Monitorable operation = new TestMonitor("Test report slow disabled", nanoTime(), false, timeout, 0); waitForOperationsToBeReportedAsSlow(operation); assertTrue(operation.isSlow()); @@ -217,7 +217,7 @@ public class MonitoringTaskTest @Test public void testReport() throws InterruptedException { - Monitorable operation = new TestMonitor("Test report", System.nanoTime(), false, timeout, slowTimeout); + Monitorable operation = new TestMonitor("Test report", nanoTime(), false, timeout, slowTimeout); waitForOperationsToComplete(operation); assertTrue(operation.isSlow()); @@ -238,13 +238,13 @@ public class MonitoringTaskTest MonitoringTask.instance = MonitoringTask.make(10, -1); try { - Monitorable operation1 = new TestMonitor("Test report 1", System.nanoTime(), false, timeout, slowTimeout); + Monitorable operation1 = new TestMonitor("Test report 1", nanoTime(), false, timeout, slowTimeout); waitForOperationsToComplete(operation1); assertTrue(operation1.isAborted()); assertFalse(operation1.isCompleted()); - Monitorable operation2 = new TestMonitor("Test report 2", System.nanoTime(), false, timeout, slowTimeout); + Monitorable operation2 = new TestMonitor("Test report 2", nanoTime(), false, timeout, slowTimeout); waitForOperationsToBeReportedAsSlow(operation2); operation2.complete(); @@ -271,7 +271,7 @@ public class MonitoringTaskTest for (int i = 0; i < opCount; i++) { executorService.submit(() -> - operations.add(new TestMonitor(UUID.randomUUID().toString(), System.nanoTime(), false, timeout, slowTimeout)) + operations.add(new TestMonitor(randomUUID().toString(), nanoTime(), false, timeout, slowTimeout)) ); } @@ -316,14 +316,14 @@ public class MonitoringTaskTest for (int j = 0; j < numTimes; j++) { Monitorable operation1 = new TestMonitor(operationName, - System.nanoTime(), + nanoTime(), false, timeout, slowTimeout); waitForOperationsToComplete(operation1); Monitorable operation2 = new TestMonitor(operationName, - System.nanoTime(), + nanoTime(), false, timeout, slowTimeout); @@ -371,7 +371,7 @@ public class MonitoringTaskTest try { Monitorable operation = new TestMonitor("Test testMultipleThreadsSameName failed", - System.nanoTime(), + nanoTime(), false, timeout, slowTimeout); @@ -405,7 +405,7 @@ public class MonitoringTaskTest try { Monitorable operation = new TestMonitor("Test testMultipleThreadsSameName slow", - System.nanoTime(), + nanoTime(), false, timeout, slowTimeout); @@ -440,8 +440,8 @@ public class MonitoringTaskTest executorService.submit(() -> { try { - Monitorable operation = new TestMonitor("Test thread " + Thread.currentThread().getName(), - System.nanoTime(), + Monitorable operation = new TestMonitor("Test thread " + currentThread().getName(), + nanoTime(), false, timeout, slowTimeout); diff --git a/test/unit/org/apache/cassandra/io/sstable/IndexSummaryTest.java b/test/unit/org/apache/cassandra/io/sstable/IndexSummaryTest.java index 01cd0dd9fb..1318227bf4 100644 --- a/test/unit/org/apache/cassandra/io/sstable/IndexSummaryTest.java +++ b/test/unit/org/apache/cassandra/io/sstable/IndexSummaryTest.java @@ -42,6 +42,7 @@ import org.apache.cassandra.utils.Pair; import static org.apache.cassandra.io.sstable.IndexSummaryBuilder.downsample; import static org.apache.cassandra.io.sstable.IndexSummaryBuilder.entriesAtSamplingLevel; import static org.apache.cassandra.io.sstable.Downsampling.BASE_SAMPLING_LEVEL; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.junit.Assert.*; public class IndexSummaryTest @@ -53,7 +54,7 @@ public class IndexSummaryTest { DatabaseDescriptor.daemonInitialization(); - final long seed = System.nanoTime(); + final long seed = nanoTime(); System.out.println("Using seed: " + seed); random.setSeed(seed); } @@ -63,7 +64,7 @@ public class IndexSummaryTest @BeforeClass public static void setup() { - final long seed = System.nanoTime(); + final long seed = nanoTime(); System.out.println("Using seed: " + seed); random.setSeed(seed); } diff --git a/test/unit/org/apache/cassandra/io/sstable/SSTableCorruptionDetectionTest.java b/test/unit/org/apache/cassandra/io/sstable/SSTableCorruptionDetectionTest.java index 2510c5e8a4..c4e5207acc 100644 --- a/test/unit/org/apache/cassandra/io/sstable/SSTableCorruptionDetectionTest.java +++ b/test/unit/org/apache/cassandra/io/sstable/SSTableCorruptionDetectionTest.java @@ -47,6 +47,7 @@ import org.apache.cassandra.io.sstable.format.SSTableWriter; import org.apache.cassandra.io.util.*; import org.apache.cassandra.schema.*; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; @@ -95,7 +96,7 @@ public class SSTableCorruptionDetectionTest extends SSTableWriterTestBase maxValueSize = DatabaseDescriptor.getMaxValueSize(); DatabaseDescriptor.setMaxValueSize(1024 * 1024); - long seed = System.nanoTime(); + long seed = nanoTime(); logger.info("Seed {}", seed); random = new Random(seed); diff --git a/test/unit/org/apache/cassandra/io/util/BufferedDataOutputStreamTest.java b/test/unit/org/apache/cassandra/io/util/BufferedDataOutputStreamTest.java index c5c3b6066b..66f506ddab 100644 --- a/test/unit/org/apache/cassandra/io/util/BufferedDataOutputStreamTest.java +++ b/test/unit/org/apache/cassandra/io/util/BufferedDataOutputStreamTest.java @@ -44,6 +44,7 @@ import com.google.common.primitives.UnsignedBytes; import com.google.common.primitives.UnsignedInteger; import com.google.common.primitives.UnsignedLong; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.apache.cassandra.utils.FBUtilities.preventIllegalAccessWarnings; import static org.junit.Assert.*; @@ -171,7 +172,7 @@ public class BufferedDataOutputStreamTest static Field baos_bytes; static { - long seed = System.nanoTime(); + long seed = nanoTime(); //seed = 210187780999648L; System.out.println("Seed " + seed); r = new Random(seed); diff --git a/test/unit/org/apache/cassandra/io/util/FileSegmentInputStreamTest.java b/test/unit/org/apache/cassandra/io/util/FileSegmentInputStreamTest.java index b040d27a08..0f72e33760 100644 --- a/test/unit/org/apache/cassandra/io/util/FileSegmentInputStreamTest.java +++ b/test/unit/org/apache/cassandra/io/util/FileSegmentInputStreamTest.java @@ -29,6 +29,7 @@ import org.junit.Test; import org.apache.cassandra.utils.ByteBufferUtil; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; @@ -38,7 +39,7 @@ public class FileSegmentInputStreamTest private ByteBuffer allocateBuffer(int size) { ByteBuffer ret = ByteBuffer.allocate(Ints.checkedCast(size)); - long seed = System.nanoTime(); + long seed = nanoTime(); //seed = 365238103404423L; System.out.println("Seed " + seed); diff --git a/test/unit/org/apache/cassandra/io/util/MmappedRegionsTest.java b/test/unit/org/apache/cassandra/io/util/MmappedRegionsTest.java index 2814bab6ec..400bea92b2 100644 --- a/test/unit/org/apache/cassandra/io/util/MmappedRegionsTest.java +++ b/test/unit/org/apache/cassandra/io/util/MmappedRegionsTest.java @@ -39,6 +39,7 @@ import org.apache.cassandra.io.sstable.metadata.MetadataCollector; import org.apache.cassandra.schema.CompressionParams; import static junit.framework.Assert.assertNull; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotNull; @@ -57,7 +58,7 @@ public class MmappedRegionsTest private static ByteBuffer allocateBuffer(int size) { ByteBuffer ret = ByteBuffer.allocate(Ints.checkedCast(size)); - long seed = System.nanoTime(); + long seed = nanoTime(); //seed = 365238103404423L; logger.info("Seed {}", seed); diff --git a/test/unit/org/apache/cassandra/io/util/NIODataInputStreamTest.java b/test/unit/org/apache/cassandra/io/util/NIODataInputStreamTest.java index 829cfcff2a..eba6d8d4fd 100644 --- a/test/unit/org/apache/cassandra/io/util/NIODataInputStreamTest.java +++ b/test/unit/org/apache/cassandra/io/util/NIODataInputStreamTest.java @@ -41,6 +41,7 @@ import com.google.common.primitives.UnsignedBytes; import com.google.common.primitives.UnsignedInteger; import com.google.common.primitives.UnsignedLong; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.junit.Assert.*; public class NIODataInputStreamTest @@ -51,7 +52,7 @@ public class NIODataInputStreamTest void init() { - long seed = System.nanoTime(); + long seed = nanoTime(); //seed = 365238103404423L; System.out.println("Seed " + seed); r = new Random(seed); diff --git a/test/unit/org/apache/cassandra/io/util/RandomAccessReaderTest.java b/test/unit/org/apache/cassandra/io/util/RandomAccessReaderTest.java index 8904daab29..0d86f0baa8 100644 --- a/test/unit/org/apache/cassandra/io/util/RandomAccessReaderTest.java +++ b/test/unit/org/apache/cassandra/io/util/RandomAccessReaderTest.java @@ -43,6 +43,7 @@ import org.junit.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.junit.Assert.*; import org.apache.cassandra.config.DatabaseDescriptor; @@ -428,7 +429,7 @@ public class RandomAccessReaderTest final File f = FileUtils.createTempFile("testMark", "1"); final byte[] expected = new byte[1 << 16]; - long seed = System.nanoTime(); + long seed = nanoTime(); //seed = 365238103404423L; logger.info("Seed {}", seed); Random r = new Random(seed); diff --git a/test/unit/org/apache/cassandra/locator/TokenMetadataTest.java b/test/unit/org/apache/cassandra/locator/TokenMetadataTest.java index 06ce83cf95..c1b76b3bfc 100644 --- a/test/unit/org/apache/cassandra/locator/TokenMetadataTest.java +++ b/test/unit/org/apache/cassandra/locator/TokenMetadataTest.java @@ -64,7 +64,7 @@ public class TokenMetadataTest @Before public void before() throws Throwable { - tmd = StorageService.instance.getTokenMetadata(); + tmd = new TokenMetadata(); tmd.updateNormalToken(token(ONE), InetAddressAndPort.getByName("127.0.0.1")); tmd.updateNormalToken(token(SIX), InetAddressAndPort.getByName("127.0.0.6")); } diff --git a/test/unit/org/apache/cassandra/metrics/DecayingEstimatedHistogramReservoirTest.java b/test/unit/org/apache/cassandra/metrics/DecayingEstimatedHistogramReservoirTest.java index b62078ce5c..8959046896 100644 --- a/test/unit/org/apache/cassandra/metrics/DecayingEstimatedHistogramReservoirTest.java +++ b/test/unit/org/apache/cassandra/metrics/DecayingEstimatedHistogramReservoirTest.java @@ -37,6 +37,7 @@ import org.apache.cassandra.utils.EstimatedHistogram; import org.apache.cassandra.utils.Pair; import org.quicktheories.core.Gen; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; @@ -143,7 +144,7 @@ public class DecayingEstimatedHistogramReservoirTest nStripes, clock); - long seed = System.nanoTime(); + long seed = nanoTime(); System.out.println("DecayingEstimatedHistogramReservoirTest#testStriping.seed = " + seed); Random valGen = new Random(seed); ExecutorService executors = Executors.newFixedThreadPool(nStripes * 2); diff --git a/test/unit/org/apache/cassandra/net/AsyncOneResponseTest.java b/test/unit/org/apache/cassandra/net/AsyncOneResponseTest.java index 3d0508cc07..1ffcdef076 100644 --- a/test/unit/org/apache/cassandra/net/AsyncOneResponseTest.java +++ b/test/unit/org/apache/cassandra/net/AsyncOneResponseTest.java @@ -23,6 +23,7 @@ import java.util.concurrent.TimeUnit; import org.junit.Assert; import org.junit.Test; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.junit.Assert.assertTrue; public class AsyncOneResponseTest @@ -43,9 +44,9 @@ public class AsyncOneResponseTest final long expectedTimeoutMillis = 1000; // Should time out after roughly this time final long schedulingError = 10; // Scheduling is imperfect - long startTime = System.nanoTime(); + long startTime = nanoTime(); boolean timeout = !response.await(expectedTimeoutMillis, TimeUnit.MILLISECONDS); - long endTime = System.nanoTime(); + long endTime = nanoTime(); assertTrue(timeout); assertTrue(TimeUnit.NANOSECONDS.toMillis(endTime - startTime) > (expectedTimeoutMillis - schedulingError)); diff --git a/test/unit/org/apache/cassandra/net/AsyncStreamingInputPlusTest.java b/test/unit/org/apache/cassandra/net/AsyncStreamingInputPlusTest.java index b575747417..bc41992ae7 100644 --- a/test/unit/org/apache/cassandra/net/AsyncStreamingInputPlusTest.java +++ b/test/unit/org/apache/cassandra/net/AsyncStreamingInputPlusTest.java @@ -36,6 +36,7 @@ import org.apache.cassandra.io.util.BufferedDataOutputStreamPlus; import org.apache.cassandra.net.AsyncStreamingInputPlus; import org.apache.cassandra.net.AsyncStreamingInputPlus.InputTimeoutException; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.junit.Assert.assertFalse; public class AsyncStreamingInputPlusTest @@ -263,7 +264,7 @@ public class AsyncStreamingInputPlusTest long timeoutMillis = 1000; inputPlus = new AsyncStreamingInputPlus(channel, timeoutMillis, TimeUnit.MILLISECONDS); - long startNanos = System.nanoTime(); + long startNanos = nanoTime(); try { inputPlus.readInt(); @@ -274,7 +275,7 @@ public class AsyncStreamingInputPlusTest // this is the success case, and is expected. any other exception is a failure. } - long durationNanos = System.nanoTime() - startNanos; + long durationNanos = nanoTime() - startNanos; Assert.assertTrue(TimeUnit.MILLISECONDS.toNanos(timeoutMillis) <= durationNanos); } } diff --git a/test/unit/org/apache/cassandra/net/ConnectionTest.java b/test/unit/org/apache/cassandra/net/ConnectionTest.java index 5c637ace9f..7abdcec772 100644 --- a/test/unit/org/apache/cassandra/net/ConnectionTest.java +++ b/test/unit/org/apache/cassandra/net/ConnectionTest.java @@ -68,6 +68,7 @@ import org.apache.cassandra.io.util.DataOutputPlus; import org.apache.cassandra.locator.InetAddressAndPort; import org.apache.cassandra.utils.FBUtilities; +import static java.util.concurrent.TimeUnit.MILLISECONDS; import static java.util.concurrent.TimeUnit.MINUTES; import static java.util.concurrent.TimeUnit.SECONDS; import static org.apache.cassandra.net.MessagingService.VERSION_30; @@ -80,6 +81,7 @@ import static org.apache.cassandra.net.ConnectionType.LARGE_MESSAGES; import static org.apache.cassandra.net.ConnectionType.SMALL_MESSAGES; import static org.apache.cassandra.net.OutboundConnectionSettings.Framing.LZ4; import static org.apache.cassandra.net.OutboundConnections.LARGE_MESSAGE_THRESHOLD; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.apache.cassandra.utils.MonotonicClock.approxTime; public class ConnectionTest @@ -336,7 +338,7 @@ public class ConnectionTest }); unsafeSetHandler(Verb._TEST_1, () -> msg -> receiveDone.countDown()); Message message = Message.builder(Verb._TEST_1, new Object()) - .withExpiresAt(System.nanoTime() + SECONDS.toNanos(30L)) + .withExpiresAt(nanoTime() + SECONDS.toNanos(30L)) .build(); for (int i = 0 ; i < count ; ++i) outbound.enqueue(message); @@ -444,7 +446,7 @@ public class ConnectionTest AtomicInteger serialized = new AtomicInteger(); Message message = Message.builder(Verb._TEST_1, new Object()) - .withExpiresAt(System.nanoTime() + SECONDS.toNanos(30L)) + .withExpiresAt(nanoTime() + SECONDS.toNanos(30L)) .build(); unsafeSetSerializer(Verb._TEST_1, () -> new IVersionedSerializer() { @@ -663,7 +665,7 @@ public class ConnectionTest { testManual((settings, inbound, outbound, endpoint) -> { Message message = Message.builder(Verb._TEST_1, noPayload) - .withExpiresAt(System.nanoTime() + SECONDS.toNanos(30L)) + .withExpiresAt(nanoTime() + SECONDS.toNanos(30L)) .build(); for (int i = 0 ; i < 1000 ; ++i) @@ -683,12 +685,12 @@ public class ConnectionTest for (int i = 0; i < 5; i++) { Message message = Message.builder(Verb._TEST_1, noPayload) - .withExpiresAt(System.nanoTime() + TimeUnit.MILLISECONDS.toNanos(50L)) + .withExpiresAt(nanoTime() + MILLISECONDS.toNanos(50L)) .build(); OutboundMessageQueue queue = outbound.queue; while (true) { - try (OutboundMessageQueue.WithLock withLock = queue.lockOrCallback(System.nanoTime(), null)) + try (OutboundMessageQueue.WithLock withLock = queue.lockOrCallback(nanoTime(), null)) { if (withLock != null) { diff --git a/test/unit/org/apache/cassandra/service/PaxosStateTest.java b/test/unit/org/apache/cassandra/service/PaxosStateTest.java index 7d69223d98..0329ccf881 100644 --- a/test/unit/org/apache/cassandra/service/PaxosStateTest.java +++ b/test/unit/org/apache/cassandra/service/PaxosStateTest.java @@ -39,6 +39,7 @@ import org.apache.cassandra.utils.ByteBufferUtil; import org.apache.cassandra.utils.FBUtilities; import org.apache.cassandra.utils.UUIDGen; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.junit.Assert.*; public class PaxosStateTest @@ -60,7 +61,7 @@ public class PaxosStateTest public void testCommittingAfterTruncation() throws Exception { ColumnFamilyStore cfs = Keyspace.open("PaxosStateTestKeyspace1").getColumnFamilyStore("Standard1"); - String key = "key" + System.nanoTime(); + String key = "key" + nanoTime(); ByteBuffer value = ByteBufferUtil.bytes(0); RowUpdateBuilder builder = new RowUpdateBuilder(cfs.metadata(), FBUtilities.timestampMicros(), key); builder.clustering("a").add("val", value); @@ -108,7 +109,7 @@ public class PaxosStateTest public void testPrepareProposePaxos() throws Throwable { ColumnFamilyStore cfs = Keyspace.open("PaxosStateTestKeyspace1").getColumnFamilyStore("Standard1"); - String key = "key" + System.nanoTime(); + String key = "key" + nanoTime(); ByteBuffer value = ByteBufferUtil.bytes(0); RowUpdateBuilder builder = new RowUpdateBuilder(cfs.metadata(), FBUtilities.timestampMicros(), key); builder.clustering("a").add("val", value); diff --git a/test/unit/org/apache/cassandra/service/WriteResponseHandlerTest.java b/test/unit/org/apache/cassandra/service/WriteResponseHandlerTest.java index 5d8d19107a..837cf1bb57 100644 --- a/test/unit/org/apache/cassandra/service/WriteResponseHandlerTest.java +++ b/test/unit/org/apache/cassandra/service/WriteResponseHandlerTest.java @@ -49,7 +49,9 @@ import org.apache.cassandra.net.Verb; import org.apache.cassandra.schema.KeyspaceParams; import org.apache.cassandra.utils.ByteBufferUtil; +import static java.util.concurrent.TimeUnit.DAYS; import static org.apache.cassandra.net.NoPayload.noPayload; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; @@ -145,7 +147,7 @@ public class WriteResponseHandlerTest { long startingCount = ks.metric.idealCLWriteLatency.latency.getCount(); //Specify query start time in past to ensure minimum latency measurement - AbstractWriteResponseHandler awr = createWriteResponseHandler(ConsistencyLevel.LOCAL_QUORUM, ConsistencyLevel.EACH_QUORUM, System.nanoTime() - TimeUnit.DAYS.toNanos(1)); + AbstractWriteResponseHandler awr = createWriteResponseHandler(ConsistencyLevel.LOCAL_QUORUM, ConsistencyLevel.EACH_QUORUM, nanoTime() - DAYS.toNanos(1)); //dc1 awr.onResponse(createDummyMessage(0)); @@ -260,7 +262,7 @@ public class WriteResponseHandlerTest private static AbstractWriteResponseHandler createWriteResponseHandler(ConsistencyLevel cl, ConsistencyLevel ideal) { - return createWriteResponseHandler(cl, ideal, System.nanoTime()); + return createWriteResponseHandler(cl, ideal, nanoTime()); } private static AbstractWriteResponseHandler createWriteResponseHandler(ConsistencyLevel cl, ConsistencyLevel ideal, long queryStartTime) diff --git a/test/unit/org/apache/cassandra/service/reads/DataResolverTest.java b/test/unit/org/apache/cassandra/service/reads/DataResolverTest.java index 900a40f0da..593e3e483c 100644 --- a/test/unit/org/apache/cassandra/service/reads/DataResolverTest.java +++ b/test/unit/org/apache/cassandra/service/reads/DataResolverTest.java @@ -76,6 +76,8 @@ import static org.apache.cassandra.Util.assertClustering; import static org.apache.cassandra.Util.assertColumn; import static org.apache.cassandra.Util.assertColumns; import static org.apache.cassandra.db.ClusteringBound.Kind; +import static org.apache.cassandra.db.ConsistencyLevel.ALL; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotNull; @@ -131,7 +133,7 @@ public class DataResolverTest extends AbstractReadResponseTest public void testResolveNewerSingleRow() { EndpointsForRange replicas = makeReplicas(2); - DataResolver resolver = new DataResolver(command, plan(replicas, ConsistencyLevel.ALL), readRepair, System.nanoTime()); + DataResolver resolver = new DataResolver(command, plan(replicas, ALL), readRepair, nanoTime()); InetAddressAndPort peer1 = replicas.get(0).endpoint(); resolver.preprocess(response(command, peer1, iter(new RowUpdateBuilder(cfm, nowInSec, 0L, dk).clustering("1") .add("c1", "v1") @@ -163,7 +165,7 @@ public class DataResolverTest extends AbstractReadResponseTest public void testResolveDisjointSingleRow() { EndpointsForRange replicas = makeReplicas(2); - DataResolver resolver = new DataResolver(command, plan(replicas, ConsistencyLevel.ALL), readRepair, System.nanoTime()); + DataResolver resolver = new DataResolver(command, plan(replicas, ALL), readRepair, nanoTime()); InetAddressAndPort peer1 = replicas.get(0).endpoint(); resolver.preprocess(response(command, peer1, iter(new RowUpdateBuilder(cfm, nowInSec, 0L, dk).clustering("1") .add("c1", "v1") @@ -200,7 +202,7 @@ public class DataResolverTest extends AbstractReadResponseTest public void testResolveDisjointMultipleRows() throws UnknownHostException { EndpointsForRange replicas = makeReplicas(2); - DataResolver resolver = new DataResolver(command, plan(replicas, ConsistencyLevel.ALL), readRepair, System.nanoTime()); + DataResolver resolver = new DataResolver(command, plan(replicas, ALL), readRepair, nanoTime()); InetAddressAndPort peer1 = replicas.get(0).endpoint(); resolver.preprocess(response(command, peer1, iter(new RowUpdateBuilder(cfm, nowInSec, 0L, dk).clustering("1") .add("c1", "v1") @@ -247,7 +249,7 @@ public class DataResolverTest extends AbstractReadResponseTest public void testResolveDisjointMultipleRowsWithRangeTombstones() { EndpointsForRange replicas = makeReplicas(4); - DataResolver resolver = new DataResolver(command, plan(replicas, ConsistencyLevel.ALL), readRepair, System.nanoTime()); + DataResolver resolver = new DataResolver(command, plan(replicas, ALL), readRepair, nanoTime()); RangeTombstone tombstone1 = tombstone("1", "11", 1, nowInSec); RangeTombstone tombstone2 = tombstone("3", "31", 1, nowInSec); @@ -328,7 +330,7 @@ public class DataResolverTest extends AbstractReadResponseTest public void testResolveWithOneEmpty() { EndpointsForRange replicas = makeReplicas(2); - DataResolver resolver = new DataResolver(command, plan(replicas, ConsistencyLevel.ALL), readRepair, System.nanoTime()); + DataResolver resolver = new DataResolver(command, plan(replicas, ALL), readRepair, nanoTime()); InetAddressAndPort peer1 = replicas.get(0).endpoint(); resolver.preprocess(response(command, peer1, iter(new RowUpdateBuilder(cfm, nowInSec, 1L, dk).clustering("1") .add("c2", "v2") @@ -359,7 +361,7 @@ public class DataResolverTest extends AbstractReadResponseTest { EndpointsForRange replicas = makeReplicas(2); TestableReadRepair readRepair = new TestableReadRepair(command); - DataResolver resolver = new DataResolver(command, plan(replicas, ConsistencyLevel.ALL), readRepair, System.nanoTime()); + DataResolver resolver = new DataResolver(command, plan(replicas, ALL), readRepair, nanoTime()); resolver.preprocess(response(command, replicas.get(0).endpoint(), EmptyIterators.unfilteredPartition(cfm))); resolver.preprocess(response(command, replicas.get(1).endpoint(), EmptyIterators.unfilteredPartition(cfm))); @@ -375,7 +377,7 @@ public class DataResolverTest extends AbstractReadResponseTest public void testResolveDeleted() { EndpointsForRange replicas = makeReplicas(2); - DataResolver resolver = new DataResolver(command, plan(replicas, ConsistencyLevel.ALL), readRepair, System.nanoTime()); + DataResolver resolver = new DataResolver(command, plan(replicas, ALL), readRepair, nanoTime()); // one response with columns timestamped before a delete in another response InetAddressAndPort peer1 = replicas.get(0).endpoint(); resolver.preprocess(response(command, peer1, iter(new RowUpdateBuilder(cfm, nowInSec, 0L, dk).clustering("1") @@ -401,7 +403,7 @@ public class DataResolverTest extends AbstractReadResponseTest public void testResolveMultipleDeleted() { EndpointsForRange replicas = makeReplicas(4); - DataResolver resolver = new DataResolver(command, plan(replicas, ConsistencyLevel.ALL), readRepair, System.nanoTime()); + DataResolver resolver = new DataResolver(command, plan(replicas, ALL), readRepair, nanoTime()); // deletes and columns with interleaved timestamp, with out of order return sequence InetAddressAndPort peer1 = replicas.get(0).endpoint(); resolver.preprocess(response(command, peer1, fullPartitionDelete(cfm, dk, 0, nowInSec))); @@ -486,7 +488,7 @@ public class DataResolverTest extends AbstractReadResponseTest private void resolveRangeTombstonesOnBoundary(long timestamp1, long timestamp2) { EndpointsForRange replicas = makeReplicas(2); - DataResolver resolver = new DataResolver(command, plan(replicas, ConsistencyLevel.ALL), readRepair, System.nanoTime()); + DataResolver resolver = new DataResolver(command, plan(replicas, ALL), readRepair, nanoTime()); InetAddressAndPort peer1 = replicas.get(0).endpoint(); InetAddressAndPort peer2 = replicas.get(1).endpoint(); @@ -560,7 +562,7 @@ public class DataResolverTest extends AbstractReadResponseTest private void testRepairRangeTombstoneBoundary(int timestamp1, int timestamp2, int timestamp3) throws UnknownHostException { EndpointsForRange replicas = makeReplicas(2); - DataResolver resolver = new DataResolver(command, plan(replicas, ConsistencyLevel.ALL), readRepair, System.nanoTime()); + DataResolver resolver = new DataResolver(command, plan(replicas, ALL), readRepair, nanoTime()); InetAddressAndPort peer1 = replicas.get(0).endpoint(); InetAddressAndPort peer2 = replicas.get(1).endpoint(); @@ -613,7 +615,7 @@ public class DataResolverTest extends AbstractReadResponseTest { EndpointsForRange replicas = makeReplicas(2); - DataResolver resolver = new DataResolver(command, plan(replicas, ConsistencyLevel.ALL), readRepair, System.nanoTime()); + DataResolver resolver = new DataResolver(command, plan(replicas, ALL), readRepair, nanoTime()); InetAddressAndPort peer1 = replicas.get(0).endpoint(); InetAddressAndPort peer2 = replicas.get(1).endpoint(); @@ -652,7 +654,7 @@ public class DataResolverTest extends AbstractReadResponseTest public void testRepairRangeTombstoneWithPartitionDeletion2() { EndpointsForRange replicas = makeReplicas(2); - DataResolver resolver = new DataResolver(command, plan(replicas, ConsistencyLevel.ALL), readRepair, System.nanoTime()); + DataResolver resolver = new DataResolver(command, plan(replicas, ALL), readRepair, nanoTime()); InetAddressAndPort peer1 = replicas.get(0).endpoint(); InetAddressAndPort peer2 = replicas.get(1).endpoint(); @@ -736,7 +738,7 @@ public class DataResolverTest extends AbstractReadResponseTest EndpointsForRange replicas = makeReplicas(2); ReadCommand cmd = Util.cmd(cfs2, dk).withNowInSeconds(nowInSec).build(); TestableReadRepair readRepair = new TestableReadRepair(cmd); - DataResolver resolver = new DataResolver(cmd, plan(replicas, ConsistencyLevel.ALL), readRepair, System.nanoTime()); + DataResolver resolver = new DataResolver(cmd, plan(replicas, ALL), readRepair, nanoTime()); long[] ts = {100, 200}; @@ -788,7 +790,7 @@ public class DataResolverTest extends AbstractReadResponseTest EndpointsForRange replicas = makeReplicas(2); ReadCommand cmd = Util.cmd(cfs2, dk).withNowInSeconds(nowInSec).build(); TestableReadRepair readRepair = new TestableReadRepair(cmd); - DataResolver resolver = new DataResolver(cmd, plan(replicas, ConsistencyLevel.ALL), readRepair, System.nanoTime()); + DataResolver resolver = new DataResolver(cmd, plan(replicas, ALL), readRepair, nanoTime()); long[] ts = {100, 200}; @@ -832,7 +834,7 @@ public class DataResolverTest extends AbstractReadResponseTest EndpointsForRange replicas = makeReplicas(2); ReadCommand cmd = Util.cmd(cfs2, dk).withNowInSeconds(nowInSec).build(); TestableReadRepair readRepair = new TestableReadRepair(cmd); - DataResolver resolver = new DataResolver(cmd, plan(replicas, ConsistencyLevel.ALL), readRepair, System.nanoTime()); + DataResolver resolver = new DataResolver(cmd, plan(replicas, ALL), readRepair, nanoTime()); long[] ts = {100, 200}; @@ -882,7 +884,7 @@ public class DataResolverTest extends AbstractReadResponseTest EndpointsForRange replicas = makeReplicas(2); ReadCommand cmd = Util.cmd(cfs2, dk).withNowInSeconds(nowInSec).build(); TestableReadRepair readRepair = new TestableReadRepair(cmd); - DataResolver resolver = new DataResolver(cmd, plan(replicas, ConsistencyLevel.ALL), readRepair, System.nanoTime()); + DataResolver resolver = new DataResolver(cmd, plan(replicas, ALL), readRepair, nanoTime()); long[] ts = {100, 200}; @@ -938,7 +940,7 @@ public class DataResolverTest extends AbstractReadResponseTest verifier.expectDigest(peer1, digest1, true); verifier.expectDigest(peer2, digest1, true); - DataResolver resolver = resolverWithVerifier(command, plan(replicas, ConsistencyLevel.ALL), readRepair, System.nanoTime(), verifier); + DataResolver resolver = resolverWithVerifier(command, plan(replicas, ALL), readRepair, nanoTime(), verifier); resolver.preprocess(response(peer1, iter(PartitionUpdate.emptyUpdate(cfm, dk)), digest1, true, command)); resolver.preprocess(response(peer2, iter(PartitionUpdate.emptyUpdate(cfm, dk)), digest1, true, command)); @@ -958,7 +960,7 @@ public class DataResolverTest extends AbstractReadResponseTest verifier.expectDigest(peer1, digest1, false); verifier.expectDigest(peer2, digest1, true); - DataResolver resolver = resolverWithVerifier(command, plan(replicas, ConsistencyLevel.ALL), readRepair, System.nanoTime(), verifier); + DataResolver resolver = resolverWithVerifier(command, plan(replicas, ALL), readRepair, nanoTime(), verifier); resolver.preprocess(response(peer1, iter(PartitionUpdate.emptyUpdate(cfm, dk)), digest1, false, command)); resolver.preprocess(response(peer2, iter(PartitionUpdate.emptyUpdate(cfm, dk)), digest1, true, command)); @@ -978,7 +980,7 @@ public class DataResolverTest extends AbstractReadResponseTest verifier.expectDigest(peer1, digest1, false); verifier.expectDigest(peer2, digest1, false); - DataResolver resolver = resolverWithVerifier(command, plan(replicas, ConsistencyLevel.ALL), readRepair, System.nanoTime(), verifier); + DataResolver resolver = resolverWithVerifier(command, plan(replicas, ALL), readRepair, nanoTime(), verifier); resolver.preprocess(response(peer1, iter(PartitionUpdate.emptyUpdate(cfm, dk)), digest1, false, command)); resolver.preprocess(response(peer2, iter(PartitionUpdate.emptyUpdate(cfm, dk)), digest1, false, command)); @@ -998,7 +1000,7 @@ public class DataResolverTest extends AbstractReadResponseTest verifier.expectDigest(peer1, digest1, true); verifier.expectDigest(peer2, digest1, true); - DataResolver resolver = resolverWithVerifier(command, plan(replicas, ConsistencyLevel.ALL), readRepair, System.nanoTime(), verifier); + DataResolver resolver = resolverWithVerifier(command, plan(replicas, ALL), readRepair, nanoTime(), verifier); resolver.preprocess(response(peer1, iter(PartitionUpdate.emptyUpdate(cfm,dk)), digest1, true, command)); resolver.preprocess(response(peer2, iter(PartitionUpdate.emptyUpdate(cfm, dk)), digest1, true, command)); @@ -1018,7 +1020,7 @@ public class DataResolverTest extends AbstractReadResponseTest verifier.expectDigest(peer1, digest1, true); verifier.expectDigest(peer2, digest1, false); - DataResolver resolver = resolverWithVerifier(command, plan(replicas, ConsistencyLevel.ALL), readRepair, System.nanoTime(), verifier); + DataResolver resolver = resolverWithVerifier(command, plan(replicas, ALL), readRepair, nanoTime(), verifier); resolver.preprocess(response(peer1, iter(PartitionUpdate.emptyUpdate(cfm,dk)), digest1, true, command)); resolver.preprocess(response(peer2, iter(PartitionUpdate.emptyUpdate(cfm, dk)), digest1, false, command)); @@ -1038,7 +1040,7 @@ public class DataResolverTest extends AbstractReadResponseTest verifier.expectDigest(peer1, digest1, false); verifier.expectDigest(peer2, digest1, false); - DataResolver resolver = resolverWithVerifier(command, plan(replicas, ConsistencyLevel.ALL), readRepair, System.nanoTime(), verifier); + DataResolver resolver = resolverWithVerifier(command, plan(replicas, ALL), readRepair, nanoTime(), verifier); resolver.preprocess(response(peer1, iter(PartitionUpdate.emptyUpdate(cfm, dk)), digest1, false, command)); resolver.preprocess(response(peer2, iter(PartitionUpdate.emptyUpdate(cfm, dk)), digest1, false, command)); @@ -1059,7 +1061,7 @@ public class DataResolverTest extends AbstractReadResponseTest verifier.expectDigest(peer1, digest1, true); verifier.expectDigest(peer2, digest1, true); - DataResolver resolver = resolverWithVerifier(command, plan(replicas, ConsistencyLevel.ALL), readRepair, System.nanoTime(), verifier); + DataResolver resolver = resolverWithVerifier(command, plan(replicas, ALL), readRepair, nanoTime(), verifier); resolver.preprocess(response(peer1, iter(new RowUpdateBuilder(cfm, nowInSec, 1L, dk).clustering("1") .buildUpdate()), digest1, true, command)); resolver.preprocess(response(peer2, iter(PartitionUpdate.emptyUpdate(cfm, dk)), digest1, true, command)); @@ -1080,7 +1082,7 @@ public class DataResolverTest extends AbstractReadResponseTest verifier.expectDigest(peer1, digest1, true); verifier.expectDigest(peer2, digest2, true); - DataResolver resolver = resolverWithVerifier(command, plan(replicas, ConsistencyLevel.ALL), readRepair, System.nanoTime(), verifier); + DataResolver resolver = resolverWithVerifier(command, plan(replicas, ALL), readRepair, nanoTime(), verifier); resolver.preprocess(response(peer1, iter(PartitionUpdate.emptyUpdate(cfm, dk)), digest1, true, command)); resolver.preprocess(response(peer2, iter(PartitionUpdate.emptyUpdate(cfm, dk)), digest2, true, command)); @@ -1101,7 +1103,7 @@ public class DataResolverTest extends AbstractReadResponseTest verifier.expectDigest(peer1, digest1, false); verifier.expectDigest(peer2, digest2, true); - DataResolver resolver = resolverWithVerifier(command, plan(replicas, ConsistencyLevel.ALL), readRepair, System.nanoTime(), verifier); + DataResolver resolver = resolverWithVerifier(command, plan(replicas, ALL), readRepair, nanoTime(), verifier); resolver.preprocess(response(peer1, iter(PartitionUpdate.emptyUpdate(cfm, dk)), digest1, false, command)); resolver.preprocess(response(peer2, iter(PartitionUpdate.emptyUpdate(cfm, dk)), digest2, true, command)); @@ -1122,7 +1124,7 @@ public class DataResolverTest extends AbstractReadResponseTest verifier.expectDigest(peer1, digest1, false); verifier.expectDigest(peer2, digest2, false); - DataResolver resolver = resolverWithVerifier(command, plan(replicas, ConsistencyLevel.ALL), readRepair, System.nanoTime(), verifier); + DataResolver resolver = resolverWithVerifier(command, plan(replicas, ALL), readRepair, nanoTime(), verifier); resolver.preprocess(response(peer1, iter(PartitionUpdate.emptyUpdate(cfm, dk)), digest1, false, command)); resolver.preprocess(response(peer2, iter(PartitionUpdate.emptyUpdate(cfm, dk)), digest2, false, command)); @@ -1143,7 +1145,7 @@ public class DataResolverTest extends AbstractReadResponseTest verifier.expectDigest(peer1, digest1, true); verifier.expectDigest(peer2, digest2, true); - DataResolver resolver = resolverWithVerifier(command, plan(replicas, ConsistencyLevel.ALL), readRepair, System.nanoTime(), verifier); + DataResolver resolver = resolverWithVerifier(command, plan(replicas, ALL), readRepair, nanoTime(), verifier); resolver.preprocess(response(peer1, iter(new RowUpdateBuilder(cfm, nowInSec, 1L, dk).clustering("1") .buildUpdate()), digest1, true, command)); resolver.preprocess(response(peer2, iter(PartitionUpdate.emptyUpdate(cfm, dk)), digest2, true, command)); @@ -1163,7 +1165,7 @@ public class DataResolverTest extends AbstractReadResponseTest TestRepairedDataVerifier verifier = new TestRepairedDataVerifier(); verifier.expectDigest(peer1, digest1, true); - DataResolver resolver = resolverWithVerifier(command, plan(replicas, ConsistencyLevel.ALL), readRepair, System.nanoTime(), verifier); + DataResolver resolver = resolverWithVerifier(command, plan(replicas, ALL), readRepair, nanoTime(), verifier); resolver.preprocess(response(peer1, iter(PartitionUpdate.emptyUpdate(cfm,dk)), digest1, true, command)); @@ -1185,7 +1187,7 @@ public class DataResolverTest extends AbstractReadResponseTest InetAddressAndPort peer2 = replicas.get(1).endpoint(); verifier.expectDigest(peer1, digest1, true); - DataResolver resolver = resolverWithVerifier(command, plan(replicas, ConsistencyLevel.ALL), readRepair, System.nanoTime(), verifier); + DataResolver resolver = resolverWithVerifier(command, plan(replicas, ALL), readRepair, nanoTime(), verifier); resolver.preprocess(response(peer1, iter(PartitionUpdate.emptyUpdate(cfm,dk)), digest1, true, command)); // peer2 is advertising an older version, so when we deserialize its response there are two things to note: @@ -1217,7 +1219,7 @@ public class DataResolverTest extends AbstractReadResponseTest InetAddressAndPort peer2 = replicas.get(1).endpoint(); verifier.expectDigest(peer1, digest1, true); - DataResolver resolver = resolverWithVerifier(command, plan(replicas, ConsistencyLevel.ALL), readRepair, System.nanoTime(), verifier); + DataResolver resolver = resolverWithVerifier(command, plan(replicas, ALL), readRepair, nanoTime(), verifier); resolver.preprocess(response(peer1, iter(PartitionUpdate.emptyUpdate(cfm,dk)), digest1, true, command)); resolver.preprocess(response(peer2, iter(PartitionUpdate.emptyUpdate(cfm,dk)), digest2, true, command)); diff --git a/test/unit/org/apache/cassandra/service/reads/ReadExecutorTest.java b/test/unit/org/apache/cassandra/service/reads/ReadExecutorTest.java index ac6820548a..962801f161 100644 --- a/test/unit/org/apache/cassandra/service/reads/ReadExecutorTest.java +++ b/test/unit/org/apache/cassandra/service/reads/ReadExecutorTest.java @@ -45,8 +45,11 @@ import org.apache.cassandra.net.NoPayload; import org.apache.cassandra.net.Verb; import org.apache.cassandra.schema.KeyspaceParams; +import static java.util.concurrent.TimeUnit.DAYS; import static java.util.concurrent.TimeUnit.MILLISECONDS; +import static org.apache.cassandra.db.ConsistencyLevel.LOCAL_QUORUM; import static org.apache.cassandra.locator.ReplicaUtils.full; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertSame; import static org.junit.Assert.assertTrue; @@ -92,7 +95,7 @@ public class ReadExecutorTest { assertEquals(0, cfs.metric.speculativeInsufficientReplicas.getCount()); assertEquals(0, ks.metric.speculativeInsufficientReplicas.getCount()); - AbstractReadExecutor executor = new AbstractReadExecutor.NeverSpeculatingReadExecutor(cfs, new MockSinglePartitionReadCommand(), plan(targets, ConsistencyLevel.LOCAL_QUORUM), System.nanoTime(), true); + AbstractReadExecutor executor = new AbstractReadExecutor.NeverSpeculatingReadExecutor(cfs, new MockSinglePartitionReadCommand(), plan(targets, LOCAL_QUORUM), nanoTime(), true); executor.maybeTryAdditionalReplicas(); try { @@ -107,7 +110,7 @@ public class ReadExecutorTest assertEquals(1, ks.metric.speculativeInsufficientReplicas.getCount()); //Shouldn't increment - executor = new AbstractReadExecutor.NeverSpeculatingReadExecutor(cfs, new MockSinglePartitionReadCommand(), plan(targets, ConsistencyLevel.LOCAL_QUORUM), System.nanoTime(), false); + executor = new AbstractReadExecutor.NeverSpeculatingReadExecutor(cfs, new MockSinglePartitionReadCommand(), plan(targets, LOCAL_QUORUM), nanoTime(), false); executor.maybeTryAdditionalReplicas(); try { @@ -133,7 +136,7 @@ public class ReadExecutorTest assertEquals(0, cfs.metric.speculativeFailedRetries.getCount()); assertEquals(0, ks.metric.speculativeRetries.getCount()); assertEquals(0, ks.metric.speculativeFailedRetries.getCount()); - AbstractReadExecutor executor = new AbstractReadExecutor.SpeculatingReadExecutor(cfs, new MockSinglePartitionReadCommand(TimeUnit.DAYS.toMillis(365)), plan(ConsistencyLevel.LOCAL_QUORUM, targets, targets.subList(0, 2)), System.nanoTime()); + AbstractReadExecutor executor = new AbstractReadExecutor.SpeculatingReadExecutor(cfs, new MockSinglePartitionReadCommand(DAYS.toMillis(365)), plan(LOCAL_QUORUM, targets, targets.subList(0, 2)), nanoTime()); executor.maybeTryAdditionalReplicas(); new Thread() { @@ -174,7 +177,7 @@ public class ReadExecutorTest assertEquals(0, cfs.metric.speculativeFailedRetries.getCount()); assertEquals(0, ks.metric.speculativeRetries.getCount()); assertEquals(0, ks.metric.speculativeFailedRetries.getCount()); - AbstractReadExecutor executor = new AbstractReadExecutor.SpeculatingReadExecutor(cfs, new MockSinglePartitionReadCommand(), plan(ConsistencyLevel.LOCAL_QUORUM, targets, targets.subList(0, 2)), System.nanoTime()); + AbstractReadExecutor executor = new AbstractReadExecutor.SpeculatingReadExecutor(cfs, new MockSinglePartitionReadCommand(), plan(LOCAL_QUORUM, targets, targets.subList(0, 2)), nanoTime()); executor.maybeTryAdditionalReplicas(); try { @@ -200,7 +203,7 @@ public class ReadExecutorTest { MockSinglePartitionReadCommand command = new MockSinglePartitionReadCommand(TimeUnit.DAYS.toMillis(365)); ReplicaPlan.ForTokenRead plan = plan(ConsistencyLevel.LOCAL_ONE, targets, targets.subList(0, 1)); - AbstractReadExecutor executor = new AbstractReadExecutor.SpeculatingReadExecutor(cfs, command, plan, System.nanoTime()); + AbstractReadExecutor executor = new AbstractReadExecutor.SpeculatingReadExecutor(cfs, command, plan, nanoTime()); // Issue an initial request against the first endpoint... executor.executeAsync(); diff --git a/test/unit/org/apache/cassandra/service/reads/range/RangeCommandIteratorTest.java b/test/unit/org/apache/cassandra/service/reads/range/RangeCommandIteratorTest.java index d82a503c4f..ea564647ee 100644 --- a/test/unit/org/apache/cassandra/service/reads/range/RangeCommandIteratorTest.java +++ b/test/unit/org/apache/cassandra/service/reads/range/RangeCommandIteratorTest.java @@ -42,6 +42,7 @@ import org.apache.cassandra.locator.ReplicaPlans; import org.apache.cassandra.schema.KeyspaceParams; import org.apache.cassandra.utils.CloseableIterator; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.junit.Assert.assertEquals; public class RangeCommandIteratorTest @@ -104,27 +105,27 @@ public class RangeCommandIteratorTest // without range merger, there will be 2 batches requested: 1st batch with 1 range and 2nd batch with remaining ranges CloseableIterator replicaPlans = replicaPlanIterator(keyRange, keyspace, false); - RangeCommandIterator data = new RangeCommandIterator(replicaPlans, command, 1, 1000, vnodeCount, System.nanoTime()); + RangeCommandIterator data = new RangeCommandIterator(replicaPlans, command, 1, 1000, vnodeCount, nanoTime()); verifyRangeCommandIterator(data, rows, 2, vnodeCount); // without range merger and initial cf=5, there will be 1 batches requested: 5 vnode ranges for 1st batch replicaPlans = replicaPlanIterator(keyRange, keyspace, false); - data = new RangeCommandIterator(replicaPlans, command, vnodeCount, 1000, vnodeCount, System.nanoTime()); + data = new RangeCommandIterator(replicaPlans, command, vnodeCount, 1000, vnodeCount, nanoTime()); verifyRangeCommandIterator(data, rows, 1, vnodeCount); // without range merger and max cf=1, there will be 5 batches requested: 1 vnode range per batch replicaPlans = replicaPlanIterator(keyRange, keyspace, false); - data = new RangeCommandIterator(replicaPlans, command, 1, 1, vnodeCount, System.nanoTime()); + data = new RangeCommandIterator(replicaPlans, command, 1, 1, vnodeCount, nanoTime()); verifyRangeCommandIterator(data, rows, vnodeCount, vnodeCount); // with range merger, there will be only 1 batch requested, as all ranges share the same replica - localhost replicaPlans = replicaPlanIterator(keyRange, keyspace, true); - data = new RangeCommandIterator(replicaPlans, command, 1, 1000, vnodeCount, System.nanoTime()); + data = new RangeCommandIterator(replicaPlans, command, 1, 1000, vnodeCount, nanoTime()); verifyRangeCommandIterator(data, rows, 1, vnodeCount); // with range merger and max cf=1, there will be only 1 batch requested, as all ranges share the same replica - localhost replicaPlans = replicaPlanIterator(keyRange, keyspace, true); - data = new RangeCommandIterator(replicaPlans, command, 1, 1, vnodeCount, System.nanoTime()); + data = new RangeCommandIterator(replicaPlans, command, 1, 1, vnodeCount, nanoTime()); verifyRangeCommandIterator(data, rows, 1, vnodeCount); } diff --git a/test/unit/org/apache/cassandra/service/reads/range/RangeCommandsTest.java b/test/unit/org/apache/cassandra/service/reads/range/RangeCommandsTest.java index 294be2a717..259a65f195 100644 --- a/test/unit/org/apache/cassandra/service/reads/range/RangeCommandsTest.java +++ b/test/unit/org/apache/cassandra/service/reads/range/RangeCommandsTest.java @@ -39,6 +39,7 @@ import org.apache.cassandra.index.StubIndex; import org.apache.cassandra.schema.IndexMetadata; import static org.apache.cassandra.db.ConsistencyLevel.ONE; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.junit.Assert.assertEquals; /** @@ -73,7 +74,7 @@ public class RangeCommandsTest extends CQLTester // verify that a low concurrency factor is not capped by the max concurrency factor PartitionRangeReadCommand command = command(cfs, 50, 50); - try (RangeCommandIterator partitions = RangeCommands.rangeCommandIterator(command, ONE, System.nanoTime()); + try (RangeCommandIterator partitions = RangeCommands.rangeCommandIterator(command, ONE, nanoTime()); ReplicaPlanIterator ranges = new ReplicaPlanIterator(command.dataRange().keyRange(), keyspace, ONE)) { assertEquals(2, partitions.concurrencyFactor()); @@ -83,7 +84,7 @@ public class RangeCommandsTest extends CQLTester // verify that a high concurrency factor is capped by the max concurrency factor command = command(cfs, 1000, 50); - try (RangeCommandIterator partitions = RangeCommands.rangeCommandIterator(command, ONE, System.nanoTime()); + try (RangeCommandIterator partitions = RangeCommands.rangeCommandIterator(command, ONE, nanoTime()); ReplicaPlanIterator ranges = new ReplicaPlanIterator(command.dataRange().keyRange(), keyspace, ONE)) { assertEquals(MAX_CONCURRENCY_FACTOR, partitions.concurrencyFactor()); @@ -93,7 +94,7 @@ public class RangeCommandsTest extends CQLTester // with 0 estimated results per range the concurrency factor should be 1 command = command(cfs, 1000, 0); - try (RangeCommandIterator partitions = RangeCommands.rangeCommandIterator(command, ONE, System.nanoTime()); + try (RangeCommandIterator partitions = RangeCommands.rangeCommandIterator(command, ONE, nanoTime()); ReplicaPlanIterator ranges = new ReplicaPlanIterator(command.dataRange().keyRange(), keyspace, ONE)) { assertEquals(1, partitions.concurrencyFactor()); diff --git a/test/unit/org/apache/cassandra/service/reads/repair/AbstractReadRepairTest.java b/test/unit/org/apache/cassandra/service/reads/repair/AbstractReadRepairTest.java index d36808fcab..7587993d3e 100644 --- a/test/unit/org/apache/cassandra/service/reads/repair/AbstractReadRepairTest.java +++ b/test/unit/org/apache/cassandra/service/reads/repair/AbstractReadRepairTest.java @@ -80,6 +80,7 @@ import org.apache.cassandra.utils.ByteBufferUtil; import static org.apache.cassandra.locator.Replica.fullReplica; import static org.apache.cassandra.locator.ReplicaUtils.FULL_RANGE; import static org.apache.cassandra.net.Verb.INTERNAL_RSP; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; @Ignore public abstract class AbstractReadRepairTest @@ -98,7 +99,7 @@ public abstract class AbstractReadRepairTest static EndpointsForRange replicas; static ReplicaPlan.ForRead replicaPlan; - static long now = TimeUnit.NANOSECONDS.toMicros(System.nanoTime()); + static long now = TimeUnit.NANOSECONDS.toMicros(nanoTime()); static DecoratedKey key; static Cell cell1; static Cell cell2; @@ -320,7 +321,7 @@ public abstract class AbstractReadRepairTest public InstrumentedReadRepair createInstrumentedReadRepair(ReplicaPlan.Shared replicaPlan) { - return createInstrumentedReadRepair(command, replicaPlan, System.nanoTime()); + return createInstrumentedReadRepair(command, replicaPlan, nanoTime()); } diff --git a/test/unit/org/apache/cassandra/service/reads/repair/BlockingReadRepairTest.java b/test/unit/org/apache/cassandra/service/reads/repair/BlockingReadRepairTest.java index 43a1275a44..0666eb191c 100644 --- a/test/unit/org/apache/cassandra/service/reads/repair/BlockingReadRepairTest.java +++ b/test/unit/org/apache/cassandra/service/reads/repair/BlockingReadRepairTest.java @@ -43,6 +43,9 @@ import org.apache.cassandra.locator.ReplicaUtils; import org.apache.cassandra.net.Message; import org.apache.cassandra.service.reads.ReadCallback; +import static java.util.concurrent.TimeUnit.NANOSECONDS; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + public class BlockingReadRepairTest extends AbstractReadRepairTest { private static class InstrumentedReadRepairHandler @@ -287,6 +290,6 @@ public class BlockingReadRepairTest extends AbstractReadRepairTest private boolean getCurrentRepairStatus(BlockingPartitionRepair handler) { - return handler.awaitRepairsUntil(System.nanoTime(), TimeUnit.NANOSECONDS); + return handler.awaitRepairsUntil(nanoTime(), NANOSECONDS); } } diff --git a/test/unit/org/apache/cassandra/service/reads/repair/DiagEventsBlockingReadRepairTest.java b/test/unit/org/apache/cassandra/service/reads/repair/DiagEventsBlockingReadRepairTest.java index ae83efb6b0..713cef6122 100644 --- a/test/unit/org/apache/cassandra/service/reads/repair/DiagEventsBlockingReadRepairTest.java +++ b/test/unit/org/apache/cassandra/service/reads/repair/DiagEventsBlockingReadRepairTest.java @@ -49,6 +49,9 @@ import org.apache.cassandra.net.Message; import org.apache.cassandra.service.reads.ReadCallback; import org.apache.cassandra.service.reads.repair.ReadRepairEvent.ReadRepairEventType; +import static java.util.concurrent.TimeUnit.NANOSECONDS; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + /** * Variation of {@link BlockingReadRepair} using diagnostic events instead of instrumentation for test validation. */ @@ -110,7 +113,7 @@ public class DiagEventsBlockingReadRepairTest extends AbstractReadRepairTest private boolean getCurrentRepairStatus(BlockingPartitionRepair handler) { - return handler.awaitRepairsUntil(System.nanoTime(), TimeUnit.NANOSECONDS); + return handler.awaitRepairsUntil(nanoTime(), NANOSECONDS); } public InstrumentedReadRepair createInstrumentedReadRepair(ReadCommand command, ReplicaPlan.Shared replicaPlan, long queryStartNanoTime) diff --git a/test/unit/org/apache/cassandra/service/reads/repair/ReadRepairTest.java b/test/unit/org/apache/cassandra/service/reads/repair/ReadRepairTest.java index dad9aa488e..82de4f3dce 100644 --- a/test/unit/org/apache/cassandra/service/reads/repair/ReadRepairTest.java +++ b/test/unit/org/apache/cassandra/service/reads/repair/ReadRepairTest.java @@ -58,7 +58,9 @@ import org.apache.cassandra.schema.TableMetadata; import org.apache.cassandra.schema.Tables; import org.apache.cassandra.utils.ByteBufferUtil; +import static java.util.concurrent.TimeUnit.NANOSECONDS; import static org.apache.cassandra.locator.ReplicaUtils.full; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; public class ReadRepairTest { @@ -86,7 +88,7 @@ public class ReadRepairTest } } - static long now = TimeUnit.NANOSECONDS.toMicros(System.nanoTime()); + static long now = TimeUnit.NANOSECONDS.toMicros(nanoTime()); static DecoratedKey key; static Cell cell1; static Cell cell2; @@ -348,6 +350,6 @@ public class ReadRepairTest private boolean getCurrentRepairStatus(BlockingPartitionRepair handler) { - return handler.awaitRepairsUntil(System.nanoTime(), TimeUnit.NANOSECONDS); + return handler.awaitRepairsUntil(nanoTime(), NANOSECONDS); } } diff --git a/test/unit/org/apache/cassandra/tools/OfflineToolUtils.java b/test/unit/org/apache/cassandra/tools/OfflineToolUtils.java index c1678d723b..0fea44866d 100644 --- a/test/unit/org/apache/cassandra/tools/OfflineToolUtils.java +++ b/test/unit/org/apache/cassandra/tools/OfflineToolUtils.java @@ -66,7 +66,7 @@ public abstract class OfflineToolUtils "ScheduledTasks:[1-9]", "OptionalTasks:[1-9]", "Reference-Reaper:[1-9]", - "LocalPool-Cleaner:[1-9]", + "LocalPool-Cleaner(-networking|-chunk-cache)?:[1-9]", "CacheCleanupExecutor:[1-9]", "CompactionExecutor:[1-9]", "ValidationExecutor:[1-9]", @@ -76,6 +76,9 @@ public abstract class OfflineToolUtils "Strong-Reference-Leak-Detector:[1-9]", "Background_Reporter:[1-9]", "EXPIRING-MAP-REAPER:[1-9]", + "ObjectCleanerThread", + "process reaper" // spawned by the jvm when executing external processes + // and may still be active when we check }; public void assertNoUnexpectedThreadsStarted(String[] expectedThreadNames, String[] optionalThreadNames) diff --git a/test/unit/org/apache/cassandra/triggers/TriggersSchemaTest.java b/test/unit/org/apache/cassandra/triggers/TriggersSchemaTest.java index 31111bddae..cd59aa18d4 100644 --- a/test/unit/org/apache/cassandra/triggers/TriggersSchemaTest.java +++ b/test/unit/org/apache/cassandra/triggers/TriggersSchemaTest.java @@ -32,13 +32,14 @@ import org.apache.cassandra.schema.TriggerMetadata; import org.apache.cassandra.schema.Triggers; import org.apache.cassandra.schema.MigrationManager; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.junit.Assert.*; public class TriggersSchemaTest { - String ksName = "ks" + System.nanoTime(); - String cfName = "cf" + System.nanoTime(); - String triggerName = "trigger_" + System.nanoTime(); + String ksName = "ks" + nanoTime(); + String cfName = "cf" + nanoTime(); + String triggerName = "trigger_" + nanoTime(); String triggerClass = "org.apache.cassandra.triggers.NoSuchTrigger.class"; @BeforeClass diff --git a/test/unit/org/apache/cassandra/triggers/TriggersTest.java b/test/unit/org/apache/cassandra/triggers/TriggersTest.java index 2cf0e84ee4..1d32f53817 100644 --- a/test/unit/org/apache/cassandra/triggers/TriggersTest.java +++ b/test/unit/org/apache/cassandra/triggers/TriggersTest.java @@ -38,6 +38,7 @@ import org.apache.cassandra.service.StorageService; import org.apache.cassandra.utils.FBUtilities; import static org.apache.cassandra.utils.ByteBufferUtil.toInt; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; @@ -123,7 +124,7 @@ public class TriggersTest @Test(expected=org.apache.cassandra.exceptions.InvalidRequestException.class) public void onCqlUpdateWithConditionsRejectGeneratedUpdatesForDifferentPartition() throws Exception { - String cf = "cf" + System.nanoTime(); + String cf = "cf" + nanoTime(); try { setupTableWithTrigger(cf, CrossPartitionTrigger.class); @@ -139,7 +140,7 @@ public class TriggersTest @Test(expected=org.apache.cassandra.exceptions.InvalidRequestException.class) public void onCqlUpdateWithConditionsRejectGeneratedUpdatesForDifferentTable() throws Exception { - String cf = "cf" + System.nanoTime(); + String cf = "cf" + nanoTime(); try { setupTableWithTrigger(cf, CrossTableTrigger.class); @@ -155,7 +156,7 @@ public class TriggersTest @Test(expected=org.apache.cassandra.exceptions.InvalidRequestException.class) public void ifTriggerThrowsErrorNoMutationsAreApplied() throws Exception { - String cf = "cf" + System.nanoTime(); + String cf = "cf" + nanoTime(); try { setupTableWithTrigger(cf, ErrorTrigger.class); diff --git a/test/unit/org/apache/cassandra/utils/MonotonicClockTest.java b/test/unit/org/apache/cassandra/utils/MonotonicClockTest.java index b2891a9950..06b44182ca 100644 --- a/test/unit/org/apache/cassandra/utils/MonotonicClockTest.java +++ b/test/unit/org/apache/cassandra/utils/MonotonicClockTest.java @@ -17,6 +17,7 @@ */ package org.apache.cassandra.utils; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.apache.cassandra.utils.MonotonicClock.approxTime; import static org.junit.Assert.*; @@ -27,7 +28,7 @@ public class MonotonicClockTest @Test public void testTimestampOrdering() throws Exception { - long nowNanos = System.nanoTime(); + long nowNanos = nanoTime(); long now = System.currentTimeMillis(); long lastConverted = 0; for (long ii = 0; ii < 10000000; ii++) @@ -39,7 +40,7 @@ public class MonotonicClockTest Thread.sleep(1); } - nowNanos = Math.max(nowNanos, System.nanoTime()); + nowNanos = Math.max(nowNanos, nanoTime()); long convertedNow = approxTime.translate().toMillisSinceEpoch(nowNanos); int maxDiff = FBUtilities.isWindows ? 15 : 1; diff --git a/test/unit/org/apache/cassandra/utils/SlidingTimeRateTest.java b/test/unit/org/apache/cassandra/utils/SlidingTimeRateTest.java deleted file mode 100644 index 8dc4a14d6d..0000000000 --- a/test/unit/org/apache/cassandra/utils/SlidingTimeRateTest.java +++ /dev/null @@ -1,161 +0,0 @@ -/* - * 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.cassandra.utils; - -import java.util.concurrent.ExecutorService; -import java.util.concurrent.Executors; -import java.util.concurrent.TimeUnit; - -import org.junit.Assert; -import org.junit.Ignore; -import org.junit.Test; - -/** - * No objects are created currently from SlidingTimeRate in Cassandra 4.0. - * If you decide to use it, please check CASSANDRA-16713. - * There still might be a bug, flaky test to be fixed before using it again. - * - * Skipping all tests for running now to clean he noise before 4.0 GA release. - */ -public class SlidingTimeRateTest -{ - @Ignore - @Test - public void testUpdateAndGet() - { - SlidingTimeRate rate = new SlidingTimeRate(new TestTimeSource(), 10, 1, TimeUnit.SECONDS); - int updates = 100; - for (int i = 0; i < updates; i++) - { - rate.update(1); - } - Assert.assertEquals(updates, rate.get(TimeUnit.SECONDS), 0.0); - } - - @Ignore - @Test - public void testUpdateAndGetBetweenWindows() - { - TestTimeSource time = new TestTimeSource(); - SlidingTimeRate rate = new SlidingTimeRate(time, 5, 1, TimeUnit.SECONDS); - int updates = 100; - for (int i = 0; i < updates; i++) - { - rate.update(1); - time.sleep(100, TimeUnit.MILLISECONDS); - } - Assert.assertEquals(10, rate.get(TimeUnit.SECONDS), 0.0); - } - - @Ignore - @Test - public void testUpdateAndGetPastWindowSize() - { - TestTimeSource time = new TestTimeSource(); - SlidingTimeRate rate = new SlidingTimeRate(time, 5, 1, TimeUnit.SECONDS); - int updates = 100; - for (int i = 0; i < updates; i++) - { - rate.update(1); - } - - time.sleep(6, TimeUnit.SECONDS); - - Assert.assertEquals(0, rate.get(TimeUnit.SECONDS), 0.0); - } - - @Ignore - @Test - public void testUpdateAndGetToPointInTime() - { - TestTimeSource time = new TestTimeSource(); - SlidingTimeRate rate = new SlidingTimeRate(time, 5, 1, TimeUnit.SECONDS); - int updates = 10; - for (int i = 0; i < updates; i++) - { - rate.update(1); - time.sleep(100, TimeUnit.MILLISECONDS); - } - - time.sleep(1, TimeUnit.SECONDS); - - Assert.assertEquals(5, rate.get(TimeUnit.SECONDS), 0.0); - Assert.assertEquals(10, rate.get(1, TimeUnit.SECONDS), 0.0); - } - - @Ignore - @Test - public void testDecay() throws InterruptedException - { - TestTimeSource time = new TestTimeSource(); - SlidingTimeRate rate = new SlidingTimeRate(time, 5, 1, TimeUnit.SECONDS); - int updates = 10; - for (int i = 0; i < updates; i++) - { - rate.update(1); - time.sleep(100, TimeUnit.MILLISECONDS); - } - Assert.assertEquals(10, rate.get(TimeUnit.SECONDS), 0.0); - - time.sleep(1, TimeUnit.SECONDS); - - Assert.assertEquals(5, rate.get(TimeUnit.SECONDS), 0.0); - - time.sleep(2, TimeUnit.SECONDS); - - Assert.assertEquals(2.5, rate.get(TimeUnit.SECONDS), 0.0); - } - - @Ignore - @Test - public void testPruning() - { - TestTimeSource time = new TestTimeSource(); - SlidingTimeRate rate = new SlidingTimeRate(time, 5, 1, TimeUnit.SECONDS); - - rate.update(1); - Assert.assertEquals(1, rate.size()); - - time.sleep(6, TimeUnit.SECONDS); - - rate.prune(); - Assert.assertEquals(0, rate.size()); - } - - @Ignore - @Test - public void testConcurrentUpdateAndGet() throws InterruptedException - { - final ExecutorService executor = Executors.newFixedThreadPool(FBUtilities.getAvailableProcessors()); - final TestTimeSource time = new TestTimeSource(); - final SlidingTimeRate rate = new SlidingTimeRate(time, 5, 1, TimeUnit.SECONDS); - int updates = 100000; - for (int i = 0; i < updates; i++) - { - executor.submit(() -> { - time.sleep(1, TimeUnit.MILLISECONDS); - rate.update(1); - }); - } - - executor.shutdown(); - - Assert.assertTrue(executor.awaitTermination(1, TimeUnit.MINUTES)); - Assert.assertEquals(1000, rate.get(TimeUnit.SECONDS), 100.0); - } -} diff --git a/test/unit/org/apache/cassandra/utils/TestTimeSource.java b/test/unit/org/apache/cassandra/utils/TestTimeSource.java deleted file mode 100644 index 4ecd086f38..0000000000 --- a/test/unit/org/apache/cassandra/utils/TestTimeSource.java +++ /dev/null @@ -1,72 +0,0 @@ -/* - * 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.cassandra.utils; - -import java.util.concurrent.TimeUnit; -import java.util.concurrent.atomic.AtomicLong; - -public class TestTimeSource implements TimeSource -{ - private final AtomicLong timeInMillis = new AtomicLong(System.currentTimeMillis()); - - @Override - public long currentTimeMillis() - { - return timeInMillis.get(); - } - - @Override - public long nanoTime() - { - return timeInMillis.get() * 1_000_000; - } - - @Override - public TimeSource sleep(long sleepFor, TimeUnit unit) - { - long current = timeInMillis.get(); - long sleepInMillis = TimeUnit.MILLISECONDS.convert(sleepFor, unit); - boolean elapsed; - do - { - long newTime = current + sleepInMillis; - elapsed = timeInMillis.compareAndSet(current, newTime); - if (!elapsed) - { - long updated = timeInMillis.get(); - if (updated - current >= sleepInMillis) - { - elapsed = true; - } - else - { - sleepInMillis -= updated - current; - current = updated; - } - } - } - while (!elapsed); - return this; - } - - @Override - public TimeSource sleepUninterruptibly(long sleepFor, TimeUnit unit) - { - return sleep(sleepFor, unit); - } -} diff --git a/test/unit/org/apache/cassandra/utils/binlog/BinLogTest.java b/test/unit/org/apache/cassandra/utils/binlog/BinLogTest.java index 311b924f9e..3a21ed167a 100644 --- a/test/unit/org/apache/cassandra/utils/binlog/BinLogTest.java +++ b/test/unit/org/apache/cassandra/utils/binlog/BinLogTest.java @@ -40,6 +40,7 @@ import net.openhft.chronicle.queue.RollCycles; import net.openhft.chronicle.wire.WireOut; import org.apache.cassandra.Util; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotEquals; @@ -50,7 +51,7 @@ public class BinLogTest { public static Path tempDir() throws Exception { - return Files.createTempDirectory("binlogtest" + System.nanoTime()); + return Files.createTempDirectory("binlogtest" + nanoTime()); } private static final String testString = "ry@nlikestheyankees"; diff --git a/tools/stress/src/org/apache/cassandra/io/sstable/StressCQLSSTableWriter.java b/tools/stress/src/org/apache/cassandra/io/sstable/StressCQLSSTableWriter.java index bc6756b498..c087cab252 100644 --- a/tools/stress/src/org/apache/cassandra/io/sstable/StressCQLSSTableWriter.java +++ b/tools/stress/src/org/apache/cassandra/io/sstable/StressCQLSSTableWriter.java @@ -58,6 +58,8 @@ import org.apache.cassandra.service.ClientState; import org.apache.cassandra.transport.ProtocolVersion; import org.apache.cassandra.utils.ByteBufferUtil; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; + /** * Utility to write SSTables. *

@@ -245,7 +247,7 @@ public class StressCQLSSTableWriter implements Closeable List keys = insert.buildPartitionKeyNames(options); SortedSet> clusterings = insert.createClustering(options); - long now = System.currentTimeMillis(); + long now = currentTimeMillis(); // Note that we asks indexes to not validate values (the last 'false' arg below) because that triggers a 'Keyspace.open' // and that forces a lot of initialization that we don't want. UpdateParameters params = new UpdateParameters(insert.metadata(), diff --git a/tools/stress/src/org/apache/cassandra/stress/StressAction.java b/tools/stress/src/org/apache/cassandra/stress/StressAction.java index 3268182342..f9912acf52 100644 --- a/tools/stress/src/org/apache/cassandra/stress/StressAction.java +++ b/tools/stress/src/org/apache/cassandra/stress/StressAction.java @@ -39,6 +39,8 @@ import org.jctools.queues.SpscUnboundedArrayQueue; import com.google.common.util.concurrent.Uninterruptibles; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + public class StressAction implements Runnable { @@ -315,7 +317,7 @@ public class StressAction implements Runnable void start() { - start = System.nanoTime(); + start = nanoTime(); } /** @@ -361,7 +363,7 @@ public class StressAction implements Runnable long intendedTime = rateLimiter.acquire(partitionCount); op.intendedStartNs(intendedTime); long now; - while ((now = System.nanoTime()) < intendedTime) + while ((now = nanoTime()) < intendedTime) { LockSupport.parkNanos(intendedTime - now); } diff --git a/tools/stress/src/org/apache/cassandra/stress/report/StressMetrics.java b/tools/stress/src/org/apache/cassandra/stress/report/StressMetrics.java index b2afd1bf9e..b50dfd23f0 100644 --- a/tools/stress/src/org/apache/cassandra/stress/report/StressMetrics.java +++ b/tools/stress/src/org/apache/cassandra/stress/report/StressMetrics.java @@ -54,7 +54,10 @@ import org.apache.cassandra.stress.util.ResultLogger; import org.apache.cassandra.stress.util.Uncertainty; import org.apache.cassandra.utils.FBUtilities; +import static java.util.concurrent.TimeUnit.MILLISECONDS; import static java.util.concurrent.TimeUnit.NANOSECONDS; +import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; public class StressMetrics implements MeasurementSink { @@ -65,8 +68,8 @@ public class StressMetrics implements MeasurementSink private final CountDownLatch stopped = new CountDownLatch(1); private final Callable gcStatsCollector; private final HistogramLogWriter histogramWriter; - private final long epochNs = System.nanoTime(); - private final long epochMs = System.currentTimeMillis(); + private final long epochNs = nanoTime(); + private final long epochMs = currentTimeMillis(); private volatile JmxCollector.GcStats totalGcStats = new GcStats(0); @@ -159,10 +162,10 @@ public class StressMetrics implements MeasurementSink private void reportingLoop(final long logIntervalMillis) { // align report timing to the nearest second - final long currentTimeMs = System.currentTimeMillis(); + final long currentTimeMs = currentTimeMillis(); final long startTimeMs = currentTimeMs - (currentTimeMs % 1000); // reporting interval starts rounded to the second - long reportingStartNs = (System.nanoTime() - TimeUnit.MILLISECONDS.toNanos(currentTimeMs - startTimeMs)); + long reportingStartNs = (nanoTime() - MILLISECONDS.toNanos(currentTimeMs - startTimeMs)); final long parkIntervalNs = TimeUnit.MILLISECONDS.toNanos(logIntervalMillis); try { @@ -178,7 +181,7 @@ public class StressMetrics implements MeasurementSink reportingStartNs += parkIntervalNs; } - final long end = System.nanoTime(); + final long end = nanoTime(); recordInterval(end, end - reportingStartNs); } catch (Exception e) @@ -198,7 +201,7 @@ public class StressMetrics implements MeasurementSink { long parkFor; while (!stop && - (parkFor = until - System.nanoTime()) > 0) + (parkFor = until - nanoTime()) > 0) { LockSupport.parkNanos(parkFor); } diff --git a/tools/stress/src/org/apache/cassandra/stress/report/Timer.java b/tools/stress/src/org/apache/cassandra/stress/report/Timer.java index b3df52f985..09377210ae 100644 --- a/tools/stress/src/org/apache/cassandra/stress/report/Timer.java +++ b/tools/stress/src/org/apache/cassandra/stress/report/Timer.java @@ -23,6 +23,8 @@ package org.apache.cassandra.stress.report; import org.apache.cassandra.stress.StressAction.MeasurementSink; +import static org.apache.cassandra.utils.Clock.Global.nanoTime; + // a timer - this timer must be used by a single thread, and co-ordinates with other timers by public final class Timer { @@ -42,7 +44,7 @@ public final class Timer public void stop(long partitionCount, long rowCount, boolean error) { - sink.record(opType, intendedTimeNs, startTimeNs, System.nanoTime(), rowCount, partitionCount, error); + sink.record(opType, intendedTimeNs, startTimeNs, nanoTime(), rowCount, partitionCount, error); resetTimes(); } @@ -58,6 +60,6 @@ public final class Timer public void start() { - startTimeNs = System.nanoTime(); + startTimeNs = nanoTime(); } } \ No newline at end of file