Behavioral Descriptions行為描述動作記述

1. Behaviors: initial and always1. 行為描述：initial 與 always1. ビヘイビア：initial と always

1.1 Merging all different levels1.1 混合各種不同的描述層次1.1 あらゆる記述レベルの混在

A single Verilog module may freely mix every description level: continuous assignments (dataflow), primitive and UDP instances (gate level), sub-module instances (structural) and procedural blocks (behavioral).同一個 Verilog 模組可以自由混用所有描述層次：連續賦值（資料流）、基本閘與 UDP 的實體化（閘層次）、子模組的實體化（結構式），以及程序區塊（行為式）。一つの Verilog モジュールの中で、あらゆる記述レベルを自由に混在させてよい。連続代入（データフロー）、プリミティブと UDP のインスタンス（ゲートレベル）、サブモジュールのインスタンス（構造記述）、そして手続きブロック（動作記述）である。

module my_module (...);
  ...
  assign ...;               // continuous assignment
  and (...);                // instantiation of a primitive
  my_udp (...);             // instantiation of a UDP
  adder_16bits M1 (...);    // instantiation of a module
  always @ (...) begin      // "always" block
    ...
  end
endmodule

1.2 Procedural assignments: initial vs always1.2 程序式賦值：initial 與 always1.2 手続き型代入：initial と always

• The body is a single statement or a begin ... end block.本體是單一敘述，或是一個 begin ... end 區塊。本体は単一の文、または begin ... end ブロックである。
• Procedural statements assign values to register variables (reg, integer, ...). The only exception is force ... release, which can also drive nets.程序式敘述只能對暫存器型別變數（reg、integer 等）賦值。唯一的例外是 force ... release，它也可以驅動 net。手続き文が値を代入できるのはレジスタ型変数（reg、integer など）だけである。唯一の例外は force ... release で、これは net も駆動できる。
• Two constructs:共有兩種建構：構文は二種類ある。
  • initial — one-shot activity flow. Runs once from time 0. Not synthesized, but essential for test-benches.initial — 一次性的活動流程，從時間 0 起只執行一次。不可合成，但在測試平台（test-bench）中不可或缺。initial — 一回限りの動作フロー。時刻 0 から一度だけ実行される。合成はできないが、テストベンチには不可欠である。
  • always — cyclic activity flow. An infinite loop until simulation stops; with an event list it re-evaluates whenever a signal in the sensitivity list changes.always — 循環的活動流程，在模擬結束前都是無窮迴圈；加上事件列表後，只要敏感列表中的訊號改變就重新計算一次。always — 周期的な動作フロー。シミュレーションが止まるまで無限ループする。イベントリストを付ければ、感度リスト中の信号が変化するたびに再評価される。

initial            // an "initial" behavior
  begin
    sig_a = 0;     // procedural assignments
    sig_b = 1;     // execute sequentially
    sig_c = 0;
  end

always @ (b or c or d) begin
  if (b == 1'b1) begin
    a = c;
  end
  else begin
    a = d;
  end
end

2. Blocking vs Non-Blocking Assignment2. 阻擋式與非阻擋式賦值2. ブロッキング代入とノンブロッキング代入

2.1 The two operators2.1 兩種賦值運算子2.1 二つの代入演算子

2.2 Swap examples2.2 交換（swap）範例2.2 スワップの例

Start from a = 1; b = 0;.起始值為 a = 1; b = 0;。初期値を a = 1; b = 0; とする。

2.3 Merged example — four flavours of delay2.3 綜合範例 — 四種延遲寫法2.3 総合例 — 四種類の遅延の書き方

module blocking_nonblocking();
reg a, b, c, d;

initial begin            // (A) blocking, inter-statement delay
  #10 a = 0;
  #11 a = 1;
  #12 a = 0;
  #13 a = 1;
end

initial begin            // (B) non-blocking, inter-statement delay
  #10 b <= 0;
  #11 b <= 1;
  #12 b <= 0;
  #13 b <= 1;
end

initial begin            // (C) blocking, intra-assignment delay
  c = #10 0;
  c = #11 1;
  c = #12 0;
  c = #13 1;
end

initial begin            // (D) non-blocking, intra-assignment delay
  d <= #10 0;
  d <= #11 1;
  d <= #12 0;
  d <= #13 1;
end

initial begin
  $monitor("TIME = %d A = %b B = %b C = %b D = %b", $time, a, b, c, d);
  #50 $finish;
end
endmodule

TIME =  0 A = x B = x C = x D = x
TIME = 10 A = 0 B = 0 C = 0 D = 0
TIME = 11 A = 0 B = 0 C = 0 D = 1
TIME = 12 A = 0 B = 0 C = 0 D = 0
TIME = 13 A = 0 B = 0 C = 0 D = 1
TIME = 21 A = 1 B = 1 C = 1 D = 1
TIME = 33 A = 0 B = 0 C = 0 D = 1
TIME = 46 A = 1 B = 1 C = 1 D = 1

3. Procedural Continuous Assignment (PCA)3. 程序式連續賦值（PCA）3. 手続き型連続代入（PCA）

A PCA is executed from inside a procedural block, but once executed it behaves like a continuous assignment: the target keeps following the RHS expression until the binding is removed.PCA 是在程序區塊內執行的，但一旦執行，它的行為就像連續賦值：在綁定被解除之前，目標會持續跟著 RHS 運算式變化。PCA は手続きブロックの内部で実行されるが、いったん実行されると連続代入のように振る舞う。すなわち、束縛が解除されるまで対象は右辺の式に追従し続ける。

3.1 Method 1: assign ... deassign3.1 方法一：assign ... deassign3.1 方法 1：assign ... deassign

• Target must be a register variable; binding is dynamic.目標必須是暫存器型別的變數；綁定是動態的。対象はレジスタ型の変数でなければならない。束縛は動的である。
• Overrides all ordinary procedural assignments to that register.它會蓋過對該暫存器的所有一般程序式賦值。そのレジスタへの通常の手続き型代入をすべて上書きする。
• Binding lasts until deassign or until a new PCA to the same register is established; deassign is optional.綁定會持續到 deassign，或直到對同一暫存器建立新的 PCA 為止；deassign 並非必要。束縛は deassign まで、あるいは同じレジスタに新しい PCA が設定されるまで続く。deassign は必須ではない。
• Synthesis tools might not support it.合成工具不一定支援。合成ツールが対応していない場合がある。
• Can model level-sensitive behavior: combinational logic, transparent latches, asynchronous control of sequential logic.可以用來描述位準敏感的行為：組合邏輯、透通閂鎖（transparent latch），以及序向邏輯的非同步控制。レベルセンシティブな振る舞いのモデル化に使える。組合せ論理、トランスペアレント・ラッチ、順序論理の非同期制御などである。

Example 1 — 4-to-1 mux with PCA範例 1 — 用 PCA 寫的 4 對 1 多工器例 1 — PCA で書いた 4 対 1 マルチプレクサ

module mux4_PCA (a, b, c, d, select, y_out);
  input       a, b, c, d;
  input [1:0] select;
  output      y_out;
  reg         y_out;

  always @ (select) begin          // Caution!!
    if      (select == 0) assign y_out = a;
    else if (select == 1) assign y_out = b;
    else if (select == 2) assign y_out = c;
    else if (select == 3) assign y_out = d;
    else                  assign y_out = 1'b0;
  end
endmodule

Example 2 — Flip-flop with asynchronous clear/preset範例 2 — 具非同步清除／預設的正反器例 2 — 非同期クリア／プリセット付きフリップフロップ Non-synthesized不可合成合成不可

module Flop_PCA (preset, clear, q, qbar, clock, data);
  input  preset, clear, clock, data;
  output q, qbar;
  reg    q;

  assign qbar = ~q;

  always @ (negedge clock)
    q = data;

  always @ (clear or preset)
    begin
      if      (!clear)  assign q = 0;     // async clear dominates
      else if (!preset) assign q = 1;
      else              deassign q;       // clock regains control
    end
endmodule

While clear or preset is active the PCA overrides the clocked assignment q = data; after deassign, q keeps its value until the next falling clock edge.clear 或 preset 有效期間，PCA 會蓋過時脈同步的賦值 q = data；執行 deassign 之後，q 會保持原值直到下一個時脈下降緣。clear または preset が有効な間、PCA はクロック同期の代入 q = data を上書きする。deassign の後、q は次のクロック立ち下がりまで値を保持する。

3.2 Method 2: force ... release3.2 方法二：force ... release3.2 方法 2：force ... release

• Target may be a net or a register.目標可以是 net 或暫存器。対象は net でもレジスタでもよい。
• On a net it overwrites primitive outputs and continuous assignments; on a register it overrides procedural assignments and assign PCAs.用在 net 上時，它會蓋過基本閘的輸出與連續賦值；用在暫存器上時，它會蓋過程序式賦值以及 assign 形式的 PCA。net に対してはプリミティブの出力と連続代入を上書きし、レジスタに対しては手続き型代入および assign 形式の PCA を上書きする。
• Binding cannot be removed until release.綁定在 release 之前無法解除。束縛は release まで解除できない。
• Synthesis tools might not support it — intended for debugging in a test-bench, often with hierarchical names.合成工具不一定支援 — 它的用途是在測試平台中除錯，常搭配階層式名稱使用。合成ツールが対応していない場合がある。テストベンチでのデバッグ用であり、階層名と組み合わせて使うことが多い。

...
force sig_a = 1;            // internal nodes of the DUT
force sig_b = 1;
force sig_c = 0;
sig_in1 = 0;
#5 sig_in1 = 1;
#5 sig_in1 = 0;
// insert code to construct tests
release sig_a;
release sig_b;
release sig_c;
...

In the lecture diagram sig_a, sig_b come from mod_abc and sig_c from mod_xyz; forcing them isolates the AND/OR gates feeding mod_def so they can be tested independently of the upstream modules.在課堂的圖中，sig_a、sig_b 來自 mod_abc，sig_c 來自 mod_xyz；把它們 force 住就能把餵給 mod_def 的 AND／OR 閘隔離出來，獨立於上游模組進行測試。講義の図では sig_a と sig_b は mod_abc から、sig_c は mod_xyz から来ている。これらを force すると、mod_def へ入力される AND／OR ゲートを切り離し、上流のモジュールとは独立に検証できる。 Non-synthesized不可合成合成不可

3.3 Net / register assignment modes3.3 net 與 register 的賦值模式3.3 net とレジスタの代入モード

4. Procedural Timing Controls4. 程序式時序控制4. 手続き型タイミング制御

Five mechanisms: delay control #, event control @, event or, named events, and the wait construct.共有五種機制：延遲控制 #、事件控制 @、事件 or、具名事件，以及 wait 敘述。機構は五つある。遅延制御 #、イベント制御 @、イベントの or、名前付きイベント、そして wait 構文である。

4.1 Delay control operator (#)4.1 延遲控制運算子（#）4.1 遅延制御演算子（#） Non-synthesized不可合成合成不可

Suspends the activity flow at the location of the operator. Typical use: clock generators in test-benches.在運算子所在的位置暫停活動流程。典型用途：測試平台中的時脈產生器。演算子が置かれた位置で動作フローを停止させる。典型的な用途はテストベンチのクロック生成器である。

always
  begin
    #0  clock = 0;
    #50 clock = 1;
    #50;
  end           // period 100

always
  begin
    #clock_period/2;
    clock = ~clock;
  end           // clock must be initialised!

4.2 Event control operator (@)4.2 事件控制運算子（@）4.2 イベント制御演算子（@） Non-synthesized不可合成合成不可

Synchronizes execution to an event: the flow waits until the event occurs.把執行與某個事件同步：流程會等到該事件發生為止。実行をイベントに同期させる。フローはそのイベントが起こるまで待つ。

...
@ signal_1 a = b;   // wait for any change on signal_1
...

...
@ (event_a) begin
  ...
  @ (event_b) begin
    ...
  end
end
...

4.3 posedge and negedge4.3 posedge 與 negedge4.3 posedge と negedge

Usually used for clock and reset signals in the sensitivity list:通常用在敏感列表中的時脈與重置訊號：通常は感度リスト中のクロックやリセット信号に用いる。

always @ (posedge clock) begin
  #10 b = a;     // samples a 10 units AFTER the edge
end

4.4 Event or4.4 事件 or4.4 イベントの or

Positive-edge D flip-flop with asynchronous active-low set and reset:具非同步低態有效 set 與 reset 的正緣觸發 D 型正反器：非同期かつ負論理の set と reset をもつ立ち上がりエッジ D フリップフロップ：

always @ (posedge clk or negedge set or negedge rst) begin
  if (rst == 0)
    q = 1'b0;          // reset has highest priority
  else if (set == 0)
    q = 1'b1;
  else if (clk == 1)
    q = data_in;       // woke up by the clock edge
  else
    q = q;
end

4.5 Named events4.5 具名事件4.5 名前付きイベント Non-synthesized不可合成合成不可

• Synchronization within and between modules.可用於模組內部以及模組之間的同步。モジュール内およびモジュール間の同期に使える。
• Declared only inside a module with the keyword event; referenced directly in that module, or in other modules by hierarchical dereferencing.只能在模組內用關鍵字 event 宣告；在該模組內可直接引用，其他模組則需透過階層式名稱取用。モジュール内でのみキーワード event により宣言する。そのモジュール内では直接参照でき、他のモジュールからは階層名で参照する。
• Triggered explicitly with the event-trigger operator ->.必須用事件觸發運算子 -> 明確觸發。イベントトリガ演算子 -> によって明示的に起動する。

module top (clk, data, q);
  input  clk, data;
  output q;
  talker   M1 (clk);
  receiver M2 (q, data);
endmodule

module talker (clk);
  input clk;
  event do_it;
  always @ (posedge clk)
    -> do_it;           // trigger
endmodule

module receiver (q, data);
  input  data;
  output q;
  reg    q;
  always @ (top.M1.do_it) // hierarchical
    q = data;
endmodule

4.6 wait statement4.6 wait 敘述4.6 wait 文 Non-synthesized不可合成合成不可

Suspends the activity flow until the expression is true (level-sensitive, unlike the edge-sensitive @). If the condition is already true, execution continues immediately.暫停活動流程直到運算式為真（屬於位準敏感，與邊緣敏感的 @ 不同）。若條件當下已經為真，則立即繼續執行。式が真になるまで動作フローを停止させる（エッジセンシティブな @ と異なり、レベルセンシティブである）。条件がすでに真であれば、ただちに実行を続ける。

data_out = 0;
wait (enable) data_out = data_in;

5. Intra-Assignment Delay5. 賦值內延遲5. 代入内遅延

5.1 Postpone assignment, not evaluation5.1 延後的是賦值，不是運算5.1 先送りされるのは代入であって評価ではない

In lhs = #d rhs; or lhs = @(ev) rhs; the RHS is evaluated immediately; only the update of the LHS waits.在 lhs = #d rhs; 或 lhs = @(ev) rhs; 之中，RHS 會立刻被計算；只有 LHS 的更新要等待。lhs = #d rhs; や lhs = @(ev) rhs; では、右辺はただちに評価される。待たされるのは左辺の更新だけである。

a = #5 b;        // sample b now, write a at +5
c = d;           // runs at +5 (blocked)

e = @(bus) f;    // sample f now, write e at next bus change
g = h;           // runs after e is written

initial begin
  @(posedge clk)
    g <= @(bus) k;   // sample k, schedule
    p <= q;          // runs immediately
end

always begin
  @(posedge clock)
    g <= @(bus) k;
end

The equivalent of a = #5 b; is begin temp = b; #5 a = temp; end.a = #5 b; 等價於 begin temp = b; #5 a = temp; end。a = #5 b; は begin temp = b; #5 a = temp; end と等価である。

5.2 Five delay styles compared5.2 五種延遲寫法的比較5.2 五つの遅延スタイルの比較

5.3 Repeated intra-assignment delay5.3 重複的賦值內延遲5.3 繰り返し付き代入内遅延 Non-synthesized不可合成合成不可

reg_a = repeat (5) @ (negedge clock) reg_b;

begin                     // equivalent
  temp = reg_b;
  @ (negedge clock);
  @ (negedge clock);
  @ (negedge clock);
  @ (negedge clock);
  @ (negedge clock);
  reg_a = temp;
end

Test-bench example:測試平台範例：テストベンチの例：

module repeater;
  reg clock;
  reg reg_a, reg_b;

  initial clock = 0;
  always #5 clock = ~clock;

  initial begin
    #5  reg_a = 1;
    #10 reg_a = 0;
    #5  reg_a = 1;
    #20 reg_a = 0;
  end

  initial #100 $finish;

  initial begin
    #10 reg_b = repeat (5) @ (posedge clock) reg_a;
  end
endmodule

6. Simulation of Procedural Assignments6. 程序式賦值的模擬6. 手続き型代入のシミュレーション

6.1 Order of operations within one time step6.1 單一時間步內的執行順序6.1 一つの時間ステップ内での処理順序

1. Evaluate expressions on the RHS.計算所有 RHS 上的運算式。右辺の式を評価する。
2. Execute blocking assignments.執行阻擋式賦值。ブロッキング代入を実行する。
3. Execute non-blocking assignments that do not have intra-assignment timing control.執行沒有賦值內時序控制的非阻擋式賦值。代入内タイミング制御を持たないノンブロッキング代入を実行する。
4. Execute past assignments that were scheduled to execute in the current time step.執行過去排程、指定在目前時間步生效的賦值。過去にスケジュールされ、現在の時間ステップで実行される代入を処理する。
5. Execute $monitor. ($display executes when it is encountered, i.e. before the non-blocking updates.)執行 $monitor。（$display 則是在被執行到的當下就印出，也就是在非阻擋式更新之前。）$monitor を実行する。（$display は出会った時点で実行される。つまりノンブロッキング更新の前である。）
6. Advance simulation time.推進模擬時間。シミュレーション時刻を進める。

6.2 $display vs $monitor6.2 $display 與 $monitor6.2 $display と $monitor

initial begin
  a = 1;
  b = 0;
  a <= b;
  b <= a;
  $display("a=%b b=%b", a, b);
end
// display: a=1 b=0

initial begin
  a = 1;
  b = 0;
  a <= b;
  b <= a;
  $monitor("a=%b b=%b", a, b);
end
// monitor: a=0 b=1

$display prints immediately, before the non-blocking swap takes effect. $monitor prints at the end of the time step (and whenever an argument changes afterwards), so it sees the swapped values. $strobe behaves like a one-shot $monitor.$display 當下就印出，此時非阻擋式的交換尚未生效。$monitor 在時間步結束時才印（之後只要引數改變也會再印），所以看到的是交換後的值。$strobe 的行為就像只觸發一次的 $monitor。$display はその場でただちに出力するため、ノンブロッキングの交換はまだ反映されていない。$monitor は時間ステップの終わりに出力し（以降は引数が変化するたびに出力する）、交換後の値を見る。$strobe は一回限りの $monitor のように振る舞う。

initial begin
  x = 0;
  x <= 1;
  $display("D x=%b", x);
  $strobe ("S x=%b", x);
  #1 $display("D1 x=%b", x);
end

7. Activity Flow Control7. 活動流程控制7. 動作フロー制御

Constructs: conditional operator ?:, case / casex / casez, if ... else, loops (repeat, for, while, forever), disable, fork ... join.可用的建構：條件運算子 ?:、case / casex / casez、if ... else、迴圈（repeat, for, while, forever）、disable、fork ... join。使える構文：条件演算子 ?:、case / casex / casez、if ... else、ループ（repeat, for, while, forever）、disable、fork ... join。

7.1 Conditional operator7.1 條件運算子7.1 条件演算子

Besides continuous assignments, ?: can be used in a procedural statement to assign a register:除了連續賦值之外，?: 也可以寫在程序式敘述中，對暫存器賦值：連続代入のほか、?: は手続き文の中でレジスタへの代入にも使える。

always @ (posedge clock)
  q = s ? a : b;

7.2 case, casex, casez7.2 case、casex、casez7.2 case、casex、casez

• case requires a complete bit-wise match (including x and z), so the expression and items should have the same bit length.case 要求逐位元完全相符（包含 x 與 z），所以運算式與各個項目的位元寬度應該相同。case はビットごとの完全一致（x と z を含む）を要求するので、式と各項目のビット幅は揃えるべきである。
• An incomplete case list (no default, not all values covered) in combinational logic synthesizes to a latch — avoid it.在組合邏輯中，不完整的 case 列表（沒有 default、也沒有涵蓋所有值）合成後會產生閂鎖（latch） — 應該避免。組合せ論理において不完全な case リスト（default がなく、すべての値も網羅していない）は、合成するとラッチになる — 避けること。

always @ (a or b or c or d or select)
begin
  case (select)
    0: y = a;
    1: y = b;
    2: y = c;
    3: y = d;
    default: y = 1'bx;
  endcase
end

always @ (opcode or a or b or c)
casex (opcode)
  4'b1zzx : begin  // don't care bits 2:0
              out = a;
            end
  4'b01?? : begin  // bits 1:0 are don't care
              out = b;
            end
  4'b001? : begin  // bit 0 is don't care
              out = c;
            end
  default : begin
              out = 4'b0;
            end
endcase

7.3 if ... else7.3 if ... else7.3 if ... else

• True: numerical value 1. False: 0, x or z.真：數值為 1。假：0、x 或 z。真：数値が 1。偽：0、x、z。
• else pairs with the nearest if; use begin ... end in nesting to clarify.else 會配對到最近的 if；巢狀時請用 begin ... end 明確界定。else は最も近い if と対応する。入れ子にするときは begin ... end で範囲を明示すること。

always @ (posedge clk) begin
  // if reset is asserted
  if (reset == 1'b0) begin
    counter <= 4'b0000;
  // if counter is enabled and up count is asserted
  end else if (enable == 1'b1 && up_en == 1'b1) begin
    counter <= counter + 1'b1;
  // if counter is enabled and down count is asserted
  end else if (enable == 1'b1 && down_en == 1'b1) begin
    counter <= counter - 1'b1;
  // if counting is disabled
  end else begin
    counter <= counter;   // redundant code
  end
end

The last branch is redundant in a clocked block: a register holds its value anyway. (In a combinational block, the missing else would create a latch.) Note the priority: up-count wins if both up_en and down_en are asserted.在時脈同步的區塊中，最後一個分支是多餘的：暫存器本來就會保持原值。（但在組合區塊中，少了 else 反而會產生閂鎖。）另外注意優先權：若 up_en 與 down_en 同時有效，上數會贏。クロック同期ブロックでは最後の分岐は冗長である。レジスタはもともと値を保持するからである。（ただし組合せブロックでは else が欠けるとラッチが生じる。）優先順位にも注意する。up_en と down_en が同時に有効なら、アップカウントが勝つ。

7.4 Loops: repeat, for, while7.4 迴圈：repeat、for、while7.4 ループ：repeat、for、while

parameter memory_size = 1024;
...
word_address = 0;
repeat (memory_size)
  begin
    memory[word_address] = 0;
    word_address = word_address + 1;
  end

begin
  reg [7:0] temp;
  counter = 0;
  temp = a;
  while (temp)
    begin
      if (temp[0]) counter = counter + 1;
      // or: counter = counter + temp[0];
      temp = temp >> 1;
    end
end

reg [15:0] data;
integer k;

for (k = 4; k > 0; k = k - 1)
  begin
    data[k+10] = 0;
    data[k+2]  = 1;
  end

reg [3:0] k;

for (k = 0; k <= 15; k = k + 1)
  ...

7.5 Example: 4-bit carry look-ahead adder7.5 範例：4 位元超前進位加法器7.5 例：4 ビット桁上げ先見加算器

module Add_prop_gen (sum, c_out, a, b, c_in);  // behavioral model
  output [3:0] sum;
  output       c_out;
  input  [3:0] a, b;
  input        c_in;

  reg  [3:0] carrychain;
  wire [3:0] g = a & b;   // carry generate  (continuous assignment)
  wire [3:0] p = a ^ b;   // carry propagate (continuous assignment)

  always @ (a or b or c_in)               // event "or"
    begin : carry_generation              // named block
      integer i;
      #0 carrychain[0] = g[0] + (p[0] & c_in);   // #0 needed for simulation
      for (i = 1; i <= 3; i = i + 1)
        begin
          carrychain[i] = g[i] | (p[i] & carrychain[i-1]);
        end
    end

  wire [4:0] shiftedcarry = {carrychain, c_in};  // concatenation
  wire [3:0] sum   = p ^ shiftedcarry;           // summation (low 4 bits)
  wire       c_out = shiftedcarry[4];            // carry out, bit select
endmodule

7.6 forever and disable7.6 forever 與 disable7.6 forever と disable

initial
  begin : clock_loop
    clock = 0;
    forever
      #10 clock = ~clock;
  end

initial
  #100 disable clock_loop;

module find_first_one (a, trigger, i);
  input  [15:0] a;
  input         trigger;
  output [4:0]  i;
  reg    [4:0]  i;

  always @ trigger
    begin : search
      for (i = 0; i < 16; i = i + 1)
        if (a[i] == 1) disable search;
    end
endmodule

The slide writes a bare disable; — disable must name a block or task, so the loop is wrapped in the named block search. If no bit is set, i ends at 16 (which is why it is 5 bits wide).投影片上只寫了一個光禿禿的 disable; — disable 必須指名一個區塊或任務，所以這裡把迴圈包在具名區塊 search 內。若沒有任何位元為 1，i 最後會停在 16（這就是它要宣告成 5 位元的原因）。スライドには disable; とだけ書かれている — disable はブロックまたはタスクを名指ししなければならないので、ここではループを名前付きブロック search で囲んでいる。どのビットも 1 でなければ i は 16 で終わる（5 ビット幅にしてある理由がこれである）。

8. Parallel Activity Flow: fork ... join8. 平行活動流程：fork ... join8. 並列動作フロー：fork ... join

8.1 Parallel threads8.1 平行執行緒8.1 並列スレッド

• Creates parallel threads of activity; not supported by synthesis.會產生平行的活動執行緒；合成不支援。動作の並列スレッドを生成する。合成では対応していない。
• The join waits for completion of all threads.join 會等到所有執行緒都完成。join はすべてのスレッドの完了を待つ。
• No ordering among the threads; interaction between them can be ambiguous.執行緒之間沒有先後順序；它們彼此互動的結果可能是模稜兩可的。スレッド間に順序は定まっておらず、相互作用の結果は曖昧になりうる。

fork
  #50  a = 1;
  #100 a = 0;
  #150 a = 1;
  #200 a = 0;
join

begin
  #50 a = 1;
  #50 a = 0;
  #50 a = 1;
  #50 a = 0;
end

Both produce the same waveform: in fork all delays are measured from the fork start (absolute), in begin ... end they accumulate (relative).兩者產生相同的波形：在 fork 中所有延遲都是從 fork 起點算起（絕對時間），在 begin ... end 中則會累加（相對時間）。どちらも同じ波形になる。fork では遅延がすべて fork の開始時点から数えられ（絶対時間）、begin ... end では累積する（相対時間）。

8.2 Race condition vs no race condition8.2 有競爭條件與無競爭條件8.2 競合が起きる場合と起きない場合

A race: the target value is ambiguous because different assignments occur in the same time step in no defined order.競爭（race）：由於不同的賦值在同一個時間步內以未定義的順序發生，目標的值因此模稜兩可。競合（race）とは、異なる代入が同一の時間ステップ内で順序の定まらないまま起こるために、対象の値が曖昧になることをいう。

fork
  #150 a = b;
  #150 c = a;
join

fork
  a = #150 b;
  c = #150 a;
join

Left: both statements execute at t = 150; c gets either the old or the new a depending on thread order. Right: both RHS are sampled at t = 0 (intra-assignment delay), so c deterministically receives the original a — the pair behaves like a shift.左邊：兩個敘述都在 t = 150 執行；c 拿到舊的還是新的 a，取決於執行緒的順序。右邊：兩個 RHS 都在 t = 0 取樣（賦值內延遲），所以 c 必定拿到原本的 a — 這一對敘述的行為就像一次移位。左：どちらの文も t = 150 で実行される。c が古い a を得るか新しい a を得るかはスレッドの順序次第である。右：どちらの右辺も t = 0 で採取される（代入内遅延）ため、c は必ず元の a を受け取る — この二文はシフト動作のように振る舞う。

fork
  #10 x = 1;
  begin #5 y = 2; #10 y = 3; end
  #20 z = x + y;
join

9. Summary and Exam Checklist9. 總結與考前重點9. まとめと試験前チェックリスト