0

我想做的是将任务随机分布在多个服务器上，如果可能的话，偏差很小。到目前为止，我所做的工作是能够将任务随机分布在不同的服务器上。问题是，每当我将任务分布在服务器上时，它都会在每个服务器上分布 1-3 个任务。使用的负载平衡方法是 Power of Two Choices。如果我的概念错了，请原谅我。

两个选择的力量是选择两个随机队列的地方，其中任务最少的一个被分配一个任务。如我错了请纠正我。

下面的照片显示了我当前的输出。 电流输出

我想要的是这个 预期产出

我的主要文件如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;



namespace C1._2
{

    class Program
    {
        static void details(Server[] server, int num)
        {
            int count = 0;
            for (int i = 0; i < server.Length; i++)
            {
                if (server[i].Tasks == num)
                {
                    count++;
                }
            }
            Console.WriteLine("There are " + count + " servers with " + num + " tasks.");
        }
        static void Main(string[] args)
        {
            Random rand = new Random();
            int n = 256; //number of tasks
            int m; //number of servers
            m = 64;//Convert.ToInt32(Console.ReadLine())

            Console.WriteLine("Number of servers(m): " + m);

            int d = 1; //random servers to be chosen

            Console.WriteLine("Number of tasks(n): " + n);

            Console.WriteLine("Number of randomly selected server(d): " + d);

            //Main server setup
            Server[] servers = new Server[m];

            for (int i = 0; i < m; i++)
            {
                servers[i] = new Server(i);
            }

            if (d == 1)
            {
                for (int i = 0; i < n; i++)
                {
                   int randS = rand.Next(m);
                   servers[randS].Tasks++;
                }
            }
            //Power of Two choice algorithm is here
            if (d == 2)
            {
                for(int i = 0; i < n; i++)
                {
                    Server s1 = servers[rand.Next(m)];
                    Server s2 = servers[rand.Next(m)];
                    if (s1.Tasks < s2.Tasks)
                    {
                        for(int j = 0; j < m; j++)
                        {
                            if (servers[j].SNo == s1.SNo)
                            {
                                servers[j].Tasks++;
                            }
                        }
                    }
                    else
                    {
                        for (int j = 0; j < m; j++)
                        {
                            if (servers[j].SNo == s2.SNo)
                            {
                                servers[j].Tasks++;
                            }
                        }
                    }
                }
            }
            //Server min max
            Server maxServer = new Server();
            maxServer = servers[0];
            for (int i = 0; i < m; i++)
            {
                if (maxServer.Tasks < servers[i].Tasks)
                {
                    maxServer = servers[i];
                }
            }
            Console.WriteLine("\nIndex of servers with most tasks: " + "[" + maxServer.SNo + "]");
            Console.WriteLine("Highest number of tasks: " + maxServer.Tasks+"\n");

            Server minServer = new Server();
            minServer = servers[0];
            for (int i = 0; i < m; i++)
            {
                if (minServer.Tasks > servers[i].Tasks)
                {
                    minServer = servers[i];
                }
            }
            Console.WriteLine("\nIndex of servers with least tasks: " + "[" + minServer.SNo + "]");
            Console.WriteLine("Lowest number of tasks: " + minServer.Tasks+"\n");

            //details
            details(servers, 0);
            details(servers, 1);
            details(servers, 2);
            details(servers, 3);
            details(servers, 4);
            details(servers, 5);
            details(servers, 6);
            details(servers, 7);
            details(servers, 8);
            details(servers, 9);


        }
    }
}

附带的服务器类：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace C1._2
{
    class Server
    {
        private int server_number;
        private int task;

        public Server()
        {
            this.server_number = (int)0;
            this.task = 0;
        }
        public Server(int sn)
        {
            this.server_number = sn;
            this.task = 0;
        }
        public int SNo
        {
            get
            {
                return this.server_number;
            }
            set
            {
                this.server_number = value;
            }
        }
        public int Tasks
        {
            get
            {
                return this.task;
            }
            set
            {
                this.task = value;
            }
        }

    }
}

关于如何做到这一点的任何建议？

4

2 回答 2

0

更新了负载均衡算法

if (d == 2)
{
    for(int i = 0; i < n; i++)
    {
        int a = rand.Next(m);
        int b = rand.Next(m);
        servers[a < b ? a : b].Tasks++;
    }
}

我的问题是代码过于复杂。它上面所做的是它从可用的总服务器中随机选择两个随机服务器。比较哪个服务器的负担/任务最少，并为其分配任务。

于 2019-09-11T12:11:25.730 回答
0

当你说“随机......任务最少的那个”对我来说意味着不是随机的。但我想我明白你想要什么。因此，我们需要选择任务最少的项目列表，并选择其中一项。

我重写了类 Program 的一部分。让我知道这是否是预期的结果。

class Program
{


    static void Main(string[] args)
    {
        //Random rand = new Random();
        int numberOfTasks = 256; //number of tasks
        int numberOfServers; //number of servers
        numberOfServers = 64;//Convert.ToInt32(Console.ReadLine())

        Console.WriteLine("Number of servers(m): " + numberOfServers);

        //int d = 1; //random servers to be chosen

        Console.WriteLine("Number of tasks(n): " + numberOfTasks);

        //Console.WriteLine("Number of randomly selected server(d): " + d);

        //Main server setup
        Server[] servers = new Server[numberOfServers];

        for (int i = 0; i < numberOfServers; i++)
        {
            servers[i] = new Server(i);
        }

        for(int i = 0; i < numberOfTasks; i++){

            var minimumTasksValue = servers.Min(x => x.Tasks);
            var listOfServersToSpread = servers.Where(x => x.Tasks == minimumTasksValue).ToList();

            Random rand = new Random();
            var randomServer = rand.Next(0, listOfServersToSpread.Count() - 1);
            listOfServersToSpread[randomServer].Tasks++;
        }


        //Server min max
        Server maxServer = new Server();
        maxServer = servers[0];
        for (int i = 0; i < numberOfServers; i++)
        {
            if (maxServer.Tasks < servers[i].Tasks)
            {
                maxServer = servers[i];
            }
        }
        Console.WriteLine("\nIndex of servers with most tasks: " + "[" + maxServer.SNo + "]");
        Console.WriteLine("Highest number of tasks: " + maxServer.Tasks + "\n");

        Server minServer = new Server();
        minServer = servers[0];
        for (int i = 0; i < numberOfServers; i++)
        {
            if (minServer.Tasks > servers[i].Tasks)
            {
                minServer = servers[i];
            }
        }
        Console.WriteLine("\nIndex of servers with least tasks: " + "[" + minServer.SNo + "]");
        Console.WriteLine("Lowest number of tasks: " + minServer.Tasks + "\n");

        //details
        details(servers);

        Console.ReadLine();
    }


    static void details(Server[] server)
    {
        var numberOfTasksAvailable = server.Select(x => x.Tasks).Distinct().OrderBy(x => x);

        foreach(var numberOfTasks in numberOfTasksAvailable)
        {
            Console.WriteLine("There are " + server.Count(x => x.Tasks == numberOfTasks) + " servers with " + numberOfTasks + " tasks.");
        }            
    }
}
于 2019-09-11T12:15:59.977 回答