{
INSTANCE;
@Override
public void handleEventException(final Throwable ex, final long sequence, final SimpleEvent event)
{
// nop
}
@Override
public void handleOnStartException(final Throwable ex)
{
// nop
}
@Override
public void handleOnShutdownException(final Throwable ex)
{
// nop
}
}
}
================================================
FILE: src/jcstress/java/com/lmax/disruptor/MultiProducerSequencerUnsafeStress.java
================================================
package com.lmax.disruptor;
import com.lmax.disruptor.alternatives.MultiProducerSequencerUnsafe;
import org.openjdk.jcstress.annotations.Actor;
import org.openjdk.jcstress.annotations.JCStressTest;
import org.openjdk.jcstress.annotations.Outcome;
import org.openjdk.jcstress.annotations.State;
import org.openjdk.jcstress.infra.results.ZZ_Result;
import static org.openjdk.jcstress.annotations.Expect.ACCEPTABLE;
import static org.openjdk.jcstress.annotations.Expect.FORBIDDEN;
public final class MultiProducerSequencerUnsafeStress
{
private static Sequencer createSequencer()
{
return new MultiProducerSequencerUnsafe(64, new BlockingWaitStrategy());
}
@JCStressTest
@Outcome(id = {"false, false", "true, false", "true, true"}, expect = ACCEPTABLE, desc = "Assuming ordered updates")
@Outcome(id = "false, true", expect = FORBIDDEN, desc = "publish(2) should not be available before publish(1)")
@State
public static class PublishUpdatesIsAvailableLazily
{
Sequencer sequencer = createSequencer();
@Actor
public void actor1()
{
// The store to the underlying availableBuffer is lazily done and stores can be visible out of order
sequencer.publish(1);
sequencer.publish(2);
}
@Actor
public void actor2(final ZZ_Result r)
{
// The load in isAvailable is a full store/load barrier, so any stores from actor1 should get flushed
r.r2 = sequencer.isAvailable(2);
r.r1 = sequencer.isAvailable(1);
}
}
/**
* The isAvailable implementation is volatile so we should never see an update to it without seeing the update to a
* previously set value also.
*
* If the value was not volatile there would be no ordering rules stopping it being seen updated before the
* other value.
*/
@JCStressTest
@Outcome(id = "false, false", expect = ACCEPTABLE, desc = "Doing both reads early.")
@Outcome(id = "true, true", expect = ACCEPTABLE, desc = "Doing both reads late.")
@Outcome(id = "false, true", expect = ACCEPTABLE, desc = "Caught in the middle: $x is visible, $y is not.")
@Outcome(id = "true, false", expect = FORBIDDEN, desc = "Seeing $y, but not $x!")
@State
public static class GetVolatile
{
boolean x = false;
Sequencer y = createSequencer();
@Actor
public void actor1()
{
x = true;
y.publish(1);
}
@Actor
public void actor2(final ZZ_Result r)
{
r.r1 = y.isAvailable(1);
r.r2 = x;
}
}
/**
* In absence of synchronization, the order of independent reads is undefined.
* In our case, the read of isAvailable is volatile which mandates the writes to the same
* variable to be observed in a total order (that implies that _observers_ are also ordered)
*/
@JCStressTest
@Outcome(id = "false, false", expect = ACCEPTABLE, desc = "Doing both reads early.")
@Outcome(id = "true, true", expect = ACCEPTABLE, desc = "Doing both reads late.")
@Outcome(id = "false, true", expect = ACCEPTABLE, desc = "Doing first read early, not surprising.")
@Outcome(id = "true, false", expect = FORBIDDEN, desc = "Violates coherence.")
@State
public static class SameVolatileRead
{
private final SameVolatileRead.Holder h1 = new SameVolatileRead.Holder();
private final SameVolatileRead.Holder h2 = h1;
private static class Holder
{
Sequencer sequence = createSequencer();
}
@Actor
public void actor1()
{
h1.sequence.publish(1);
}
@Actor
public void actor2(final ZZ_Result r)
{
SameVolatileRead.Holder h1 = this.h1;
SameVolatileRead.Holder h2 = this.h2;
r.r1 = h1.sequence.isAvailable(1);
r.r2 = h2.sequence.isAvailable(1);
}
}
}
================================================
FILE: src/jcstress/java/com/lmax/disruptor/MultiProducerSequencerVarHandleStress.java
================================================
package com.lmax.disruptor;
import com.lmax.disruptor.alternatives.MultiProducerSequencerVarHandle;
import org.openjdk.jcstress.annotations.Actor;
import org.openjdk.jcstress.annotations.JCStressTest;
import org.openjdk.jcstress.annotations.Outcome;
import org.openjdk.jcstress.annotations.State;
import org.openjdk.jcstress.infra.results.ZZ_Result;
import static org.openjdk.jcstress.annotations.Expect.ACCEPTABLE;
import static org.openjdk.jcstress.annotations.Expect.FORBIDDEN;
public final class MultiProducerSequencerVarHandleStress
{
private static Sequencer createSequencer()
{
return new MultiProducerSequencerVarHandle(64, new BlockingWaitStrategy());
}
@JCStressTest
@Outcome(id = {"false, false", "true, false", "true, true"}, expect = ACCEPTABLE, desc = "Assuming ordered updates")
@Outcome(id = "false, true", expect = FORBIDDEN, desc = "publish(2) should not be available before publish(1)")
@State
public static class PublishUpdatesIsAvailableLazily
{
Sequencer sequencer = createSequencer();
@Actor
public void actor1()
{
sequencer.publish(1);
sequencer.publish(2);
}
@Actor
public void actor2(final ZZ_Result r)
{
r.r2 = sequencer.isAvailable(2);
r.r1 = sequencer.isAvailable(1);
}
}
/**
* The isAvailable implementation is volatile so we should never see an update to it without seeing the update to a
* previously set value also.
*
*
If the value was not volatile there would be no ordering rules stopping it being seen updated before the
* other value.
*/
@JCStressTest
@Outcome(id = "false, false", expect = ACCEPTABLE, desc = "Doing both reads early.")
@Outcome(id = "true, true", expect = ACCEPTABLE, desc = "Doing both reads late.")
@Outcome(id = "false, true", expect = ACCEPTABLE, desc = "Caught in the middle: $x is visible, $y is not.")
@Outcome(id = "true, false", expect = FORBIDDEN, desc = "Seeing $y, but not $x!")
@State
public static class GetVolatile
{
boolean x = false;
Sequencer y = createSequencer();
@Actor
public void actor1()
{
x = true;
y.publish(1);
}
@Actor
public void actor2(final ZZ_Result r)
{
r.r1 = y.isAvailable(1);
r.r2 = x;
}
}
/**
* In absence of synchronization, the order of independent reads is undefined.
* In our case, the read of isAvailable is volatile which mandates the writes to the same
* variable to be observed in a total order (that implies that _observers_ are also ordered)
*/
@JCStressTest
@Outcome(id = "false, false", expect = ACCEPTABLE, desc = "Doing both reads early.")
@Outcome(id = "true, true", expect = ACCEPTABLE, desc = "Doing both reads late.")
@Outcome(id = "false, true", expect = ACCEPTABLE, desc = "Doing first read early, not surprising.")
@Outcome(id = "true, false", expect = FORBIDDEN, desc = "Violates coherence.")
@State
public static class SameVolatileRead
{
private final Holder h1 = new Holder();
private final Holder h2 = h1;
private static class Holder
{
Sequencer sequence = createSequencer();
}
@Actor
public void actor1()
{
h1.sequence.publish(1);
}
@Actor
public void actor2(final ZZ_Result r)
{
Holder h1 = this.h1;
Holder h2 = this.h2;
r.r1 = h1.sequence.isAvailable(1);
r.r2 = h2.sequence.isAvailable(1);
}
}
}
================================================
FILE: src/jcstress/java/com/lmax/disruptor/SequenceStressUnsafe.java
================================================
package com.lmax.disruptor;
import com.lmax.disruptor.alternatives.SequenceUnsafe;
import org.openjdk.jcstress.annotations.Actor;
import org.openjdk.jcstress.annotations.Arbiter;
import org.openjdk.jcstress.annotations.JCStressTest;
import org.openjdk.jcstress.annotations.Outcome;
import org.openjdk.jcstress.annotations.Ref;
import org.openjdk.jcstress.annotations.State;
import org.openjdk.jcstress.infra.results.JJ_Result;
import org.openjdk.jcstress.infra.results.J_Result;
import org.openjdk.jcstress.infra.results.ZZJ_Result;
import static org.openjdk.jcstress.annotations.Expect.ACCEPTABLE;
import static org.openjdk.jcstress.annotations.Expect.ACCEPTABLE_INTERESTING;
import static org.openjdk.jcstress.annotations.Expect.FORBIDDEN;
public class SequenceStressUnsafe
{
/**
* `SequenceUnsafe::incrementAndGet` is atomic and should never lose an update, even with multiple threads racing.
*/
@JCStressTest
@Outcome(id = "1", expect = FORBIDDEN, desc = "One update lost.")
@Outcome(id = "2", expect = ACCEPTABLE, desc = "Both updates.")
@State
public static class IncrementAndGet
{
SequenceUnsafe sequence = new SequenceUnsafe(0);
@Actor
public void actor1()
{
sequence.incrementAndGet();
}
@Actor
public void actor2()
{
sequence.incrementAndGet();
}
@Arbiter
public void arbiter(final J_Result r)
{
r.r1 = sequence.get();
}
}
/**
* `SequenceUnsafe::compareAndSet` is atomic and should never lose an update, even with multiple threads racing.
*/
@JCStressTest
@Outcome(id = {"true, false, 10", "false, true, 20"}, expect = ACCEPTABLE, desc = "Either updated.")
@Outcome(expect = FORBIDDEN, desc = "Other cases are forbidden.")
@State
public static class CompareAndSet
{
SequenceUnsafe sequence = new SequenceUnsafe(0);
@Actor
public void actor1(final ZZJ_Result r)
{
r.r1 = sequence.compareAndSet(0, 10);
}
@Actor
public void actor2(final ZZJ_Result r)
{
r.r2 = sequence.compareAndSet(0, 20);
}
@Arbiter
public void arbiter(final ZZJ_Result r)
{
r.r3 = sequence.get();
}
}
/**
* `SequenceUnsafe::addAndGet` is atomic and should never lose an update, even with multiple threads racing.
*/
@JCStressTest
@Outcome(id = "10", expect = FORBIDDEN, desc = "One update lost.")
@Outcome(id = "20", expect = FORBIDDEN, desc = "One update lost.")
@Outcome(id = "30", expect = ACCEPTABLE, desc = "Both updates.")
@State
public static class AddAndGet
{
SequenceUnsafe sequence = new SequenceUnsafe(0);
@Actor
public void actor1()
{
sequence.addAndGet(10);
}
@Actor
public void actor2()
{
sequence.addAndGet(20);
}
@Arbiter
public void arbiter(final J_Result r)
{
r.r1 = sequence.get();
}
}
/**
* Updates to non-volatile long values in Java are issued as two separate 32-bit writes.
* SequenceUnsafe should store its underlying value as a volatile long and therefore should not experience this effect
* even when a non-volatile UNSAFE set method is used.
*/
@JCStressTest
@Outcome(id = "0", expect = ACCEPTABLE, desc = "Seeing the default value: writer had not acted yet.")
@Outcome(id = "-1", expect = ACCEPTABLE, desc = "Seeing the full value.")
@Outcome(expect = FORBIDDEN, desc = "Other cases are forbidden.")
@Ref("https://docs.oracle.com/javase/specs/jls/se11/html/jls-17.html#jls-17.7")
@State
public static class LongFullSet
{
SequenceUnsafe sequence = new SequenceUnsafe(0);
@Actor
public void writer()
{
sequence.set(0xFFFFFFFF_FFFFFFFFL);
}
@Actor
public void reader(final J_Result r)
{
r.r1 = sequence.get();
}
}
/**
* Updates to non-volatile long values in Java are issued as two separate 32-bit writes.
* SequenceUnsafe should store its underlying value as a volatile long and therefore should not experience this effect.
*/
@JCStressTest
@Outcome(id = "0", expect = ACCEPTABLE, desc = "Seeing the default value: writer had not acted yet.")
@Outcome(id = "-1", expect = ACCEPTABLE, desc = "Seeing the full value.")
@Outcome(expect = FORBIDDEN, desc = "Other cases are forbidden.")
@Ref("https://docs.oracle.com/javase/specs/jls/se11/html/jls-17.html#jls-17.7")
@State
public static class LongFullSetVolatile
{
SequenceUnsafe sequence = new SequenceUnsafe(0);
@Actor
public void writer()
{
sequence.setVolatile(0xFFFFFFFF_FFFFFFFFL);
}
@Actor
public void reader(final J_Result r)
{
r.r1 = sequence.get();
}
}
/**
* Updates to non-volatile long values in Java are issued as two separate 32-bit writes.
* SequenceUnsafe should store its underlying value as a volatile long and therefore should not experience this effect.
*/
@JCStressTest
@Outcome(id = "0", expect = ACCEPTABLE, desc = "Seeing the default value: writer had not acted yet.")
@Outcome(id = "-1", expect = ACCEPTABLE, desc = "Seeing the full value.")
@Outcome(expect = FORBIDDEN, desc = "Other cases are forbidden.")
@Ref("https://docs.oracle.com/javase/specs/jls/se11/html/jls-17.html#jls-17.7")
@State
public static class LongFullCompareAndSet
{
SequenceUnsafe sequence = new SequenceUnsafe(0);
@Actor
public void writer()
{
sequence.compareAndSet(0, 0xFFFFFFFF_FFFFFFFFL);
}
@Actor
public void reader(final J_Result r)
{
r.r1 = sequence.get();
}
}
/**
* In absence of synchronization, the order of independent reads is undefined.
* In our case, the value in SequenceUnsafe is volatile which mandates the writes to the same
* variable to be observed in a total order (that implies that _observers_ are also ordered)
*/
@JCStressTest
@Outcome(id = "0, 0", expect = ACCEPTABLE, desc = "Doing both reads early.")
@Outcome(id = "1, 1", expect = ACCEPTABLE, desc = "Doing both reads late.")
@Outcome(id = "0, 1", expect = ACCEPTABLE, desc = "Doing first read early, not surprising.")
@Outcome(id = "1, 0", expect = FORBIDDEN, desc = "Violates coherence.")
@State
public static class SameVolatileRead
{
private final Holder h1 = new Holder();
private final Holder h2 = h1;
private static class Holder
{
SequenceUnsafe sequence = new SequenceUnsafe(0);
}
@Actor
public void actor1()
{
h1.sequence.set(1);
}
@Actor
public void actor2(final JJ_Result r)
{
Holder h1 = this.h1;
Holder h2 = this.h2;
r.r1 = h1.sequence.get();
r.r2 = h2.sequence.get();
}
}
/**
* The value field in SequenceUnsafe is volatile so we should never see an update to it without seeing the update to a
* previously set value also.
*
*
If the value was not volatile there would be no ordering rules stopping it being seen updated before the
* other value.
*/
@JCStressTest
@Outcome(id = "0, 0", expect = ACCEPTABLE, desc = "Doing both reads early.")
@Outcome(id = "1, 1", expect = ACCEPTABLE, desc = "Doing both reads late.")
@Outcome(id = "0, 1", expect = ACCEPTABLE, desc = "Caught in the middle: $x is visible, $y is not.")
@Outcome(id = "1, 0", expect = FORBIDDEN, desc = "Seeing $y, but not $x!")
@State
public static class SetVolatileGuard
{
long x = 0;
SequenceUnsafe y = new SequenceUnsafe(0);
@Actor
public void actor1()
{
x = 1;
y.setVolatile(1);
}
@Actor
public void actor2(final JJ_Result r)
{
r.r1 = y.get();
r.r2 = x;
}
}
/**
* The value field in SequenceUnsafe is volatile so we should never see an update to it without seeing the update to a
* previously set value also.
*
*
If the value was not volatile there would be no ordering rules stopping it being seen updated before the
* other value.
*
*
This is a property of the field, not a property of the method used to set the value of it.
*/
@JCStressTest
@Outcome(id = "0, 0", expect = ACCEPTABLE, desc = "Doing both reads early.")
@Outcome(id = "1, 1", expect = ACCEPTABLE, desc = "Doing both reads late.")
@Outcome(id = "0, 1", expect = ACCEPTABLE, desc = "Caught in the middle: $x is visible, $y is not.")
@Outcome(id = "1, 0", expect = FORBIDDEN, desc = "Seeing $y, but not $x!")
@State
public static class SetGuard
{
long x = 0;
SequenceUnsafe y = new SequenceUnsafe(0);
@Actor
public void actor1()
{
x = 1;
y.set(1);
}
@Actor
public void actor2(final JJ_Result r)
{
r.r1 = y.get();
r.r2 = x;
}
}
/**
* Volatile setting will experience total ordering.
*/
@JCStressTest
@Outcome(id = {"0, 1", "1, 0", "1, 1"}, expect = ACCEPTABLE, desc = "Trivial under sequential consistency")
@Outcome(id = "0, 0", expect = FORBIDDEN, desc = "Violates sequential consistency")
@State
public static class SetVolatileDekker
{
SequenceUnsafe x = new SequenceUnsafe(0);
SequenceUnsafe y = new SequenceUnsafe(0);
@Actor
public void actor1(final JJ_Result r)
{
x.setVolatile(1);
r.r1 = y.get();
}
@Actor
public void actor2(final JJ_Result r)
{
y.setVolatile(1);
r.r2 = x.get();
}
}
/**
* Non-volatile setting will not experience total ordering, those gets can be re-ordered and happen before either set.
*/
@JCStressTest
@Outcome(id = {"0, 1", "1, 0", "1, 1"}, expect = ACCEPTABLE, desc = "Trivial under sequential consistency")
@Outcome(id = "0, 0", expect = ACCEPTABLE_INTERESTING, desc = "Violates sequential consistency")
@State
public static class SetDekker
{
SequenceUnsafe x = new SequenceUnsafe(0);
SequenceUnsafe y = new SequenceUnsafe(0);
@Actor
public void actor1(final JJ_Result r)
{
x.set(1);
r.r1 = y.get();
}
@Actor
public void actor2(final JJ_Result r)
{
y.set(1);
r.r2 = x.get();
}
}
}
================================================
FILE: src/jcstress/java/com/lmax/disruptor/SequenceStressVarHandle.java
================================================
package com.lmax.disruptor;
import com.lmax.disruptor.alternatives.SequenceVarHandle;
import org.openjdk.jcstress.annotations.Actor;
import org.openjdk.jcstress.annotations.Arbiter;
import org.openjdk.jcstress.annotations.JCStressTest;
import org.openjdk.jcstress.annotations.Outcome;
import org.openjdk.jcstress.annotations.Ref;
import org.openjdk.jcstress.annotations.State;
import org.openjdk.jcstress.infra.results.JJ_Result;
import org.openjdk.jcstress.infra.results.J_Result;
import org.openjdk.jcstress.infra.results.ZZJ_Result;
import static org.openjdk.jcstress.annotations.Expect.ACCEPTABLE;
import static org.openjdk.jcstress.annotations.Expect.ACCEPTABLE_INTERESTING;
import static org.openjdk.jcstress.annotations.Expect.FORBIDDEN;
public class SequenceStressVarHandle
{
/**
* `SequenceVarHandle::incrementAndGet` is atomic and should never lose an update, even with multiple threads racing.
*/
@JCStressTest
@Outcome(id = "1", expect = FORBIDDEN, desc = "One update lost.")
@Outcome(id = "2", expect = ACCEPTABLE, desc = "Both updates.")
@State
public static class IncrementAndGet
{
SequenceVarHandle sequence = new SequenceVarHandle(0);
@Actor
public void actor1()
{
sequence.incrementAndGet();
}
@Actor
public void actor2()
{
sequence.incrementAndGet();
}
@Arbiter
public void arbiter(final J_Result r)
{
r.r1 = sequence.get();
}
}
/**
* `SequenceVarHandle::compareAndSet` is atomic and should never lose an update, even with multiple threads racing.
*/
@JCStressTest
@Outcome(id = {"true, false, 10", "false, true, 20"}, expect = ACCEPTABLE, desc = "Either updated.")
@Outcome(expect = FORBIDDEN, desc = "Other cases are forbidden.")
@State
public static class CompareAndSet
{
SequenceVarHandle sequence = new SequenceVarHandle(0);
@Actor
public void actor1(final ZZJ_Result r)
{
r.r1 = sequence.compareAndSet(0, 10);
}
@Actor
public void actor2(final ZZJ_Result r)
{
r.r2 = sequence.compareAndSet(0, 20);
}
@Arbiter
public void arbiter(final ZZJ_Result r)
{
r.r3 = sequence.get();
}
}
/**
* `SequenceVarHandle::addAndGet` is atomic and should never lose an update, even with multiple threads racing.
*/
@JCStressTest
@Outcome(id = "10", expect = FORBIDDEN, desc = "One update lost.")
@Outcome(id = "20", expect = FORBIDDEN, desc = "One update lost.")
@Outcome(id = "30", expect = ACCEPTABLE, desc = "Both updates.")
@State
public static class AddAndGet
{
SequenceVarHandle sequence = new SequenceVarHandle(0);
@Actor
public void actor1()
{
sequence.addAndGet(10);
}
@Actor
public void actor2()
{
sequence.addAndGet(20);
}
@Arbiter
public void arbiter(final J_Result r)
{
r.r1 = sequence.get();
}
}
/**
* Updates to non-volatile long values in Java are issued as two separate 32-bit writes.
* SequenceVarHandle should store its underlying value as a volatile long and therefore should not experience this effect
* even when a non-volatile UNSAFE set method is used.
*/
@JCStressTest
@Outcome(id = "0", expect = ACCEPTABLE, desc = "Seeing the default value: writer had not acted yet.")
@Outcome(id = "-1", expect = ACCEPTABLE, desc = "Seeing the full value.")
@Outcome(expect = FORBIDDEN, desc = "Other cases are forbidden.")
@Ref("https://docs.oracle.com/javase/specs/jls/se11/html/jls-17.html#jls-17.7")
@State
public static class LongFullSet
{
SequenceVarHandle sequence = new SequenceVarHandle(0);
@Actor
public void writer()
{
sequence.set(0xFFFFFFFF_FFFFFFFFL);
}
@Actor
public void reader(final J_Result r)
{
r.r1 = sequence.get();
}
}
/**
* Updates to non-volatile long values in Java are issued as two separate 32-bit writes.
* SequenceVarHandle should store its underlying value as a volatile long and therefore should not experience this effect.
*/
@JCStressTest
@Outcome(id = "0", expect = ACCEPTABLE, desc = "Seeing the default value: writer had not acted yet.")
@Outcome(id = "-1", expect = ACCEPTABLE, desc = "Seeing the full value.")
@Outcome(expect = FORBIDDEN, desc = "Other cases are forbidden.")
@Ref("https://docs.oracle.com/javase/specs/jls/se11/html/jls-17.html#jls-17.7")
@State
public static class LongFullSetVolatile
{
SequenceVarHandle sequence = new SequenceVarHandle(0);
@Actor
public void writer()
{
sequence.setVolatile(0xFFFFFFFF_FFFFFFFFL);
}
@Actor
public void reader(final J_Result r)
{
r.r1 = sequence.get();
}
}
/**
* Updates to non-volatile long values in Java are issued as two separate 32-bit writes.
* SequenceVarHandle should store its underlying value as a volatile long and therefore should not experience this effect.
*/
@JCStressTest
@Outcome(id = "0", expect = ACCEPTABLE, desc = "Seeing the default value: writer had not acted yet.")
@Outcome(id = "-1", expect = ACCEPTABLE, desc = "Seeing the full value.")
@Outcome(expect = FORBIDDEN, desc = "Other cases are forbidden.")
@Ref("https://docs.oracle.com/javase/specs/jls/se11/html/jls-17.html#jls-17.7")
@State
public static class LongFullCompareAndSet
{
SequenceVarHandle sequence = new SequenceVarHandle(0);
@Actor
public void writer()
{
sequence.compareAndSet(0, 0xFFFFFFFF_FFFFFFFFL);
}
@Actor
public void reader(final J_Result r)
{
r.r1 = sequence.get();
}
}
/**
* In absence of synchronization, the order of independent reads is undefined.
* In our case, the value in SequenceVarHandle is volatile which mandates the writes to the same
* variable to be observed in a total order (that implies that _observers_ are also ordered)
*/
@JCStressTest
@Outcome(id = "0, 0", expect = ACCEPTABLE, desc = "Doing both reads early.")
@Outcome(id = "1, 1", expect = ACCEPTABLE, desc = "Doing both reads late.")
@Outcome(id = "0, 1", expect = ACCEPTABLE, desc = "Doing first read early, not surprising.")
@Outcome(id = "1, 0", expect = FORBIDDEN, desc = "Violates coherence.")
@State
public static class SameVolatileRead
{
private final Holder h1 = new Holder();
private final Holder h2 = h1;
private static class Holder
{
SequenceVarHandle sequence = new SequenceVarHandle(0);
}
@Actor
public void actor1()
{
h1.sequence.set(1);
}
@Actor
public void actor2(final JJ_Result r)
{
Holder h1 = this.h1;
Holder h2 = this.h2;
r.r1 = h1.sequence.get();
r.r2 = h2.sequence.get();
}
}
/**
* The value field in SequenceVarHandle is volatile so we should never see an update to it without seeing the update to a
* previously set value also.
*
*
If the value was not volatile there would be no ordering rules stopping it being seen updated before the
* other value.
*/
@JCStressTest
@Outcome(id = "0, 0", expect = ACCEPTABLE, desc = "Doing both reads early.")
@Outcome(id = "1, 1", expect = ACCEPTABLE, desc = "Doing both reads late.")
@Outcome(id = "0, 1", expect = ACCEPTABLE, desc = "Caught in the middle: $x is visible, $y is not.")
@Outcome(id = "1, 0", expect = FORBIDDEN, desc = "Seeing $y, but not $x!")
@State
public static class SetVolatileGuard
{
long x = 0;
SequenceVarHandle y = new SequenceVarHandle(0);
@Actor
public void actor1()
{
x = 1;
y.setVolatile(1);
}
@Actor
public void actor2(final JJ_Result r)
{
r.r1 = y.get();
r.r2 = x;
}
}
/**
* The value field in SequenceVarHandle is volatile so we should never see an update to it without seeing the update to a
* previously set value also.
*
*
If the value was not volatile there would be no ordering rules stopping it being seen updated before the
* other value.
*
*
This is a property of the field, not a property of the method used to set the value of it.
*/
@JCStressTest
@Outcome(id = "0, 0", expect = ACCEPTABLE, desc = "Doing both reads early.")
@Outcome(id = "1, 1", expect = ACCEPTABLE, desc = "Doing both reads late.")
@Outcome(id = "0, 1", expect = ACCEPTABLE, desc = "Caught in the middle: $x is visible, $y is not.")
@Outcome(id = "1, 0", expect = FORBIDDEN, desc = "Seeing $y, but not $x!")
@State
public static class SetGuard
{
long x = 0;
SequenceVarHandle y = new SequenceVarHandle(0);
@Actor
public void actor1()
{
x = 1;
y.set(1);
}
@Actor
public void actor2(final JJ_Result r)
{
r.r1 = y.get();
r.r2 = x;
}
}
/**
* Volatile setting will experience total ordering.
*/
@JCStressTest
@Outcome(id = {"0, 1", "1, 0", "1, 1"}, expect = ACCEPTABLE, desc = "Trivial under sequential consistency")
@Outcome(id = "0, 0", expect = FORBIDDEN, desc = "Violates sequential consistency")
@State
public static class SetVolatileDekker
{
SequenceVarHandle x = new SequenceVarHandle(0);
SequenceVarHandle y = new SequenceVarHandle(0);
@Actor
public void actor1(final JJ_Result r)
{
x.setVolatile(1);
r.r1 = y.get();
}
@Actor
public void actor2(final JJ_Result r)
{
y.setVolatile(1);
r.r2 = x.get();
}
}
/**
* Non-volatile setting will not experience total ordering, those gets can be re-ordered and happen before either set.
*/
@JCStressTest
@Outcome(id = {"0, 1", "1, 0", "1, 1"}, expect = ACCEPTABLE, desc = "Trivial under sequential consistency")
@Outcome(id = "0, 0", expect = ACCEPTABLE_INTERESTING, desc = "Violates sequential consistency")
@State
public static class SetDekker
{
SequenceVarHandle x = new SequenceVarHandle(0);
SequenceVarHandle y = new SequenceVarHandle(0);
@Actor
public void actor1(final JJ_Result r)
{
x.set(1);
r.r1 = y.get();
}
@Actor
public void actor2(final JJ_Result r)
{
y.set(1);
r.r2 = x.get();
}
}
}
================================================
FILE: src/jcstress/java/com/lmax/disruptor/SequenceStressVarHandleBarrier.java
================================================
package com.lmax.disruptor;
import com.lmax.disruptor.alternatives.SequenceVarHandleBarrier;
import org.openjdk.jcstress.annotations.Actor;
import org.openjdk.jcstress.annotations.Arbiter;
import org.openjdk.jcstress.annotations.JCStressTest;
import org.openjdk.jcstress.annotations.Outcome;
import org.openjdk.jcstress.annotations.Ref;
import org.openjdk.jcstress.annotations.State;
import org.openjdk.jcstress.infra.results.JJ_Result;
import org.openjdk.jcstress.infra.results.J_Result;
import org.openjdk.jcstress.infra.results.ZZJ_Result;
import static org.openjdk.jcstress.annotations.Expect.ACCEPTABLE;
import static org.openjdk.jcstress.annotations.Expect.ACCEPTABLE_INTERESTING;
import static org.openjdk.jcstress.annotations.Expect.FORBIDDEN;
public class SequenceStressVarHandleBarrier
{
/**
* `com.lmax.disruptor.alternatives.SequenceVarHandleBarrier::incrementAndGet` is atomic and should never lose an update, even with multiple threads racing.
*/
@JCStressTest
@Outcome(id = "1", expect = FORBIDDEN, desc = "One update lost.")
@Outcome(id = "2", expect = ACCEPTABLE, desc = "Both updates.")
@State
public static class IncrementAndGet
{
SequenceVarHandleBarrier sequence = new SequenceVarHandleBarrier(0);
@Actor
public void actor1()
{
sequence.incrementAndGet();
}
@Actor
public void actor2()
{
sequence.incrementAndGet();
}
@Arbiter
public void arbiter(final J_Result r)
{
r.r1 = sequence.get();
}
}
/**
* `SequenceVarHandleBarrier::compareAndSet` is atomic and should never lose an update, even with multiple threads racing.
*/
@JCStressTest
@Outcome(id = {"true, false, 10", "false, true, 20"}, expect = ACCEPTABLE, desc = "Either updated.")
@Outcome(expect = FORBIDDEN, desc = "Other cases are forbidden.")
@State
public static class CompareAndSet
{
SequenceVarHandleBarrier sequence = new SequenceVarHandleBarrier(0);
@Actor
public void actor1(final ZZJ_Result r)
{
r.r1 = sequence.compareAndSet(0, 10);
}
@Actor
public void actor2(final ZZJ_Result r)
{
r.r2 = sequence.compareAndSet(0, 20);
}
@Arbiter
public void arbiter(final ZZJ_Result r)
{
r.r3 = sequence.get();
}
}
/**
* `SequenceVarHandleBarrier::addAndGet` is atomic and should never lose an update, even with multiple threads racing.
*/
@JCStressTest
@Outcome(id = "10", expect = FORBIDDEN, desc = "One update lost.")
@Outcome(id = "20", expect = FORBIDDEN, desc = "One update lost.")
@Outcome(id = "30", expect = ACCEPTABLE, desc = "Both updates.")
@State
public static class AddAndGet
{
SequenceVarHandleBarrier sequence = new SequenceVarHandleBarrier(0);
@Actor
public void actor1()
{
sequence.addAndGet(10);
}
@Actor
public void actor2()
{
sequence.addAndGet(20);
}
@Arbiter
public void arbiter(final J_Result r)
{
r.r1 = sequence.get();
}
}
/**
* Updates to non-volatile long values in Java are issued as two separate 32-bit writes.
* SequenceVarHandleBarrier should store its underlying value as a volatile long and therefore should not experience this effect
* even when a non-volatile UNSAFE set method is used.
*/
@JCStressTest
@Outcome(id = "0", expect = ACCEPTABLE, desc = "Seeing the default value: writer had not acted yet.")
@Outcome(id = "-1", expect = ACCEPTABLE, desc = "Seeing the full value.")
@Outcome(expect = FORBIDDEN, desc = "Other cases are forbidden.")
@Ref("https://docs.oracle.com/javase/specs/jls/se11/html/jls-17.html#jls-17.7")
@State
public static class LongFullSet
{
SequenceVarHandleBarrier sequence = new SequenceVarHandleBarrier(0);
@Actor
public void writer()
{
sequence.set(0xFFFFFFFF_FFFFFFFFL);
}
@Actor
public void reader(final J_Result r)
{
r.r1 = sequence.get();
}
}
/**
* Updates to non-volatile long values in Java are issued as two separate 32-bit writes.
* SequenceVarHandleBarrier should store its underlying value as a volatile long and therefore should not experience this effect.
*/
@JCStressTest
@Outcome(id = "0", expect = ACCEPTABLE, desc = "Seeing the default value: writer had not acted yet.")
@Outcome(id = "-1", expect = ACCEPTABLE, desc = "Seeing the full value.")
@Outcome(expect = FORBIDDEN, desc = "Other cases are forbidden.")
@Ref("https://docs.oracle.com/javase/specs/jls/se11/html/jls-17.html#jls-17.7")
@State
public static class LongFullSetVolatile
{
SequenceVarHandleBarrier sequence = new SequenceVarHandleBarrier(0);
@Actor
public void writer()
{
sequence.setVolatile(0xFFFFFFFF_FFFFFFFFL);
}
@Actor
public void reader(final J_Result r)
{
r.r1 = sequence.get();
}
}
/**
* Updates to non-volatile long values in Java are issued as two separate 32-bit writes.
* SequenceVarHandleBarrier should store its underlying value as a volatile long and therefore should not experience this effect.
*/
@JCStressTest
@Outcome(id = "0", expect = ACCEPTABLE, desc = "Seeing the default value: writer had not acted yet.")
@Outcome(id = "-1", expect = ACCEPTABLE, desc = "Seeing the full value.")
@Outcome(expect = FORBIDDEN, desc = "Other cases are forbidden.")
@Ref("https://docs.oracle.com/javase/specs/jls/se11/html/jls-17.html#jls-17.7")
@State
public static class LongFullCompareAndSet
{
SequenceVarHandleBarrier sequence = new SequenceVarHandleBarrier(0);
@Actor
public void writer()
{
sequence.compareAndSet(0, 0xFFFFFFFF_FFFFFFFFL);
}
@Actor
public void reader(final J_Result r)
{
r.r1 = sequence.get();
}
}
/**
* In absence of synchronization, the order of independent reads is undefined.
* In our case, the value in SequenceVarHandleBarrier is volatile which mandates the writes to the same
* variable to be observed in a total order (that implies that _observers_ are also ordered)
*/
@JCStressTest
@Outcome(id = "0, 0", expect = ACCEPTABLE, desc = "Doing both reads early.")
@Outcome(id = "1, 1", expect = ACCEPTABLE, desc = "Doing both reads late.")
@Outcome(id = "0, 1", expect = ACCEPTABLE, desc = "Doing first read early, not surprising.")
@Outcome(id = "1, 0", expect = FORBIDDEN, desc = "Violates coherence.")
@State
public static class SameVolatileRead
{
private final Holder h1 = new Holder();
private final Holder h2 = h1;
private static class Holder
{
SequenceVarHandleBarrier sequence = new SequenceVarHandleBarrier(0);
}
@Actor
public void actor1()
{
h1.sequence.set(1);
}
@Actor
public void actor2(final JJ_Result r)
{
Holder h1 = this.h1;
Holder h2 = this.h2;
r.r1 = h1.sequence.get();
r.r2 = h2.sequence.get();
}
}
/**
* The value field in SequenceVarHandleBarrier is volatile so we should never see an update to it without seeing the update to a
* previously set value also.
*
*
If the value was not volatile there would be no ordering rules stopping it being seen updated before the
* other value.
*/
@JCStressTest
@Outcome(id = "0, 0", expect = ACCEPTABLE, desc = "Doing both reads early.")
@Outcome(id = "1, 1", expect = ACCEPTABLE, desc = "Doing both reads late.")
@Outcome(id = "0, 1", expect = ACCEPTABLE, desc = "Caught in the middle: $x is visible, $y is not.")
@Outcome(id = "1, 0", expect = FORBIDDEN, desc = "Seeing $y, but not $x!")
@State
public static class SetVolatileGuard
{
long x = 0;
SequenceVarHandleBarrier y = new SequenceVarHandleBarrier(0);
@Actor
public void actor1()
{
x = 1;
y.setVolatile(1);
}
@Actor
public void actor2(final JJ_Result r)
{
r.r1 = y.get();
r.r2 = x;
}
}
/**
* The value field in SequenceVarHandleBarrier is volatile so we should never see an update to it without seeing the update to a
* previously set value also.
*
*
If the value was not volatile there would be no ordering rules stopping it being seen updated before the
* other value.
*
*
This is a property of the field, not a property of the method used to set the value of it.
*/
@JCStressTest
@Outcome(id = "0, 0", expect = ACCEPTABLE, desc = "Doing both reads early.")
@Outcome(id = "1, 1", expect = ACCEPTABLE, desc = "Doing both reads late.")
@Outcome(id = "0, 1", expect = ACCEPTABLE, desc = "Caught in the middle: $x is visible, $y is not.")
@Outcome(id = "1, 0", expect = FORBIDDEN, desc = "Seeing $y, but not $x!")
@State
public static class SetGuard
{
long x = 0;
SequenceVarHandleBarrier y = new SequenceVarHandleBarrier(0);
@Actor
public void actor1()
{
x = 1;
y.set(1);
}
@Actor
public void actor2(final JJ_Result r)
{
r.r1 = y.get();
r.r2 = x;
}
}
/**
* Volatile setting will experience total ordering.
*/
@JCStressTest
@Outcome(id = {"0, 1", "1, 0", "1, 1"}, expect = ACCEPTABLE, desc = "Trivial under sequential consistency")
@Outcome(id = "0, 0", expect = FORBIDDEN, desc = "Violates sequential consistency")
@State
public static class SetVolatileDekker
{
SequenceVarHandleBarrier x = new SequenceVarHandleBarrier(0);
SequenceVarHandleBarrier y = new SequenceVarHandleBarrier(0);
@Actor
public void actor1(final JJ_Result r)
{
x.setVolatile(1);
r.r1 = y.get();
}
@Actor
public void actor2(final JJ_Result r)
{
y.setVolatile(1);
r.r2 = x.get();
}
}
/**
* Non-volatile setting will not experience total ordering, those gets can be re-ordered and happen before either set.
*/
@JCStressTest
@Outcome(id = {"0, 1", "1, 0", "1, 1"}, expect = ACCEPTABLE, desc = "Trivial under sequential consistency")
@Outcome(id = "0, 0", expect = ACCEPTABLE_INTERESTING, desc = "Violates sequential consistency")
@State
public static class SetDekker
{
SequenceVarHandleBarrier x = new SequenceVarHandleBarrier(0);
SequenceVarHandleBarrier y = new SequenceVarHandleBarrier(0);
@Actor
public void actor1(final JJ_Result r)
{
x.set(1);
r.r1 = y.get();
}
@Actor
public void actor2(final JJ_Result r)
{
y.set(1);
r.r2 = x.get();
}
}
}
================================================
FILE: src/jmh/java/com/lmax/disruptor/ArrayAccessBenchmark.java
================================================
package com.lmax.disruptor;
import com.lmax.disruptor.util.SimpleEvent;
import com.lmax.disruptor.util.UnsafeAccess;
import net.openhft.affinity.Affinity;
import net.openhft.affinity.AffinityLock;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Fork;
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.TearDown;
import org.openjdk.jmh.annotations.Threads;
import org.openjdk.jmh.annotations.Warmup;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import sun.misc.Unsafe;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;
import static java.util.function.Predicate.not;
@SuppressWarnings("unused")
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@Warmup(iterations = 5, time = 1)
@Measurement(iterations = 5, time = 1)
@Fork(2)
@Threads(1)
@State(Scope.Thread)
public class ArrayAccessBenchmark
{
// To run this on a tuned system with benchmark threads pinned to isolated cpus:
// Run the JMH process with an env var defining the isolated cpu list, e.g. ISOLATED_CPUS=38,40,42,44,46,48 java -jar disruptor-jmh.jar
private static final List ISOLATED_CPUS = Arrays.stream(System.getenv().getOrDefault("ISOLATED_CPUS", "").split(","))
.map(String::trim)
.filter(not(String::isBlank))
.map(Integer::valueOf)
.collect(Collectors.toList());
private static final AtomicInteger THREAD_COUNTER = new AtomicInteger();
@State(Scope.Thread)
public static class ThreadPinningState
{
int threadId = THREAD_COUNTER.getAndIncrement();
private AffinityLock affinityLock;
@Setup
public void setup()
{
if (ISOLATED_CPUS.size() > 0)
{
if (threadId > ISOLATED_CPUS.size())
{
throw new IllegalArgumentException(
String.format("Benchmark uses at least %d threads, only defined %d isolated cpus",
threadId,
ISOLATED_CPUS.size()
));
}
final Integer cpuId = ISOLATED_CPUS.get(threadId);
affinityLock = AffinityLock.acquireLock(cpuId);
System.out.printf("Attempted to set thread affinity for %s to %d, success = %b%n",
Thread.currentThread().getName(),
cpuId,
affinityLock.isAllocated()
);
}
else
{
System.err.printf("ISOLATED_CPUS environment variable not defined, running thread %s (id=%d) on scheduler-defined CPU:%d%n ",
Thread.currentThread().getName(),
threadId,
Affinity.getCpu());
}
}
@TearDown
public void teardown()
{
if (ISOLATED_CPUS.size() > 0)
{
affinityLock.release();
}
}
}
private static final int EVENT_COUNT = 64;
private static final int INDEX_MASK = EVENT_COUNT - 1;
private final Object[] entries = new Object[EVENT_COUNT];
public int sequence;
private static final Unsafe UNSAFE = UnsafeAccess.getUnsafe();
private final int scale = UNSAFE.arrayIndexScale(Object[].class);
private final int offset = UNSAFE.arrayBaseOffset(Object[].class);
private final VarHandle varHandle = MethodHandles.arrayElementVarHandle(Object[].class);
private final MethodHandle methodHandle = MethodHandles.arrayElementGetter(Object[].class);
@Setup
public void setup()
{
for (int i = 0; i < EVENT_COUNT; i++)
{
SimpleEvent simpleEvent = new SimpleEvent();
simpleEvent.setValue(i);
entries[i] = simpleEvent;
}
sequence = 0;
}
@Benchmark
public Object standardArrayAccess(final ThreadPinningState t)
{
return entries[getNextSequence()];
}
@Benchmark
public Object unsafeArrayAccess(final ThreadPinningState t)
{
return UNSAFE.getObject(entries, offset + ((long) (getNextSequence()) * scale));
}
@Benchmark
public Object varHandleArrayAccess(final ThreadPinningState t)
{
return varHandle.get(entries, getNextSequence());
}
@Benchmark
public Object getterMethodHandleInvokeArrayAccess(final ThreadPinningState t) throws Throwable
{
return methodHandle.invoke(entries, getNextSequence());
}
@Benchmark
public Object getterMethodHandleInvokeExactArrayAccess(final ThreadPinningState t) throws Throwable
{
return methodHandle.invokeExact(entries, getNextSequence());
}
private int getNextSequence()
{
return sequence++ & INDEX_MASK;
}
public static void main(final String[] args) throws RunnerException
{
Options opt = new OptionsBuilder()
.include(ArrayAccessBenchmark.class.getSimpleName())
.build();
new Runner(opt).run();
}
}
================================================
FILE: src/jmh/java/com/lmax/disruptor/BlockingQueueBenchmark.java
================================================
package com.lmax.disruptor;
import com.lmax.disruptor.util.Constants;
import com.lmax.disruptor.util.DaemonThreadFactory;
import com.lmax.disruptor.util.SimpleEvent;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Fork;
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.TearDown;
import org.openjdk.jmh.infra.Blackhole;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@State(Scope.Thread)
@Fork(1)
public class BlockingQueueBenchmark
{
private BlockingQueue arrayBlockingQueue;
private volatile boolean consumerRunning;
private SimpleEvent simpleEvent;
@Setup
public void setup(final Blackhole bh) throws InterruptedException
{
arrayBlockingQueue = new ArrayBlockingQueue<>(Constants.RINGBUFFER_SIZE);
final CountDownLatch consumerStartedLatch = new CountDownLatch(1);
final Thread eventHandler = DaemonThreadFactory.INSTANCE.newThread(() ->
{
consumerStartedLatch.countDown();
while (consumerRunning)
{
SimpleEvent event = arrayBlockingQueue.poll();
if (event != null)
{
bh.consume(event);
}
}
});
consumerRunning = true;
eventHandler.start();
consumerStartedLatch.await();
simpleEvent = new SimpleEvent();
simpleEvent.setValue(0);
}
@Benchmark
public void producing() throws InterruptedException
{
if (!arrayBlockingQueue.offer(simpleEvent, 1, TimeUnit.SECONDS))
{
throw new IllegalStateException("Queue full, benchmark should not experience backpressure");
}
}
@TearDown
public void tearDown()
{
consumerRunning = false;
}
public static void main(final String[] args) throws RunnerException
{
Options opt = new OptionsBuilder()
.include(BlockingQueueBenchmark.class.getSimpleName())
.forks(1)
.build();
new Runner(opt).run();
}
}
================================================
FILE: src/jmh/java/com/lmax/disruptor/MultiProducerSequencerBenchmark.java
================================================
package com.lmax.disruptor;
import com.lmax.disruptor.alternatives.MultiProducerSequencerUnsafe;
import com.lmax.disruptor.alternatives.MultiProducerSequencerVarHandle;
import net.openhft.affinity.Affinity;
import net.openhft.affinity.AffinityLock;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Fork;
import org.openjdk.jmh.annotations.Group;
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.TearDown;
import org.openjdk.jmh.annotations.Threads;
import org.openjdk.jmh.annotations.Warmup;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;
import static java.util.function.Predicate.not;
@SuppressWarnings("unused")
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@Warmup(iterations = 5, time = 1)
@Measurement(iterations = 5, time = 1)
@Fork(2)
@Threads(1)
public class MultiProducerSequencerBenchmark
{
// To run this on a tuned system with benchmark threads pinned to isolated cpus:
// Run the JMH process with an env var defining the isolated cpu list, e.g. ISOLATED_CPUS=38,40,42,44,46,48 java -jar disruptor-jmh.jar
private static final List ISOLATED_CPUS = Arrays.stream(System.getenv().getOrDefault("ISOLATED_CPUS", "").split(","))
.map(String::trim)
.filter(not(String::isBlank))
.map(Integer::valueOf)
.collect(Collectors.toList());
private static final AtomicInteger THREAD_COUNTER = new AtomicInteger();
@State(Scope.Thread)
public static class ThreadPinningState
{
int threadId = THREAD_COUNTER.getAndIncrement();
private AffinityLock affinityLock;
@Setup
public void setup()
{
if (ISOLATED_CPUS.size() > 0)
{
if (threadId > ISOLATED_CPUS.size())
{
throw new IllegalArgumentException(
String.format("Benchmark uses at least %d threads, only defined %d isolated cpus",
threadId,
ISOLATED_CPUS.size()
));
}
final Integer cpuId = ISOLATED_CPUS.get(threadId);
affinityLock = AffinityLock.acquireLock(cpuId);
System.out.printf("Attempted to set thread affinity for %s to %d, success = %b%n",
Thread.currentThread().getName(),
cpuId,
affinityLock.isAllocated()
);
}
else
{
System.err.printf("ISOLATED_CPUS environment variable not defined, running thread %s (id=%d) on scheduler-defined CPU:%d%n ",
Thread.currentThread().getName(),
threadId,
Affinity.getCpu());
}
}
@TearDown
public void teardown()
{
if (ISOLATED_CPUS.size() > 0)
{
affinityLock.release();
}
}
}
/*
* com.lmax.disruptor.alternatives.MultiProducerSequencerUnsafe (as of disruptor v3.4.2)
*/
@State(Scope.Group)
public static class StateMultiProducerSequencerUnsafe
{
Sequencer value1 = new MultiProducerSequencerUnsafe(64, new BlockingWaitStrategy());
Sequencer value2 = new MultiProducerSequencerUnsafe(64, new BlockingWaitStrategy());
}
@Benchmark
@Group("SequenceUnsafe")
public boolean read1(final StateMultiProducerSequencerUnsafe s, final ThreadPinningState t)
{
return s.value1.isAvailable(1);
}
@Benchmark
@Group("SequenceUnsafe")
public boolean read2(final StateMultiProducerSequencerUnsafe s, final ThreadPinningState t)
{
return s.value1.isAvailable(1);
}
@Benchmark
@Group("SequenceUnsafe")
public void setValue1A(final StateMultiProducerSequencerUnsafe s, final ThreadPinningState t)
{
s.value1.publish(1L);
}
@Benchmark
@Group("SequenceUnsafe")
public void setValue1B(final StateMultiProducerSequencerUnsafe s, final ThreadPinningState t)
{
s.value1.publish(2L);
}
@Benchmark
@Group("SequenceUnsafe")
public void setValue2A(final StateMultiProducerSequencerUnsafe s, final ThreadPinningState t)
{
s.value2.publish(1L);
}
@Benchmark
@Group("SequenceUnsafe")
public void setValue2B(final StateMultiProducerSequencerUnsafe s, final ThreadPinningState t)
{
s.value2.publish(2L);
}
/*
* com.lmax.disruptor.alternatives.StateSequenceVarHandle (as of disruptor v3.4.2)
*/
@State(Scope.Group)
public static class StateMultiProducerSequencerVarHandle
{
Sequencer value1 = new MultiProducerSequencerVarHandle(64, new BlockingWaitStrategy());
Sequencer value2 = new MultiProducerSequencerVarHandle(64, new BlockingWaitStrategy());
}
@Benchmark
@Group("StateMultiProducerSequencerVarHandle")
public boolean read1(final StateMultiProducerSequencerVarHandle s, final ThreadPinningState t)
{
return s.value1.isAvailable(1);
}
@Benchmark
@Group("StateMultiProducerSequencerVarHandle")
public boolean read2(final StateMultiProducerSequencerVarHandle s, final ThreadPinningState t)
{
return s.value1.isAvailable(1);
}
@Benchmark
@Group("StateMultiProducerSequencerVarHandle")
public void setValue1A(final StateMultiProducerSequencerVarHandle s, final ThreadPinningState t)
{
s.value1.publish(1L);
}
@Benchmark
@Group("StateMultiProducerSequencerVarHandle")
public void setValue1B(final StateMultiProducerSequencerVarHandle s, final ThreadPinningState t)
{
s.value1.publish(2L);
}
@Benchmark
@Group("StateMultiProducerSequencerVarHandle")
public void setValue2A(final StateMultiProducerSequencerVarHandle s, final ThreadPinningState t)
{
s.value2.publish(1L);
}
@Benchmark
@Group("StateMultiProducerSequencerVarHandle")
public void setValue2B(final StateMultiProducerSequencerVarHandle s, final ThreadPinningState t)
{
s.value2.publish(2L);
}
public static void main(final String[] args) throws RunnerException
{
Options opt = new OptionsBuilder()
.include(MultiProducerSequencerBenchmark.class.getSimpleName())
.build();
new Runner(opt).run();
}
}
================================================
FILE: src/jmh/java/com/lmax/disruptor/MultiProducerSingleConsumer.java
================================================
package com.lmax.disruptor;
import com.lmax.disruptor.dsl.Disruptor;
import com.lmax.disruptor.dsl.ProducerType;
import com.lmax.disruptor.util.DaemonThreadFactory;
import com.lmax.disruptor.util.SimpleEvent;
import com.lmax.disruptor.util.SimpleEventHandler;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Fork;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OperationsPerInvocation;
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.TearDown;
import org.openjdk.jmh.annotations.Threads;
import org.openjdk.jmh.infra.Blackhole;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import java.util.concurrent.TimeUnit;
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@State(Scope.Benchmark)
@Fork(1)
public class MultiProducerSingleConsumer
{
private RingBuffer ringBuffer;
private Disruptor disruptor;
private static final int BIG_BUFFER = 1 << 22;
private static final int BATCH_SIZE = 100;
@Setup
public void setup(final Blackhole bh)
{
disruptor = new Disruptor<>(SimpleEvent::new,
BIG_BUFFER,
DaemonThreadFactory.INSTANCE,
ProducerType.MULTI,
new BusySpinWaitStrategy());
disruptor.handleEventsWith(new SimpleEventHandler(bh));
ringBuffer = disruptor.start();
}
@Benchmark
@Threads(4)
public void producing()
{
long sequence = ringBuffer.next();
SimpleEvent simpleEvent = ringBuffer.get(sequence);
simpleEvent.setValue(0);
ringBuffer.publish(sequence);
}
@Benchmark
@Threads(4)
@OperationsPerInvocation(BATCH_SIZE)
public void producingBatch()
{
long hi = ringBuffer.next(BATCH_SIZE);
long lo = hi - (BATCH_SIZE - 1);
for (long sequence = lo; sequence <= hi; sequence++)
{
SimpleEvent simpleEvent = ringBuffer.get(sequence);
simpleEvent.setValue(0);
}
ringBuffer.publish(lo, hi);
}
@TearDown
public void tearDown()
{
disruptor.shutdown();
}
public static void main(final String[] args) throws RunnerException
{
Options opt = new OptionsBuilder()
.include(MultiProducerSingleConsumer.class.getSimpleName())
.build();
new Runner(opt).run();
}
}
================================================
FILE: src/jmh/java/com/lmax/disruptor/RingBufferBenchmark.java
================================================
package com.lmax.disruptor;
import com.lmax.disruptor.alternatives.RingBufferArray;
import com.lmax.disruptor.alternatives.RingBufferUnsafe;
import com.lmax.disruptor.support.DummyWaitStrategy;
import com.lmax.disruptor.support.StubEvent;
import net.openhft.affinity.Affinity;
import net.openhft.affinity.AffinityLock;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Fork;
import org.openjdk.jmh.annotations.Group;
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.TearDown;
import org.openjdk.jmh.annotations.Threads;
import org.openjdk.jmh.annotations.Warmup;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;
import static java.util.function.Predicate.not;
@SuppressWarnings("ALL")
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@Warmup(iterations = 5, time = 1)
@Measurement(iterations = 5, time = 1)
@Fork(2)
@Threads(1)
public class RingBufferBenchmark
{
// To run this on a tuned system with benchmark threads pinned to isolated cpus:
// Run the JMH process with an env var defining the isolated cpu list, e.g. ISOLATED_CPUS=38,40,42,44,46,48 java -jar disruptor-jmh.jar
private static final List ISOLATED_CPUS = Arrays.stream(System.getenv().getOrDefault("ISOLATED_CPUS", "").split(","))
.map(String::trim)
.filter(not(String::isBlank))
.map(Integer::valueOf)
.collect(Collectors.toList());
private static final AtomicInteger THREAD_COUNTER = new AtomicInteger();
@State(Scope.Thread)
public static class ThreadPinningState
{
int threadId = THREAD_COUNTER.getAndIncrement();
private AffinityLock affinityLock;
@Setup
public void setup()
{
if (ISOLATED_CPUS.size() > 0)
{
if (threadId > ISOLATED_CPUS.size())
{
throw new IllegalArgumentException(
String.format("Benchmark uses at least %d threads, only defined %d isolated cpus",
threadId,
ISOLATED_CPUS.size()
));
}
final Integer cpuId = ISOLATED_CPUS.get(threadId);
affinityLock = AffinityLock.acquireLock(cpuId);
System.out.printf("Attempted to set thread affinity for %s to %d, success = %b%n",
Thread.currentThread().getName(),
cpuId,
affinityLock.isAllocated()
);
}
else
{
System.err.printf("ISOLATED_CPUS environment variable not defined, running thread %s (id=%d) on scheduler-defined CPU:%d%n ",
Thread.currentThread().getName(),
threadId,
Affinity.getCpu());
}
}
@TearDown
public void teardown()
{
if (ISOLATED_CPUS.size() > 0)
{
affinityLock.release();
}
}
}
/*
* APPROACH 1: RingBufferUnsafe - Using the unsafe API to avoid bounds-checking, as was the case for Disruptor 3.x
*/
@State(Scope.Group)
public static class StateRingBufferUnsafe
{
RingBufferUnsafe