Subversion Repositories udp_ip__core

/*
 * Copyright (C) 2010 Simon A. Berger
 *
 * This program is free software; you may redistribute it and/or modify its
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
 * for more details.
 */
 
 
/*
 * This is the code used for the evaluation of the FPGA/PC communication using
 * UDP/IP. 
 * This program can operate in two modes, which correspond to the two evaluations
 * in the paper:
 * - one way test: receive packets for 10 seconds. Calculate actual number of
 *   sent packets from the serial numbers.
 * - two way (duplex) test: send a fixed number of packets and count received
 *   packets.
 *
 * The program mode is controlled with the DUPLEX_TEST constant.
 *
 * To compile this program use "javac GigaRxLossy.java"
 * To run the program use "java GigaRxLoss"
 */
 
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.nio.ByteBuffer;
import java.nio.MappedByteBuffer;
import java.nio.IntBuffer;
import java.nio.DoubleBuffer;
 
import java.nio.channels.ClosedByInterruptException;
import java.nio.channels.DatagramChannel;
 
 
public class GigaRxLossy {
	public static boolean isValid( ByteBuffer b, int size ) {
		int ref = b.get();
 
		for( int i = 1; i < size; i++ ) {
			if( b.get() != ref ) {
 
				return false;
			}
		}
 
		return true;
	}
 
	public static void main(String[] args) throws IOException, InterruptedException {
		final int MTU = 1500;
 
		final SocketAddress rxaddr = new InetSocketAddress( 21844 );
 
		final DatagramChannel rxc = DatagramChannel.open();
 
		rxc.socket().bind(rxaddr);
 
		final SocketAddress txsendtoaddr = new InetSocketAddress( "192.168.1.1", 21845 );
 
 
		// set this constant to:
		// - false for the one-way test
		// - true for the duplex test
 
		boolean DUPLEX_TEST = !true;
 
 
		boolean haveTx;
		boolean trigger;
		if( DUPLEX_TEST ) {
			haveTx = true;
			trigger = false;
 
		} else {
			haveTx = false;
			trigger = true;
		}
 
 
		final DatagramChannel txc;
 
		if( haveTx || trigger )
		{
			txc = DatagramChannel.open();
			txc.socket().bind(null);
		} else {
			txc = null;
		}
 
		final Thread reader = new Thread() {
			// this is the recaiver thread
			@Override
			public void run() {
 
				java.nio.ByteBuffer rxb = ByteBuffer.allocateDirect(MTU);
 
				boolean first = true;
				int firstser = -1;
				int lastser = -1;
				int nrec = 0;
				long time = System.currentTimeMillis();
 
				long rxbytes = 0;
				long txn = 0;
				try {
					//rxc.connect(rxaddr);
 
 
					while( !isInterrupted() ) {
 
						rxb.rewind();
						rxc.receive(rxb);
						int rxsize = rxb.position();
 
						rxb.rewind();
						//int ser = rxb.asIntBuffer().get(0);
						IntBuffer ib = rxb.asIntBuffer();					
//						DoubleBuffer db = rxb.asDoubleBuffer();					
 
						int ser = ib.get()>>>24;
 
						// calculate the number of actually sent packets from the serial
						// number.
						if( !first ) {
							if( ser < lastser ) {
								txn += ser - (lastser - 256 );					
							} else {
								txn += ser - lastser;
							}
							//System.out.printf( "int %d\n", txn );
						} else {
							first = false;
						}
						lastser = ser;
 
						if( firstser == -1 ) {
							firstser = ser;
						}
 
 
						// for maximum speed the validity check may be disabled as the current
						// implementation is fairly inefficient. In our tests we never got any
						// packet corruption.
						boolean CHECK_VALID = true;
						if( CHECK_VALID ) {
							if( !isValid( rxb, rxsize ) ) {
								System.out.println( "invalid" );
							}
						}
//						lastser = ser;
						nrec++;
						rxbytes+=rxsize;
 
					}
				} catch( ClosedByInterruptException e ) {
					System.out.printf( "reader: interrupted. bye ...\n" );
 
				} catch (IOException e) {
 
					// TODO Auto-generated catch block
					e.printStackTrace();
					throw new RuntimeException( "bailing out." );
				}
				long dt = System.currentTimeMillis() - time;
				System.out.printf( "%d bytes in %d ms: %.2f Mb/s\n", rxbytes, dt, rxbytes / (dt * 1000.0) );
				int serrange = (lastser - firstser) + 1;
				System.out.printf( "nrec: %d of %d (%.2f%%)\n", nrec, txn, nrec / (float)txn * 100.0 );
			}
		};
 
		if( !trigger ) {	
			reader.start();
		}
 
		if( haveTx ) {
			Thread writer = new Thread() {
				// this is the sender thread.
				@Override
				public void run() {
					// TODO Auto-generated method stub
					//java.nio.ByteBuffer txb = MappedByteBuffer.allocate(MTU);
					java.nio.ByteBuffer txb = java.nio.ByteBuffer.allocateDirect(MTU);
					int i = 0;
					long time = System.currentTimeMillis();
 
					long txbytes = 0;
					long nj = 0;
					while( i < 1000000 ) {
						txb.rewind();
 
						txb.asIntBuffer().put(0, i);
						txb.rewind();
						try {
							txbytes += txc.send(txb, txsendtoaddr);
 
 
 
						} catch (IOException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
						i++;
 
						if( i % 10000 == 0 ) {
							System.out.printf( "tx -> rx %d\n", i );
						}
 
	//					if( ack.i != -1 ) {
	//						i = ack.i;
	//						ack.i = -1;
	//					}
					}
					long dt = System.currentTimeMillis() - time;
					System.out.printf( "%d bytes in %d ms: %.2f Mb/s\n", txbytes, dt, txbytes / (dt * 1000.0) );
				}
			};
 
 
 
			writer.start();
 
			writer.join();
			reader.interrupt();
		} else {
			if( trigger ) {
				java.nio.ByteBuffer txb = java.nio.ByteBuffer.allocateDirect(MTU);
                               	txc.send(txb, txsendtoaddr);
				Thread.sleep( 1000 );
			}
			reader.start();
			Thread.sleep(10000);
			reader.interrupt();
		}
	}
}