sv中的一些processes

1. initital;

2. always;

        a. always;

        一般来讲因为其带有循环的性质，因此一般只是在时间控制上有作用，另外因为其不会推进仿真时间，因此使用不当将会造成挂死；

        always areg = ~areg;//挂死

        b. always_comb and always @*;

        1). always_comb中的语句，在仿真0时刻，会自动的执行一次；但是always @*只有在敏感信号变化的时候才会执行；

        2). always_comb中，左侧的变量不能被其他的进程再次修改；always@*可以；

        3). always_comb中的语句，不能有带有时间延迟的语句出现（event,fork-join等）；

        4). always @*的敏感变量，只有内部的信号；而always_comb的敏感变量，包括调用always_comb的function中的所有变量；因此，他们更新的时刻也不同；

        c. always_latch；

        基本同alway_comb， 只是内部必须是latch结构，而comb必须是组合逻辑；

        d. always_ff；

        时序逻辑使用；

3. final

它发生在仿真时间的末尾，并且执行时没有延迟。finial通常用于显示有关仿真的统计信息。

A final procedure executes when simulation ends due to an explicit or implicit call to $finish.

上面的意思是说，当调用$finish的时候，final语句就会执行；

final begin

        $display("Number of cycles executed %d",$time/period);

        $display("Final PC = %h",PC);

end

4. 进程的时间控制；

        a. wait；

        begin

                wait (!enable) ；

                #10 a = b;

                #10 c = d;

        end

        或者是等待某个时间触发；

        sequence abc;

                @(posedge clk) a ##1 b ##1 c;

        endsequence

        sequence de;

                @(negedge clk) d ##[2:5] e;

        endsequence

        program check;

                initial begin wait( abc.triggered || de.triggered );

                 xxxxxxxxx       

        b.repeat;

        repeat (a) @ (event_expression)；等待某个时间a次；这个事件可以是上升沿，也可以是上面的其他时间；

5. process的控制；

a. wait fork;等待所有的fork的执行完成后，往下走；

initial begin : test

        fork         

                child1();

                child2();

        join_none

        do_test();

end : test

task do_test();         

         fork

                child3();

                child4();

                fork : child5 // nested fork-join_none is a child process

                        descendant1();

                        descendant2();

                join_none

        join_none

        do_sequence();

        wait fork; // block until child1 ... child7 complete

endtask

function void do_sequence();

        fork

                child6();

                child7();

        join_none

endfunction

注意不能按照每个fork的粒度来wait, 只能一起wait;

b. disable;

disable的使用场景很多，只要是进程类的，都可以用disable来处理，所谓的进程，包括fork, always, begin/end,task等任何一个进程块；

e.g 0:

 fork

        begin : event_expr

                @ev1;

                repeat (3)  @trig;

                #d action (areg, breg);

        end

        @reset disable event_expr;

join

e.g 1:

task proc_a;

        begin

                ...

                ...

                if (a == 0)

                disable proc_a; // return if true ... ...

e.g 2:

module m (...);

        always

                begin : always1

                ...

                t1: task1( ); // task call

                ...

                end

        ...

        always

                begin

                ...

                disable m.always1; // exit always1, which will exit task1, // if it was currently executing                 end

endmodule

e.g.3: disable fork, 可以按照名字来disable;

task get_first( output int adr );

        fork

                wait_device( 1, adr );

                wait_device( 7, adr );

                wait_device( 13, adr );

        join_any

        disable fork;

endtask