1 /*
  2  * Copyright (c) 2022, red Hat, Inc. 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 
 24 
 25 package org.openjdk.bench.jdk.incubator.concurrent;
 26 
 27 import jdk.incubator.concurrent.ExtentLocal;
 28 import java.util.concurrent.TimeUnit;
 29 import org.openjdk.jmh.annotations.*;
 30 import org.openjdk.jmh.infra.Blackhole;
 31 
 32 import static org.openjdk.bench.jdk.incubator.concurrent.ExtentLocalsData.*;
 33 
 34 /**
 35  * Tests ExtentLocal
 36  */
 37 @BenchmarkMode(Mode.AverageTime)
 38 @OutputTimeUnit(TimeUnit.MICROSECONDS)
 39 @Warmup(iterations=4, time=1)
 40 @Measurement(iterations=10, time=1)
 41 @Threads(1)
 42 @Fork(value = 1,
 43       jvmArgsPrepend = {"-Djmh.executor.class=org.openjdk.bench.jdk.incubator.concurrent.ExtentLocalsExecutorService",
 44                         "-Djmh.executor=CUSTOM",
 45                         "-Djmh.blackhole.mode=COMPILER",
 46                         "--add-modules=jdk.incubator.concurrent",
 47                         "--enable-preview"})
 48 @State(Scope.Thread)
 49 @SuppressWarnings("preview")
 50 public class ExtentLocals {
 51 
 52     private static final Integer THE_ANSWER = 42;
 53 
 54     // Test 1: make sure ExtentLocal.get() is hoisted out of loops.
 55 
 56     @Benchmark
 57     public void thousandAdds_ExtentLocal(Blackhole bh) throws Exception {
 58         int result = 0;
 59         for (int i = 0; i < 1_000; i++) {
 60             result += ExtentLocalsData.sl1.get();
 61         }
 62         bh.consume(result);
 63     }
 64 
 65     @Benchmark
 66     public void thousandAdds_ThreadLocal(Blackhole bh) throws Exception {
 67         int result = 0;
 68         for (int i = 0; i < 1_000; i++) {
 69             result += ExtentLocalsData.tl1.get();
 70         }
 71         bh.consume(result);
 72     }
 73 
 74     // Test 2: stress the ExtentLocal cache.
 75     // The idea here is to use a bunch of bound values cyclically, which
 76     // stresses the ExtentLocal cache.
 77 
 78     int combine(int n, int i1, int i2, int i3, int i4, int i5, int i6) {
 79         return n + ((i1 ^ i2 >>> 6) + (i3 << 7) + i4 - i5 | i6);
 80     }
 81 
 82     @Benchmark
 83     public int sixValues_ExtentLocal() throws Exception {
 84         int result = 0;
 85         for (int i = 0 ; i < 166; i++) {
 86             result = combine(result, sl1.get(), sl2.get(), sl3.get(), sl4.get(), sl5.get(), sl6.get());
 87         }
 88         return result;
 89     }
 90 
 91     @Benchmark
 92     public int sixValues_ThreadLocal() throws Exception {
 93         int result = 0;
 94         for (int i = 0 ; i < 166; i++) {
 95             result = combine(result, tl1.get(), tl2.get(), tl3.get(), tl4.get(), tl5.get(), tl6.get());
 96         }
 97         return result;
 98     }
 99 
100     // Test 3: The cost of bind, then get
101     // This is the worst case for ExtentLocals because we have to create
102     // a binding, link it in, then search the current bindings. In addition, we
103     // create a cache entry for the bound value, then we immediately have to
104     // destroy it.
105 
106     @Benchmark
107     @OutputTimeUnit(TimeUnit.NANOSECONDS)
108     public int CreateBindThenGetThenRemove_ExtentLocal() throws Exception {
109         return ExtentLocal.where(sl1, THE_ANSWER).call(sl1::get);
110     }
111 
112 
113     // Create a Carrier ahead of time: might be slightly faster
114     private static final ExtentLocal.Carrier HOLD_42 = ExtentLocal.where(sl1, 42);
115     @Benchmark
116     @OutputTimeUnit(TimeUnit.NANOSECONDS)
117     public int bindThenGetThenRemove_ExtentLocal() throws Exception {
118         return HOLD_42.call(sl1::get);
119     }
120 
121     @Benchmark
122     @OutputTimeUnit(TimeUnit.NANOSECONDS)
123     public int bindThenGetThenRemove_ThreadLocal() throws Exception {
124         try {
125             tl1.set(THE_ANSWER);
126             return tl1.get();
127         } finally {
128             tl1.remove();
129         }
130     }
131 
132     // This has no exact equivalent in ExtentLocal, but it's provided here for
133     // information.
134     @Benchmark
135     @OutputTimeUnit(TimeUnit.NANOSECONDS)
136     public int bindThenGetNoRemove_ThreadLocal() throws Exception {
137         tl1.set(THE_ANSWER);
138         return tl1.get();
139     }
140 
141     // Test 4: The cost of binding, but not using any result
142 
143     @Benchmark
144     @OutputTimeUnit(TimeUnit.NANOSECONDS)
145     public Object bind_ExtentLocal() throws Exception {
146         return HOLD_42.call(this::getClass);
147     }
148 
149     @Benchmark
150     @OutputTimeUnit(TimeUnit.NANOSECONDS)
151     public Object bind_ThreadLocal() throws Exception {
152         try {
153             tl1.set(THE_ANSWER);
154             return this.getClass();
155         } finally {
156             tl1.remove();
157         }
158     }
159 
160     // Simply set a ThreadLocal so that the caller can see it
161     // This has no exact equivalent in ExtentLocal, but it's provided here for
162     // information.
163     @Benchmark
164     @OutputTimeUnit(TimeUnit.NANOSECONDS)
165     public void setNoRemove_ThreadLocal() throws Exception {
166         tl1.set(THE_ANSWER);
167     }
168 
169     // This is the closest I can think of to setNoRemove_ThreadLocal in that it
170     // returns a value in a ExtentLocal container. The container must already
171     // be bound to an AtomicReference for this to work.
172     @Benchmark
173     @OutputTimeUnit(TimeUnit.NANOSECONDS)
174     public void setNoRemove_ExtentLocal() throws Exception {
175         sl_atomicRef.get().setPlain(THE_ANSWER);
176     }
177 
178     // Test 5: A simple counter
179 
180     @Benchmark
181     @OutputTimeUnit(TimeUnit.NANOSECONDS)
182     public void counter_ExtentLocal() {
183         sl_atomicInt.get().setPlain(
184                 sl_atomicInt.get().getPlain() + 1);
185     }
186 
187     @Benchmark
188     @OutputTimeUnit(TimeUnit.NANOSECONDS)
189     public void counter_ThreadLocal() {
190         // Very slow:
191         // tl1.set(tl1.get() + 1);
192         var ctr = tl_atomicInt.get();
193         ctr.setPlain(ctr.getPlain() + 1);
194     }
195 }