Behavioral Modeling

Introduction
• Signal assignment statement is the most basic form of behavioral modeling.
 Following is an example: a <= b;
 This statement is read as a gets the value of b.
 This statement is executed whenever signal b changes value.
 Signal b is in the sensitivity list of this statement.
 Whenever a signal in the sensitivity list of a signal assignment statement
changes value, the signal assignment statement is executed.
 If the result of the execution is a new value that is different from the current
value of the signal, then an event is scheduled for the target signal.
 If the result of the execution is the same value, then no event is scheduled
but a transaction is still generated.
 A transaction is always generated when a model is evaluated, but only
signal value changes cause events to be scheduled.
 Introduction
 The next example shows how to introduce a nonzero delay value for the
assignment: a <= b after 10 ns;
 This statement is read as a gets the value of b after 10 nanoseconds.
 Both of the preceding statements are concurrent signal assignment
statements.
 Both statements are sensitive to changes in the value of signal b.
 Whenever b changes value, these statements execute and new values are
assigned to signal a.
 Using concurrent signal assignment statement, simple AND gate can be
modeled as:
ENTITY and2 IS
PORT ( a, b : IN BIT; c : OUT BIT );
END and2;
ARCHITECTURE and2_behav OF and2 IS
BEGIN
c <= a AND b AFTER 5 ns;
END and2_behav;
 AND Gate Design
 The AND gate has two inputs a, b and one output c, as shown.
 Value of signal c may be assigned a new value whenever either a or b changes
value.
 With an AND gate, if a is a ‘0’ and b changes from a ‘1’ to a ‘0’, output c does
not change.
 If the output does change value, then a transaction occurs which causes an
event to be scheduled on signal c; otherwise, a transaction occurs on signal c.
 The entity design unit describes the ports of the and2 gate.
 The architecture and2_behav contains one concurrent signal assignment
statement.
 Value of the expression a and b is calculated first, and the resulting value from
the calculation is scheduled on output c, 5 nanoseconds from the time the
calculation is completed.
 Mux Design
 Next example shows signal assignment statements and demonstrates concept of concurrency.
 This is the behavioral model for the 4 input mux:
ENTITY mux4 IS
PORT ( i0, i1, i2, i3, a, b : IN std_logic;
i0, i1, i2, i3, a, q : OUT std_logic);
END mux4;
ARCHITECTURE mux4 OF mux4 IS
SIGNAL sel: INTEGER;
BEGIN
WITH sel SELECT
q <= i0 AFTER 10 ns WHEN 0,
q <= i1 AFTER 10 ns WHEN 1,
q <= i2 AFTER 10 ns WHEN 2,
q <= i3 AFTER 10 ns WHEN 3,
q <= ‘X’ AFTER 10 ns WHEN OTHERS;
sel <= 0 WHEN a = ‘0’ AND b = ‘0’ ELSE
1 WHEN a = ‘1’ AND b = ‘0’ ELSE
2 WHEN a = ‘0’ AND b = ‘1’ ELSE
3 WHEN a = ‘1’ AND b = ‘1’ ELSE
4;
END mux4;
 Transport Versus Inertial Delay

 there are two types of delay that can be used for modeling behaviors.
 Inertial delay is the most commonly used, while transport delay is used
where a wire delay model is required.
 Inertia Delay
 Inertial delay is the default in VHDL.
 If no delay type is specified, inertial delay is used.
 Inertial delay is the default because it behaves similarly to the actual device.
 Transport Delay
 Transport delay is not the default in VHDL and must be specified.
 It represents a wire delay in which any pulse, no matter how small, is propagated
to the output signal delayed by the delay value specified.
 Transport delay is especially useful for modeling delay line devices, wire delays on a
PC board, and path delays on an ASIC.
 Inertial Delay Model

 Inertia delay of the buffer is 20 ns

 When a pulse signal of 10ns is applied, the pulse is swallowed
 This is because the pulse signal duration is not long enough to overcome
the inertia of the buffer
 Inertia Delay Model

 The following model shows how to write an inertial delay model.

 It is the same as any other model we have been looking at.
 The default delay type is inertial; therefore, it is not necessary to specify the
delay type to be inertial:

LIBRARY IEEE;
USE IEEE.std_logic_1164.ALL;
ENTITY buf IS
PORT ( a : IN std_logic;
b : OUT std_logic);
END buf;
ARCHITECTURE buf OF buf IS
BEGIN
b <= a AFTER 20 ns;
END buf;
 Transport Delay Model

 Transport delay of the buffer is 20 ns

 When a pulse signal of 10ns duration is applied, the same pulse is seen at the output
 Because delay of the buffer is 20 ns, pulse signal is seen in the output 20 ns after.
 No matter how small the pulse is, it is seen in the output after the transport delay
specified.
 Transport Delay

 Following is an example of a transport delay model.

 It is similar to inertial delay model except for the keyword TRANSPORT in
the signal assignment statement to signal b.
 Hence this keyword exists, the delay type used in the statement is the transport
delay mechanism:

LIBRARY IEEE;
USE IEEE.std_logic_1164.ALL;
ENTITY delay_line IS
PORT ( a : IN std_logic;
b : OUT std_logic);
END delay_line;
ARCHITECTURE delay_line OF delay_line IS
BEGIN
b <= TRANSPORT a AFTER 20 ns;
END delay_line;
 Simulation Deltas
 Simulation deltas are used to order some types of events during a simulation.
 Specifically, zero delay events must be ordered to produce consistent results.
 If zero delay events are not properly ordered, results can be disparate between
different simulation runs.
 An example of this is shown using the following circuit.
 This circuit could be part of a clocking scheme in a complex device being modeled.
 It probably would not be the entire circuit, but only a part of the circuit used to
generate the clock to the D flip-flop.
 The circuit consists of an inverter, a NAND gate, and an AND gate driving the
clock input of a flip-flop component.
 The NAND gate and AND gate are used to gate the clock input to the flip-flop.
 Let’s examine the circuit operation, using a delta delay mechanism and
another mechanism.
 Simulation Deltas
 To use delta delay, all of the circuit components must have zero delay specified.
 The delay for all three gates is specified as zero.
 Let’s examine the non delta delay mechanism first.
 When a falling edge occurs on signal A, the output of the inverter changes in 0 time.
 Let’s assume that such an event occurs at time 10 nanoseconds.
 The output of the inverter, signal B, changes to reflect the new input value.
 When signal B changes, both the AND gate and the NAND gate are reevaluated.
 For this example, the clock input is assumed to be a constant value ‘1’.
 If the NAND gate is evaluated first, its new value is ‘0’.
 When the AND gate evaluates, signal B is a ‘0’, and signal C is a ‘1’; therefore, the AND gate
predicts a new value of ‘0’.
 But what happens if the AND gate evaluates first?
 The AND gate sees a ‘1’ value on signal B, and a ‘1’ value on signal C before the NAND gate
has a chance to reevaluate.
 The AND gate predicts a new value of ‘1’.
 Simulation Deltas
• The NAND gate reevaluates and calculates its new value as ‘0’.
• The change on the output of the NAND gate causes the AND gate to reevaluate again.
• The AND gate now sees the value of B, a ‘1’ value, and the new value of signal C, a ‘0’ value.
• The AND gate now predicts a ‘0’ on its output.
• Both circuits arrive at the same value for signal D.
• However, when the AND gate is evaluated first, a rising edge, one delta delay wide, occurs on
signal D.
• This rising edge can clock the flip-flop, depending on how the flip-flop is modeled.
• The point of this discussion is that without a delta synchronization mechanism, the results of
the simulation can depend on how the simulator data structures are built.
• For instance, compiling the circuit the first time might make the AND gate evaluate first,
while compiling again might make the NAND gate evaluate first; simulation deltas prevent
this behavior from occurring.
• Evaluation of the circuit does not depend on order of evaluation of NAND gate or AND gate.
• The sequence occurs irrespective of the evaluation order of the AND or NAND gate.
• During the first delta time point of time 10 nanoseconds, signal A receives the value ‘0’.
• This causes the inverter to reevaluate with the new value.
 Simulation Deltas
• The inverter calculates the new value for signal B, which is the value ‘1’.
• This value is not propagated immediately, but is scheduled for the next delta time point.
• The simulator then begins execution of delta time point 2.
• Signal B is updated to a ‘1’ value, and the AND gate and NAND gate are reevaluated.
• Both the AND gate and NAND gate now schedule their new values for the next delta time
point.
• When delta 3 occurs, signal D receives a ‘1’ value, and signal C receives a ‘0’ value.
• Because signal C also drives the AND gate, the AND gate is reevaluated and schedules its
new output for delta time point 4.
• To summarize, simulation deltas are an infinitesimal amount of time used as a
synchronization mechanism when 0 delay events are present.
• Delta delay is used whenever 0 delay is specified, as shown in the following:
a <= b AFTER 0 ns;
• Another case for using delta delay is when no delay is specified. For example: a <= b;
• In both cases, whenever signal b changes value from an event, signal a has a delta-delayed
signal assignment to it.
• An equivalent VHDL model of the circuit shown in Figure 2-6, except for the flip-flop, is
shown in the following
 Simulation Deltas
ENTITY reg IS
PORT( a, clock : in bit
d : out bit);
END reg;
ARCHITECTURE test OF reg IS
SIGNAL b, c : bit;
BEGIN
b <= NOT(a); -- notice no delay
c <= NOT( clock AND b);
d <= c AND b;
END test;
 Derivers
• A VHDL driver is one contributor to the overall value of a signal.
• A multiply driven signal has many drivers.
• Multiply driven signals are very useful for modeling a data bus, a
bidirectional bus, and so on.
• Correctly modeling these kinds of circuits requires the concept of signal
drivers.
• Values of all of the drivers are resolved together to create a single value for
the signal.
• The method of resolving all of the contributors into a single value is
through a resolution function.
• A resolution function is a designer written function that is called whenever
a driver of a signal changes value.
 Driver Creation

 A concurrent signal assignment inside of an architecture produces one driver for

each signal assignment.
 Therefore, multiple signal assignments produce multiple drivers for a signal.
 Consider the following architecture:

ARCHITECTURE test OF test IS

BEGIN
a <= b AFTER 10 ns;
a <= c AFTER 10 ns;
END test;

 Signal a is being driven from two sources, b and c.

 Each concurrent signal assignment statement creates a driver for signal a.
 First statement creates driver that contains the value of signal b delayed by 10ns.
 Second statement creates a driver that contains value of signal c delayed by 10ns.
 How these two drivers are resolved is left to the designer.
 Synthesizing the preceding example would short c and b together
 Bad Multiple Derivers

LIBRARY IEEE;
USE WORK.std_logic_1164.ALL;
ENTITY mux IS
PORT (i0, i1, i2, i3, a, b: IN std_logic;
q : OUT std_logic);
END mux;
ARCHITECTURE bad OF mux IS
BEGIN
q <= i0 WHEN a = ‘0’ AND b = ‘0’ ELSE ‘0’;
q <= i1 WHEN a = ‘1’ AND b = ‘0’ ELSE ‘0’;
q <= i2 WHEN a = ‘0’ AND b = ‘1’ ELSE ‘0’;
q <= i3 WHEN a = ‘1’ AND b = ‘1’ ELSE ‘0’;
END BAD;
 Better Multiple Derivers

LIBRARY IEEE;
USE WORK.std_logic_1164.ALL;
ENTITY mux IS
PORT (i0, i1, i2, i3, a, b: IN std_logic;
q : OUT std_logic);
END mux;
ARCHITECTURE better OF mux IS
BEGIN
q <= i0 WHEN a = ‘0’ AND b = ‘0’ ELSE
i1 WHEN a = ‘1’ AND b = ‘0’ ELSE
i2 WHEN a = ‘0’ AND b = ‘1’ ELSE
i3 WHEN a = ‘1’ AND b = ‘1’ ELSE
‘X’; --- unknown
END better;
 Generics

 Generics are used to pass information to an instance of an entity.

 Information passed to an entity can be
 delay times for rising and falling delays.
 user-defined data types [load capacitance, resistance,etc].
 data path widths, signal widths, and so on.
 All of the data passed to an entity is instance-specific information.
 A designer can pass different values to different instances in the design.
 The data passed to an instance is static data.
 After the model has been elaborated, the data does not change during
simulation.
 Generics cannot be assigned information as part of a simulation run.
 Information contained in generics passed into a component instance or
a block can be used to alter the simulation results.
 Simulation results cannot modify the generics.
 Generics

 Example of an entity for an AND gate that has three generics

associated with it:
ENTITY and2 IS
GENERIC(rise, fall : TIME; load : INTEGER);
PORT( a, b : IN BIT; c : OUT BIT);
END AND2;
 This entity allows the designer to pass in a value for the rise and fall
delays, as well as the loading that the device has on its output.
 With this information, the model can correctly model the AND gate
in the design.
 Generics

 Following is the architecture for the AND gate:

ARCHITECTURE load_dependent OF and2 IS
SIGNAL internal : BIT;
BEGIN
internal <= a AND b;
c <= internal AFTER (rise + (load * 2 ns)) WHEN internal = ‘1’
ELSE internal AFTER (fall + (load * 3 ns));
END load_dependent;
 Generics
LIBRARY IEEE;
USE IEEE.std_logic_1164.ALL;
ENTITY test IS
GENERIC(rise, fall : TIME; load : INTEGER);
PORT ( ina, inb, inc, ind : IN std_logic;
out1, out2 : OUT std_logic);
END test;
ARCHITECTURE test_arch OF test IS
COMPONENT AND2
GENERIC(rise, fall : TIME; load : INTEGER);
PORT ( a, b : IN std_logic;
c : OUT std_logic);
END COMPONENT;
BEGIN
U1: AND2 GENERIC MAP(10 ns, 12 ns, 3 )
PORT MAP (ina, inb, out1 );
U2: AND2 GENERIC MAP(9 ns, 11 ns, 5 )
PORT MAP (inc, ind, out2 );
END test_arch;
 Generics
• LIBRARY IEEE;
USE IEEE.std_logic_1164.ALL;
ENTITY test IS
GENERIC(rise, fall : TIME; load : INTEGER);
PORT ( ina, inb, inc, ind : IN std_logic;
out1, out2 : OUT std_logic);
END test;
ARCHITECTURE test_arch OF test IS
COMPONENT and2
GENERIC(rise, fall : TIME := 10 NS; load : INTEGER := 0);
PORT ( a, b : IN std_logic;
c : OUT std_logic);
END COMPONENT;
BEGIN
U1: and2 GENERIC MAP(10 ns, 12 ns, 3 )
PORT MAP (ina, inb, out1 );
U2: and2 PORT MAP (inc, ind, out2 );
END test_arch
 Block Statements
• Blocks are partitioning mechanism.
• Allow the designer to logically group areas of the model.
• The statement area in an architecture can be broken into a number of
separate logical areas.
• If you are designing a CPU, one block might be an ALU, another a register
bank, and another a shifter.
• Each block represents a self-contained area of the model.
• Each block can declare local signals, types, constants, and so on.
• object that can be declared in the architecture declaration section can be
declared in the block declaration section.
 Block Statements
LIBRARY IEEE;
USE IEEE.std_logic_1164.ALL;
PACKAGE bit32 IS
TYPE tw32 IS ARRAY(31 DOWNTO 0) OF std_logic;
END bit32;
LIBRARY IEEE;
USE IEEE.std_logic_1164.ALL;
USE WORK.bit32.ALL;
ENTITY cpu IS
PORT( clk, interrupt : IN std_logic;
addr : OUT tw32; data : INOUT tw32 );
END cpu;
ARCHITECTURE cpu_blk OF cpu IS
SIGNAL ibus, dbus : tw32;
BEGIN
ALU : BLOCK
SIGNAL qbus : tw32;
BEGIN -- alu behavior statements
END BLOCK ALU;
REG8 : BLOCK
SIGNAL zbus : tw32;
BEGIN
REG1: BLOCK
SIGNAL qbus : tw32;
 Block Statements
BEGIN-- reg1 behavioral statements
END BLOCK REG1; -- more REG8 statements
END BLOCK REG8;
END cpu_blk;
BLK1 : BLOCK
SIGNAL qbus : tw32;
BEGIN
BLK2 : BLOCK
SIGNAL qbus : tw32;
BEGIN -- blk2 statements
END BLOCK BLK2; -- blk1 statements
END BLOCK BLK1;
 Block Statements
PACKAGE math IS
TYPE tw32 IS ARRAY(31 DOWNTO 0) OF std_logic;
FUNCTION tw_add(a, b : tw32) RETURN tw32;
FUNCTION tw_sub(a, b : tw32) RETURN tw32;
END math;
USE WORK.math.ALL;
LIBRARY IEEE;
USE IEEE.std_logic_1164.ALL;
ENTITY cpu IS
PORT( clk, interrupt : IN std_logic;
addr : OUT tw32; cont : IN INTEGER;
data : INOUT tw32 );
END cpu;
ARCHITECTURE cpu_blk OF cpu IS
SIGNAL ibus, dbus : tw32;
BEGIN
 Block Statements
ALU : BLOCK
PORT( abus, bbus : IN tw32;
d_out : OUT tw32;
ctbus : IN INTEGER);
PORT MAP ( abus => ibus, bbus => dbus, d_out => data,
PORT MAP ( ctbus => cont);
SIGNAL qbus : tw32;
BEGIN
d_out <= tw_add(abus, bbus) WHEN ctbus = 0 ELSE
d_out <= tw_sub(abus, bbus) WHEN ctbus = 1 ELSE
d_out <= abus;
END BLOCK ALU;
END cpu_blk;
 Guarded Blocks
 Block statements have another interesting behavior known as
guarded blocks.
 A guarded block contains a guard expression that can enable and
disable drivers inside the block.
 The guard expression is a Boolean expression:
 when true, drivers contained in the block are enabled, and when
false, the drivers are disabled.
 Let’s look at the following example to show some more of the
details:
 Guarded Blocks
LIBRARY IEEE;
USE IEEE.std_logic_1164.ALL;

ENTITY latch IS
PORT( d, clk : IN std_logic;
q, qb : OUT std_logic);
END latch;

ARCHITECTURE latch_guard OF latch IS

BEGIN
G1 : BLOCK( clk = ‘1’)
BEGIN
q <= GUARDED d AFTER 5 ns;
qb <= GUARDED NOT(d) AFTER 7 ns;
END BLOCK G1;
END latch_guard;