| package disruptor |
| |
| import ( |
| "math" |
| "sync/atomic" |
| ) |
| |
| type MultiWriter struct { |
| capacity int64 |
| gate int64 |
| shift uint8 |
| committed []int32 |
| upstream Barrier |
| claimed *Cursor |
| } |
| |
| func NewMultiWriter(claimed *Cursor, capacity int64, upstream Barrier) *MultiWriter { |
| assertPowerOfTwo(capacity) |
| |
| shift := uint8(math.Log2(float64(capacity))) |
| buffer := initializeCommitBuffer(capacity) |
| |
| return &MultiWriter{ |
| capacity: capacity, |
| gate: InitialSequenceValue, |
| shift: shift, |
| committed: buffer, |
| upstream: upstream, |
| claimed: claimed, |
| } |
| } |
| func initializeCommitBuffer(capacity int64) []int32 { |
| buffer := make([]int32, capacity) |
| for i := int64(0); i < capacity; i++ { |
| buffer[i] = -1 |
| } |
| return buffer |
| } |
| |
| func (this *MultiWriter) Reserve(count int64) (int64, int64) { |
| if count <= 0 { |
| panic("Reservation must be a positive number.") |
| } else if count > this.capacity { |
| panic("Reservation cannot exceed the capacity.") |
| } |
| |
| for { |
| previous := this.claimed.Load() |
| next := previous + count |
| wrap := next - this.capacity |
| |
| if wrap > this.gate { |
| min := this.upstream.Load() |
| if wrap > min { |
| return 0, Gating |
| } |
| |
| this.gate = min |
| } |
| |
| if atomic.CompareAndSwapInt64(&this.claimed.value, previous, next) { |
| return previous + 1, next |
| } |
| } |
| } |
| |
| func (this *MultiWriter) Commit(lower, upper int64) { |
| for mask := this.capacity - 1; lower <= upper; lower++ { |
| this.committed[lower&mask] = int32(lower >> this.shift) |
| } |
| } |
| |
| func (this *MultiWriter) Claimed() *Cursor { |
| return this.claimed |
| } |
| func (this *MultiWriter) Buffer() []int32 { |
| return this.committed |
| } |