entry = new HashMap<>();
- results.add(entry);
- }
- testCheapPerformance(iterationCount);
- if (SAVE_RESULTS_TO_DISK) saveResults("cheap");
- testExpensivePerformance(iterationCount);
- if (SAVE_RESULTS_TO_DISK) saveResults("expensive");
- }
-
- /**
- * Saves benchmark results to the given CSV file on disk.
- *
- * The motivation is to produce two charts:
- *
- *
- * - performance by iteration number (on each size of image)
- *
- * - one line graph per method
- * - X axis = iteration number
- * - Y axis = time needed
- *
- *
- * - average performance by image size (for first iteration, and 10th)
- *
- * - one line graph per method
- * - X axis = size of image
- * - Y axis = time needed
- *
- *
- *
- *
- * The CSV file produced enables graph #1 very easily. For graph #2, results
- * from several files must be combined.
- *
- */
- public void saveResults(final String prefix) throws IOException {
- final StringBuilder sb = new StringBuilder();
-
- // write header
- final Map firstEntry = results.get(0);
- final String[] methods = firstEntry.keySet().toArray(new String[0]);
- Arrays.sort(methods);
- sb.append("Iteration");
- for (final String method : methods) {
- sb.append("\t");
- sb.append(method);
- }
- sb.append("\n");
-
- // write data
- for (int iter = 0; iter < results.size(); iter++) {
- final Map entry = results.get(iter);
- sb.append(iter + 1);
- for (final String method : methods) {
- sb.append("\t");
- sb.append(entry.get(method));
- }
- sb.append("\n");
- }
-
- // write to disk
- final String path = "results-" + prefix + "-" + width + "x" + height +
- ".csv";
- final PrintWriter out = new PrintWriter(new FileWriter(path));
- out.print(sb);
- out.close();
- }
-
- // -- Helper methods --
-
- /** Measures performance of a cheap operation (image inversion). */
- private void testCheapPerformance(final int iterationCount) {
- System.out.println();
- System.out.println("-- TIME PERFORMANCE - CHEAP OPERATION --");
- for (int i = 0; i < iterationCount; i++) {
- System.gc();
- System.out.println("Iteration #" + (i + 1) + "/" + iterationCount + ":");
- final List times = new ArrayList<>();
- times.add(System.currentTimeMillis());
- invertRaw(rawData);
- times.add(System.currentTimeMillis());
- invertUsingSciJavaOps(scijavaOpsData);
- times.add(System.currentTimeMillis());
- invertUsingImageJOps(imageJOpsData);
- times.add(System.currentTimeMillis());
- logTimePerformance(i, times);
- }
- }
-
- /** Measures performance of a computationally more expensive operation. */
- private void testExpensivePerformance(final int iterationCount) {
- System.out.println();
- System.out.println("-- TIME PERFORMANCE - EXPENSIVE OPERATION --");
- for (int i = 0; i < iterationCount; i++) {
- System.gc();
- System.out.println("Iteration #" + (i + 1) + "/" + iterationCount + ":");
- final List times = new ArrayList<>();
- times.add(System.currentTimeMillis());
- randomizeRaw(rawData);
- times.add(System.currentTimeMillis());
- randomizeUsingSciJavaOps(scijavaOpsData);
- times.add(System.currentTimeMillis());
- randomizeUsingImageJOps(imageJOpsData);
- times.add(System.currentTimeMillis());
- logTimePerformance(i, times);
- }
- }
-
- private long getMemUsage() {
- final Runtime r = Runtime.getRuntime();
- System.gc();
- System.gc();
- return r.totalMemory() - r.freeMemory();
- }
-
- private void reportMemoryUsage(final List memUsage) {
- final long rawMem = computeDifference(memUsage);
- final long sjMem = computeDifference(memUsage);
- final long ijMem = computeDifference(memUsage);
- System.out.println();
- System.out.println("-- MEMORY OVERHEAD --");
- System.out.println(METHOD_RAW + ": " + rawMem + " bytes");
- System.out.println(METHOD_SCIJAVA_OPS + ": " + sjMem + " bytes");
- System.out.println(METHOD_IMAGEJ_OPS + ": " + ijMem + " bytes");
- }
-
- private void logTimePerformance(final int iter, final List times) {
- final long rawTime = computeDifference(times);
- final long sjTime = computeDifference(times);
- final long ijTime = computeDifference(times);
-
- final Map entry = results.get(iter);
- entry.put(METHOD_RAW, rawTime);
- entry.put(METHOD_SCIJAVA_OPS, sjTime);
- entry.put(METHOD_IMAGEJ_OPS, ijTime);
-
- reportTime(METHOD_RAW, rawTime, rawTime, sjTime);
- reportTime(METHOD_SCIJAVA_OPS, sjTime, rawTime, sjTime);
- reportTime(METHOD_IMAGEJ_OPS, ijTime, rawTime, sjTime);
- }
-
- private long computeDifference(final List list) {
- final long mem = list.remove(0);
- return list.get(0) - mem;
- }
-
- private void reportTime(final String label, final long time,
- final long... otherTimes)
- {
- final StringBuilder sb = new StringBuilder();
- sb.append("\t");
- sb.append(label);
- sb.append(": ");
- sb.append(time);
- sb.append(" ms");
- for (final long otherTime : otherTimes) {
- sb.append(", ");
- sb.append(time / (float) otherTime);
- }
- System.out.println(sb);
- }
-
- // -- Creation methods --
-
- private byte[] createRawData(final int w, final int h) {
- final int size = w * h;
- final int max = w + h;
- final byte[] data = new byte[size];
- int index = 0;
- for (int y = 0; y < h; y++) {
- for (int x = 0; x < w; x++) {
- data[index++] = (byte) (255 * (x + y) / max);
- }
- }
- return data;
- }
-
- // -- Inversion methods --
-
- /**
- * @param data the data to invert
- * @implNote op name="benchmark.invert",type=Inplace1
- */
- public static void invertRaw(final byte[] data) {
- for (int i = 0; i < data.length; i++) {
- final int value = data[i] & 0xff;
- final int result = 255 - value;
- data[i] = (byte) result;
- }
- }
-
- private void invertUsingSciJavaOps(final byte[] data) {
- env.unary("benchmark.invert").input(data).mutate();
- }
-
- private void invertUsingImageJOps(final byte[] data) {
- ops.run("image.invert", new Object[] { data });
- }
-
- // -- Randomization methods --
-
- /**
- * @param data the data to invert
- * @implNote op name="benchmark.randomize",type=Inplace1
- */
- public static void randomizeRaw(final byte[] data) {
- for (int i = 0; i < data.length; i++) {
- final int value = data[i] & 0xff;
- final double result = expensiveOperation(value);
- data[i] = (byte) result;
- }
- }
-
- private void randomizeUsingSciJavaOps(final byte[] data) {
- env.unary("benchmark.randomize").input(data).mutate();
- }
-
- private void randomizeUsingImageJOps(final byte[] data) {
- ops.run("math.randomUniform", new Object[] { data });
- }
-
- private static double expensiveOperation(final int value) {
- return 255 * Math.random() * Math.sin(value / 255.0);
- }
-
-}
diff --git a/scijava-ops-benchmarks/src/main/java/org/scijava/ops/benchmarks/RandomOp.java b/scijava-ops-benchmarks/src/main/java/org/scijava/ops/benchmarks/RandomOp.java
deleted file mode 100644
index 7af84b4b3..000000000
--- a/scijava-ops-benchmarks/src/main/java/org/scijava/ops/benchmarks/RandomOp.java
+++ /dev/null
@@ -1,17 +0,0 @@
-
-package org.scijava.ops.benchmarks;
-
-import net.imagej.ops.Ops;
-import net.imagej.ops.special.inplace.AbstractUnaryInplaceOp;
-import org.scijava.plugin.Plugin;
-
-@Plugin(type = Ops.Math.RandomUniform.class)
-public class RandomOp extends AbstractUnaryInplaceOp implements
- Ops.Math.RandomUniform
-{
-
- @Override
- public void mutate(byte[] o) {
- PerformanceBenchmark.randomizeRaw(o);
- }
-}
diff --git a/scijava-ops-benchmarks/src/main/java/org/scijava/ops/benchmarks/frameworks/BenchmarkFrameworks.java b/scijava-ops-benchmarks/src/main/java/org/scijava/ops/benchmarks/frameworks/BenchmarkFrameworks.java
new file mode 100644
index 000000000..6c64eb757
--- /dev/null
+++ b/scijava-ops-benchmarks/src/main/java/org/scijava/ops/benchmarks/frameworks/BenchmarkFrameworks.java
@@ -0,0 +1,83 @@
+
+package org.scijava.ops.benchmarks.frameworks;
+
+import net.imagej.ops.Ops;
+import net.imagej.ops.special.inplace.AbstractUnaryInplaceOp;
+import org.openjdk.jmh.annotations.*;
+import org.scijava.ops.api.Hints;
+import org.scijava.plugin.Plugin;
+
+/**
+ * Tests relative performance of ImageJ Ops and SciJava Ops.
+ *
+ * @author Gabriel Selzer
+ */
+public class BenchmarkFrameworks {
+
+ private static final Hints HINTS = new Hints("cache.IGNORE");
+
+ /**
+ * Baseline benchmark - static code execution
+ *
+ * @param state the state between benchmarks
+ */
+ @Fork(value = 1, warmups = 2)
+ @Warmup(iterations = 2)
+ @Benchmark
+ @BenchmarkMode(Mode.AverageTime)
+ public void runStatic(FrameworksState state) {
+ invertRaw(state.in);
+ }
+
+ /**
+ * SciJava Ops benchmark
+ *
+ * @param state the state between benchmarks
+ */
+ @Fork(value = 1, warmups = 2)
+ @Warmup(iterations = 2)
+ @Benchmark
+ @BenchmarkMode(Mode.AverageTime)
+ public void sciJavaOps(final FrameworksState state) {
+ state.env.unary("benchmark.invert", HINTS).input(state.in).mutate();
+ }
+
+ /**
+ * ImageJ Ops benchmark
+ *
+ * @param state the state between benchmarks
+ */
+ @Fork(value = 1, warmups = 2)
+ @Warmup(iterations = 2)
+ @Benchmark
+ @BenchmarkMode(Mode.AverageTime)
+ public void imageJOps(final FrameworksState state) {
+ state.ops.run("image.invert", new Object[] { state.in });
+ }
+
+ // -- Ops -- //
+
+ /**
+ * @param data the data to invert
+ * @implNote op name="benchmark.invert",type=Inplace1
+ */
+ public static void invertRaw(final byte[] data) {
+ for (int i = 0; i < data.length; i++) {
+ final int value = data[i] & 0xff;
+ final int result = 255 - value;
+ data[i] = (byte) result;
+ }
+ }
+
+ @Plugin(type = Ops.Image.Invert.class)
+ public static class InvertOp extends AbstractUnaryInplaceOp implements
+ Ops.Image.Invert
+ {
+
+ @Override
+ public void mutate(byte[] o) {
+ invertRaw(o);
+ }
+ }
+
+}
diff --git a/scijava-ops-benchmarks/src/main/java/org/scijava/ops/benchmarks/frameworks/FrameworksState.java b/scijava-ops-benchmarks/src/main/java/org/scijava/ops/benchmarks/frameworks/FrameworksState.java
new file mode 100644
index 000000000..bb8594931
--- /dev/null
+++ b/scijava-ops-benchmarks/src/main/java/org/scijava/ops/benchmarks/frameworks/FrameworksState.java
@@ -0,0 +1,54 @@
+
+package org.scijava.ops.benchmarks.frameworks;
+
+import net.imagej.ops.OpService;
+import org.openjdk.jmh.annotations.*;
+import org.scijava.Context;
+import org.scijava.annotations.Index;
+import org.scijava.annotations.IndexItem;
+import org.scijava.ops.api.OpEnvironment;
+import org.scijava.plugin.Plugin;
+
+/**
+ * {@link State} used in SciJava Ops framework benchmarks
+ *
+ * @author Gabriel Selzer
+ */
+@State(Scope.Benchmark)
+public class FrameworksState {
+
+ public OpEnvironment env;
+ public OpService ops;
+ public byte[] in;
+
+ private Context ctx;
+
+ @Setup(Level.Invocation)
+ public void setUpInvocation() {
+ // Set up ImageJ Ops
+ ctx = new Context(OpService.class);
+ ops = ctx.getService(OpService.class);
+ // Set up SciJava Ops
+ env = OpEnvironment.build();
+ // Create input data
+ in = createRawData(4000, 4000);
+ }
+
+ @TearDown(Level.Invocation)
+ public void tearDownInvocation() {
+ ctx.dispose();
+ }
+
+ private byte[] createRawData(final int w, final int h) {
+ final int size = w * h;
+ final int max = w + h;
+ final byte[] data = new byte[size];
+ int index = 0;
+ for (int y = 0; y < h; y++) {
+ for (int x = 0; x < w; x++) {
+ data[index++] = (byte) (255 * (x + y) / max);
+ }
+ }
+ return data;
+ }
+}
diff --git a/scijava-ops-benchmarks/src/main/java/org/scijava/ops/benchmarks/matching/BenchmarkCaching.java b/scijava-ops-benchmarks/src/main/java/org/scijava/ops/benchmarks/matching/BenchmarkCaching.java
new file mode 100644
index 000000000..3cb6b26de
--- /dev/null
+++ b/scijava-ops-benchmarks/src/main/java/org/scijava/ops/benchmarks/matching/BenchmarkCaching.java
@@ -0,0 +1,52 @@
+
+package org.scijava.ops.benchmarks.matching;
+
+import net.imglib2.img.array.ArrayImgs;
+import org.openjdk.jmh.annotations.*;
+import org.scijava.ops.api.Hints;
+
+import static org.scijava.ops.benchmarks.matching.MatchingOpCollection.op;
+
+/**
+ * Benchmark showcasing the effects of Op caching
+ *
+ * @author Gabriel Selzer
+ */
+public class BenchmarkCaching {
+
+ private static final Hints CACHE_HIT_HINTS = new Hints();
+ private static final Hints CACHE_MISS_HINTS = new Hints("cache.IGNORE");
+
+ @Fork(value = 1, warmups = 2)
+ @Warmup(iterations = 2)
+ @Benchmark
+ @BenchmarkMode(Mode.AverageTime)
+ public void runStatic(MatchingState state) {
+ var out = ArrayImgs.doubles(state.in.dimensionsAsLongArray());
+ op(state.in, 1.0, out);
+ }
+
+ @Fork(value = 1, warmups = 2)
+ @Warmup(iterations = 2)
+ @Benchmark
+ @BenchmarkMode(Mode.AverageTime)
+ public void runOp(final MatchingState state) {
+ var out = ArrayImgs.doubles(state.in.dimensionsAsLongArray());
+ state.env.binary("benchmark.match", CACHE_MISS_HINTS) //
+ .input(state.in, 1.0) //
+ .output(out) //
+ .compute();
+ }
+
+ @Fork(value = 1, warmups = 2)
+ @Warmup(iterations = 2)
+ @Benchmark
+ @BenchmarkMode(Mode.AverageTime)
+ public void runOpCached(final MatchingState state) {
+ var out = ArrayImgs.doubles(state.in.dimensionsAsLongArray());
+ state.env.binary("benchmark.match", CACHE_HIT_HINTS) //
+ .input(state.in, 1.0) //
+ .output(out) //
+ .compute();
+ }
+}
diff --git a/scijava-ops-benchmarks/src/main/java/org/scijava/ops/benchmarks/matching/BenchmarkConversion.java b/scijava-ops-benchmarks/src/main/java/org/scijava/ops/benchmarks/matching/BenchmarkConversion.java
new file mode 100644
index 000000000..6cc6b540b
--- /dev/null
+++ b/scijava-ops-benchmarks/src/main/java/org/scijava/ops/benchmarks/matching/BenchmarkConversion.java
@@ -0,0 +1,78 @@
+
+package org.scijava.ops.benchmarks.matching;
+
+import net.imglib2.RandomAccessibleInterval;
+import net.imglib2.converter.Converters;
+import net.imglib2.converter.readwrite.SamplerConverter;
+import net.imglib2.img.array.ArrayImgs;
+import net.imglib2.img.basictypeaccess.DoubleAccess;
+import net.imglib2.type.numeric.integer.ByteType;
+import net.imglib2.type.numeric.real.DoubleType;
+import org.openjdk.jmh.annotations.*;
+import org.scijava.ops.api.Hints;
+
+import static org.scijava.ops.benchmarks.matching.MatchingOpCollection.op;
+
+/**
+ * Benchmark showcasing the performance of Op parameter conversion
+ *
+ * @author Gabriel Selzer
+ */
+public class BenchmarkConversion {
+
+ private static final Hints HINTS = new Hints("cache.IGNORE");
+
+ private static final SamplerConverter CONVERTER //
+ = sampler -> new DoubleType(new DoubleAccess() {
+
+ @Override
+ public double getValue(int index) {
+ return sampler.get().getRealDouble();
+ }
+
+ @Override
+ public void setValue(int index, double value) {
+ sampler.get().setReal(value);
+ }
+ });
+
+ @Fork(value = 1, warmups = 2)
+ @Warmup(iterations = 2)
+ @Benchmark
+ @BenchmarkMode(Mode.AverageTime)
+ public void runStatic(MatchingState state) {
+ // manual conversion of simple input
+ var in = Converters.convert( //
+ (RandomAccessibleInterval) state.simpleIn, //
+ CONVERTER //
+ );
+ // manual creation of simple output
+ var out = ArrayImgs.doubles(in.dimensionsAsLongArray());
+
+ // invoke Op statically
+ op(in, 1.0, out);
+ }
+
+ @Fork(value = 1, warmups = 2)
+ @Warmup(iterations = 2)
+ @Benchmark
+ @BenchmarkMode(Mode.AverageTime)
+ public void runOpConverted(final MatchingState state) {
+ var out = ArrayImgs.bytes(state.simpleIn.dimensionsAsLongArray());
+ state.env.binary("benchmark.match", HINTS) //
+ .input(state.simpleIn, (byte) 1) //
+ .output(out) //
+ .compute();
+ }
+
+ @Fork(value = 1, warmups = 2)
+ @Warmup(iterations = 2)
+ @Benchmark
+ @BenchmarkMode(Mode.AverageTime)
+ public void runOpConvertedAdapted(final MatchingState state) {
+ state.env.binary("benchmark.match", HINTS) //
+ .input(state.simpleIn, (byte) 1.0) //
+ .apply();
+ }
+
+}
diff --git a/scijava-ops-benchmarks/src/main/java/org/scijava/ops/benchmarks/matching/BenchmarkMatching.java b/scijava-ops-benchmarks/src/main/java/org/scijava/ops/benchmarks/matching/BenchmarkMatching.java
new file mode 100644
index 000000000..6e084070b
--- /dev/null
+++ b/scijava-ops-benchmarks/src/main/java/org/scijava/ops/benchmarks/matching/BenchmarkMatching.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2014, Oracle America, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * * Neither the name of Oracle nor the names of its contributors may be used
+ * to endorse or promote products derived from this software without
+ * specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.scijava.ops.benchmarks.matching;
+
+import net.imglib2.img.array.ArrayImgs;
+import org.openjdk.jmh.annotations.*;
+import org.scijava.ops.api.Hints;
+
+/**
+ * JMH Benchmarks comparing the performance of basic Op invocations
+ *
+ * @author Gabriel Selzer
+ */
+public class BenchmarkMatching {
+
+ private static final Hints HINTS = new Hints("cache.IGNORE");
+
+ @Fork(value = 1, warmups = 2)
+ @Warmup(iterations = 2)
+ @Benchmark
+ @BenchmarkMode(Mode.AverageTime)
+ public void runStatic(MatchingState state) {
+ var out = ArrayImgs.doubles(state.in.dimensionsAsLongArray());
+ MatchingOpCollection.op(state.in, 1.0, out);
+ }
+
+ @Fork(value = 1, warmups = 2)
+ @Warmup(iterations = 2)
+ @Benchmark
+ @BenchmarkMode(Mode.AverageTime)
+ public void runOp(final MatchingState state) {
+ var out = ArrayImgs.doubles(state.in.dimensionsAsLongArray());
+ state.env.binary("benchmark.match", HINTS) //
+ .input(state.in, 1.0) //
+ .output(out) //
+ .compute();
+ }
+
+ @Fork(value = 1, warmups = 2)
+ @Warmup(iterations = 2)
+ @Benchmark
+ @BenchmarkMode(Mode.AverageTime)
+ public void runOpAdapted(final MatchingState state) {
+ var tmp = state.env.binary("benchmark.match", HINTS) //
+ .input(state.in, 1.0) //
+ .apply();
+ }
+}
diff --git a/scijava-ops-benchmarks/src/main/java/org/scijava/ops/benchmarks/matching/MatchingOpCollection.java b/scijava-ops-benchmarks/src/main/java/org/scijava/ops/benchmarks/matching/MatchingOpCollection.java
new file mode 100644
index 000000000..2a7c8780c
--- /dev/null
+++ b/scijava-ops-benchmarks/src/main/java/org/scijava/ops/benchmarks/matching/MatchingOpCollection.java
@@ -0,0 +1,79 @@
+
+package org.scijava.ops.benchmarks.matching;
+
+import net.imglib2.RandomAccessibleInterval;
+import net.imglib2.converter.Converters;
+import net.imglib2.img.basictypeaccess.ByteAccess;
+import net.imglib2.img.basictypeaccess.DoubleAccess;
+import net.imglib2.loops.LoopBuilder;
+import net.imglib2.type.numeric.integer.ByteType;
+import net.imglib2.type.numeric.real.DoubleType;
+
+/**
+ * Class containing Ops used in benchmarking
+ *
+ * @author Gabriel Selzer
+ */
+public class MatchingOpCollection {
+
+ /**
+ * @param in the data to input to our function
+ * @param d the value to add to each element in the input
+ * @param out the preallocated storage buffer
+ * @implNote op name="benchmark.match",type=Computer
+ */
+ public static void op( //
+ final RandomAccessibleInterval in, //
+ final Double d, //
+ final RandomAccessibleInterval out //
+ ) {
+ LoopBuilder.setImages(in, out).multiThreaded().forEachPixel((i, o) -> o.set(
+ i.get() + d));
+ }
+
+ /**
+ * @param in the {@link RandomAccessibleInterval} containing {@link ByteType}s
+ * @return a {@link RandomAccessibleInterval} wrapping {@code in}.
+ * @implNote op name="engine.convert", type=Function, priority='1000.'
+ */
+ public static RandomAccessibleInterval toDoubleType(
+ RandomAccessibleInterval in)
+ {
+ return Converters.convert(in, sampler -> new DoubleType(new DoubleAccess() {
+
+ @Override
+ public double getValue(int index) {
+ return sampler.get().getRealDouble();
+ }
+
+ @Override
+ public void setValue(int index, double value) {
+ sampler.get().setReal(value);
+ }
+ }));
+ }
+
+ /**
+ * @param in the {@link RandomAccessibleInterval} containing
+ * {@link DoubleType}s
+ * @return a {@link RandomAccessibleInterval} wrapping {@code in}.
+ * @implNote op name="engine.convert", type=Function, priority='1000.'
+ */
+ public static RandomAccessibleInterval toByteType(
+ RandomAccessibleInterval in)
+ {
+ return Converters.convert(in, sampler -> new ByteType(new ByteAccess() {
+
+ @Override
+ public byte getValue(int index) {
+ return (byte) sampler.get().getRealDouble();
+ }
+
+ @Override
+ public void setValue(int index, byte value) {
+ sampler.get().setReal(value);
+ }
+ }));
+ }
+
+}
diff --git a/scijava-ops-benchmarks/src/main/java/org/scijava/ops/benchmarks/matching/MatchingState.java b/scijava-ops-benchmarks/src/main/java/org/scijava/ops/benchmarks/matching/MatchingState.java
new file mode 100644
index 000000000..2297f7860
--- /dev/null
+++ b/scijava-ops-benchmarks/src/main/java/org/scijava/ops/benchmarks/matching/MatchingState.java
@@ -0,0 +1,32 @@
+
+package org.scijava.ops.benchmarks.matching;
+
+import net.imglib2.img.Img;
+import net.imglib2.img.array.ArrayImgs;
+import net.imglib2.type.numeric.integer.ByteType;
+import net.imglib2.type.numeric.real.DoubleType;
+import org.openjdk.jmh.annotations.Level;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.scijava.ops.api.OpEnvironment;
+
+/**
+ * {@link State} used in SciJava Ops benchmarks
+ *
+ * @author Gabriel Selzer
+ */
+@State(Scope.Benchmark)
+public class MatchingState {
+
+ public OpEnvironment env;
+ public Img in;
+ public Img simpleIn;
+
+ @Setup(Level.Invocation)
+ public void setUpInvocation() {
+ env = OpEnvironment.build();
+ in = ArrayImgs.doubles(1000, 1000);
+ simpleIn = ArrayImgs.bytes(1000, 1000);
+ }
+}
diff --git a/scijava-ops-benchmarks/src/main/scripts/benchmark.sh b/scijava-ops-benchmarks/src/main/scripts/benchmark.sh
deleted file mode 100755
index 4b68a44af..000000000
--- a/scijava-ops-benchmarks/src/main/scripts/benchmark.sh
+++ /dev/null
@@ -1,69 +0,0 @@
-#!/bin/sh
-
-###
-# #%L
-# ImgLib2: a general-purpose, multidimensional image processing library.
-# %%
-# Copyright (C) 2009 - 2016 Tobias Pietzsch, Stephan Preibisch, Stephan Saalfeld,
-# John Bogovic, Albert Cardona, Barry DeZonia, Christian Dietz, Jan Funke,
-# Aivar Grislis, Jonathan Hale, Grant Harris, Stefan Helfrich, Mark Hiner,
-# Martin Horn, Steffen Jaensch, Lee Kamentsky, Larry Lindsey, Melissa Linkert,
-# Mark Longair, Brian Northan, Nick Perry, Curtis Rueden, Johannes Schindelin,
-# Jean-Yves Tinevez and Michael Zinsmaier.
-# %%
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as
-# published by the Free Software Foundation, either version 2 of the
-# License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public
-# License along with this program. If not, see
-# .
-# #L%
-###
-
-# This simple script executes the imglib performance benchmark on
-# images with varying numbers of pixels. Results are written to
-# CSV in the current directory.
-
-DIR="$(dirname "$0")"
-TARGET="$DIR/../../../target"
-
-CP=\
-$TARGET'/dependency/*':\
-$TARGET/classes:
-
-JAVA=java
-MEM=512m
-MAIN_CLASS=org.scijava.ops.benchmarks.PerformanceBenchmark
-
-# copy dependent JARs first
-cd "$DIR/../../.."
-mvn -DskipTests package dependency:copy-dependencies
-cd -
-
-# 1 million
-$JAVA -mx$MEM -cp "$CP" $MAIN_CLASS 1000
-# 4 million
-$JAVA -mx$MEM -cp "$CP" $MAIN_CLASS 2000
-# 7 million
-$JAVA -mx$MEM -cp "$CP" $MAIN_CLASS 2646
-# 10 million
-$JAVA -mx$MEM -cp "$CP" $MAIN_CLASS 3162
-# 13 million
-$JAVA -mx$MEM -cp "$CP" $MAIN_CLASS 3606
-# 16 million
-$JAVA -mx$MEM -cp "$CP" $MAIN_CLASS 4000
-# 19 million
-$JAVA -mx$MEM -cp "$CP" $MAIN_CLASS 4359
-# 22 million
-$JAVA -mx$MEM -cp "$CP" $MAIN_CLASS 4690
-# 25 million
-$JAVA -mx$MEM -cp "$CP" $MAIN_CLASS 5000
-
-python "$DIR/chart-gen.py" > copyme.txt
diff --git a/scijava-ops-benchmarks/src/main/scripts/chart-gen.py b/scijava-ops-benchmarks/src/main/scripts/chart-gen.py
deleted file mode 100644
index 387097dfd..000000000
--- a/scijava-ops-benchmarks/src/main/scripts/chart-gen.py
+++ /dev/null
@@ -1,125 +0,0 @@
-###
-# #%L
-# ImgLib2: a general-purpose, multidimensional image processing library.
-# %%
-# Copyright (C) 2009 - 2016 Tobias Pietzsch, Stephan Preibisch, Stephan Saalfeld,
-# John Bogovic, Albert Cardona, Barry DeZonia, Christian Dietz, Jan Funke,
-# Aivar Grislis, Jonathan Hale, Grant Harris, Stefan Helfrich, Mark Hiner,
-# Martin Horn, Steffen Jaensch, Lee Kamentsky, Larry Lindsey, Melissa Linkert,
-# Mark Longair, Brian Northan, Nick Perry, Curtis Rueden, Johannes Schindelin,
-# Jean-Yves Tinevez and Michael Zinsmaier.
-# %%
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as
-# published by the Free Software Foundation, either version 2 of the
-# License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public
-# License along with this program. If not, see
-# .
-# #L%
-###
-
-# Transforms CSV data into HTML that uses pChart4mw charts.
-
-# Charts produced:
-# - Iteration x Time for minimum resolution image, by method
-# - Iteration x Time for maximum resolution image, by method
-# - Resolution x Time at first iteration, by method
-# - Resolution x Time at last iteration, by method
-
-# Total charts: 8 (4 for "cheap" and 4 for "expensive")
-
-import math
-
-# NB: Presumably there is a slick way to avoid having two very similar
-# methods (generateIterationChart and generateResolutionChart) iterating
-# over different list indices, but my Python knowledge is weak.
-
-# Iteration x Time at a given resolution, by method
-def generateIterationChart(name, data, methods, resolution_index, keywords):
- resolutions = range(1, 26, 3)
- iteration_count = len(data[0])
- title = 'Iteration x Time (ms) at ' + str(resolutions[resolution_index]) + ' Mpx'
- # Header
- print(f'plot("{name}IterationVsTime{resolutions[resolution_index]}", "{title}", "Iteration",')
- print(f'\t"Iteration,{",".join(methods)}\\n" +')
- # Data
- for i in range(0, iteration_count):
- suffix = '\\n" +' if i < iteration_count - 1 else '");'
- print(f'\t"{i},{",".join(str(v) for v in data[resolution_index][i])}{suffix}')
- print()
-
-# Resolution x Time at a given iteration, by method
-def generateResolutionChart(name, data, methods, iteration_index, keywords):
- resolution_count = len(data)
- title = 'Resolution x Time (ms) at iteration #' + str(iteration_index + 1)
- # Header
- print(f'plot("{name}ResolutionVsTime{iteration_index + 1}", "{title}", "Mpx",')
- print(f'\t"Mpx,{",".join(methods)}\\n" +')
- # Data
- for r in range(resolution_count):
- suffix = '\\n" +' if r < resolution_count - 1 else '");'
- print(f'\t"{r},{",".join(str(v) for v in data[r][iteration_index])}{suffix}')
- print()
-
-# reads data from CSV files into 3D array dimensioned:
-# [resolution_count][iteration_count][method_count]
-def process(prefix):
- methods = []
-
- # loop over image resolutions
- data = []
- for p in range(1, 26, 3):
- # compute filename
- res = round(math.sqrt(1000000 * p))
- s_res = str(int(res))
- path_prefix = 'results-' + prefix + '-' + s_res + 'x' + s_res
- in_path = path_prefix + '.csv'
-
- # read data file
- with open(in_path, 'r') as f:
- lines = f.readlines()
-
- # loop over iterations
- header = True
- data0 = []
- for line in lines:
- items = line.rstrip().split('\t')
- items.pop(0)
- if header:
- header = False
- methods = items
- else:
- # loop over methods
- data1 = []
- for item in items:
- data1.append(int(item))
- data0.append(data1)
- data.append(data0)
-
- resolution_count = len(data)
- iteration_count = len(data[0])
-
- w = 300
- h = 250
- l_size = 'size=' + str(w) + 'x' + str(h)
- r_size = 'size=' + str(w + 135) + 'x' + str(h)
-
- # Iteration x Time for minimum resolution image, by method
- generateIterationChart(prefix, data, methods, 0, l_size + ' plots')
- # Iteration x Time for maximum resolution image, by method
- generateIterationChart(prefix, data, methods, resolution_count - 1, r_size + ' plots legend')
- # Resolution x Time at first iteration, by method
- generateResolutionChart(prefix, data, methods, 0, l_size + ' angle=90 cubic plots')
- # Resolution x Time at last iteration, by method
- generateResolutionChart(prefix, data, methods, iteration_count - 1, r_size + ' angle=90 cubic plots legend')
-
-print("")
-process('cheap')
-process('expensive')
\ No newline at end of file
diff --git a/scijava-ops-benchmarks/src/test/java/org/scijava/ops/benchmarks/matching/BenchmarkingOpsTest.java b/scijava-ops-benchmarks/src/test/java/org/scijava/ops/benchmarks/matching/BenchmarkingOpsTest.java
new file mode 100644
index 000000000..a793c7808
--- /dev/null
+++ b/scijava-ops-benchmarks/src/test/java/org/scijava/ops/benchmarks/matching/BenchmarkingOpsTest.java
@@ -0,0 +1,34 @@
+
+package org.scijava.ops.benchmarks.matching;
+
+import net.imglib2.img.array.ArrayImgs;
+import org.junit.jupiter.api.Test;
+import org.scijava.ops.api.OpEnvironment;
+
+/**
+ * A simple test ensuring that the Ops used in benchmarks get matched.
+ *
+ * @author Gabriel Selzer
+ */
+public class BenchmarkingOpsTest {
+
+ @Test
+ public void testImageConversion() {
+ OpEnvironment env = OpEnvironment.build();
+ var simpleIn = ArrayImgs.bytes(1000, 1000);
+ var out = ArrayImgs.bytes(simpleIn.dimensionsAsLongArray());
+ env.binary("benchmark.match") //
+ .input(simpleIn, (byte) 1) //
+ .output(out) //
+ .compute();
+ }
+
+ @Test
+ public void testImageConversionAdaptation() {
+ OpEnvironment env = OpEnvironment.build();
+ var simpleIn = ArrayImgs.bytes(1000, 1000);
+ env.binary("benchmark.match") //
+ .input(simpleIn, 1.0) //
+ .apply();
+ }
+}