.li_facts { margin: 0 0 17px 0; }

In this article we list the main reasons that make CoralFIX a very fast and easy to use FIX engine.

• Network I/O: The most important part of a FIX engine in terms of performance is the network I/O library. That’s because FIX parsing can be done in nanoseconds while TCP latencies are in microseconds. So it is not enough to be super fast when parsing the FIX message while your bottleneck may be in the network I/O. In addition to parsing a FIX message very fast (in nanoseconds), CoralFIX uses CoralReactor under the hood, which brings our years of experience with Java NIO and network I/O. We provide our own selector implementation which is much faster than the standard JDK implementation.




• Non-Blocking I/O: CoralFIX is built from the ground up to use non-blocking sockets through Java NIO selectors. That has several advantages over blocking sockets:
  
  
  • Ultra-Low-Latency: Blocking sockets are very slow and can block for any arbitrary amount of time when you try to send and receive data. Non-blocking sockets on the other hand never block and sending/receiving data becomes as fast as simply copying data to/from the underlying native socket buffer.

  
  

  • Scalability: The same CoralFIX thread can not only handle hundreds of clients but it can also handle clients, servers and any mix of the two. For blocking sockets on the other hand, the old one-thread-per-client approach must be used, which is very hard to scale when the number of threads surpasses the number of available CPU cores. Thread pools or any other trick will not match the flexibility and scalability of non-blocking sockets running inside the same super-fast thread.

  
  

  • Simplicity: The single-threaded approach of CoralFIX eliminates all the issues that are so common to multithreaded programming. You suddenly don’t have to worry about thread synchronization, lock contention, race-conditions, deadlocks, thread starvation, context switches and many other pitfalls that arise when different threads need to coordinate and share state. Because CoralFIX clients and servers run inside the same thread, all these problems disappear and you can re-allocate your brain power to other tasks.




• Zero Garbage: All Coral Blocks components produce zero garbage for the GC in the critical path. With CoralFIX you are able to send/receive billions of messages without ever producing any garbage. No GC interruption, ever!




• Zero Depedencies: At Coral Blocks we use Java as a syntax language. Our libraries have zero external dependencies and we don’t even rely on the JDK standard libraries. With CoralFIX you have total control over the critical path.




• Zero Copy: When parsing a ByteBuffer into a FixMessage object, CoralFIX does not copy any bytes or create any objects. The resulting FixMessage object is backed up by the same ByteBuffer that was parsed. The parsing process simply delimits the tags and values of the FIX message. Moreover all values are lazy parsed, in other words, a price value won’t be parsed to a double until you explicitly call getDouble(FixTags.Price). Or you can call getByteBuffer(FixTags.Price) to return your value delimited in the original ByteBuffer, without any parsing.




• Thread Affinity: Although not a requirement, it is recommended that you pin your critical threads to dedicated cpu cores. CoralFIX supports thread affinity out-of-the-box and can pin your critical threads to the cpu cores you specify. To pin your critical threads, all you have to do is pass the cpu core id in the command-line options below:

-DnioReactorProcToBind=CORE_ID 
-DlogProcToBindAsyncThread=CORE_ID
-DfixStoreProcToBind=CORE_ID




• Kernel Bypass: CoralFIX is fully compatible with kernel bypass. We have the expertise with OpenOnLoad from SolarFlare and can help you with the setup/config to bypass the kernel and go straight to the network card buffers to save extra microseconds.




• Audit Logging: Audit logging is a necessity for production FIX clients and servers. CoralFIX supports audit logging out-of-the-box and can asynchronously audit log a message in nanoseconds. To audit log all messages from your fix connection, all you have to do is:

config.add("auditLog", true);




• Message Persistence: Although not always enforced, the FIX protocol specifies message retransmission for gap fills. When that’s in place, all application FIX messages sent must be persisted. CoralFIX supports messages persistence and retransmission out-of-the-box and can asynchronously persist application messages to disk in nanoseconds. To support persistence and to make your FIX client or server automatically retransmit messages through gap fills, all you need to do is:

config.add("supportPersistence", true);




• Sequences Persistence: CoralFIX persists both inbound and outbound sequences to disk in a asynchronous way, without introducing any latency to the FIX client. That’s important if your FIX client is restarted so it can remember that last sequences it used. To tell CoralFIX to persist the sequences to disk, all you have to do is:

config.add("persistSequences", true);




• FIX Versions: CoralFIX supports all FIX versions. To specify the version you want to use, all you have to do is:

config.add("fixVersion", FixVersions.VERSION_44);




• FIX Session Protocol: CoralFIX makes all the FIX session protocol details transparent to the developer. That means you don’t have to worry about sequences, resend requests, sequence resets, gap fills, logon, logout, heartbeats, test requests or any other low level FIX detail. With CoralFIX you only focus on your application logic. You can even start a FIX client with few lines of code:

NioReactor nio = NioReactor.create();
		
MapConfiguration config = new MapConfiguration();
config.add("fixVersion", FixVersions.VERSION_44);
config.add("senderComp", "testClient");

Client client = new FixApplicationClient(nio, "localhost", 45451, config);		
client.open();

nio.start();




• FIX Session Timers: CoralFIX supports session timers out-of-the-box so you can synchronize your FIX session with the exchange hours of operation. You can set daily and weekly timers to start or stop your FIX connection and optionally reset the sequences (defaults to true). To set a timer all you have to do is:

// add a start session timer daily at 14:30:00 EST
config.add("startSessionTimer", "D-EST-14:30:00");
 
// add a stop session timer weekly on Sunday at 16:00:00 EST
config.add("stopSessionTimer", "W-SUNDAY-EST-16:00:00");




• High Level API: CoralFIX provides a high-level and easy-to-use API based on our vast experience writing several different FIX trading gateways and market data feeds for all kinds of markets. We are constantly improving the API based on our customers feedback and our own research to make it even easier to understand and use. Below an example of how you would send a message from a CoralFIX client:

// Get a FIX message ready to be sent out, with sequences, header and everything taken care for you
FixMessage outFixMsg = getOutFixMessage(MsgTypes.NewOrderSingle);

// Add any kind of value as a tag
outFixMsg.add(Price, 50.34);
outFixMsg.add(ClOrdID, "A123");
outFixMsg.add(Side, '2');

// Add a repeating group
FixGroup partyIds = outFixMsg.createGroup(NoPartyIDs);
partyIds.nextElement().add(PartyID, "BLAH").add(PartyIDSource, 'D').add(PartyRole, 54);
partyIds.nextElement().add(PartyID, "TRD").add(PartyIDSource, 'D').add(PartyRole, 36);

// Send out the message to the client
send(outFixMsg);




• Benchmarks: Our clients can modify and run our benchmark source code on their own environment to access the performance numbers. We publish our numbers as a reference but we encourage our clients to benchmark CoralFIX themselves. They have been doing that and reporting back results that they are unable to get through other FIX engine alternatives, even in C++. In our lab, we are able to go as low as 4.8 micros for the one-way latency to send a FIX message from a client to a server over loopback. We have also used tcpdump and Wireshark to measure the tick-to-trade latencies and they are around 8 micros.




• Release Early, Release Often: We work very close to our customers and we are constantly listening to their feedback for improvements and new features. We have a quick release cycle and we release often to incorporate our customers needs as soon as they ask for them.




• Satisfied Customers: CoralFIX has been used in production by small and big companies for years with great results. Our customers are not only happy with better performance numbers, but they are also able to complete and deploy their projects more quickly, increasing their productivity and reducing time-to-market.

Conclusion

Although it is important for a FIX engine to be as fast as possible, and we got that covered through fast parsing and networking, at Coral Blocks we believe that ease of use is even more important. Not just CoralFIX but all of our components must be very easy to understand, integrate and use. Our licensing model also allows us to have a commitment to our clients in providing first-class support and to share our know-how throughout the license period. We are passionate about what we do and we enjoy working side-by-side with our clients to bring outstanding results.

FixApplicationClient and FixApplicationServer

By inheriting from FixApplicationClient you can code a fully functional FIX connection that will handle all the low-level session details of the FIX protocol like sequences, logon, resend requests, etc. All you have to do is handle the incoming application messages in any way you want. See an example below:

package com.coralblocks.coralfix.sample;

import static com.coralblocks.coralfix.FixTags.*;

import com.coralblocks.coralfix.FixConstants.FixVersions;
import com.coralblocks.coralfix.FixConstants.MsgTypes;
import com.coralblocks.coralfix.FixGroup;
import com.coralblocks.coralfix.FixMessage;
import com.coralblocks.coralfix.FixTag;
import com.coralblocks.coralfix.FixTags;
import com.coralblocks.coralfix.client.FixApplicationClient;
import com.coralblocks.coralreactor.client.Client;
import com.coralblocks.coralreactor.nio.NioReactor;
import com.coralblocks.coralreactor.util.Configuration;
import com.coralblocks.coralreactor.util.MapConfiguration;

public class SimpleFixApplicationClient extends FixApplicationClient {
	
	// Add any extra / non-standard fix tag from your spec, so you can work with the name instead of the id
	private static FixTag MySpecialTag = FixTags.addTag("MySpecialTag", 3434);
	
	public SimpleFixApplicationClient(NioReactor nio, String localhost, int port, Configuration config) {
	    super(nio, localhost, port, config);
    }
	
	@Override
	protected void handleOpened() {
		// client was opened and will now try to connect to its destination
		
		// do anything you want to do here...
	}
	
	@Override
	protected void handleClosed() {
		// client was closed, its connection was terminated and it will now sit idle
		
		// do anything you want to do here...
	}
	
	@Override
	protected void handleConnectionEstablished() {
		// socket connection was established but no login handshake was done yet
		
		// do anything you want to do here...
	}
	
	@Override
	protected void handleConnectionOpened() {
		// the FIX session handshake through LOGON messages was performed...
		// the client is now ready to start sending/receiving messages
		
		// do anything you want to do here...
	}
	
	@Override
	protected void handleConnectionReady() {
		// any sequence reset or re-send request have been processed at the session level...
		// the client is now ready to start sending/receiving any business application messages
		
		// do anything you want to do here...
		
		sendNewOrderSingle();
	}
	
	private void sendNewOrderSingle() {
		
		FixMessage outFixMsg = getOutFixMessage(MsgTypes.NewOrderSingle);
		
		// Add the tags you want to outFixMsg
		// NOTE: there is no need to add any session-level tags like MsgSeqNum, SenderCompID, etc.
		outFixMsg.add(Price, 50.34);
		outFixMsg.addTimestamp(TransactTime, System.currentTimeMillis());
		outFixMsg.add(ClOrdID, "A123");
		outFixMsg.add(MySpecialTag, 'Y');
		
		// Add a repeating group
		FixGroup partyIds = outFixMsg.createGroup(NoPartyIDs);
		partyIds.nextElement().add(PartyID, "BLAH").add(PartyIDSource, 'D').add(PartyRole, 54);
		partyIds.nextElement().add(PartyID, "TRD").add(PartyIDSource, 'D').add(PartyRole, 36);
		partyIds.nextElement().add(PartyID, "FOO").add(PartyIDSource, 'D').add(PartyRole, 7);
		
		// Send out the message to the client
		send(outFixMsg);
	}
	
	@Override
	protected void handleConnectionTerminated() {
		// the socket connection was broken/terminated
		
		// do anything you want to do here...
	}
	
	@Override
	protected void prepareLogon(FixMessage outFixMsg) {
		super.prepareLogon(outFixMsg);
		
		// add/remove any tag here... probably not necessary because the base
		// class is already adding all the required tags
	}
	
	@Override
	protected void handleFixApplicationMessage(FixMessage fixMsg, boolean possDupe) {
		
		// do what you have to do with this FIX application message
	}		
	
	public static void main(String[] args) {
		
		String senderComp = args.length > 0 ? args[0] : "testClient";
		
		NioReactor nio = NioReactor.create();
		
		MapConfiguration config = new MapConfiguration();
		
		// REQUIRED
		config.add("fixVersion", FixVersions.VERSION_44);
		
		// the senderComp of the fix client
		// REQUIRED
		config.add("senderComp", senderComp);
		
		// NOT required:
		// config.add("targetComp", "testAcct"); // the TargetCompID tag
		// config.add("senderSub", "xxx"); // the SenderSubID tag
		// config.add("targetSub", "yyy"); // the TargetSubID tag
		// config.add("senderLoc", "aaa"); // the SenderLocationID tag
		// config.add("heartbeat", "20"); // the HeartBtInt tag (defaults to 10 seconds)
		// config.add("encryption", "1"); // the EncryptMethod tag (defaults to 0)
		// config.add("username", "myusername"); // sends the Username tag with the Logon message
		// config.add("password", "mypass"); // the RawData tag (the RawDataLength tag will also be included)
		
		// print all messages received and sent to STDOUT for debugging purposes
		// (default is false)
		config.add("debugMessages", true);
		// config.add("debugHeartbeats", true); // show heartbeats as well (default is true)
		
		// send a ResetSeqNumFlag=Y on Logon to force a sequence reset on both sides (inbound and outbound)
		// (default is false)
		config.add("forceSeqReset", true);
		
		// turn on asynchronous audit logging
		// (default is false)
		config.add("auditLog", false);
		// config.add("auditLogDir", "/mylogdir/"); // set the folder where to save the audit log file (default is "auditLog")
		
		// turn on asynchronous fix logging (human readable fix messages)
		// (default is false)
		config.add("fixLog", false);
		// config.add("fixLogDir", "/mylogdir"); // set the folder where to save the fix log file (default is "fixLog")
		// config.add("fixLogHeartbeats", true); // log heartbeats to the fix log (default is false)
		
		// persist sequences asynchronously to a file, so you don't lose them across restarts
		// (default is false)
		config.add("persistSequences", false);
		// config.add("persistDir", "mySeqFolder"); // the folder where to store the sequence files (default is current dir)
		// config.add("persistFilename, "mySeqFilename"); // the filename of the sequence file (default is the client name)
		
		// persists outbound fix messages asynchronously for message resends / gap fills
		// (default is false)
		config.add("supportPersistence", false);
		
		// open the admin server to accept telnet connections to monitor and control this fix client
		// (default is false)
		config.add("adminServer", false);
		
		// change the port for the admin server
		// (default is 45441)
		config.add("adminServerPort", 45441);
		
		// change to put the outbound FIX store in another thread
		// (default is true)
		config.add("fixStoreAsync", false);
		
		// set heartbeat interval in seconds
		// (default is 10)
		config.add("heartbeat", 5);
		
		/*
		// More optional config parameters
		// IMPORTANT: The default values should be what you want most of the time!
		
		config.add("includeLastMsgSeqNumProcessedTag", false); // include this header tag on every fix message? (default is true)
		
		config.add("maxLogonAttempts", 10); // if Logon fail for whatever reason, retry (default is 5)
		
		config.add("secondsToReopenAfterClose", 60 * 10); // if can't logon, then client will be closed and re-open after N seconds (default is 300)
		
		config.add("sendLogoutOnClose", false); // on a client close, a logout message will be sent (default is false)
		
		config.add("sendLogonOnConnected", true); // when socket is estabilished send logon automatically (default is true)
		
		config.add("persistSequencesImmediately", false); // force the mmap file to commit the the sequences to disk immediately (default is false)
		
		config.add("sequence", 1); // the initial inbound sequence (default is 1 or whatever is persisted if persistence is on)
		
		config.add("outboundSeq", 1); // the initial outbound sequence (default is 1 or wahtever is persisted if persitence is on)
		
		config.add("acceptInboundSeqFromServer", false); // accept whatever sequence you get from server as your inbound sequence (default is false)
		
		config.add("disconnectOnGap", false); // disconnect on gap instead of sending a sequence reset / message retransmission (default is false)
		
		config.add("reconnectOnStartTimerEvent", true); // when using a start timer, reconnect if connected (default is true)
		
		config.add("resetSequencesOnStartTimerEvent", true); // when using a start timer, reset the sequences (default is true)
		 */
		
		/*
		// More optional config parameters related to the max size of FIX messages:
		
		config.add("fixMaxTags", 64); // max number of tags, not including tags from repeating groups (defaults to 64)
		config.add("fixMaxGroups", 8); // max number of different repeating groups a message can have (defaults to 8)
		config.add("fixMaxValueLength", 256); // max length of a tag value in characters (defaults to 256)
		config.add("fixMaxGroupElements", 64); // max number of repeating group elements (defaults to 64)
		config.add("fixMaxValuesPerGroupElement", 64); // max number of repeating group tags/values per group element (defaults to 64)
		 */
		
		Client client = new SimpleFixApplicationClient(nio, "localhost", 45451, config);
		client.open();
		
		nio.start();
	}
}

And same thing in the server side, by inheriting from FixApplicationServer:

package com.coralblocks.coralfix.sample;

import static com.coralblocks.coralfix.FixTags.*;

import java.util.Iterator;

import com.coralblocks.coralfix.FixConstants.FixVersions;
import com.coralblocks.coralfix.FixConstants.MsgTypes;
import com.coralblocks.coralfix.FixGroup;
import com.coralblocks.coralfix.FixGroupElement;
import com.coralblocks.coralfix.FixMessage;
import com.coralblocks.coralfix.FixTag;
import com.coralblocks.coralfix.FixTags;
import com.coralblocks.coralfix.server.FixApplicationServer;
import com.coralblocks.coralreactor.client.Client;
import com.coralblocks.coralreactor.nio.NioReactor;
import com.coralblocks.coralreactor.util.Configuration;
import com.coralblocks.coralreactor.util.MapConfiguration;

public class SimpleFixApplicationServer extends FixApplicationServer {
	
	// Add any extra / non-standard fix tag from your spec, so you can work with the name instead of the id
	private static FixTag MySpecialTag = FixTags.addTag("MySpecialTag", 3434);

	public SimpleFixApplicationServer(NioReactor nio, int port, Configuration config) {
		super(nio, port, config);
		
	    // Specify the repeating group you expect to parse, for each message type:
	    addGroupTemplate(MsgTypes.NewOrderSingle, NoPartyIDs, PartyID, PartyIDSource, PartyRole);
	    
	   /* Explanation about addGroupTemplate above:
        *
        * MsgTypes.NewOrderSingle is the message type containing the repeating group
        *    
        * NoPartyIDs is the main repeating group tag, meaning the repeating groups will
        * start after that tag. This tag contains the number (i.e. an integer) of repeating groups that follow.
        *
        * PartyID is the very first tag that every repeating group will have. That's important
        * to correctly denote the starting of a new repeating group and is enforced by the
        * FIX spec (i.e. you can't start a new repeating group with another tag)
        *
        * PartyIDSource, PartyRole, etc. are all the other tags (not included the very first
        * one above) that this repeating group can contain. They can be specified in any order
        * and can appear in the repeating group in any order. They are also all optional, in other words,
        * they do not need to appear in the FIX message BUT THEY DO HAVE TO BE SPECIFIED HERE, ALL OF THEM.
        */
    }
	
	@Override
	protected void handleOpened() {
		// sever was opened and will now accept connections from clients...
		
		// do anything you want to do here...
	}
	
	@Override
	protected void handleClosed() {
		// server was closed, all clients were disconnected and it will not accept any connection...
		
		// do anything you want to do here...
	}
	
	@Override
	protected void handleConnectionEstablished(Client client) {
		// socket connection was established for a client but no login handshake was done yet
		
		// do anything you want to do here...
	}
	
	@Override
	protected void handleConnectionOpened(Client client) {
		// the FIX session handshake through LOGON messages was performed for this client...
		// the client is now ready to start sending/receiving messages
		
		// do anything you want to do here...
	}
	
	@Override
	protected void handleConnectionReady(Client client) {
		// any sequence reset or re-send request have been processed at the session level...
		// the client is now ready to start sending/receiving any business application messages
		
		// do anything you want to do here...
	}
	
	@Override
	protected void handleConnectionTerminated(Client client) {
		// the socket connection was broken/terminated for this client
		
		// do anything you want to do here...
	}
	
	@Override
	protected void handleFixApplicationMessage(Client client, FixMessage fixMsg, boolean possDupe) {
		
		// do whatever you want to do with the application message received from this client...
		
		if (fixMsg.checkType(MsgTypes.NewOrderSingle)) {
			
			double price = fixMsg.getDouble(Price);
			System.out.println("Read price: " + price);
			
			CharSequence clOrdID = fixMsg.getCharSequence(ClOrdID);
			System.out.println("Read ClOrdID: " + clOrdID);
			
			char mySpecialTag = fixMsg.getChar(MySpecialTag);
			System.out.println("Read MySpecialTag: " + mySpecialTag);
			
			FixGroup fixGroup = fixMsg.getGroup(NoPartyIDs);
			System.out.println(fixGroup.getNumberOfElements());
		 
			// you can also print the whole fix group for debugging purposes:
			System.out.println(fixGroup);
		         
	        Iterator<FixGroupElement> iter = fixGroup.iterator();
		         
	        while(iter.hasNext()) {
	             
	            FixGroupElement elem = iter.next();
	            
	            CharSequence partyID = elem.getCharSequence(PartyID);
	            System.out.println(partyID);
	            
	            char partyIDSource = elem.getChar(PartyIDSource);
	            System.out.println(partyIDSource);
	            
	            int partyRole = elem.getInt(PartyRole);
	            System.out.println(partyRole);
	             
	            // you can also print the whole element for debugging purposes:
	            System.out.println(elem);
	        }
		}
	}
	
	public static void main(String[] args) {

		NioReactor nio = NioReactor.create();
		
		MapConfiguration config = new MapConfiguration();
		
		// REQUIRED
		config.add("fixVersion", FixVersions.VERSION_44);
		
		// print all messages received and sent to STDOUT for debugging purposes
		// (default is false)
		config.add("debugMessages", true);
		
		// accept as the client inbound sequence whatever sequence I receive in the first message coming from the client
		// (default is false)
		config.add("acceptInboundSeqFromClient", false);
		
		// turn on asynchronous audit logging
		// (default is false)
		config.add("auditLog", false);
		
		// turn on asynchronous fix logging (human readable fix messages)
		// (default is false)
		config.add("fixLog", false);
		
		// persist all sequences from all clients (senderCompIDs) to disk
		// (default is false)
		config.add("persistSequences", false);
		
		// support persistence of outbound fix messages for message resends / gap fills
		// (default is false)
		config.add("supportPersistence", false);
		
		// enable the telnet admin server
		// (default is false)
		config.add("adminServer", false);
		
		// change the port for the admin server
		// (default is 45442)
		config.add("adminServerPort", 45442);
		
		// change to put the outbound FIX store in another thread
		// (default is true)
		config.add("fixStoreAsync", false);
		
		FixApplicationServer server = new SimpleFixApplicationServer(nio, 45451, config);
		server.open();

		nio.start();
	}
}

Conclusion

CoralFIX is fully integrated with CoralReactor so you can easily code your own FIX clients and servers. Furthermore, it takes care of all the low-level session details of the FIX protocol for you, so all you have to do is handle messages in the application level.

Working with FixMessages

package com.coralblocks.coralfix.sample;

import static com.coralblocks.coralfix.FixTags.*;

import java.nio.ByteBuffer;

import com.coralblocks.coralbits.util.ByteBufferUtils;
import com.coralblocks.coralfix.FixConstants.FixVersions;
import com.coralblocks.coralfix.FixConstants.MsgTypes;
import com.coralblocks.coralfix.FixMessage;
import com.coralblocks.coralfix.FixParser;

public class Sample {

	public static void main(String[] args) {

		FixMessage fixOutMsg = new FixMessage(FixVersions.VERSION_42);
		// or
		// FixMessage fixOutMsg = new FixMessage(); // defaults to VERSION_44 (you can change the default with -DfixDefaultVersion=50)
		
		fixOutMsg.add(MsgType, MsgTypes.Logon);
		// or
		// fixOutMsg.add(MsgType, 'A'); // same thing as above
		
		fixOutMsg.add(SenderCompID, "TTTTTTT6"). add(TargetCompID, "TAL").add(5555, 3.14).add(34, "1");
		// fluent API
		// you can add by tag name (enum) and tag id (integer)

		fixOutMsg.addTimestamp(SendingTime, System.currentTimeMillis()); // UTC time zone by default...
		// timestamps are automatically converted to the FIX format YYYYMMdd HH:mm:ss.SSS
		// or if you need a different time zone:
		// fixOutMsg.addTimestamp(SendingTime, System.currentTimeMillis(), TimeZone.getTimeZone("EST"));
		
		
		fixOutMsg.add(7777, 'Y').add(TargetSubID, "ARCA").add(108, 60).add(98,  0);

		// you can print the full message for debugging purposes:
		System.out.println(fixOutMsg);
		// prints BeginString(8)=FIX.4.2 BodyLength(9)=97 MsgType(35)=Logon("A") SenderCompID(49)=TTTTTTT6 TargetCompID(56)=TAL Unknown(5555)=3.14000000 MsgSeqNum(34)=1 SendingTime(52)=20140707-19:37:11.429 Unknown(7777)=Y TargetSubID(57)=ARCA HeartBtInt(108)=60 EncryptMethod(98)=0
		
		ByteBuffer bb = ByteBuffer.allocate(1024);
		
		fixOutMsg.writeTo(bb); // write complete fix message to the ByteBuffer...
		
		bb.flip();

		// you can also print the ByteBuffer for debugging purposes:
		ByteBufferUtils.println(bb); // ByteBufferUtils.println does not change the ByteBuffer position...
		// prints [8=FIX.4.2
9=97
35=A
49=TTTTTTT6
56=TAL
5555=3.14000000
34=1
52=20140707-19:37:11.429
7777=Y
57=ARCA
108=60
98=0
10=160
]
		// note: SOH character which separates tags is a non-ascii character so you don't see it...

		FixParser parser = new FixParser();

		FixMessage fixMsg = parser.parse(bb);

		// passing the tag name as an enum
		System.out.println(fixMsg.getInt(BodyLength));
		// prints 80
		// BodyLength = tag 9

    	// you can also pass the tag name as a String
		System.out.println(fixMsg.getLong("HeartBtInt")); 
		// prints 60
    	// HeartBtInt = tag 108

		// you can also pass the tag id
		System.out.println(fixMsg.getDouble(5555)); 
		// prints 3.14

		// gets timestamp as epoch UTC long
		System.out.println(fixMsg.getTimestamp(SendingTime)); 
		// prints 1104411600000

		// gets the timestamp as a CharSequence
		System.out.println(fixMsg.getCharSequence(SendingTime));
		// prints 20140707-19:42:57.002

    	// gets a single char
		System.out.println(fixMsg.getChar(7777)); 
		// prints Y

	    // gets value as a CharSequence
		System.out.println(fixMsg.getCharSequence(BeginString)); 
		// prints FIX.4.2
	    // BeginString = tag 8
		
		// gets a ByteBuffer with the value
		System.out.println(fixMsg.getByteBuffer(BeginString));
		// prints java.nio.HeapByteBuffer[pos=2 lim=9 cap=109]

		// prints the whole message for debugging purposes
		System.out.println(fixMsg);
		// prints BeginString(8)=FIX.4.2 BodyLength(9)=109 BeginString(8)=FIX.4.2 BodyLength(9)=87 MsgType(35)=Logon("A") SenderCompID(49)=TTTTTTT6 TargetCompID(56)=TAL Unknown(5555)=3.14 MsgSeqNum(34)=1 SendingTime(52)=20041230-13:00:00 Unknown(7777)=Y TargetSubID(57)=ARCA HeartBtInt(108)=60 EncryptMethod(98)=0 CheckSum(10)=009
	}
}

Notice above that you can add fix tag values to a FixMessage by passing the tag directly (as a Java enum) or the tag id (as an int). The tag values can be passed in a variety of formats from primitives to CharSequences. You can also chain many add methods in the same line (fluent API).

In the other hand, when getting the fix tag values from the FixMessage, you can fetch them in a variety of formats, from primitive values (no garbage is created when parsing primitives) to String and ByteBuffer objects. To get the values you can pass the tag directly (as a Java enum), the tag name (as a String) or the tag id (as an int).

The whole FixMessage can also be printed for debugging purposes through its toString method.

Working with FIX tags and MsgTypes

The class FixTags defines most of the FIX tags by id as specified by the standard FIX dictionary. As we did in our first example above, you can statically import FixTags.* to use fix tags straight in your code by their names (i.e. java enums). Of course you can also add new tags. Below some examples:

import static com.coralblocks.coralfix.FixTags.*;

// the flexibility and convenience of Java enumerations:
System.out.println(AllocAccount); // => AllocAccount(79)

// you can get a FixTag by its id:
System.out.println(fromId(79)); // => AllocAccount(79)

// you can get a FixTag by its name:
System.out.println(fromName("AllocAccount")); // => AllocAccount(79)

// you can define new FixTags easily:
System.out.println(fromName("SuperTag")); // => null
addTag("SuperTag", 6767);
System.out.println(fromName("SuperTag")); // => SuperTag(6767)

// now instead of using the string "SuperTag" everywhere,
// you can create a variable to use instead
private final static FixTag SuperTag = addTag("SuperTag", 6767);
// then use everywhere the variable instead of the string
fixMsg.add(SuperTag, "aValue"); // instead of fixMsg.add("SuperTag", "aValue");
// same thing when getting:
fixMsg.getCharSequence(SuperTag); // instead of fixMsg.getCharSequence("SuperTag");

// you can check if a tag is defined by name and id:
System.out.println(isDefined("BeginString")); // => true
System.out.println(isDefined(79)); // => true
System.out.println(isDefined("blahblah")); // => false
System.out.println(isDefined(8888)); // => false

// and you can print all tags if you want to:
printAll();

By statically importing FixConstants.*, the same can be done for MsgTypes in case you need to define any new one that is not already defined:

import static com.coralblocks.coralfix.FixConstants.*;

System.out.println(MsgTypes.NewOrderSingle); // => NewOrderSingle("D")

// but you can also add new ones:
MsgTypes.add("MyMessageType", "t");
MsgTypes.add("SomeOtherType", "tx");

System.out.println(MsgTypes.fromValue("t")); // => MyMessageType("t")
System.out.println(MsgTypes.fromValue("tx")); // => SomeOtherType("tx")

System.out.println(MsgTypes.fromName("MyMessageType")); // => MyMessageType("t")
System.out.println(MsgTypes.fromName("SomeOtherType")); // => SomeOtherType("tx")

System.out.println(MsgTypes.isValueDefined("t")); // => true
System.out.println(MsgTypes.isNameDefined("SomeOtherType")); // => true

Working with repeating groups

CoralFIX makes it very easy and straightforward to work with FIX repeating groups, even in the situation where you have repeating groups inside repeating groups. See the examples below:

package com.coralblocks.coralfix;

import static com.coralblocks.coralfix.FixConstants.MsgTypes.*;
import static com.coralblocks.coralfix.FixTags.*;

import java.nio.ByteBuffer;
import java.util.Iterator;

public class Sample3 {

	public static void main(String[] args) {
		
		FixMessage fixOutMsg = new FixMessage();

		fixOutMsg.add(MsgType, QuoteStatusRequest);
		
		fixOutMsg.add(SenderCompID, "TTTTTTT6"). add(TargetCompID, "TAL").add(5555, 3.14).add(34, 1);
		fixOutMsg.addTimestamp(SendingTime, System.currentTimeMillis());
		fixOutMsg.add(7777, 'Y').add(TargetSubID, "ARCA").add(108, 60).add(98,  0);
		
		FixGroup fixGroup = fixOutMsg.createGroup(NoRelatedSym);
		
		// group element 1:
		fixGroup.nextElement().add(Symbol, "AAPL").add(SettlDate, 1).add(SecurityDesc, "blah1");
		
		// group element 2:
		FixGroupElement fixGroupElem = fixGroup.nextElement();
		fixGroupElem.add(Symbol, "IBM").add(SettlDate, 2).add(SecurityDesc, "blah2");

		// group element 3:
		fixGroupElem = fixGroup.nextElement();
		fixGroupElem.add(Symbol, "LDK");
		fixGroupElem.add(SettlDate, 3).add(SecurityDesc, "blah3");
		
		// group element 4:
		fixGroup.nextElement().add(Symbol, "FB").add(SettlDate, 4).add(SecurityDesc, "blah4");
		
		System.out.println(fixOutMsg); // for debugging purposes...
		
		ByteBuffer bb = ByteBuffer.allocate(1024);
		
		fixOutMsg.writeTo(bb); // write complete fix message to the ByteBuffer...
		
		bb.flip();

		FixParser parser = new FixParser();
		
		// define a repeating group for a message type:
		parser.addGroupTemplate(QuoteStatusRequest, NoRelatedSym, Symbol, SettlDate, SecurityDesc);
	       
         	/* Explanation about addGroupTemplate above:
         	*
         	* QuoteStatusRequest is the message type containing the repeating group
         	*    
         	* NoRelatedSym is the main repeating group tag, meaning the repeating groups will
         	* start after that tag. This tag contains the number (i.e. an integer) of repeating groups that follow.
         	*
         	* Symbol is the very first tag that every repeating group will have. That's important
         	* to correctly denote the starting of a new repeating group and is enforced by the
         	* FIX spec (i.e. you can't start a new repeating group with another tag)
         	*
         	* SettlDate, SecurityDesc, etc. are all the other tags (not included the very first
         	* one above) that this repeating group can contain. They can be specified in any order
         	* and can appear in the repeating group in any order. They are also all optional, in other words,
         	* they do not need to appear in the FIX message but they do have to be specified here.
         	*/
		
		FixMessage fixMsg = parser.parse(bb);
		
		fixGroup = fixMsg.getGroup(NoRelatedSym);
		
		System.out.println(fixGroup.getNumberOfElements()); // => 4

		// you can also print the whole fix group for debugging purposes:
		System.out.println(fixGroup);
		// Symbol(55)=AAPL SettlDate(64)=1 SecurityDesc(107)=blah1 | Symbol(55)=IBM SettlDate(64)=2 SecurityDesc(107)=blah2 | Symbol(55)=LDK SettlDate(64)=3 SecurityDesc(107)=blah3 | Symbol(55)=FB SettlDate(64)=4 SecurityDesc(107)=blah4
		
		System.out.println();
		
		Iterator<FixGroupElement> iter = fixGroup.iterator();
		
		while(iter.hasNext()) {
			
			FixGroupElement elem = iter.next();
			
			// fetch fix tag values as usual:
			System.out.println(elem.getCharSequence(Symbol));
			System.out.println(elem.getInt("SettlDate"));
			System.out.println(elem.getCharSequence(107));
			
			// you can also print the whole element for debugging purposes:
			System.out.println(elem);
			System.out.println();
		}
	}
}

When it comes to building a FixMessage with a repeating group, you just create a FixGroup in the message and then call nextElement() on the FixGroup to create a new FixGroupElement with as many tags as you want. Each FixGroupElement will have the repeating tags of the group and you don’t need to specify the number of repeating groups (i.e. the value of tag NoRelatedSym above) because this is done automatically by counting the number of FixGroupElements created.

When it comes to parsing, the most important part of the code above is where the fix repeating group is specified. The line means: message type QuoteStatusRequest has a repeating group defined by tag NoRelatedSym (specifies the number of repeating group elements) with the following possible tags: Symbol (first and mandatory for all elements), SettlDate and SecurityDesc.

Groups inside groups

A FIX message can contain repeating groups inside repeating groups. CoralFIX makes it very easy to deal with that situation as well. See the examples below:

package com.coralblocks.coralfix;

import static com.coralblocks.coralfix.FixConstants.MsgTypes.*;
import static com.coralblocks.coralfix.FixTags.*;

import java.nio.ByteBuffer;
import java.util.Iterator;

public class Sample4 {

	public static void main(String[] args) {
		
		FixMessage fixOutMsg = new FixMessage();

		fixOutMsg.add(MsgType, QuoteStatusRequest);
		
		fixOutMsg.add(SenderCompID, "TTTTTTT6"). add(TargetCompID, "TAL").add(5555, 3.14).add(34, 1);
		fixOutMsg.addTimestamp(SendingTime, System.currentTimeMillis());
		fixOutMsg.add(7777, 'Y').add(TargetSubID, "ARCA").add(108, 60).add(98,  0);
		
		FixGroup fixGroup = fixOutMsg.createGroup(NoRelatedSym);
		
		FixGroupElement elem;
		
		FixGroup subgroup;
		
		// group element 1:
		elem = fixGroup.nextElement();
		elem.add(Symbol, "AAPL").add(SettlDate, 1).add(SecurityDesc, "blah1");
		// subgroup with 2 elements:
		subgroup = elem.createGroup(NoTestSubgroup);
		subgroup.nextElement().add(TestTag1, "foo111").add(TestTag2, "foo112");
		subgroup.nextElement().add(TestTag1, "foo121").add(TestTag2, "foo122");
		
		// group element 2:
		elem = fixGroup.nextElement();
		elem.add(Symbol, "IBM").add(SettlDate, 2).add(SecurityDesc, "blah2");
		// subgroup with 3 elements:
		subgroup = elem.createGroup(NoTestSubgroup);
		subgroup.nextElement().add(TestTag1, "foo211").add(TestTag2, "foo212");
		subgroup.nextElement().add(TestTag1, "foo221").add(TestTag2, "foo222");
		subgroup.nextElement().add(TestTag1, "foo231").add(TestTag2, "foo232");

		// group element 3:
		elem = fixGroup.nextElement();
		elem.add(Symbol, "LDK").add(SettlDate, 3).add(SecurityDesc, "blah3");
		// subgroup with 1 element:
		subgroup = elem.createGroup(NoTestSubgroup);
		subgroup.nextElement().add(TestTag1, "foo311").add(TestTag2, "foo312");
		
		// group element 4:
		elem = fixGroup.nextElement();
		elem.add(Symbol, "FB").add(SettlDate, 4).add(SecurityDesc, "blah4");
		// subgroup with 2 elements:
		subgroup = elem.createGroup(NoTestSubgroup);
		subgroup.nextElement().add(TestTag1, "foo411").add(TestTag2, "foo412");
		subgroup.nextElement().add(TestTag1, "foo421").add(TestTag2, "foo422");

		System.out.println(fixOutMsg); // for debugging purposes...
		
		ByteBuffer bb = ByteBuffer.allocate(1024);
		
		fixOutMsg.writeTo(bb); // write complete fix message to the ByteBuffer...
		
		bb.flip();
		
		FixParser parser = new FixParser();
		
		// define a repeating group for a message type:
		parser.addGroupTemplate(QuoteStatusRequest, NoRelatedSym, Symbol, SettlDate, SecurityDesc, NoTestSubgroup);
		parser.addSubgroupTemplate(NoRelatedSym, NoTestSubgroup, TestTag1, TestTag2, TestTag3, TestTag10, TestTag8);

		/*
		* Explanation about the addSubgroupTemplate above:
		* 
		* NoRelatedSym is the parent repeating group, in other words, the repeating group that will 
		* contain another repeating group.
		* It will most likely have been specified by a previous addGroupTemplate method.
		* 
		* NoTestSubgroup is the main repeating group tag, meaning the repeating groups will
		* start after that tag. This tag contains the number (i.e. an integer) of repeating groups that follow.
		* 
		* TestTag1 is the very first tag that every repeating group will have. That's important
		* to correctly denote the starting of a new repeating group and is enforced by the
		* FIX spec (i.e. you can't start a new repeating group with another tag)
		* 
		* TestTag2, TestTag3, TestTag10, TestTag8 are all the other tags (not included the very first
		* one above) that this repeating group can contain. They can be specified in any order
		* and can appear in the repeating group in any order. They are also all optional, in other words,
		* they do not need to appear in the FIX message but they do have to be specified here.
		*/
		
		FixMessage fixMsg = parser.parse(bb);
		fixGroup = fixMsg.getGroup(NoRelatedSym);
		
		Iterator<FixGroupElement> iter = fixGroup.iterator();
		
		while(iter.hasNext()) {
			
			elem = iter.next();
			
			// fetch fix tag values as usual:
			System.out.println(elem.getCharSequence(Symbol));
			System.out.println(elem.getInt("SettlDate"));
			System.out.println(elem.getCharSequence(107));
			
			// you can also fetch a group as usual from the group
			subgroup = elem.getGroup(NoTestSubgroup);

			Iterator<FixGroupElement> iter2 = subgroup.iterator();
			
			while(iter2.hasNext()) {
				
				FixGroupElement e = iter2.next();
				
				// and you can fetch the fix tag values as usual:
				System.out.println(e.getCharSequence(TestTag1));
				System.out.println(e.getCharSequence(TestTag2));
			}
			
			System.out.println();
		}
	}
}

When it comes to building a FixMessage, you can add a subgroup by calling createGroup on a FixGroupElement. Then you just call nextElement() and add the values as usual. When it comes to parsing, the most important part of the code above is where the fix repeating subgroup is specified. This line means: the group NoRelatedSym can contain a subgroup defined by tag NoTestSubgroup (specifies the number of repeating subgroup elements) with the following possible tags: TestTag1 (first and mandatory for all elements) and TestTag2. Also note that we must also include the new tag NoTestSubgroup in the group template list for the group NoRelatedSym.

Conclusion

CoralFIX makes it very easy to parse fix messages. The API comes with the most common fix tags and you can easily define new ones as needed. Working with fix tags is very easy because they are all Java enumerations that you can use directly inside your code. CoralFix also provides a simple and fast API to fetch fix tag values from fix messages, fix repeating groups and even from groups inside groups. The library is an ultra-low-latency Coral Blocks component that has minimal variance and produces zero garbage.

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

Simple FIX Message

For our test we randomize 2.5 million FIX messages like the one below:

BeginString(8)=FIX.4.2 BodyLength(9)=101 MsgType(35)=SecurityStatusRequest("e") SenderCompID(49)=TTTTTTT6 TargetCompID(56)=872 
Unknown(5555)=6236.83333333 MsgSeqNum(34)=99 SendingTime(52)=20140709-14:43:12.934 Unknown(7777)=Y TargetSubID(57)=ARCA 
HeartBtInt(108)=60 EncryptMethod(98)=0 CheckSum(10)=114

From FixMessage to ByteBuffer:

Messages: 2,500,000
Avg Time: 474.51 nanos
Min Time: 443.0 nanos
Max Time: 38.514 micros
Garbage: no garbage created for the GC
75% = [avg: 470.0 nanos, max: 475.0 nanos]
90% = [avg: 471.0 nanos, max: 481.0 nanos]
99% = [avg: 473.0 nanos, max: 522.0 nanos]
99.9% = [avg: 473.0 nanos, max: 632.0 nanos]
99.99% = [avg: 474.0 nanos, max: 1.671 micros]
9.999% = [avg: 474.0 nanos, max: 3.557 micros]

From ByteBuffer to FixMessage:

Messages: 2,500,000
Avg Time: 481.55 nanos
Min Time: 438.0 nanos
Max Time: 8.929 micros
Garbage: no garbage created for the GC
75% = [avg: 475.0 nanos, max: 499.0 nanos]
90% = [avg: 478.0 nanos, max: 501.0 nanos]
99% = [avg: 480.0 nanos, max: 521.0 nanos]
99.9% = [avg: 480.0 nanos, max: 644.0 nanos]
99.99% = [avg: 481.0 nanos, max: 1.71 micros]
99.999% = [avg: 481.0 nanos, max: 3.345 micros]

FIX message with repeating groups

For our test we randomize 2.5 million FIX messages like the one below:

BeginString(8)=FIX.4.2 BodyLength(9)=157 MsgType(35)=QuoteStatusRequest("a") SenderCompID(49)=TTTTTTT6 TargetCompID(56)=44611
Unknown(5555)=11855.33 MsgSeqNum(34)=58 SendingTime(52)=20140709-15:01:26.209 
[NoRelatedSym(146)=2 | Symbol(55)=AAPL FutSettDate(64)=65912 SecurityDesc(107)=blah1 | Symbol(55)=IBM FutSettDate(64)=56132 SecurityDesc(107)=blah2] 
Unknown(7777)=Y TargetSubID(57)=ARCA HeartBtInt(108)=60 EncryptMethod(98)=0 CheckSum(10)=114

From FixMessage to ByteBuffer:

Messages: 2,500,000
Avg Time: 879.73 nanos
Min Time: 818.0 nanos
Max Time: 15.48 micros
Garbage: no garbage created for the GC
75% = [avg: 869.0 nanos, max: 888.0 nanos]
90% = [avg: 873.0 nanos, max: 903.0 nanos]
99% = [avg: 877.0 nanos, max: 956.0 nanos]
99.9% = [avg: 878.0 nanos, max: 1.26 micros]
99.99% = [avg: 879.0 nanos, max: 2.733 micros]
99.999% = [avg: 879.0 nanos, max: 4.483 micros]

From ByteBuffer to FixMessage:

Messages: 2,500,000
Avg Time: 1.132 micros
Min Time: 1.044 micros
Max Time: 13.381 micros
Garbage: no garbage created for the GC
75% = [avg: 1.118 micros, max: 1.146 micros]
90% = [avg: 1.124 micros, max: 1.165 micros]
99% = [avg: 1.129 micros, max: 1.224 micros]
99.9% = [avg: 1.13 micros, max: 1.646 micros]
99.99% = [avg: 1.131 micros, max: 3.947 micros]
99.999% = [avg: 1.132 micros, max: 5.948 micros]

Note: This shows a known weakness of the FIX protocol: parsing repeating groups is expensive.

FIX message with repeating groups inside repeating groups

For our test we randomize 2.5 million FIX messages like the one below:

BeginString(8)=FIX.4.2 BodyLength(9)=272 MsgType(35)=QuoteStatusRequest("a") SenderCompID(49)=TTTTTTT6 TargetCompID(56)=63016 
Unknown(5555)=4592.00 MsgSeqNum(34)=64 SendingTime(52)=20140709-19:38:42.653 
[NoRelatedSym(146)=2 | 
Symbol(55)=AAPL FutSettDate(64)=61245 SecurityDesc(107)=blah1 
[NoTestSubgroup(10000)=2 | TestTag1(10001)=61245 TestTag2(10002)=21785 | TestTag1(10001)=foo421 TestTag2(10002)=foo422] | 
Symbol(55)=IBM FutSettDate(64)=21785 SecurityDesc(107)=blah2 
[NoTestSubgroup(10000)=2 | TestTag1(10001)=15732 TestTag2(10002)=39740 | TestTag1(10001)=foo421 TestTag2(10002)=foo422]] 
Unknown(7777)=Y TargetSubID(57)=ARCA HeartBtInt(108)=60 EncryptMethod(98)=0 CheckSum(10)=114

From FixMessage to ByteBuffer:

Messages: 2,500,000
Avg Time: 1.792 micros
Min Time: 1.656 micros
Max Time: 14.2 micros
Garbage: no garbage created for the GC
75% = [avg: 1.771 micros, max: 1.815 micros]
90% = [avg: 1.78 micros, max: 1.844 micros]
99% = [avg: 1.788 micros, max: 1.92 micros]
99.9% = [avg: 1.79 micros, max: 2.106 micros]
99.99% = [avg: 1.791 micros, max: 5.73 micros]
99.999% = [avg: 1.791 micros, max: 6.249 micros]

From ByteBuffer to FixMessage:

Messages: 2,500,000
Avg Time: 1.932 micros
Min Time: 1.832 micros
Max Time: 16.903 micros
Garbage: no garbage created for the GC
75% = [avg: 1.913 micros, max: 1.95 micros]
90% = [avg: 1.921 micros, max: 1.976 micros]
99% = [avg: 1.928 micros, max: 2.084 micros]
99.9% = [avg: 1.93 micros, max: 2.319 micros]
99.99% = [avg: 1.931 micros, max: 5.932 micros]
99.999% = [avg: 1.932 micros, max: 6.324 micros]

Note: This shows a known weakness of the FIX protocol: parsing repeating groups is expensive.

To test the performance of CoralFIX + CoralReactor we have developed a simple test with a fix server and a fix client. The client connects to the server, the standard FIX handshake through LOGON messages happens and the server proceeds to send 2 million FIX messages to the client. So we are measuring one-way latency from FIX server to FIX client over loopback. For a throughput benchmark instead you can check this article. Note that the server only sends the next message to the client when it gets a message back from it so we can correctly measure the time it takes for each message in isolation to travel from the server to the client. We then compute the average latency, which includes the full CoralFIX parsing time (i.e. encoding and decoding of the FIX message) plus the full CoralReactor TCP network I/O time. Below we present the latency results and the source code.

NOTE: If you want to check the benchmark of just the CoralFIX parser without any network I/O code (i.e. without CoralReactor) you can check this article.

The Results

Messages: 1,800,000 (one-way)
Avg Time: 4.774 micros
Min Time: 4.535 micros
Max Time: 69.516 micros
Garbage created: ZERO
75% = [avg: 4.712 micros, max: 4.774 micros]
90% = [avg: 4.726 micros, max: 4.825 micros]
99% = [avg: 4.761 micros, max: 5.46 micros]
99.9% = [avg: 4.769 micros, max: 7.07 micros]
99.99% = [avg: 4.772 micros, max: 9.481 micros]
99.999% = [avg: 4.773 micros, max: 24.017 micros]

The machine used for the benchmarks was an Intel i7 (4 x 3.5GHz) Ubuntu box overclocked to 4.5GHz.

The Source Code

The server:

package com.coralblocks.coralfix.bench.latency;

import com.coralblocks.coralfix.FixConstants;
import com.coralblocks.coralfix.FixMessage;
import com.coralblocks.coralfix.FixTags;
import com.coralblocks.coralfix.server.FixApplicationServer;
import com.coralblocks.coralreactor.client.Client;
import com.coralblocks.coralreactor.nio.NioReactor;
import com.coralblocks.coralreactor.server.Server;
import com.coralblocks.coralreactor.util.Configuration;
import com.coralblocks.coralreactor.util.MapConfiguration;

public class FixLatencyOneWayServer extends FixApplicationServer {
	
	// java -Xms6g -Xmx8g -server -verbose:gc -Xbootclasspath/p:../CoralReactor-boot-jdk7/target/coralreactor-boot-jdk7.jar -cp target/coralfix-all.jar:lib/jna-3.5.1.jar -DnioReactorProcToBind=2 com.coralblocks.coralfix.bench.latency.FixLatencyOneWayServer
	
	private long id;
	
	public FixLatencyOneWayServer(NioReactor nio, int port, Configuration config) {
	    super(nio, port, config);
    }

	@Override
    protected void handleConnectionOpened(Client client) {
		this.id = 1;
		send(client);
	}
	
	@Override
    protected void handleFixApplicationMessage(Client client, FixMessage fixMsg, boolean possDupe) {
	    send(client);
    }

	private final void send(Client client) {
		
		FixMessage fixOutMsg = getOutFixMessage(client, FixConstants.MsgTypes.ExecutionReport);
		fixOutMsg.addTimestamp(FixTags.TransactTime, nio.currentTimeMillis());
		fixOutMsg.add(FixTags.Account, "01234567");
		fixOutMsg.add(FixTags.OrderQty, 50);
		fixOutMsg.add(FixTags.Price, 400.5);
		fixOutMsg.add(FixTags.ClOrdID, id++);
		fixOutMsg.add(FixTags.HandlInst, '1');
		fixOutMsg.add(FixTags.OrdType, '2');
		fixOutMsg.add(FixTags.Side, '1');
		fixOutMsg.add(FixTags.Symbol, "OC");
		fixOutMsg.add(FixTags.Text, "NIGEL");
		fixOutMsg.add(FixTags.TimeInForce, '0');
		fixOutMsg.add(FixTags.SecurityDesc, "AOZ3 C02000");
		fixOutMsg.add(FixTags.SecurityType, 'O');
		// Note: contrary to popular belief, System.nanoTime() is consistency across CPU cores
		// and can be used to measure one-way latency without any problems. We have also used
		// native rdtsc timers with very similar latency results.
		fixOutMsg.add(7676, System.nanoTime());
	
		send(client, fixOutMsg);
	}
	
	public static void main(String[] args) {
		NioReactor nio = NioReactor.create();
		MapConfiguration config = new MapConfiguration();
		config.add("fixVersion", 44);
		Server server = new FixLatencyOneWayServer(nio, 55555, config);
		server.open();
		nio.start();
	}
}

The client:

package com.coralblocks.coralfix.bench.latency;

import com.coralblocks.coralbits.bench.Benchmarker;
import com.coralblocks.coralbits.util.SystemUtils;
import com.coralblocks.coralfix.FixConstants;
import com.coralblocks.coralfix.FixMessage;
import com.coralblocks.coralfix.client.FixApplicationClient;
import com.coralblocks.coralreactor.client.Client;
import com.coralblocks.coralreactor.nio.NioReactor;
import com.coralblocks.coralreactor.util.Configuration;
import com.coralblocks.coralreactor.util.MapConfiguration;

public class FixLatencyOneWayClient extends FixApplicationClient {

	// java -Xms6g -Xmx8g -server -verbose:gc -Xbootclasspath/p:../CoralReactor-boot-jdk7/target/coralreactor-boot-jdk7.jar -cp target/coralfix-all.jar:lib/jna-3.5.1.jar -DdetailedBenchmarker=true -DnioReactorProcToBind=3 com.coralblocks.coralfix.bench.latency.FixLatencyOneWayClient
	
	private int count = 0;
	private final int messages;
	private final Benchmarker bench;
	
	public FixLatencyOneWayClient(NioReactor nio, String localhost, int port, Configuration config) {
		super(nio, localhost, port, config);
		int warmup = SystemUtils.getInt("warmup", 200000);
		this.messages = SystemUtils.getInt("messages", 2000000);
		this.bench = Benchmarker.create(warmup);
    }
	
	@Override
	protected void handleFixApplicationMessage(FixMessage fixMsg, boolean possDupe) {
		
		long ts = fixMsg.getLong(7676);
		// Note: contrary to popular belief, System.nanoTime() is consistency across CPU cores
		// and can be used to measure one-way latency without any problems. We have also used
		// native rdtsc timers with very similar latency results.
		bench.measure(System.nanoTime() - ts);
		
		if (++count == messages) {
			// done...
			bench.printResults();
			close();
		} else {
			// send a dummy message back, just to trigger a new one...
			FixMessage fixOutMessage = getOutFixMessage(FixConstants.MsgTypes.ExecutionReport);
			fixOutMessage.add(333, 3);
			send(fixOutMessage);
		}
	}
	
	public static void main(String[] args) {
		NioReactor nio = NioReactor.create();
		MapConfiguration config = new MapConfiguration();
		config.add("fixVersion", "44");
		config.add("senderComp", "testClient");
		Client client = new FixLatencyOneWayClient(nio, "localhost", 55555, config);
		client.open();
		nio.start();
	}
}

Conclusion

CoralFIX + CoralReactor can easily deliver one-way FIX message latencies below 5 microseconds.

Test Details

A pseudo market data generator sends UDP packets containing market data updates (i.e. ticks). Our test trading strategy receives these packets, parses them and places a trade order using the FIX protocol on a pseudo exchange that immediately executes the order. To warm up the test strategy, we initially send 1 million market data updates. Then we proceed to send one packet every 5 seconds. To measure the latency, we use tcpdump to record the UDP packet coming in and the FIX order going out. With the packet capture file from tcpdump we then use wireshark to calculate the difference in the timestamps of the packet arriving and the FIX order leaving.

Results

As you can see from the wireshark screenshot below, the tick-to-trade latencies are around 8-9 microseconds.

Source Code

Note that the source code down below produces zero garbage for the GC.

package com.coralblocks.coralfix.bench.trade;

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;

import com.coralblocks.coralbits.util.PriceUtils;
import com.coralblocks.coralfix.FixConstants;
import com.coralblocks.coralfix.FixMessage;
import com.coralblocks.coralfix.FixTags;
import com.coralblocks.coralfix.client.FixApplicationClient;
import com.coralblocks.coralreactor.client.Client;
import com.coralblocks.coralreactor.client.ClientAdapter;
import com.coralblocks.coralreactor.client.receiver.ReceiverUdpClient;
import com.coralblocks.coralreactor.nio.NioReactor;
import com.coralblocks.coralreactor.util.MapConfiguration;

public class TickToTrade extends ClientAdapter {
	
	private final NioReactor nio;
	private final FixApplicationClient fixGateway;
	private final byte[] symbol = new byte[8];
	private long orderIDs = 1;
	
	public TickToTrade(NioReactor nio, final Client marketDataFeed, FixApplicationClient fixGateway) {
		this.nio = nio;
		this.fixGateway = fixGateway;
		
		fixGateway.addListener(new ClientAdapter() {

			@Override
			public void onConnectionOpened(Client client) {
				// gateway is connected and ready to trade...
				marketDataFeed.open(); // open the feed...
				marketDataFeed.addListener(TickToTrade.this); // so that onMessage below is called
			}
		});
	}
	
	public void start() {
		fixGateway.open();
	}

	@Override
    public void onMessage(Client client, InetSocketAddress fromAddress, ByteBuffer msg) {
		
		// parse the market data quote
		long quoteId = msg.getLong();
		boolean isBid = msg.get() == 'B';
		msg.get(symbol);
		long size = msg.getInt();
		long price = msg.getLong();
		
		// hit the market data quote
		FixMessage outFixMsg = fixGateway.getOutFixMessage(FixConstants.MsgTypes.NewOrderSingle);
		outFixMsg.add(FixTags.ClOrdID, orderIDs++);
		outFixMsg.add(FixTags.OrigClOrdID, quoteId);
		outFixMsg.addTrimmed(FixTags.Symbol, symbol);
		outFixMsg.add(FixTags.Side, isBid ? "2" : "1"); // sell to the bid or buy from the offer
		outFixMsg.addTimestamp(FixTags.TransactTime, nio.currentTimeMillis());
		outFixMsg.add(FixTags.OrderQty, size);
		outFixMsg.add(FixTags.OrdType, "2"); // limit order
		outFixMsg.add(FixTags.Price, PriceUtils.toDouble(price));
		outFixMsg.add(FixTags.TimeInForce, "3"); // IoC
		fixGateway.send(outFixMsg);
    }

	public static void main(String[] args) {
		
		NioReactor nio = NioReactor.create();
		
		Client marketDataFeed = new ReceiverUdpClient(nio, 44444);
		
		MapConfiguration config = new MapConfiguration();
		config.add("fixVersion", 44);
		config.add("senderComp", "testClient");
		config.add("forceSeqReset", true);
		
		FixApplicationClient fixGateway = new FixApplicationClient(nio, args.length > 0 ? args[0] : "localhost", 55555, config);
		
		TickToTrade tickToTrade = new TickToTrade(nio, marketDataFeed, fixGateway);
		tickToTrade.start();
		
		nio.start();
	}
}

NOTE: If you want to check the benchmark of just the CoralFIX parser without any network I/O code (i.e. without CoralReactor) you can check this article.

The Results

Messages: 5,000,000 (one-way)
Throughput: 279,314 msgs/sec

The machine used for the benchmarks was an Intel i7 (4 x 3.5GHz) Ubuntu box overclocked to 4.5GHz.

The Source Code

The server:

package com.coralblocks.coralfix.bench.throughput;

import com.coralblocks.coralfix.FixMessage;
import com.coralblocks.coralfix.server.FixApplicationServer;
import com.coralblocks.coralreactor.client.Client;
import com.coralblocks.coralreactor.nio.NioReactor;
import com.coralblocks.coralreactor.server.Server;
import com.coralblocks.coralreactor.util.Configuration;
import com.coralblocks.coralreactor.util.MapConfiguration;

public class FixThroughputServer extends FixApplicationServer {
	
	// java -Xms6g -Xmx8g -server -verbose:gc -Xbootclasspath/p:../CoralReactor-boot-jdk7/target/coralreactor-boot-jdk7.jar -cp target/coralfix-all.jar:lib/jna-3.5.1.jar -DpersistSequences=false -DnioReactorProcToBind=2 com.coralblocks.coralfix.bench.throughput.FixThroughputServer
		
	private long start;
	private long msgCount;

	public FixThroughputServer(NioReactor nio, int port, Configuration config) {
	    super(nio, port, config);
    }

	@Override
    protected void handleFixApplicationMessage(Client client, FixMessage fixMsg, boolean possDupe) {
		msgCount++;
    }
	
	@Override
	protected void handleConnectionEstablished(Client client) {
		msgCount = 0;
	}
	
	@Override
	protected void handleConnectionOpened(Client client) {
		start = System.nanoTime();
	}
	
	@Override
	protected void handleConnectionTerminated(Client client) {
		if (msgCount > 0) {
    		long totalTime = System.nanoTime() - start;
    		long latency = totalTime / msgCount;
    		long ops = msgCount * 1000000000L / totalTime;
    		System.out.println("Done receiving messages! messagesReceived=" + msgCount 
		+ " avgLatencyPerMsg=" + latency + " nanos throughput=" + ops + " msgs/sec");
		}
	}
	
	public static void main(String[] args) {
		NioReactor nio = NioReactor.create();
		MapConfiguration config = new MapConfiguration();
		config.add("fixVersion", 44);
		Server server = new FixThroughputServer(nio, 45451, config);
		server.open();
		nio.start();
	}
}

The client:

package com.coralblocks.coralfix.bench.throughput;

import java.nio.channels.SelectionKey;
import java.nio.channels.WritableByteChannel;

import com.coralblocks.coralbits.util.SystemUtils;
import com.coralblocks.coralfix.FixConstants;
import com.coralblocks.coralfix.FixMessage;
import com.coralblocks.coralfix.FixTags;
import com.coralblocks.coralfix.client.FixApplicationClient;
import com.coralblocks.coralreactor.client.Client;
import com.coralblocks.coralreactor.nio.NioReactor;
import com.coralblocks.coralreactor.util.Configuration;
import com.coralblocks.coralreactor.util.MapConfiguration;

public class FixThroughputClient extends FixApplicationClient {
	
	// java -Xms6g -Xmx8g -server -verbose:gc -Xbootclasspath/p:../CoralReactor-boot-jdk7/target/coralreactor-boot-jdk7.jar -cp target/coralfix-all.jar:lib/jna-3.5.1.jar -DpersistSequences=false -DnioReactorProcToBind=3 com.coralblocks.coralfix.bench.throughput.FixThroughputClient
	
	private final int messagesToSend;
	private final int batchSize;
	
	private int msgCount;
	private long start;

	public FixThroughputClient(NioReactor nio, String host, int port, Configuration config) {
	    super(nio, host, port, config);
	    this.messagesToSend = config.getInt("messagesToSend");
	    this.batchSize = config.getInt("batchSize");
    }
	
	@Override
	protected void handleConnectionEstablished() {
		msgCount = 0;
	}

	@Override
	protected void handleConnectionOpened() {
		start = System.nanoTime();
		addInterestOp(SelectionKey.OP_WRITE);
	}
	
	@Override
	public void onWrite(WritableByteChannel channel) {
		
		for(int i = 0; i < batchSize; i++) {
		
    		if (msgCount < messagesToSend) {
    			
    			FixMessage fixOutMsg = getOutFixMessage(FixConstants.MsgTypes.ExecutionReport);
    			fixOutMsg.addTimestamp(FixTags.TransactTime, nio.currentTimeMillis());
    			fixOutMsg.add(FixTags.Account, "01234567");
    			fixOutMsg.add(FixTags.OrderQty, 50);
    			fixOutMsg.add(FixTags.Price, 400.5);
    			fixOutMsg.add(FixTags.ClOrdID, "4");
    			fixOutMsg.add(FixTags.HandlInst, '1');
    			fixOutMsg.add(FixTags.OrdType, '2');
    			fixOutMsg.add(FixTags.Side, '1');
    			fixOutMsg.add(FixTags.Symbol, "OC");
    			fixOutMsg.add(FixTags.Text, "NIGEL");
    			fixOutMsg.add(FixTags.TimeInForce, '0');
    			fixOutMsg.add(FixTags.SecurityDesc, "AOZ3 C02000");
    			fixOutMsg.add(FixTags.SecurityType, 'O');
    		
    			if (!send(fixOutMsg)) {
    				// underlying kernel write socket buffer is full
    				// sending too fast and/or the other side is lagging
    				return; // abort and wait for OP_WRITE
    			}
    			msgCount++;
    		} else {
    			if (hasPendingDataToFlush()) {
    				flush();
    			} else {
    				printResults();
    				disconnect();
    				return;
    			}
    		}
		}
	}
	
	private void printResults() {
		long totalTime = System.nanoTime() - start;
		long latency = totalTime / msgCount;
		long ops = msgCount * 1000000000L / totalTime;
		System.out.println("Done sending messages! messagesSent=" + msgCount 
		+ " avgLatencyPerMsg=" + latency + " nanos throughput=" + ops + " msgs/sec");
	}
	
	public static void main(String[] args) {
		
		NioReactor nio = NioReactor.create();
		
		int messagesToSend = SystemUtils.getInt("messagesToSend", 5000000);
		int batchSize = SystemUtils.getInt("batchSize", 128);
		
		MapConfiguration config = new MapConfiguration();
		config.add("fixVersion", 44);
		config.add("senderComp", "testSenderCompID");
		config.add("messagesToSend", messagesToSend);
		config.add("batchSize", batchSize);
		
		Client client = new FixThroughputClient(nio, "localhost", 45451, config);
		client.open();
		nio.start();
	}
}

Conclusion

CoralFIX + CoralReactor can easily process more than 250,000 FIX messages per second.

Daily and Weekly Timers

CoralFIX comes with two ready-to-use timers that you can use in your FIX clients. See the examples below:

// a timer that will trigger everyday 15:30:00 America/New_York
FixSessionTimer timer = new DailyFixSessionTimer(TimeZone.getTimeZone("America/New_York"), 15, 30, 0);
System.out.println(timer); // => DailyFixSessionTimer-America/New_York-15:30:0

// a timer what will trigger every Sunday at 14:30:00 America/New_York
FixSessionTimer timer = new WeeklyFixSessionTimer(TimeZone.getTimeZone("America/New_York"), Calendar.SUNDAY, 14, 30, 0);
System.out.println(timer); // => WeeklyFixSessionTimer-America/New_York-SUNDAY-14:30:0

Adding Timers to a FIX Client

There are two actions for a timer:

• Stop: Disconnects and closes the client
• Start: Resets both inbound and outbound sequences and reconnects the client

NOTE: You can also use the config options “resetSequencesOnStartTimerEvent” and “reconnectOnStartTimerEvent” to fine tune the start action. Both of these options default to true.

To add one or more timers you pass them as config options. For the config option key you can use:

"startSessionTimer" => no label for this start timer
"startSessionTimer-myStartTimer" => "myStartTimer" is the label for this start timer
"stopSessionTimer" => no label for this stop timer
"stopSessionTimer-myStopTimer" => "myStopTimer" is the label for this stop timer

The formats for the weekly and daily timers are:

DailyTimer => D-TZ-HH:MM:SS => "D-America/New_York-13:00:00"
WeeklyTimer => W-DAY-TZ-HH:MM:SS => "W-SATURDAY-America/New_York-15:00:00"

See below some code examples:

// add a start session timer daily at 14:30:00 America/New_York
config.add("startSessionTimer", "D-America/New_York-14:30:00");

// add a stop session timer weekly on Sunday at 16:00:00 America/New_York
config.add("stopSessionTimer", "W-SUNDAY-America/New_York-16:00:00");

// add a second start session timer with label "midweekStart" weekly on Wednesday at 14:00:00 America/New_York
config.add("startSessionTimer-midweekStart", "W-WEDNESDAY-America/New_York-14:00:00");

// add a second stop session timer with lable "midweekStop" weekly on Wednesday at 13:00:00 America/New_York
config.add("stopSessionTimer-midweekStop", "W-WEDNESDAY-America/New_York-13:00:00");

Additional Features

Timers are smart! That means they will inform the FIX client if it is in a down period and prevent a connection to the server until the next start timer triggers. The FixApplicationClient will also detect a missed start timer (i.e. start timer that was supposed to trigger but the client wasn’t running) and reset the sequences appropriately on the next time the client is started.

Handling Multiple Timers

There can be a situation where each timer needs to perform a different action inside the handleTriggered method. For that you can use the FixSessionTimer argument passed in the method to find out which timer has triggered. In order to do that you can compare the timers by reference or by label as the example below demonstrates:

public class MyClient extends FixApplicationClient {

   // (...)

   @Override
   protected void handleTriggered(FixSessionTimer timer, boolean isCloseTrigger, boolean isMissedStartTrigger) {

      if (timer == timer1) {
         
            // your specific action here

      } else if (timer == timer2) {
         super.handleTriggered(timer); // reset both sequences
      }

      // OR

      if (timer.getLabel().equals("myTimerLabel1")) {

            // your specific cation here

      } else if (timer.getLabel().equals("myTimerLabel2")) {
         super.handleTriggered(timer); // reset both sequences
      }
   }
}

Implementing Timers

The DailyFixSessionTimer and the WeeklyFixSessionTimer should be enough for most situations. However, if you want to implement your own timer with a more complicated schedule, you can code your own implementation of the FixSessionTimer interface.

Conclusion

CoralFIX allows you to schedule timers to perform any kind of action you need on your FIX session, such as resetting sequences and connect/disconnect.