congrats Icon
New! Tabnine Pro 14-day free trial
Start a free trial
Tabnine Logo
HighResolutionClock.nanoTime
Code IndexAdd Tabnine to your IDE (free)

How to use
nanoTime
method
in
org.apache.samza.util.HighResolutionClock

Best Java code snippets using org.apache.samza.util.HighResolutionClock.nanoTime (Showing top 20 results out of 315)

origin: org.apache.samza/samza-core_2.10

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

 @Override
 public void run() {
  final long actualDelay = clock.nanoTime() - startTimeNs;
  addToPendingNanos(-actualDelay);
  callback.run();
 }
}, delay, TimeUnit.NANOSECONDS);
origin: org.apache.samza/samza-core_2.11

 @Override
 public void run() {
  final long actualDelay = clock.nanoTime() - startTimeNs;
  addToPendingNanos(-actualDelay);
  callback.run();
 }
}, delay, TimeUnit.NANOSECONDS);
origin: org.apache.samza/samza-core_2.12

 @Override
 public void run() {
  final long actualDelay = clock.nanoTime() - startTimeNs;
  addToPendingNanos(-actualDelay);
  callback.run();
 }
}, delay, TimeUnit.NANOSECONDS);
origin: org.apache.samza/samza-core

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

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;
}
origin: apache/samza

@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);
}
origin: apache/samza

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

@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);
 }
}
origin: apache/samza

 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;
 }
}
origin: apache/samza

/**
 * 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));
}
origin: apache/samza

@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;
  });
}
origin: apache/samza

@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;
  });
}
origin: apache/samza

private void setActualDelay(long actualDelayNs) {
 Mockito.when(clock.nanoTime()).thenReturn(0L).thenReturn(actualDelayNs);
}
origin: apache/samza

@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;
  });
}
origin: apache/samza

private void setWorkTime(long workTimeNanos) {
 Mockito.when(clock.nanoTime()).thenReturn(0L).thenReturn(workTimeNanos);
}
origin: apache/samza

@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;
  });
}
origin: apache/samza

 @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();
  }
 }
};
origin: apache/samza

 @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();
  }
 }
};
origin: org.apache.samza/samza-core_2.11

 @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();
  }
 }
};
org.apache.samza.utilHighResolutionClocknanoTime

Javadoc

Returns a time point that can be used to calculate the difference in nanoseconds with another time point. Resolution of the timer is platform dependent and not guaranteed to actually operate at nanosecond precision.

Popular methods of HighResolutionClock

    Popular in Java

    • Start an intent from android
    • compareTo (BigDecimal)
    • getSystemService (Context)
    • getContentResolver (Context)
    • String (java.lang)
    • MalformedURLException (java.net)
      This exception is thrown when a program attempts to create an URL from an incorrect specification.
    • TreeMap (java.util)
      Walk the nodes of the tree left-to-right or right-to-left. Note that in descending iterations, next
    • ExecutorService (java.util.concurrent)
      An Executor that provides methods to manage termination and methods that can produce a Future for tr
    • Stream (java.util.stream)
      A sequence of elements supporting sequential and parallel aggregate operations. The following exampl
    • Get (org.apache.hadoop.hbase.client)
      Used to perform Get operations on a single row. To get everything for a row, instantiate a Get objec
    • Top 25 Plugins for Webstorm
    Tabnine Logo
    • Products

      Search for Java codeSearch for JavaScript code
    • IDE Plugins

      IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimAtomGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
    • Company

      About UsContact UsCareers
    • Resources

      FAQBlogTabnine AcademyStudentsTerms of usePrivacy policyJava Code IndexJavascript Code Index
    Get Tabnine for your IDE now