@Override protected long runDisruptorPass() throws Exception { CountDownLatch latch = new CountDownLatch(1); fizzBuzzHandler.reset(latch, batchProcessorFizzBuzz.getSequence().get() + ITERATIONS); executor.submit(batchProcessorFizz); executor.submit(batchProcessorBuzz); executor.submit(batchProcessorFizzBuzz); long start = System.currentTimeMillis(); for (long i = 0; i < ITERATIONS; i++) { long sequence = ringBuffer.next(); ringBuffer.get(sequence).setValue(i); ringBuffer.publish(sequence); } latch.await(); long opsPerSecond = (ITERATIONS * 1000L) / (System.currentTimeMillis() - start); batchProcessorFizz.halt(); batchProcessorBuzz.halt(); batchProcessorFizzBuzz.halt(); Assert.assertEquals(expectedResult, fizzBuzzHandler.getFizzBuzzCounter()); return opsPerSecond; }
private void consumeBatchToCursor(long cursor, EventHandler<Object> handler) { for (long curr = _consumer.get() + 1; curr <= cursor; curr++) { try { MutableObject mo = _buffer.get(curr); Object o = mo.o; mo.setObject(null); if (o == FLUSH_CACHE) { Object c = null; while (true) { c = _cache.poll(); if (c == null) break; else handler.onEvent(c, curr, true); } } else if (o == INTERRUPT) { throw new InterruptedException("Disruptor processing interrupted"); } else { handler.onEvent(o, curr, curr == cursor); } } catch (Exception e) { throw new RuntimeException(e); } } // TODO: only set this if the consumer cursor has changed? _consumer.set(cursor); }
public void onData(ByteBuffer bb) { long sequence = ringBuffer.next(); // Grab the next sequence try { LongEvent event = ringBuffer.get(sequence); // Get the entry in the Disruptor for the sequence event.set(bb.getLong(0)); // Fill with data } finally { ringBuffer.publish(sequence); } }
public void pushData(ByteBuffer bb) { long sequence = ringBuffer.next(); try { PCData event = ringBuffer.get(sequence); event.setData(bb.getLong(0)); } finally { ringBuffer.publish(sequence); } }
public void run() { // Publishers claim events in sequence long sequence = ringBuffer.next(); ValueEvent event = ringBuffer.get(sequence); for (int i = 0; i < 3000; i++) { event.setValue(i); // this could be more complex with multiple fields // make the event available to EventProcessors ringBuffer.publish(sequence); } }
public void put(Object member, List<Record> records) throws AnalyticsException { RingBuffer<RecordsHolder> buffer = this.getRingBuffer(member); long sequence = buffer.next(); try { RecordsHolder event = buffer.get(sequence); event.setRecords(records); } finally { buffer.publish(sequence); } }
private void prefillArgumentHolderObjects( final RingBuffer<ProxyMethodInvocation> ringBuffer, final ArgumentHolderGenerator argumentHolderGenerator) { final int bufferSize = ringBuffer.getBufferSize(); for (int i = 0; i < bufferSize; i++) { ringBuffer .get(i) .setArgumentHolder( (Resetable) instantiate(argumentHolderGenerator.getGeneratedClass(), new Class[] {})); } }
private void publishDirect(Object obj, boolean block) throws InsufficientCapacityException { final long id; if (block) { id = _buffer.next(); } else { id = _buffer.tryNext(1); } final MutableObject m = _buffer.get(id); m.setObject(obj); _buffer.publish(id); }
private boolean send(RingBuffer<byte[]> ringBuffer) { if (ringBuffer.hasAvailableCapacity(1)) { long next = ringBuffer.next(); byte[] event = ringBuffer.get(next); System.arraycopy(input, 0, event, 0, event.length); ringBuffer.publish(next); return true; } else { errorCount++; return false; } }
@Override public void run() { try { cyclicBarrier.await(); for (long i = 0; i < iterations; i++) { long sequence = ringBuffer.next(); ValueEvent event = ringBuffer.get(sequence); event.setValue(i); ringBuffer.publish(sequence); } } catch (Exception ex) { throw new RuntimeException(ex); } }
public void publish(Object obj, boolean block) throws InsufficientCapacityException { if (consumerStartedFlag) { final long id; if (block) { id = _buffer.next(); } else { id = _buffer.tryNext(1); } final MutableObject m = _buffer.get(id); m.setObject(obj); _buffer.publish(id); } else { _cache.add(obj); if (consumerStartedFlag) flushCache(); } }
public void engage() { // starts WorkerPool workers in separate thread(s) RingBuffer<DemoEvent> ringBuf = workerPool.start(execService); // publish lots of events for (int i = 0; i < 5 * NUM_WORKERS; i++) { long seq = ringBuf.next(); ringBuf.get(seq).setProcessId(i); ringBuf.publish(seq); // try it with and without the sleep // try { Thread.sleep(33); } catch (Exception e) { } } // wait until all published events are processed, then stop the workers workerPool.drainAndHalt(); }
@SuppressWarnings("unchecked") public void run() { try { if (cyclicBarrier != null) cyclicBarrier.await(); for (int i = 0; i < howmany; i++) { long seq = ringBuf.next(); DemoEvent ev = ringBuf.get(seq); // each event will have the pubcount in processId // and the name of the publisher it came from in the Name field ev.setProcessId(i); ev.setName("Published by DemoPublisher #" + id); System.out.printf("Published by DemoPublisher #%d; procId: %d; slot: %d\n", id, i, seq); ringBuf.publish(seq); if (should_pause_b) try { Thread.sleep(8); } catch (Exception e) { } } } catch (Exception e) { throw new RuntimeException(e); } }