JNI-based Iterator benchmark.

Add license notices

Author: Chessray

src/main/c++/iterators/Iterator.cpp

@@ -0,0 +1,58 @@
+/**
+ * Copyright © 2026, Evolved Binary Ltd
+ * 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 the <organization> 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 <COPYRIGHT HOLDER> 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.
+ */
+#include "Iterator.h"
+#include <stdexcept>
+#include <algorithm>
+
+Iterator::Iterator(int num_elements, size_t element_size)
+    : m_num_elements(num_elements), m_element_size(element_size), m_current_index(0) {
+
+    m_elements.reserve(num_elements);
+
+    std::random_device rd;
+    std::mt19937 gen(rd());
+    std::uniform_int_distribution<int> dis(0, 255);
+
+    for (int i = 0; i < num_elements; ++i) {
+        std::vector<char> element(element_size);
+        std::generate(element.begin(), element.end(), [&]() {
+            return static_cast<char>(dis(gen));
+        });
+        m_elements.push_back(std::move(element));
+    }
+}
+
+bool Iterator::hasNext() const {
+    return m_current_index < m_num_elements;
+}
+
+const std::vector<char>& Iterator::next() {
+    if (!hasNext()) {
+        throw std::out_of_range("No more elements in iterator");
+    }
+    return m_elements[m_current_index++];
+}

src/main/c++/iterators/Iterator.h

@@ -0,0 +1,61 @@
+/**
+ * Copyright © 2026, Evolved Binary Ltd
+ * 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 the <organization> 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 <COPYRIGHT HOLDER> 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.
+ */
+#ifndef ITERATOR_H
+#define ITERATOR_H
+
+#include <vector>
+#include <cstddef>
+#include <random>
+
+class Iterator {
+public:
+    /**
+     * @param num_elements Number of elements to generate.
+     * @param element_size Size of each individual element in bytes.
+     */
+    Iterator(int num_elements, size_t element_size);
+
+    /**
+     * @return true if the iteration has more elements.
+     */
+    bool hasNext() const;
+
+    /**
+     * @return The next element in the iteration.
+     * Note: In a real Java Iterator, next() returns the element.
+     * Here we return a pointer to the random data.
+     */
+    const std::vector<char>& next();
+
+private:
+    int m_num_elements;
+    size_t m_element_size;
+    int m_current_index;
+    std::vector<std::vector<char>> m_elements;
+};
+
+#endif // ITERATOR_H

src/main/c++/iterators/NativeIterator.cpp

@@ -0,0 +1,94 @@
+/**
+ * Copyright © 2026, Evolved Binary Ltd
+ * 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 the <organization> 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 <COPYRIGHT HOLDER> 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.
+ */
+#include <jni.h>
+#include "Iterator.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Class:     com_evolvedbinary_jnibench_common_iterators_NativeIterator
+ * Method:    createIterator
+ * Signature: (IJ)J
+ */
+JNIEXPORT jlong JNICALL Java_com_evolvedbinary_jnibench_common_iterators_NativeIterator_createIterator
+  (JNIEnv *env, jobject obj, jint num_elements, jlong element_size) {
+    Iterator* iterator = new Iterator(num_elements, static_cast<size_t>(element_size));
+    return reinterpret_cast<jlong>(iterator);
+}
+
+/*
+ * Class:     com_evolvedbinary_jnibench_common_iterators_NativeIterator
+ * Method:    hasNext
+ * Signature: (J)B
+ */
+JNIEXPORT jboolean JNICALL Java_com_evolvedbinary_jnibench_common_iterators_NativeIterator_hasNext
+  (JNIEnv *env, jobject obj, jlong handle) {
+    Iterator* iterator = reinterpret_cast<Iterator*>(handle);
+    return iterator->hasNext() ? JNI_TRUE : JNI_FALSE;
+}
+
+/*
+ * Class:     com_evolvedbinary_jnibench_common_iterators_NativeIterator
+ * Method:    next
+ * Signature: (J)[B
+ */
+JNIEXPORT jbyteArray JNICALL Java_com_evolvedbinary_jnibench_common_iterators_NativeIterator_next
+  (JNIEnv *env, jobject obj, jlong handle) {
+    Iterator* iterator = reinterpret_cast<Iterator*>(handle);
+    try {
+        const std::vector<char>& data = iterator->next();
+        jbyteArray result = env->NewByteArray(static_cast<jsize>(data.size()));
+        if (result == nullptr) {
+            return nullptr;
+        }
+        env->SetByteArrayRegion(result, 0, static_cast<jsize>(data.size()), reinterpret_cast<const jbyte*>(data.data()));
+        return result;
+    } catch (const std::out_of_range& e) {
+        jclass exClass = env->FindClass("java/util/NoSuchElementException");
+        if (exClass != nullptr) {
+            env->ThrowNew(exClass, e.what());
+        }
+        return nullptr;
+    }
+}
+
+/*
+ * Class:     com_evolvedbinary_jnibench_common_iterators_NativeIterator
+ * Method:    disposeInternal
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_com_evolvedbinary_jnibench_common_iterators_NativeIterator_disposeInternal
+  (JNIEnv *env, jobject obj, jlong handle) {
+    Iterator* iterator = reinterpret_cast<Iterator*>(handle);
+    delete iterator;
+}
+
+#ifdef __cplusplus
+}
+#endif

src/main/java/com/evolvedbinary/jnibench/common/iterators/NativeIterator.java

@@ -0,0 +1,54 @@
+/**
+ * Copyright © 2026, Evolved Binary Ltd
+ * 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 the <organization> 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 <COPYRIGHT HOLDER> 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 com.evolvedbinary.jnibench.common.iterators;
+
+import com.evolvedbinary.jnibench.common.NativeBackedObject;
+
+public class NativeIterator extends NativeBackedObject {
+
+    public NativeIterator(int numElements, long elementSize) {
+        _nativeHandle = createIterator(numElements, elementSize);
+    }
+
+    public boolean hasNext() {
+        return hasNext(_nativeHandle);
+    }
+
+    public byte[] next() {
+        return next(_nativeHandle);
+    }
+
+    @Override
+    protected void disposeInternal() {
+        disposeInternal(_nativeHandle);
+    }
+
+    private native long createIterator(int numElements, long elementSize);
+    private native boolean hasNext(long handle);
+    private native byte[] next(long handle);
+    private native void disposeInternal(long handle);
+}

src/main/java/com/evolvedbinary/jnibench/jmhbench/IteratorBenchmark.java

@@ -0,0 +1,75 @@
+/**
+ * Copyright © 2026, Evolved Binary Ltd
+ * 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 the <organization> 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 <COPYRIGHT HOLDER> 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 com.evolvedbinary.jnibench.jmhbench;
+
+import com.evolvedbinary.jnibench.common.iterators.NativeIterator;
+import com.evolvedbinary.jnibench.consbench.NarSystem;
+import org.openjdk.jmh.annotations.*;
+import org.openjdk.jmh.infra.Blackhole;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Benchmark for the C++ Iterator via JNI.
+ */
+@BenchmarkMode(Mode.SampleTime)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+@Warmup(iterations = 10, time = 100, timeUnit = TimeUnit.MILLISECONDS)
+@Measurement(iterations = 10, time = 100, timeUnit = TimeUnit.MILLISECONDS)
+public class IteratorBenchmark {
+
+    static {
+        NarSystem.loadLibrary();
+    }
+
+    @State(Scope.Benchmark)
+    public static class BenchmarkState {
+
+        @Param({"10", "100", "1000"})
+        int numElements;
+
+        @Param({"16", "128", "1024"})
+        long elementSize;
+
+        @Setup(Level.Iteration)
+        public void setup() {
+        }
+
+        @TearDown(Level.Iteration)
+        public void tearDown() {
+        }
+    }
+
+    @Benchmark
+    public void iterate(BenchmarkState benchmarkState, Blackhole blackhole) {
+        try (NativeIterator iterator = new NativeIterator(benchmarkState.numElements, benchmarkState.elementSize)) {
+            while (iterator.hasNext()) {
+                blackhole.consume(iterator.next());
+            }
+        }
+    }
+}