数字IC前端学习笔记:仲裁轮询(四)

这篇具有很好参考价值的文章主要介绍了数字IC前端学习笔记:仲裁轮询(四)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

相关文章 

数字IC前端专栏https://blog.csdn.net/weixin_45791458/category_12173698.html?spm=1001.2014.3001.5482


6.带权重的轮询(第一部分)

        带权重的轮询(Weighted Round Robin, WRR)方案与常规的轮询方案类似,所不同的是不同的用户得到许可的机会存在差异,也就是说,不同的用户权重不同,权重高的用户得到许可的机会更多。权重的分配存在多种方式,这里介绍两种。第一种方法是为每个用户分配一个变量,该变量决定了在一个轮询周期内该用户能够得到许可(被授权)的次数。该变量是可以通过软件编程进行修改的,因此其轮询权重也可以相应调整。例如,有三个用户,agent0的权重为3,、agent1的权重为2、agent2的权重为1。在一个轮询周期中,agent0最大可以得到3次许可,agent1可以得到2次许可,agent2可以得到1次许可。在一个轮询周期开始时,变量N_agnt0、N_agnt1和N_agnt2分别被预置为3、2和1.每次轮询过后对应的变量值减1,一个轮询周期结束后,这些变量会被重新设置为预置的初值。如果所有的用户同时请求,仲裁器将按照下面两种方式之一给予许可:

        1、一个用户可以连续地获取许可,获得许可的次数由预置的权重值决定。当所有用户同时发出请求时,许可序列依次为:

                (A,A,A),(B,B),C,    (A,A,A),(B,B),C ......

        2、在所有存在许可机会的用户之间进行公平轮询,一个循环周期内,不同用户得到的总许可机会由预置的权重值决定。当所有请求同时发生时,许可序列为:

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

        在第二种方案中,可软件编程的定时器被用于分配权重。一个仲裁周期开始时,定时器数值被加载。当一个用户获得许可后,定时器开始计时,直到计满,此时如果被授权的用户没有完成操作,仲裁器停止对当前用户的许可并根据优先级轮询下一个用户。

        下面是采用WRR轮询方案的Verilog代码及仿真结果,它采用的是第一种方法的第一种许可方式,序列为A,A,A,B,B,C...。

module arbiter_wrr(clk,resetb,req_vec,
                   req_vec_wt_0,
                   req_vec_wt_1,
                   req_vec_wt_2,
                   req_n_valid,
                   end_access_vec,
                   gnt_vec);
    input clk;
    input resetb;
    input [2:0] req_vec;
    input [3:0] req_vec_wt_0;
    input [3:0] req_vec_wt_1;
    input [3:0] req_vec_wt_2;
    input req_n_valid;
    input [2:0] end_access_vec;
    output reg [2:0] gnt_vec;
    
    reg [2:0] arbiter_state,arbiter_state_nxt;
    reg [2:0] gnt_vec_nxt;
    reg [3:0] count_req_vec [2:0];
    reg [3:0] count_req_vec_nxt [2:0];
    wire [3:0] req_vec_wt [2:0];
    reg [3:0] req_vec_wt_stored [2:0];
    reg [3:0] req_vec_wt_stored_nxt [2:0];
    wire [2:0] cnt_reqdone_vec;
    
    parameter IDLE = 3'b001;
    parameter ARM_VALUE = 3'b010;
    parameter END_ACCESS = 3'b100;
    

    assign req_vec_wt[0] = req_vec_wt_0;
    assign req_vec_wt[1] = req_vec_wt_1;
    assign req_vec_wt[2] = req_vec_wt_2;    

    always@(*) begin
        arbiter_state_nxt = arbiter_state;
        gnt_vec_nxt = gnt_vec;
        count_req_vec_nxt[0] = count_req_vec[0];
        count_req_vec_nxt[1] = count_req_vec[1];
        count_req_vec_nxt[2] = count_req_vec[2];
        req_vec_wt_stored_nxt[0] = req_vec_wt_stored[0];
        req_vec_wt_stored_nxt[1] = req_vec_wt_stored[1];
        req_vec_wt_stored_nxt[2] = req_vec_wt_stored[2];
        case(arbiter_state)
            IDLE:begin
                if(req_n_valid)begin
                    arbiter_state_nxt = ARM_VALUE;
                    count_req_vec_nxt[0] = req_vec_wt[0];
                    count_req_vec_nxt[1] = req_vec_wt[1];
                    count_req_vec_nxt[2] = req_vec_wt[2];
                    req_vec_wt_stored_nxt[0] = req_vec_wt[0];
                    req_vec_wt_stored_nxt[1] = req_vec_wt[1];
                    req_vec_wt_stored_nxt[2] = req_vec_wt[2];
                end
            end
            ARM_VALUE:begin
                if((gnt_vec == 0) ||
                   (end_access_vec[0] & gnt_vec[0]) ||
                   (end_access_vec[1] & gnt_vec[1]) ||
                   (end_access_vec[2] & gnt_vec[2]))
                    begin
                        if(req_vec[0] & !cnt_reqdone_vec[0]) begin
                            arbiter_state_nxt = END_ACCESS;
                            gnt_vec_nxt = 3'b001;
                            count_req_vec_nxt[0] = count_req_vec[0] - 1;
                        end
                        else if(req_vec[1] & !cnt_reqdone_vec[0]) begin
                            arbiter_state_nxt = END_ACCESS;
                            gnt_vec_nxt = 3'b010;
                            count_req_vec_nxt[1] = count_req_vec[1] - 1;
                        end
                        else if(req_vec[2] & !cnt_reqdone_vec[1]) begin
                            arbiter_state_nxt = END_ACCESS;
                            gnt_vec_nxt = 3'b100;
                            count_req_vec_nxt[2] = count_req_vec[2] - 1;
                        end
                        else begin
                            count_req_vec_nxt[0] = req_vec_wt_stored[0];
                            count_req_vec_nxt[1] = req_vec_wt_stored[1];
                            count_req_vec_nxt[2] = req_vec_wt_stored[2];
                            gnt_vec_nxt = 3'b0;
                        end
                    end
            end
            END_ACCESS:if((end_access_vec[0] & gnt_vec[0]) ||
                          (end_access_vec[1] & gnt_vec[1]) ||
                          (end_access_vec[2] & gnt_vec[2]))
                        begin
                            arbiter_state_nxt = ARM_VALUE;
                            
                            if(req_vec[0] & !cnt_reqdone_vec[0]) begin
                                arbiter_state_nxt = END_ACCESS;
                                gnt_vec_nxt = 3'b001;
                            count_req_vec_nxt[0] = count_req_vec[0] - 1;
                            end
                            else if(req_vec[1] & !cnt_reqdone_vec[0]) begin
                                arbiter_state_nxt = END_ACCESS;
                                gnt_vec_nxt = 3'b010;
                                count_req_vec_nxt[1] = count_req_vec[1] - 1;
                            end
                            else if(req_vec[2] & !cnt_reqdone_vec[1]) begin
                                arbiter_state_nxt = END_ACCESS;
                                gnt_vec_nxt = 3'b100;
                                count_req_vec_nxt[2] = count_req_vec[2] - 1;
                            end
                            else begin
                                count_req_vec_nxt[0] = req_vec_wt_stored[0];
                                count_req_vec_nxt[1] = req_vec_wt_stored[1];
                                count_req_vec_nxt[2] = req_vec_wt_stored[2];
                                gnt_vec_nxt = 3'b0;
                            end
                        end
        endcase
    end

    assign cnt_reqdone_vec[0] = (count_req_vec[0] == 0);
    assign cnt_reqdone_vec[1] = (count_req_vec[1] == 0);
    assign cnt_reqdone_vec[2] = (count_req_vec[2] == 0);
    
    always@(posedge clk or negedge resetb) begin
        if(!resetb) begin
            arbiter_state <= IDLE;
            gnt_vec <= 0;
            count_req_vec[0] <= 0;    
            count_req_vec[1] <= 0; 
            count_req_vec[2] <= 0;
            req_vec_wt_stored[0] <= 0;
            req_vec_wt_stored[1] <= 0;
            req_vec_wt_stored[2] <= 0; 
        end 
        else begin
            arbiter_state <= arbiter_state_nxt;
            gnt_vec <= gnt_vec_nxt;
            count_req_vec[0] <= count_req_vec_nxt[0];    
            count_req_vec[1] <= count_req_vec_nxt[1]; 
            count_req_vec[2] <= count_req_vec_nxt[2];
            req_vec_wt_stored[0] <= req_vec_wt_stored_nxt[0];
            req_vec_wt_stored[1] <= req_vec_wt_stored_nxt[1];
            req_vec_wt_stored[2] <= req_vec_wt_stored_nxt[2]; 
        end
    end
endmodule

        代码中使用了req_vec_wt_stored信号保存各用户的权重值,使用count_req_vec保存用户的当前剩余请求次数。注意:一旦出现了空档期,则所有用户的剩余请求次数会重置。

数字IC前端学习笔记:仲裁轮询(四)

数字IC前端学习笔记:仲裁轮询(五)https://mp.csdn.net/mp_blog/creation/editor/131398161

以上内容来源于《Verilog高级数字系统设计技术和实例分析》文章来源地址https://www.toymoban.com/news/detail-510684.html

到了这里,关于数字IC前端学习笔记:仲裁轮询(四)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【数字IC精品文章收录】近500篇文章|学习路线|基础知识|接口|总线|脚本语言|芯片求职|安全|EDA|工具|低功耗设计|Verilog|低功耗|STA|设计|验证|FPGA|架构|AMBA|书籍|

    1.1 索引目的 本篇索引旨在 收藏CSDN全站中有关数字IC领域高价值文章 ,在数字芯片领域中,就算将架构,设计,验证,DFT,后端诸多岗位加在一起的数量,都不及软件类一个细分方向的岗位数量多,反映在社区氛围或是开源资料的丰富度而言,数字IC领域相较于软件/互联网领

    2024年02月03日
    浏览(120)
  • round robin arbiter 轮询仲裁器设计

    前言 仲裁器Arbiter 是数字设计中非常常见的模块,应用也非常广泛。定义就是当有两个或两个以上的模块 需要占用同一个资源 的时候,我们需要由仲裁器arbiter来决定哪一个模块来占有这个资源。一般来说,提出占有资源的模块要产生一个请求(request),所有的请求送给仲裁器

    2024年02月12日
    浏览(31)
  • IC设计----仲裁器

    #为了方便以后自己查询和复习,写了一个简短的总结;代码部分是参考其他博主 假设request低bit优先级更高,那么低位到高位,最先出现1的那一位被对应的request被grant,那问题就变成了如何从一个01串中寻找最先出现bit 为1的那一位,这里最经典的方法就是: equest和它的2的补

    2024年04月14日
    浏览(31)
  • Verilog权重轮询仲裁器设计——Weighted Round Robin Arbiter

    前两篇讲了固定优先级仲裁器的设计、轮询仲裁器的设计 Verilog固定优先级仲裁器——Fixed Priority Arbiter_weixin_42330305的博客-CSDN博客 Verilog轮询仲裁器设计——Round Robin Arbiter_weixin_42330305的博客-CSDN博客 权重轮询仲裁器就是在轮询仲裁器的基础上,当grant次数等于weight时,再切换

    2024年02月14日
    浏览(42)
  • 【AHB接口协议】固定优先级和轮询仲裁器的Verilog实现

    目录 一、 实验目的 1 二、 实验工具及环境 1 三、 实验内容及步骤 1 1、 实验2.1:16位可参数化仲裁器的设计 1 (1)补码相与法 1 (2)可变参数设计 1 2、 实验2.2:AHB总线仲裁器的设计 2 (1)设计目标 2 (2)状态机实现 3 ①状态定义 3 ②增量控制寄存器cnt 4 ③轮询数计数器

    2024年02月10日
    浏览(47)
  • 数字IC前端设计流程及详细解释

    数字前端以设计架构为起点,以生成可以布局布线的网表为终点。 使用设计的电路实现想法,主要包括:基本的RTL编程和仿真。前端设计还可以包括 IC系统设计、前仿真波形验证、综合、STA、FM验证。其中 IC系统设计最难掌握,它需要多年的IC设计经验和熟悉那个应用领域,

    2024年02月06日
    浏览(54)
  • 数字IC学习01

    在正式开始前,我必须要交代一下,我写这些博客的原因:主要是想记录和梳理一下自己如何学习数字IC这个我也许余身都要从事的行业,如果能给读者带来帮助,那便是更好不过的事情了。 作为一个经历过千万人高考,百万人考研的人来说,学习并不是一件轻松的事,更可

    2024年02月03日
    浏览(31)
  • 数字IC后端设计如何从零基础快速入门?(内附数字IC后端学习视频)

    数字IC后端工程师主要职责是把数字IC前端工程师写的逻辑功能RTL转变成物理实际连线GDS版图。这个过程的本质是基于一定的时序约束和物理约束将设计的逻辑功能等价转变成物理连接。因为这个GDS最后是要提交给foundary进行芯片加工制作的,光刻机无法识别逻辑功能,它只认

    2024年01月20日
    浏览(46)
  • 数字IC与模拟IC到底哪个更适合你?一文为你讲清楚(内附学习视频)

    选数字IC还是模拟IC? 这是很多同学进入IC行业的一个难题,后台也有很多同学问模拟IC和数字IC的区别。 本文就从大家比较关心的内容入手,分析这两个方向的异同。 (文末有免费学习视频哦~) 这里放个入口:IC入行了解 首先要有模拟信号和数字信号的概念。 在时间和幅值

    2024年02月03日
    浏览(43)
  • IC学习笔记:SystemVerilog队列及数组方法

    队列和数组是SystemVerilog中常用的数据结构,它们可以用来存储和操作一组数据。本文将介绍SystemVerilog中队列和数组的常用方法。 1. 队列方法          队列是一种先进先出(FIFO)的数据结构,它可以用来存储一组有序的数据。 SystemVerilog中的队列有以下常用方法: 1.1 p

    2024年02月16日
    浏览(42)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包