TASS Belgium / Mbed 2 deprecated PicoTCP_Official_TCP_Rx_Benchmark

TCP Official Rx Benchmark

Dependencies:   PicoTCP lpc1768-picotcp-eth mbed-rtos mbed

This project represents a the official TCP Rx Benchmark for the PicoTCP library.

The mbed board is receiving one Megabyte from the other side and we measure how fast it does that.

The result:
RX Throughput: 1048576 bytes in < 1 seconds (20.236)Mbits/s

The python script used (which you should rename it to PicoTCP_Official_TCP_Rx_Benchmark.py)

#!/usr/bin/python
import sys, socket
import random, string
import select
from time import time
#ECHO_SERVER_ADDRESS = "10.20.30.139"
ECHO_SERVER_ADDRESS = "192.168.100.12"
ECHO_SERVER_PORT = 7
N_PACKETS = 1024
LEN_PACKET = 1024

TOT_BITS = (LEN_PACKET * N_PACKETS * 8) # TX bits + RX bits
PACKET = ''.join(random.choice(string.ascii_uppercase+string.digits) for _ in range(LEN_PACKET))
MEGA = 1024 * 1024.
UPDATE_STEP = (N_PACKETS/20) # Make the update step such as one step = 5%
UPDATE_R_STEP = (N_PACKETS/100) #Make the update step such as one step = 1%
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((ECHO_SERVER_ADDRESS, ECHO_SERVER_PORT))
start = time()
rx_total = 0
tx_total = 0
data = ''
i = 0
lp = []
p = select.poll()
while(True): # keeping this in for robustness testing, when the test will run for days
	#Stage I - sending data from host towards mbed board	
	print "Started sending data...."
	while (i < N_PACKETS):
	  p.register(s, select.POLLOUT)
	  lp = p.poll(1)
	  if (len(lp) > 0):
	    s.sendall(PACKET)
	    i+=1
	    if (i % UPDATE_STEP) == 0: print "sent %d/%d (%.2f%%)" % (i, N_PACKETS, float(i)/ float(N_PACKETS) * 100.)
	    continue

	print "Test was finished!"
	break;	

t = time() - start
s.close()
print "RX Throughput: %d bytes in %d seconds (%.3f)Mbits/s" % (TOT_BITS / 8, t, ((TOT_BITS / t) / MEGA))

This test is based on the following libraries

#include <mbed.h>
#include <stdarg.h>
#include "EthernetInterface.h"

#define ECHO_SERVER_PORT  7
#define BUFFER_QUANTITY   (1024*1024)
#define BUFFER_SIZE       (1024)


EthernetInterface eth;

int main() 
{
    TCPSocketServer server;
   
    printf("Started PicoTCP Rx Benchmark....\n");
    
    eth.init();
    printf("Waiting for DHCP server to give IP...\n");
    
    while(eth.connect() != 0);
    printf("IP address assigned : %s\n",eth.getIPAddress());
    
    server.bind(ECHO_SERVER_PORT);
    server.listen();
    printf("Local server listening on port : %d\n",ECHO_SERVER_PORT);
    
    
    while (true) {
        printf("\n>>> You can start PicoTCP_Official_TCP_Rx_Benchmark.py\n");    
        
        TCPSocketConnection client;
        uint32_t startTime, stopTime;
        server.accept(client);
        client.set_blocking(false, 1500); // Timeout after (1.5)s
        
        char buffer[BUFFER_SIZE];
        int dataReceived = 0;
        
        startTime = PICO_TIME_MS();
        while(dataReceived < BUFFER_QUANTITY)
        {
            int n = client.receive(buffer, sizeof(buffer));
            if (n <= 0) {
                break;
            }
            dataReceived += n;
        }
        stopTime = PICO_TIME_MS();
        
        if(dataReceived == BUFFER_QUANTITY)
        {
            printf("PicoTCP Rx Throughput is : %.3f Mbit/s\n" , (float)((BUFFER_QUANTITY*8.0)/(1000*(stopTime - startTime))));
        }
        else
        {
            printf("Benchmark failed !\n");
        }
    }    
}