Visionary Bits

Here are some tips to creating low latency servers.

1. Use low level TCP instead of any high level HTTP  (applies to .NET RMI as well)
2. Don’t use too descriptive language like XML unless constraint by requirements. This is a repeated pattern in mobile development (iPhone development included) .
3. If absolutely have to use HTTP, use 1.1 keep alive to avoid closing and opening http connections.
4. Rule of thumb - open/close connection is very very expensive in terms of creating sockets with OS.
5. Don’t do a lot of I/O - For logging or data collection,  have another thread to buffer the write every interval.
6. Again, Don’t use I/O.  Load data into memory at all if possible or cache the data.     I’ve worked in Realtime systems, and even for dot com companies, we always load lookup & hash tables to memory, sometimes a few MB of memory or even a few GIGS of memory.     Make sure the system have plenty of memory otherwise your server will thrash as it tries to page in and out of disk.
7. Please don’t query database ( I/O !! ) . If SLA is 5 ms or sometimes in microsecond,  it is not realistic to query against database no matter how fast it is.   Straight list search is decent, but Hash with O(1) is even better.

Minimize memory allocation, best not to allocate any memory in queries unless absolutely necessary.

1. Allocate memory buffers ahead of time before going into the Query.
2. Use Object Pool
3. Use Thread Pool
4. Use Thread specific storage
5. Use buffers.
6. Turn off RTTI on the compiler.  Type information can be VERY expensive.
7. Turn on optimization on the computer.
8. Inline functions.
9. Avoid too much level of abstraction. This makes it slower for code to transverse your hierarchy.

Here’s a quick code to check the sizes in your OS:

#include "stdio.h"
int main(){
printf("char = %i bytes\n",sizeof(char));
printf("short = %i bytes\n",sizeof(short));
printf("int = %i bytes\n",sizeof(int));
printf("long = %i bytes\n",sizeof(long));
printf("long long = %i bytes\n",sizeof(long long));
printf("float = %i bytes\n",sizeof(float));
printf("double = %i bytes\n",sizeof(double));
return 0;
}

Here’s the results:

Output:
char = 1 bytes
short = 2 bytes
int = 4 bytes
long = 4 bytes
long long = 8 bytes
float = 4 bytes
double = 8 bytes

It appears that float is only 32 bit, hence single precision floating point, and double is 64 bit, hence double precision floating point. It be can dangerous to use floating point in financial calculation because it can cause inaccuracy. I did not believe at first until I saw this great example w/ the code to prove that inaccuracy will happen eventually.

References:
http://virtuallyshocking.com/2008/01/14/float-vs-double/
Wikipedia - Double precision

Welcome to WordPress. This is your first post. Edit or delete it, then start blogging!