OPEN SOURCE
Chronicle Wire
Chronicle Wire is a java serialiser, that is able to read and write to different message formats such as JSON, YAML, CSV and raw binary data.
Pluggable Wire Implementation
Chronicle Wire abstracts away the implementation of the serialization to a pluggable Wire implementation. This means there is no need to change the code to change the encoding. The objects only need to describe what is to be serialized not how it should be serialized. It is developed with low latency in mind and reduced object creation this helps to deliver the highest possible performance.
Balanced Compactness
Chronicle Wire balances the compactness of the format without going to the extreme of compressing the data, which would use valuable CPU time. Storing the data in as few bytes as possible without sacrificing performance, for example, integers can be stored using stop bit encoding.
Schema Changes
A key aim is to allow the schema to evolve over time. New schemas for an existing message can contain optional fields, fields in a different order, fields that are not expected. In other words, Chronicle Wire is able to read a message to a different type. It is also able to handle updating fixed-length fields and dynamic updates of Enums or objects passed-by-name.
Easy to Convert Format
Chronicle Wire is designed to make it easy to convert from one wire format to another. For example, you can use fixed-width binary data in memory for performance, and variable-width or text over the network. Different TCP connections could use different formats. It also supports hybrid wire formats. For example, you can have one format embedded in another.
Low-latency
Benchmarks
Chronicle Wire is developed with Low latency in mind and with reduced object creation to deliver the highest possible performance.
Wire Comparison for 100 byte messages
* 96 byte messages
Related Articles
Java serialization is a popular mechanism where you are able to serialize and deserialize complex object graphs; for example where object A can contain a reference to object B, which in turn has a reference back to object A. The problem is that this rich functionality comes at a performance cost. However, if you do…
As most Java developers know, putting values in a Java Map (like a HashMap) involves creating a large number of auxiliary objects under the covers. For example, a HashMap with int keys and long values might, for each entry, create a wrapped Integer, a wrapped Long object and a Node that holds the former values…
If you use a standard JVM like the Oracle JVM or the OpenJDK, you might find that as the heap size grows the performance of your JVM can drop as GC pause time escalates. This tends to be a problem around 32 GB of heap, but it often depends on the application at which point…