@Override public long checkFrequencyMillis() { return Stream.of( thresholds ) .mapToLong( CheckPointThreshold::checkFrequencyMillis ) .min().orElse( DEFAULT_CHECKING_FREQUENCY_MILLIS ); } };
public static long min(long... nums) { if(nums.length == 0) return Long.MIN_VALUE; return Arrays.stream(nums).min().getAsLong(); }
private synchronized boolean allAssignmentsHavePropagated(Iterable<QueryExecution> queries) { if (nodes.isEmpty()) { // Assignments can't have propagated, if there are no visible nodes. return false; } long newestAssignment = ImmutableList.copyOf(queries).stream() .map(QueryExecution::getMemoryPool) .mapToLong(VersionedMemoryPoolId::getVersion) .min() .orElse(-1); long mostOutOfDateNode = nodes.values().stream() .mapToLong(RemoteNodeMemory::getCurrentAssignmentVersion) .min() .orElse(Long.MAX_VALUE); return newestAssignment <= mostOutOfDateNode; }
@Override public OptionalLong getMinStoreFileAge() { return getStoreFileAgeStream().min(); }
@Override public ColdTestPublisher<T> assertMinRequested(long n) { ColdTestPublisherSubscription<T>[] subs = subscribers; long minRequest = Stream.of(subs) .mapToLong(s -> s.requested) .min() .orElse(0); if (minRequest < n) { throw new AssertionError("Expected minimum request of " + n + "; got " + minRequest); } return this; }
@Override public DefaultTestPublisher<T> assertMinRequested(long n) { TestPublisherSubscription<T>[] subs = subscribers; long minRequest = Stream.of(subs) .mapToLong(s -> s.requested) .min() .orElse(0); if (minRequest < n) { throw new AssertionError("Expected minimum request of " + n + "; got " + minRequest); } return this; }
@Override public OptionalLong execute() { try (final LongStream stream = buildPrevious()) { return stream.min(); } } }
default OptionalLong min(LongPipeline pipeline) { requireNonNull(pipeline); return optimize(pipeline).getAsLongStream().min(); }
private long computeCost() { OptionalLong minRequiredCost = Stream.concat( subs.get(Occur.MUST).stream(), subs.get(Occur.FILTER).stream()) .mapToLong(ScorerSupplier::cost) .min(); if (minRequiredCost.isPresent() && minShouldMatch == 0) { return minRequiredCost.getAsLong(); } else { final Collection<ScorerSupplier> optionalScorers = subs.get(Occur.SHOULD); final long shouldCost = MinShouldMatchSumScorer.cost( optionalScorers.stream().mapToLong(ScorerSupplier::cost), optionalScorers.size(), minShouldMatch); return Math.min(minRequiredCost.orElse(Long.MAX_VALUE), shouldCost); } }
default long getLastMajorCompactionTimestamp(TableName table) { return getLiveServerMetrics().values().stream() .flatMap(s -> s.getRegionMetrics().values().stream()) .filter(r -> RegionInfo.getTable(r.getRegionName()).equals(table)) .mapToLong(RegionMetrics::getLastMajorCompactionTimestamp).min().orElse(0); }
/** * Discards tombstones no longer needed by active transactions. */ private void discardTombstones() { if (activeTransactions.isEmpty()) { Iterator<Map.Entry<K, MapEntryValue>> iterator = entries().entrySet().iterator(); while (iterator.hasNext()) { MapEntryValue value = iterator.next().getValue(); if (value.type() == MapEntryValue.Type.TOMBSTONE) { iterator.remove(); } } } else { long lowWaterMark = activeTransactions.values().stream() .mapToLong(TransactionScope::version) .min().getAsLong(); Iterator<Map.Entry<K, MapEntryValue>> iterator = entries().entrySet().iterator(); while (iterator.hasNext()) { MapEntryValue value = iterator.next().getValue(); if (value.type() == MapEntryValue.Type.TOMBSTONE && value.version < lowWaterMark) { iterator.remove(); } } } }
/** * Return a list of boundaries for multiple compaction output in ascending order. */ private List<Long> getCompactBoundariesForMajor(Collection<HStoreFile> filesToCompact, long now) { long minTimestamp = filesToCompact.stream().mapToLong(f -> f.getMinimumTimestamp().orElse(Long.MAX_VALUE)).min() .orElse(Long.MAX_VALUE); List<Long> boundaries = new ArrayList<>(); // Add startMillis of all windows between now and min timestamp for (CompactionWindow window = getIncomingWindow(now); window .compareToTimestamp(minTimestamp) > 0; window = window.nextEarlierWindow()) { boundaries.add(window.startMillis()); } boundaries.add(Long.MIN_VALUE); Collections.reverse(boundaries); return boundaries; }
private static DocIdSetIterator createConjunction( List<DocIdSetIterator> allIterators, List<TwoPhaseIterator> twoPhaseIterators) { long minCost = allIterators.stream().mapToLong(DocIdSetIterator::cost).min().getAsLong(); List<BitSetIterator> bitSetIterators = new ArrayList<>(); List<DocIdSetIterator> iterators = new ArrayList<>(); for (DocIdSetIterator iterator : allIterators) { if (iterator.cost() > minCost && iterator instanceof BitSetIterator) { // we put all bitset iterators into bitSetIterators // except if they have the minimum cost, since we need // them to lead the iteration in that case bitSetIterators.add((BitSetIterator) iterator); } else { iterators.add(iterator); } } DocIdSetIterator disi; if (iterators.size() == 1) { disi = iterators.get(0); } else { disi = new ConjunctionDISI(iterators); } if (bitSetIterators.size() > 0) { disi = new BitSetConjunctionDISI(disi, bitSetIterators); } if (twoPhaseIterators.isEmpty() == false) { disi = TwoPhaseIterator.asDocIdSetIterator(new ConjunctionTwoPhaseIterator(disi, twoPhaseIterators)); } return disi; }
final long serverTtl = records.stream().mapToLong(DnsRecord::timeToLive).min().orElse(minTtl); final int effectiveTtl = (int) Math.max(Math.min(serverTtl, maxTtl), minTtl);
long min = initialData.stream() .mapToLong(keyFunction::apply) .min() .getAsLong(); long max = initialData.stream()
private long getSCPProcId(ProcedureExecutor<?> procExec) { util.waitFor(30000, () -> !procExec.getProcedures().isEmpty()); return procExec.getActiveProcIds().stream().mapToLong(Long::longValue).min().getAsLong(); }
highestWeightForDominationTest = router.weight(discoveredSolutions.get(discoveredSolutions.size()-1)); } else { highestWeightForDominationTest = discoveredSolutions.stream().filter(s -> !s.impossible && (ignoreTransfers || s.nTransfers <= 1)).mapToLong(router::weight).min().orElse(Long.MAX_VALUE);
private void testAvgMinMaxCounter(AvgMinMaxCounter metric, int size) { final long[] values = generateRandomValues(size); for (long value : values) { metric.add(value); } long expectedMin = Arrays.stream(values).min().orElse(0); long expectedMax = Arrays.stream(values).max().orElse(0); long expectedSum = Arrays.stream(values).sum(); long expectedCnt = values.length; double expectedAvg = expectedSum / Math.max(1, expectedCnt); Assert.assertEquals(expectedAvg, metric.getAvg(), (double)200); Assert.assertEquals(expectedMin, metric.getMin()); Assert.assertEquals(expectedMax, metric.getMax()); Assert.assertEquals(expectedCnt, metric.getCount()); Assert.assertEquals(expectedSum, metric.getTotal()); final Map<String, Object> results = metric.values(); Assert.assertEquals(expectedMax, (long)results.get("max_test")); Assert.assertEquals(expectedMin, (long)results.get("min_test")); Assert.assertEquals(expectedCnt, (long)results.get("cnt_test")); Assert.assertEquals(expectedAvg, (double)results.get("avg_test"), (double)200); metric.reset(); }
assertEquals(numberOfCell, memstore.getSegments().stream().mapToInt(Segment::getCellsCount).sum()); assertEquals(minTs, memstore.getSegments().stream().mapToLong( m -> m.getTimeRangeTracker().getMin()).min().getAsLong()); assertEquals(currentTs, memstore.getSegments().stream().mapToLong( m -> m.getTimeRangeTracker().getMax()).max().getAsLong()); assertEquals(numberOfCell, memstore.getSegments().stream().mapToInt(Segment::getCellsCount).sum()); assertEquals(minTs, memstore.getSegments().stream().mapToLong( m -> m.getTimeRangeTracker().getMin()).min().getAsLong()); assertEquals(currentTs, memstore.getSegments().stream().mapToLong( m -> m.getTimeRangeTracker().getMax()).max().getAsLong()); m -> m.getTimeRangeTracker().getMin()).min().getAsLong()); assertEquals(currentTs, memstore.getSegments().stream().mapToLong( m -> m.getTimeRangeTracker().getMax()).max().getAsLong());
long procId = procExec.getProcedures().stream() .filter(p -> p instanceof TransitPeerSyncReplicationStateProcedure && !p.isFinished()) .mapToLong(Procedure::getProcId).min().getAsLong(); MasterProcedureTestingUtility.testRecoveryAndDoubleExecution(procExec, procId); ProcedureTestingUtility.setKillAndToggleBeforeStoreUpdate(procExec, false);