Modeling Complex Behavior

(1)
 Outline

• Abstraction and the Process Statement

– Concurrent processes and CSAs

• Process event behavior and signals vs. variables

• Timing behavior of processes

• Attributes

• Putting it together  modeling state machines

(2)
 Raising the Level of Abstraction
add R1, R2, R3
R W
sub R3, R4, R5
move R7, R3
..
Data Output

Data input
Address
.
Memory Module Instruction Set Simulation

• Concurrent signal assignment statements can easily capture the

gate level behavior of digital systems
• Higher level digital components have more complex behaviors
– Input/output behavior not easily captured by concurrent
signal assignment statements
– Models utilize state information
– Incorporate data structures
• We need more powerful constructs

(3)
 Extending the Event Model

Description of a
Complex
Process Output signals
Input signals
Sig1 <= …..
Sig2 <= …...

• Combinational logic input/output semantics

– Events on inputs causes re-computation
– Re-computation may lead to events on outputs
• Computation of the value and time of output events
can be a complex process

(4)
 The Process Statement

library IEEE;
use IEEE.std_logic_1164.all;
entity mux4 is
port (In0, In1, In2, In3: in std_logic_vector (7 downto 0);
Sel: in std_logic_vector(1 downto 0);
Z : out std_logic_vector (7 downto 0));
end entity mux4;

Sensitivity List
architecture behavioral-3 of mux4 is

process (Sel, In0, In1, In2, In3) is

Use of variables rather than signals
variable Zout: std_logic;
begin
if (Sel = “00”) then Zout := In0;
Variable Assignment
elsif (Sel = “01”) then Zout := In1;
elsif (Sel = “10”) then Zout := In2;
else Zout:= In3;
end if;
Z <= Zout;
end process;

(5)
 The Process Construct

• Statements in a process are executed sequentially

• A process body is structured much like conventional C function

– Declaration and use of variables
– if-then, if-then-else, case, for and while constructs
– A process can contain signal assignment statements

• A process executes concurrently with other concurrent signal

assignment statements

• A process takes 0 seconds of simulated time to execute and

may schedule events in the future

• We can think of a process as a complex signal assignment

statement!

(6)
 Concurrent Processes: Full Adder

s1
In1 sum
Half Half
Adder Adder
In2 s2

c_in c_out
s3

port Internal signal

Model using processes

• Each of the components of the full adder can be

modeled using a process
• Processes execute concurrently
– In this sense they behave exactly like concurrent signal
assignment statements
• Processes communicate via signals
(7)
 Concurrent Processes: Full Adder

library IEEE; HA2: process(s1,c_in) is

use IEEE.std_logic_1164.all; begin
sum <= (s1 xor c_in) after delay;
entity full_adder is s2 <= (s1 and c_in) after delay;
port (In1, c_in, In2: in std_logic; end process HA2;
sum, c_out: out std_logic);
end entity full_adder; OR1: process (s2, s3) -- process
describing the two-input OR gate
architecture behavioral of full_adder is begin
signal s1, s2, s3: std_logic; c_out <= (s2 or s3) after delay;
constant delay:Time:= 5 ns; end process OR1;
begin
end architecture behavioral;
HA1: process (In1, In2) is
begin
s1 <= (In1 xor In2) after delay;
s3 <= (In1 and In2) after delay;
end process HA1;

(8)
 Concurrent Processes: Half Adder

library IEEE; carry_proc: process (a,b) is

use IEEE.std_logic_1164.all; begin
case a is
entity half_adder is when ‘0’ =>
port (a, b : in std_logic; carry <= a after 5 ns;
sum, carry : out std_logic); when ‘1’ =>
end entity half_adder; carry <= b after 5 ns;
when others =>
architecture behavior of half_adder is carry <= ‘X’ after 5 ns;
begin end case;
end process carry_proc;
sum_proc: process(a,b) is
begin end architecture behavior;
if (a = b) then
sum <= ‘0’ after 5 ns;
else
sum <= (a or b) after 5 ns;
end if;
end process;

(9)
 Processes + CSAs
library IEEE; MemRead MemWrite
use IEEE.std_logic_1164.all;
use IEEE.std_logic_arith.all;

entity memory is address

port (address, write_data: in std_logic_vector (7 downto 0); write_data
MemWrite, MemRead, clk, reset: in std_logic; read_data
read_data: out std_logic_vector (7 downto 0));
end entity memory;
clk reset
architecture behavioral of memory is
signal dmem0,dmem1,dmem2,dmem3: std_logic_vector (7 downto 0);
begin
mem_proc: process (clk) is
-- process body
end process mem_proc;
-- read operation CSA
end architecture behavioral;

(10)
 Process + CSAs: The Write Process

mem_proc: process (clk) is

begin
if (rising_edge(clk)) then -- wait until next clock edge
if reset = ‘1’ then -- initialize values on reset
dmem0 <= x”00”; -- memory locations are initialized to
dmem1 <= x”11”;-- some random values
dmem2 <= x”22”;
dmem3 <= x”33”;
elsif MemWrite = ‘1’ then -- if not reset then check for memory write
case address (1 downto 0) is
when “00” => dmem0 <= write_data;
when “01” => dmem1 <= write_data;
when “10” => dmem2 <= write_data;
when “11” => dmem3 <= write_data;
when others => dmem0 <= x“ff”;
end case;
end if;
end if;
end process mem_proc;

(11)
 Process + CSAs: The Read Statement

- memory read is implemented with a conditional signal assignment

read_data <= dmem0 when address (1 downto 0) = “00” and MemRead = ‘1’ else
dmem1 when address (1 downto 0) = “01” and MemRead = ‘1’ else
dmem2 when address (1 downto 0) = “10” and MemRead = ‘1’ else
dmem3 when address (1 downto 0) = “11” and MemRead = ‘1’ else
x”00”;

• A process can be viewed as single concurrent signal

assignment statement
– The external behavior is the same as a CSA
– Processes describe more complex event generation
behavior
• Processes execute concurrently in simulated time
with other CSAs

(12)
 Iteration
Example: A Simple Multiplier
architecture behavioral of mult32 is
constant module_delay: Time:= 10 ns;
begin
mult_process: process(multiplicand,multiplier) is
variable product_register : std_logic_vector (63 downto 0) := X”0000000000000000”;
variable multiplicand_register : std_logic_vector (31 downto 0):= X”00000000”;

begin
multiplicand_register := multiplicand;
product_register(63 downto 0) := X”00000000” & multiplier;
for index in 1 to 32 loop
if product_register(0) = ‘1’ then
product_register(63 downto 32) := product_register (63 downto 32) +
multiplicand_register(31 downto 0);
end if;
-- perform a right shift with zero fill
product_register (63 downto 0) := ‘0’ & product_register (63 downto 1);
end loop;
-- write result to output port Concatenation operator
product <= product_register after module_delay;

end process mult_process;

(13)
 Iteration

• for loop index

– Implicit declaration via “use”
• Scope is local to the loop
– Cannot be used elsewhere in model

• while loop
– Boolean expression for termination

while j < 32 loop

...
...
j := j+1;
end loop;

(14)
 Outline

• Abstraction and the Process Statement

• Process event behavior and signals vs. variables

• Timing behavior of processes

• Attributes

• Putting it together  modeling state machines

(15)
 Process Behavior
• All processes are executed once at start-up
• Thereafter dependencies between signal values and events on
these signals determine process initiation
• One can view processes as components with an
interface/function
• Note that signals behave differently from variables!
library IEEE; begin
use IEEE.std_logic_1164.all; L1: var_s1 := x and y;
L2: var_s2 := var_s1 xor z;
entity sig_var is L3: res1 <= var_s1 nand var_s2;
port (x, y, z: in std_logic; end process;
res1, res2: out std_logic);
end entity sig_var; proc2: process (x, y, z) -- Process 2
begin
architecture behavior of sig_var is L1: sig_s1 <= x and y;
signal sig_s1, sig_s2: std_logic; L2: sig_s2 <= sig_s1 xor z;
begin L3: res2 <= sig_s1 nand sig_s2;
proc1: process (x, y, z) is -- Process 1 end process;
variable var_s1, var_s2: std_logic;
end architecture behavior;
(16)
 Variables vs. Signals: Example

proc1: process (x, y, z) is -- Process 1 proc2: process (x, y, z) -- Process 2

variable var_s1, var_s2: std_logic; begin
begin L1: sig_s1 <= x and y;
L1: var_s1 := x and y; L2: sig_s2 <= sig_s1 xor z;
L2: var_s2 := var_s1 xor z; L3: res2 <= sig_s1 nand sig_s2;
L3: res1 <= var_s1 nand var_s2; end process;
end process;

signals
variables

• Distinction between the use of variables vs. signals

– Computing values vs. computing time-value pairs
– Remember event ordering and delta delays!
(17)
 Variables vs. Signals: Example

This transition is
determined by
process initiation

variables signals

• Writing processes
– Use signals to represent corresponding hardware entities
– Use variables when computing (future) values of signals

(18)
 Simulation and Signals
Execute Process

• Process is initiated
current signal future signal
• Compute new signal values using
values values
current signal values
s1 reference compute
s1 – Use the value of the signal
s2 Process Foo s2 at process initiation
– Ignore textual
s7
dependencies between
s7 signals

Update Process State

• Process state (signal values) are

updated
s1 s1
• Process now waits for an event
s2 Process Foo s2 on its sensitivity list
• When initiated, process execution
s7 s7 references these new signal
values

update

Ready to execute process

(19)
 Using Signals in a Process

s1 s3
In1

In2 s4
s2

• Entity signals are visible in a process

• Processes can encapsulate variable and signal
assignment statements
• What is the effect on the model behavior between
dataflow and process models?
• Actual waveforms will depend on how initialization is
handled/performed
(20)
 Using Signals in a Process

library IEEE;
library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.std_logic_1164.all;
entity combinational is
entity combinational is
port (In1, In2: in std_logic;
port (In1, In2: in std_logic;
z : out std_logic);
z : out std_logic);
end entity combinational;
end entity combinational;
signal s1, s2, s3, s4: std_logic:= ‘0’;
signal s1, s2, s3, s4: std_logic:= ‘0’;
begin
begin
sig_in_proc: process (In1, In2) is
s1 <= not In1;
begin
s2 <= not In2;
s1 <= not In1;
s3 <= not (s1 and In2);
s4 <= not (s2 and In1);
s2 <= not In2;
z <= not (s3 and s4); s3 <= not (s1 and In2);
Encapsulate in a
end architecture behavior; process
s4 <= not (s2 and In1);
z <= not (s3 and s4);
end process sig_in_proc;
end architecture behavior;

(21)
 Using Signals in a Process (cont.)
IN1 IN1

IN2 IN2

Z Z

S1 S1

S2 S2

S3 S3

S4 S4

10 20 30 40 50 60 70 10 20 30 40 50 60 70

Using concurrent signal assignment statements Using signal assignment statements within a process

(22)
 Outline

• Abstraction and the Process Statement

– Concurrent processes and CSAs

• Process event behavior and signals vs. variables

• Timing behavior of processes

• Attributes

• Putting it together  modeling state machines

(23)
 The Wait Statement

library IEEE;
use IEEE.std_logic_1164.all;
entity dff is
port (D, Clk : in std_logic;
Q, Qbar : out std_logic);
end entity dff; signifies a value change on signal clk
architecture behavioral of dff is
begin
output: process is
begin
wait until (Clk’event and Clk = ‘1’); -- wait for rising edge
Q <= D after 5 ns;
Qbar <= not D after 5 ns;
end process output;
end architecture behavioral;

• The wait statements can describe synchronous or

asynchronous timing operations

(24)
 The Wait Statement: Waveform
Generation
library IEEE; clock_process: process is
use IEEE.std_logic_1164.all; begin
entity two_phase is phi1 <= ‘1’, ‘0’ after 10 ns;
port(phi1, phi2, reset: out std_logic); phi2 <= ‘0’, ‘1’ after 12 ns, ‘0’ after
end entity two_phase; 18 ns;
architecture behavioral of two_phase is wait for 20 ns;
begin end process clock_process;
rproc: reset <= ‘1’, ‘0’ after 10 ns; end architecture behavioral;

reset
events specified
by the reset phi1
and clock
phi2
processes
10 20 30 40 50 60
Time (ns)

• Note the “perpetual” behavior of processes

(25)
Wait Statement: Asynchronous Inputs
library IEEE; use IEEE.std_logic_1164.all;
entity asynch_dff is
port (R, S, D, Clk: in std_logic;
Q, Qbar: out std_logic);
end entity asynch_dff;
architecture behavioral of asynch_dff is
begin
output: process (R, S, Clk) is execute on event on any signal
begin
if (R = ‘0’) then
Q <= ‘0’ after 5 ns; implied ordering provides
Qbar <= ‘1’ after 5 ns; asynchronous set
elsif S = ‘0’ then reset
Q <= ‘1’ after 5 ns;
Qbar <= ‘0’ after 5 ns;
elsif (rising_edge(Clk)) then
Q<= D after 5 ns;
Qbar <= (not D) after 5 ns;
end if;
end process output;
end architecture behavioral;

(26)
 The Wait Statement

• A process can have multiple wait statements

• A process cannot have both a wait statement and a sensitivity

list (it should have one or the other): why?

• wait statements provide explicit control over suspension and

resumption of processes
– Representation of both synchronous and asynchronous events in a
digital systems

(27)
 Outline

• Abstraction and the Process Statement

– Concurrent processes and CSAs

• Process event behavior and signals vs. variables

• Timing behavior of processes

• Attributes

• Putting it together  modeling state machines

(28)
 Attributes

• Data can be obtained about VHDL objects such as types, arrays

and signals.
object’ attribute

• Example: consider the implementation of a signal

value-time pair

driver

• What types of information about this signal are useful?

– Occurrence of an event
– Elapsed time since last event
– Previous value, i.e., prior to the last event

(29)
 Classes of Attributes

• Value attributes
– returns a constant value

• Function attributes
– invokes a function that returns a value

• Signal attributes
– creates a new signal

• Type Attributes
– Supports queries about the type of VHDL objects

• Range attributes
– returns a range

(30)
 Value Attributes
• Return a constant value
– type statetype is (state0, state1, state2 state3);
• state_type’left = state0
• state_type’right = state3

• Examples

Value attribute Value

type_name’left returns the left most value of type_name in its
defined range
type_name’right returns the right most value of type_name in its
defined range
type_name’high returns the highest value of type_name in its range
type_name’low returns the lowest value of type_name in its range
array_name’length returns the number of elements in the array
array_name

(31)
 Example

clk_process: process
begin
wait until (clk’event and clk = ‘1’);
if reset = ‘1’ then
state <= statetype’left;
else state <= next_state;
end if;
end process clk_process;

• The signal state is an enumerated type

– type statetype is (state0, state1, state3, state4);

• signal state:statetype:= statetype’left;

(32)
 Function Attributes

• Use of attributes invokes a function call which returns a value

– if (Clk’event and Clk = ‘1’)
• function call
• Examples: function signal attributes

Function attribute Function

signal_name’event Return a Boolean value signifying a change in
value on this signal
signal_name’active Return a Boolean value signifying an assignment
made to this signal. This assignment may not be a
new value.
signal_name’last_event Return the time since the last event on this signal
signal_name’last_active Return the time since the signal was last active
signal_name’last_value Return the previous value of this signal

(33)
 Function Attributes (cont.)

• Function array attributes

Function attribute Function

array_name’left returns the left bound of the index range
array_name’right returns the right bound of the index range

array_name’high returns the upper bound of the index range

array_name’low returns the lower bound of the index range

• type mem_array is array(0 to 7) of bit_vector(31 downto 0)

– mem_array’left = 0
– mem_array’right = 7
– mem_array’length = 8 (value kind attribute)

(34)
 Range Attributes

•Returns the index range of a constrained array

for i in value_array’range loop

...
my_var := value_array(i);
...
end loop;

•Makes it easy to write loops

(35)
 Signal Attributes

• Creates a new “implicit” signal

Signal attribute Implicit Signal

signal_name’delayed(T) Signal delayed by T units of time
signal_name’transaction Signal whose value toggles when
signal_name is active
signal_name’quiet(T) True when signal_name has been quiet
for T units of time
signal_name’stable(T) True when event has not occurred on
signal_name for T units of time

• Internal signals are useful modeling tools

(36)
 Signal Attributes: Example

architecture behavioral of attributes is

begin
outdelayed <= data'delayed(5 ns); These are real (in simulation) signals and
can be used elsewhere in the model
outtransaction <= data'transaction;
end attributes;

(37)
 Outline

• Abstraction and the Process Statement

– Concurrent processes and CSAs

• Process event behavior and signals vs. variables

• Timing behavior of processes

• Attributes

• Putting it together  modeling state machines

(38)
 State Machines

0/1
Combinational Outputs
Inputs logic
1/0 s0 s1 0/1

1/0
Next state
State

Clk

• Basic components
– Combinational component: output function and next state
function
– Sequential component
• Natural process-based implementation

(39)
 Example: State Machine

library IEEE;
use IEEE.std_logic_1164.all;
entity state_machine is
port(reset, clk, x : in std_logic;
z : out std_logic);
end entity state_machine;
architecture behavioral of state_machine is
type statetype is (state0, state1);
signal state, next_state : statetype := state0;
begin
comb_process: process (state, x) is
begin
--- process description here
end process comb_process;
clk_process: process is
begin
-- process description here
end process clk_process;
end architectural behavioral;

(40)
 Example: Output and Next State Functions

comb_process: process (state, x) is

begin
case state is -- depending upon the current state
when state0 => -- set output signals and next state
if x = ‘0’ then
next_state <= state1;
z <= ‘1’;
else next_state <= state0;
z <= ‘0’;
end if;
when state1 =>
if x = ‘1’ then
next_state <= state0;
z <= ‘0’;
else next_state <= state1;
z <= ‘1’;
end if;
end case;
end process comb_process;

•Combination of the next state and output functions

(41)
 Example: Clock Process

clk_process: process is
begin
wait until (clk’event and clk = ‘1’); -- wait until the
rising edge
if reset = ‘1’ then -- check for reset and initialize
state
state <= statetype’left;
else state <= next_state;
end if;
end process clk_process;
end behavioral;

• Use of asynchronous reset to initialize into a known state

(42)
 Summary

• Processes
– variables and sequential statements
– if-then, if-then-else, case, while, for
– concurrent processes
– sensitivity list

• The Wait statement

– wait until, wait for, wait on

• Attributes
• Modeling State machines
wait on ReceiveData’transaction
if ReceiveData’delayed = ReceiveData then
..

(43)