c# - 模拟纯 Aloha 协议(protocol)

Question

我正在尝试模拟 Pure Aloha 协议(protocol)。经过一些研究，我了解了该协议(protocol)的工作原理。简而言之，假设我们有 5 个节点并且帧大小是固定的。所有节点共享一个 channel 。当节点有数据要发送时，它会通过 channel 发送数据。如果两个或多个节点尝试同时(或在同一时间帧内)发送帧，则数据包会发生冲突，并且每个节点都必须再次重新发送数据包。碰撞帧必须在随机时间后重新传输，这将降低再次碰撞的可能性。

这就是我目前所拥有的。我有五个节点 [A-E]。这是五个站。每个节点都有自己的整数列表。这些是发送帧的时间。我生成了五个随机帧，结果如下:- 例如A 5、A 7、B 7、C 8、E 9。这些是随机生成的，意味着节点 A 在时间 = 5 和时间 = 7 时要发送两帧。帧 B 在时间 = 7 时要发送一帧。由于我们有两个帧试图同时发送一个帧，因此我们发生了冲突。

使用这段代码我得到以下结果...

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Timers;

namespace Test_v1
{
    public class Simulation
    {
        Utility utils = new Utility();
        static Random random = new Random();
        private Timer t1;
        int currentTime;
        int frameSize;               //frame size in bits.
        int channelCapacity;         //channel capacity in bits.
        int frameTime;               //time to transmit one frame on the channel in milliseconds.
        private List<Node> nodeList;
        Node A;
        Node B;
        Node C;
        Node D;
        Node E;
        int collisions = 0;

        public Simulation()
        {
            frameSize = 10;
            channelCapacity = 100;
            frameTime = (frameSize / channelCapacity) * 100;
            nodeList = new List<Node>();
            A = new Node(); A.stationName = "Station A";
            B = new Node(); B.stationName = "Station B";
            C = new Node(); C.stationName = "Station C";
            D = new Node(); D.stationName = "Station D";
            E = new Node(); E.stationName = "Station E";
            nodeList.Add(A);
            nodeList.Add(B);
            nodeList.Add(C);
            nodeList.Add(D);
            nodeList.Add(E);

            generateFrames(5);

            t1 = new Timer(100);
            t1.Elapsed += new ElapsedEventHandler(IntervalTimerElapsed);
            t1.Start();


        }


        protected void IntervalTimerElapsed(object sender, EventArgs e)
        {
            int framesOnChannel = 0;

            foreach (Node n in nodeList)
            {
                for (int i = 0; i < n.queue.Count; i++)
                {
                    if (currentTime == n.queue[i])
                    {
                        Console.WriteLine(currentTime + " " + n.stationName + " " + n.queue[i]);                    
                        framesOnChannel = framesOnChannel + 1;
                        collisions = collisions + 1;
                        if(framesOnChannel > 1)
                        n.queue[i] = BackOff(n) + currentTime;
                    }
                    else
                    {
                        Console.WriteLine(currentTime);
                    }

                }
            }
            currentTime++;
            if (framesOnChannel > 1)
            {
                Console.WriteLine("Frames on Channel:" + framesOnChannel + " Collision!");
            }
            else
            {
                Console.WriteLine("Frames on Channel:" + framesOnChannel);
            }

            framesOnChannel = 0;

            if (currentTime > 10)
                t1.Stop();
        }

        private void generateFrames(int load_G)
        {
            for (int i = 0; i < load_G; i++)
            {
                Node randomStation = getRandomNode();                
                randomStation.queue.Add(utils.RandomNumber(0, 10));
            }

            foreach (Node n in nodeList)
            {
               n.queue.Sort();       
            }
        }

        private int BackOff(Node node)
        {
            int k = node.attempts;

            if (k > 10)
                k = 10;

            int R = (int)Math.Round(Math.Pow(2, k) - 1);
            int backOffTime = random.Next(0, R) * frameTime;

            return backOffTime + (frameTime * 2);
        }

        private Node getRandomNode(){
        switch (random.Next(1, 6))
            {
                case 1:
                    return A;

                case 2:
                    return B;

                case 3:
                    return C;

                case 4:
                    return D;

                default:
                    return E;
            }
        } 
    }
}

到目前为止，我已经设法检测到何时发生碰撞。a) 我需要以某种方式将 Backoff 方法应用于那些在将来发生碰撞并发送它们的节点。当检测到碰撞但没有任何反应时，我应用了退避。在这种情况下，所有帧都应该发生冲突，因为要成功传输一个帧，必须在两个滴答的时间内只有一个帧。

b) 我需要计算成功传输的次数。如果在 2 个滴答内没有发送其他帧，则传输成功。例如，如果一个帧在时间 = 1 时发送。在时间 = 1 到时间 = 3 内必须没有其他帧才能成功。

在此先感谢您的帮助。如果有什么不清楚的地方请告诉我。

Answer 1

假设您想创建一个单线程模拟，您有两种选择 - 时间驱动模拟，或事件驱动模拟。两者之间的区别在于模拟时间(或模拟时钟)前进的方式。时间推进的方式决定了模拟运行的方式:

<强>1。时间驱动的模拟

在时间驱动的模拟中，时间连续运行，并在时序循环中以小的、离散的值递增。计时循环增加模拟时钟并迭代模拟的每个组件(例如节点、 channel 等)，询问每个组件当前是否想要做某事。

模拟组件根据当前模拟时间(由计时循环传递)及其预定义行为做出决策。例如，节点可能决定在模拟时间 A、B 和 C 发送数据包。

完成每次迭代后，时序循环将仿真时间提前一个固定的小量，然后重新开始。在此模型中，要创建对实际时间的良好近似，时间增量必须非常小。

<强>2。事件驱动模拟

在事件驱动的模拟中，事情发生是因为是时候发生了。时间不会有争议地前进，而是从一个甚至另一个。在这样的模拟中，每个模拟元素(节点、消息、共享 channel 等)都会生成定时事件(比如“我需要在时间 XXX 发送数据包”，或“消息已在时间 XXX 到达”)。事件被放入按时间排序的队列中，定时循环一次一个地出列事件。

每当事件出队时，都会通过通知事件的所有相关实体来处理。例如，如果出队事件是“节点 A 在时间 5 通过 channel C 向节点 B 发送了一个数据包”，则通过将发送的数据包通知 channel C 来处理该事件。当获悉该事件时， channel C 可以反过来创建事件作为响应。例如，它可以创建一个新事件，表示“来自节点 A 的消息已在时间 6 通过 channel C 传递到节点 B”，从而创建一个模拟，其中消息需要 1 个模拟时间单位才能在 channel 中传播(在我的示例中，从时间 5 到时间 6)。这些响应事件被放回队列中，并按时间排序。

接下来，计时循环只是将下一个事件从队列中取出，并将模拟时钟提前到下一个事件的时间。这样，如果长时间没有模拟事件发生，事件循环就会向前跳过，这与时间驱动的模拟不同。

这是一种(通常)更好、更有效的系统模拟方法，但它也稍微复杂一些。