1 /*
  2  * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  4  *
  5  * This code is free software; you can redistribute it and/or modify it
  6  * under the terms of the GNU General Public License version 2 only, as
  7  * published by the Free Software Foundation.
  8  *
  9  * This code is distributed in the hope that it will be useful, but WITHOUT
 10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 12  * version 2 for more details (a copy is included in the LICENSE file that
 13  * accompanied this code).
 14  *
 15  * You should have received a copy of the GNU General Public License version
 16  * 2 along with this work; if not, write to the Free Software Foundation,
 17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 18  *
 19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 20  * or visit www.oracle.com if you need additional information or have any
 21  * questions.
 22  */
 23 package org.openjdk.bench.jdk.incubator.foreign;
 24 
 25 import jdk.incubator.foreign.MemoryLayout;
 26 import jdk.incubator.foreign.MemorySegment;
 27 import jdk.incubator.foreign.SegmentAllocator;
 28 import jdk.incubator.foreign.ResourceScope;
 29 import org.openjdk.jmh.annotations.Benchmark;
 30 import org.openjdk.jmh.annotations.BenchmarkMode;
 31 import org.openjdk.jmh.annotations.Fork;
 32 import org.openjdk.jmh.annotations.Measurement;
 33 import org.openjdk.jmh.annotations.Mode;
 34 import org.openjdk.jmh.annotations.OutputTimeUnit;
 35 import org.openjdk.jmh.annotations.Setup;
 36 import org.openjdk.jmh.annotations.State;
 37 import org.openjdk.jmh.annotations.TearDown;
 38 import org.openjdk.jmh.annotations.Warmup;
 39 import sun.misc.Unsafe;
 40 
 41 import java.lang.invoke.VarHandle;
 42 import java.nio.ByteBuffer;
 43 import java.nio.ByteOrder;
 44 import java.util.concurrent.TimeUnit;
 45 
 46 import static jdk.incubator.foreign.MemoryLayout.PathElement.sequenceElement;
 47 import static jdk.incubator.foreign.ValueLayout.JAVA_INT;
 48 
 49 @BenchmarkMode(Mode.AverageTime)
 50 @Warmup(iterations = 5, time = 500, timeUnit = TimeUnit.MILLISECONDS)
 51 @Measurement(iterations = 10, time = 500, timeUnit = TimeUnit.MILLISECONDS)
 52 @State(org.openjdk.jmh.annotations.Scope.Thread)
 53 @OutputTimeUnit(TimeUnit.MILLISECONDS)
 54 @Fork(value = 3, jvmArgsAppend = { "--add-modules=jdk.incubator.foreign" })
 55 public class LoopOverNew {
 56 
 57     static final Unsafe unsafe = Utils.unsafe;
 58 
 59     static final int ELEM_SIZE = 1_000_000;
 60     static final int CARRIER_SIZE = (int)JAVA_INT.byteSize();
 61     static final int ALLOC_SIZE = ELEM_SIZE * CARRIER_SIZE;
 62     static final MemoryLayout ALLOC_LAYOUT = MemoryLayout.sequenceLayout(ELEM_SIZE, JAVA_INT);
 63 
 64     static final VarHandle VH_int = MemoryLayout.sequenceLayout(JAVA_INT).varHandle(sequenceElement());
 65 
 66     final ResourceScope scope = ResourceScope.newConfinedScope();
 67     final SegmentAllocator recyclingAlloc = SegmentAllocator.prefixAllocator(MemorySegment.allocateNative(ALLOC_LAYOUT, scope));
 68 
 69     @TearDown
 70     public void tearDown() throws Throwable {
 71         scope.close();
 72     }
 73 
 74     @Benchmark
 75     public void unsafe_loop() {
 76         long unsafe_addr = unsafe.allocateMemory(ALLOC_SIZE);
 77         for (int i = 0; i < ELEM_SIZE; i++) {
 78             unsafe.putInt(unsafe_addr + (i * CARRIER_SIZE) , i);
 79         }
 80         unsafe.freeMemory(unsafe_addr);
 81     }
 82 
 83     @Benchmark
 84     public void segment_loop_confined() {
 85         try (ResourceScope scope = ResourceScope.newConfinedScope()) {
 86             MemorySegment segment = MemorySegment.allocateNative(ALLOC_SIZE, 4, scope);
 87             for (int i = 0; i < ELEM_SIZE; i++) {
 88                 VH_int.set(segment, (long) i, i);
 89             }
 90         }
 91     }
 92 
 93     @Benchmark
 94     public void segment_loop_shared() {
 95         try (ResourceScope scope = ResourceScope.newSharedScope()) {
 96             MemorySegment segment = MemorySegment.allocateNative(ALLOC_SIZE, 4, scope);
 97             for (int i = 0; i < ELEM_SIZE; i++) {
 98                 VH_int.set(segment, (long) i, i);
 99             }
100         }
101     }
102 
103     @Benchmark
104     public void segment_loop_recycle() {
105         MemorySegment segment = recyclingAlloc.allocate(ALLOC_SIZE, 4);
106         for (int i = 0; i < ELEM_SIZE; i++) {
107             VH_int.set(segment, (long) i, i);
108         }
109     }
110 
111     @Benchmark
112     public void buffer_loop() {
113         ByteBuffer byteBuffer = ByteBuffer.allocateDirect(ALLOC_SIZE).order(ByteOrder.nativeOrder());
114         for (int i = 0; i < ELEM_SIZE; i++) {
115             byteBuffer.putInt(i * CARRIER_SIZE , i);
116         }
117         unsafe.invokeCleaner(byteBuffer);
118     }
119 
120     // hack to even out calls to System::gc, which allows us to compare how the implicit segment deallocation
121     // fares compared with ByteBuffer; if there's no call to System.gc() we end up comparing how well the two
122     // act under significant native memory pressure, and here the ByteBuffer API has more juice, since it features
123     // a complex exponential back off with multiple GC retries (see ByteBuffer::allocateDirect). Of course, we
124     // don't care about those cases with segments, as if clients need to allocate/free very frequently
125     // they should just use deterministic deallocation (with confined scope) instead, which delivers much
126     // better performances anyway.
127     static byte gcCount = 0;
128 
129     @Benchmark
130     public void buffer_loop_implicit() {
131         if (gcCount++ == 0) System.gc(); // GC when we overflow
132         ByteBuffer byteBuffer = ByteBuffer.allocateDirect(ALLOC_SIZE).order(ByteOrder.nativeOrder());
133         for (int i = 0; i < ELEM_SIZE; i++) {
134             byteBuffer.putInt(i * CARRIER_SIZE , i);
135         }
136     }
137 
138     @Benchmark
139     public void segment_loop_implicit() {
140         if (gcCount++ == 0) System.gc(); // GC when we overflow
141         MemorySegment segment = MemorySegment.allocateNative(ALLOC_SIZE, 4, ResourceScope.newImplicitScope());
142         for (int i = 0; i < ELEM_SIZE; i++) {
143             VH_int.set(segment, (long) i, i);
144         }
145     }
146 }