The machine used for the benchmarks below was an Intel i7 quad-core (4 x 3.50GHz) Ubuntu box overclocked to 4.50Ghz.

FileStore

With a FileStore you can persist all your messages to disk. As the example below demonstrates, a FileStore by itself (i.e. without being asynchronous) is already very fast, but has some outliers as you can see in the 99.9 percentile:

Messages: 900,000 (256 bytes)
Avg Time: 159.06 nanos
Min Time: 47.0 nanos
Max Time: 98.944 micros
75% = [avg: 51.0 nanos, max: 53.0 nanos]
90% = [avg: 51.0 nanos, max: 55.0 nanos]
99% = [avg: 53.0 nanos, max: 174.0 nanos]
99.9% = [avg: 132.0 nanos, max: 25.571 micros]
99.99% = [avg: 155.0 nanos, max: 27.549 micros]
99.999% = [avg: 158.0 nanos, max: 38.035 micros]

AsyncStore

With the AsyncStore you can get blazing fast performance with no outliers as you can see by the results below:

Messages: 900,000 (256 bytes)
Avg Time: 59.84 nanos
Min Time: 41.0 nanos
Max Time: 10.221 micros
75% = [avg: 49.0 nanos, max: 71.0 nanos]
90% = [avg: 54.0 nanos, max: 84.0 nanos]
99% = [avg: 58.0 nanos, max: 176.0 nanos]
99.9% = [avg: 59.0 nanos, max: 388.0 nanos]
99.99% = [avg: 59.0 nanos, max: 476.0 nanos]
99.999% = [avg: 59.0 nanos, max: 1.748 micros]

FileStore Benchmark Source Code

package com.coralblocks.coralstore.bench;

import java.io.IOException;
import java.nio.ByteBuffer;

import com.coralblocks.coralbits.bench.Benchmarker;
import com.coralblocks.coralstore.FileStore;
import com.coralblocks.coralstore.Store;
import com.coralblocks.coralthreads.Affinity;

public class FileBench {
	
	public static void main(String[] args) throws IOException {
		
		// java -server -verbose:gc -cp target/coralstore-all.jar:lib/jna-3.5.1.jar -DdetailedBenchmarker=true -Xms2g -Xmx8g -XX:NewSize=512m -XX:MaxNewSize=1024m com.coralblocks.coralstore.bench.FileBench 256 100000 1000000 2
		
		int msgSize = Integer.parseInt(args[0]);
		int warmup = Integer.parseInt(args[1]);
		int messages = Integer.parseInt(args[2]);
		int procToBind = args.length > 3 ? Integer.parseInt(args[3]) : -1;
		
		byte[] msgBytes = new byte[msgSize];
		// build a dummy message:
		for(int i = 0; i < msgBytes.length; i++) {
			msgBytes[i] = (byte) String.valueOf(i % 10).charAt(0);	
		}
		ByteBuffer msg = ByteBuffer.wrap(msgBytes);
		
		Store store = new FileStore(".", "fileStoreSession");
		
		Benchmarker bench = Benchmarker.create(warmup);
		
		if (procToBind != -1) {
			System.out.println("Using affinity! procToBind=" + procToBind + " available=" + Affinity.isAvailable());
			Affinity.assignToProcessor(procToBind, Thread.currentThread());
			Affinity.bind();
		}
		
		for(int i = 0; i < messages; i++) {
			msg.position(0);
			bench.mark();
			store.addMessage(msg);
			store.flush();
			bench.measure();
		}
		
		store.close();
		
		bench.printResults();
	}
}

AsyncStore Benchmark Source Code

package com.coralblocks.coralstore.bench;

import java.io.IOException;
import java.nio.ByteBuffer;

import com.coralblocks.coralbits.bench.Benchmarker;
import com.coralblocks.coralstore.FileStore;
import com.coralblocks.coralstore.Store;
import com.coralblocks.coralstore.async.AsyncStore;
import com.coralblocks.coralthreads.Affinity;

public class AsyncBench {
	
	public static void main(String[] args) throws IOException, InterruptedException {
		
		// java -server -verbose:gc -cp target/coralstore-all.jar:lib/jna-3.5.1.jar -DdetailedBenchmarker=true -DcoralThreadsVerbose=true -Xms2g -Xmx8g -XX:NewSize=512m -XX:MaxNewSize=1024m com.coralblocks.coralstore.bench.AsyncBench 256 100000 1000000 2 3
		
		int msgSize = Integer.parseInt(args[0]);
		int warmup = Integer.parseInt(args[1]);
		int messages = Integer.parseInt(args[2]);
		int procToBind = args.length > 3 ? Integer.parseInt(args[3]) : -1;
		int procToBindAsync = args.length > 4 ? Integer.parseInt(args[4]) : -1;
		
		byte[] msgBytes = new byte[msgSize];
		// build a dummy message:
		for(int i = 0; i < msgBytes.length; i++) {
			msgBytes[i] = (byte) String.valueOf(i % 10).charAt(0);	
		}
		ByteBuffer msg = ByteBuffer.wrap(msgBytes);
		
		Store store = new FileStore(".", "asyncStoreSession");
		AsyncStore asyncStore = new AsyncStore(store, msgSize, procToBindAsync);
		
		Benchmarker bench = Benchmarker.create(warmup);
		
		if (procToBind != -1) {
			Affinity.assignToProcessor(procToBind, Thread.currentThread());
			Affinity.bind();
		}
		
		for(int i = 0; i < messages; i++) {
			msg.position(0);
			bench.mark();
			asyncStore.addMessage(msg);
			asyncStore.flush();
			bench.measure();
			
			if ((i + 1) % AsyncStore.getQueueCapacity() == 0) {
				// avoid queue contention because we are measuring latency, not throughput
				asyncStore.drainAndWait();
			}
		}
		
		asyncStore.discard();
		
		bench.printResults();
	}
}

Conclusion

CoralStore delivers blazing fast performance with very low latency and variance. You can persist messages in 70 nanoseconds on average.