ProtocolStack/RateManager.cs

using System;
using System.Threading;

namespace ProtocolStack
{
        public class RateManager
        {
                int BDP; // bandwith delay product
                private StackInterface thisStack;
                private uint bytesSinceSegmentSent;
                private uint bytesSinceAckableSent;
                private Object counterSyncRoot; 
                private Object creditSyncRoot;
                int sendCredit; 
                int creditAtLastACKableRx;
                                

                public RateManager(RemoteHostComms remoteHost) {
                        thisStack = remoteHost.thisStack;
                        counterSyncRoot = new Object();
                        creditSyncRoot = new Object();
                        Init();
                }

                public void ResetConnection() {
                        Console.WriteLine("Rate Manager Reset Started ...");
                        Init();
                        Console.WriteLine("... Rate Manager Reset Completed");
                }

                private void Init() {
                        BDP = thisStack.settings.DefaultBandwidthDelayProdut; // 8kb Bandwidth Delay product (default in settings)
                        bytesSinceSegmentSent = 0;
                        bytesSinceAckableSent = 0;
                        sendCredit = BDP;
                        creditAtLastACKableRx = sendCredit;
                }

                public RateInfo GetRateInfoForTx(bool IsAckable) {
                        uint bytesReceived = 0;
                        if (!IsAckable) { // regular segment
                                lock (counterSyncRoot) {
                                        // get and clear 'bytesSinceLastRegularSegment'
                                        bytesReceived = bytesSinceSegmentSent;
                                        bytesSinceSegmentSent = 0;
                                }
                        } else { // ackable segment
                                lock (counterSyncRoot) {
                                        // get and clear 'bytesSinceLastAckableSegment'
                                        bytesReceived = bytesSinceAckableSent;
                                        bytesSinceAckableSent = 0;
                                        bytesSinceSegmentSent = 0;
                                }
                        }
                        return new RateInfo(bytesReceived);
                }

                public void ProcessReceivedSegmentHeaders(ref SegmentHeaders headers, uint dataLength) {
                        // add to bytes received
                        lock (counterSyncRoot) {
                                bytesSinceAckableSent += dataLength;
                                bytesSinceSegmentSent += dataLength;
                        }
                        // add credit information
                        if (!headers.IsResynch) {
                                lock (creditSyncRoot) {
                                        if (headers.IsAckable) {
                                                int temp = sendCredit;
                                                sendCredit = (int)(creditAtLastACKableRx + headers.SynchOrRate);
        //                                      Console.WriteLine("Forcing Send Credit from {0} to {1} ({2} + {3})", temp, sendCredit, creditAtLastACKableRx, headers.SynchOrRate);
                                                creditAtLastACKableRx = sendCredit;
                                        } else { // non-ackable segment
                                                sendCredit += (int)headers.SynchOrRate;
//                                              Console.WriteLine("[+] New Send Credit = {0} bytes", sendCredit);
                                        }
                                Monitor.PulseAll(creditSyncRoot);
                                }
                        } else {
                                // TODO: What happens when we have resynch segments?
                                // no change to send credit
                        }
                }

                public void DecreaseSendCredit(int amount) {
                        lock (creditSyncRoot) {
                                sendCredit -= amount;
                                creditAtLastACKableRx -= amount;
                                if (sendCredit < 0) { sendCredit = 0; }
//                              Console.WriteLine("[-] New Send Credit = {0} bytes", sendCredit);
                                Monitor.PulseAll(creditSyncRoot);
                        }

                }

                public bool WaitForSend(uint datagramSize, int secondsToWait) {
                        bool result = true;
                        lock(creditSyncRoot) {
                                while (sendCredit <= datagramSize) {
                                        Console.WriteLine("Waiting for {0} bytes of credit", datagramSize);
                                        if (!Monitor.Wait(creditSyncRoot, secondsToWait * 1000)) { // if lock was not re-aquired before timeout
                                                result = false;
                                                break;
                                        }
                                }
                                return result; 
                        }
                }

                public bool CanSend(uint datagramSize) {
                        return (sendCredit > datagramSize);
                }
        }

        public class RateInfo { 
                /* not entirely sure how this one works, but it is what is sent along to tell
                 * the other host how fast to communicate.
                 * */
                public uint data;
                public RateInfo(uint bytesReceived) {
                        data = bytesReceived;                   
                }
        }
}

---