changeset 59570:2594b4a5d71b foreign-jextract

Automatic merge with foreign-abi
author mcimadamore
date Fri, 10 Jan 2020 15:59:34 +0000
parents d8b18d311277 c9fa701aa2ef
children 4cabdd7fcba8
files
diffstat 3 files changed, 242 insertions(+), 13 deletions(-) [+]
line wrap: on
line diff
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverConstant.java	Fri Jan 10 15:59:34 2020 +0000
@@ -0,0 +1,142 @@
+/*
+ *  Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.  Oracle designates this
+ *  particular file as subject to the "Classpath" exception as provided
+ *  by Oracle in the LICENSE file that accompanied this code.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *   Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ *
+ */
+
+package org.openjdk.bench.jdk.incubator.foreign;
+
+import jdk.incubator.foreign.MemoryLayout;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.CompilerControl;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.TearDown;
+import org.openjdk.jmh.annotations.Warmup;
+import sun.misc.Unsafe;
+
+import jdk.incubator.foreign.MemoryAddress;
+import jdk.incubator.foreign.MemorySegment;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.concurrent.TimeUnit;
+
+import static jdk.incubator.foreign.MemoryLayout.PathElement.sequenceElement;
+import static jdk.incubator.foreign.MemoryLayouts.JAVA_INT;
+
+@BenchmarkMode(Mode.AverageTime)
+@Warmup(iterations = 5, time = 500, timeUnit = TimeUnit.MILLISECONDS)
+@Measurement(iterations = 10, time = 500, timeUnit = TimeUnit.MILLISECONDS)
+@State(org.openjdk.jmh.annotations.Scope.Thread)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@Fork(3)
+public class LoopOverConstant {
+
+    static final Unsafe unsafe = Utils.unsafe;
+
+    static final int ELEM_SIZE = 1_000_000;
+    static final int CARRIER_SIZE = (int)JAVA_INT.byteSize();
+    static final int ALLOC_SIZE = ELEM_SIZE * CARRIER_SIZE;
+
+    static final long unsafe_addr = unsafe.allocateMemory(ALLOC_SIZE);
+
+    //setup unsafe address
+
+    static {
+        for (int i = 0; i < ELEM_SIZE; i++) {
+            unsafe.putInt(unsafe_addr + (i * CARRIER_SIZE) , i);
+        }
+    }
+
+    //setup native memory segment
+
+    static final MemoryAddress segment_addr = MemorySegment.allocateNative(ALLOC_SIZE).baseAddress();
+    static final VarHandle VH_int = MemoryLayout.ofSequence(JAVA_INT).varHandle(int.class, sequenceElement());
+
+    static {
+        for (int i = 0; i < ELEM_SIZE; i++) {
+            VH_int.set(segment_addr, (long) i, i);
+        }
+    }
+
+    //setup direct buffer
+
+    static final ByteBuffer bb = ByteBuffer.allocateDirect(ALLOC_SIZE).order(ByteOrder.nativeOrder());
+
+    static {
+        for (int i = 0; i < ELEM_SIZE; i++) {
+            bb.putInt(i * CARRIER_SIZE , i);
+        }
+    }
+
+    @Benchmark
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public int unsafe_get() {
+        return unsafe.getInt(unsafe_addr);
+    }
+
+    @Benchmark
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public int segment_get() {
+        return (int)VH_int.get(segment_addr, 0L);
+    }
+
+    @Benchmark
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public int BB_get() {
+        return bb.getInt(0);
+    }
+
+    @Benchmark
+    public int unsafe_loop() {
+        int res = 0;
+        for (int i = 0; i < ELEM_SIZE; i ++) {
+            res += unsafe.getInt(unsafe_addr + (i * CARRIER_SIZE));
+        }
+        return res;
+    }
+
+    @Benchmark
+    public int segment_loop() {
+        int res = 0;
+        for (int i = 0; i < ELEM_SIZE; i++) {
+            res += (int) VH_int.get(segment_addr, (long)i);
+        }
+        return res;
+    }
+
+    @Benchmark
+    public int BB_loop() {
+        int res = 0;
+        for (int i = 0; i < ELEM_SIZE; i++) {
+            res += bb.getInt(i * CARRIER_SIZE);
+        }
+        return res;
+    }
+}
--- a/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNonConstant.java	Thu Jan 09 15:54:29 2020 +0000
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNonConstant.java	Fri Jan 10 15:59:34 2020 +0000
@@ -35,13 +35,15 @@
 import org.openjdk.jmh.annotations.State;
 import org.openjdk.jmh.annotations.TearDown;
 import org.openjdk.jmh.annotations.Warmup;
+import sun.misc.Unsafe;
 
 import java.lang.invoke.VarHandle;
 import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
 import java.util.concurrent.TimeUnit;
 
 import static jdk.incubator.foreign.MemoryLayout.PathElement.sequenceElement;
-import static jdk.incubator.foreign.MemoryLayouts.JAVA_BYTE;
+import static jdk.incubator.foreign.MemoryLayouts.JAVA_INT;
 
 @BenchmarkMode(Mode.AverageTime)
 @Warmup(iterations = 5, time = 500, timeUnit = TimeUnit.MILLISECONDS)
@@ -51,37 +53,75 @@
 @Fork(3)
 public class LoopOverNonConstant {
 
-    static final int SIZE = 1_000_000;
+    static final Unsafe unsafe = Utils.unsafe;
 
-    static final VarHandle VH_byte = MemoryLayout.ofSequence(JAVA_BYTE).varHandle(byte.class, sequenceElement());
+    static final int ELEM_SIZE = 1_000_000;
+    static final int CARRIER_SIZE = (int)JAVA_INT.byteSize();
+    static final int ALLOC_SIZE = ELEM_SIZE * CARRIER_SIZE;
+
+    static final VarHandle VH_int = MemoryLayout.ofSequence(JAVA_INT).varHandle(int.class, sequenceElement());
     MemorySegment segment;
+    long unsafe_addr;
 
     ByteBuffer byteBuffer;
 
     @Setup
     public void setup() {
-        segment = MemorySegment.allocateNative(SIZE);
-        for (int i = 0; i < SIZE; i++) {
-            VH_byte.set(segment.baseAddress(), (long) i, (byte) i);
+        unsafe_addr = unsafe.allocateMemory(ALLOC_SIZE);
+        for (int i = 0; i < ELEM_SIZE; i++) {
+            unsafe.putInt(unsafe_addr + (i * CARRIER_SIZE) , i);
+        }
+        segment = MemorySegment.allocateNative(ALLOC_SIZE);
+        for (int i = 0; i < ELEM_SIZE; i++) {
+            VH_int.set(segment.baseAddress(), (long) i, i);
         }
 
-        byteBuffer = ByteBuffer.allocateDirect(SIZE);
-        for (int i = 0; i < SIZE; i++) {
-            byteBuffer.put(i , (byte) i);
+        byteBuffer = ByteBuffer.allocateDirect(ALLOC_SIZE).order(ByteOrder.nativeOrder());
+        for (int i = 0; i < ELEM_SIZE; i++) {
+            byteBuffer.putInt(i * CARRIER_SIZE , i);
         }
     }
 
     @TearDown
     public void tearDown() {
         segment.close();
+        unsafe.invokeCleaner(byteBuffer);
+        unsafe.freeMemory(unsafe_addr);
+    }
+
+    @Benchmark
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public int unsafe_get() {
+        return unsafe.getInt(unsafe_addr);
+    }
+
+    @Benchmark
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public int segment_get() {
+        return (int) VH_int.get(segment.baseAddress(), 0L);
+    }
+
+    @Benchmark
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public int BB_get() {
+        return byteBuffer.getInt(0);
+    }
+
+    @Benchmark
+    public int unsafe_loop() {
+        int res = 0;
+        for (int i = 0; i < ELEM_SIZE; i ++) {
+            res += unsafe.getInt(unsafe_addr + (i * CARRIER_SIZE));
+        }
+        return res;
     }
 
     @Benchmark
     public int segment_loop() {
         int sum = 0;
         MemoryAddress base = segment.baseAddress();
-        for (int i = 0; i < SIZE; i++) {
-            sum += (byte) VH_byte.get(base, (long) i);
+        for (int i = 0; i < ELEM_SIZE; i++) {
+            sum += (int) VH_int.get(base, (long) i);
         }
         return sum;
     }
@@ -90,8 +130,8 @@
     public int BB_loop() {
         int sum = 0;
         ByteBuffer bb = byteBuffer;
-        for (int i = 0; i < SIZE; i++) {
-            sum += bb.get(i);
+        for (int i = 0; i < ELEM_SIZE; i++) {
+            sum += bb.getInt(i * CARRIER_SIZE);
         }
         return sum;
     }
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/Utils.java	Fri Jan 10 15:59:34 2020 +0000
@@ -0,0 +1,47 @@
+/*
+ *  Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.  Oracle designates this
+ *  particular file as subject to the "Classpath" exception as provided
+ *  by Oracle in the LICENSE file that accompanied this code.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *   Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ *
+ */
+
+package org.openjdk.bench.jdk.incubator.foreign;
+
+import sun.misc.Unsafe;
+
+import java.lang.reflect.Field;
+
+public class Utils {
+
+    static final Unsafe unsafe;
+
+    //setup unsafe
+    static {
+        try {
+            Field f = Unsafe.class.getDeclaredField("theUnsafe");
+            f.setAccessible(true);
+            unsafe = (Unsafe) f.get(null);
+        } catch (ReflectiveOperationException ex) {
+            throw new IllegalStateException();
+        }
+    }
+}