From 3210a42f0958e395930d2259e155a7149fb475eb Mon Sep 17 00:00:00 2001 From: Marios Trivyzas <5058131+matriv@users.noreply.github.com> Date: Sat, 29 Oct 2022 10:05:17 +0300 Subject: [PATCH] Fix nanos to millis conversion for tests (#11856) --- lucene/CHANGES.txt | 3 +++ .../analysis/hunspell/TestPerformance.java | 2 +- .../pattern/TestPatternReplaceCharFilter.java | 3 ++- .../sinks/TestTeeSinkTokenFilter.java | 7 ++++-- .../analysis/ja/TestJapaneseTokenizer.java | 9 +++++--- .../lucene90/Lucene90HnswGraphBuilder.java | 5 +++-- .../lucene60/bkd/BKDWriter60.java | 4 ++-- .../lucene91/Lucene91HnswGraphBuilder.java | 5 +++-- .../byTask/tasks/NearRealtimeReaderTask.java | 2 +- .../benchmark/byTask/TestPerfTasksLogic.java | 6 +++-- .../byTask/tasks/CountingSearchTestTask.java | 3 ++- .../Test20NewsgroupsClassification.java | 11 +++++++--- .../simpletext/SimpleTextBKDWriter.java | 4 ++-- .../lucene/index/BufferedUpdatesStream.java | 3 ++- .../org/apache/lucene/index/CheckIndex.java | 2 +- .../index/ConcurrentMergeScheduler.java | 5 +++-- .../index/DocumentsWriterFlushControl.java | 3 ++- .../index/DocumentsWriterPerThread.java | 6 ++++- .../lucene/index/FrozenBufferedUpdates.java | 7 +++--- .../apache/lucene/index/IndexFileDeleter.java | 3 ++- .../org/apache/lucene/index/IndexWriter.java | 17 +++++++------- .../apache/lucene/index/IndexingChain.java | 22 +++++++++++++------ .../org/apache/lucene/index/MergeState.java | 5 ++++- .../lucene/index/ReadersAndUpdates.java | 3 ++- .../apache/lucene/index/SegmentMerger.java | 18 +++++++++++---- .../ControlledRealTimeReopenThread.java | 5 +++-- .../org/apache/lucene/util/bkd/BKDWriter.java | 4 ++-- .../lucene/util/hnsw/HnswGraphBuilder.java | 5 +++-- .../org/apache/lucene/index/Test2BTerms.java | 11 +++++++--- .../lucene/index/TestDeletionPolicy.java | 2 +- .../apache/lucene/index/TestTermdocPerf.java | 11 ++++++++-- .../lucene/search/TestShardSearching.java | 4 +++- .../apache/lucene/store/TestRateLimiter.java | 5 ++++- .../apache/lucene/util/SelectorBenchmark.java | 5 +++-- .../apache/lucene/util/SorterBenchmark.java | 5 +++-- .../util/fst/TestFSTDirectAddressing.java | 10 ++++++--- .../org/apache/lucene/util/fst/TestFSTs.java | 16 +++++++++----- .../lucene/util/hnsw/KnnGraphTester.java | 11 ++++++---- .../org/apache/lucene/demo/IndexFiles.java | 2 +- .../lucene/luke/app/desktop/LukeMain.java | 8 +++++-- .../lucene/replicator/nrt/CopyOneFile.java | 3 ++- .../apache/lucene/replicator/nrt/Node.java | 13 ++++++----- .../nrt/PreCopyMergedSegmentWarmer.java | 3 ++- .../lucene/replicator/nrt/ReplicaNode.java | 5 +++-- .../lucene/replicator/nrt/SimpleCopyJob.java | 3 ++- .../replicator/nrt/SimplePrimaryNode.java | 3 ++- .../replicator/nrt/TestNRTReplication.java | 3 ++- .../nrt/TestStressNRTReplication.java | 15 +++++++------ .../analyzing/AnalyzingInfixSuggester.java | 2 +- .../ThreadedIndexingAndSearchingTestCase.java | 11 ++++++---- .../tests/util/ThrottledIndexOutput.java | 3 ++- 51 files changed, 213 insertions(+), 113 deletions(-) diff --git a/lucene/CHANGES.txt b/lucene/CHANGES.txt index 5cbec01f8cc..bfd79ec9b79 100644 --- a/lucene/CHANGES.txt +++ b/lucene/CHANGES.txt @@ -160,6 +160,9 @@ Optimizations Other --------------------- + +* GITHUB#11856: Fix nanos to millis conversion for tests (Marios Trivyzas) + * LUCENE-10423: Remove usages of System.currentTimeMillis() from tests. (Marios Trivyzas) * GITHUB#11811: Upgrade google java format to 1.15.0 (Dawid Weiss) diff --git a/lucene/analysis/common/src/test/org/apache/lucene/analysis/hunspell/TestPerformance.java b/lucene/analysis/common/src/test/org/apache/lucene/analysis/hunspell/TestPerformance.java index a6b069f848c..190f3cab8c4 100644 --- a/lucene/analysis/common/src/test/org/apache/lucene/analysis/hunspell/TestPerformance.java +++ b/lucene/analysis/common/src/test/org/apache/lucene/analysis/hunspell/TestPerformance.java @@ -258,7 +258,7 @@ public class TestPerformance extends LuceneTestCase { for (int i = 0; i < 7; i++) { long start = System.nanoTime(); iteration.run(consumer); - times.add((System.nanoTime() - start) / 1_000_000); + times.add(TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start)); } double average = times.stream().mapToLong(Long::longValue).average().orElseThrow(); System.out.println( diff --git a/lucene/analysis/common/src/test/org/apache/lucene/analysis/pattern/TestPatternReplaceCharFilter.java b/lucene/analysis/common/src/test/org/apache/lucene/analysis/pattern/TestPatternReplaceCharFilter.java index d73ef8f7230..e39bffb9c64 100644 --- a/lucene/analysis/common/src/test/org/apache/lucene/analysis/pattern/TestPatternReplaceCharFilter.java +++ b/lucene/analysis/common/src/test/org/apache/lucene/analysis/pattern/TestPatternReplaceCharFilter.java @@ -20,6 +20,7 @@ import java.io.IOException; import java.io.Reader; import java.io.StringReader; import java.util.Random; +import java.util.concurrent.TimeUnit; import java.util.regex.Matcher; import java.util.regex.Pattern; import org.apache.lucene.analysis.Analyzer; @@ -261,7 +262,7 @@ public class TestPatternReplaceCharFilter extends BaseTokenStreamTestCase { if (matcher.find()) { System.out.println(matcher.group()); } - System.out.println(i + " > " + (System.nanoTime() - t) / 1_000_000_000.0); + System.out.println(i + " > " + TimeUnit.NANOSECONDS.toSeconds(System.nanoTime() - t)); } } diff --git a/lucene/analysis/common/src/test/org/apache/lucene/analysis/sinks/TestTeeSinkTokenFilter.java b/lucene/analysis/common/src/test/org/apache/lucene/analysis/sinks/TestTeeSinkTokenFilter.java index 36e7914c307..c049eb65a99 100644 --- a/lucene/analysis/common/src/test/org/apache/lucene/analysis/sinks/TestTeeSinkTokenFilter.java +++ b/lucene/analysis/common/src/test/org/apache/lucene/analysis/sinks/TestTeeSinkTokenFilter.java @@ -19,6 +19,7 @@ package org.apache.lucene.analysis.sinks; import java.io.IOException; import java.io.StringReader; import java.util.Locale; +import java.util.concurrent.TimeUnit; import org.apache.lucene.analysis.Analyzer; import org.apache.lucene.analysis.CachingTokenFilter; import org.apache.lucene.analysis.FilteringTokenFilter; @@ -199,7 +200,8 @@ public class TestTeeSinkTokenFilter extends BaseTokenStreamTestCase { } long finish = System.nanoTime(); System.out.println( - "ModCount: " + modCounts[j] + " Two fields took " + (finish - start) / 100_000 + " ms"); + ("ModCount: " + modCounts[j]) + + (" Two fields took " + TimeUnit.NANOSECONDS.toMillis(finish - start) + " ms")); int sinkPos = 0; // simulate one field with one sink start = System.nanoTime(); @@ -219,7 +221,8 @@ public class TestTeeSinkTokenFilter extends BaseTokenStreamTestCase { } finish = System.nanoTime(); System.out.println( - "ModCount: " + modCounts[j] + " Tee fields took " + (finish - start) / 100_000 + " ms"); + ("ModCount: " + modCounts[j]) + + (" Tee fields took " + TimeUnit.NANOSECONDS.toMillis(finish - start) + " ms")); assertTrue(sinkPos + " does not equal: " + tfPos, sinkPos == tfPos); } System.out.println("- End Tokens: " + tokCount[k] + "-----"); diff --git a/lucene/analysis/kuromoji/src/test/org/apache/lucene/analysis/ja/TestJapaneseTokenizer.java b/lucene/analysis/kuromoji/src/test/org/apache/lucene/analysis/ja/TestJapaneseTokenizer.java index d76209815cf..c910c11842d 100644 --- a/lucene/analysis/kuromoji/src/test/org/apache/lucene/analysis/ja/TestJapaneseTokenizer.java +++ b/lucene/analysis/kuromoji/src/test/org/apache/lucene/analysis/ja/TestJapaneseTokenizer.java @@ -26,6 +26,7 @@ import java.nio.charset.StandardCharsets; import java.util.ArrayList; import java.util.List; import java.util.Random; +import java.util.concurrent.TimeUnit; import org.apache.lucene.analysis.Analyzer; import org.apache.lucene.analysis.TokenStream; import org.apache.lucene.analysis.Tokenizer; @@ -711,7 +712,7 @@ public class TestJapaneseTokenizer extends BaseTokenStreamTestCase { nonCompoundCount++; if (nonCompoundCount % 1000000 == 0) { System.out.println(String.format("%.2f msec [pos=%d, %d, %d]", - (System.nanoTime()-startTimeNS)/1000000.0, + (System.nanoTime() - startTimeNS) / (double) TimeUnit.MILLISECONDS.toNanos(1), netOffset + offsetAtt.startOffset(), nonCompoundCount, compoundCount)); @@ -764,7 +765,8 @@ public class TestJapaneseTokenizer extends BaseTokenStreamTestCase { } String[] sentences = line.split("、|。"); if (VERBOSE) { - System.out.println("Total time : " + (System.nanoTime() - totalStart) / 100_000); + System.out.println( + "Total time : " + TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - totalStart) + " ms"); System.out.println( "Test for Bocchan with pre-splitting sentences (" + sentences.length + " sentences)"); } @@ -780,7 +782,8 @@ public class TestJapaneseTokenizer extends BaseTokenStreamTestCase { } } if (VERBOSE) { - System.out.println("Total time : " + (System.nanoTime() - totalStart) / 100_000); + System.out.println( + "Total time : " + TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - totalStart) + " ms"); } } diff --git a/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene90/Lucene90HnswGraphBuilder.java b/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene90/Lucene90HnswGraphBuilder.java index a9dfaf6f470..81327fbfcd5 100644 --- a/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene90/Lucene90HnswGraphBuilder.java +++ b/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene90/Lucene90HnswGraphBuilder.java @@ -21,6 +21,7 @@ import java.io.IOException; import java.util.Locale; import java.util.Objects; import java.util.SplittableRandom; +import java.util.concurrent.TimeUnit; import org.apache.lucene.index.RandomAccessVectorValues; import org.apache.lucene.index.VectorSimilarityFunction; import org.apache.lucene.util.InfoStream; @@ -123,8 +124,8 @@ public final class Lucene90HnswGraphBuilder { Locale.ROOT, "built %d in %d/%d ms", node, - ((now - t) / 1_000_000), - ((now - start) / 1_000_000))); + TimeUnit.NANOSECONDS.toMillis(now - t), + TimeUnit.NANOSECONDS.toMillis(now - start))); t = now; } } diff --git a/lucene/backward-codecs/src/test/org/apache/lucene/backward_codecs/lucene60/bkd/BKDWriter60.java b/lucene/backward-codecs/src/test/org/apache/lucene/backward_codecs/lucene60/bkd/BKDWriter60.java index 884550b0bc9..c11ab33275e 100644 --- a/lucene/backward-codecs/src/test/org/apache/lucene/backward_codecs/lucene60/bkd/BKDWriter60.java +++ b/lucene/backward-codecs/src/test/org/apache/lucene/backward_codecs/lucene60/bkd/BKDWriter60.java @@ -1021,8 +1021,8 @@ public class BKDWriter60 implements Closeable { // If no exception, we should have cleaned everything up: assert tempDir.getCreatedFiles().isEmpty(); - // long t2 = System.nanoTime(); - // System.out.println("write time: " + ((t2-t1)/1000000.0) + " msec"); + // System.out.println("write time: " + ((System.nanoTime() - t1) / (double) + // TimeUnit.MILLISECONDS.toNanos(1)) + " ms"); success = true; } finally { diff --git a/lucene/backward-codecs/src/test/org/apache/lucene/backward_codecs/lucene91/Lucene91HnswGraphBuilder.java b/lucene/backward-codecs/src/test/org/apache/lucene/backward_codecs/lucene91/Lucene91HnswGraphBuilder.java index 3076abaed95..344c01ab085 100644 --- a/lucene/backward-codecs/src/test/org/apache/lucene/backward_codecs/lucene91/Lucene91HnswGraphBuilder.java +++ b/lucene/backward-codecs/src/test/org/apache/lucene/backward_codecs/lucene91/Lucene91HnswGraphBuilder.java @@ -23,6 +23,7 @@ import java.io.IOException; import java.util.Locale; import java.util.Objects; import java.util.SplittableRandom; +import java.util.concurrent.TimeUnit; import org.apache.lucene.index.RandomAccessVectorValues; import org.apache.lucene.index.VectorEncoding; import org.apache.lucene.index.VectorSimilarityFunction; @@ -176,8 +177,8 @@ public final class Lucene91HnswGraphBuilder { Locale.ROOT, "built %d in %d/%d ms", node, - ((now - t) / 1_000_000), - ((now - start) / 1_000_000))); + TimeUnit.NANOSECONDS.toMillis(now - t), + TimeUnit.NANOSECONDS.toMillis(now - start))); return now; } diff --git a/lucene/benchmark/src/java/org/apache/lucene/benchmark/byTask/tasks/NearRealtimeReaderTask.java b/lucene/benchmark/src/java/org/apache/lucene/benchmark/byTask/tasks/NearRealtimeReaderTask.java index 4e37347e6e6..1e82fac6193 100644 --- a/lucene/benchmark/src/java/org/apache/lucene/benchmark/byTask/tasks/NearRealtimeReaderTask.java +++ b/lucene/benchmark/src/java/org/apache/lucene/benchmark/byTask/tasks/NearRealtimeReaderTask.java @@ -71,7 +71,7 @@ public class NearRealtimeReaderTask extends PerfTask { long waitForMsec = (pauseMSec - (System.currentTimeMillis() - t)); if (waitForMsec > 0) { Thread.sleep(waitForMsec); - // System.out.println("NRT wait: " + waitForMsec + " msec"); + // System.out.println("NRT wait: " + waitForMsec + " ms"); } t = System.currentTimeMillis(); diff --git a/lucene/benchmark/src/test/org/apache/lucene/benchmark/byTask/TestPerfTasksLogic.java b/lucene/benchmark/src/test/org/apache/lucene/benchmark/byTask/TestPerfTasksLogic.java index d83a3d960bb..38e4804da41 100644 --- a/lucene/benchmark/src/test/org/apache/lucene/benchmark/byTask/TestPerfTasksLogic.java +++ b/lucene/benchmark/src/test/org/apache/lucene/benchmark/byTask/TestPerfTasksLogic.java @@ -24,6 +24,7 @@ import java.text.Collator; import java.util.Collection; import java.util.List; import java.util.Locale; +import java.util.concurrent.TimeUnit; import org.apache.lucene.analysis.Analyzer; import org.apache.lucene.analysis.TokenStream; import org.apache.lucene.analysis.tokenattributes.TermToBytesRefAttribute; @@ -126,8 +127,9 @@ public class TestPerfTasksLogic extends BenchmarkTestCase { execBenchmark(algLines); assertTrue(CountingSearchTestTask.numSearches > 0); long elapsed = - (CountingSearchTestTask.prevLastNanos - CountingSearchTestTask.startNanos) / 1_000_000; - assertTrue("elapsed time was " + elapsed + " msec", elapsed <= 1500); + TimeUnit.NANOSECONDS.toMillis( + CountingSearchTestTask.prevLastNanos - CountingSearchTestTask.startNanos); + assertTrue("elapsed time was " + elapsed + " ms", elapsed <= 1500); } // disabled until we fix BG thread prio -- this test diff --git a/lucene/benchmark/src/test/org/apache/lucene/benchmark/byTask/tasks/CountingSearchTestTask.java b/lucene/benchmark/src/test/org/apache/lucene/benchmark/byTask/tasks/CountingSearchTestTask.java index 8238ac08d5a..1fc9a35f6e3 100644 --- a/lucene/benchmark/src/test/org/apache/lucene/benchmark/byTask/tasks/CountingSearchTestTask.java +++ b/lucene/benchmark/src/test/org/apache/lucene/benchmark/byTask/tasks/CountingSearchTestTask.java @@ -16,6 +16,7 @@ */ package org.apache.lucene.benchmark.byTask.tasks; +import java.util.concurrent.TimeUnit; import org.apache.lucene.benchmark.byTask.PerfRunData; /** Test Search task which counts number of searches. */ @@ -47,6 +48,6 @@ public class CountingSearchTestTask extends SearchTask { } public long getElapsedMillis() { - return lastNanos - startNanos / 1_000_000; + return TimeUnit.NANOSECONDS.toMillis(lastNanos - startNanos); } } diff --git a/lucene/classification/src/test/org/apache/lucene/classification/Test20NewsgroupsClassification.java b/lucene/classification/src/test/org/apache/lucene/classification/Test20NewsgroupsClassification.java index 12eb045b4fd..77c8d4f2fa4 100644 --- a/lucene/classification/src/test/org/apache/lucene/classification/Test20NewsgroupsClassification.java +++ b/lucene/classification/src/test/org/apache/lucene/classification/Test20NewsgroupsClassification.java @@ -131,7 +131,11 @@ public final class Test20NewsgroupsClassification extends LuceneTestCase { long endIndex = System.nanoTime(); System.out.println( - "Indexed " + docsIndexed + " docs in " + (endIndex - startIndex) / 1_000_000_000 + "s"); + "Indexed " + + docsIndexed + + " docs in " + + TimeUnit.NANOSECONDS.toSeconds(endIndex - startIndex) + + "s"); indexWriter.close(); } @@ -161,7 +165,8 @@ public final class Test20NewsgroupsClassification extends LuceneTestCase { reader.close(); reader = DirectoryReader.open(train); // using the train index from now on long endSplit = System.nanoTime(); - System.out.println("Splitting done in " + (endSplit - startSplit) / 1_000_000_000 + "s"); + System.out.println( + "Splitting done in " + TimeUnit.NANOSECONDS.toSeconds(endSplit - startSplit) + "s"); } classifiers.add( @@ -371,7 +376,7 @@ public final class Test20NewsgroupsClassification extends LuceneTestCase { ar, classifier, CATEGORY_FIELD, BODY_FIELD, 60000 * 30); } final long endTime = System.nanoTime(); - final int elapse = (int) (endTime - startTime) / 1_000_000_000; + final int elapse = (int) TimeUnit.NANOSECONDS.toSeconds(endTime - startTime); return " * " + classifier diff --git a/lucene/codecs/src/java/org/apache/lucene/codecs/simpletext/SimpleTextBKDWriter.java b/lucene/codecs/src/java/org/apache/lucene/codecs/simpletext/SimpleTextBKDWriter.java index 8b4b53510d9..432f5b7e5f5 100644 --- a/lucene/codecs/src/java/org/apache/lucene/codecs/simpletext/SimpleTextBKDWriter.java +++ b/lucene/codecs/src/java/org/apache/lucene/codecs/simpletext/SimpleTextBKDWriter.java @@ -704,8 +704,8 @@ final class SimpleTextBKDWriter implements Closeable { // If no exception, we should have cleaned everything up: assert tempDir.getCreatedFiles().isEmpty(); - // long t2 = System.nanoTime(); - // System.out.println("write time: " + ((t2-t1)/1000000.0) + " msec"); + // System.out.println("write time: " + ((System.nanoTime() - t1) / (double) + // TimeUnit.MILLISECONDS.toNanos(1)) + " ms"); success = true; } finally { diff --git a/lucene/core/src/java/org/apache/lucene/index/BufferedUpdatesStream.java b/lucene/core/src/java/org/apache/lucene/index/BufferedUpdatesStream.java index e44a0ae2ae9..32c944623b5 100644 --- a/lucene/core/src/java/org/apache/lucene/index/BufferedUpdatesStream.java +++ b/lucene/core/src/java/org/apache/lucene/index/BufferedUpdatesStream.java @@ -24,6 +24,7 @@ import java.util.HashSet; import java.util.List; import java.util.Locale; import java.util.Set; +import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicLong; import org.apache.lucene.store.IOContext; @@ -267,7 +268,7 @@ final class BufferedUpdatesStream implements Accountable { packetCount, totalDelCount, bytesUsed.get(), - (System.nanoTime() - startNS) / 1000000.)); + (System.nanoTime() - startNS) / (double) TimeUnit.MILLISECONDS.toNanos(1))); } } diff --git a/lucene/core/src/java/org/apache/lucene/index/CheckIndex.java b/lucene/core/src/java/org/apache/lucene/index/CheckIndex.java index 193cb4f2687..78b5e57e1a5 100644 --- a/lucene/core/src/java/org/apache/lucene/index/CheckIndex.java +++ b/lucene/core/src/java/org/apache/lucene/index/CheckIndex.java @@ -4190,7 +4190,7 @@ public final class CheckIndex implements Closeable { } private static double nsToSec(long ns) { - return ns / 1000000000.0; + return ns / (double) TimeUnit.SECONDS.toNanos(1); } /** diff --git a/lucene/core/src/java/org/apache/lucene/index/ConcurrentMergeScheduler.java b/lucene/core/src/java/org/apache/lucene/index/ConcurrentMergeScheduler.java index 08cc014b3e1..8ffbbd759a4 100644 --- a/lucene/core/src/java/org/apache/lucene/index/ConcurrentMergeScheduler.java +++ b/lucene/core/src/java/org/apache/lucene/index/ConcurrentMergeScheduler.java @@ -21,6 +21,7 @@ import java.io.UncheckedIOException; import java.util.ArrayList; import java.util.List; import java.util.Locale; +import java.util.concurrent.TimeUnit; import org.apache.lucene.index.MergePolicy.OneMerge; import org.apache.lucene.internal.tests.ConcurrentMergeSchedulerAccess; import org.apache.lucene.internal.tests.TestSecrets; @@ -614,7 +615,7 @@ public class ConcurrentMergeScheduler extends MergeScheduler { } if (verbose() && startStallTime != 0) { - message(" stalled for " + (System.currentTimeMillis() - startStallTime) + " msec"); + message(" stalled for " + (System.currentTimeMillis() - startStallTime) + " ms"); } return true; @@ -889,7 +890,7 @@ public class ConcurrentMergeScheduler extends MergeScheduler { protected void targetMBPerSecChanged() {} private static double nsToSec(long ns) { - return ns / 1000000000.0; + return ns / (double) TimeUnit.SECONDS.toNanos(1); } private static double bytesToMB(long bytes) { diff --git a/lucene/core/src/java/org/apache/lucene/index/DocumentsWriterFlushControl.java b/lucene/core/src/java/org/apache/lucene/index/DocumentsWriterFlushControl.java index 0dd39c32180..a8fcc82999d 100644 --- a/lucene/core/src/java/org/apache/lucene/index/DocumentsWriterFlushControl.java +++ b/lucene/core/src/java/org/apache/lucene/index/DocumentsWriterFlushControl.java @@ -23,6 +23,7 @@ import java.util.LinkedList; import java.util.List; import java.util.Locale; import java.util.Queue; +import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicBoolean; import org.apache.lucene.store.AlreadyClosedException; import org.apache.lucene.util.Accountable; @@ -311,7 +312,7 @@ final class DocumentsWriterFlushControl implements Accountable, Closeable { String.format( Locale.ROOT, "done stalling flushes for %.1f msec: netBytes: %.1f MB flushBytes: %.1f MB fullFlush: %b", - (System.nanoTime() - stallStartNS) / 1000000., + (System.nanoTime() - stallStartNS) / (double) TimeUnit.MILLISECONDS.toNanos(1), netBytes() / 1024. / 1024., getFlushingBytes() / 1024. / 1024., fullFlush)); diff --git a/lucene/core/src/java/org/apache/lucene/index/DocumentsWriterPerThread.java b/lucene/core/src/java/org/apache/lucene/index/DocumentsWriterPerThread.java index 4083e95ba76..0bd4348a33b 100644 --- a/lucene/core/src/java/org/apache/lucene/index/DocumentsWriterPerThread.java +++ b/lucene/core/src/java/org/apache/lucene/index/DocumentsWriterPerThread.java @@ -25,6 +25,7 @@ import java.util.List; import java.util.Locale; import java.util.Objects; import java.util.Set; +import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicLong; import java.util.concurrent.locks.ReentrantLock; import org.apache.lucene.codecs.Codec; @@ -473,7 +474,10 @@ final class DocumentsWriterPerThread implements Accountable { sealFlushedSegment(fs, sortMap, flushNotifications); if (infoStream.isEnabled("DWPT")) { infoStream.message( - "DWPT", "flush time " + ((System.nanoTime() - t0) / 1000000.0) + " msec"); + "DWPT", + "flush time " + + ((System.nanoTime() - t0) / (double) TimeUnit.MILLISECONDS.toNanos(1)) + + " ms"); } return fs; } catch (Throwable t) { diff --git a/lucene/core/src/java/org/apache/lucene/index/FrozenBufferedUpdates.java b/lucene/core/src/java/org/apache/lucene/index/FrozenBufferedUpdates.java index c68a88aba09..b9bdc528c92 100644 --- a/lucene/core/src/java/org/apache/lucene/index/FrozenBufferedUpdates.java +++ b/lucene/core/src/java/org/apache/lucene/index/FrozenBufferedUpdates.java @@ -22,6 +22,7 @@ import java.util.List; import java.util.Locale; import java.util.Map; import java.util.concurrent.CountDownLatch; +import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.ReentrantLock; import java.util.function.IntConsumer; import org.apache.lucene.search.DocIdSetIterator; @@ -216,7 +217,7 @@ final class FrozenBufferedUpdates { String.format( Locale.ROOT, "applyDocValuesUpdates %.1f msec for %d segments, %d field updates; %d new updates", - (System.nanoTime() - startNS) / 1000000., + (System.nanoTime() - startNS) / (double) TimeUnit.MILLISECONDS.toNanos(1), segStates.length, fieldUpdatesCount, updateCount)); @@ -430,7 +431,7 @@ final class FrozenBufferedUpdates { String.format( Locale.ROOT, "applyQueryDeletes took %.2f msec for %d segments and %d queries; %d new deletions", - (System.nanoTime() - startNS) / 1000000., + (System.nanoTime() - startNS) / (double) TimeUnit.MILLISECONDS.toNanos(1), segStates.length, deleteQueries.length, delCount)); @@ -493,7 +494,7 @@ final class FrozenBufferedUpdates { String.format( Locale.ROOT, "applyTermDeletes took %.2f msec for %d segments and %d del terms; %d new deletions", - (System.nanoTime() - startNS) / 1000000., + (System.nanoTime() - startNS) / (double) TimeUnit.MILLISECONDS.toNanos(1), segStates.length, deleteTerms.size(), delCount)); diff --git a/lucene/core/src/java/org/apache/lucene/index/IndexFileDeleter.java b/lucene/core/src/java/org/apache/lucene/index/IndexFileDeleter.java index 85cd7eb2fe3..30b7737225e 100644 --- a/lucene/core/src/java/org/apache/lucene/index/IndexFileDeleter.java +++ b/lucene/core/src/java/org/apache/lucene/index/IndexFileDeleter.java @@ -30,6 +30,7 @@ import java.util.Locale; import java.util.Map; import java.util.Objects; import java.util.Set; +import java.util.concurrent.TimeUnit; import java.util.regex.Matcher; import org.apache.lucene.store.AlreadyClosedException; import org.apache.lucene.store.Directory; @@ -605,7 +606,7 @@ final class IndexFileDeleter implements Closeable { if (infoStream.isEnabled("IFD")) { long t1 = System.nanoTime(); - infoStream.message("IFD", ((t1 - t0) / 1000000) + " msec to checkpoint"); + infoStream.message("IFD", TimeUnit.NANOSECONDS.toMillis(t1 - t0) + " ms to checkpoint"); } } diff --git a/lucene/core/src/java/org/apache/lucene/index/IndexWriter.java b/lucene/core/src/java/org/apache/lucene/index/IndexWriter.java index aabba4d6b33..3b8f4315d84 100644 --- a/lucene/core/src/java/org/apache/lucene/index/IndexWriter.java +++ b/lucene/core/src/java/org/apache/lucene/index/IndexWriter.java @@ -696,8 +696,7 @@ public class IndexWriter maybeMerge(config.getMergePolicy(), MergeTrigger.FULL_FLUSH, UNBOUNDED_MAX_MERGE_SEGMENTS); } if (infoStream.isEnabled("IW")) { - infoStream.message( - "IW", "getReader took " + (System.currentTimeMillis() - tStart) + " msec"); + infoStream.message("IW", "getReader took " + (System.currentTimeMillis() - tStart) + " ms"); } success2 = true; } catch (VirtualMachineError tragedy) { @@ -867,7 +866,7 @@ public class IndexWriter count, readerPool.ramBytesUsed() / 1024. / 1024., ramBufferSizeMB, - ((System.nanoTime() - startNS) / 1000000000.))); + ((System.nanoTime() - startNS) / (double) TimeUnit.SECONDS.toNanos(1)))); } } } @@ -4130,7 +4129,7 @@ public class IndexWriter String.format( Locale.ROOT, "commit: took %.1f msec", - (System.nanoTime() - startCommitTime) / 1000000.0)); + (System.nanoTime() - startCommitTime) / (double) TimeUnit.MILLISECONDS.toNanos(1))); infoStream.message("IW", "commit: done"); } } @@ -4718,7 +4717,7 @@ public class IndexWriter "IW", "merge time " + (System.currentTimeMillis() - t0) - + " msec for " + + " ms for " + merge.info.info.maxDoc() + " docs"); } @@ -5154,7 +5153,7 @@ public class IndexWriter String.format( Locale.ROOT, "%.1f sec %s", - e.getValue() / 1000000000., + e.getValue() / (double) TimeUnit.SECONDS.toNanos(1), e.getKey().name().toLowerCase(Locale.ROOT))) .collect(Collectors.joining(", ")); if (!pauseInfo.isEmpty()) { @@ -5162,7 +5161,7 @@ public class IndexWriter } long t1 = System.nanoTime(); - double sec = (t1 - merge.mergeStartNS) / 1000000000.; + double sec = (t1 - merge.mergeStartNS) / (double) TimeUnit.SECONDS.toNanos(1); double segmentMB = (merge.info.sizeInBytes() / 1024. / 1024.); infoStream.message( "IW", @@ -6154,7 +6153,7 @@ public class IndexWriter this, segStates.length, delCount, - (System.nanoTime() - iterStartNS) / 1000000000.)); + (System.nanoTime() - iterStartNS) / (double) TimeUnit.SECONDS.toNanos(1))); } if (updates.privateSegment != null) { // No need to retry for a segment-private packet: the merge that folds in our private @@ -6211,7 +6210,7 @@ public class IndexWriter this, totalSegmentCount, totalDelCount, - (System.nanoTime() - startNS) / 1000000000.); + (System.nanoTime() - startNS) / (double) TimeUnit.SECONDS.toNanos(1)); if (iter > 0) { message += "; " + (iter + 1) + " iters due to concurrent merges"; } diff --git a/lucene/core/src/java/org/apache/lucene/index/IndexingChain.java b/lucene/core/src/java/org/apache/lucene/index/IndexingChain.java index 789fac9b400..19b513eb9a1 100644 --- a/lucene/core/src/java/org/apache/lucene/index/IndexingChain.java +++ b/lucene/core/src/java/org/apache/lucene/index/IndexingChain.java @@ -25,6 +25,7 @@ import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Objects; +import java.util.concurrent.TimeUnit; import java.util.function.Consumer; import org.apache.lucene.analysis.Analyzer; import org.apache.lucene.analysis.TokenStream; @@ -241,7 +242,8 @@ final class IndexingChain implements Accountable { long t0 = System.nanoTime(); writeNorms(state, sortMap); if (infoStream.isEnabled("IW")) { - infoStream.message("IW", ((System.nanoTime() - t0) / 1000000) + " msec to write norms"); + infoStream.message( + "IW", TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - t0) + " ms to write norms"); } SegmentReadState readState = new SegmentReadState( @@ -254,19 +256,22 @@ final class IndexingChain implements Accountable { t0 = System.nanoTime(); writeDocValues(state, sortMap); if (infoStream.isEnabled("IW")) { - infoStream.message("IW", ((System.nanoTime() - t0) / 1000000) + " msec to write docValues"); + infoStream.message( + "IW", TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - t0) + " ms to write docValues"); } t0 = System.nanoTime(); writePoints(state, sortMap); if (infoStream.isEnabled("IW")) { - infoStream.message("IW", ((System.nanoTime() - t0) / 1000000) + " msec to write points"); + infoStream.message( + "IW", TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - t0) + " ms to write points"); } t0 = System.nanoTime(); vectorValuesConsumer.flush(state, sortMap); if (infoStream.isEnabled("IW")) { - infoStream.message("IW", ((System.nanoTime() - t0) / 1000000) + " msec to write vectors"); + infoStream.message( + "IW", TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - t0) + " ms to write vectors"); } // it's possible all docs hit non-aborting exceptions... @@ -275,7 +280,8 @@ final class IndexingChain implements Accountable { storedFieldsConsumer.flush(state, sortMap); if (infoStream.isEnabled("IW")) { infoStream.message( - "IW", ((System.nanoTime() - t0) / 1000000) + " msec to finish stored fields"); + "IW", + TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - t0) + " ms to finish stored fields"); } t0 = System.nanoTime(); @@ -304,7 +310,8 @@ final class IndexingChain implements Accountable { if (infoStream.isEnabled("IW")) { infoStream.message( "IW", - ((System.nanoTime() - t0) / 1000000) + " msec to write postings and finish vectors"); + TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - t0) + + " ms to write postings and finish vectors"); } // Important to save after asking consumer to flush so @@ -317,7 +324,8 @@ final class IndexingChain implements Accountable { .fieldInfosFormat() .write(state.directory, state.segmentInfo, "", state.fieldInfos, IOContext.DEFAULT); if (infoStream.isEnabled("IW")) { - infoStream.message("IW", ((System.nanoTime() - t0) / 1000000) + " msec to write fieldInfos"); + infoStream.message( + "IW", TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - t0) + " ms to write fieldInfos"); } return sortMap; diff --git a/lucene/core/src/java/org/apache/lucene/index/MergeState.java b/lucene/core/src/java/org/apache/lucene/index/MergeState.java index faea6cbf0e8..105c598f072 100644 --- a/lucene/core/src/java/org/apache/lucene/index/MergeState.java +++ b/lucene/core/src/java/org/apache/lucene/index/MergeState.java @@ -21,6 +21,7 @@ import static org.apache.lucene.index.IndexWriter.isCongruentSort; import java.io.IOException; import java.util.List; import java.util.Locale; +import java.util.concurrent.TimeUnit; import org.apache.lucene.codecs.DocValuesProducer; import org.apache.lucene.codecs.FieldsProducer; import org.apache.lucene.codecs.KnnVectorsReader; @@ -215,7 +216,9 @@ public class MergeState { infoStream.message( "SM", String.format( - Locale.ROOT, "%.2f msec to build merge sorted DocMaps", (t1 - t0) / 1000000.0)); + Locale.ROOT, + "%.2f msec to build merge sorted DocMaps", + (t1 - t0) / (double) TimeUnit.MILLISECONDS.toNanos(1))); } return result; } diff --git a/lucene/core/src/java/org/apache/lucene/index/ReadersAndUpdates.java b/lucene/core/src/java/org/apache/lucene/index/ReadersAndUpdates.java index 58668055b3f..0f579b9d266 100644 --- a/lucene/core/src/java/org/apache/lucene/index/ReadersAndUpdates.java +++ b/lucene/core/src/java/org/apache/lucene/index/ReadersAndUpdates.java @@ -27,6 +27,7 @@ import java.util.Locale; import java.util.Map; import java.util.Map.Entry; import java.util.Set; +import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicLong; import java.util.function.Function; @@ -701,7 +702,7 @@ final class ReadersAndUpdates { Locale.ROOT, "done write field updates for seg=%s; took %.3fs; new files: %s", info, - (System.nanoTime() - startTimeNS) / 1000000000.0, + (System.nanoTime() - startTimeNS) / (double) TimeUnit.SECONDS.toNanos(1), newDVFiles)); } return true; diff --git a/lucene/core/src/java/org/apache/lucene/index/SegmentMerger.java b/lucene/core/src/java/org/apache/lucene/index/SegmentMerger.java index 805b5e5a23d..7fc2f046a65 100644 --- a/lucene/core/src/java/org/apache/lucene/index/SegmentMerger.java +++ b/lucene/core/src/java/org/apache/lucene/index/SegmentMerger.java @@ -18,6 +18,7 @@ package org.apache.lucene.index; import java.io.IOException; import java.util.List; +import java.util.concurrent.TimeUnit; import org.apache.lucene.codecs.Codec; import org.apache.lucene.codecs.DocValuesConsumer; import org.apache.lucene.codecs.FieldsConsumer; @@ -271,10 +272,14 @@ final class SegmentMerger { } int numMerged = merger.merge(); if (mergeState.infoStream.isEnabled("SM")) { - long t1 = System.nanoTime(); mergeState.infoStream.message( "SM", - ((t1 - t0) / 1000000) + " msec to merge " + formatName + " [" + numMerged + " docs]"); + TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - t0) + + " ms to merge " + + formatName + + " [" + + numMerged + + " docs]"); } return numMerged; } @@ -291,11 +296,16 @@ final class SegmentMerger { t0 = System.nanoTime(); } merger.merge(segmentWriteState, segmentReadState); + long t1 = System.nanoTime(); if (mergeState.infoStream.isEnabled("SM")) { - long t1 = System.nanoTime(); mergeState.infoStream.message( "SM", - ((t1 - t0) / 1000000) + " msec to merge " + formatName + " [" + numMerged + " docs]"); + TimeUnit.NANOSECONDS.toMillis(t1 - t0) + + " ms to merge " + + formatName + + " [" + + numMerged + + " docs]"); } } } diff --git a/lucene/core/src/java/org/apache/lucene/search/ControlledRealTimeReopenThread.java b/lucene/core/src/java/org/apache/lucene/search/ControlledRealTimeReopenThread.java index 3ea290970cb..997e52423d5 100644 --- a/lucene/core/src/java/org/apache/lucene/search/ControlledRealTimeReopenThread.java +++ b/lucene/core/src/java/org/apache/lucene/search/ControlledRealTimeReopenThread.java @@ -18,6 +18,7 @@ package org.apache.lucene.search; import java.io.Closeable; import java.io.IOException; +import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.ReentrantLock; import org.apache.lucene.index.IndexWriter; @@ -162,13 +163,13 @@ public class ControlledRealTimeReopenThread extends Thread implements Closeab reopenLock.unlock(); } - long startMS = System.nanoTime() / 1000000; + long startMS = TimeUnit.NANOSECONDS.toMillis(System.nanoTime()); while (targetGen > searchingGen) { if (maxMS < 0) { wait(); } else { - long msLeft = (startMS + maxMS) - System.nanoTime() / 1000000; + long msLeft = (startMS + maxMS) - TimeUnit.NANOSECONDS.toMillis(System.nanoTime()); if (msLeft <= 0) { return false; } else { diff --git a/lucene/core/src/java/org/apache/lucene/util/bkd/BKDWriter.java b/lucene/core/src/java/org/apache/lucene/util/bkd/BKDWriter.java index 44af1e38b19..efd2e0522d5 100644 --- a/lucene/core/src/java/org/apache/lucene/util/bkd/BKDWriter.java +++ b/lucene/core/src/java/org/apache/lucene/util/bkd/BKDWriter.java @@ -988,8 +988,8 @@ public class BKDWriter implements Closeable { // If no exception, we should have cleaned everything up: assert tempDir.getCreatedFiles().isEmpty(); - // long t2 = System.nanoTime(); - // System.out.println("write time: " + ((t2-t1)/1000000.0) + " msec"); + // System.out.println("write time: " + ((System.nanoTime() - t1) / (double) + // TimeUnit.SECONDS.toNanos(1)) + " ms"); success = true; } finally { diff --git a/lucene/core/src/java/org/apache/lucene/util/hnsw/HnswGraphBuilder.java b/lucene/core/src/java/org/apache/lucene/util/hnsw/HnswGraphBuilder.java index cc8e330ffc8..d9c772f093b 100644 --- a/lucene/core/src/java/org/apache/lucene/util/hnsw/HnswGraphBuilder.java +++ b/lucene/core/src/java/org/apache/lucene/util/hnsw/HnswGraphBuilder.java @@ -23,6 +23,7 @@ import java.io.IOException; import java.util.Locale; import java.util.Objects; import java.util.SplittableRandom; +import java.util.concurrent.TimeUnit; import org.apache.lucene.index.RandomAccessVectorValues; import org.apache.lucene.index.VectorEncoding; import org.apache.lucene.index.VectorSimilarityFunction; @@ -209,8 +210,8 @@ public final class HnswGraphBuilder { Locale.ROOT, "built %d in %d/%d ms", node, - ((now - t) / 1_000_000), - ((now - start) / 1_000_000))); + TimeUnit.NANOSECONDS.toMillis(now - t), + TimeUnit.NANOSECONDS.toMillis(now - start))); return now; } diff --git a/lucene/core/src/test/org/apache/lucene/index/Test2BTerms.java b/lucene/core/src/test/org/apache/lucene/index/Test2BTerms.java index 27c08adb545..de90a0ae1db 100644 --- a/lucene/core/src/test/org/apache/lucene/index/Test2BTerms.java +++ b/lucene/core/src/test/org/apache/lucene/index/Test2BTerms.java @@ -22,6 +22,7 @@ import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.Random; +import java.util.concurrent.TimeUnit; import org.apache.lucene.analysis.TokenStream; import org.apache.lucene.analysis.tokenattributes.CharTermAttribute; import org.apache.lucene.analysis.tokenattributes.TermToBytesRefAttribute; @@ -202,7 +203,12 @@ public class Test2BTerms extends LuceneTestCase { final long t0 = System.nanoTime(); w.addDocument(doc); System.out.println( - i + " of " + numDocs + " " + (System.nanoTime() - t0) / 1_000_000 + " msec"); + i + + " of " + + numDocs + + " " + + TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - t0) + + " ms"); } savedTerms = ts.savedTerms; @@ -266,8 +272,7 @@ public class Test2BTerms extends LuceneTestCase { System.out.println(" FAILED: count=" + count); failed = true; } - final long t1 = System.nanoTime(); - System.out.println(" took " + (t1 - t0) / 1_000_000 + " millis"); + System.out.println(" took " + TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - t0) + " ms"); TermsEnum.SeekStatus result = termsEnum.seekCeil(term); if (result != TermsEnum.SeekStatus.FOUND) { diff --git a/lucene/core/src/test/org/apache/lucene/index/TestDeletionPolicy.java b/lucene/core/src/test/org/apache/lucene/index/TestDeletionPolicy.java index 0e7fadffa85..f2b56868e6c 100644 --- a/lucene/core/src/test/org/apache/lucene/index/TestDeletionPolicy.java +++ b/lucene/core/src/test/org/apache/lucene/index/TestDeletionPolicy.java @@ -297,7 +297,7 @@ public class TestDeletionPolicy extends LuceneTestCase { + SECONDS + " seconds (" + (lastDeleteTime - modTime) - + " msec) but did not get deleted ", + + " ms) but did not get deleted ", lastDeleteTime - modTime <= leeway); } catch ( @SuppressWarnings("unused") diff --git a/lucene/core/src/test/org/apache/lucene/index/TestTermdocPerf.java b/lucene/core/src/test/org/apache/lucene/index/TestTermdocPerf.java index d8c0dd0d2bb..c8e2b56b1ea 100644 --- a/lucene/core/src/test/org/apache/lucene/index/TestTermdocPerf.java +++ b/lucene/core/src/test/org/apache/lucene/index/TestTermdocPerf.java @@ -18,6 +18,7 @@ package org.apache.lucene.index; import java.io.IOException; import java.util.Random; +import java.util.concurrent.TimeUnit; import org.apache.lucene.analysis.Analyzer; import org.apache.lucene.analysis.Tokenizer; import org.apache.lucene.analysis.tokenattributes.CharTermAttribute; @@ -118,7 +119,10 @@ public class TestTermdocPerf extends LuceneTestCase { long end = System.nanoTime(); if (VERBOSE) System.out.println( - "milliseconds for creation of " + ndocs + " docs = " + (end - start) / 1_000_000); + "milliseconds for creation of " + + ndocs + + " docs = " + + TimeUnit.NANOSECONDS.toMillis(end - start)); IndexReader reader = DirectoryReader.open(dir); @@ -140,7 +144,10 @@ public class TestTermdocPerf extends LuceneTestCase { end = System.nanoTime(); if (VERBOSE) System.out.println( - "milliseconds for " + iter + " TermDocs iteration: " + (end - start) / 1_000_000); + "milliseconds for " + + iter + + " TermDocs iteration: " + + TimeUnit.NANOSECONDS.toMillis(end - start)); return ret; } diff --git a/lucene/core/src/test/org/apache/lucene/search/TestShardSearching.java b/lucene/core/src/test/org/apache/lucene/search/TestShardSearching.java index f30c2846c0d..be0a4825ae6 100644 --- a/lucene/core/src/test/org/apache/lucene/search/TestShardSearching.java +++ b/lucene/core/src/test/org/apache/lucene/search/TestShardSearching.java @@ -20,6 +20,7 @@ import java.io.IOException; import java.util.ArrayList; import java.util.Collections; import java.util.List; +import java.util.concurrent.TimeUnit; import org.apache.lucene.index.IndexReader; import org.apache.lucene.index.IndexReaderContext; import org.apache.lucene.index.MultiReader; @@ -110,7 +111,8 @@ public class TestShardSearching extends ShardSearchingTestBase { if (VERBOSE) { System.out.println( "\nTEST: follow-on query age=" - + ((System.nanoTime() - prevSearchState.searchTimeNanos) / 1000000000.0)); + + ((System.nanoTime() - prevSearchState.searchTimeNanos) + / (double) TimeUnit.SECONDS.toNanos(1))); } try { diff --git a/lucene/core/src/test/org/apache/lucene/store/TestRateLimiter.java b/lucene/core/src/test/org/apache/lucene/store/TestRateLimiter.java index 5a7255e5615..94eaa4df002 100644 --- a/lucene/core/src/test/org/apache/lucene/store/TestRateLimiter.java +++ b/lucene/core/src/test/org/apache/lucene/store/TestRateLimiter.java @@ -17,6 +17,7 @@ package org.apache.lucene.store; import java.util.concurrent.CountDownLatch; +import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicLong; import org.apache.lucene.store.RateLimiter.SimpleRateLimiter; import org.apache.lucene.tests.util.LuceneTestCase; @@ -85,7 +86,9 @@ public final class TestRateLimiter extends LuceneTestCase { thread.join(); } long endNS = System.nanoTime(); - double actualMBPerSec = (totBytes.get() / 1024 / 1024.) / ((endNS - startNS) / 1000000000.0); + double actualMBPerSec = + (totBytes.get() / 1024 / 1024.) + / ((endNS - startNS) / (double) TimeUnit.SECONDS.toNanos(1)); // TODO: this may false trip .... could be we can only assert that it never exceeds the max, so // slow jenkins doesn't trip: diff --git a/lucene/core/src/test/org/apache/lucene/util/SelectorBenchmark.java b/lucene/core/src/test/org/apache/lucene/util/SelectorBenchmark.java index 669bcd36514..bf5524a7585 100644 --- a/lucene/core/src/test/org/apache/lucene/util/SelectorBenchmark.java +++ b/lucene/core/src/test/org/apache/lucene/util/SelectorBenchmark.java @@ -18,6 +18,7 @@ package org.apache.lucene.util; import java.util.Locale; import java.util.Random; +import java.util.concurrent.TimeUnit; import org.apache.lucene.util.BaseSortTestCase.Entry; import org.apache.lucene.util.BaseSortTestCase.Strategy; @@ -112,8 +113,8 @@ public class SelectorBenchmark { k -= clone.length; } } - long timeMs = (System.nanoTime() - startTimeNs) / 1000000; - System.out.printf(Locale.ROOT, "%5d", timeMs); + System.out.printf( + Locale.ROOT, "%5d", TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTimeNs)); } } diff --git a/lucene/core/src/test/org/apache/lucene/util/SorterBenchmark.java b/lucene/core/src/test/org/apache/lucene/util/SorterBenchmark.java index b02579bfeed..7aae8758d84 100644 --- a/lucene/core/src/test/org/apache/lucene/util/SorterBenchmark.java +++ b/lucene/core/src/test/org/apache/lucene/util/SorterBenchmark.java @@ -18,6 +18,7 @@ package org.apache.lucene.util; import java.util.Locale; import java.util.Random; +import java.util.concurrent.TimeUnit; import org.apache.lucene.util.BaseSortTestCase.Entry; import org.apache.lucene.util.BaseSortTestCase.Strategy; @@ -98,8 +99,8 @@ public class SorterBenchmark { System.arraycopy(original, 0, clone, 0, original.length); sorter.sort(0, clone.length); } - long timeMs = (System.nanoTime() - startTimeNs) / 1000000; - System.out.printf(Locale.ROOT, "%5d", timeMs); + System.out.printf( + Locale.ROOT, "%5d", TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTimeNs)); } } diff --git a/lucene/core/src/test/org/apache/lucene/util/fst/TestFSTDirectAddressing.java b/lucene/core/src/test/org/apache/lucene/util/fst/TestFSTDirectAddressing.java index d54f572d27c..34315147226 100644 --- a/lucene/core/src/test/org/apache/lucene/util/fst/TestFSTDirectAddressing.java +++ b/lucene/core/src/test/org/apache/lucene/util/fst/TestFSTDirectAddressing.java @@ -30,6 +30,7 @@ import java.util.HashSet; import java.util.List; import java.util.Locale; import java.util.Set; +import java.util.concurrent.TimeUnit; import java.util.zip.GZIPInputStream; import org.apache.lucene.store.ByteArrayDataInput; import org.apache.lucene.store.DataInput; @@ -270,21 +271,24 @@ public class TestFSTDirectAddressing extends LuceneTestCase { long startTimeMs = System.nanoTime(); FST originalFst = new FST<>(in, in, CharSequenceOutputs.getSingleton()); long endTimeMs = System.nanoTime(); - System.out.println("time = " + (endTimeMs - startTimeMs) / 100_000 + " ms"); + System.out.println( + "time = " + TimeUnit.NANOSECONDS.toMillis(endTimeMs - startTimeMs) + " ms"); for (float oversizingFactor : List.of(0f, 0f, 0f, 1f, 1f, 1f)) { System.out.println("\nFST construction (oversizingFactor=" + oversizingFactor + ")"); startTimeMs = System.nanoTime(); FST fst = recompile(originalFst, oversizingFactor); endTimeMs = System.nanoTime(); - System.out.println("time = " + (endTimeMs - startTimeMs) / 100_000 + " ms"); + System.out.println( + "time = " + TimeUnit.NANOSECONDS.toMillis(endTimeMs - startTimeMs) + " ms"); System.out.println("FST RAM = " + fst.ramBytesUsed() + " B"); System.out.println("FST enum"); startTimeMs = System.nanoTime(); walk(fst); endTimeMs = System.nanoTime(); - System.out.println("time = " + (endTimeMs - startTimeMs) / 100_000 + " ms"); + System.out.println( + "time = " + TimeUnit.NANOSECONDS.toMillis(endTimeMs - startTimeMs) + " ms"); } } } diff --git a/lucene/core/src/test/org/apache/lucene/util/fst/TestFSTs.java b/lucene/core/src/test/org/apache/lucene/util/fst/TestFSTs.java index 561c1ad01c7..fcdacbd5b18 100644 --- a/lucene/core/src/test/org/apache/lucene/util/fst/TestFSTs.java +++ b/lucene/core/src/test/org/apache/lucene/util/fst/TestFSTs.java @@ -40,6 +40,7 @@ import java.util.Random; import java.util.Set; import java.util.TreeMap; import java.util.TreeSet; +import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicInteger; import org.apache.lucene.document.Document; import org.apache.lucene.document.Field; @@ -543,7 +544,7 @@ public class TestFSTs extends LuceneTestCase { System.out.printf( Locale.ROOT, "%6.2fs: %9d...", - ((System.nanoTime() - tStart) / 1_000_000_000.0), + (System.nanoTime() - tStart) / (double) TimeUnit.SECONDS.toNanos(1), ord); } if (ord >= limit) { @@ -552,12 +553,14 @@ public class TestFSTs extends LuceneTestCase { } long tMid = System.nanoTime(); - System.out.println(((tMid - tStart) / 1_000_000_000.0) + " sec to add all terms"); + System.out.println( + ((tMid - tStart) / (double) TimeUnit.SECONDS.toNanos(1)) + " sec to add all terms"); assert fstCompiler.getTermCount() == ord; FST fst = fstCompiler.compile(); long tEnd = System.nanoTime(); - System.out.println(((tEnd - tMid) / 1_000_000_000.0) + " sec to finish/pack"); + System.out.println( + ((tEnd - tMid) / (double) TimeUnit.SECONDS.toNanos(1)) + " sec to finish/pack"); if (fst == null) { System.out.println("FST was fully pruned!"); System.exit(0); @@ -622,14 +625,17 @@ public class TestFSTs extends LuceneTestCase { ord++; if (ord % 500000 == 0) { System.out.println( - ((System.nanoTime() - tStart) / 1_000_000_000.0) + "s: " + ord + "..."); + (System.nanoTime() - tStart) / (double) TimeUnit.SECONDS.toNanos(1) + + "sec: " + + ord + + "..."); } if (ord >= limit) { break; } } - double totSec = ((System.nanoTime() - tStart) / 1_000_000_000.0); + double totSec = (System.nanoTime() - tStart) / (double) TimeUnit.SECONDS.toNanos(1); System.out.println( "Verify took " + totSec diff --git a/lucene/core/src/test/org/apache/lucene/util/hnsw/KnnGraphTester.java b/lucene/core/src/test/org/apache/lucene/util/hnsw/KnnGraphTester.java index 198c8f0ea9d..95961ceda64 100644 --- a/lucene/core/src/test/org/apache/lucene/util/hnsw/KnnGraphTester.java +++ b/lucene/core/src/test/org/apache/lucene/util/hnsw/KnnGraphTester.java @@ -36,6 +36,7 @@ import java.util.HashSet; import java.util.Locale; import java.util.Objects; import java.util.Set; +import java.util.concurrent.TimeUnit; import org.apache.lucene.codecs.KnnVectorsFormat; import org.apache.lucene.codecs.KnnVectorsReader; import org.apache.lucene.codecs.lucene94.Lucene94Codec; @@ -401,8 +402,9 @@ public class KnnGraphTester { } } } - totalCpuTime = (bean.getCurrentThreadCpuTime() - cpuTimeStartNs) / 1_000_000; - elapsed = (System.nanoTime() - start) / 1_000_000; // ns -> ms + totalCpuTime = + TimeUnit.NANOSECONDS.toMillis(bean.getCurrentThreadCpuTime() - cpuTimeStartNs); + elapsed = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start); // ns -> ms for (int i = 0; i < numIters; i++) { totalVisited += results[i].totalHits.value; for (ScoreDoc doc : results[i].scoreDocs) { @@ -728,9 +730,10 @@ public class KnnGraphTester { } long elapsed = System.nanoTime() - start; if (quiet == false) { - System.out.println("Indexed " + numDocs + " documents in " + elapsed / 1_000_000_000 + "s"); + System.out.println( + "Indexed " + numDocs + " documents in " + TimeUnit.NANOSECONDS.toSeconds(elapsed) + "s"); } - return (int) (elapsed / 1_000_000); + return (int) TimeUnit.NANOSECONDS.toMillis(elapsed); } private static void usage() { diff --git a/lucene/demo/src/java/org/apache/lucene/demo/IndexFiles.java b/lucene/demo/src/java/org/apache/lucene/demo/IndexFiles.java index 886f34f3251..defadfb7d23 100644 --- a/lucene/demo/src/java/org/apache/lucene/demo/IndexFiles.java +++ b/lucene/demo/src/java/org/apache/lucene/demo/IndexFiles.java @@ -174,7 +174,7 @@ public class IndexFiles implements AutoCloseable { + reader.numDocs() + " documents in " + (end.getTime() - start.getTime()) - + " milliseconds"); + + " ms"); if (reader.numDocs() > 100 && vectorDictSize < 1_000_000 && System.getProperty("smoketester") == null) { diff --git a/lucene/luke/src/java/org/apache/lucene/luke/app/desktop/LukeMain.java b/lucene/luke/src/java/org/apache/lucene/luke/app/desktop/LukeMain.java index 69dcc888cbc..de51c7b9bff 100644 --- a/lucene/luke/src/java/org/apache/lucene/luke/app/desktop/LukeMain.java +++ b/lucene/luke/src/java/org/apache/lucene/luke/app/desktop/LukeMain.java @@ -23,6 +23,7 @@ import java.awt.*; import java.lang.invoke.MethodHandles; import java.util.Arrays; import java.util.concurrent.SynchronousQueue; +import java.util.concurrent.TimeUnit; import java.util.logging.Level; import java.util.logging.Logger; import javax.swing.*; @@ -94,7 +95,7 @@ public class LukeMain { javax.swing.SwingUtilities.invokeLater( () -> { try { - long _start = System.nanoTime() / 1_000_000; + long _start = System.nanoTime(); guiThreadResult.put(createGUI()); // Show the initial dialog. @@ -107,7 +108,10 @@ public class LukeMain { (factory) -> {}); long _end = System.nanoTime() / 1_000_000; - log.info("Elapsed time for initializing GUI: " + (_end - _start) + "msec"); + log.info( + "Elapsed time for initializing GUI: " + + TimeUnit.NANOSECONDS.toMillis(_end - _start) + + " ms"); } catch (Exception e) { throw new RuntimeException(e); } diff --git a/lucene/replicator/src/java/org/apache/lucene/replicator/nrt/CopyOneFile.java b/lucene/replicator/src/java/org/apache/lucene/replicator/nrt/CopyOneFile.java index e11a10ed1a7..d8329ff761c 100644 --- a/lucene/replicator/src/java/org/apache/lucene/replicator/nrt/CopyOneFile.java +++ b/lucene/replicator/src/java/org/apache/lucene/replicator/nrt/CopyOneFile.java @@ -20,6 +20,7 @@ package org.apache.lucene.replicator.nrt; import java.io.Closeable; import java.io.IOException; import java.util.Locale; +import java.util.concurrent.TimeUnit; import org.apache.lucene.codecs.CodecUtil; import org.apache.lucene.store.DataInput; import org.apache.lucene.store.IOContext; @@ -134,7 +135,7 @@ public class CopyOneFile implements Closeable { "file %s: done copying [%s, %.3fms]", name, Node.bytesToString(metaData.length), - (System.nanoTime() - copyStartNS) / 1000000.0)); + (System.nanoTime() - copyStartNS) / (double) TimeUnit.MILLISECONDS.toNanos(1))); } return true; diff --git a/lucene/replicator/src/java/org/apache/lucene/replicator/nrt/Node.java b/lucene/replicator/src/java/org/apache/lucene/replicator/nrt/Node.java index 25b9a90c063..be78a9dc6ee 100644 --- a/lucene/replicator/src/java/org/apache/lucene/replicator/nrt/Node.java +++ b/lucene/replicator/src/java/org/apache/lucene/replicator/nrt/Node.java @@ -25,6 +25,7 @@ import java.io.PrintStream; import java.nio.file.NoSuchFileException; import java.util.Locale; import java.util.Map; +import java.util.concurrent.TimeUnit; import org.apache.lucene.codecs.CodecUtil; import org.apache.lucene.index.CorruptIndexException; import org.apache.lucene.index.DirectoryReader; @@ -121,8 +122,8 @@ public abstract class Node implements Closeable { String.format( Locale.ROOT, "%5.3fs %5.1fs: [%11s] %s", - (now - globalStartNS) / 1000000000., - (now - localStartNS) / 1000000000., + (now - globalStartNS) / (double) TimeUnit.SECONDS.toNanos(1), + (now - localStartNS) / (double) TimeUnit.SECONDS.toNanos(1), Thread.currentThread().getName(), message)); } @@ -135,8 +136,8 @@ public abstract class Node implements Closeable { String.format( Locale.ROOT, "%5.3fs %5.1fs: N%d [%11s] %s", - (now - globalStartNS) / 1000000000., - (now - localStartNS) / 1000000000., + (now - globalStartNS) / (double) TimeUnit.SECONDS.toNanos(1), + (now - localStartNS) / (double) TimeUnit.SECONDS.toNanos(1), id, Thread.currentThread().getName(), message)); @@ -150,8 +151,8 @@ public abstract class Node implements Closeable { String.format( Locale.ROOT, "%5.3fs %5.1fs: %7s %2s [%11s] %s", - (now - globalStartNS) / 1000000000., - (now - localStartNS) / 1000000000., + (now - globalStartNS) / (double) TimeUnit.SECONDS.toNanos(1), + (now - localStartNS) / (double) TimeUnit.SECONDS.toNanos(1), state, name(), Thread.currentThread().getName(), diff --git a/lucene/replicator/src/java/org/apache/lucene/replicator/nrt/PreCopyMergedSegmentWarmer.java b/lucene/replicator/src/java/org/apache/lucene/replicator/nrt/PreCopyMergedSegmentWarmer.java index 183448e7efe..f8af950cf7b 100644 --- a/lucene/replicator/src/java/org/apache/lucene/replicator/nrt/PreCopyMergedSegmentWarmer.java +++ b/lucene/replicator/src/java/org/apache/lucene/replicator/nrt/PreCopyMergedSegmentWarmer.java @@ -26,6 +26,7 @@ import java.io.IOException; import java.util.HashMap; import java.util.Locale; import java.util.Map; +import java.util.concurrent.TimeUnit; import org.apache.lucene.index.IndexWriter.IndexReaderWarmer; import org.apache.lucene.index.LeafReader; import org.apache.lucene.index.SegmentCommitInfo; @@ -60,7 +61,7 @@ class PreCopyMergedSegmentWarmer implements IndexReaderWarmer { String.format( Locale.ROOT, "top: done warm merge " + info + ": took %.3f sec, %.1f MB", - (System.nanoTime() - startNS) / 1000000000., + (System.nanoTime() - startNS) / (double) TimeUnit.SECONDS.toNanos(1), info.sizeInBytes() / 1024 / 1024.)); primary.finishedMergedFiles.addAll(filesMetaData.keySet()); } diff --git a/lucene/replicator/src/java/org/apache/lucene/replicator/nrt/ReplicaNode.java b/lucene/replicator/src/java/org/apache/lucene/replicator/nrt/ReplicaNode.java index eadff6afd89..c3d79b84843 100644 --- a/lucene/replicator/src/java/org/apache/lucene/replicator/nrt/ReplicaNode.java +++ b/lucene/replicator/src/java/org/apache/lucene/replicator/nrt/ReplicaNode.java @@ -33,6 +33,7 @@ import java.util.Objects; import java.util.Set; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap; +import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicBoolean; import org.apache.lucene.index.IndexFileNames; import org.apache.lucene.index.IndexWriter; @@ -298,7 +299,7 @@ public abstract class ReplicaNode extends Node { Locale.ROOT, "top: %d: start: done sync: took %.3fs for %s, opened NRT reader version=%d", id, - (System.nanoTime() - initSyncStartNS) / 1000000000.0, + (System.nanoTime() - initSyncStartNS) / (double) TimeUnit.SECONDS.toNanos(1), bytesToString(job.getTotalBytesCopied()), job.getCopyState().version)); @@ -491,7 +492,7 @@ public abstract class ReplicaNode extends Node { String.format( Locale.ROOT, "top: done sync: took %.3fs for %s, opened NRT reader version=%d markerCount=%d", - (System.nanoTime() - startNS) / 1000000000.0, + (System.nanoTime() - startNS) / (double) TimeUnit.SECONDS.toNanos(1), bytesToString(job.getTotalBytesCopied()), copyState.version, markerCount)); diff --git a/lucene/replicator/src/test/org/apache/lucene/replicator/nrt/SimpleCopyJob.java b/lucene/replicator/src/test/org/apache/lucene/replicator/nrt/SimpleCopyJob.java index a353b1e9b05..ad410989554 100644 --- a/lucene/replicator/src/test/org/apache/lucene/replicator/nrt/SimpleCopyJob.java +++ b/lucene/replicator/src/test/org/apache/lucene/replicator/nrt/SimpleCopyJob.java @@ -23,6 +23,7 @@ import java.util.Iterator; import java.util.Locale; import java.util.Map; import java.util.Set; +import java.util.concurrent.TimeUnit; import org.apache.lucene.util.IOUtils; /** @@ -151,7 +152,7 @@ class SimpleCopyJob extends CopyJob { String.format( Locale.ROOT, "top: file copy done; took %.1f msec to copy %d bytes; now rename %d tmp files", - (System.nanoTime() - startNS) / 1000000.0, + (System.nanoTime() - startNS) / (double) TimeUnit.MILLISECONDS.toNanos(1), totBytesCopied, copiedFiles.size())); diff --git a/lucene/replicator/src/test/org/apache/lucene/replicator/nrt/SimplePrimaryNode.java b/lucene/replicator/src/test/org/apache/lucene/replicator/nrt/SimplePrimaryNode.java index 2617ecfda6d..a5349abf0d3 100644 --- a/lucene/replicator/src/test/org/apache/lucene/replicator/nrt/SimplePrimaryNode.java +++ b/lucene/replicator/src/test/org/apache/lucene/replicator/nrt/SimplePrimaryNode.java @@ -34,6 +34,7 @@ import java.util.Locale; import java.util.Map; import java.util.Random; import java.util.Set; +import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicBoolean; import org.apache.lucene.document.Document; import org.apache.lucene.document.Field; @@ -245,7 +246,7 @@ class SimplePrimaryNode extends PrimaryNode { + " to " + preCopy.connections.size() + " replicas for %.1f sec...", - (ns - startNS) / 1000000000.0)); + (ns - startNS) / (double) TimeUnit.SECONDS.toNanos(1))); lastWarnNS = ns; } diff --git a/lucene/replicator/src/test/org/apache/lucene/replicator/nrt/TestNRTReplication.java b/lucene/replicator/src/test/org/apache/lucene/replicator/nrt/TestNRTReplication.java index e01cf3e3ae6..2af7a68bdb6 100644 --- a/lucene/replicator/src/test/org/apache/lucene/replicator/nrt/TestNRTReplication.java +++ b/lucene/replicator/src/test/org/apache/lucene/replicator/nrt/TestNRTReplication.java @@ -26,6 +26,7 @@ import java.nio.file.Path; import java.util.ArrayList; import java.util.List; import java.util.Locale; +import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicLong; import java.util.regex.Pattern; @@ -1000,7 +1001,7 @@ public class TestNRTReplication extends LuceneTestCase { String.format( Locale.ROOT, "%5.3fs : parent [%11s] %s", - (now - Node.globalStartNS) / 1000000000., + (now - Node.globalStartNS) / (double) TimeUnit.SECONDS.toNanos(1), Thread.currentThread().getName(), message)); } diff --git a/lucene/replicator/src/test/org/apache/lucene/replicator/nrt/TestStressNRTReplication.java b/lucene/replicator/src/test/org/apache/lucene/replicator/nrt/TestStressNRTReplication.java index ed1bb97af93..def80b121b6 100644 --- a/lucene/replicator/src/test/org/apache/lucene/replicator/nrt/TestStressNRTReplication.java +++ b/lucene/replicator/src/test/org/apache/lucene/replicator/nrt/TestStressNRTReplication.java @@ -39,6 +39,7 @@ import java.util.Locale; import java.util.Map; import java.util.Set; import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicLong; @@ -526,8 +527,8 @@ public class TestStressNRTReplication extends LuceneTestCase { long t1 = System.nanoTime(); message( "top: done translog replay; took " - + ((t1 - t0) / 1000000.0) - + " msec; now publish primary"); + + ((t1 - t0) / (double) TimeUnit.MILLISECONDS.toNanos(1)) + + " ms; now publish primary"); // Publish new primary only after translog has succeeded in replaying; this is important, for // this test anyway, so we keep a "linear" @@ -901,7 +902,7 @@ public class TestStressNRTReplication extends LuceneTestCase { long nowNS = System.nanoTime(); for (int i = 0; i < nodes.length; i++) { b.append(' '); - double sec = (nowNS - nodeTimeStamps[i]) / 1000000000.0; + double sec = (nowNS - nodeTimeStamps[i]) / (double) TimeUnit.SECONDS.toNanos(1); String prefix; if (nodes[i] == null) { downNodes.add(i); @@ -1293,7 +1294,7 @@ public class TestStressNRTReplication extends LuceneTestCase { if (random().nextInt(100) == 17) { int pauseMS = TestUtil.nextInt(random(), 500, 2000); - System.out.println("Indexer: now pause for " + pauseMS + " msec..."); + System.out.println("Indexer: now pause for " + pauseMS + " ms..."); Thread.sleep(pauseMS); System.out.println("Indexer: done pause for a bit..."); } @@ -1335,7 +1336,7 @@ public class TestStressNRTReplication extends LuceneTestCase { String.format( Locale.ROOT, "%5.3fs : parent [%11s] %s", - (now - Node.globalStartNS) / 1000000000., + (now - Node.globalStartNS) / (double) TimeUnit.SECONDS.toNanos(1), Thread.currentThread().getName(), message)); } @@ -1346,8 +1347,8 @@ public class TestStressNRTReplication extends LuceneTestCase { String.format( Locale.ROOT, "%5.3fs %5.1fs: parent [%11s] %s", - (now - Node.globalStartNS) / 1000000000., - (now - localStartNS) / 1000000000., + (now - Node.globalStartNS) / (double) TimeUnit.SECONDS.toNanos(1), + (now - localStartNS) / (double) TimeUnit.SECONDS.toNanos(1), Thread.currentThread().getName(), message)); } diff --git a/lucene/suggest/src/java/org/apache/lucene/search/suggest/analyzing/AnalyzingInfixSuggester.java b/lucene/suggest/src/java/org/apache/lucene/search/suggest/analyzing/AnalyzingInfixSuggester.java index 0c73fe1b69a..77a92c3217f 100644 --- a/lucene/suggest/src/java/org/apache/lucene/search/suggest/analyzing/AnalyzingInfixSuggester.java +++ b/lucene/suggest/src/java/org/apache/lucene/search/suggest/analyzing/AnalyzingInfixSuggester.java @@ -751,7 +751,7 @@ public class AnalyzingInfixSuggester extends Lookup implements Closeable { mgr.release(searcher); } - // System.out.println((System.currentTimeMillis() - t0) + " msec for infix suggest"); + // System.out.println((System.currentTimeMillis() - t0) + " ms for infix suggest"); // System.out.println(results); return results; diff --git a/lucene/test-framework/src/java/org/apache/lucene/tests/index/ThreadedIndexingAndSearchingTestCase.java b/lucene/test-framework/src/java/org/apache/lucene/tests/index/ThreadedIndexingAndSearchingTestCase.java index e65ba808b81..68cdc753bb9 100644 --- a/lucene/test-framework/src/java/org/apache/lucene/tests/index/ThreadedIndexingAndSearchingTestCase.java +++ b/lucene/test-framework/src/java/org/apache/lucene/tests/index/ThreadedIndexingAndSearchingTestCase.java @@ -583,7 +583,7 @@ public abstract class ThreadedIndexingAndSearchingTestCase extends LuceneTestCas "TEST: DONE start " + NUM_INDEX_THREADS + " indexing threads [" - + (System.nanoTime() - t0) / 1_000_000 + + TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - t0) + " ms]"); } @@ -594,7 +594,9 @@ public abstract class ThreadedIndexingAndSearchingTestCase extends LuceneTestCas if (VERBOSE) { System.out.println( - "TEST: all searching done [" + (System.nanoTime() - t0) / 1_000_000 + " ms]"); + "TEST: all searching done [" + + TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - t0) + + " ms]"); } for (Thread thread : indexThreads) { @@ -604,7 +606,7 @@ public abstract class ThreadedIndexingAndSearchingTestCase extends LuceneTestCas if (VERBOSE) { System.out.println( "TEST: done join indexing threads [" - + (System.nanoTime() - t0) / 1_000_000 + + TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - t0) + " ms]; addCount=" + addCount + " delCount=" @@ -765,7 +767,8 @@ public abstract class ThreadedIndexingAndSearchingTestCase extends LuceneTestCas dir.close(); if (VERBOSE) { - System.out.println("TEST: done [" + (System.nanoTime() - t0) / 1_000_000 + " ms]"); + System.out.println( + "TEST: done [" + TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - t0) + " ms]"); } } diff --git a/lucene/test-framework/src/java/org/apache/lucene/tests/util/ThrottledIndexOutput.java b/lucene/test-framework/src/java/org/apache/lucene/tests/util/ThrottledIndexOutput.java index d24368ee5af..013bdc21d3d 100644 --- a/lucene/test-framework/src/java/org/apache/lucene/tests/util/ThrottledIndexOutput.java +++ b/lucene/test-framework/src/java/org/apache/lucene/tests/util/ThrottledIndexOutput.java @@ -17,6 +17,7 @@ package org.apache.lucene.tests.util; import java.io.IOException; +import java.util.concurrent.TimeUnit; import org.apache.lucene.store.DataInput; import org.apache.lucene.store.IndexOutput; import org.apache.lucene.util.ThreadInterruptedException; @@ -117,7 +118,7 @@ public class ThrottledIndexOutput extends IndexOutput { long actualBps = (timeElapsed / pendingBytes) * 1000000000l; // nano to sec if (actualBps > bytesPerSecond) { long expected = (pendingBytes * 1000l / bytesPerSecond); - final long delay = expected - (timeElapsed / 1000000l); + final long delay = expected - TimeUnit.NANOSECONDS.toMillis(timeElapsed); pendingBytes = 0; timeElapsed = 0; return delay;