Thread: Gigabit TCP Transfer

Hello,

I'm trying to achieve gigabit file transfer in c#. It is a speed test, so there is a packet of bytes, which is send out until the speed test is done.

Code:

					while (!Stopped)
					{
						stream.Write(data, 0, 524288);
						transferred += data.Length;
						[...]
					}

The point is that I'm reaching like 500 MBit/s, not at all gigabit. Let alone the CPU usage is extremely high (about 70%)

The question here is: How can I minimize the CPU usage and how can I achieve maximum data throughput?

Well you could add at the top of your while loop...

Code:

Thread.Sleep(25);

That should take care of your CPU usage issue, however, it won't help in aspiring for higher throughput rates.

Well, it would lower the CPU usage, but make the test results useless.. any other suggestions?

Uisng 1400 bytes, it is far slower (say 5 MB/s). With 512 KB packets the speed is about 60 MB/s.
the more data I send, the faster it gets... Don't know why.

This is the other side, reading the packets:

Code:

private void ClientThread(TcpClient client)
		{
			try
			{
				NetworkStream stream = client.GetStream();
				BinaryReader bin = new BinaryReader(stream);
				byte[] buffer = new byte[bin.ReadInt32()];                         // read the size of the packets
				while (true)
				{
					stream.Read(buffer, 0, buffer.Length);
				}
			}
			catch { }
		}

And yes, I know that TCP has an overhead of about 20%

Both machines have about the same performance. The firewall doesn't seem to slow down anything (same speed when turned off).
I will try it with UDP now.

UDP isn't much faster, because of the datagram size. When I'm sending 1400 bytes or 10 KB via UDP, the speed is between 5 MB/s and 30 MB/s. When using TCP and 1400 bytes it is also 5 MB/s. But using TCP and 512 KB speeds up to 60 MB/s. It seems more like there is a problem with the packet size or the way I'm sending.

Here's the source: http://xload.dev-ch.de/f690bc45828e7...1.0.0b-src.zip
If you could look into it, I would be happy
Maybe you'll see the mistake I'm making right away.

Ok, good point. So here is the source code of the most important parts:

This happens, when a client joins the server. Here, the data is read until the connection is closed.

Code:

private void ClientThread(TcpClient client)
		{
			try
			{
				NetworkStream stream = client.GetStream();
				BinaryReader bin = new BinaryReader(stream);
				byte[] buffer = new byte[bin.ReadInt32()];
				while (true)
				{
					stream.Read(buffer, 0, buffer.Length);
				}
			}
			catch { }
		}

This is the connection code for a TCP client:

Code:

public TcpClient Connect(string ip)
		{
			try
			{
				TcpClient client = new TcpClient(ip, Port);
				client.NoDelay = true;
				return client;
			}
			catch
			{
				return null;
			}
		}

and this is the code, which sends tcp packets:

Code:

private void btnRun_Click(object sender, EventArgs e)
		{
			btnStop.Text = "Stop";
			Stopped = false;
			lblSpeed.Text = "0 Bytes/s";
			lblSpeedBit.Text = "0 Bits/s";
			netGauge.KBitsPerSecond = 0;
			netGauge.Invalidate();
			lblConnectionLost.Visible = false;
			try
			{
				if (lstComputers.SelectedItems.Count == 1)
				{
					tabMain.SelectedIndex = 2;
					btnNext.Visible = false;
					btnRun.Visible = false;
					btnStop.Visible = true;
					lblConnectedTo.Text = lstComputers.SelectedItems[0].Text;
					lblConnectedIP.Text = (string)lstComputers.SelectedItems[0].Tag;

					TcpClient client = Analyzer.Connect(lblConnectedIP.Text);
					NetworkStream stream = client.GetStream();
					BinaryWriter bin = new BinaryWriter(stream);
					int len = (int)edtPacketSize.Value;
					bin.Write(len);
					byte[] data = new byte[len];
					if (chkRandomData.Checked)
					{
						RandomNumberGenerator.Create().GetBytes(data);
					}

					long transferred = 0, transferredthissecond = 0;
					DateTime start = DateTime.Now, lastrefresh = DateTime.Now, lastmeasured = DateTime.Now;

					while (!Stopped)
					{
						stream.Write(data, 0, data.Length);
						transferred += data.Length;
						transferredthissecond += data.Length;
						if ((DateTime.Now - lastmeasured).TotalMilliseconds > 500)
						{
							lastmeasured = DateTime.Now;
							transferredthissecond *= 2;
							lblSpeed.Text = GetSizeName(transferredthissecond) + "/s";
							lblSpeedBit.Text = GetBitSizeName(transferredthissecond) + "/s";
							netGauge.KBitsPerSecond = (int)(transferredthissecond * 8 / 1000);
							netGauge.Invalidate();
							transferredthissecond = 0;
						}

						lblTransferred.Text = GetSizeName(transferred);
						if ((DateTime.Now - lastrefresh).TotalMilliseconds > 25)
						{
							TimeSpan timespan = DateTime.Now - start;
							lblTimeElapsed.Text = (timespan).ToString().PadRight(11).Substring(0, 11);
							int avg = (int)(transferred / timespan.TotalSeconds);
							lblAverageSpeed.Text = GetSizeName(avg) + "/s - " + GetBitSizeName(avg) + "/s";
							Application.DoEvents();
							lastrefresh = DateTime.Now;
						}
					}
					client.Close();
				}
			}
			catch
			{
				lblConnectionLost.Visible = true;
			}
			btnStop.Text = "<< First";
		}

a standard 33MHz/32-bit PCI bus can only move about a gigabit per second of data, so unless you're using a 64-bit or 66MHz PCI or PCI-e bus, there's a good chance that your machine just doesn't have the bus bandwidth to push that kind of data, when everything else is also going on inside the machine. a lot of computers/motherboards are still made with the ethernet port connected to a PCI bus instead of a PCI-e bus, so this is a real possibility.

on another note, gigabit ethernet supports jumbo frames, up to (and maybe over) 16k. if both machines and your switch are set to support jumbo frames (9000 bytes is usually a good number for a few reasons) you may be able to get higher transfer rates, assuming you also have machines that can handle data at that rate.

The transfer rates are slow, when using such small packet sizes. For example 1400 bytes packet size slows the speed down to 5 MB/s. It seems to be some kind of coding issue...
Btw: you seem to have pretty well knowledge of TCP and networking