tc_TcpRecv Namespace Reference

Functions
def	tcp_rx_loop (clientSock, serverSock, size, ip_da, tcp_dp, count, verbose=False)
def	tcp_rx_ramp (clientSock, serverSock, ip_da, tcp_dp, verbose=False, start=1, end=0xFFFF)

Variables
	parser = argparse.ArgumentParser(description='A script to receive TCP data from an FPGA module.')
	type
	str
	default
	help
	int
	action
	args = parser.parse_args()
	ipFpga = getFpgaIpv4(args)
	instId = getInstanceId(args)
	ipResMngr = getResourceManagerIpv4(args)
	portFpgaServer = XMIT_MODE_LSN_PORT
	portResMngr = getResourceManagerPort(args)
tuple	fpgaServerAssociation = (str(ipFpga), portFpgaServer)
	tcpClientSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
	hostname = socket.gethostname()
	ipHostStr = socket.gethostbyname(hostname)
	ip4Str = ni.ifaddresses(itf)[AF_INET][0]['addr']
	ipHost = int(ipaddress.IPv4Address(ipHostStr))
int	dpHost = 2718
tuple	hostListenAssociation = (str(ipHostStr), dpHost)
	tcpListenSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
	reqMsgAsBytes = struct.pack(">IHH", ipHost, dpHost, 0)
	tcpServerSock
	fpgaClientAssociation
	seed = args.seed
int	TODO_MAX_SEG_SIZE = 2048
	size = args.size
	count = args.loop_count
	verbose = args.verbose

Function Documentation

tcp_rx_loop()

def tc_TcpRecv.tcp_rx_loop	(		clientSock,
			serverSock,
			size,
			ip_da,
			tcp_dp,
			count,
			verbose = False
	)

TCP Rx Single-Thread Loop.
 Requests the FPGA to send 'count' segments of 'size' bytes and expect the HOST to receive
  them on the socket (ip_da, tcp_port). Each segment is made of the following repetitive
  pattern '48692066726f6d200x464d4b553630210a' which decodes into "Hi from FMKU60\n".
 :param clientSock The socket to send to.
 :param serverSock The socket to receive from.
 :param size       The size of the expected segment.
 :param ip_da      The destination address of the host.
 :param tcp_dp     The destination port of the host.
 :param count      The number of segments to receive.
 :param verbose    Enables verbosity.
 :return           None

Definition at line 44 of file tc_TcpRecv.py.

def tcp_rx_loop(clientSock, serverSock, size, ip_da, tcp_dp, count, verbose=False):
    """TCP Rx Single-Thread Loop.
     Requests the FPGA to send 'count' segments of 'size' bytes and expect the HOST to receive
      them on the socket (ip_da, tcp_port). Each segment is made of the following repetitive
      pattern '48692066726f6d200x464d4b553630210a' which decodes into "Hi from FMKU60\n".
     :param clientSock The socket to send to.
     :param serverSock The socket to receive from.
     :param size       The size of the expected segment.
     :param ip_da      The destination address of the host.
     :param tcp_dp     The destination port of the host.
     :param count      The number of segments to receive.
     :param verbose    Enables verbosity.
     :return           None"""
    if verbose:
        print("[INFO] Requesting the FPGA to send %d segments of %d bytes on TCP port number %d." % (count, size, tcp_dp))
    nrErr = 0
    loop = 0
    totalReceivedBytes = 0
 
    # Set the client and server sockets non-blocking
    # -----------------------------------------------
    clientSock.settimeout(5)
    clientSock.setblocking(False)
    serverSock.settimeout(5)
    serverSock.setblocking(False)
 
    # Request the test to generate a segment of length='size' and to send it to socket={ip_da, tcp_dp}
    # by sending 'ip_da', 'tcp_dp' and 'size' to the FPGA.
    #  Turn the 'ip_da' into an unsigned int binary and 'tcp_dp' and 'size' into an unsigned short binary data.
    reqMsgAsBytes = struct.pack(">IHH", ip_da, tcp_dp, size)
    if verbose:
        print("[DEBUG] >>> reqMsgAsBytes = %s" % reqMsgAsBytes)
 
    startTime = datetime.datetime.now()
    while loop < count:
            # SEND message length request to FPGA
            # ------------------------------------
            try:
                clientSock.sendall(reqMsgAsBytes)
            except socket.error as exception:
                # Any exception
                print("[EXCEPTION] Socket error while transmitting :: %s" % exception)
                exit(1)
            finally:
                pass
 
            # RECEIVE message length bytes from FPGA
            # ---------------------------------------
            currRxByteCnt = 0
            nonBlockingTrials = 0
            while currRxByteCnt < size:
                try:
                    data = serverSock.recv(MTU)
                except IOError as e:
                    # On non blocking connections - when there are no incoming data, error is going to be raised
                    # Some operating systems will indicate that using AGAIN, and some using WOULDBLOCK error code
                    # We are going to check for both - if one of them - that's expected, means no incoming data,
                    # continue as normal. If we got different error code - something happened
                    if e.errno != errno.EAGAIN and e.errno != errno.EWOULDBLOCK:
                        print('\n[ERROR] Socket reading error: {}'.format(str(e)))
                        exit(1)
                    # We just did not receive anything
                    if nonBlockingTrials > 100000:
                        print('\n[ERROR] Too many socket read attempts ({:d})'.format(nonBlockingTrials))
                        break
                    else:
                        nonBlockingTrials += 1
                    if verbose and (nonBlockingTrials % 100 == 0):
                        # print("[DEBUG] So far we received %d bytes out of %d." % (currRxByteCnt, size))
                        print(".", end="")
                    continue
                except socket.error as exc:
                    # Any other exception
                    print("\n[EXCEPTION] Socket error while receiving :: %s" % exc)
                    exit(1)
                else:
                    currRxByteCnt += len(data)
                    if verbose:
                        print("\n[INFO] Loop=%6d | RxBytes=%3d | " % (loop, len(data)))
                        print("RxData=%s" % data)
                        # [FIXME-TODO: assess the stream of received bytes]
                    nonBlockingTrials = 0
                finally:
                    pass
            totalReceivedBytes += currRxByteCnt
            loop += 1
    endTime = datetime.datetime.now()
    elapseTime = endTime - startTime
 
    if totalReceivedBytes < 1000000:
        print("[INFO] Received a total of %d bytes." % totalReceivedBytes)
    elif totalReceivedBytes < 1000000000:
        megaBytes = (totalReceivedBytes * 1.0) / (1024 * 1024 * 1.0)
        print("[INFO] Received a total of %.1f MB." % megaBytes)
    else:
        gigaBytes = (totalReceivedBytes * 1.0) / (1024 * 1024 * 1024 * 1.0)
        print("[INFO] Transferred a total of %.1f GB." % gigaBytes)
 
    bandwidth = (totalReceivedBytes * 8 * 1.0) / (elapseTime.total_seconds() * 1024 * 1024)
    print("#####################################################")
    if bandwidth < 1000:
        print("#### TCP Rx DONE with bandwidth = %6.1f Mb/s" % bandwidth)
    else:
        bandwidth = bandwidth / 1000
        print("#### TCP Rx DONE with bandwidth = %2.1f Gb/s" % bandwidth)
    if (totalReceivedBytes != (size * count)):
        print("####  [WARNING] TCP data loss = %.1f%%" % (100 - (totalReceivedBytes) / (size * count)))
        # [FIXME] Should return an error code
    print("#####################################################")
    print()
 
 

tcp_rx_ramp()

def tc_TcpRecv.tcp_rx_ramp	(		clientSock,
			serverSock,
			ip_da,
			tcp_dp,
			verbose = False,
			start = 1,
			end = 0xFFFF
	)

TCP Rx Single-Thread Ramp.
Requests the FPGA to send 'start'-'end' number of segments to the HOST, each segment with an
 increasing number of bytes from 'start' to 'end'. Expect the HOST to receive the segments
 on the socket (ip_da, tcp_port). Each segment is made of the following repetitive pattern
 pattern '48692066726f6d200x464d4b553630210a' which decodes into "Hi from FMKU60\n".
 :param clientSock The socket to send to.
 :param serverSock The socket to receive from.
 :param ip_da      The destination address of the host
 :param tcp_dp     The destination port of the host.
 :param verbose    Enables verbosity.
 :param start      The start size of the ramp (in bytes).
 :param end        The end size of the ramp (in bytes).
 :return           None

Definition at line 156 of file tc_TcpRecv.py.

def tcp_rx_ramp(clientSock, serverSock, ip_da, tcp_dp, verbose=False, start=1, end=0xFFFF):
    """TCP Rx Single-Thread Ramp.
    Requests the FPGA to send 'start'-'end' number of segments to the HOST, each segment with an
     increasing number of bytes from 'start' to 'end'. Expect the HOST to receive the segments
     on the socket (ip_da, tcp_port). Each segment is made of the following repetitive pattern
     pattern '48692066726f6d200x464d4b553630210a' which decodes into "Hi from FMKU60\n".
     :param clientSock The socket to send to.
     :param serverSock The socket to receive from.
     :param ip_da      The destination address of the host
     :param tcp_dp     The destination port of the host.
     :param verbose    Enables verbosity.
     :param start      The start size of the ramp (in bytes).
     :param end        The end size of the ramp (in bytes).
     :return           None"""
    if verbose:
        print("[INFO] Requesting the FPGA to send a ramp of segments of increasing size from %d to %d bytes." % (
               start, end))
    nrErr = 0
    loop = 0
    totalReceivedBytes = 0
 
    # Set the client and server sockets non-blocking
    # -----------------------------------------------
    clientSock.settimeout(5)
    clientSock.setblocking(False)
    serverSock.settimeout(5)
    serverSock.setblocking(False)
 
    startTime = datetime.datetime.now()
 
    for size in range(start, end+1):
 
        # Request the test to generate a segment of length='size' and to send it to
        # socket={ip_da, tcp_dp}. This procedure is triggered by sending 'ip_da', 'tcp_dp' and
        # 'size' to the FPGA.
        reqMsgAsBytes = struct.pack(">IHH", ip_da, tcp_dp, size)
        if verbose:
            print("[DEBUG] Requesting a segment of size=%d bytes (reqMsgAsBytes = %s)" % (size, reqMsgAsBytes))
 
        # SEND message length request to FPGA
        # ------------------------------------
        try:
            clientSock.sendall(reqMsgAsBytes)
        except socket.error as exception:
            # Any exception
            print("[EXCEPTION] Socket error while transmitting :: %s" % exception)
            exit(1)
        finally:
            pass
 
        # RECEIVE message length bytes from FPGA
        # ---------------------------------------
        currRxByteCnt = 0
        nonBlockingTrials = 0
        while currRxByteCnt < size:
            try:
                data = serverSock.recv(MTU)
            except IOError as e:
                # On non blocking connections - when there are no incoming data, error is going to be raised
                # Some operating systems will indicate that using AGAIN, and some using WOULDBLOCK error code
                # We are going to check for both - if one of them - that's expected, means no incoming data,
                # continue as normal. If we got different error code - something happened
                if e.errno != errno.EAGAIN and e.errno != errno.EWOULDBLOCK:
                    print('[ERROR] Socket reading error: {}'.format(str(e)))
                    exit(1)
                # We just did not receive anything
                if nonBlockingTrials > 1000000:
                    print('\n[ERROR] Too many socket read attempts ({:d})'.format(nonBlockingTrials))
                    exit(1)
                    break
                else:
                    nonBlockingTrials += 1
                if verbose and (nonBlockingTrials % 100 == 0):
                    # print("[DEBUG] So far we received %d bytes out of %d." % (currRxByteCnt, size))
                    print(".", end="")
                continue
            except socket.error as exc:
                # Any other exception
                print("[EXCEPTION] Socket error while receiving :: %s" % exc)
                exit(1)
            else:
                currRxByteCnt += len(data)
                if verbose:
                    print("[INFO] ReqBytes=%d | RxBytes=%d\n" % (size, len(data)))
                    print("RxData=%s\n" % data)
                    # [FIXME-TODO: assess the stream of received bytes]
                nonBlockingTrials = 0
            finally:
                pass
        totalReceivedBytes += currRxByteCnt
 
    endTime = datetime.datetime.now()
    elapseTime = endTime - startTime
 
    if totalReceivedBytes < 1000000:
        print("[INFO] Received a total of %d bytes." % totalReceivedBytes)
    elif totalReceivedBytes < 1000000000:
        megaBytes = (totalReceivedBytes * 1.0) / (1024 * 1024 * 1.0)
        print("[INFO] Received a total of %.1f MB." % megaBytes)
    else:
        gigaBytes = (totalReceivedBytes * 1.0) / (1024 * 1024 * 1024 * 1.0)
        print("[INFO] Transferred a total of %.1f GB." % gigaBytes)
 
    bandwidth = (totalReceivedBytes * 8 * 1.0) / (elapseTime.total_seconds() * 1024 * 1024)
    print("#####################################################")
    if bandwidth < 1000:
        print("#### TCP Rx DONE with bandwidth = %6.1f Mb/s" % bandwidth)
    else:
        bandwidth = bandwidth / 1000
        print("#### TCP Rx DONE with bandwidth = %2.1f Gb/s" % bandwidth)
    if totalReceivedBytes != (end-start+1)*(start+end)/2:
        print("####  [WARNING] TCP data loss = %.1f%%" % (100 - (totalReceivedBytes) / (size * count)))
    print("#####################################################")
    print()
 
 

Variable Documentation

action

tc_TcpRecv.action

Definition at line 299 of file tc_TcpRecv.py.

args

tc_TcpRecv.args = parser.parse_args()

Definition at line 302 of file tc_TcpRecv.py.

count

tc_TcpRecv.count = args.loop_count

Definition at line 474 of file tc_TcpRecv.py.

default

tc_TcpRecv.default

Definition at line 281 of file tc_TcpRecv.py.

dpHost

int tc_TcpRecv.dpHost = 2718

Definition at line 385 of file tc_TcpRecv.py.

fpgaClientAssociation

tc_TcpRecv.fpgaClientAssociation

Definition at line 441 of file tc_TcpRecv.py.

fpgaServerAssociation

tuple tc_TcpRecv.fpgaServerAssociation = (str(ipFpga), portFpgaServer)

Definition at line 338 of file tc_TcpRecv.py.

help

tc_TcpRecv.help

Definition at line 282 of file tc_TcpRecv.py.

hostListenAssociation

tuple tc_TcpRecv.hostListenAssociation = (str(ipHostStr), dpHost)

Definition at line 386 of file tc_TcpRecv.py.

hostname

tc_TcpRecv.hostname = socket.gethostname()

Definition at line 366 of file tc_TcpRecv.py.

instId

tc_TcpRecv.instId = getInstanceId(args)

Definition at line 314 of file tc_TcpRecv.py.

int

tc_TcpRecv.int

Definition at line 283 of file tc_TcpRecv.py.

ip4Str

tc_TcpRecv.ip4Str = ni.ifaddresses(itf)[AF_INET][0]['addr']

Definition at line 373 of file tc_TcpRecv.py.

ipFpga

tc_TcpRecv.ipFpga = getFpgaIpv4(args)

Definition at line 310 of file tc_TcpRecv.py.

ipHost

tc_TcpRecv.ipHost = int(ipaddress.IPv4Address(ipHostStr))

Definition at line 382 of file tc_TcpRecv.py.

ipHostStr

string tc_TcpRecv.ipHostStr = socket.gethostbyname(hostname)

Definition at line 367 of file tc_TcpRecv.py.

ipResMngr

tc_TcpRecv.ipResMngr = getResourceManagerIpv4(args)

Definition at line 318 of file tc_TcpRecv.py.

parser

tc_TcpRecv.parser = argparse.ArgumentParser(description='A script to receive TCP data from an FPGA module.')

                                        #

MAIN # #

Definition at line 280 of file tc_TcpRecv.py.

portFpgaServer

tc_TcpRecv.portFpgaServer = XMIT_MODE_LSN_PORT

Definition at line 322 of file tc_TcpRecv.py.

portResMngr

tc_TcpRecv.portResMngr = getResourceManagerPort(args)

Definition at line 326 of file tc_TcpRecv.py.

reqMsgAsBytes

tc_TcpRecv.reqMsgAsBytes = struct.pack(">IHH", ipHost, dpHost, 0)

Definition at line 419 of file tc_TcpRecv.py.

seed

tc_TcpRecv.seed = args.seed

Definition at line 456 of file tc_TcpRecv.py.

size

tc_TcpRecv.size = args.size

Definition at line 464 of file tc_TcpRecv.py.

str

tc_TcpRecv.str

Definition at line 281 of file tc_TcpRecv.py.

tcpClientSock

tc_TcpRecv.tcpClientSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

Definition at line 343 of file tc_TcpRecv.py.

tcpListenSock

tc_TcpRecv.tcpListenSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

Definition at line 392 of file tc_TcpRecv.py.

tcpServerSock

tc_TcpRecv.tcpServerSock

Definition at line 441 of file tc_TcpRecv.py.

TODO_MAX_SEG_SIZE

int tc_TcpRecv.TODO_MAX_SEG_SIZE = 2048

Definition at line 463 of file tc_TcpRecv.py.

type

tc_TcpRecv.type

Definition at line 281 of file tc_TcpRecv.py.

verbose

tc_TcpRecv.verbose = args.verbose

Definition at line 478 of file tc_TcpRecv.py.