In this article we analyze how CoralQueue implements a multiplexer to allow multiple producers to send messages to a single consumer. We then present the throughput numbers for different set of configurations with different set of cpu cores. Continue reading
Multicasting with CoralQueue through a Splitter
In this article we show how to use CoralQueue to multicast/broadcast the same message to multiple consumers so each consumer receives and processes all messages. We also present throughput numbers for different configurations, each one using a different set of cpu cores. Continue reading
CoralQueue Throughput Test Explained
In this article we will present the benchmark test used by CoralQueue that shows a throughput between 55 and 65 million messages per second without hyper-threading and between 85 and 95 million messages per second with hyper-threading. If you are interested in the CoralQueue Getting Started article, you can check it here first. Continue reading
Getting Started with CoralQueue
CoralQueue is a ultra-low-latency lock-free and garbage-free queue for inter-thread communication. It can be defined as a batching queue backed up by a circular array (i.e. the ring buffer) filled with pre-allocated transfer objects which uses memory-barriers to synchronize producers and consumers through sequences. Fortunately you don’t have to understand all its intrinsic details to use it. In this article we show how to use CoralQueue to send messages from a producer thread to a consumer thread in a very fast way without producing any garbage. Continue reading
CoralLog vs Log4J Performance Comparison
In this article we compare CoralLog and Log4J in terms of latency and throughput. Benchmarks were conducted against asynchronous Log4J 2.0-rc2 using Disruptor 3.2.1. Continue reading
Java Development without GC
All products developed by Coral Blocks have the very important feature of leaving ZERO garbage behind. Because the latency imposed by the Java Garbage Collector (i.e. GC) is unacceptable for high-performance systems and because it is impossible to turn off the GC, the best option for real-time systems in Java is to not produce any garbage at all so that the GC never kicks in. Imagine a high-performance matching engine operating in the microsecond level, sending and receiving hundreds of thousands messages per second. If at any given time the GC decides to kick in with its 1+ millisecond latencies, the disruption in the system will be huge. Therefore, if you want to develop real-time systems in Java with minimal variance and latency, the best option is to do it right without creating any garbage for the GC. In this article we will discuss best practices and how you can use Coral Blocks’ MemorySampler utility class to help you accomplish this critical goal. Continue reading
CoralReactor vs Netty Performance Comparison
In this article we compare CoralReactor and Netty in terms of performance to show that CoralReactor is 10 times faster and produces zero garbage. Continue reading
Getting Started with CoralThreads
In this article we will see how easy it is to use CoralThreads to pin a critical thread to a microprocessor core. Continue reading
CoralQueue Performance Numbers
In this article we present CoralQueue performance numbers for four different scenarios: message-sender latency, message transit latency, message-sender throughput and message transit throughput. The standard scenario of one producer (message-sender) and one consumer (message-receiver) is used with two possible setups: producer and consumer pinned to the same core (hyper-threading) and producer and consumer pinned to different cores (no hyper-threading). Continue reading
CoralLog Performance Numbers
In this article we present the CoralLog performance numbers when logging messages to a file. Continue reading