数字IC前端学习笔记：仲裁轮询（六）

已于 2023-10-25 14:50:29 修改
阅读量485 收藏 34
点赞数 12
分类专栏： # 仲裁轮询 数字IC前端 文章标签： fpga开发 Verilog HDL 数字IC 硬件工程 前端
于 2023-06-27 16:43:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45791458/article/details/131417734
版权

相关文章

数字IC前端专栏icon-default.png?t=N7T8https://blog.csdn.net/weixin_45791458/category_12173698.html?spm=1001.2014.3001.5482

8.分组轮询

        在一些应用中，用户被分成两组：快组和慢组。如下图所示，快组内的用户具有相同的优先级，内部采用公平轮询方式。类似地，慢组内的用户也具有相同优先级，慢组内部也采用公平轮询方式。但快组慢组之间是嵌套的关系，即整个慢组被当做是快组的一个用户。例如，快组有两个用户(A,B)，慢组也有两个用户(C,D)。如果所有用户都发出请求，那么轮询序列为：

A,B,C,A,B,D,A,B,C,A,B,D ......

        两组轮询的代码及仿真结果如下。

module arbiter_twogroups(clk, resetb,
                         req_vec_groupa,
                         end_access_vec_groupa,
                         req_vec_groupb,
                         end_access_vec_groupb,
                         gnt_vec_groupa,
                         gnt_vec_groupb);

    input clk;
    input resetb;
    input [1:0] req_vec_groupa;
    input [1:0] end_access_vec_groupa;
    input [1:0] req_vec_groupb;
    input [1:0] end_access_vec_groupb;
    output [1:0] gnt_vec_groupa;
    output [1:0] gnt_vec_groupb;
    
    reg [1:0] arbiter_state, arbiter_state_nxt;
    reg [2:0] gnt_vec, gnt_vec_nxt;
    reg [2:0] relative_req_vec;
    wire any_req_asserted;
    reg [1:0] grant_posn, grant_posn_nxt;
    wire any_req_asserted_slow;
    wire [1:0] gnt_vec_groupa;
    wire [1:0] gnt_vec_groupb;
    reg [1:0] grant_posn_slow, grant_posn_slow_nxt;

    parameter IDLE = 2'b01;
    parameter END_ACCESS = 2'b10;

    
    assign any_req_asserted = (req_vec_groupa != 0) || (req_vec_groupb != 0);
    assign any_req_asserted_slow = (req_vec_groupb != 0);
    assign gnt_vec_groupa = gnt_vec[1:0];
    assign gnt_vec_groupb[0] = gnt_vec[2] & grant_posn_slow[0];
    assign gnt_vec_groupb[1] = gnt_vec[2] & grant_posn_slow[1];
    
    always@(*) begin
        relative_req_vec = {any_req_asserted_slow,
                            req_vec_groupa[1],
                            req_vec_groupa[0]};

        case(grant_posn)
            2'd0: relative_req_vec = {req_vec_groupa[0],
                                      any_req_asserted_slow,
                                      req_vec_groupa[1]};
            2'd1: relative_req_vec = {req_vec_groupa[1],
                                      req_vec_groupa[0],
                                      any_req_asserted_slow};
            2'd2: relative_req_vec = {any_req_asserted_slow,
                                      req_vec_groupa[1],
                                      req_vec_groupa[0]};
        endcase
    end


    always@(*) begin
        arbiter_state_nxt = arbiter_state;
        grant_posn_nxt = grant_posn;
        gnt_vec_nxt = gnt_vec;
        grant_posn_slow_nxt = grant_posn_nxt;

        case(arbiter_state)
            IDLE: begin
                if(((gnt_vec_groupa == 0) && (gnt_vec_groupb == 0))||
                   (end_access_vec_groupa[0] & gnt_vec_groupa[0])  ||
                   (end_access_vec_groupa[1] & gnt_vec_groupa[1])  ||
                   (end_access_vec_groupb[0] & gnt_vec_groupb[0])  ||
                   (end_access_vec_groupb[1] & gnt_vec_groupb[1])) begin
                    if(any_req_asserted)
                        arbiter_state_nxt = END_ACCESS;
                    if(relative_req_vec[0]) begin
                        case(grant_posn)
                            2'd0: gnt_vec_nxt = 3'b010;
                            2'd1:begin
                                gnt_vec_nxt = 3'b100;
                                if(grant_posn_slow[0]) begin
                                    if(req_vec_groupb[1])
                                        grant_posn_slow_nxt = 2'b10;
                                    else if(req_vec_groupb[0])
                                        grant_posn_slow_nxt = 2'b01;
                                end
                                else if(grant_posn_slow[1]) begin
                                    if(req_vec_groupb[0])
                                        grant_posn_slow_nxt = 2'b01;
                                    else if(req_vec_groupb[1])
                                        grant_posn_slow_nxt = 2'b10;                                
                                end 
                            end
                            2'd2: gnt_vec_nxt = 3'b001;
                        endcase
                        case(grant_posn) 
                            2'd0: grant_posn_nxt = 1;
                            2'd1: grant_posn_nxt = 2;
                            2'd2: grant_posn_nxt = 0;
                        endcase
                    end
                    else if(relative_req_vec[1]) begin
                        case(grant_posn)
                            2'd0: begin
                                gnt_vec_nxt = 3'b100;
                                if(grant_posn_slow[0]) begin
                                    if(req_vec_groupb[1])
                                        grant_posn_slow_nxt = 2'b10;
                                    else if(req_vec_groupb[0])
                                        grant_posn_slow_nxt = 2'b01;
                                end
                                else if(grant_posn_slow[1]) begin
                                    if(req_vec_groupb[0])
                                        grant_posn_slow_nxt = 2'b01;
                                    else if(req_vec_groupb[1])
                                        grant_posn_slow_nxt = 2'b10;                                
                                end 
                            end
                            2'd1: gnt_vec_nxt = 3'b001;
                            2'd2: gnt_vec_nxt = 3'b010;
                        endcase
                        case(grant_posn) 
                            2'd0: grant_posn_nxt = 2;
                            2'd1: grant_posn_nxt = 0;
                            2'd2: grant_posn_nxt = 1;
                        endcase
                    end
                    else if(relative_req_vec[2]) begin
                        case(grant_posn)
                            2'd2: begin
                                gnt_vec_nxt = 3'b100;
                                if(grant_posn_slow[0]) begin
                                    if(req_vec_groupb[1])
                                        grant_posn_slow_nxt = 2'b10;
                                    else if(req_vec_groupb[0])
                                        grant_posn_slow_nxt = 2'b01;
                                end
                                else if(grant_posn_slow[1]) begin
                                    if(req_vec_groupb[0])
                                        grant_posn_slow_nxt = 2'b01;
                                    else if(req_vec_groupb[1])
                                        grant_posn_slow_nxt = 2'b10;                                
                                end 
                            end
                            2'd0: gnt_vec_nxt = 3'b001;
                            2'd1: gnt_vec_nxt = 3'b010;
                        endcase
                        case(grant_posn) 
                            2'd0: grant_posn_nxt = 0;
                            2'd1: grant_posn_nxt = 1;
                            2'd2: grant_posn_nxt = 2;
                        endcase
                    end
                end
            end
            END_ACCESS: begin
                if((end_access_vec_groupa[0] & gnt_vec_groupa[0])  ||
                   (end_access_vec_groupa[1] & gnt_vec_groupa[1])  ||
                   (end_access_vec_groupb[0] & gnt_vec_groupb[0])  ||
                   (end_access_vec_groupb[1] & gnt_vec_groupb[1])) begin
                    arbiter_state_nxt = IDLE;
                    if(relative_req_vec[0]) begin
                        case(grant_posn)
                            2'd0: gnt_vec_nxt = 3'b010;
                            2'd1: begin
                                gnt_vec_nxt = 3'b100;
                                if(grant_posn_slow[0]) begin
                                    if(req_vec_groupb[1])
                                        grant_posn_slow_nxt = 2'b10;
                                    else if(req_vec_groupb[0])
                                        grant_posn_slow_nxt = 2'b01;
                                end
                                else if(grant_posn_slow[1]) begin
                                    if(req_vec_groupb[0])
                                        grant_posn_slow_nxt = 2'b01;
                                    else if(req_vec_groupb[1])
                                        grant_posn_slow_nxt = 2'b10;                                
                                end 
                            end
                            2'd2: gnt_vec_nxt = 3'b001;
                        endcase
                        case(grant_posn) 
                            2'd0: grant_posn_nxt = 1;
                            2'd1: grant_posn_nxt = 2;
                            2'd2: grant_posn_nxt = 0;
                        endcase
                    end
                    else if(relative_req_vec[1]) begin
                        case(grant_posn)
                            2'd0: begin
                                gnt_vec_nxt = 3'b100;
                                if(grant_posn_slow[0]) begin
                                    if(req_vec_groupb[1])
                                        grant_posn_slow_nxt = 2'b10;
                                    else if(req_vec_groupb[0])
                                        grant_posn_slow_nxt = 2'b01;
                                end
                                else if(grant_posn_slow[1]) begin
                                    if(req_vec_groupb[0])
                                        grant_posn_slow_nxt = 2'b01;
                                    else if(req_vec_groupb[1])
                                        grant_posn_slow_nxt = 2'b10;                                
                                end 
                            end
                            2'd1: gnt_vec_nxt = 3'b001;
                            2'd2: gnt_vec_nxt = 3'b010;
                        endcase
                        case(grant_posn) 
                            2'd0: grant_posn_nxt = 2;
                            2'd1: grant_posn_nxt = 0;
                            2'd2: grant_posn_nxt = 1;
                        endcase
                    end
                    else if(relative_req_vec[2]) begin
                        case(grant_posn)
                            2'd2: begin
                                gnt_vec_nxt = 3'b100;
                                if(grant_posn_slow[0]) begin
                                    if(req_vec_groupb[1])
                                        grant_posn_slow_nxt = 2'b10;
                                    else if(req_vec_groupb[0])
                                        grant_posn_slow_nxt = 2'b01;
                                end
                                else if(grant_posn_slow[1]) begin
                                    if(req_vec_groupb[0])
                                        grant_posn_slow_nxt = 2'b01;
                                    else if(req_vec_groupb[1])
                                        grant_posn_slow_nxt = 2'b10;                                
                                end 
                            end
                            2'd0: gnt_vec_nxt = 3'b001;
                            2'd1: gnt_vec_nxt = 3'b010;
                        endcase
                        case(grant_posn) 
                            2'd0: grant_posn_nxt = 0;
                            2'd1: grant_posn_nxt = 1;
                            2'd2: grant_posn_nxt = 2;
                        endcase
                    end
                end
            end
        endcase
    end

    always@(posedge clk, negedge resetb) begin
        if(!resetb) begin
            arbiter_state <= IDLE;
            gnt_vec <= 0;
            grant_posn <= 2;
            grant_posn_slow <= 2;
        end
        else begin
            arbiter_state <= arbiter_state_nxt;
            gnt_vec <= gnt_vec_nxt;
            grant_posn <= grant_posn_nxt;
            grant_posn_slow <= grant_posn_slow_nxt;            
        end
    end
endmodule

以上内容来源于《Verilog高级数字系统设计技术和实例分析》

日晨难再
关注
  • 12
    点赞
  • 踩
  • 34
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
专栏目录
numeter:数字轮询器存储 webapp 的主要存储库。 Python中的图形系统
06-21
Numeter 是一种新的动态图形解决方案，由 eNovance 的一些人制作。 我们将其用作云解决方案的一部分。... 当前的数字架构： 轮询器：安装在需要图形的服务器上的代理。 它收集数据并将它们发送到 rp
pollerdox:统一轮询工具的文档
03-06
花粉统一轮询工具的文档
数字IC前端学习笔记：仲裁轮询（一）
前进，才知道自己的渺小
06-12 1366
当多个源或用户需要共享同一资源时，需要某种仲裁形式，使得所有用户基于一定的规则或算法得到获取或访问共享资源的机会。例如，共享总线上，可以连接多个总线用户。另一个例子是交换机中的端口仲裁，当多个入口希望通过某一个出口输出数据时，需要使用一定的端口仲裁机制来选择某一时刻允许哪一个入口发送数据。最简单的仲裁方案是公平轮询(round-robin)方案，此时，仲裁器公平的对待所有用户的请求，不同用户具有均等的机会。
数字IC前端学习笔记：仲裁轮询（二）
前进，才知道自己的渺小
06-18 892
此外还有一种机制，每个用户获得授权后，可以占用资源的时间片长度是受约束的，每个用户可以占用资源的时间不能超过规定的长度。如果一个用户在所分配的时间结束之前完成了操作，仲裁器将轮询后续的用户。一开始，选择用户的顺序可以是任意的，但在一个轮询周期内，所有发出请求的用户都有公平得到授权的机会。仲裁器每次仲裁时，依次查看每个用户的请求信号是否有效，如果一个用户的请求无效，那么将按序查看下一个用户。仲裁器会记住上一次被授权的用户，当该用户的操作完成后，仲裁器会按序轮询其他用户是否有请求。下图为公平轮询的波形图。
数字IC前端学习笔记：仲裁轮询（四）
前进，才知道自己的渺小
06-25 1419
带权重的轮询(Weighted Round Robin, WRR)方案与常规的轮询方案类似，所不同的是不同的用户得到许可的机会存在差异，也就是说，不同的用户权重不同，权重高的用户得到许可的机会更多。当一个用户获得许可后，定时器开始计时，直到计满，此时如果被授权的用户没有完成操作，仲裁器停止对当前用户的许可并根据优先级轮询下一个用户。2、在所有存在许可机会的用户之间进行公平轮询，一个循环周期内，不同用户得到的总许可机会由预置的权重值决定。1、一个用户可以连续地获取许可，获得许可的次数由预置的权重值决定。
数字IC前端学习笔记：仲裁轮询（三）
前进，才知道自己的渺小
06-22 1303
在前面公平轮询仲裁器的Verilog RTL代码中，每个用户有三个信号：request（请求）、grant（授权）、end_access（结束访问）。在总线使用时，我们能观察到总线上存在不能进行数据传输的死周期。当传输的数据包较长或每个突发较长时，其对传输效率影响不大。然而，当数据包很短时，死周期会影响到总线的使用效率。如下图所示为没有间隔的公平轮询仲裁波形。下面给出了一些方法，用于减少甚至消除死周期。没有死周期的公平轮询代码及仿真结果如下。
数字IC前端学习笔记：仲裁轮询（五）
前进，才知道自己的渺小
06-26 476
上一部分中我们对仲裁的第一种方法的第一种许可方式进行了Verilog设计，接下来将使用Verilog对第一种方法的第二种许可方式进行设计，即当所有用户发出请求时，授权序列为。以上内容来源于《Verilog高级数字系统设计技术和实例分析》以下是代码及仿真结果。
正点原子[第二期]Linux之ARM（MX6U）裸机篇学习笔记-23.1,2 讲 I2C驱动
最新发布
weixin_40289409的博客
05-24 275
本文是根据哔哩哔哩网站上“正点原子[第二期]Linux之ARM（MX6U）裸机篇”视频的学习笔记，在这里会记录下正点原子 I.MX6ULL 开发板的配套视频教程所作的实验和学习笔记内容。本文大量引用了正点原子教学视频和链接中的内容。第23.1, 23.2 讲 I2C驱动。
CISCO技术(1.7万)
热门推荐
08-09 6万+
0 base|以零为基底\r\n 0 disturbed zero output signal|干扰0输出信号\r\n 0parallel communication cable|平行通讯传输缆线\r\n 1 binary operation|二进制运算\r\n 1 di
mbus_arb.zip_8-1公平轮询仲裁_mbus_仲裁_轮询_轮询 仲裁
07-15
8通道输入，1通道输出，采取请求应答方式，对8通道输入进行仲裁，采用公平轮询机制；
polled.win：:bar_chart:实时轮询
02-04
已轮询实时轮询Web应用程序。建立创建一个.env文件，并添加： REDISCLOUD_URL = XXX DB_URL = XXX yarn install npm run webpack / npm start 转到http://localhost:5000
Lets-Poll:匿名轮询平台。
04-07
设计和开发网站应用程序，其中： 登录的用户可以创建公开或私有的民意调查 ... 可以在首页上看到公开民意调查和私人民意调查（有效和无效） 每个显示的民意调查将具有以下信息-处于非活动状态之前的剩余时间，创建者...
对systemverilog/verilog中forever语法的理解
qq_33300585的博客
05-20 187
对systemverilog/verilog中forever语法的理解
【IC设计】任意倍数占空比为50%的奇数分频和偶数分频（Verilog源码、仿真波形、讲解）
VICI的博客
05-19 509
以四分频为例，分频后的一个周期是分频前的四个周期，并且分频后的一个周期中，一半是高电平，一半是低电平，这就是占空比为50%的四分频。要实现该功能，使用一个计数器在0~3之间计数，clk_out在0和2时翻转即可。
产品推荐 | 基于Xilinx XCKU115的半高PCIe x8 硬件加速卡
dpwkj的博客
05-21 394
采用Xilinx公司的XCKU115-3-FLVF1924-E芯片作为主处理器，主要用于FPGA硬件加速。板卡设计满足工业级要求。
基于FPGA的VGA协议实现----条纹-文字-图片
LX567567的博客
05-20 944
深入了解VGA协议理解不同显示模式下的VGA控制时序参数完成在VGA上显示对应的条纹-文字-图片为了适应匹配不同厂家的 VGA 显示器， VGA 视频传输接口有自己的一套 VGA 时序标准，只有遵循 VGA 的时序标准，才能正确的进行图像信息的显示。在这里我们以 VESA VGA 时序标准为例，为大家讲解一下 VGA 时序标准，具体见图 2。图 2 VESA VGA时序标准图。
第9篇：创建Nios II工程之读取Switch的值＜二＞
weixin_47841246的博客
04-30 566
创建读取Switch的值的Nios II软件工程
vue源码之mustache模板引擎1
qweasl_的博客
05-21 425
模板引擎的一个有点：它是将数据转为视图的最优雅的方法。相信vue的玩家首先想到的是。而还没学vue的朋友，就只能进行dom操作了。通过数组的join方法。以及es6推出的模板字符串。
std::map 轮询
04-25
以下是一个示例代码，演示如何使用迭代器进行轮询： ```cpp #include #include int main() { std::map, std::string> myMap; myMap = "apple"; myMap = "banana"; myMap = "orange"; // 使用迭代器进行...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

日晨难再

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值