disruptor 1.0.0.beta2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4a35b494617ac7e18df43e17b591458e04387d3e
+  data.tar.gz: a765278e3f12b61f4d441a6b4670c5ca15554d7b
+SHA512:
+  metadata.gz: 5addfcfb1602ef8e119ab131ed412908e367d23bfd7b8e2d08d8998e184076f9514e65c7d579b4a0e489977406b248c34e2b389faa7d409404e1f22870cf1e4c
+  data.tar.gz: de42b8177aa049e903a1d7c2ae35a653dda549d46cc065ad8e536565af733728919ae2a073849b241697661584fe01688aa1511e02def4dc922fc14121d7bae2

data/.gitignore

@@ -0,0 +1,2 @@
+.rbx/
+pkg/

data/.rspec

@@ -0,0 +1,2 @@
+--color
+-f d

data/.rubocop.yml

@@ -0,0 +1,12 @@
+AllCops:
+  Exclude:
+    - 'disruptor.gemspec'
+
+LineLength:
+  Enabled: false
+
+Style/SignalException:
+  Enabled: false
+
+Documentation:
+  Enabled: false

data/.ruby-gemset

@@ -0,0 +1 @@
+disruptor

data/.ruby-version

@@ -0,0 +1 @@
+2.2.0

data/.travis.yml

@@ -0,0 +1,12 @@
+sudo: false
+
+cache: :bundler
+
+language: ruby
+
+rvm:
+  - 2.0.0
+  - 2.1.0
+  - 2.2.0
+  - jruby-1.7.18
+  - rbx-2.5.2

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gem 'rspec'
+gem 'rubocop', platform: :ruby
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,53 @@
+PATH
+  remote: .
+  specs:
+    disruptor (1.0.0.beta2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.0.0)
+    astrolabe (1.3.0)
+      parser (>= 2.2.0.pre.3, < 3.0)
+    concurrent-ruby (0.8.0)
+      ref (~> 1.0, >= 1.0.5)
+    concurrent-ruby (0.8.0-java)
+    diff-lcs (1.2.5)
+    parser (2.2.0.2)
+      ast (>= 1.1, < 3.0)
+    powerpack (0.0.9)
+    rainbow (2.0.0)
+    rake (10.4.2)
+    ref (1.0.5)
+    rspec (3.2.0)
+      rspec-core (~> 3.2.0)
+      rspec-expectations (~> 3.2.0)
+      rspec-mocks (~> 3.2.0)
+    rspec-core (3.2.0)
+      rspec-support (~> 3.2.0)
+    rspec-expectations (3.2.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-mocks (3.2.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-support (3.2.0)
+    rubocop (0.28.0)
+      astrolabe (~> 1.3)
+      parser (>= 2.2.0.pre.7, < 3.0)
+      powerpack (~> 0.0.6)
+      rainbow (>= 1.99.1, < 3.0)
+      ruby-progressbar (~> 1.4)
+    ruby-progressbar (1.7.1)
+
+PLATFORMS
+  java
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.7)
+  concurrent-ruby
+  disruptor!
+  rake (~> 10.0)
+  rspec
+  rubocop

data/README.md

@@ -0,0 +1,35 @@
+[![Build Status](https://travis-ci.org/ileitch/disruptor.svg?branch=master)](https://travis-ci.org/ileitch/disruptor)
+
+# The LMAX Disruptor in Ruby.
+
+The reference Java implementation is more of a framework than a pattern. I have simply taken the core concepts of the Disruptor.
+
+The code may serve as a handy companion for Ruby developers digging into the [Disruptor Technical Paper](http://disruptor.googlecode.com/files/Disruptor-1.0.pdf).
+
+There is a simple Queue implementation, if you're after a lock-free queue.
+
+### Wait Strategies
+
+* `BusySpinWaitStrategy` - Spins until the sequence reaches the required value. CPU intensive but provides best throughput and latency. Do not use if there are more threads than logical CPU cores.
+* `BlockingWaitStrategy` - Puts waiting threads to sleep. Use this strategy if you have more threads than logical cores.
+
+```
+buffer = Disruptor::RingBuffer.new(20, BusySpinWaitStrategy.new)
+```
+
+### Cache-line Padding
+
+One neat optimization the LMAX developers have used is cache-line padding of their Sequence object. Replicating this in Ruby is a little tricky as Ruby does not support native types. The problem is made even more tricky when you take into account the different internal Object structure across Ruby implementations. Perhaps a C-ext could achieve this, VM level support would be even better. Patches welcome! ;)
+
+### Benchmarks
+
+I'm not going to show any results here, because they're pretty meaningless. No Ruby implementation can get close to performance of the Java implementation. If you do want to use the Disruptor pattern in JRuby, you're probably better off writing an extension for the official Disruptor.
+
+Saying that, there are a couple of simple Queue benchmarks in `bm`.
+
+### TODO
+
+* Detect buffer wrap around, have the publishers wait.
+* Implement different processor wait strategies.
+* Implement different publisher claim strategies.
+* Implement cache-line padding (possible on MRI, Rubinius?).

data/Rakefile

@@ -0,0 +1,12 @@
+require 'rake'
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+Dir['lib/tasks/*.rake'].each { |rake| load rake }
+
+RSpec::Core::RakeTask.new(:spec)
+
+if RUBY_VERSION > '1.9' && defined?(RUBY_ENGINE) && %w(rbx ruby).include?(RUBY_ENGINE)
+  task default: %w(spec rubocop)
+else
+  task default: 'spec'
+end

data/bm/one_processor.rb

@@ -0,0 +1,25 @@
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + '/../lib'))
+require 'disruptor'
+require 'benchmark'
+require 'thread'
+
+width = 14
+n = 6_000_000
+
+Benchmark.bm(width) do |x|
+  disruptor = Disruptor::Queue.new(n, Disruptor::BusySpinWaitStrategy.new)
+  queue = Queue.new
+
+  n.times do
+    disruptor.push(nil)
+    queue.push(nil)
+  end
+
+  x.report('disruptor:') do
+    n.times { disruptor.pop }
+  end
+
+  x.report('    queue:') do
+    n.times { queue.pop }
+  end
+end

data/bm/two_processors.rb

@@ -0,0 +1,31 @@
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + '/../lib'))
+require 'disruptor'
+require 'benchmark'
+require 'thread'
+
+width = 14
+n = 6_000_000
+
+Benchmark.bm(width) do |x|
+  disruptor = Disruptor::Queue.new(n, Disruptor::BusySpinWaitStrategy.new)
+  queue = Queue.new
+
+  n.times do
+    queue.push(nil)
+    disruptor.push(nil)
+  end
+
+  x.report('disruptor:') do
+    threads = []
+    threads << Thread.new { (n / 2).times { disruptor.pop } }
+    threads << Thread.new { (n / 2).times { disruptor.pop } }
+    threads.map(&:join)
+  end
+
+  x.report('    queue:') do
+    threads = []
+    threads << Thread.new { (n / 2).times { queue.pop } }
+    threads << Thread.new { (n / 2).times { queue.pop } }
+    threads.map(&:join)
+  end
+end

data/disruptor.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'disruptor/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'disruptor'
+  spec.version       = Disruptor::VERSION
+  spec.authors       = ['Ian Leitch']
+  spec.email         = ['port001@gmail.com']
+  spec.summary       = %q(Basic implementation of the LMAX Disruptor pattern in Ruby.)
+  spec.homepage      = 'https://github.com/ileitch/disruptor'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'concurrent-ruby'
+
+  spec.platform = 'java' if defined? JRUBY_VERSION
+end

data/lib/disruptor.rb

@@ -0,0 +1,16 @@
+module Disruptor
+  class BufferSizeError < StandardError; end
+end
+
+require 'concurrent'
+require 'thread'
+
+require 'disruptor/wait_strategy'
+require 'disruptor/busy_spin_wait_strategy'
+require 'disruptor/blocking_wait_strategy'
+require 'disruptor/ring_buffer'
+require 'disruptor/sequence'
+require 'disruptor/processor'
+require 'disruptor/processor_barrier'
+require 'disruptor/processor_pool'
+require 'disruptor/queue'

data/lib/disruptor/blocking_wait_strategy.rb

@@ -0,0 +1,27 @@
+module Disruptor
+  #
+  # Implements a lock based wait strategy.
+  #
+  # Use when CPU resources are more of a concern than throughput and latency.
+  #
+  # Blocking causes a context switch when the thread sleeps, consider the
+  # BusySpinWaitStrategy instead if you expect the wait time to be less than
+  # the time it takes perform a context switch.
+  #
+  # This strategy is preferred if you have more threads than logical cores.
+  #
+  class BlockingWaitStrategy < WaitStrategy
+    def initialize
+      @mutex = Mutex.new
+      @cond = ConditionVariable.new
+    end
+
+    def wait_for(cursor, sequence)
+      @mutex.synchronize { @cond.wait(@mutex) } while cursor.get < sequence
+    end
+
+    def notify_blocked
+      @mutex.synchronize { @cond.broadcast }
+    end
+  end
+end

data/lib/disruptor/busy_spin_wait_strategy.rb

@@ -0,0 +1,15 @@
+module Disruptor
+  #
+  # Implements a Busy Spin wait strategy.
+  #
+  # Use when throughput and latency are of more concern than CPU resources.
+  #
+  # Typically this strategy is preferred when the number of threads is <= the
+  # number of logical cores.
+  #
+  class BusySpinWaitStrategy < WaitStrategy
+    def wait_for(cursor, sequence)
+      while cursor.get < sequence; end
+    end
+  end
+end

data/lib/disruptor/processor.rb

@@ -0,0 +1,53 @@
+module Disruptor
+  #
+  # Include this class into your event processors.
+  # Your processor must implement process_event(event).
+  #
+  module Processor
+    class Stop < StandardError; end
+
+    def self.method_added(name)
+      if name.to_sym == :setup && self != Disruptor::Processor
+        raise 'Do not override setup in your processor subclass.'
+      end
+    end
+
+    def setup(buffer, barrier, sequence)
+      @buffer = buffer
+      @barrier = barrier
+      @sequence = sequence
+    end
+
+    def start
+      @thread = Thread.new do
+        loop do
+          begin
+            process_next_sequence
+          rescue Stop
+            break
+          end
+        end
+      end
+    end
+
+    def process_next_sequence
+      next_sequence = @sequence.increment
+      @barrier.wait_for(next_sequence)
+      event = @buffer.get(next_sequence)
+      raise event if event == Stop
+      process_event(event)
+    end
+
+    def stop
+      seq = @buffer.claim
+      @buffer.set(seq, Stop)
+      @buffer.commit(seq)
+
+      @thread.join if @thread
+    end
+
+    def process_event(event) # rubocop:disable Lint/UnusedMethodArgument
+      raise NotImplementedError
+    end
+  end
+end

data/lib/disruptor/processor_barrier.rb

@@ -0,0 +1,38 @@
+module Disruptor
+  #
+  # This class implements a thread-safe read barrier between the buffer
+  # and Processors.
+  #
+  # Processors ask the barrier for the next sequence they want, the barrier
+  # spins waiting for the sequence to become available.
+  # This is achieved without CAS as the buffer's cursor is protected by a
+  # memory barrier.
+  #
+  #           <- claimed ->
+  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+  #        ^                 ^
+  #        cursor            next
+  #
+  # In this example sequences 0, 1 and 2 are available for reading by
+  # the processors.
+  #
+  class ProcessorBarrier
+    def initialize(buffer, wait_strategy)
+      @buffer = buffer
+      @wait_strategy = wait_strategy
+      @last_known_sequence = Disruptor::RingBuffer::INITIAL_CURSOR_VALUE
+    end
+
+    def wait_for(sequence)
+      # Optimization:
+      # Store the last known cursor value in local memory to avoid
+      # going down into the primitive Sequence#get.
+      return if sequence < @last_known_sequence
+
+      @wait_strategy.wait_for(@buffer.cursor, sequence)
+
+      # TODO: Candidate for cache-line padding?
+      @last_known_sequence = @buffer.cursor.get
+    end
+  end
+end

data/lib/disruptor/processor_pool.rb

@@ -0,0 +1,28 @@
+module Disruptor
+  #
+  # This class implements a collection of Processors that share a CAS
+  # protected incremental sequence.
+  #
+  # Processors request slots from the buffer in a gated fashion.
+  # Processors A, B, C ... will never contend for the same slot in the buffer.
+  #
+  class ProcessorPool
+    def initialize(buffer, wait_strategy)
+      @sequence = Sequence.new(Disruptor::RingBuffer::INITIAL_NEXT_VALUE)
+      @buffer = buffer
+      @barrier = ProcessorBarrier.new(@buffer, wait_strategy)
+      @processors = []
+    end
+
+    def add(processor)
+      processor.setup(@buffer, @barrier, @sequence)
+      @processors << processor
+      processor.start
+    end
+
+    def drain
+      @processors.map(&:stop)
+      @processors = []
+    end
+  end
+end

data/lib/disruptor/queue.rb

@@ -0,0 +1,30 @@
+module Disruptor
+  #
+  # A simple n-reader, n-writer queue.
+  #
+  class Queue
+    def initialize(size, wait_strategy)
+      @buffer = RingBuffer.new(size, wait_strategy)
+      @sequence = Sequence.new
+      @barrier = ProcessorBarrier.new(@buffer, wait_strategy)
+    end
+
+    def push(obj)
+      seq = @buffer.claim
+      @buffer.set(seq, obj)
+      @buffer.commit(seq)
+      nil
+    end
+    alias_method :<<, :push
+
+    def pop
+      next_sequence = @sequence.increment
+      @barrier.wait_for(next_sequence)
+      @buffer.get(next_sequence)
+    end
+
+    def size
+      @buffer.committed_count - @sequence.get
+    end
+  end
+end

data/lib/disruptor/ring_buffer.rb

@@ -0,0 +1,67 @@
+module Disruptor
+  #
+  # This class implements an n-writer ring buffer.
+  #
+  # A publisher must first claim a slot in the buffer before it can write
+  # any data. This is achieved using a pointer to the next available slot
+  # which is incremented using CAS. Once the Publisher has written data
+  # it commits it (makes it visible to Processors) by setting a cursor
+  # pointer.
+  #
+  # Publishers commit in the same order they claim a slot, this is enforced
+  # for you by the buffer. For example, Publisher A has claimed slot 1 and
+  # Publisher B slot 2. Publisher A - for whatever reason - may take more
+  # time to commit the slot than Publisher B. In this scenario Publisher B
+  # will spin trying to set the cursor until A commits.
+  #
+  # Note that the actual position of data in the ring buffer is never known
+  # outside of the buffer. Publishers and Processors communicate with the
+  # buffer using a non-looping sequence. The buffer uses the sequence
+  # modulo the buffer size as the physical slot.
+  #
+  class RingBuffer
+    INITIAL_CURSOR_VALUE = -1
+    INITIAL_NEXT_VALUE = 0
+
+    attr_reader :cursor, :next
+
+    def initialize(size, wait_strategy, &blk)
+      raise BufferSizeError, 'Buffer size must be a power of two.' if size.odd?
+
+      @size = size
+      @wait_strategy = wait_strategy
+      @cursor = Sequence.new(INITIAL_CURSOR_VALUE)
+      @next = Sequence.new(INITIAL_NEXT_VALUE)
+      @buffer = Array.new(@size, &blk)
+    end
+
+    def claim
+      @next.increment
+    end
+
+    def commit(seq)
+      if @cursor.get != INITIAL_CURSOR_VALUE && seq != INITIAL_NEXT_VALUE
+        @wait_strategy.wait_for(@cursor, seq - 1)
+      end
+
+      @cursor.set(seq - 1, seq)
+      @wait_strategy.notify_blocked
+    end
+
+    def set(seq, event)
+      @buffer[seq % @size] = event
+    end
+
+    def get(seq)
+      @buffer[seq % @size]
+    end
+
+    def claimed_count
+      @next.get - @cursor.get - 1
+    end
+
+    def committed_count
+      @cursor.get + 1
+    end
+  end
+end

data/lib/disruptor/sequence.rb

@@ -0,0 +1,25 @@
+module Disruptor
+  class Sequence
+    INITIAL_VALUE = 0
+
+    def initialize(initial = INITIAL_VALUE)
+      @sequence = Concurrent::Atomic.new(initial)
+    end
+
+    def get
+      @sequence.get
+    end
+
+    def set(current_seq, new_seq)
+      until @sequence.compare_and_set(current_seq, new_seq); end
+    end
+
+    def increment
+      loop do
+        current_seq = @sequence.get
+        next_seq = current_seq + 1
+        return current_seq if @sequence.compare_and_set(current_seq, next_seq)
+      end
+    end
+  end
+end

data/lib/disruptor/version.rb

@@ -0,0 +1,3 @@
+module Disruptor
+  VERSION = '1.0.0.beta2'
+end

data/lib/disruptor/wait_strategy.rb

@@ -0,0 +1,9 @@
+module Disruptor
+  class WaitStrategy
+    def wait_for(sequence, slot) # rubocop:disable Lint/UnusedMethodArgument
+      raise NotImplementedError
+    end
+
+    def notify_blocked; end
+  end
+end

data/lib/tasks/rubocop.rake

@@ -0,0 +1,8 @@
+begin
+  require 'rubocop/rake_task'
+  t = RuboCop::RakeTask.new
+  t.options << '-D'
+rescue LoadError
+  warn 'rubocop not available.'
+  task rubocop: []
+end

data/spec/blocking_wait_strategy_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Disruptor::BlockingWaitStrategy do
+  let(:mutex) { double }
+  let(:condition) { double(broadcast: nil) }
+  let(:strategy) { Disruptor::BlockingWaitStrategy.new }
+  let(:sequence) { double }
+
+  before do
+    allow(mutex).to receive(:synchronize).and_yield
+    allow(Mutex).to receive_messages(new: mutex)
+    allow(ConditionVariable).to receive_messages(new: condition)
+  end
+
+  it 'returns when the sequence value reaches the given slot' do
+    allow(sequence).to receive_messages(get: 1)
+    strategy.wait_for(sequence, 1)
+  end
+
+  it 'sleeps if the sequence has not reached the given slot'
+
+  it 'notifies all blocked publishers' do
+    expect(condition).to receive(:broadcast)
+    strategy.notify_blocked
+  end
+end

data/spec/busy_spin_wait_strategy_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Disruptor::BusySpinWaitStrategy do
+  let(:strategy) { Disruptor::BusySpinWaitStrategy.new }
+  let(:sequence) { double }
+
+  it 'returns when the sequence value reaches the given slot' do
+    allow(sequence).to receive_messages(get: 1)
+    strategy.wait_for(sequence, 1)
+  end
+end

data/spec/fixtures/test_wait_strategy.rb

@@ -0,0 +1,5 @@
+module Disruptor
+  class TestWaitStrategy < WaitStrategy
+    def wait_for(*); end
+  end
+end

data/spec/processor_pool_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Disruptor::ProcessorPool, 'add' do
+  let(:buffer) { double }
+  let(:pool) { Disruptor::ProcessorPool.new(buffer, Disruptor::TestWaitStrategy.new) }
+  let(:barrier) { double }
+  let(:sequence) { double }
+  let(:processor) { double(setup: nil, start: nil) }
+
+  before do
+    allow(Disruptor::ProcessorBarrier).to receive_messages(new: barrier)
+    allow(Disruptor::Sequence).to receive_messages(new: sequence)
+  end
+
+  it 'calls setup on the given processor' do
+    expect(processor).to receive(:setup).with(buffer, barrier, sequence)
+    pool.add(processor)
+  end
+
+  it 'starts the processor' do
+    expect(processor).to receive(:start)
+    pool.add(processor)
+  end
+end
+
+describe Disruptor::ProcessorPool, 'drain' do
+  let(:buffer) { double }
+  let(:pool) { Disruptor::ProcessorPool.new(buffer, Disruptor::TestWaitStrategy.new) }
+  let(:processor) { double(setup: nil, start: nil) }
+
+  before { pool.add(processor) }
+
+  it 'stops each processor' do
+    expect(processor).to receive(:stop)
+    pool.drain
+  end
+end

data/spec/processor_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+describe Disruptor::Processor do
+  let(:processor_subclass) do
+    c = Class.new
+    c.send(:include, Disruptor::Processor)
+    c
+  end
+
+  it 'raises a NotImplementedError if the subclass does not implement handle_event' do
+    expect { processor_subclass.new.process_event(double) }.to raise_error(NotImplementedError)
+  end
+
+  it 'raises an error when a subclass overrides the setup method' do
+    expect { processor_subclass.define_method(:setup) {} }.to raise_error
+  end
+end
+
+describe Disruptor::Processor, 'process_next_sequence' do
+  class MyProcessor
+    include Disruptor::Processor
+    attr_accessor :processed_event
+    def process_event(e)
+      self.processed_event = e
+    end
+  end
+
+  let(:event) { double }
+  let(:sequence) { double(increment: 10) }
+  let(:buffer) { double(get: event) }
+  let(:barrier) { double(wait_for: nil, processor_stopping: nil) }
+  let(:processor) { MyProcessor.new }
+
+  before { processor.setup(buffer, barrier, sequence) }
+
+  it 'increments the sequence' do
+    expect(sequence).to receive(:increment)
+    processor.process_next_sequence
+  end
+
+  it 'waits for the next sequence' do
+    expect(barrier).to receive(:wait_for).with(10)
+    processor.process_next_sequence
+  end
+
+  it 'gets the event for the sequence' do
+    expect(buffer).to receive(:get).with(10)
+    processor.process_next_sequence
+  end
+
+  it 'dispatches the event processor' do
+    expect do
+      processor.process_next_sequence
+    end.to change(processor, :processed_event).from(nil).to(event)
+  end
+end
+
+describe Disruptor::Processor, 'stop' do
+  let(:processor_subclass) do
+    c = Class.new
+    c.send(:include, Disruptor::Processor)
+    c
+  end
+
+  let(:buffer) { double(claim: nil, set: nil, commit: nil) }
+  let(:thread) { double }
+  let(:processor) { processor_subclass.new }
+  let(:barrier) { double(processor_stopping: nil) }
+
+  before do
+    processor.setup(buffer, barrier, nil)
+    allow(Thread).to receive_messages(new: thread)
+  end
+
+  it 'claims a slot in the buffer for the Stop instruction' do
+    expect(buffer).to receive(:claim)
+    processor.stop
+  end
+
+  it 'adds a Stop instruction into the buffer' do
+    allow(buffer).to receive_messages(claim: 1)
+    expect(buffer).to receive(:set).with(1, Disruptor::Processor::Stop)
+    processor.stop
+  end
+
+  it 'commits the Stop instruction in the buffer' do
+    expect(buffer).to receive(:commit)
+    processor.stop
+  end
+
+  it 'joins the thread' do
+    processor.start
+    expect(thread).to receive(:join)
+    processor.stop
+  end
+end

data/spec/queue_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Disruptor::Queue do
+  it 'returns the queue size' do
+    queue = Disruptor::Queue.new(6, Disruptor::TestWaitStrategy.new)
+    expect(queue.size).to eq(0)
+    5.times { queue.push(nil) }
+    expect(queue.size).to eq(5)
+    3.times { queue.pop }
+    expect(queue.size).to eq(2)
+    2.times { queue.pop }
+    expect(queue.size).to eq(0)
+  end
+
+  describe 'with BusySpinWaitStrategy' do
+    let(:queue) { Disruptor::Queue.new(12, Disruptor::BusySpinWaitStrategy.new) }
+
+    it 'can push and pop an object' do
+      q = queue
+      t1 = Thread.new { 10.times { q.push(:data) } }
+      t2 = Thread.new { 10.times.map { q.pop } }
+      [t1, t2].map(&:join)
+      expect(t2.value).to eq([:data] * 10)
+    end
+  end
+
+  describe 'with BlockingWaitStrategy' do
+    let(:queue) { Disruptor::Queue.new(12, Disruptor::BlockingWaitStrategy.new) }
+
+    it 'can push and pop an object' do
+      q = queue
+      t1 = Thread.new { 10.times { q.push(:data) } }
+      t2 = Thread.new { 10.times.map { q.pop } }
+      [t1, t2].map(&:join)
+      expect(t2.value).to eq([:data] * 10)
+    end
+  end
+end

data/spec/ring_buffer_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe Disruptor::RingBuffer do
+  let(:buffer) { Disruptor::RingBuffer.new(32, Disruptor::TestWaitStrategy.new) }
+
+  it 'raises an error when initialized with a size that is not a power of two' do
+    expect { Disruptor::RingBuffer.new(31, Disruptor::TestWaitStrategy.new) }.to raise_error(Disruptor::BufferSizeError)
+  end
+
+  it 'accepts a block to preallocate the buffer' do
+    event = double
+    buffer = Disruptor::RingBuffer.new(6, Disruptor::TestWaitStrategy.new) { event }
+    expect(buffer.get(0)).to eq(event)
+  end
+
+  it 'returns the number of claimed slots' do
+    buffer = Disruptor::RingBuffer.new(20, Disruptor::TestWaitStrategy.new)
+    5.times { buffer.claim }
+    2.times { |i| buffer.commit(i) }
+    expect(buffer.claimed_count).to eq(3)
+  end
+
+  it 'returns the committed slots count' do
+    buffer = Disruptor::RingBuffer.new(20, Disruptor::TestWaitStrategy.new)
+    5.times do
+      i = buffer.claim
+      buffer.commit(i)
+    end
+    expect(buffer.committed_count).to eq(5)
+  end
+end
+
+describe Disruptor::RingBuffer, 'claim' do
+  let(:buffer) { Disruptor::RingBuffer.new(20, Disruptor::TestWaitStrategy.new) }
+
+  it 'returns the next sequence' do
+    expect(buffer.claim).to eq(0)
+    expect(buffer.claim).to eq(1)
+    expect(buffer.claim).to eq(2)
+  end
+end
+
+describe Disruptor::RingBuffer, 'commit' do
+  let(:wait_strategy) { double(wait_for: nil, notify_blocked: nil) }
+  let(:buffer) { Disruptor::RingBuffer.new(12, wait_strategy) }
+  let(:cursor) { double(set: nil, get: Disruptor::RingBuffer::INITIAL_CURSOR_VALUE) }
+
+  before do
+    allow(Disruptor::Sequence).to receive_messages(new: cursor)
+  end
+
+  it 'waits for the cursor to reach the previous slot' do
+    allow(cursor).to receive_messages(get: 0)
+    expect(wait_strategy).to receive(:wait_for).with(cursor, 15)
+    buffer.commit(16)
+  end
+
+  it 'sets the cursor to the current slot' do
+    allow(cursor).to receive_messages(get: 0)
+    expect(cursor).to receive(:set).with(15, 16)
+    buffer.commit(16)
+  end
+
+  it 'sets the cursor to 0 for the first commit' do
+    expect(cursor).to receive(:set).with(-1, 0)
+    buffer.commit(0)
+  end
+
+  it 'does not wait for the cursor for the first commit into the buffer' do
+    expect(wait_strategy).not_to receive(:wait_for)
+    buffer.commit(0)
+  end
+
+  it 'notifies blocked publishers' do
+    expect(wait_strategy).to receive(:notify_blocked)
+    buffer.commit(0)
+  end
+end
+
+describe Disruptor::RingBuffer, 'get/set' do
+  let(:buffer) { Disruptor::RingBuffer.new(12, Disruptor::TestWaitStrategy.new) }
+  let(:event) { double }
+
+  it 'returns the event for the given seq' do
+    buffer.set(16, event)
+    expect(buffer.get(16)).to eq(event)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + '/../lib'))
+require 'disruptor'
+require 'fixtures/test_wait_strategy'

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: disruptor
+version: !ruby/object:Gem::Version
+  version: 1.0.0.beta2
+platform: ruby
+authors:
+- Ian Leitch
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- port001@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-gemset"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bm/one_processor.rb
+- bm/two_processors.rb
+- disruptor.gemspec
+- lib/disruptor.rb
+- lib/disruptor/blocking_wait_strategy.rb
+- lib/disruptor/busy_spin_wait_strategy.rb
+- lib/disruptor/processor.rb
+- lib/disruptor/processor_barrier.rb
+- lib/disruptor/processor_pool.rb
+- lib/disruptor/queue.rb
+- lib/disruptor/ring_buffer.rb
+- lib/disruptor/sequence.rb
+- lib/disruptor/version.rb
+- lib/disruptor/wait_strategy.rb
+- lib/tasks/rubocop.rake
+- spec/blocking_wait_strategy_spec.rb
+- spec/busy_spin_wait_strategy_spec.rb
+- spec/fixtures/test_wait_strategy.rb
+- spec/processor_pool_spec.rb
+- spec/processor_spec.rb
+- spec/queue_spec.rb
+- spec/ring_buffer_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/ileitch/disruptor
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Basic implementation of the LMAX Disruptor pattern in Ruby.
+test_files:
+- spec/blocking_wait_strategy_spec.rb
+- spec/busy_spin_wait_strategy_spec.rb
+- spec/fixtures/test_wait_strategy.rb
+- spec/processor_pool_spec.rb
+- spec/processor_spec.rb
+- spec/queue_spec.rb
+- spec/ring_buffer_spec.rb
+- spec/spec_helper.rb