1 /* 2 * Copyright (c) 2014 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. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 package org.openjdk.bench.java.lang; 26 27 import org.openjdk.jmh.annotations.Benchmark; 28 import org.openjdk.jmh.annotations.BenchmarkMode; 29 import org.openjdk.jmh.annotations.Mode; 30 import org.openjdk.jmh.annotations.OutputTimeUnit; 31 import org.openjdk.jmh.annotations.Scope; 32 import org.openjdk.jmh.annotations.Setup; 33 import org.openjdk.jmh.annotations.State; 34 import org.openjdk.jmh.infra.Blackhole; 35 36 import java.util.concurrent.TimeUnit; 37 38 /** 39 * Benchmark measuring java.lang.Class.newInstance speed. 40 */ 41 @BenchmarkMode(Mode.AverageTime) 42 @OutputTimeUnit(TimeUnit.NANOSECONDS) 43 @State(Scope.Thread) 44 public class NewInstance { 45 46 public Class<?>[] samePublicClasses; 47 public Class<?>[] differentPublicClasses; 48 public Class<?>[] differentPublicClassesConstant; 49 public Class<?>[] sameProtectedClasses; 50 public Class<?>[] differentProtectedClasses; 51 52 @Setup 53 public void setup() { 54 samePublicClasses = new Class<?>[]{Apub.class, Apub.class, Apub.class}; 55 differentPublicClasses = new Class<?>[]{Apub.class, Bpub.class, Cpub.class}; 56 differentPublicClassesConstant = new Class<?>[]{Apub.class, Bpub.class, Cpub.class}; 57 sameProtectedClasses = new Class<?>[]{Apro.class, Apro.class, Apro.class}; 58 differentProtectedClasses = new Class<?>[]{Apro.class, Bpro.class, Cpro.class}; 59 } 60 61 /** 62 * Performs Class.newInstance on the same class over and over again. That it is the same class is not provable at 63 * compile time. The class is protected. 64 */ 65 @Benchmark 66 public void threeSameProtected(Blackhole bh) throws IllegalAccessException, InstantiationException { 67 for (Class<?> cl : sameProtectedClasses) { 68 bh.consume(cl.newInstance()); 69 } 70 } 71 72 /** 73 * Performs Class.newInstance on three different classes, just allocating one instance of one class at a time. The 74 * classes are all protected. 75 */ 76 @Benchmark 77 public void threeDifferentProtected(Blackhole bh) throws IllegalAccessException, InstantiationException { 78 for (Class<?> cl : differentProtectedClasses) { 79 bh.consume(cl.newInstance()); 80 } 81 } 82 83 /** 84 * Performs Class.newInstance on the same class over and over again. That it is the same class is not provable at 85 * compile time. The class is public. 86 */ 87 @Benchmark 88 public void threeSamePublic(Blackhole bh) throws IllegalAccessException, InstantiationException { 89 for (Class<?> cl : samePublicClasses) { 90 bh.consume(cl.newInstance()); 91 } 92 } 93 94 /** 95 * Performs Class.newInstance on three different classes, just allocating one instance of one class at a time. The 96 * classes are all public. 97 */ 98 @Benchmark 99 public void threeDifferentPublic(Blackhole bh) throws IllegalAccessException, InstantiationException { 100 for (Class<?> cl : differentPublicClasses) { 101 bh.consume(cl.newInstance()); 102 } 103 } 104 105 /** 106 * Performs Class.newInstance on three different classes, just allocating one instance of one class at a time. The 107 * classes are all public. 108 */ 109 @Benchmark 110 public void threeDifferentPublicConstant(Blackhole bh) throws IllegalAccessException, InstantiationException { 111 bh.consume(Apub.class.newInstance()); 112 bh.consume(Bpub.class.newInstance()); 113 bh.consume(Cpub.class.newInstance()); 114 } 115 116 @Benchmark 117 public void threeDifferentPublicFinal(Blackhole bh) throws IllegalAccessException, InstantiationException { 118 for (Class<?> cl : differentPublicClassesConstant) { 119 bh.consume(cl.newInstance()); 120 } 121 } 122 123 /* Protected test classes */ 124 static class Apro {} 125 static class Bpro {} 126 static class Cpro {} 127 128 /* Public test classes */ 129 public static class Apub {} 130 public static class Bpub {} 131 public static class Cpub {} 132 133 }