diff --git a/README.md b/README.md new file mode 100644 index 000000000..31660ce6a --- /dev/null +++ b/README.md @@ -0,0 +1,152 @@ +LMAX Disruptor +============== + +A High Performance Inter-Thread Messaging Library + +Maintainer +========== + +Michael Barker + +Changelog +========== + +### 2.10.3 Released (22-Aug-2012) + +- Bug fix, race condition in SequenceGroup when removing Sequences and getting current value + +### 2.10.2 Released (21-Aug-2012) + +- Bug fix, potential race condition in BlockingWaitStrategy. +- Bug fix set initial SequenceGroup value to -1 (Issue #27). +- Deprecate timeout methods that will be removed in version 3. + +### 2.10.1 (6-June-2012) + +- Bug fix, correct OSGI metadata. +- Remove unnecessary code in wait strategies. + +## 2.10 (13-May-2012) + +- Remove deprecated timeout methods. +- Added OSGI metadata to jar file. +- Removed PaddedAtomicLong and use Sequence in all places. +- Fix various generics warnings. +- Change Sequence implementation to work around IBM JDK bug and improve performance by ~10%. +- Add a remainingCapacity() call to the Sequencer class. + +## 2.9 (8-Apr-2012) + +- Deprecate timeout methods for publishing. +- Add tryNext and tryPublishEvent for events that shouldn't block during delivery. +- Small performance enhancement for MultithreadClaimStrategy. + +## 2.8 (6-Feb-2012) + +- Create new MultithreadClaimStrategy that works between when threads are highly contended. Previous implementation is now called MultithreadLowContentionClaimStrategy +- Fix for bug where EventProcessors weren't being added as gating sequences to the ring buffer. +- Fix range tracking bug in Histogram + +### 2.7.1 (21-Dec-2011) + +- Artefacts made available via maven central repository. (groupId:com.googlecode.disruptor, artifactId:disruptor) See UsingDisruptorInYourProject for details. + +## 2.7 (12-Nov-2011) + +- Changed construction API to allow user supplied claim and wait strategies +- Added AggregateEventHandler to support multiple EventHandlers from a single BatchEventProcessor +- Support exception handling from LifecycleAware +- Added timeout API calls for claiming a sequence when publishing +- Use LockSupport.parkNanos() instead of Thread.sleep() to reduce latency +- Reworked performance tests to better support profiling and use LinkedBlockingQueue for comparison because it performs better on the latest processors +- Minor bugfixes + +## 2.6 + +- Introduced WorkerPool to allow the one time consumption of events by a worker in a pool of EventProcessors. +- New internal implementation of SequenceGroup which is lock free at all times and garbage free for get and set operations. +- SequenceBarrier now checks alert status on every call whether it is blocking or not. +- Added scripts in preparation for publishing binaries to maven repository. + +### 2.5.1 + +- Bugfix for supporting SequenceReportingEventHandler from DSL. ([issue 9](https://github.com/LMAX-Exchange/disruptor/issues#issue/9)) +- Bugfix for multi-threaded publishing to multiple ring buffers ([issue 10](https://github.com/LMAX-Exchange/disruptor/issues#issue/10)) +- Change SequenceBarrier to always check alert status before entering waitFor cycle. Previously this was only checked when the requested sequence was not available. +- Change ClaimStrategy to not spin when the buffer has no available capacity, instead go straight to yielding to allow event processors to catch up. + +## 2.5 + +- Changed RingBuffer and publisher API so any mutable object can be placed in the RingBuffer without having to extend AbstractEvent +- Added EventPublisher implementation to allow the publishing steps to be combined into one action +- DisruptorWizard has been renamed to Disruptor with added support for any subtype of EventProcessor +- Introduced a new Sequencer class that allows the Disruptor to be applied to other data structures such as multiple arrays. This can be a very useful pattern when multiple event processors work on the same event and you want to avoid false sharing. The Diamond for FizzBuzz is a good example of the issue. It is also higher performance by avoiding the pointer indirection when arrays of primitives are used. +- Further increased performance and scalability by reducing false sharing. +- Added progressive backoff strategy to the MultiThreadedClaimStrategy to prevent publisher getting into the claim cycle when the buffer is full because of a slow EventProcessor. +- Significantly improved performance to WaitStrategy.Option.BLOCKING +- Introduced SequenceGroup to allow dynamic registration of EventProcessors. + +### 2.0.2 + +- Rework of "False Sharing" prevention which makes the performance much more predictable across all platforms. Special thanks to Jeff Hain for helping focus in on a solution. + +### 2.0.1 + +- Renaming mistake for publishEventAtSequence should have been claimEventAtSequence +- Fixed bug in YieldingStrategy that was busy spinning more than yielding and introduced SleepingStrategy +- Removed code duplication in Unicast perf tests for expected result + +## 2.0.0 + +- New API to reflect naming changes +- Producer -> Publisher +- Entry -> Event +- Consumer -> EventProcessor +- ConsumerBarrier -> DependencyBarrier +- ProducerBarrier has been incorporated into the RingBuffer for ease of use +- DisruptorWizard integrated for fluent API dependency graph construction +- Rework of sequence tracking to avoid false sharing on Java 7, plus avoid mega-morphic calls to make better use of the instruction cache +- Reduced usage of memory barriers where possible +- WaitStrategy.YIELDING initially spins for a short period to reduce latency +- Major performance improvement giving more than a 2X increase for throughput across most use cases. + +### 1.2.2 + +- ProducerBarrier change to yield after busy spinning for a while. This may help the situation when the the number of producers exceeds the number of cores. + +### 1.2.1 + +- Bug fix for setting the sequence in the ForceFillProducerBarrier. +- Code syntax tidy up. + +## 1.2.0 + +- Bug fix for regression introduced inlining multi-thread producer commit tracking code. This was a critical bug for the multi-threaded producer scenario. +- Added new ProducerBarrier method for claiming a batch of sequences. This feature can give a significant throughput increase. + +## 1.1.0 + +- Off by one regression bug in ProducerBarrier introduced in 1.0.9. +- Clarified the algorithm for initial cursor value in the ClaimStrategy. + +### 1.0.9 + +- Added Apache 2.0 licence and comments. +- Small performance improvements to producers barriers and BatchConsumer. + +### 1.0.8 + +- Bugfix for BatchConsumer sequence update when using SequenceTrackingHandler to ensure sequence is always updated at the end of a batch regardless. + +### 1.0.7 + +- Factored out LifecycleAware interface to allowing consumers handlers to be notified when their thread starts and shuts down. + +### 1.0.6 + +- Cache minimum consumer sequence in producer barriers. This helps make the performance more predictable on Nehalem processors and greater on earlier Core 2 processors. + +### 1.0.5 + +- Removed Entry interface. All Entries must now extend AbstractEntry. +- Made setSequence package private on AbstractEntry for encapsulation. \ No newline at end of file