Please check out the article on SubMicroTrading at theTradingMesh.com :-
http://www.thetradingmesh.
http://www.thetradingmesh.
Monday, 17 August 2015
Sunday, 16 August 2015
Avoid Unnecessary Allocations and Memcpy's
This blog may seem obvious but its worth a mention anyway.
Low latency java needs to follow a different path from standard java and avoid allocations and unnecessary memcpy's.
Low latency java needs to follow a different path from standard java and avoid allocations and unnecessary memcpy's.
Consider the following example, how many memory
allocations occur for the StringBuilder?
A) Typical java code
private
Message read() {
StringBuilder info = new StringBuilder();
Message m = decode();
info.append( "seqNum=" ).append( m.getSeqNum() )
.append( ", isDup="
).append( m.isPosDup() )
m.dump( info );
log( info );
return m;
}
GC .. who
cares ? Multiple allocs per call to read. Threadsafe
B)Presized string buffer
private
Message read() {
StringBuilderinfo = new StringBuilder(1024);
Message m = decode();
info.append( "seqNum=" ).append( m.getSeqNum() )
.append( ", isDup="
).append( m.isPosDup() )
m.dump( info );
log( info );
return m;
}
GC .. who
cares ? One buffer alloc per call to read. Threadsafe
C)Member variable
private final
StringBuilder _info = new StringBuilder();
private
Message read() {
_info.setLength(0);
Message m = decode();
_info.append( "seqNum=" ).append( m.getSeqNum() )
.append( ",
isDup=" ).append( m.isPosDup() )
m.dump( _info );
log( _info );
return m;
}
Lazy
initialisation for the StringBuilder. Some allocs until buffer hits max
required size.
Best option
where memory is limited and there can be many instances
Not thread
safe ... but thats FINE as all code assumed single threaded unless otherwise
specified
In ultra low
latency threading model is explicit and all contention minimised and
understood.
D)Presized member variable
private final
StringBuilder _info = new StringBuilder(1024);
private
Message read() {
_info.setLength(0);
Message m = decode();
if ( isLogEnabled() ) {
_info.append( "seqNum=" ).append( m.getSeqNum() )
.append( ",
isDup=" ).append( m.isPosDup() )
m.dump( _info );
log( _info );
}
return m;
}
Ok so the
guards should of been in all examples, but in typical java code its ignored and
the allocations and mempcy paid ... a lazy tax.
Ultra Low
Latency approach for the StringBuilder. Single buffer allocation presized to
max requirement.
Not thread
safe ... but thats FINE as all code assumed single threaded unless otherwise
specified
In ultra low
latency threading model is explicit and all contention minimised and
understood.
FYI
SubMicroTrading doesnt use StringBuilder but ReusableString to avoid the
overhead of toString() and uses byte instead of char.
Tuesday, 11 August 2015
SubMicroTrading Open Source on GitHub
As explained in my last post I have now Open Sourced SubMicroTrading.com on GitHub
SubMicroTrading on GitHub
There is almost a quarter of a million lines of code.
Code highlights for me are
1) The socket session class hierarchy and cleanly extending it across all the different exchange sessions
2) Exchange Agnostic Algo Container to make writing strategies easier
3) Highly concurrent book maintenance in MarketDataController and Book snapping with optimisation to snap at most once per thread without a map lookup
Please check it out !!
SubMicroTrading on GitHub
There is almost a quarter of a million lines of code.
Code highlights for me are
1) The socket session class hierarchy and cleanly extending it across all the different exchange sessions
2) Exchange Agnostic Algo Container to make writing strategies easier
3) Highly concurrent book maintenance in MarketDataController and Book snapping with optimisation to snap at most once per thread without a map lookup
Please check it out !!
Subscribe to:
Posts (Atom)