/base/Applications/Network/UdpBlast/UdpBlast.cs

////////////////////////////////////////////////////////////////////////////////

//

//  Microsoft Research Singularity

//

//  Copyright (c) Microsoft Corporation.  All rights reserved.

//

//  Note:   Simple Singularity test program.

//

using System;

using System.Diagnostics;

using System.Net.IP;

using System.Threading;



using Microsoft.Singularity;

using Microsoft.SingSharp;

using Microsoft.Singularity.Channels;

using Microsoft.Singularity.Directory;

using NetStack.Contracts;

using NetStack.Channels.Public;



using Microsoft.Contracts;

using Microsoft.SingSharp.Reflection;

using Microsoft.Singularity.Applications;

using Microsoft.Singularity.Io;

using Microsoft.Singularity.Configuration;

[assembly: Transform(typeof(ApplicationResourceTransform))]



namespace Microsoft.Singularity.Applications.Network

{

    [ConsoleCategory(HelpMessage="Send UDP data to and ipAddress and port",

                     DefaultAction=true)]

    internal class Parameters {

        [InputEndpoint("data")]

        public readonly TRef<UnicodePipeContract.Exp:READY> Stdin;



        [OutputEndpoint("data")]

        public readonly TRef<UnicodePipeContract.Imp:READY> Stdout;



        [Endpoint]

        public readonly TRef<UdpContract.Imp:Start> udpRef;



        [LongParameter("p", Mandatory=false, HelpMessage="Packet size (bytes)", Default = 1500)]

        internal long packetBytes;



        [LongParameter("r", Mandatory=false, HelpMessage="Transmission rate in bits per second", Default = 64000)]

        internal long bitsPerSecond;



        [LongParameter("t", Mandatory=false, HelpMessage="Seconds to send packets for", Default = 30)]

        internal long seconds;



        [BoolParameter("v", Mandatory=false, HelpMessage="Verbose output", Default = true)]

        internal bool verbose;



        [StringParameter("Address", Mandatory=true, Position=0, HelpMessage="Destination IP Address")]

        internal string address;



        [LongParameter("port", Mandatory=true, Position=1, HelpMessage="Destination UDP port")]

        internal long port;



        reflective internal Parameters();



        internal int AppMain() {

            return UdpBlast.AppMain(this);

        }

    }



    public class UdpBlast

    {

        private const uint FixedHeaderBytes = 42; // Ether + IP + UDP



        private static bool verbose;



        public static void VerboseWriteLine(string format,

                                            params Object [] args)

        {

            string msg = String.Format(format, args);

            DebugStub.WriteLine(msg);

            if (verbose) {

                Console.WriteLine(format, args);

            }

        }



        private static void

        SendPackets(

            UdpConnectionContract.Imp:ReadyState! udpConn,

            long   bitsPerSecond,

            uint   bytesPerPacket,

            long   durationSeconds

            )

        {

            DateTime startTime  = DateTime.Now;

            DateTime endTime    = (startTime +

                                   TimeSpan.FromSeconds(durationSeconds));



            DateTime secondStart = startTime;

            DateTime secondEnd   = startTime + TimeSpan.FromSeconds(1);



            DateTime now = startTime;



            uint second         = 0;

            long bitsThisSecond = 0;

            long totalBits      = 0;

            int  totalPackets   = 0;



            VerboseWriteLine("UdpBlast: {0} bytesPerPacket, Limiting transfer to {1} bitsPerSecond, for {2} seconds",

                              bytesPerPacket, bitsPerSecond, durationSeconds);



            while (now < endTime) {

                int pps = 0;



                while (now < secondEnd && bitsThisSecond < bitsPerSecond) {

                    // XXX: Just bursting packets out for

                    // now rather than pacing them,

                    // interested mainly in saturation case.

                    byte[] in ExHeap pkt;

                    uint pktSize;

                    if ((long)bytesPerPacket * 8 < bitsPerSecond - bitsThisSecond) {

                        pktSize = bytesPerPacket;

                    }

                    else {

                        // Send a final runt packet for this cycle to keep us under

                        // the agreed total bits per second rate.

                        pktSize = (uint)((bitsPerSecond - bitsThisSecond) / 8);

                        if (pktSize <= FixedHeaderBytes) {

                            pktSize = FixedHeaderBytes + 1;

                        }

                    }

                    pkt = new [ExHeap] byte [pktSize - FixedHeaderBytes];

                    udpConn.SendWrite(pkt);

                    udpConn.RecvOK();

                    bitsThisSecond += pktSize * 8;

                    now = DateTime.Now;

                    pps++;

                    totalPackets++;

                }



                while (now < secondEnd) {

                    Thread.Sleep(0);

                    now = DateTime.Now;

                }



                TimeSpan tau = secondEnd - secondStart;



                long bytesPerSecond = (bitsThisSecond / tau.TotalSeconds) / 8;



                VerboseWriteLine(

                    "Round {0} duration(secs) {1:f2} rate (pps) {2} rate (bps) {3:e3}, bytes/sec {4:e3}",

                    second, tau.TotalSeconds,

                    pps,

                    bitsThisSecond / tau.TotalSeconds,

                    bytesPerSecond);



                second++;

                totalBits      += bitsThisSecond;

                bitsThisSecond  = 0;

                secondStart     = now;

                secondEnd       = now + TimeSpan.FromSeconds(1);

            }



            Console.WriteLine(

                "Average rate: packets/sec {0}, bits/sec {1:e3}, bytes/sec {2:e3}",

                totalPackets / (now - startTime).TotalSeconds,

                totalBits / (now - startTime).TotalSeconds,

                (totalBits / (now - startTime).TotalSeconds) / 8

                );

        }



        public static int

        Blast(

            [Claims] UdpConnectionContract.Imp:ReadyState! udpConn,

            IPv4   address,

            ushort port,

            long   bitsPerSecond,

            long   bytesPerPacket,

            long   durationSeconds

            )

        {

            Console.WriteLine("UdpBlast({0}, {1})", address, port);



            try {

                udpConn.SendConnectWithAnyLocalEndPoint((uint)address, port);



                switch receive {

                    case udpConn.OK() :

                        // success;

                        Console.WriteLine("Connected");

                        break;



                    case udpConn.InvalidEndPoint(ip, rejectedPort) :

                        throw new Exception("udpConn address and port rejected");



                    case udpConn.ChannelClosed() :

                        throw new Exception("udpConn channel closed");

                }



                SendPackets(udpConn,

                            bitsPerSecond,

                            (uint)bytesPerPacket,

                            durationSeconds);

                Console.WriteLine("Closing connection");



                udpConn.SendClose();

            }

            catch (Exception e) {

                Console.WriteLine("Unexpected exception: {0}", e);

            }

            finally {

                delete udpConn;

            }



            return 0;

        }



        internal static int AppMain(Parameters! config)

        {

            IPv4 host;

            try {

                host = IPv4.Parse(config.address);

            }

            catch (FormatException e) {

                Console.WriteLine("{0}: {1}", e, config.address);

                return -1;

            }



            if (config.port > 65536 || config.port < 0) {

                Console.WriteLine("Port number out of range: {0}", config.port);

                return -1;

            }

            ushort port = (ushort) config.port;



            if ((uint)config.packetBytes < FixedHeaderBytes) {

                Console.WriteLine("Packet size needs to be larger than fixed header size ({0} bytes)", FixedHeaderBytes);

                return -1;

            }



            UdpBlast.verbose = config.verbose;



            UdpContract.Imp udpConn = ((!)config.udpRef).Acquire();

            if (udpConn == null) {

                Console.WriteLine("Could not initialize TCP endpoint.");

                return 1;

            }

            udpConn.RecvReady();



            UdpConnectionContract.Imp! connImp;

            UdpConnectionContract.Exp! connExp;

            UdpConnectionContract.NewChannel(out connImp, out connExp);



            udpConn.SendCreateUdpSession(connExp);

            connImp.RecvReady();

            delete udpConn;



            return Blast(connImp,

                         host, port,

                         config.bitsPerSecond,

                         config.packetBytes,

                         config.seconds

                         );

        }

    } // end class UdpBlast

}