Concurrent Code

Advanced Digital Electronics

Lecture 4
 Outlines
❖ Concurrent versus Sequential
❖ Using Operators
❖ WHEN (Simple and Selected)
❖ GENERATE
❖ BLOCK
❖ Examples
Concurrent versus Sequential
We start by reviewing the fundamental differences between
combinational logic and sequential logic, and by contrasting
them with the differences between concurrent code and
sequential code.

In combinational logic the output of the circuit depends on the

current inputs, the system requires no memory and can be
implemented using conventional logic gates.

In sequential logic the output does depend on previous inputs,

storage elements are required, which are connected to the
combinational logic block through a feedback loop, such that
now the stored states (created by previous inputs) will also
affect the output of the circuit.
Concurrent versus Sequential Code
VHDL code is inherently concurrent (parallel). Only
statements placed inside a PROCESS, FUNCTION, or
PROCEDURE are sequential. Still, though within these blocks
the execution is sequential, the block, as a whole, is
concurrent with any other (external) statements. Concurrent
code is also called dataflow code.
let us consider a code with three concurrent statements
(stat1, stat2, stat3). Then any of the alternatives below will
render the same physical circuit:
stat1 stat3 stat1
Stat2 Ξ stat2 Ξ stat3
stat3 stat1 stat2
Concurrent versus Sequential Code
concurrent code, the statements that can only be used
outside PROCESSES, FUNCTIONS, or PROCEDURES are:
➢ Operators;
➢ The WHEN statement (WHEN/ELSE or WITH/SELECT/WHEN);
➢ The GENERATE statement;
➢ The BLOCK statement..
 Concurrent Code Using Operators
This is the most basic way of creating concurrent code.
Operators as shown in table below:
 Example: Multiplexer #1
Figure shows a 4:1 multiplexer. The output must be equal to the
input selected by the selection bits, s1-s0. Its implementation,
using only logical operators, can be done as follows:
Example: Multiplexer #1
Simulation results of the circuit, are shown in figure below:
WHEN (Simple and Selected)
WHEN is one of the fundamental concurrent statements (along
with operators and GENERATE). It appears in two forms: WHEN /
ELSE (simple WHEN) and WITH / SELECT / WHEN (selected
WHEN). Its syntax is shown below.
➢ WHEN / ELSE:
assignment WHEN condition ELSE
assignment WHEN condition ELSE
.....;
➢ WITH / SELECT / WHEN:
WITH identifier SELECT
assignment WHEN value,
assignment WHEN value,
.....;
Whenever WITH / SELECT / WHEN is used, all permutations
must be tested, so the keyword OTHERS is often useful.
WHEN (Simple and Selected)
Example:
------ with WHEN/ELSE -------------------------
outp <= "000" WHEN (inp='0' OR reset='1') ELSE
"001" WHEN ctl='1' ELSE
"010“ ;
---- With WITH/SELECT/WHEN --------------------
WITH control SELECT
output <= "000" WHEN reset,
"111" WHEN set,
UNAFFECTED WHEN OTHERS;
-----------------------------------------------
Example : Multiplexer #2
This example shows the implementation of the same
multiplexer of previous example , but with a slightly different
representation for the sel input. However, in it WHEN was
employed instead of logical operators. Two solutions are
presented: one using WHEN/ELSE (simple WHEN) and the
other with WITH/SELECT/WHEN (selected WHEN). The
experimental results are obviously similar to those obtained
in previous example.
Example : Multiplexer #2
Example : Multiplexer #2
Example : Multiplexer #2
In the solutions above, sel could have been declared as an
INTEGER, in which case the code would be the following:
Example : Multiplexer #2
Example : Tri-state Buffer
The 3-state buffer in figure must provide output=input when
ena=low, or output =‘‘ZZZZZZZZ’’(high impedance) otherwise.
Example : Encoder
The top-level diagram of an n-by-m encoder is shown in
figure. Two solutions are presented, one using WHEN / ELSE,
and the other with WITH / SELECT / WHEN.
Example : Encoder
Example : Encoder
GENERATE
GENERATE is another concurrent statement (along with
operators and WHEN). It is equivalent to the sequential
statement LOOP in the sense that it allows a section of code to
be repeated a number of times, thus creating several instances
of the same assignments. Its regular form is the FOR /
GENERATE construct, with the syntax shown below. Notice that
GENERATE must be labeled.
FOR / GENERATE:

label: FOR identifier IN range GENERATE

(concurrent assignments)
END GENERATE;
GENERATE
Another form is also available, which uses IF/GENERATE (Here
ELSE is not allowed). In the same way that IF/GENERATE can be
nested inside FOR/ GENERATE (syntax below), the opposite can
also be done.

IF / GENERATE nested inside FOR / GENERATE:

label1: FOR identifier IN range GENERATE

...
label2: IF condition GENERATE
(concurrent assignments)
END GENERATE;
...
END GENERATE;
GENERATE
Example:
SIGNAL x: BIT_VECTOR (7 DOWNTO 0);
SIGNAL y: BIT_VECTOR (15 DOWNTO 0);
SIGNAL z: BIT_VECTOR (7 DOWNTO 0);
...
G1: FOR i IN x'RANGE GENERATE
z(i) <= x(i) AND y(i+8);
END GENERATE;

One important remark about GENERATE is that the range

must be static. As an example, let us consider the code below
this kind of code is generally not synthesizable.

NotOK: FOR i IN 0 TO choice GENERATE

(concurrent statements)
END GENERATE;
BLOCK
There are two kinds of BLOCK statements: Simple and
Guarded.
Simple BLOCK
The BLOCK statement, in its simple form, represents only a way
of locally partitioning the code. It allows a set of concurrent
statements to be clustered into a BLOCK, with the purpose of
turning the overall code more readable and more manageable
(which might be helpful when dealing with long codes). Its
syntax is shown below.
label: BLOCK
[declarative part]
BEGIN
(concurrent statements)
END BLOCK label;
BLOCK: Simple BLOCK
Therefore, the overall aspect of a ‘‘blocked’’ code is the
following:
ARCHITECTURE example ...
BEGIN
...
block1: BLOCK
BEGIN
...
END BLOCK block1
...
block2: BLOCK
BEGIN
...
END BLOCK block2;
...
END example;
Example:
b1: BLOCK
SIGNAL a: STD_LOGIC;
BEGIN
a <= input_sig WHEN ena='1' ELSE 'Z';
END BLOCK b1;
BLOCK: Simple BLOCK
A BLOCK (simple or guarded) can be nested inside another
BLOCK. The corresponding syntax is shown below.
label1: BLOCK
[declarative part of top block]
BEGIN
[concurrent statements of top block]
label2: BLOCK
[declarative part nested block]
BEGIN
(concurrent statements of nested block)
END BLOCK label2;
[more concurrent statements of top block]
END BLOCK label1;
BLOCK: Guarded BLOCK
A guarded BLOCK is a special kind of BLOCK, which
includes an additional expression, called guard expression. A
guarded statement in a guarded BLOCK is executed only when
the guard expression is TRUE.
Guarded BLOCK:
label: BLOCK (guard expression)
[declarative part]
BEGIN
(concurrent guarded and unguarded statements)
END BLOCK label;
As the examples below illustrate, even though only concurrent
statements can be written within a BLOCK, with a guarded
BLOCK even sequential circuits can be constructed. This,
however, is not a usual design approach.
Example: DFF with a Guarded BLOCK
Here, a positive-edge sensitive D-type flip-flop, with
synchronous reset, is designed. clk'EVENT AND clk='1' is the
guard expression, while q <= GUARDED '0'WHEN rst='1' is a
guarded statement. Therefore, q<='0' will occur when the
guard expression is true and rst is ‘1’.
LIBRARY ieee;
USE ieee.std_logic_1164.all;
ENTITY dff IS
PORT ( d, clk, rst: IN STD_LOGIC;
q: OUT STD_LOGIC);
END dff;
ARCHITECTURE dff OF dff IS
BEGIN
b1: BLOCK (clk'EVENT AND clk='1')
BEGIN
q <= GUARDED '0' WHEN rst='1' ELSE d;
END BLOCK b1;
END dff;
Home work:
Construct a circuit capable of comparing two 8-bit vectors,
a and b. A selection pin (sel) should determine whether the
comparison is signed (sel = ‘1’) or unsigned (sel = ‘0’). The
circuit must have three outputs, x1, x2, and x3, corresponding
to a > b, a = b, and a < b, respectively
QUESTIONS?