UVM factory允许在构造时将类替换为派生类型的另一个类。这对于通过将一个类替换为另一个类而无需编辑或重新编译测试平台代码来更改测试平台的行为来说是非常有用的。为了使factory重载过程起作用，需要遵循许多编码约定先决条件，这些在UVM factory的文章中进行了解释。
       UVM factory可以被认为是查找表。当使用 :: type_id :: create（“”，）方法（approach）进行“普通”组件构造时，会发生的是type_id用于为类选择factory组件包装器， 构造其内容并再次传回结果句柄。factory重载更改了查找的发生方式，因此查找原始的type_id会导致使用不同的type_id。因此，返回不同类型的构造对象的句柄。此技术依赖于多态性，即能够使用基本类型句柄引用派生类型的能力。实际上，只有当父类被类扩展层次结构中的一个子类重载时，重载才会起作用。

       Component Overrides 

     UVM中有两种类型的组件重载 - type overrides 和 instance overrides。  

       Component Type Overrides  

       type override意味着每次在测试平台层次结构中创建组件类type时，都会在其位置创建替换type。这适用于该组件类型的所有实例。以下代码片段中说明了此类重载的方法调用：

       // 
       // Component type override example 
       // ---------------------------------------------

       // Colour parent class 
       class colour extends uvm_component;

       `uvm_component_utils(colour)

       //etc
       endclass: colour

       // Red child class 
       class red extends colour;

       `uvm_component_utils(red)

       //etc 
       endclass: red

       // 
       // Factory type override syntax is: 
       // 
       // ::type_id::set_type_override(::get_type(), replace);
       //
       // Where replace is a bit which when ==1 enables the override of an existing override, otherwise
       // the existing override is honoured.

       // To override all instances of colour with red:
       colour::type_id::set_type_override(red::get_type(), 1);

       // This means that the following creation line returns a red, rather than a colour
       pixel = colour::type_id::create("pixel", this);

       参数化组件类也可以被重载，但必须注意确保重载类具有与被重载的类相同的参数值，否则它们不被认为是相关types：

        // 
        // Type overrides for parameterised classes: 
        // ----------------------------------------------------------

        // Base class type 
        class bus_driver #(int BUS_WIDTH = 32) extends uvm_component;

        `uvm_component_param_utils(bus_driver #(BUS_WIDTH))
        // etc

        endclass: bus_driver

        // Derived class type 
        class bus_conductor #(int BUS_WIDTH = 32) extends bus_driver #(BUS_WIDTH);

        `uvm_component_param_utils(bus_conductor #(BUS_WIDTH)) 
        // etc

        endclass: bus_conductor

        // The parameterised type override needs to keep the parameterisation consistent【重点记录下】

        bus_driver #(64)::type_id::set_type_override(bus_conductor #(64)::get_type(), 1); // This will succeed

        // Creation of a #(64) bus_driver results in a #(64) bus_conductor handle being returned:

        bus_person = bus_driver#(64)::type_id::create("bus_person", this);

        // Whereas creating a #(16) bus_driver results in a #(16) bus_driver handle being returned because
        // the matching type override is not found:

        bus_person = bus_driver#(16)::type_id::create("bus_person", this);

        // Similarly if a type override has non-matching parameters, then it will fail and return the original type

        bus_driver #(64)::type_id::set_type_override(bus_conductor #(32)::get_type(), 1); // Returns bus_driver #(64)
       
        Component Instance Overrides

        可以通过在uvm组件层次结构中指定其位置来重载特定组件实例。同样，这种方法可以与参数化类一起使用，只要注意匹配重载中涉及的两个类类型的参数：

        // 
        // Component Instance Factory Override example 
        // --------------------------------------------

        // Using red --> colour example from type override example 
        // 
        // Syntax for the instance override:
        //
        // ::type_id::set_inst_override(::get_type(), );
        //

        colour::type_id::set_inst_override(red::get_type(), "top.env.raster.spot");

        // And again for a parameterised type, the parameter values must match

        bus_driver #(64)::type_id::set_inst_override(bus_conductor #(64)::get_type(), "top.env.bus_agent.m_driver");

        Object Overrides

      Objects or sequence 相关 objects通常仅与type重载一起使用，因为instance重载方法涉及UVM测试平台组件层次结构中哪些objects不参与的位置。然而，有一个编码技巧可用于重载object的特定“instances”，这在overriding sequences的文章中有解释。

       object 重载的代码遵循与组件重载相同的形式。

包是SystemVerilog语言结构，它使相关的声明和定义能够在包名称空间中组合在一起。包可能包含类型定义，常量声明，函数和类模板。为了能在一个范围内使用包，必须先导入它，然后才能引用其内容。
       包是组织代码的一种有用方法，也是确保对类型、类等的引用是一致的有用方法。UVM基类库包含在一个名为“uvm_pkg”的包中。在开发UVM测试平台时，应该使用包来收集和组织各种类定义，这些类定义是为实现agent、envs、sequence libraries、 test libraries等而开发的。 

       UVM Package Coding Guidelines 

      Package naming and file naming conventions: 

       应使用_pkg 后缀命名包。包含该包的文件的名称应反映包的名称，并具有.sv扩展名。【如YnrrubysimTestTop.sv文件中包含一个包，名字是package  YnrrubysimTestTop】
      例如：文件spi_env_pkg.sv将包含spi_env_pkg包。
      Justification：.sv扩展名是一种约定，表示包文件是独立的编译单元。_pkg 后缀表示该文件包含一个包。这两个约定对人类和机器解析脚本都很有用。

      Classes contained within a package should be `included 

      在包范围内声明的类模板应该分成具有.svh扩展名的单个文件。这些文件应该按照需要编译的顺序包含在包中【使用`include】。包文件是唯一应该使用`includes的地方，被'include的文件中不应该包含其他`include语句。
      Justification：.将类声明在单独的文件中使它们更易于维护，并且还使包内容更清晰。

      Imports from other packages should be declared at the head of the package

      包的内容可能需要引用另一个包的内容。在这种情况下，外部包应该在包代码体的开头声明。单个文件（例如可能被`include的类模板）不应单独导入。
      Justification：.将所有imports分组到一个地方可以清楚地了解包依赖那些文件或外部包。将imports放置在包的其他部分或内部被include的文件中，这可能会导致排序和潜在的类型冲突。

      All the files used by a package should be collected together in one directory

      要包含在包中的所有文件应该一起收集在一个目录文件夹中。这对于agents来说，它的目录结构需要是完整的独立包，这点尤为重要。
      Justification：.这使编译更容易，因为只有一个include目录，它还有助于重用，因为包的所有文件可以很容易地收集在一起。
      下面是UVM env的包文件示例。这个env包含两个agent（spi和apb）和一个寄存器模型，这些作为子包导入。与env相关的类模板被`include。

       // Note that this code is contained in a file called spi_env_pkg.sv 
       // 
       // In Questa it would be compiled using:
       // vlog +incdir+$UVM_HOME/src+  /spi_env_pkg.sv
       //

       //
       // Package Description:
       //
       package spi_env_pkg;

       // Standard UVM import & include:
       import uvm_pkg::*; 
       `include "uvm_macros.svh"

       // Any further package imports:
       import apb_agent_pkg::*; 
       import spi_agent_pkg::*; 
       import spi_register_pkg::*;

       // Includes:
       `include "spi_env_config.svh"
       `include "spi_virtual_sequencer.svh"
       `include "spi_env.svh"

       endpackage: spi_env_pkg

       Package Scopes

      经常让用户感到困惑的是SystemVerilog package是一个范围。这意味着在package中声明的所有内容以及导入到package中的其他package的内容仅在本package的范围内可见。如果将包导入另一个范围（即另一个包或模块），则只能看到包的内容，而不是它导入的任何包的内容。如果新范围中需要这些其他包的内容，则需要单独导入它们。

       // 
       // Package Scope Example
       // ---------------------------------------------------- 
       //
       package spi_test_pkg;

       // The UVM package has to be imported, even though it is imported
       // in the spi_env package. This is because the import of the uvm_pkg 
       // is only visible within the current scope
       import uvm_pkg::*;
       // The same is true of the `include of the uvm_macros
       `include "uvm_macros.svh"

       // Import of uvm_pkg inside the spi_env package is not 
       // visible within the scope of the spi_test package
       import spi_env_pkg::*; 

       // Other imports 
       // Other `includes
       `include spi_test_base.svh

       endpackage: spi_test_pkg

最近需要需要用sv读取文件，然后设定环境参数的问题。

用$fscanf和$feof结合的方式解决了。

具体做法如下：

integer fd;

string name;

reg value;

reg setting_value;

fd=$fopen("ABC.txt","r");

while(!$feof(fd))begin

     $fscanf(fd, "%s %d", name, value);

     $display( "%s %d", name, value);

     if(name == "my_name") begin

        setting_value = value;

        break;

     end

end

ABC.txt的文件内容每行都是字符串+数字组成：

string_A 1

srting_B 0

...

总结：无论是C++还是perl等脚本，读取文件内容方式都是差不多的，大同小异。

建立时间，保持时间
    为了确保寄存器在时钟沿稳定采集数据，那么必须要满足寄存器的建立，保持时间要求。

建立时间要求：在寄存器有效时钟沿之前至少Tsetup时间，数据必须到达且稳定。如下图所示。

     保持时间要求：在数据采集有效时钟沿之后，数据必须维持最短Thold时间不变。如下图所示。

      建立时间裕量计算
同步时序电路如下图所示。这里对后面一个寄存器进行建立时间裕量分析。

     其中寄存器的输出延时为Tcq，即时钟有效沿之后延时Tcq时间，数据才到达寄存器Q端。第一个寄存器有效时钟沿之后Tcq时间，数据才到达Q1端，如下图所示。

     再经过组合逻辑运算，得到数据C1，其中组合逻辑的延时为Tlogic。时序如下图。

      从这里可以看到，如果clk2和clk1之间没有延时。那么对于后面的寄存器而言，数据提前于采样时钟沿之前Tcycle-（Tcq+Tlogic）时间到来，且稳定。其中Tcycle为时钟周期。

     由于寄存器要求的建立时间为Tsetup，故电路必须满足 Tcycle -（Tcq+Tlogic）- Tsetup>0 。建立时间裕量 Tset_slack = Tcycle -（Tcq+Tlogic）- Tsetup

如果clk1与clk2之间存在skew，如下图所示，如正skew。得建立时间裕量为

Tset_slack = Tcycle -（Tcq+Tlogic）- Tsetup + Tskew

这是对建立时间有益的。

    保持时间裕量计算
在时钟没有skew的情况下。在后一个寄存器有效采样时钟沿之后，同时新的C1只有经过Tcq+Tlogic之后才会到达。故要满足保持时间要求，只需要满足Tcq+Tlogic>Thold。保持时间裕量Thold_slack = Tcq+Tlogic-Thold

如果clk1与clk2之间存在skew。如下图所示（正skew）。

可以看到，C1_NEW在clk2时钟沿后，Tlogic+Tcq-Tskew就改变了。此时保持时间裕量Thold_slack = Tcq+Tlogic-Thold - Tskew 。可以看到，正skew对保持时间是无益的。

总结
可以看到，必须满足建立时间要求和保持时间要求，级满足如下关系式。

Tset_slack = Tcycle -（Tcq+Tlogic）- Tsetup + Tskew>0

Thold_slack = Tcq+Tlogic-Thold - Tskew > 0

从中可以看出，建立时间与保持时间要求是一对矛盾的关系，在设计电路时，我们要折中考虑。

    一个完整的UVM验证平台应该具有一些基本功能：产生并驱动激励，与DUT行为一致的理想参考模型reference_model（golden_model），监测并收集DUT和reference_mode的输入/输出信号，比较并判断DUV和reference_mode的输出是否一致且符合预期结果，等。这些基本的功能由相应的组件来完成。那么，这些组件之间是如何可靠、高效的完成验证工作的？或者说，UVM方法学中有哪些特有的机制可以保证验证平台自动的、可靠的并且高效率的完成验证工作呢？这篇内容将对一些常见的UVM机制进行一些简单的总结。
    常见的UVM机制：
    1.field_automation机制
    对field_automation最直观的感受是，他可以自动实现copy、compare、print等三个函数。当使用uvm_field系列相关宏注册之后，可以直接调用以上三个函数，而无需自己定义。这极大的简化了验证平台的搭建，尤其是简化了driver和monitor，提高了效率。    
    2.config_db机制
    config_db机制在UVM验证平台中主要用于参数传递。它们通常都是成对出现的，set函数是寄信，而get函数是收信。函数格式如下：
    uvm_config_db# (Type)::set(this,"inst_path","field",value); //将value寄送给 “field(字段)”
    uvm_config_db# (Type)::get(this,"","field",field)      //field将接收参数的传递
    结果得到：field = value；    
    所谓“字段”，是变量名包含的内容。在set和get函数中为第三个参数，字段在set和get中必须保持一致，才能保证参数的正确传递。例如要将参数值10，传递给int类型的变量data,则：
    uvm_config_db# (int)::set(this,"env.i_agt.drv","dat",10); //将10寄送给env组件中的成员变量“data”
    uvm_config_db# (int)::get(this,"","dat",data)      //字段“dat”保持一致，成员变量data将接收参数的传递
    结果得到：data = 10;    
    3.objection机制
    UVM中通过objection机制来控制验证平台的关闭，需要在drop_objection之前先raise_objection。验证在进入到某一phase时，UVM会收集此phase提出的所有objection，并且实时监测所有objection是否已经被撤销了，当发现所有都已经撤销后，那么就会关闭此phase，开始进入下一个phase。当所有的phase都执行完毕后，就会调用$finish来将整个验证平台关掉。如果UVM发现此phase没有提起任何objection，那么将会直接跳转到下一个phase中。
    UVM的设计哲学就是全部由sequence来控制激励生成，因此一般情况下只在sequence中控制objection。另外还需注意的是，raise_objection语句必须在main_phase中第一个消耗仿真时间的语句之前。
    4.factory机制
    factory机制的优势在于其具有重载功能。重载并不是factory机制的发明，只是factory机制的重载与这些重载都不一样。要想使用factory机制的重载功能，必须满足以下要求：
    1) 无论是重载的类（parrot）还是被重载的类（bird），都要在定义时注册到factory机制中。
    2) 被重载的类（bird）在实例化时，要使用factory机制的方式进行实例化，而不能使用传统的new的方式。
    3) 最重要的是，重载的类（parrot）要与被重载的类（bird）有派生关系。重载的类必须派生自被重载的类，被重载的类必须是重载类的父类。
    4) component与object之间互相不能重载。虽然uvm_component是派生自uvm_object，但是这两者根本不能重载。因为，从两者的new参数的函数就可以看出来，二者互相重载时，多出来的一个parent参数会使factory机制无所适从。
    当然，factory机制的实现被集成在了一个宏中：uvm_component_utils。这个宏最主要的任务是，将字符串登记在UVM内部的一张表中，这张表是factory功能实现的基础。只要在定义一个新的类时使用这个宏，就相当于把这个类注册到了这张表中。这样，factory机制可以实现：根据一个字符串自动创建一个类的实例，并且调用其中的函数（function）和任务（task），这个类的main_phase就会被自动调用。
    5.callback机制
    在UVM验证平台中，callback机制最大的用处就是提高验证平台的可重用性。很多情况下，验证人员期望在一个项目中开发的验证平台能够用于另外一个项目。但是，通常来说，完全的重用是比较难实现的，两个不同的项目之间或多或少会有一些差异。如果把两个项目不同的地方使用callback函数来做，而把相同的地方写成一个完整的env，这样重用时，只要改变相关的callback函数，env可完全的重用。
    除了提高可重用性外，callback机制还用于构建异常的测试用例，VMM用户会非常熟悉这一点。只是在UVM中，构建异常的测试用例有很多种方式，如factory机制重载，而callback机制只是其中的一种。
    6.phase机制
    在不同的时间做不同的事情，这就是UVM中phase的设计哲学。但是仅仅划分成phase是不够的，phase的自动执行功能才极大方便了用户。当new语句执行完成后，后边的connect语句肯定就会自动执行。现引入phase概念，将前面的new的部分包裹进build_phase里面，把后边的connect语句包裹进connect_phase里边，很自然的，当build_phase执行结束后就应该自动执行connect_phase。
    phase的引入在很大程度上解决了因代码顺序杂乱可能会引起的问题。遵循UVM的代码顺序划分原则（如build_phase做例化工作，connect_phase做连接工作等），可以在很大程度上减少验证平台开发者的工作量，使其从一段杂乱的工作中解脱出来。
    UVM中的phase按照其是否消耗仿真时间（$time打印出的时间）的特性，可以分成两大类：一类是function_phase，如产生build_phase、connect_phase等，这些phase都不消耗仿真时间，通过函数来实现；另一类是task_phase，如run_phase等，他们消耗仿真时间，通过任务来实现。给DUT施加激励、监测DUT的输出都是在这些phase中完成的。
    所有的phase按照以下顺序自上而下自动执行：
    build_pase
    connect_phase
    end_of_elaboration_phase
    start_of_simulation_phase
    *run_pase*
    extract_phase
    check_phase
    report_phase
    final_phase

    其中，*run_phase*按照以下顺序自上而下执行：
    pre_reset_phase
    reset_phase
    post_reset_phase
    pre_configure_phase
    configure_phase
    post_configure_phase
    pre_main_phase
    main_phase
    post_main_phase
    pre_shutdown_phase
    shutdown_phase
    post_shutdown_phase

    7.sequence机制
    sequence机制用于产生激励，它是UVM中最重要的机制之一。sequence机制有两大组成部分：sequence和sequencer。在整个验证平台中sequence处于一个比较特殊的位置。sequence不属于验证平台的任何一部分，但是它与sequencer之间有着密切的关系。只有在sequencer的帮助下，sequence产生的transaction才能最终送给driver；同样，sequencer只有在sequence出现的情况下才能体现出其价值，如果没有sequence，sequencer几乎没有任何作用。除此之外，sequence与sequencer还有显著的区别。从本质上说，sequencer是一个uvm_component,而sequence是一个uvm_object。与my_transaction一样，sequence也有其生命周期。它的生命周期比my_transaction要更长一点，其内部的transaction全部发送完毕后，它的生命周期也就结束了。
    8.通信机制TLM1.0
    UVM中，通常使用TLM（Transaction Level Modeling）实现component之间transaction级别的通信。TLM现在已经发展到TLM2.0，是对TLM1.0的扩展。但是TLM1.0足以满足大多数完整的验证平台的通信要求，所以主要学习TLM1.0。关于TLM1.0通信机制，后续将会详细介绍。

1、Recovery check 和 Removal check的概念？ 怎么保证不出现问题 ？(有关异步信号/异步复位)

  对于一个异步复位寄存器来说，异步复位信号需要和时钟满足recovery time和removal time 才能有效进行复位和复位释放操作，防止输出亚稳态。

 1.1 Recovery time：恢复时间

 撤销复位时，恢复到非复位状态的电平必须在时钟有效沿来临之前的一段时间到来，才能保证有效地恢复到非复位状态，此段时间为recovery time。类似于同步时钟的setup time。

 如图所示，rst_n为0表示复位，clk上升沿触发，rst_n从0到1的上升沿与时钟上升沿之间地时间差必须不小于recovery time才能保证寄存器恢复到正常状态。

 1.2 Removal time：去除时间

 复位时，在时钟有效沿来临之后复位信号还需要保持的时间为去除时间removal time。类似同步时钟hold time。

 如图所示，rst_n为0表示复位有效，clk为上升沿触发，rst_n保持为0经过clk上升沿后仍需要保持一段时间，才能保证寄存器有效复位，防止亚稳态。

2、 画出 Y=A+BC 的 COMS 电路？

3、SDF 文件在 IC 设计中哪个阶段使用？文件包含了哪些信息？

 SDF ： Standard delay format,标准延时格式，是IEEE标准，它描述设计中的时序信息，包括cell delay 和wire delay。cell delay是指模块内部的延时，wire delay是器件互连的延时。 

4、画出 4 分频电路？

5、画出 assign out = (a[3:0] != 4’b0001)的门电路？

a[3:0] == 4’b0001  ->  out = 1’b0 ;

a[3:0] != 4’b0001   ->  out = 1’b1 ;

6、分析以下电路功能？

上图左边为一个16分频的电路。

当 A 为低电平时，5个D触发器全部复位，Y输出低电平

当 A 为高电平时，左边4个触发器开始分频计数，计数到第4个触发器输出高电平（上升沿，分频器半个周期，8个CLK周期）时，Y输出高电平。

即个人觉得功能是检测输入A高电平脉冲宽度

7、写 verilog 代码。

输入 in，输出 out，对输入 in 维持的周期进行计数 N：

如果 N<4，则 out 为 0，

如果 N>4，则将 out 拉高，并保持 N/4个周期数，限定 N/4 不大于 6

使用状态机，

current_state == 0 : IDLE

current_state == 1 : 计数

current_state == 2 :  计算out高电平持续周期

current_state == 3 : 拉高out

1、如何将XOR门转换为buffer和inverter（仅使用一个XOR门）？

                                                    Buffer

                                                    Inverter

2、使用2x1 MUX实现2输入AND门

3、什么是多路复用器（mux）？

多路复用器是一种组合电路，它从许多输入信号中选择一个作为输出。

4、什么是环形振荡器？

环形计数器是一种由循环移位寄存器组成的计数器。最后一个移位寄存器的输出被馈送到第一个寄存器的输入。例如，在4寄存器计数器中，初始寄存器值为1100，重复模式为：1100,0110,0011,1001,1100，依此类推。

5、比较同步和异步复位。

同步复位逻辑将综合较小的触发器，但是组合逻辑门数会增加。时钟可以滤除复位信号的毛刺，但是如果这些毛刺发生在有效时钟边沿附近，则触发器可能会变成亚稳态。在某些设计中，复位必须由一组内部逻辑生成的。建议对这些类型的设计进行同步复位，因为它会过滤时钟之间的毛刺。

同步复位的问题在于综合工具不能容易地将复位信号与任何其他数据信号区分开。同步复位需要在数据路径中增加额外的逻辑和延迟以处理同步复位。 

异步复位：使用异步复位，不会在数据路径增加额外的逻辑门。异步复位的主要问题是复位释放。如果复位的释放发生在时钟边沿或者接近时钟边沿，则触发器可能进入亚稳态。

6、什么是Johnson计数器？

Johnson计数器将最后一个移位寄存器的输出反相连接到它的输入。例如，在包含4个寄存器Johnson计数器中，重复模式是：0000,1000,1100,1110,1111,0111,0011,0001，依此类推。

7、在4位Johnson计数器中有多少未使用的状态？

4位Johnson计数器：0000,1000,1100,1110,1111,0111,0011,0001,0000。

存在8个未使用的状态。

8、使用最少数量的2个输入与非门设计3输入与非门。

9、如何将JK触发器转换为D触发器？

10、触发器和锁存器之间有什么区别？         

触发器是边沿敏感，锁存器是电平敏感。触发器不受毛刺的影响，锁存器对毛刺很敏感。锁存器比触发器需要更少数量的门，功耗更低。锁存器比触发器快。

11、Mealy型状态机和Moore 型状态机有什么区别？

Mealy型状态机输出取决于输入和状态。Moore 型状态机输出仅取决于状态。

12、什么是状态编码技术？ 解释一下。

One-Hot encoding：每个状态由1位触发器表示。 如果有四种状态，那么它需要四个触发器来表示当前状态。 有效状态值为1000,0100,0010和0001.如果值为0100，则表示第二个状态是当前状态。

One-Cold encoding:：与One-Hot encoding:相同，只是'0'是有效值。如果有四种状态，那么它需要四个触发器来表示当前状态。有效状态值是0111,1011,1101和1110。

Binary encoding:每个状态由二进制代码表示。具有“2^N”状态的有限状态机仅需要N个触发器。 

  Gray encoding: 每个状态由格雷码表示。具有“2^N”状态的有限状态机仅需要N个触发器。

13、什么是时钟偏移（Clockskew），负时钟偏移，正时钟偏移？

时钟偏移是同步电路中的一种现象，时钟信号在不同时间到达不同的时序器件。这可能是由许多不同的因素造成的，例如导线互连长度，温度变化，电容耦合等。

时钟偏差有两种类型：负偏斜和正偏斜。当时钟到达接收寄存器比到达发送寄存器时，会发生正偏移。负偏斜是相反的：接收寄存器比发送寄存器更早地获得时钟触发。

14、给出CMOS NAND门的晶体管级电路。

15、什么是亚稳态（Metastability）。

如果在任何时序电路中存在建立（setup time）和保持时间（hold time）违例，则输出会进入不可预测的状态，该状态称为亚稳状态。在亚稳状态结束时，触发器稳定至逻辑高或逻辑低。

16、什么是setup时间和hold时间

setup时间是时钟边沿到达之前的数据需要稳定的时间。

hold时间是在时钟边沿到达之后数据需要稳定的时间。

当触发器中存在setup和hold时间违例时，它就进入输出不可预测的状态，这被称为亚稳状态。

17、画出二分频电路

18、给出两种将两输入NAND门转换为反相器的方法。

19、使用2x1多路复用器实现D锁存器。

20、如果A * B = C且C * A = B那么，布尔运算符*是什么？

  * is 异或

21、使用PLA实现功能：X = A'BC+ ABC + A'B'C'和Y = ABC + AB'C。

可编程互连线

22、什么是LUT？

LUT  - 查找表。查找表可以用多路复用器实现，其选择是LUT的输入。LUT可以通过真值表来编码任何布尔函数。LUT实际上是现代FPGA的关键组件。

23、FPGA在现代电子产品中的重要意义是什么？

• ASIC原型设计：由于ASIC芯片的高成本，首先在FPGA中验证。

• 数字信号处理
  

24、什么是bus？

总线是一组承载数据，地址和控制信号的线。

25、什么是三态逻辑？

使用三个逻辑电平，它们是高，低和高阻抗状态。高和低是逻辑1和零电平。高阻抗状态是电气开路状态。三态逻辑有enable端。

26、什么是冯·诺依曼架构？

冯·诺依曼体系结构是一种计算机设计模型，它使用单独的存储结构来保存指令和数据。从存储器读取指令/数据并由处理单元执行。

27、function和task有什么区别？

function                                                                                    

可以调用其他function，但是不能调用其他task  

消耗0仿真时间                     

不得包含任何延迟和时序控制语句。         

必须至少有一个输入参数。 

函数始终返回单个值。他们不能有output或inout参数。 

task

可以调用其他function 和 task

消耗非0仿真时间

可以包含任何延迟和时序控制语句。

可以有零个或多个类型为input，output或inout参数。

output或inout参数。 任务不返回值，但可以通过output或inout参数传递多个值。

28、$ display和$ monitor有什么区别？

$ monitor持续监视参数列表中指定的变量或信号的值，并在任何一个变量/参数的值发生变化时执行该语句。

与$ display不同，$ monitor只需要调用一次。

29、wire和reg有什么区别？

Wire是一种net数据类型，表示硬件元素之间的连接。 它的默认值是z。 reg是寄存器数据类型，表示数据存储元素。 寄存器保留值，直到将另一个值放在它们上面。 它的默认值是x。

30、阻塞赋值和非阻塞赋值有什么区别？

阻塞赋值语句按顺序块中指定的顺序执行。 阻塞赋值不会阻止并行块中的语句执行。“=”运算符用于指定阻塞赋值。

非阻塞赋值不阻止顺序块中的语句。“<=”运算符用于指定非阻塞赋值。

31、使用和不使用临时寄存器写一个verilog代码来交换两个寄存器的内容。

With a temporary register:

always @ (posedge clock) begin
  temp_reg=b;
  b=a;
  a=temp_reg;
  end

Without using a temporary register:

always @ (posedge clock) begin
  a < = b;
  b < = a;
 end

32、`timescale 1 ns / 1ps 在verilog代码中表示什么？

这意味着时间单位为1ns，精度最高可达1ps。

33、在纯组合电路中，是否有必要在敏感列表中的列入所有输入？为什么？

 是的，在组合电路中，如果其中一个输入发生变化，则输出重新计算。因此，必须将所有输入信号放在敏感列表中。

34、如何使用verilog编码生成正弦波？

使用CORDIC算法。

35、如何在Verilog中描述同步和异步复位？

Synchronous reset:always @(posedge clk)begin  
        -- 
        if(reset)  
          --
        end

Asynchronous reset:always @(posedge clk or posedge reset)begin 
        -- 
        if(reset) 
         --
        end

36、是否可以优化Verilog代码，以便实现低功耗设计？

是。尝试优化代码，以减少数据转换和filp-flops的时钟切换。

37、为什么现有的VLSI电路使用MOSFET而不是BJT

与BJT相比，MOSFET可以面积更小并且制造相对简单。

38、什么是阈值电压？

栅极和源极之间的电压值，即VGS，其中足够数量的移动电子在沟道区域中累积以形成导电沟道被称为阈值电压（Vt对于NMOS是正的而对于PMOS是负的）。

39、给出CMOS开关功耗的表达式。

P_switching = (1/2)CV_dd²/f
P_switching = Switchingpower.
C = Load capacitance.
V_dd = Supplyvoltage.
f = Operating frequency.

40、VLSI优化的重要方面是什么？

Power, Area, and Speed.

41、功耗的来源是什么？

+动态功耗，逻辑转换导致逻辑门负载电容充电/放电。

+短路电流，在逻辑转换期间短路（一段时间）时发生。

+泄露功耗，由泄漏电流引起的。

42、为什么需要减少功耗？

低功耗可延长电池寿命，降低冷却和封装成本。

43、提供一些低功耗设计技术。

电压调节，晶体管尺寸调整，电源管理模式等。

44、逻辑电路中的毛刺是否会导致功耗泄露？

是的，因为它们会导致逻辑门的转换。

45、SRAM中功耗浪费的主要来源是什么？

要读写数据，需要激活字线，这会导致行中的所有列都处于激活状态，即使我们只需要一个字数据。这消耗了大量的功耗。

46、在CMOS数字设计中，为什么PMOS的尺寸通常高于NMOS的尺寸？

在PMOS中，载流子是空穴，其迁移率小于NMOS中的载流子，电子。这意味着PMOS比NMOS慢。在CMOS技术中，NMOS将输出下拉至地，PMOS将输出上拉至Vdd。如果PMOS和NMOS的大小相同，则PMOS需要很长时间才能对输出节点充电。如果我们有更大的PMOS，那么充电更快。所有这些都是为了输出节点的上升时间和下降时间相等。

47、什么是slack？

slack是特定路径中要求延迟与实际延迟的时间差。 Slack可以是正的也可以是负的。

48、如果负载电容增加，延迟会发生什么？

延迟增加。

49、为什么逻辑综合最好读入floorplan信息？

提高逻辑综合和物理实现的时序相关性

50、在设计中，有多少种时序路径？

reg2reg、input2reg、reg2output、input2output

大公司内推岗位：AMD，海光，德州仪器，杭州矽力杰，苏州瑞晟微电子，盛科网络，兆芯的一切职位

小公司以及创业ai公司招聘：上海，深圳，珠海，广州，成都，杭州，苏州，北京，西安，数字ic设计工程师，数字验证工程师，模拟ic设计工程师，DFT,FPGA,数字后端工程师，RFIC,射频工程师，ae,fae,sales.欢迎自荐和推荐。
联系方式：微信chipist1

本文来自于数字芯片实验室。

1、连续赋值和过程赋值之间有什么区别？

2、initial和always中的赋值有什么区别？

    initial和always中的赋值都是过程赋值。

3、阻塞和非阻塞赋值之间有什么区别？

阻塞和非阻塞赋值都是过程赋值。

4、如何使用连续赋值建模双向nets？

assign语句构成一个连续赋值。 RHS变化立即影响LHS。 然而，LHS的任何变化都不会影响RHS。

例如，在以下声明，rhs的更改将更新到lhs，但反之不会。

      wire rhs,lhs;

      assign lhs=rhs;

System Verilog引入了一个关键字alias，能定义双向nets。

例如，在以下代码中，rhs的任何变化都会更新到lhs，反之亦然。

module test_alias;

     wire [3:0] lhs,rhs;

     alias lhs=rhs;

   initial begin

         force rhs=4'h2;

         $display("lhs=%0h,rhs=%0h",lhs,rhs);

         release rhs;

         force lhs=4'hc;

        $display("lhs=%0h,rhs=%0h",lhs,rhs);

        release lhs;

    end

endmodule //test_alias

5、task和function之间有什么区别？

6、静态task和动态task有何不同？

   动态task在关键字task和名称之间有automatic关键字。 动态task在每个task调用期间，自动分配变量内存空间，即每次调用都不会覆盖这些值。没有automatic关键字，变量是静态分配的，这意味着这些变量在不同的task调用之间共享，因此可以被覆盖。

以下示例说明了关键字automatic的效果。 这是一个不可综合的代码。

module modify_taskval;

    integer out_val;

    task automatic modify_value;

       input [1:0] in_value;

       output [3:0] out_value;

       reg [1:0] my_value;

       begin

          //syntax error to use nonblocking assignment with automatic variables            

          my_value=in_value; //blocking assigment

          $display("my_value=\t%0d,t=%0d",my_value,$time);

          out_value=my_value+2;

       end

   endtask

  initial begin

      fork 

         begin  //first parallel call

           #1        

             $display("in1=\t\t%0d,t=%0d",2,$time);

             modify_value(2,out_val);

          end 

         begin  //second parallel call

           #2        

             $display("in2=\t\t%0d,t=%0d",3,$time);

             modify_value(3,out_val);

          end

        join

   end

endmodule

  在上面的示例中，my_value是task中的局部变量。 每当调用此task时，输入in_value在5个仿真时间单位之后赋值给局部变量。 在initial begin中，有一个fork-join，它启动两个并行进程，分别在仿真时间单位＃1和＃2之后开始。 第1个进程赋值2给my_value，第2个进程赋值3给my_value。 假设没有automatic关键字，使用上面的代码运行仿真，会输出以下内容：

in1      =2 ,t=1 //passed value is 2

in2      =3 ,t=2

my_value   =3 ,t=6 //retained value is 3

my_value   =3 ,t=7

in1      =2 ,t=1 //passed value is 2

in2      =3 ,t=2

my_value   =2 ,t=6 //passed value 2 preserved

my_value   =3 ,t=7

按照上述相同的步骤，这次，由于存在关键字automatic，变量不会被其他进程覆盖。

下表总结了动态task和静态task之间的差异：

7、如何覆盖automatic task中的变量？

默认情况下，module中的所有变量都是静态的。 但是， task/function中的变量都可以定义为static或automatic。

以下示例组合了static或者automatic的task/function和其变量：

1、task/function和其变量都没有定义为automatic

在Verilog-1995中，task/function和其变量都是隐式静态的。 变量仅分配一次内存，多次调用将覆盖其变量。

2、static task/function

System Verilog引入了关键字static。 当task/function被明确定义为static，它的变量只分配一次内存，并且多次调用将覆盖其变量。 、

3、automatic task/function

从Verilog-2001开始，当task/function定义为automatic，其变量也是隐式automatic的。 因此，在多次调用task/function时，变量每次都会分配内存并不会覆盖。

4、static  task/function和automatic变量

SystemVerilog还允许在静态task/function中使用automatic变量。 那些没有automatic定义的变量会保持隐含的静态。 这在变量需要在task/function调用之前初始化，并且自动分配内存的情况下很有用

5、automatic task/function和static变量

SystemVerilog还允许automatic task/function中使用静态变量。没有static声明的那些变量将保留隐式automatic。 这在静态变量需要为每次调用更新变量值的场景中很有用

8、如何没有返回值地调用function？

      在Verilog 2001之前，任何function调用都必须返回一个值，调用function的代码必须接收返回值。 例如，以下是语法错误：

 function my_funct;

    ...

  endfunction

   intial begin

      my_funct(..)  //MUST have a destination

   end

上面例子中的一行是语法错误，因为调用了my_funct，却没有返回值。 只有task可以在没有返回值的情况下调用。

SystemVerilog引入了void来支持没有返回值的function调用。 这使得function调用类似于task调用。

以下示例说明void的function调用：

module func_1bit;

  reg [31:0] int_result;

   function void my_func;

       input [31:0] in1;

       input [31:0] in2;

       output [31:0] out1;

       int_result=in1+in2;

   endfunction

  initial begin

     my_func(3,4,int_result);

     $display("int_result=%0d",int_result);

  end

endmodule

上面的例子显示了结果：

int_result = 7

同时：

1、function不能使用＃，@等结构

2、function不能使用非阻塞赋值。

3、function返回值默认为1比特位宽

9、

如何在例化时修改模块的parameter值？

如果Verilog模块使用parameter，有两种方法可以修改它

值。

1）按顺序列表：

在此方法中，parameters的修改顺序和模块中声明它们的顺序一样。 例如，parameter_list模块包含两个参数，即width和depth，已在模块中分配默认值。 并且在example_parameter_list模块中实例化，并且这些parameter在不同的实例化中被不同的值覆盖。

module parameter_list(addr,data);//1995 format

   parameter width=32;

   parameter depth=64;

   parameter num_buses=44;

   input [width-1:0] addr;

   input [depth-1:0] data;

   ...

endmodule

module example_ordered_list;

   reg [127:0] a;

   reg [255:0] b;

   reg [63:0]  c;

   reg [31:0]  d;

  //Instantiating parameter_list module and 

 //overriding width only

  parameter_list #(128) U0 (a,c);

  //Instantiating parameter_list module and 

 //overriding width and depth only

  parameter_list #(128,256) U1(a,b); 

  //Instantiating parameter_list module and 

 //overriding num_buses only

 parameter_list #(32,256,8)  U2(d,b);

endmodule

使用上述方法的限制是：

parameter修改值必须被按顺序修改覆盖。 例如，在上面代码中，U2实例化parameter_list，不能跳过width 和depth直接修改num_buses

我们有两种方法克服这种限制：

1、  在声明模块内的parameter时，将后面例化时需要改变的parameter声明在不需要改变的parameter之前。 例如，在上面的代码中,U0和U1实例化了parameter_list .num_buses不需要更改，所以最后声明，分配给它的是默认值。

2、  在模块实例化时，为所有的parameter分配值，包括不需要修改的parameter。 在U2实例化中，虽然只有num_buses参数需要改变，但width and depth仍然需要分配模块中定义的相同的默认值。

2）按名称指定：

这是Verilog-2001开始提供的一项新功能，可以通过显式指定parameter来更好地修改模块的parameter。 这样，parameter值就链接到它的名字，而不是声明时的位置顺序。

使用与上面相同的模块parameter_list，

下面的示例显示了按名称指定的相同的parameter修改覆盖。

module example_by_name;

  reg [127:0] a;

  reg [255:0] b;

  reg [63:0] c;

  reg [31:0] d;

  //Instantiating parameter_list module and 

 //overriding width only

  parameter_list #(.width(128)) U0(a,c);

  //Instantiating parameter_list module and 

 //overriding width and depth

  parameter_list #(.width(128),.depth(256)) U1(a,b);

  //Instantiating parameter_list module and 

  //overriding depth only

  parameter_list #(.depth(256)) U2(d,b);

endmodule

请注意，显式地按parameter名称指定修改方式，括号中的值是修改的值。 在在U2实例化中，只需指定depth即可，无需为width指定任何修改值。

3）使用 defparam：

在此方法中，模块中的parameter根据其层次结构名称访问。 在下面的示例中，低层次模块parameter_list在example_defparam模块中实例化。 但是width和depth的值使用defparam修改。

module example_defparam;

  reg [127:0] a;

  reg [255:0] b;

  reg [63:0] c;

  reg [31:0] d;

  //Instantiating parameter_list module and 

 //overriding width only

  parameter U0.width=128;

  //Instantiating parameter_list module and 

 //overriding width and depth

 parameter_list U1(a,b);

 defparam U1.width=128;

 defparam U1.width=256;

  //Instantiating parameter_list module and 

 //overriding depth only

  parameter_list U2(d,b);

  defparam U2.depth=256;

endmodule

以下总结了使用defparam方法的优点：

1、修改parameter值是不需要遵循parameter声明顺序

2、可以修改特定parameter，而不是重新指定所有parameters

3、通过对defparam进行分组，可以帮助进行代码维护

10、如果阻止模块例化时parameters不被改变

如果需要阻止模块中的特定parameters被改变，应该使用localparam，而不是parameter。 localparam在Verilog-2001中引入。在以下示例中，localparam用于声明num_bits，因此尝试改变它会给出Error。

module localparam_list(addr,data);

   parameter width=32;

   parameter depth=64;

   localparam num_bits=width*depth;

   input [width-1:0] addr;

   input [depth-1:0] data;

  ...

endmodule

请注意，由于width和depth是使用parameter指定的，它们可以在实例化时被改变。

通常，localparam定义本地化标识符，其值来自常规parameters。

11、使用`define和parameter有什么区别？

`define和parameter都可以在设计中用来指定常量。 例如：

`define width 64

  if(`width==64) ...

or

 parameter width=64;

  if(width==64) ...

12、什么是派生parameters？

当一个或多个parameters用于定义另一个parameters时，则结果是派生parameters。 派生parameters可以是parameter或localparam。 在以下示例中，有两个parameter，width和 depth,，用于定义第三个parameter，num_bits。

在这种情况下，num_bits的值为32。

module derived_param;

13、层次化设计当中连接Ports的方法有哪些？各自的优缺点是什么？

1）按顺序连接

在此方法中，模块实例化中的端口顺序应与模块声明中的端口顺序相同。 例如，在下面的代码中，upper模块实例化lower模块，并且端口是隐式连接的，也就是说，按顺序连接的。

module lower(addr,data);

2）按名称连接

在此方法中，可以通过port名称，在实例化模块时显式地完成port之间的连接。如下所示，按名称连接连接进行连接port。

 lower U1(

   .data(out1),

   .addr(in1)

);

按名称连接提高了port连接的可读性， 和port声明的顺序不再相关，因为它们是显示连接的。

请注意，两种类型的模块port连接不能混合，也就是说，下面示例的连接方式不正确：

//gives a syntax error

3）按Interface连接

SystemVerilog引入了一个interface结构，将一束nets和variables封装到一个组中。使用Interface，有助于创造可维护的代码。 对Interface定义的更改会影响所有实例化interface的模块。 下面是使用Interface结构的示例：

interface basic_con;

   wire [7:0] in1,in2,in3; //bi-dir wire

endinterface:basic_con

module lower (

   basic_con all_ins, //all inputs

   output [7:0] out1,out2

);

assign out1=all_ins.in1&all_ins.in2;

assign out2=all_ins.in1 |all_ins.in3;

endmodule

在上面的例子中，all_ins是实例化的Interface，指定in1到in3端口的ports连接。

本文来自于数字芯片实验室。

// Sample APB register code
// Standard read/write registers
// Adress offset from psel:
//  0x00 : 32 bit read of status32 port
//  0x04 : 32 bit read & write control32 port
//  0x08 : 16 bit status
//         and 16 bit read & write control16 port
//  0x0C : 8 bit status8
//          and 8 bit read & write control8port
module apb_regs1 (  
    //system   
    //APB   
    //Interface);
    ...
 endmodule

其中，

// system  
     input             reset_n,
     input             enable,  // clock gating

是系统复位和使能信号

// APB  
input             pclk,             
input      [ 3:0] paddr,   // ls 2 bits are unused   
input             pwrite,  
input             psel,  
input             penable,  
input      [31:0] pwdata,  
output reg [31:0] prdata,  
output            pready,  
output            pslverr,

是APB slave的接口信号

// Interface  
  input                 [31:0]   status32,  
  input                 [15:0]   status16,  
  input                 [7:0]    status8,  
  output reg         [31:0]   control32,  
  output reg         [15:0]   control16,  
  output reg         [7:0]    control8

是一个自定义模块的寄存器，其中status32是read_only

wire apb_write = psel & penable &pwrite;wire apb_read  = psel & ~pwrite;

apb_write和apb_read是为了满足APB协议做的读写控制。apb_read信号产生和apb_write不同，具体原因可以查阅APB协议官方文档

assign pready = 1'b1;assign pslverr = 1'b0;

该APB slave模块只是对一些控制和状态寄存器进行读写，是无等待传输，同时不生成传输错误信号。

always @(posedge pclk or negedge reset_n) 

   begin    
       if (!reset_n)    
           begin      
              control32   <= 32'h0;  
              control16   <= 16'h1234; // reset/initial value    
             control8   <=  8'h0;        
             prdata    <= 32'h0;    
           end  // reset    
       else if (enable)    
          begin         
             if (apb_write)        
                 begin          
                    case (paddr)        
                        //4'h0 :  status32 read only           
                        4'h4 : control32 <= pwdata;          
                        4'h8 : control16 <= pwdata[15:0];          
                        4'hC : control8  <=pwdata[7:0];          
                    endcase        
                 end // write       
            if (apb_read)        
               begin          
                   case (paddr)          
                       4'h0 : prdata <= status32;      
                     4'h4 : prdata <= control32;       
                     4'h8 : prdata <= {status16,control16};      
                     4'hC : prdata <={8'h0,status8,8'h0,control8};  
                endcase      
              end // read      
            else        
               prdata <= 32'h0; // so we can OR all busses    
        end // clocked  
   end // always

然后我们在Testbench里例化APB slave和一个APB master模型，对该APB slave模块进行验证。

apb_bus0.read(16'h00,32'h9c4e9a31);      
apb_bus0.write(16'h04,32'h11223344);
apb_bus0.write(16'h08,32'hAABB);
apb_bus0.write(16'h0C,32'hDD);
apb_bus0.read(16'h04,32'h11223344);
apb_bus0.read(16'h08,32'h7832AABB);
apb_bus0.read(16'h0C,32'h002a00DD);