Skip to content

Commit

Permalink
Issue ReactiveX#12 speed optimisations and cleanup
Browse files Browse the repository at this point in the history
  • Loading branch information
@storozhukBM
storozhukBM committed Dec 2, 2016
1 parent 08312ea commit 49fbe85
Show file tree
Hide file tree
Showing 5 changed files with 156 additions and 175 deletions.
89 changes: 52 additions & 37 deletions src/jmh/java/javaslang/circuitbreaker/CircuitBreakerBenchmark.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -18,40 +18,55 @@
*/
package javaslang.circuitbreaker;

//@State(Scope.Benchmark)
//@OutputTimeUnit(TimeUnit.MILLISECONDS)
//@BenchmarkMode(Mode.Throughput)
//public class CircuitBreakerBenchmark {
//
// private CircuitBreaker circuitBreaker;
// private Supplier<String> supplier;
// private static final int ITERATION_COUNT = 10;
// private static final int WARMUP_COUNT = 10;
// private static final int THREAD_COUNT = 10;
//
// @Setup
// public void setUp() {
// CircuitBreakerRegistry circuitBreakerRegistry = CircuitBreakerRegistry.of(CircuitBreakerConfig.custom()
// .failureRateThreshold(1)
// .waitDurationInOpenState(Duration.ofSeconds(1))
// .build());
// circuitBreaker = circuitBreakerRegistry.circuitBreaker("testCircuitBreaker");
//
// supplier = CircuitBreaker.decorateSupplier(() -> {
// try {
// Thread.sleep(100);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// return "Hello Benchmark";
// }, circuitBreaker);
// }
//
// @Benchmark
// @Threads(value = THREAD_COUNT)
// @Warmup(iterations = WARMUP_COUNT)
// @Measurement(iterations = ITERATION_COUNT)
// public String invokeSupplier(){
// return supplier.get();
// }
//}
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Measurement;
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 org.openjdk.jmh.annotations.Threads;
import org.openjdk.jmh.annotations.Warmup;

import java.time.Duration;
import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;

@State(Scope.Benchmark)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@BenchmarkMode(Mode.Throughput)
public class CircuitBreakerBenchmark {

private static final int ITERATION_COUNT = 10;
private static final int WARMUP_COUNT = 10;
private static final int THREAD_COUNT = 10;
private CircuitBreaker circuitBreaker;
private Supplier<String> supplier;

@Setup
public void setUp() {
CircuitBreakerRegistry circuitBreakerRegistry = CircuitBreakerRegistry.of(CircuitBreakerConfig.custom()
.failureRateThreshold(1)
.waitDurationInOpenState(Duration.ofSeconds(1))
.build());
circuitBreaker = circuitBreakerRegistry.circuitBreaker("testCircuitBreaker");

supplier = CircuitBreaker.decorateSupplier(() -> {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "Hello Benchmark";
}, circuitBreaker);
}

@Benchmark
@Threads(value = THREAD_COUNT)
@Warmup(iterations = WARMUP_COUNT)
@Measurement(iterations = ITERATION_COUNT)
public String invokeSupplier() {
return supplier.get();
}
}
103 changes: 6 additions & 97 deletions src/jmh/java/javaslang/circuitbreaker/RateLimiterBenchmark.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -23,18 +23,16 @@

@State(Scope.Benchmark)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
@BenchmarkMode(Mode.All)
public class RateLimiterBenchmark {

public static final int FORK_COUNT = 2;
private static final int WARMUP_COUNT = 10;
private static final int ITERATION_COUNT = 5;
private static final int ITERATION_COUNT = 10;
private static final int THREAD_COUNT = 2;

private RateLimiter semaphoreBasedRateLimiter;
private AtomicRateLimiter atomicRateLimiter;
private AtomicRateLimiter.State state;
private static final Object mutex = new Object();

private Supplier<String> semaphoreGuardedSupplier;
private Supplier<String> atomicGuardedSupplier;
Expand All @@ -48,7 +46,6 @@ public void setUp() {
.build();
semaphoreBasedRateLimiter = new SemaphoreBasedRateLimiter("semaphoreBased", rateLimiterConfig);
atomicRateLimiter = new AtomicRateLimiter("atomicBased", rateLimiterConfig);
state = atomicRateLimiter.state.get();

Supplier<String> stringSupplier = () -> {
Blackhole.consumeCPU(1);
Expand All @@ -63,104 +60,16 @@ public void setUp() {
@Warmup(iterations = WARMUP_COUNT)
@Fork(value = FORK_COUNT)
@Measurement(iterations = ITERATION_COUNT)
public void calculateNextState(Blackhole bh) {
AtomicRateLimiter.State next = atomicRateLimiter.calculateNextState(Duration.ZERO.toNanos(), this.state);
bh.consume(next);
public String semaphoreBasedPermission() {
return semaphoreGuardedSupplier.get();
}

@Benchmark
@Threads(value = THREAD_COUNT)
@Warmup(iterations = WARMUP_COUNT)
@Fork(value = FORK_COUNT)
@Measurement(iterations = ITERATION_COUNT)
public void nanosToWaitForPermission(Blackhole bh) {
long next = atomicRateLimiter.nanosToWaitForPermission(1, 315L, 31L);
bh.consume(next);
public String atomicPermission() {
return atomicGuardedSupplier.get();
}

@Benchmark
@Threads(value = THREAD_COUNT)
@Warmup(iterations = WARMUP_COUNT)
@Fork(value = FORK_COUNT)
@Measurement(iterations = ITERATION_COUNT)
public void reservePermissions(Blackhole bh) {
AtomicRateLimiter.State next = atomicRateLimiter.reservePermissions(0L, 31L, 1, 0L);
bh.consume(next);
}

@Benchmark
@Threads(value = THREAD_COUNT)
@Warmup(iterations = WARMUP_COUNT)
@Fork(value = FORK_COUNT)
@Measurement(iterations = ITERATION_COUNT)
public void currentNanoTime(Blackhole bh) {
long next = atomicRateLimiter.currentNanoTime();
bh.consume(next);
}

// @Benchmark
// @Threads(value = THREAD_COUNT)
// @Warmup(iterations = WARMUP_COUNT)
// @Fork(value = FORK_COUNT)
// @Measurement(iterations = ITERATION_COUNT)
// public void mutex(Blackhole bh) {
// synchronized (mutex) {
// state = atomicRateLimiter.calculateNextState(Duration.ZERO.toNanos(), state);
// }
// }
//
// @Benchmark
// @Threads(value = THREAD_COUNT)
// @Warmup(iterations = WARMUP_COUNT)
// @Fork(value = FORK_COUNT)
// @Measurement(iterations = ITERATION_COUNT)
// public void atomic(Blackhole bh) {
// atomicRateLimiter.state.updateAndGet(state -> {
// return atomicRateLimiter.calculateNextState(Duration.ZERO.toNanos(), state);
// });
// }
//
// @Benchmark
// @Threads(value = THREAD_COUNT)
// @Warmup(iterations = WARMUP_COUNT)
// @Fork(value = FORK_COUNT)
// @Measurement(iterations = ITERATION_COUNT)
// public void atomicBackOf(Blackhole bh) {
// AtomicRateLimiter.State prev;
// AtomicRateLimiter.State next;
// do {
// prev = atomicRateLimiter.state.get();
// next = atomicRateLimiter.calculateNextState(Duration.ZERO.toNanos(), prev);
// } while (!compareAndSet(prev, next));
// }
//
// /*
// https://arxiv.org/abs/1305.5800 https://dzone.com/articles/wanna-get-faster-wait-bit
// */
// public boolean compareAndSet(final AtomicRateLimiter.State current, final AtomicRateLimiter.State next) {
// if (atomicRateLimiter.state.compareAndSet(current, next)) {
// return true;
// } else {
// LockSupport.parkNanos(1);
// return false;
// }
// }
//
// @Benchmark
// @Threads(value = THREAD_COUNT)
// @Warmup(iterations = WARMUP_COUNT)
// @Fork(value = FORK_COUNT)
// @Measurement(iterations = ITERATION_COUNT)
// public String semaphoreBasedPermission() {
// return semaphoreGuardedSupplier.get();
// }
//
// @Benchmark
// @Threads(value = THREAD_COUNT)
// @Warmup(iterations = WARMUP_COUNT)
// @Fork(value = FORK_COUNT)
// @Measurement(iterations = ITERATION_COUNT)
// public String atomicPermission() {
// return atomicGuardedSupplier.get();
// }
}
62 changes: 38 additions & 24 deletions src/jmh/java/javaslang/circuitbreaker/RingBitSetBenachmark.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -18,27 +18,41 @@
*/
package javaslang.circuitbreaker;

//@State(Scope.Benchmark)
//@OutputTimeUnit(TimeUnit.MILLISECONDS)
//@BenchmarkMode(Mode.Throughput)
//public class RingBitSetBenachmark {
//
// private RingBitSet ringBitSet;
// private static final int ITERATION_COUNT = 10;
// private static final int WARMUP_COUNT = 10;
// private static final int THREAD_COUNT = 10;
//
// @Setup
// public void setUp() {
// ringBitSet = new RingBitSet(1000);
// }
//
// @Benchmark
// @Threads(value = THREAD_COUNT)
// @Warmup(iterations = WARMUP_COUNT)
// @Measurement(iterations = ITERATION_COUNT)
// public void setBits(){
// ringBitSet.setNextBit(true);
// ringBitSet.setNextBit(false);
// }
//}
import javaslang.circuitbreaker.internal.RingBitSet;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Measurement;
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 org.openjdk.jmh.annotations.Threads;
import org.openjdk.jmh.annotations.Warmup;

import java.util.concurrent.TimeUnit;

@State(Scope.Benchmark)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@BenchmarkMode(Mode.Throughput)
public class RingBitSetBenachmark {

private static final int ITERATION_COUNT = 10;
private static final int WARMUP_COUNT = 10;
private static final int THREAD_COUNT = 10;
private RingBitSet ringBitSet;

@Setup
public void setUp() {
ringBitSet = new RingBitSet(1000);
}

@Benchmark
@Threads(value = THREAD_COUNT)
@Warmup(iterations = WARMUP_COUNT)
@Measurement(iterations = ITERATION_COUNT)
public void setBits() {
ringBitSet.setNextBit(true);
ringBitSet.setNextBit(false);
}
}
5 changes: 0 additions & 5 deletions src/jmh/java/javaslang/circuitbreaker/stateCalculationBenchmark.txt
View file

This file was deleted.

Loading

0 comments on commit 49fbe85

Please sign in to comment.