Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- @Retention(RetentionPolicy.RUNTIME)
- public @interface MeasureTime {
- int[] iterations() default {};
- int[] warmUpIterations() default {};
- }
- @Retention(RetentionPolicy.RUNTIME)
- public @interface Benchmark {
- int iterations() default BenchmarkRunner.DEFAULT_ITERATIONS;
- int warmUpIterations() default BenchmarkRunner.DEFAULT_WARM_UP_ITERATIONS;
- }
- import microbench.api.annotation.Benchmark;
- import microbench.api.annotation.MeasureTime;
- import microbench.api.annotation.Prepare;
- import microbench.api.annotation.Validate;
- import java.lang.reflect.InvocationTargetException;
- import java.lang.reflect.Method;
- import java.util.*;
- public class BenchmarkRunner {
- public static final int DEFAULT_ITERATIONS = 1;
- public static final int DEFAULT_WARM_UP_ITERATIONS = 0;
- private final Object target;
- private final int defaultIterations;
- private final int defaultWarmUpIterations;
- private final List<Method> measureTimeMethods = new ArrayList<>();
- private final List<Method> prepareMethods = new ArrayList<>();
- private final List<Method> validateMethods = new ArrayList<>();
- public BenchmarkRunner(Object target) {
- this.target = target;
- Class<?> clazz = target.getClass();
- Benchmark annotation = clazz.getAnnotation(Benchmark.class);
- if (annotation != null) {
- defaultIterations = annotation.iterations();
- defaultWarmUpIterations = annotation.warmUpIterations();
- } else {
- defaultIterations = DEFAULT_ITERATIONS;
- defaultWarmUpIterations = DEFAULT_WARM_UP_ITERATIONS;
- }
- for (Method method : clazz.getDeclaredMethods()) {
- if (method.getAnnotation(MeasureTime.class) != null) {
- measureTimeMethods.add(method);
- } else if (method.getAnnotation(Prepare.class) != null) {
- prepareMethods.add(method);
- } else if (method.getAnnotation(Validate.class) != null) {
- validateMethods.add(method);
- }
- }
- Collections.sort(measureTimeMethods, (o1, o2) -> o1.getName().compareTo(o2.getName()));
- }
- public static void run(Object target) {
- new BenchmarkRunner(target).run();
- }
- public void run() {
- runQuietly();
- }
- private void runQuietly() {
- try {
- runNormally();
- } catch (InvocationTargetException | IllegalAccessException e) {
- e.printStackTrace();
- }
- }
- private void runNormally() throws InvocationTargetException, IllegalAccessException {
- Map<Method, Throwable> validationFailures = new LinkedHashMap<>();
- for (Method method : measureTimeMethods) {
- MeasureTime measureTime = method.getAnnotation(MeasureTime.class);
- if (measureTime != null) {
- try {
- runMeasureTime(target, method, measureTime);
- } catch (InvocationTargetException e) {
- Throwable cause = e.getCause();
- if (cause instanceof AssertionError) {
- validationFailures.put(method, cause);
- printExecutionFailure(method);
- } else {
- throw e;
- }
- }
- }
- }
- if (!validationFailures.isEmpty()) {
- System.out.println();
- for (Map.Entry<Method, Throwable> entry : validationFailures.entrySet()) {
- System.out.print("Validation failed while executing " + entry.getKey().getName() + ": ");
- System.out.println(entry.getValue());
- }
- }
- }
- private void invokeMethods(Object instance, List<Method> methods) throws InvocationTargetException, IllegalAccessException {
- for (Method method : methods) {
- method.invoke(instance);
- }
- }
- private void runMeasureTime(Object instance, Method method, MeasureTime measureTime)
- throws InvocationTargetException, IllegalAccessException {
- for (int i = 0; i < getWarmUpIterations(measureTime); ++i) {
- invokeMethods(instance, prepareMethods);
- method.invoke(instance);
- invokeMethods(instance, validateMethods);
- }
- int iterations = getIterations(measureTime);
- long sumDiffs = 0;
- for (int i = 0; i < iterations; ++i) {
- invokeMethods(instance, prepareMethods);
- long start = System.nanoTime();
- method.invoke(instance);
- sumDiffs += System.nanoTime() - start;
- invokeMethods(instance, validateMethods);
- }
- printExecutionResult(method, sumDiffs / iterations);
- }
- private void printExecutionInfo(String message, String ms) {
- System.out.println(String.format("%-60s: %10s ms", message, ms));
- }
- private void printExecutionFailure(Method method) {
- printExecutionInfo("Validation failed while executing " + method.getName(), "-");
- }
- private void printExecutionResult(Method method, long nanoSeconds) {
- printExecutionInfo("Average execution time of " + method.getName(), "" + nanoSeconds / 1_000_000);
- }
- private int getParamValue(int[] values, int defaultValue) {
- if (values.length > 0) {
- return values[0];
- }
- return defaultValue;
- }
- private int getWarmUpIterations(MeasureTime measureTime) {
- return getParamValue(measureTime.warmUpIterations(), defaultWarmUpIterations);
- }
- private int getIterations(MeasureTime measureTime) {
- return getParamValue(measureTime.iterations(), defaultIterations);
- }
- }
- public class SimpleSortingDemo {
- private List<Integer> shuffledList;
- public SimpleSortingDemo() {
- shuffledList = new ArrayList<>();
- for (int i = 0; i < 10000; ++i) {
- shuffledList.add(i);
- }
- Collections.shuffle(shuffledList);
- }
- public static void main(String[] args) {
- new BenchmarkRunner(new SimpleSortingDemo()).run();
- }
- @MeasureTime
- public void bubbleSort() {
- BubbleSort.sort(new ArrayList<Integer>(shuffledList));
- }
- @MeasureTime
- public void insertionSort() {
- InsertionSort.sort(new ArrayList<Integer>(shuffledList));
- }
- }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement