What is Chronicle FIX?
Chronicle FIX is a fully featured FIX engine which can handle all current versions of FIX.
What distinguishes it from the competition is pure speed!
Built on our Chronicle libraries, and with the Chronicle philosophy, it employs amongst others, the principles of:
- Zero copy. Eliminates unnecessary garbage collection and increases speed.
- Runtime code generation. Reduces code size for efficient CPU cache usage and increases speed.
- Smart ordering. Optimises parsing and … increases speed!
All these combine to allow Chronicle FIX to achieve excellent performance results.
The graph displayed below shows the results of parsing and logging NewOrderSingle messages:
Note: When evaluating FIX publishers, we recommend that you measure them in a real running system, rather than going by an idealised view of the software from a micro-benchmark.
Why choose Chronicle FIX?
You need a really low-latency FIX engine.
You want a really easy-to-use FIX engine.
- You want a FIX engine that allows deterministic replay; live, or batch.
We believe that Chronicle FIX is just about as fast as you can get in Java.
- In addition we designed the software from the ground up to be the easiest FIX engine to implement.
Even if you don’t need the raw speed of Chronicle FIX, we think that you will really see the benefits of our unified FIX model, especially if you have to communicate with a number of dialects of FIX.
- We only give you the code you need. We’re pretty sure you don’t use more than 5% of the FIX specification. Why do you need to clutter your code with more FIX than you actually use? Well you don’t; and your code will become so much cleaner, simpler, and faster.
- Is it a pain to have to generate a model to generate your runtime?
Not at all.
It is actually a really easy process to define a model file. We can even automate this with our model generator to create an optimised model from your FIX messages. After that, it’s one click to have your clean, uncluttered runtime generated for you!
and there’s more …
Chronicle Queue (a super-optimised low-latency core application from the Chronicle Enterprise suite) is included which logs every FIX message.
Replay. You can easily replay all your historical FIX messages from a Chronicle queue into Chronicle FIX to give the deterministic replay. In other words, you can feed your test systems with actual historical data; so no more made-up, or generated data, that can’t reproduce production issues. You can use this technique to test experimental strategies.
- Chronicle FIX can be used stand-alone. However, it really makes sense to use it as your entry point to the rest of the Chronicle products. You will benefit from the ultra-low latency that we can provide if you use Chronicle as the backbone throughout your systems.
What will you get from us
Chronicle FIX software.
Access to our enterprise GitHub repository where you can read, fork, and create, pull-requests on our code. It works exactly like the open source. You can be as involved as you like.
- As much support as you need, to help with any issues that might arise, either with Chronicle FIX itself, or with your project as a whole. We understand that the FIX engine is usually only a small part of a system, and we can use our experience to help with latency issues with other parts of your project should you need it.
- A fair price. Although this is highly specialised software, we don’t charge a fortune for it, and we believe you will find us very competitive when compared to similar solutions.
How it Works
The parser has been optimised to accept fields in an expected order. Our default implementation has the order the fields as they appear in the fixprotocol.org documentation. However, the fields can be in any order allowed by FIX, but this may be a little slower.
For generating, you do the reverse. You call an interface which writes the FIX message as you add the fields. Ideally you call the fields in the expected order; this speeds up parsing.
- By recycling the buffer, and using object pools and mutable StringBuilders, we can send and receive messages end-to-end without significant garbage. Our target is less than one byte per message, on average.
- We design our systems to produce less than 1 GB/hour of garbage. This means that a 24 GB Eden space takes 24 hours to fill up.
- You can save around 0.2 microseconds if you drop checking, or computing, the byte sum.
Chronicle FIX offers:
- A low latency, recyclable, configurable FIX implementation for inbound FIX message parsing, and outbound FIX message transmission.
- Full FIX compatibility with FIX versions 4.0, 4.1, 4.2, 4.3, 4.4, and 5.0.
- Pre-allocates the memory for FixMessage objects. This is intended to reuse objects thus avoiding dynamic memory allocation.
- FIX parser, around 1 microsecond, 99.9% of the time for medium sized messages.
- FIX message generator, around 1 microsecond, 99.9% of the time for medium sized messages.
- Optional persistence of messages and latency checkpoints in, and out.
- Optimise latency for FIX in-order messages with fallback for out-of-order messages.
- Scalable to tens of connections per server, with minimal latency impact.
- Session handling; login, logout, and heartbeat.
- Integration with existing data structures in a zero-copy manner.
- High performance test client to drive the system to its limits.
- Tools for minimising garbage collection and enabling zero-copy.
- Optimise networking to work efficiently with Solarflare network cards.
The following functionality is planned for Chronicle FIX:
- :MIFID II support. For details of anticipated availability please contact firstname.lastname@example.org.