How to use

nanoTime

method

in

org.apache.samza.util.HighResolutionClock

 @Override
 public void run() {
  final long actualDelay = clock.nanoTime() - startTimeNs;
  addToPendingNanos(-actualDelay);
  callback.run();
 }
}, delay, TimeUnit.NANOSECONDS);

 @Override
 public void run() {
  final long actualDelay = clock.nanoTime() - startTimeNs;
  addToPendingNanos(-actualDelay);
  callback.run();
 }
}, delay, TimeUnit.NANOSECONDS);

 @Override
 public void run() {
  final long actualDelay = clock.nanoTime() - startTimeNs;
  addToPendingNanos(-actualDelay);
  callback.run();
 }
}, delay, TimeUnit.NANOSECONDS);

 @Override
 public void run() {
  final long actualDelay = clock.nanoTime() - startTimeNs;
  addToPendingNanos(-actualDelay);
  callback.run();
 }
}, delay, TimeUnit.NANOSECONDS);

 @Override
 public void run() {
  final long actualDelay = clock.nanoTime() - startTimeNs;
  addToPendingNanos(-actualDelay);
  callback.run();
 }
}, delay, TimeUnit.NANOSECONDS);

private <T> T instrument(Counter counter, Timer timer, Supplier<T> func) {
 incCounter(counter);
 long startNs = clock.nanoTime();
 T result = func.get();
 updateTimer(timer, clock.nanoTime() - startNs);
 return result;
}

@Override
public synchronized void flush() {
 incCounter(metrics.numFlushes);
 long startNs = clock.nanoTime();
 Preconditions.checkNotNull(table, "Cannot flush a read-only table: " + table);
 table.flush();
 updateTimer(metrics.flushNs, clock.nanoTime() - startNs);
}

private void instrument(Counter counter, Timer timer, Func0 func) {
 incCounter(counter);
 long startNs = clock.nanoTime();
 func.apply();
 updateTimer(timer, clock.nanoTime() - startNs);
}

@Override
public void flush() {
 try {
  incCounter(metrics.numFlushes);
  long startNs = clock.nanoTime();
  asyncTable.flush();
  updateTimer(metrics.flushNs, clock.nanoTime() - startNs);
 } catch (Exception e) {
  String errMsg = "Failed to flush remote store";
  logger.error(errMsg, e);
  throw new SamzaException(errMsg, e);
 }
}

 protected <T> CompletableFuture<T> instrument(Func1<T> func, Counter counter, Timer timer) {
  incCounter(counter);
  final long startNs = clock.nanoTime();
  CompletableFuture<T> ioFuture = func.apply();
  if (callbackExecutor != null) {
   ioFuture.thenApplyAsync(r -> {
     updateTimer(timer, clock.nanoTime() - startNs);
     return r;
    }, callbackExecutor);
  } else {
   ioFuture.thenApply(r -> {
     updateTimer(timer, clock.nanoTime() - startNs);
     return r;
    });
  }
  return ioFuture;
 }
}

/**
 * Handle timer ticks for this {@link OperatorImpl} and propagate the results and timer tick to registered operators.
 * <p>
 * Delegates to {@link #handleTimer(MessageCollector, TaskCoordinator)} for handling the timer tick.
 *
 * @param collector  the {@link MessageCollector} in the context
 * @param coordinator  the {@link TaskCoordinator} in the context
 */
public final void onTimer(MessageCollector collector, TaskCoordinator coordinator) {
 long startNs = this.highResClock.nanoTime();
 Collection<RM> results = handleTimer(collector, coordinator);
 long endNs = this.highResClock.nanoTime();
 this.handleTimerNs.update(endNs - startNs);
 results.forEach(rm ->
   this.registeredOperators.forEach(op ->
     op.onMessage(rm, collector, coordinator)));
 this.registeredOperators.forEach(op ->
   op.onTimer(collector, coordinator));
}

@Override
public CompletableFuture<Void> deleteAsync(K key) {
 incCounter(metrics.numDeletes);
 long startNs = clock.nanoTime();
 Preconditions.checkNotNull(table, "Cannot delete from a read-only table: " + table);
 return table.deleteAsync(key).handle((result, e) -> {
   if (e != null) {
    throw new SamzaException("Failed to delete the record for " + key, e);
   } else if (!isWriteAround) {
    cache.delete(key);
   }
   updateTimer(metrics.deleteNs, clock.nanoTime() - startNs);
   return result;
  });
}

@Override
public CompletableFuture<Void> deleteAllAsync(List<K> keys) {
 incCounter(metrics.numDeleteAlls);
 long startNs = clock.nanoTime();
 Preconditions.checkNotNull(table, "Cannot delete from a read-only table: " + table);
 return table.deleteAllAsync(keys).handle((result, e) -> {
   if (e != null) {
    throw new SamzaException("Failed to delete the record for " + keys, e);
   } else if (!isWriteAround) {
    cache.deleteAll(keys);
   }
   updateTimer(metrics.deleteAllNs, clock.nanoTime() - startNs);
   return result;
  });
}

private void setActualDelay(long actualDelayNs) {
 Mockito.when(clock.nanoTime()).thenReturn(0L).thenReturn(actualDelayNs);
}

@Override
public CompletableFuture<Void> putAllAsync(List<Entry<K, V>> records) {
 incCounter(metrics.numPutAlls);
 long startNs = clock.nanoTime();
 Preconditions.checkNotNull(table, "Cannot write to a read-only table: " + table);
 return table.putAllAsync(records).handle((result, e) -> {
   if (e != null) {
    throw new SamzaException("Failed to put records " + records, e);
   } else if (!isWriteAround) {
    cache.putAll(records);
   }
   updateTimer(metrics.putAllNs, clock.nanoTime() - startNs);
   return result;
  });
}

private void setWorkTime(long workTimeNanos) {
 Mockito.when(clock.nanoTime()).thenReturn(0L).thenReturn(workTimeNanos);
}

@Override
public CompletableFuture<Void> putAsync(K key, V value) {
 incCounter(metrics.numPuts);
 Preconditions.checkNotNull(table, "Cannot write to a read-only table: " + table);
 long startNs = clock.nanoTime();
 return table.putAsync(key, value).handle((result, e) -> {
   if (e != null) {
    throw new SamzaException(String.format("Failed to put a record, key=%s, value=%s", key, value), e);
   } else if (!isWriteAround) {
    if (value == null) {
     cache.delete(key);
    } else {
     cache.put(key, value);
    }
   }
   updateTimer(metrics.putNs, clock.nanoTime() - startNs);
   return result;
  });
}

 @Override
 public void run() {
  try {
   containerMetrics.commits().inc();
   long startTime = clock.nanoTime();
   task.commit();
   containerMetrics.commitNs().update(clock.nanoTime() - startTime);
   state.doneCommit();
  } catch (Throwable t) {
   log.error("Task {} commit failed", task.taskName(), t);
   abort(t);
  } finally {
   log.trace("Task {} commit completed", task.taskName());
   resume();
  }
 }
};

 @Override
 public void run() {
  try {
   ReadableCoordinator coordinator = new ReadableCoordinator(task.taskName());
   long startTime = clock.nanoTime();
   task.scheduler(coordinator);
   containerMetrics.timerNs().update(clock.nanoTime() - startTime);
   coordinatorRequests.update(coordinator);
   state.doneScheduler();
  } catch (Throwable t) {
   log.error("Task {} scheduler failed", task.taskName(), t);
   abort(t);
  } finally {
   log.trace("Task {} scheduler completed", task.taskName());
   resume();
  }
 }
};

 @Override
 public void run() {
  try {
   ReadableCoordinator coordinator = new ReadableCoordinator(task.taskName());
   long startTime = clock.nanoTime();
   task.scheduler(coordinator);
   containerMetrics.timerNs().update(clock.nanoTime() - startTime);
   coordinatorRequests.update(coordinator);
   state.doneScheduler();
  } catch (Throwable t) {
   log.error("Task {} scheduler failed", task.taskName(), t);
   abort(t);
  } finally {
   log.trace("Task {} scheduler completed", task.taskName());
   resume();
  }
 }
};