raphw / byte-buddy / #801

/*

 * Copyright 2014 - Present Rafael Winterhalter

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package net.bytebuddy.benchmark;

import javassist.util.proxy.MethodFilter;

import javassist.util.proxy.MethodHandler;

import javassist.util.proxy.ProxyFactory;

import net.bytebuddy.ByteBuddy;

import net.bytebuddy.benchmark.specimen.ExampleClass;

import net.bytebuddy.description.type.TypeDescription;

import net.bytebuddy.dynamic.loading.ClassLoadingStrategy;

import net.bytebuddy.dynamic.scaffold.TypeValidation;

import net.bytebuddy.implementation.Implementation;

import net.bytebuddy.implementation.MethodDelegation;

import net.bytebuddy.implementation.SuperMethodCall;

import net.bytebuddy.implementation.bind.annotation.AllArguments;

import net.bytebuddy.implementation.bind.annotation.RuntimeType;

import net.bytebuddy.implementation.bind.annotation.SuperCall;

import net.bytebuddy.implementation.bind.annotation.SuperMethod;

import net.bytebuddy.implementation.bind.annotation.This;

import net.bytebuddy.pool.TypePool;

import net.bytebuddy.utility.nullability.MaybeNull;

import net.sf.cglib.proxy.CallbackHelper;

import net.sf.cglib.proxy.Enhancer;

import net.sf.cglib.proxy.MethodInterceptor;

import net.sf.cglib.proxy.MethodProxy;

import net.sf.cglib.proxy.NoOp;

import org.openjdk.jmh.annotations.Benchmark;

import org.openjdk.jmh.annotations.BenchmarkMode;

import org.openjdk.jmh.annotations.Mode;

import org.openjdk.jmh.annotations.OutputTimeUnit;

import org.openjdk.jmh.annotations.Scope;

import org.openjdk.jmh.annotations.Setup;

import org.openjdk.jmh.annotations.State;

import java.lang.reflect.Method;

import java.net.URL;

import java.net.URLClassLoader;

import java.util.concurrent.Callable;

import java.util.concurrent.TimeUnit;

import static net.bytebuddy.matcher.ElementMatchers.isDeclaredBy;

import static net.bytebuddy.matcher.ElementMatchers.none;

/**

 * <p>

 * This benchmark dynamically creates a subclass of {@link ExampleClass} which overrides all methods to invoke the

 * direct super class's implementation. The benchmark furthermore creates an instance of this class since some

 * code generation frameworks rely on this property. Because this benchmark requires the creation of a subclass,

 * the JDK proxy is not included in this benchmark.

 * </p>

 * <p>

 * Note that this class defines all values that are accessed by benchmark methods as instance fields. This way, the JIT

 * compiler's capability of constant folding is limited in order to produce more comparable test results.

 * </p>

 */

@State(Scope.Thread)

@BenchmarkMode(Mode.AverageTime)

@OutputTimeUnit(TimeUnit.MICROSECONDS)

    /**

     * The base class to be subclassed in all benchmarks.

     */

    /**

     * The base class to be subclassed in all benchmarks.

     */

    /**

     * The zero-length of the class loader's URL.

     */

    /**

     * Creates a new class loader. By using a fresh class loader for each creation, we avoid name space issues.

     * A class loader's creation is part of the benchmark but since any test creates a class loader exactly once,

     * the benchmark remains valid.

     *

     * @return A new class loader.

     */

    private ClassLoader newClassLoader() {

    }

    /**

     * An implementation to be used by {@link ClassByExtensionBenchmark#benchmarkByteBuddyWithProxyAndReusedDelegator()}.

     */

    @MaybeNull

    private Implementation proxyInterceptor;

    /**

     * An implementation to be used by {@link ClassByExtensionBenchmark#benchmarkByteBuddyWithAccessorAndReusedDelegator()}.

     */

    @MaybeNull

    private Implementation accessInterceptor;

    /**

     * An implementation to be used by {@link ClassByExtensionBenchmark#benchmarkByteBuddyWithPrefixAndReusedDelegator()}.

     */

    @MaybeNull

    private Implementation.Composable prefixInterceptor;

    /**

     * A description of {@link ClassByExtensionBenchmark#baseClass}.

     */

    @MaybeNull

    private TypeDescription baseClassDescription;

    /**

     * A description of {@link ByteBuddyProxyInterceptor}.

     */

    @MaybeNull

    private TypeDescription proxyClassDescription;

    /**

     * A description of {@link ByteBuddyAccessInterceptor}.

     */

    @MaybeNull

    private TypeDescription accessClassDescription;

    /**

     * A description of {@link ByteBuddyPrefixInterceptor}.

     */

    @MaybeNull

    private TypeDescription prefixClassDescription;

    /**

     * A method delegation to {@link ByteBuddyProxyInterceptor}.

     */

    @MaybeNull

    private Implementation proxyInterceptorDescription;

    /**

     * A method delegation to {@link ByteBuddyAccessInterceptor}.

     */

    @MaybeNull

    private Implementation accessInterceptorDescription;

    /**

     * A method delegation to {@link ByteBuddyPrefixInterceptor}.

     */

    @MaybeNull

    private Implementation.Composable prefixInterceptorDescription;

    /**

     * A setup method to create precomputed delegator.

     */

    @Setup

    public void setup() {

    /**

     * Creates a baseline for the benchmark.

     *

     * @return A simple object that is not transformed.

     */

    @Benchmark

    public ExampleClass baseline() {

    }

    /**

     * Performs a benchmark of a class extension using Byte Buddy. This benchmark creates proxy classes for the invocation

     * of super methods which requires the creation of auxiliary classes.

     *

     * @return The created instance, in order to avoid JIT removal.

     * @throws java.lang.Exception If the invocation causes an exception.

     */

    @Benchmark

    public ExampleClass benchmarkByteBuddyWithProxy() throws Exception {

    }

    /**

     * Performs a benchmark of a class extension using Byte Buddy. This benchmark also uses the annotation-based approach

     * but creates delegation methods which do not require the creation of additional classes. This benchmark reuses a

     * precomputed delegator.

     *

     * @return The created instance, in order to avoid JIT removal.

     * @throws Exception If the invocation causes an exception.

     */

    @Benchmark

    public ExampleClass benchmarkByteBuddyWithProxyAndReusedDelegator() throws Exception {

    }

    /**

     * Performs a benchmark of a class extension using Byte Buddy. This benchmark creates proxy classes for the invocation

     * of super methods which requires the creation of auxiliary classes. This benchmark uses a type pool to compare against

     * usage of the reflection API.

     *

     * @return The created instance, in order to avoid JIT removal.

     * @throws java.lang.Exception If the invocation causes an exception.

     */

    @Benchmark

    public ExampleClass benchmarkByteBuddyWithProxyWithTypePool() throws Exception {

    }

    /**

     * Performs a benchmark of a class extension using Byte Buddy. This benchmark also uses the annotation-based approach

     * but creates delegation methods which do not require the creation of additional classes. This benchmark reuses a

     * precomputed delegator. This benchmark uses a type pool to compare against usage of the reflection API.

     *

     * @return The created instance, in order to avoid JIT removal.

     * @throws Exception If the invocation causes an exception.

     */

    @Benchmark

    public ExampleClass benchmarkByteBuddyWithProxyAndReusedDelegatorWithTypePool() throws Exception {

    }

    /**

     * Performs a benchmark of a class extension using Byte Buddy. This benchmark also uses the annotation-based approach

     * but creates delegation methods which do not require the creation of additional classes.

     *

     * @return The created instance, in order to avoid JIT removal.

     * @throws Exception If the invocation causes an exception.

     */

    @Benchmark

    public ExampleClass benchmarkByteBuddyWithAccessor() throws Exception {

    }

    /**

     * Performs a benchmark of a class extension using Byte Buddy. This benchmark also uses the annotation-based approach

     * but creates delegation methods which do not require the creation of additional classes. This benchmark reuses a

     * precomputed delegator.

     *

     * @return The created instance, in order to avoid JIT removal.

     * @throws Exception If the invocation causes an exception.

     */

    @Benchmark

    public ExampleClass benchmarkByteBuddyWithAccessorAndReusedDelegator() throws Exception {

    }

    /**

     * Performs a benchmark of a class extension using Byte Buddy. This benchmark also uses the annotation-based approach

     * but creates delegation methods which do not require the creation of additional classes. This benchmark uses a type

     * pool to compare against usage of the reflection API.

     *

     * @return The created instance, in order to avoid JIT removal.

     * @throws Exception If the invocation causes an exception.

     */

    @Benchmark

    public ExampleClass benchmarkByteBuddyWithAccessorWithTypePool() throws Exception {

    }

    /**

     * Performs a benchmark of a class extension using Byte Buddy. This benchmark also uses the annotation-based approach

     * but creates delegation methods which do not require the creation of additional classes. This benchmark reuses a

     * precomputed delegator. This benchmark uses a type pool to compare against usage of the reflection API.

     *

     * @return The created instance, in order to avoid JIT removal.

     * @throws Exception If the invocation causes an exception.

     */

    @Benchmark

    public ExampleClass benchmarkByteBuddyWithAccessorAndReusedDelegatorWithTypePool() throws Exception {

    }

    /**

     * Performs a benchmark of a class extension using Byte Buddy. This benchmark uses delegation but completes with a

     * hard-coded super method call.

     *

     * @return The created instance, in order to avoid JIT removal.

     * @throws Exception If the invocation causes an exception.

     */

    @Benchmark

    public ExampleClass benchmarkByteBuddyWithPrefix() throws Exception {

    }

    /**

     * Performs a benchmark of a class extension using Byte Buddy. This benchmark uses delegation but completes with a

     * hard-coded super method call. This benchmark reuses a precomputed delegator.

     *

     * @return The created instance, in order to avoid JIT removal.

     * @throws Exception If the invocation causes an exception.

     */

    @Benchmark

    public ExampleClass benchmarkByteBuddyWithPrefixAndReusedDelegator() throws Exception {

    }

    /**

     * Performs a benchmark of a class extension using Byte Buddy. This benchmark uses delegation but completes with a

     * hard-coded super method call. This benchmark uses a type pool to compare against usage of the reflection API.

     *

     * @return The created instance, in order to avoid JIT removal.

     * @throws Exception If the invocation causes an exception.

     */

    @Benchmark

    public ExampleClass benchmarkByteBuddyWithPrefixWithTypePool() throws Exception {

    }

    /**

     * Performs a benchmark of a class extension using Byte Buddy. This benchmark uses delegation but completes with a

     * hard-coded super method call. This benchmark reuses a precomputed delegator. This benchmark uses a type pool to

     * compare against usage of the reflection API.

     *

     * @return The created instance, in order to avoid JIT removal.

     * @throws Exception If the invocation causes an exception.

     */

    @Benchmark

    public ExampleClass benchmarkByteBuddyWithPrefixAndReusedDelegatorWithTypePool() throws Exception {

    }

    /**

     * Performs a benchmark of a class extension using Byte Buddy. This benchmark uses a specialized interception

     * strategy which is easier to inline by the compiler.

     *

     * @return The created instance, in order to avoid JIT removal.

     * @throws java.lang.Exception If the invocation causes an exception.

     */

    @Benchmark

    public ExampleClass benchmarkByteBuddySpecialized() throws Exception {

    }

    /**

     * Performs a benchmark of a class extension using cglib.

     *

     * @return The created instance, in order to avoid JIT removal.

     */

    @Benchmark

    public ExampleClass benchmarkCglib() {

            protected Object getCallback(Method method) {

                        public Object intercept(Object object,

                                                Method method,

                                                Object[] arguments,

                                                MethodProxy methodProxy) throws Throwable {

                        }

                    };

                } else {

                }

            }

        };

    }

    /**

     * Performs a benchmark of a class extension using javassist proxies.

     *

     * @return The created instance, in order to avoid JIT removal.

     * @throws java.lang.Exception If the invocation causes an exception.

     */

    @Benchmark

    public ExampleClass benchmarkJavassist() throws Exception {

            protected ClassLoader getClassLoader() {

            }

        };

            public boolean isHandled(Method method) {

            }

        });

        @SuppressWarnings("unchecked")

            public Object invoke(Object self,

                                 Method thisMethod,

                                 Method proceed,

                                 Object[] argument) throws Throwable {

            }

        });

    }

    /**

     * Instead of using the {@link net.bytebuddy.implementation.SuperMethodCall} implementation, we are using

     * a delegate in order to emulate the interception approach of other instrumentation libraries. Otherwise,

     * this benchmark would be biased in favor of Byte Buddy.

     */

    public static class ByteBuddyProxyInterceptor {

        /**

         * The interceptor's constructor is not supposed to be invoked.

         */

        }

        /**

         * Call the super method.

         *

         * @param zuper A proxy for invoking the super method.

         * @return The return value of the super method invocation.

         * @throws Exception As declared by {@link java.util.concurrent.Callable}'s contract.

         */

        @RuntimeType

        public static Object intercept(@SuperCall Callable<?> zuper) throws Exception {

        }

    }

    /**

     * Instead of using the {@link net.bytebuddy.implementation.SuperMethodCall} implementation, we are creating

     * delegate methods that allow the invocation of the original code.

     */

    public static class ByteBuddyAccessInterceptor {

        /**

         * The interceptor's constructor is not supposed to be invoked.

         */

        }

        /**

         * Calls the super method.

         *

         * @param target    The target instance.

         * @param arguments The arguments to the method.

         * @param method    A method for invoking the original code.

         * @return The return value of the method.

         * @throws Exception If the super method call yields an exception.

         */

        @RuntimeType

        public static Object intercept(@This Object target, @AllArguments Object[] arguments, @SuperMethod(privileged = false) Method method) throws Exception {

        }

    }

    /**

     * An interceptor that is invoked prior to a super method call.

     */

    public static class ByteBuddyPrefixInterceptor {

        /**

         * The interceptor's constructor is not supposed to be invoked.

         */

        }

        /**

         * Invoked prior to a method call.

         */

        public static void intercept() {

            /* do nothing */

    }

}