Add support for timing steps and pipelines

core/src/main/java/edu/wpi/grip/core/GripCoreModule.java

@@ -1,6 +1,8 @@
 package edu.wpi.grip.core;
 
 import edu.wpi.grip.core.events.UnexpectedThrowableEvent;
+import edu.wpi.grip.core.metrics.BenchmarkRunner;
+import edu.wpi.grip.core.metrics.Timer;
 import edu.wpi.grip.core.serialization.Project;
 import edu.wpi.grip.core.settings.SettingsProvider;
 import edu.wpi.grip.core.sockets.InputSocket;
@@ -143,6 +145,9 @@ public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
         .build(HttpSource.Factory.class));
 
     install(new FactoryModuleBuilder().build(ExceptionWitness.Factory.class));
+    install(new FactoryModuleBuilder().build(Timer.Factory.class));
+
+    bind(BenchmarkRunner.class).asEagerSingleton();
   }
 
   protected void onSubscriberException(Throwable exception, @Nullable SubscriberExceptionContext

core/src/main/java/edu/wpi/grip/core/PipelineRunner.java

@@ -1,11 +1,13 @@
 package edu.wpi.grip.core;
 
 
+import edu.wpi.grip.core.events.BenchmarkEvent;
 import edu.wpi.grip.core.events.RenderEvent;
 import edu.wpi.grip.core.events.RunPipelineEvent;
 import edu.wpi.grip.core.events.RunStartedEvent;
 import edu.wpi.grip.core.events.RunStoppedEvent;
 import edu.wpi.grip.core.events.StopPipelineEvent;
+import edu.wpi.grip.core.metrics.Timer;
 import edu.wpi.grip.core.util.SinglePermitSemaphore;
 import edu.wpi.grip.core.util.service.AutoRestartingService;
 import edu.wpi.grip.core.util.service.LoggingListener;
@@ -24,6 +26,7 @@
 import java.util.concurrent.Executor;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Supplier;
 import java.util.logging.Logger;
 
@@ -47,17 +50,25 @@ public class PipelineRunner implements RestartableService {
   private final Supplier<ImmutableList<Step>> stepSupplier;
   private final AutoRestartingService pipelineService;
 
+  private final AtomicBoolean benchmarking = new AtomicBoolean(false);
 
   @Inject
-  PipelineRunner(EventBus eventBus, Provider<Pipeline> pipelineProvider) {
-    this(eventBus, () -> pipelineProvider.get().getSources(), () -> pipelineProvider.get()
-        .getSteps());
-  }
-
-  PipelineRunner(EventBus eventBus, Supplier<ImmutableList<Source>> sourceSupplier,
-                 Supplier<ImmutableList<Step>> stepSupplier) {
+  PipelineRunner(EventBus eventBus,
+                 Provider<Pipeline> pipelineProvider,
+                 Timer.Factory timerFactory) {
+    this(eventBus,
+        () -> pipelineProvider.get().getSources(),
+        () -> pipelineProvider.get().getSteps(),
+        timerFactory);
+  }
+
+  PipelineRunner(EventBus eventBus,
+                 Supplier<ImmutableList<Source>> sourceSupplier,
+                 Supplier<ImmutableList<Step>> stepSupplier,
+                 Timer.Factory timerFactory) {
     this.sourceSupplier = sourceSupplier;
     this.stepSupplier = stepSupplier;
+    Timer timer = timerFactory.create(this);
     this.pipelineService = new AutoRestartingService<>(
         () -> new AbstractScheduledService() {
 
@@ -77,12 +88,17 @@ protected void runOneIteration() throws InterruptedException {
             if (!super.isRunning()) {
               return;
             }
-            runPipeline(super::isRunning);
+            try {
+              timer.started();
+              runPipeline(super::isRunning);
+            } finally {
+              timer.stopped();
+            }
             // This should not block access to the steps array
+            eventBus.post(new RunStoppedEvent());
             if (super.isRunning()) {
               eventBus.post(new RenderEvent());
             }
-            eventBus.post(new RunStoppedEvent());
           }
 
           @Override
@@ -195,7 +211,7 @@ private void runPipeline(Supplier<Boolean> isRunning) {
       if (!isRunning.get()) {
         break;
       }
-      step.runPerformIfPossible();
+      step.runPerform(benchmarking.get());
     }
   }
 
@@ -213,4 +229,9 @@ public void onStopPipeline(@Nullable StopPipelineEvent event) {
     stopAsync();
   }
 
+  @Subscribe
+  public void onBenchmarkEvent(BenchmarkEvent event) {
+    benchmarking.set(event.isStart());
+  }
+
 }

core/src/main/java/edu/wpi/grip/core/Step.java

@@ -1,5 +1,6 @@
 package edu.wpi.grip.core;
 
+import edu.wpi.grip.core.metrics.Timer;
 import edu.wpi.grip.core.sockets.InputSocket;
 import edu.wpi.grip.core.sockets.OutputSocket;
 import edu.wpi.grip.core.sockets.Socket;
@@ -27,6 +28,7 @@ public class Step {
   private static final String MISSING_SOCKET_MESSAGE_END = " must have a value to run this step.";
 
   private final ExceptionWitness witness;
+  private final Timer timer;
 
   private final Operation operation;
   private final OperationDescription description;
@@ -41,17 +43,20 @@ public class Step {
    * @param inputSockets            The input sockets from the operation.
    * @param outputSockets           The output sockets provided by the operation.
    * @param exceptionWitnessFactory A factory used to create an {@link ExceptionWitness}.
+   * @param timerFactory            A factory used to create a {@link Timer}.
    */
   Step(Operation operation,
        OperationDescription description,
        List<InputSocket> inputSockets,
        List<OutputSocket> outputSockets,
-       ExceptionWitness.Factory exceptionWitnessFactory) {
+       ExceptionWitness.Factory exceptionWitnessFactory,
+       Timer.Factory timerFactory) {
     this.operation = operation;
     this.description = description;
     this.inputSockets = inputSockets;
     this.outputSockets = outputSockets;
     this.witness = exceptionWitnessFactory.create(this);
+    this.timer = timerFactory.create(this);
   }
 
   /**
@@ -88,9 +93,24 @@ private void resetOutputSockets() {
   /**
    * The {@link Operation#perform} method should only be called if all {@link
    * InputSocket#getValue()} are not empty. If one input is invalid then the perform method will not
-   * run and all output sockets will be assigned to their default values.
+   * run and all output sockets will be assigned to their default values. If no input sockets have
+   * changed values, the perform method will not run.
    */
   protected final void runPerformIfPossible() {
+    runPerform(false);
+  }
+
+
+  /**
+   * The {@link Operation#perform} method should only be called if all {@link
+   * InputSocket#getValue()} are not empty. If one input is invalid then the perform method will not
+   * run and all output sockets will be assigned to their default values.
+   *
+   * @param benchmarking if this step is being benchmarked. The operation's perform method will be
+   *                     called if every input is valid regardless of 'dirtiness' if it's being
+   *                     benchmarked.
+   */
+  protected final void runPerform(boolean benchmarking) {
     boolean anyDirty = false; // Keeps track of if there are sockets that are dirty
 
     for (InputSocket<?> inputSocket : inputSockets) {
@@ -104,16 +124,16 @@ protected final void runPerformIfPossible() {
       }
       // If one value is true then this will stay true
       anyDirty |= inputSocket.dirtied();
-
     }
-    if (!anyDirty) { // If there aren't any dirty inputs Don't clear the exceptions just return
+    if (!benchmarking && !anyDirty) {
+      // If there aren't any dirty inputs don't clear the exceptions, just return
       return;
     }
 
     try {
       // We need to ensure that if perform disabled is switching states that we don't run the
-      // perform method
-      // while that is happening.
+      // perform method while that is happening.
+      timer.started();
       synchronized (removedLock) {
         if (!removed) {
           this.operation.perform();
@@ -122,12 +142,15 @@ protected final void runPerformIfPossible() {
     } catch (RuntimeException e) {
       // We do not want to catch all exceptions, only runtime exceptions.
       // This is especially important when it comes to InterruptedExceptions
-      final String operationFailedMessage = String.format("The %s operation did not perform "
-          + "correctly.", getOperationDescription().name());
+      final String operationFailedMessage =
+          String.format("The %s operation did not perform correctly.",
+              getOperationDescription().name());
       logger.log(Level.WARNING, operationFailedMessage, e);
       witness.flagException(e, operationFailedMessage);
       resetOutputSockets();
       return;
+    } finally {
+      timer.stopped();
     }
     witness.clearException();
   }
@@ -158,10 +181,13 @@ protected boolean removed() {
   @Singleton
   public static class Factory {
     private final ExceptionWitness.Factory exceptionWitnessFactory;
+    private final Timer.Factory timerFactory;
 
     @Inject
-    public Factory(ExceptionWitness.Factory exceptionWitnessFactory) {
+    public Factory(ExceptionWitness.Factory exceptionWitnessFactory,
+                   Timer.Factory timerFactory) {
       this.exceptionWitnessFactory = exceptionWitnessFactory;
+      this.timerFactory = timerFactory;
     }
 
     /**
@@ -180,7 +206,8 @@ public Step create(OperationMetaData operationData) {
           operationData.getDescription(),
           inputSockets,
           outputSockets,
-          exceptionWitnessFactory
+          exceptionWitnessFactory,
+          timerFactory
       );
 
       for (Socket<?> socket : inputSockets) {

core/src/main/java/edu/wpi/grip/core/events/BenchmarkEvent.java

@@ -0,0 +1,25 @@
+package edu.wpi.grip.core.events;
+
+/**
+ * An event posted before and after a pipeline is benchmarked.
+ */
+public final class BenchmarkEvent {
+
+  private final boolean isStart;
+
+  private BenchmarkEvent(boolean isStart) {
+    this.isStart = isStart;
+  }
+
+  public static BenchmarkEvent started() {
+    return new BenchmarkEvent(true);
+  }
+
+  public static BenchmarkEvent finished() {
+    return new BenchmarkEvent(false);
+  }
+
+  public boolean isStart() {
+    return isStart;
+  }
+}

core/src/main/java/edu/wpi/grip/core/events/BenchmarkRunEvent.java

@@ -0,0 +1,12 @@
+package edu.wpi.grip.core.events;
+
+/**
+ * An event representing the start of benchmarked pipeline run.
+ */
+public class BenchmarkRunEvent implements RunPipelineEvent {
+
+  @Override
+  public boolean pipelineShouldRun() {
+    return true;
+  }
+}

core/src/main/java/edu/wpi/grip/core/events/TimerEvent.java

@@ -0,0 +1,59 @@
+package edu.wpi.grip.core.events;
+
+import edu.wpi.grip.core.metrics.Analysis;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+/**
+ * An event fired when a {@link edu.wpi.grip.core.metrics.Timer Timer} finishes timing something.
+ *
+ * <p>This contains:
+ * <ul>
+ * <li>The object being timed</li>
+ * <li>How long the timed action took, in microseconds</li>
+ * <li>Historical data about the action</li>
+ * </ul>
+ * </p>
+ */
+public class TimerEvent<T> {
+
+  private final T source;
+  private final long elapsedTime;
+  private final Analysis data;
+
+  /**
+   * Creates a new timer event.
+   *
+   * @param source      the object that was timed
+   * @param elapsedTime the time elapsed in microseconds
+   * @param data        the analysis data of the event
+   */
+  public TimerEvent(T source, long elapsedTime, Analysis data) {
+    checkNotNull(source, "source");
+    checkNotNull(data, "data");
+    this.source = source;
+    this.elapsedTime = elapsedTime;
+    this.data = data;
+  }
+
+  /**
+   * Gets the source object that had an action being timed.
+   */
+  public T getSource() {
+    return source;
+  }
+
+  /**
+   * Gets the elapsed time of the action, in microseconds.
+   */
+  public long getElapsedTime() {
+    return elapsedTime;
+  }
+
+  /**
+   * Gets the analysis of the historical timing data for the action.
+   */
+  public Analysis getData() {
+    return data;
+  }
+}