.NET Remoting/Serialization way too slow vs C++ binary/tcp

[ajou_king]

I was running some tests on my Win32 1GHZ processor to see how long it
would take to transmit objects numerous times via TCP/IP using C#
..NET Remoting vs the C++ trustworthy method of binary streams. I ran
the test for 50K, 100K, 500K iterations, where each iteration consists
of sending an object from a client process to a server process, and the
server process sends back an ack.
Here are the results:

.NET Remoting C++ Binary TCP/IP
-------------- ------------------
50,000 Iterations: 128 seconds 3 seconds
100,000 Iterations: 300 seconds 8 seconds
500,000 Iterations: 1459 seconds 43 seconds

In the above tests the .NET remoting overhead was 42.6x, 37.5x, and
33.9x slower than the c++ version.

Here is the object that was used:
---------------------------------------------------------------
[Serializable]
public class Msg
{
public int msgType_;
public int seqNum_;
public String symbol_;
public int quoteId_;
public int responseLevel_;
public int eqiRole_;
public float bidPrice_;
public float offerPrice_;
public int bidSize_;
public int offerSize_;
public float liquidityBidPri ce_;
public float liquidityOfferP rice_;
public int liquidityBidSiz e_;
public int liquidityOfferS ize_;
public int checkSum_;
}

The Server Process:
------------------------------------------------------
using System;
using Messages;
namespace tcpServer
{

using System;
using System.Net;
using System.Net.Sock ets;
using System.Runtime. Serialization.F ormatters.Binar y;
using System.IO;
/// <summary>
/// Summary description for Class1.
/// </summary>
class Class1
{
/// <summary>
/// The main entry point for the application.
/// </summary>
[STAThread]
static void Main(string[] args)
{
int port = 7627;
int N = 50000;
int i = 0;

BinaryFormatter bF = new BinaryFormatter ();

TcpListener tcpListener = new TcpListener(por t);
tcpListener.Sta rt();
Socket soTcp = tcpListener.Acc eptSocket();
Console.WriteLi ne("SampleClien t is connected through TCP.");
NetworkStream stream = new NetworkStream(s oTcp,
FileAccess.Read Write, true);
BinaryReader bReader = new BinaryReader(st ream);

DateTime beginTime = new DateTime();

while (i < N)
{
if (i == 0)
{
beginTime = System.DateTime .Now;
}

++i;
Byte[] received = new Byte[1024];
Messages.Msg msg = new Messages.Msg();
msg = (Messages.Msg)b F.Deserialize(s tream);
String returningString = Convert.ToStrin g(99);
Byte[] returningByte =
System.Text.Enc oding.ASCII.Get Bytes(returning String.ToCharAr ray());

//Returning a confirmation back to the client.
soTcp.Send(retu rningByte, returningByte.L ength, 0);
}
DateTime endTime = System.DateTime .Now;
Console.WriteLi ne(endTime - beginTime);
}
}
}

The Client Process
---------------------------------------------------------------------
using System;
using System.Net;
using System.Net.Sock ets;
using System.IO;
using System.Runtime. Serialization.F ormatters.Binar y;
using Messages;

namespace tcpClient
{
/// <summary>
/// Summary description for Class1.
/// </summary>
///

class Class1
{
/// <summary>
/// The main entry point for the application.
/// </summary>
[STAThread]
static void Main(string[] args)
{
int port = 7627;
int N = 100000;
int i = 0;

TcpClient tcpClient = new TcpClient("mach ine1", port);
NetworkStream tcpStream = tcpClient.GetSt ream();
BinaryWriter bWriter = new BinaryWriter(tc pStream);
BinaryFormatter bF = new BinaryFormatter ();

while (i < N)
{
++i;

Messages.Msg m = new Messages.Msg();
m.msgType_ = 101;
m.bidPrice_ = 123.32f;
m.bidSize_ = 100;
m.eqiRole_ = 1;
m.liquidityBidP rice_ = 122.12f;
m.liquidityOffe rPrice_ = 192.32f;
m.offerPrice_ = 154.25f;
m.quoteId_ = i;
m.responseLevel _ = 10;
m.symbol_ = "IBM";
bF.Serialize(tc pStream, m);

// Read back the Ack
Byte[] received = new Byte[1024];
tcpStream.Read( received, 0, received.Length );

}
}
}
}


The C++ binary streams method was to simply simulate the above but no
serialization involved - just send the byte stream of the class via
TCP/IP sockets.

If .NET Remoting / Serialization is so slow, why would anyone ever use
it over C++ for performance critical applications that transmit
hundreds of thousands of messages per day ? Is the tradeoff really
worth it ? What are people's thoughts ?

[ajou_king]

Another interesting test. I added Java Serialization into the mix,
basically I ported the C# code to Java - same logic, but the results
are much in better, in favor of Java.

The Java Serialization results:
For 50,000 Iterations: 19 seconds
For 100,000 Iterations: 46 seconds
For 500,000 Iterations: 250 seconds

That averages to about 6x slower than binary C++ version, but __MUCH__
better than the .NET version which averaged about 35x slower.

Why is .NET's serialization/processing so much worse than Java's ?
Here is the Java Code:
Server
-------------------------------------------------------------------------------------------
class tcpServer
{
public static void main(String[] args)
{
tcpServer server = new tcpServer();
server.run(1000 00);
}

void run(int N)
{
try
{
ServerSocket listener = new ServerSocket(99 91);
Socket socket = listener.accept ();
DataInputStream dis = new
DataInputStream (socket.getInpu tStream());
DataOutputStrea m dos = new
DataOutputStrea m(socket.getOut putStream());
ObjectInputStre am ois = new ObjectInputStre am(dis);
ObjectOutputStr eam oos = new ObjectOutputStr eam(dos);

int i = 0;
while (i < N)
{
++i;
Msg obj = (Msg)ois.readOb ject();

// reply
Integer ii = new Integer(i);
oos.writeObject (ii);

}
}
catch (Exception e)
{
e.printStackTra ce();
}
}

}

Client
--------------------------------------------------------------------------------------------
class tcpClient
{
public static void main(String[] args)
{
tcpClient client = new tcpClient();
client.run(1000 00);
}

void run(int N)
{
try
{

InetAddress ia = InetAddress.get ByName("machine 1");
Socket socket = new Socket(ia, 9991);
ObjectOutputStr eam oos = new
ObjectOutputStr eam(socket.getO utputStream());
DataInputStream dis = new
DataInputStream (socket.getInpu tStream());
ObjectInputStre am ois = new ObjectInputStre am(dis);

int i = 0;
Calendar beginTime = null;
while (i < N)
{
if (i == 0)
{
beginTime = Calendar.getIns tance();
}

++i;

Msg object = new Msg();
object.msgType_ = 101;
object.seqNum_ = i;
object.symbol_ = "IBM";
object.quoteId_ = i;
object.response Level_ = 1;
object.eqiRole_ = 1;
object.bidPrice _ = 100.21f;
object.offerPri ce_ = 102.31f;
object.bidSize_ = 100; object.offerSiz e_ = 200;
oos.writeObject (object);

// read ack
Integer ii = (Integer)ois.re adObject();
}
Calendar endTime = Calendar.getIns tance();
System.out.prin tln("Time: " +
(endTime.getTim eInMillis() - beginTime.getTi meInMillis()) );

}
catch (Exception e)
{
e.printStackTra ce();
}
}

}
Message Object
-------------------------------------------------------------------------
public class Msg implements Serializable
{
public int msgType_;
public int seqNum_;
public String symbol_;
public int quoteId_;
public int responseLevel_;
public int eqiRole_;
public float bidPrice_;
public float offerPrice_;
public int bidSize_;
public int offerSize_;
public float liquidityBidPri ce_;
public float liquidityOfferP rice_;
public int liquidityBidSiz e_;
public int liquidityOfferS ize_;
public char[] text_ = new char[512];
public int checkSum_;

[Willy Denoyette [MVP]]

<aj*******@yaho o.com> wrote in message
news:11******** **************@ o13g2000cwo.goo glegroups.com.. .

I was running some tests on my Win32 1GHZ processor to see how long it
would take to transmit objects numerous times via TCP/IP using C#
.NET Remoting vs the C++ trustworthy method of binary streams. I ran
the test for 50K, 100K, 500K iterations, where each iteration consists
of sending an object from a client process to a server process, and the
server process sends back an ack.
Here are the results:

.NET Remoting C++ Binary TCP/IP
-------------- ------------------
50,000 Iterations: 128 seconds 3 seconds
100,000 Iterations: 300 seconds 8 seconds
500,000 Iterations: 1459 seconds 43 seconds

In the above tests the .NET remoting overhead was 42.6x, 37.5x, and
33.9x slower than the c++ version.

Here is the object that was used:
---------------------------------------------------------------
[Serializable]
public class Msg
{
public int msgType_;
public int seqNum_;
public String symbol_;
public int quoteId_;
public int responseLevel_;
public int eqiRole_;
public float bidPrice_;
public float offerPrice_;
public int bidSize_;
public int offerSize_;
public float liquidityBidPri ce_;
public float liquidityOfferP rice_;
public int liquidityBidSiz e_;
public int liquidityOfferS ize_;
public int checkSum_;
}

The Server Process:
------------------------------------------------------
using System;
using Messages;
namespace tcpServer
{

using System;
using System.Net;
using System.Net.Sock ets;
using System.Runtime. Serialization.F ormatters.Binar y;
using System.IO;
/// <summary>
/// Summary description for Class1.
/// </summary>
class Class1
{
/// <summary>
/// The main entry point for the application.
/// </summary>
[STAThread]
static void Main(string[] args)
{
int port = 7627;
int N = 50000;
int i = 0;

BinaryFormatter bF = new BinaryFormatter ();

TcpListener tcpListener = new TcpListener(por t);
tcpListener.Sta rt();
Socket soTcp = tcpListener.Acc eptSocket();
Console.WriteLi ne("SampleClien t is connected through TCP.");
NetworkStream stream = new NetworkStream(s oTcp,
FileAccess.Read Write, true);
BinaryReader bReader = new BinaryReader(st ream);

DateTime beginTime = new DateTime();

while (i < N)
{
if (i == 0)
{
beginTime = System.DateTime .Now;
}

++i;
Byte[] received = new Byte[1024];
Messages.Msg msg = new Messages.Msg();
msg = (Messages.Msg)b F.Deserialize(s tream);
String returningString = Convert.ToStrin g(99);
Byte[] returningByte =
System.Text.Enc oding.ASCII.Get Bytes(returning String.ToCharAr ray());

//Returning a confirmation back to the client.
soTcp.Send(retu rningByte, returningByte.L ength, 0);
}
DateTime endTime = System.DateTime .Now;
Console.WriteLi ne(endTime - beginTime);
}
}
}

The Client Process
---------------------------------------------------------------------
using System;
using System.Net;
using System.Net.Sock ets;
using System.IO;
using System.Runtime. Serialization.F ormatters.Binar y;
using Messages;

namespace tcpClient
{
/// <summary>
/// Summary description for Class1.
/// </summary>
///

class Class1
{
/// <summary>
/// The main entry point for the application.
/// </summary>
[STAThread]
static void Main(string[] args)
{
int port = 7627;
int N = 100000;
int i = 0;

TcpClient tcpClient = new TcpClient("mach ine1", port);
NetworkStream tcpStream = tcpClient.GetSt ream();
BinaryWriter bWriter = new BinaryWriter(tc pStream);
BinaryFormatter bF = new BinaryFormatter ();

while (i < N)
{
++i;

Messages.Msg m = new Messages.Msg();
m.msgType_ = 101;
m.bidPrice_ = 123.32f;
m.bidSize_ = 100;
m.eqiRole_ = 1;
m.liquidityBidP rice_ = 122.12f;
m.liquidityOffe rPrice_ = 192.32f;
m.offerPrice_ = 154.25f;
m.quoteId_ = i;
m.responseLevel _ = 10;
m.symbol_ = "IBM";
bF.Serialize(tc pStream, m);

// Read back the Ack
Byte[] received = new Byte[1024];
tcpStream.Read( received, 0, received.Length );

}
}
}
}


The C++ binary streams method was to simply simulate the above but no
serialization involved - just send the byte stream of the class via
TCP/IP sockets.

If .NET Remoting / Serialization is so slow, why would anyone ever use
it over C++ for performance critical applications that transmit
hundreds of thousands of messages per day ? Is the tradeoff really
worth it ? What are people's thoughts ?

You should never use the BinaryFormatter to serialize an object over a
NetworkStream.
Or you should use the Remoting infrastructure, or use a MemoryStream to
serialize the object to a byte array and send the client the length of the
array (as an int) followed by the byte array. The receiving side has to
deserialize the byte array back into an object and cast it to the desired
object instance.

Following class illustrates the process:

public class Serializer {
public Serializer(){}

public byte[] Serialize(objec t o){
byte[] buffer;
using(MemoryStr eam ms = new MemoryStream())
{
BinaryFormatter b = new BinaryFormatter ();
b.Serialize(ms, o);
if (ms.Length > int.MaxValue)
throw new ArgumentExcepti on("Serialized object is larger than
can fit into byte array");
buffer = ms.GetBuffer();
}
return buffer;
}

public object DeSerialize(byt e[] bytes){
object o;
using(MemoryStr eam ms = new MemoryStream(by tes))
{
BinaryFormatter b = new BinaryFormatter ();
o = b.Deserialize(m s);
}
return o;
}
}

Usage:
//Client....
....
Serializer se = new Serializer();
while(...)
...
sb = se.Serialize(m) ;
bWriter.Write(s b.Length); // Write size in bytes of serialized
array
bWriter.Write(s b);

}

Serializer se = new Serializer();
while (i < N)
{
++i;
int length = bReader.ReadInt 32();
byte[] data = bReader.ReadByt es(length);
Msg o = se.DeSerialize( data) as Msg;
....
}

Using this method it should be possible to achieve results approaching these
obtained with C++.

Willy.