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

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

相关文章

数字IC前端专栏https://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 ......

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

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

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

数字IC前端学习笔记:仲裁轮询(六)以上内容来源于《Verilog高级数字系统设计技术和实例分析》文章来源地址https://www.toymoban.com/news/detail-502765.html

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

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

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

相关文章

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

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

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

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

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

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

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

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

    2024年02月14日
    浏览(30)
  • 【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日
    浏览(31)
  • 数字IC前端设计流程及详细解释

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

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

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

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

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

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

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

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

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

    2024年02月16日
    浏览(30)

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

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

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

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

二维码1

领取红包

二维码2

领红包