@Override public void finish() { OperationTimer timer = new OperationTimer(statisticsCpuTimerEnabled); statisticsAggregationOperator.finish(); timer.end(statisticsTiming); if (state == State.RUNNING) { state = State.FINISHING; } }
void recordFinish(OperationTimer operationTimer) { operationTimer.recordOperationComplete(finishTiming); }
void end(OperationTiming overallTiming) { requireNonNull(overallTiming, "overallTiming is null"); checkState(!finished, "timer is finished"); finished = true; long cpuEnd = trackOverallCpuTime ? currentThreadCpuTime() : 0; long wallEnd = System.nanoTime(); overallTiming.record(nanosBetween(wallStart, wallEnd), nanosBetween(cpuStart, cpuEnd)); }
@Test public void testOperationAfterEndAreNotAllowed() { OperationTiming timing = new OperationTiming(); OperationTimer timer = new OperationTimer(true, false); timer.end(timing); assertThatThrownBy(() -> timer.end(timing)).isInstanceOf(IllegalStateException.class); assertThatThrownBy(() -> timer.recordOperationComplete(timing)).isInstanceOf(IllegalStateException.class); }
@Test public void testInvalidConstructorArguments() { assertThatThrownBy(() -> new OperationTimer(false, true)).isInstanceOf(IllegalArgumentException.class); }
public void recordProcessed(OperationTimer operationTimer) { operationTimer.end(overallTiming); }
OperationTimer(boolean trackOverallCpuTime, boolean trackOperationCpuTime) { this.trackOverallCpuTime = trackOverallCpuTime; this.trackOperationCpuTime = trackOperationCpuTime; checkArgument(trackOverallCpuTime || !trackOperationCpuTime, "tracking operation cpu time without tracking overall cpu time is not supported"); wallStart = System.nanoTime(); cpuStart = trackOverallCpuTime ? currentThreadCpuTime() : 0; intervalWallStart = wallStart; intervalCpuStart = cpuStart; }
private OperationTimer createTimer() { return new OperationTimer( driverContext.isCpuTimerEnabled(), driverContext.isCpuTimerEnabled() && driverContext.isPerOperatorCpuTimerEnabled()); }
@Override public void finish() { ListenableFuture<?> currentlyBlocked = blocked; OperationTimer timer = new OperationTimer(statisticsCpuTimerEnabled); statisticAggregationOperator.finish(); timer.end(statisticsTiming); ListenableFuture<?> blockedOnAggregation = statisticAggregationOperator.isBlocked(); ListenableFuture<?> blockedOnFinish = NOT_BLOCKED; if (state == State.RUNNING) { state = State.FINISHING; finishFuture = pageSink.finish(); blockedOnFinish = toListenableFuture(finishFuture); updateWrittenBytes(); } this.blocked = allAsList(currentlyBlocked, blockedOnAggregation, blockedOnFinish); }
private void testOverallTiming(boolean trackCpuTime) { InternalTiming timing = new InternalTiming(trackCpuTime); for (int i = 1; i <= 5; i++) { OperationTimer timer = new OperationTimer(trackCpuTime, false); doSomething(); timing.record(timer::end); } }
void recordAddInput(OperationTimer operationTimer, Page page) { operationTimer.recordOperationComplete(addInputTiming); if (page != null) { inputDataSize.update(page.getSizeInBytes()); inputPositions.update(page.getPositionCount()); } }
void recordOperationComplete(OperationTiming operationTiming) { requireNonNull(operationTiming, "operationTiming is null"); checkState(!finished, "timer is finished"); long intervalCpuEnd = trackOperationCpuTime ? currentThreadCpuTime() : 0; long intervalWallEnd = System.nanoTime(); long operationWallNanos = nanosBetween(intervalWallStart, intervalWallEnd); long operationCpuNanos = trackOperationCpuTime ? nanosBetween(intervalCpuStart, intervalCpuEnd) : 0; operationTiming.record(operationWallNanos, operationCpuNanos); intervalWallStart = intervalWallEnd; intervalCpuStart = intervalCpuEnd; }
@Override public void addInput(Page page) { requireNonNull(page, "page is null"); checkState(needsInput(), "Operator does not need input"); Block[] blocks = new Block[columnChannels.size()]; for (int outputChannel = 0; outputChannel < columnChannels.size(); outputChannel++) { blocks[outputChannel] = page.getBlock(columnChannels.get(outputChannel)); } OperationTimer timer = new OperationTimer(statisticsCpuTimerEnabled); statisticAggregationOperator.addInput(page); timer.end(statisticsTiming); ListenableFuture<?> blockedOnAggregation = statisticAggregationOperator.isBlocked(); CompletableFuture<?> future = pageSink.appendPage(new Page(blocks)); updateMemoryUsage(); ListenableFuture<?> blockedOnWrite = toListenableFuture(future); blocked = allAsList(blockedOnAggregation, blockedOnWrite); rowCount += page.getPositionCount(); updateWrittenBytes(); }
private void testOperationTiming(boolean trackCpuTime) { InternalTiming overallTiming = new InternalTiming(true); InternalTiming operationTiming1 = new InternalTiming(trackCpuTime); InternalTiming operationTiming2 = new InternalTiming(trackCpuTime); InternalTiming operationTiming3 = new InternalTiming(trackCpuTime); OperationTimer timer = new OperationTimer(true, trackCpuTime); doSomething(); operationTiming1.record(timer::recordOperationComplete); doSomething(); operationTiming1.record(timer::recordOperationComplete); doSomething(); operationTiming2.record(timer::recordOperationComplete); doSomething(); operationTiming1.record(timer::recordOperationComplete); doSomething(); operationTiming2.record(timer::recordOperationComplete); doSomething(); operationTiming3.record(timer::recordOperationComplete); overallTiming.record(timer::end); assertThat(operationTiming1.getTiming().getWallNanos() + operationTiming2.getTiming().getWallNanos() + operationTiming3.getTiming().getWallNanos()) .isLessThanOrEqualTo(overallTiming.getTiming().getWallNanos()); assertThat(operationTiming1.getTiming().getCpuNanos() + operationTiming2.getTiming().getCpuNanos() + operationTiming3.getTiming().getCpuNanos()) .isLessThanOrEqualTo(overallTiming.getTiming().getCpuNanos()); }
void recordGetOutput(OperationTimer operationTimer, Page page) { operationTimer.recordOperationComplete(getOutputTiming); if (page != null) { outputDataSize.update(page.getSizeInBytes()); outputPositions.update(page.getPositionCount()); } }
@Override public void addInput(Page page) { requireNonNull(page, "page is null"); checkState(state == State.RUNNING, "Operator is %s", state); Block rowCountBlock = page.getBlock(ROW_COUNT_CHANNEL); Block fragmentBlock = page.getBlock(FRAGMENT_CHANNEL); for (int position = 0; position < page.getPositionCount(); position++) { if (!rowCountBlock.isNull(position)) { rowCount += BIGINT.getLong(rowCountBlock, position); } if (!fragmentBlock.isNull(position)) { fragmentBuilder.add(VARBINARY.getSlice(fragmentBlock, position)); } } extractStatisticsRows(page).ifPresent(statisticsPage -> { OperationTimer timer = new OperationTimer(statisticsCpuTimerEnabled); statisticsAggregationOperator.addInput(statisticsPage); timer.end(statisticsTiming); }); }
OperationTimer timer = new OperationTimer(statisticsCpuTimerEnabled); Page aggregationOutput = statisticAggregationOperator.getOutput(); timer.end(statisticsTiming);
verify(statisticsAggregationOperator.isBlocked().isDone(), "aggregation operator should not be blocked"); OperationTimer timer = new OperationTimer(statisticsCpuTimerEnabled); Page page = statisticsAggregationOperator.getOutput(); timer.end(statisticsTiming);