标签: round-robin

基本上我有玩家名单,我想把它们配对,这样每个玩家都会玩一次.找到这些数据的最快方法是什么？

Linux内核中是否可以同时使用两个以上的调度策略？FIFO和Round Robin可以在同一台机器上运行吗？

我想使用HAProxy作为负载均衡器.我想把两个rabbitmq服务器放在haproxy后面.rabbitmq服务器都在EC2的不同实例上.我按照此引用配置了HAProxy服务器.我的工作但问题是消息不以roundrobin模式发布.消息仅在一台服务器上发布.我的要求有不同的配置吗？

我在/etc/haproxy/haproxy.cfg中的配置

listen rabbitmq 0.0.0.0:5672
     mode    tcp
     stats   enable
     balance roundrobin
    option tcplog
    no  option clitcpka
    no option srvtcpka
     server  rabbit01 46.XX.XX.XX:5672 check
     server  rabbit02 176.XX.XX.XX:5672 check
listen  web-service *:80
          mode    http
         balance roundrobin
        option httpchk HEAD / HTTP/1.0
         option httpclose
        option forwardfor
        option httpchk OPTIONS /health_check.html
        stats enable
        stats refresh 10s
        stats hide-version
        stats scope   .
        stats uri     /lb?stats
        stats realm   LB2\ Statistics
        stats auth    admin:Adm1nn

更新:

我对此进行了一些研发,发现HAProxy是在rabbitmq服务器上进行循环连接.例如:如果我请求10个连接,那么它将在我的2个rabbitmq服务器上循环10个连接并发布消息.

但问题是我想要循环消息,而不是它应该由HAProxy服务器管理的连接.即如果我一次向HAProxy发送1000 msg,那么500 msg应该转到兔子服务器1,500 msg应该转到兔子服务器2.我必须遵循的配置是什么？

更新:

我还测试了lessconn的平衡,但HAProxy的行为是出乎意料的.我在serverfault.com上发布了这个问题

我收到了这个问题

考虑一个运行十个I/0绑定任务和一个CpU绑定任务的系统.假设I/O绑定任务每毫秒CPU计算发出一次I/O操作,并且每个I/O操作需要10毫秒才能完成.还假设上下文切换开销为.1毫秒,并且所有进程都是长时间运行的任务描述以下情况时循环调度程序的CPU利用率:

一个.时间量是1毫秒

湾 时间量是10毫秒

我找到了答案

时间量是1毫秒:无论调度哪个进程,调度程序都会为每个上下文切换产生0.1毫秒的上下文切换成本.这导致CPU利用率为1/1.1*100 = 91%.

时间量是10毫秒:I/O绑定任务在耗尽仅1毫秒的时间量后会产生上下文切换.因此,遍历所有进程所需的时间是10*1.1 + 10.1(因为每个I/O绑定任务执行1毫秒然后引发上下文切换任务,而CPU绑定任务执行10毫秒之后才会产生上下文开关).因此CPU利用率为20/21.1*100 = 94%.

我唯一的问题是这个人如何得出CPU利用率的公式？我似乎无法忍受他/她获得的数字20/21.1*100 = 94%和1/1.1*100 = 91%.

我正在制作一个cpu调度模拟器(用于学校项目).我的功能有问题roundRobin.当我这样做c.get(i).jobTime -= 2;,c.get(i).jobTime -= 1;它影响我的其他ArrayLists,所以我不能做我的其他功能.在我打电话之前roundRobin2我的名单是完全正常的.为什么会这样？

例如,这就是我的list4样子roundRobin2

list 4: [Job101 0, Job102 0, Job103 0, Job104 0, Job105 0, Job106 0]

这就是我在文件中读取的方式,并将Jobs对象放入我ArrayList的文件中.

    Scanner input = new Scanner(new File("testdata1.txt"));
    ArrayList<Jobs> list = new ArrayList<Jobs>();
    ArrayList<Jobs> list2 = new ArrayList<Jobs>();
    ArrayList<Jobs> list3 = new ArrayList<Jobs>();
    ArrayList<Jobs> list4 = new ArrayList<Jobs>();


    Jobs first;

    while(input.hasNext())
    {
        first = new Jobs(input.next(), input.nextInt());
        list.add(first);
        list2.add(first);
        list3.add(first);
        list4.add(first);
    }

    input.close();

这是我的 …

我目前正在为SalesLead< - > SalesPerson情况实施许多不同的分配算法.一般的想法很简单:

1. 一个SalesLead公共网站上签约

2. 代码自动分配SalesLead给SalesPerson使用循环调度(Leads SalesPersons按相同顺序分配)

我有一些严重的编码器阻止如何实际执行此操作,以确保每次都以相同的顺序从数据库中提取代理,并使用另一个表来存储分配了SalesLead的最后一个代理(可能实际上对于构建报告非常有用,或者至少在以后使用回溯方法.我离开基地了吗？

澄清: 该代码目前与销售人员不匹配.这是一个全新的功能.目前,他们可以注册特定的SalesPerson,但我们希望能够自动分配它们.

JVM DNS缓存如何处理DNS轮询？它是为域缓存所有IP地址，然后在它们之间轮换？还是缓存一个IP地址，然后将其用于将来的所有请求，直到缓存过期？

我有两个列表

num = [1,2,3,4]
names = ['shiva','naga','sharath','krishna','pavan','adi','mulagala']

我想并行打印两个列表,如果一个列表(num)结束,我想重复第一个列表(num),直到第二个(名称)列表结束.

现在我想要输出为

1 for shiva
2 for naga
3 for sarath
4 for krishna
1 for pavan
2 for adi
3 for mulagala

my %aggrs_by_node = (
    node1 => ['a1_1','a1_2'],
    node2 => ['a2_1','a2_2','a2_3'],
    hello => ['ah_1','ah_2','ah_3'],
    node3 => ['a3_1','a3_2','a3_3','a3_4'],
);

任何人都有任何关于我如何循环遍历此哈希中的所有数组元素同时避免密钥的建议hello？

Iteration 1 = a1_1
Iteration 2 = a2_1
Iteration 3 = a3_1
Iteration 4 = a1_2
Iteration 5 = a2_2
Iteration 6 = a3_2
Iteration 7 = a1_1
Iteration 8 = a2_3

等等...

我无法理解Stuart Sutherland（和他的同事）所著SystemVerilog For Design书中的示例 10-3 。

见第 232 行：

https://code.google.com/p/vak-opensource/source/browse/trunk/hardware/systemverilog/utopia-example/squat.sv?r=185

这是代码片段。我的问题将随之而来。

  bit [0:NumRx-1] RoundRobin;

  always_ff @(posedge clk, posedge reset) begin: FSM
    bit breakVar;
    if (reset) begin: reset_logic
      Rxready <= '1;
      Txvalid <= '0;
      Txsel_out <= '0;
      SquatState <= wait_rx_valid;
      forward <= 0;
      RoundRobin = 1;
    end: reset_logic
    else begin: FSM_sequencer
      unique case (SquatState)

        wait_rx_valid: begin: rx_valid_state
          Rxready <= '1;
          breakVar = 1;
          for (int j=0; j<NumRx; j+=1) begin: loop1
            for (int i=0; i<NumRx; i+=1) begin: loop2 …

I am trying to use Kafka's RoundRobinPartitioner class for distributing messages evenly across all the partitions. My Kafka topic configuration is as follows:

name: multischemakafkatopicodd

number of partitions: 16

replication factor: 2

Say, if I am producing 100 messages then each partition should have 6 or 7 messages. But, I am getting something similar to this:

sh /usr/hdp/current/kafka-broker/bin/kafka-run-class.sh kafka.tools.GetOffsetShell --broker-list 10.0.55.211:9092 --topic multischemakafkatopicodd --time -1
multischemakafkatopicodd:0:26
multischemakafkatopicodd:5:0
multischemakafkatopicodd:10:24
multischemakafkatopicodd:15:0
multischemakafkatopicodd:13:0
multischemakafkatopicodd:8:26
multischemakafkatopicodd:2:26
multischemakafkatopicodd:12:24
multischemakafkatopicodd:14:24
multischemakafkatopicodd:9:0
multischemakafkatopicodd:11:0
multischemakafkatopicodd:4:26
multischemakafkatopicodd:1:0
multischemakafkatopicodd:6:24
multischemakafkatopicodd:7:0 …

我是第一次配置清漆,我遇到了一个问题,到目前为止我还没有找到完整的答案.

我的配置简而言之:

server0 - varnish,be1 - apache,be2 - apache

清漆从循环中的2个后端拉出.

我需要处理会话,所以我配置了一个简单的php脚本,它在会话变量中设置当前时间,然后重定向到第二页,显示该会话变量和后端的ip.

我设法让这一半工作.它正在从我所看到的内容传递会话信息,但问题是这样 - 从后端返回的信息特定于它生成的后端.因此,返回的时间将取决于是否为最后一个缓存调用了be1或be2.

有没有办法可以使这个工作,以便会话变量是相同的,无论处理它的后端如何？

我认为我的问题相当简单,但我觉得我需要一些不同的观点,因为我似乎无法将这种算法转化为代码.

我需要制定一个运动队计划,其中n个队(在这种情况下,10个队)以循环赛形式进行比赛.规则遵循基本的循环格式,其中一个团队只能在给定时间玩另一个团队,并且所有团队必须一次玩所有其他团队.

我发现算法是将团队1保持在现场,然后顺时针旋转其余部分.虚拟团队可用于处理n的奇数.问题出现在算法的"顺时针"部分.我不知道如何将顺时针旋转的概念转换为我的团队.例如,如果我让它们在数组TeamArray中拆分,TeamArray [0]在第1周播放TeamArray [10]等,我怎样才能让它们在第2周顺时针移动？

我不是在寻找一个讲义,而是寻求一些帮助,以创造性的方式看待这个算法,这样我就可以转换顺时针移动团队的概念.

我感谢所有的帮助,并很乐意回答我在最初的问题中可能令人困惑的任何事情.谢谢!