Section 8.9  HDL Description of Binary Multiplier    403
in the block diagram of  Fig.   8.14   (a). The machine will be parameterized for a five‐bit data-
path to enable a comparison between its simulation data and the result of the multiplication 
with the numerical example listed in  Table   8.5   . The same model can be used for a datapath 
having a different size merely by changing the value of the parameters. The second part of 
the description declares all registers in the controller and the datapath, as well as the one‐
hot encoding of the states. The third part specifies implicit combinational logic (continuous 
assignment statements) for the concatenated register  CAQ the  Zero  status signal, and the 
Ready  output signal. The continuous assignments for  Zero  and  Ready  are accomplished by 
assigning a Boolean expression to their  wire  declarations. The next section describes the 
control unit, using a single edge‐sensitive cyclic behavior to describe the state transitions, 
and a level‐sensitive cyclic behavior to describe the combinational logic for the next state 
and the outputs. Again, note that default assignments are made to  next_state,   Load_regs,  
Decr_P,   Add_regs and  Shift_regs . The subsequent logic of the case statement assigns their 
value by exception. The state transitions and the output logic are written directly from the 
ASMD chart of  Fig.  8.15   (b). 
The datapath unit describes the register operations within a separate edge‐sensitive 
cyclic behavior.  
3
(For clarity, separate cyclic behaviors are used; we do not mix the 
description of the datapath with the description of the controller.) Each control input 
is decoded and is used to specify the associated operations. The addition and subtraction 
operations will be implemented in hardware by combinational logic. Signal  Load_regs  
causes the counter and the other registers to be loaded with their initial values, etc. 
Because the controller and datapath have been partitioned into separate units, the con-
trol signals completely specify the behavior of the datapath; explicit information about 
the state of the controller is not needed and is not made available to the datapath unit.  
The next‐state logic of the controller includes a default case item to direct a synthesis 
tool to map any of the unused codes to  S_idle . The default case item and the default 
assignments preceding the case statement ensure that the machine will recover if it 
somehow enters an unused state. They also prevent unintentional synthesis of latches. 
(Remember, a synthesis tool will synthesize latches when what was intended to be com-
binational logic in fact fails to completely specify the input–output function of the logic.)    
3   The width of the datapath here is  dp‐width . 
HDL Example 8.5 (Sequential Multiplier)  
module  Sequential_Binary_Multiplier (Product, Ready, Multiplicand, Multiplier, Start, 
clock, reset_b);
// Default configuration: five-bit datapath
parameter  
dp_width = 5; 
// Set to width of datapath
output   
[2*dp_width -1: 0] 
Product;
output  
Ready;
input  
[dp_width -1: 0] 
Multiplicand, Multiplier;
input   
Start, clock, reset_b;
How to change pdf to powerpoint - C# Create PDF from PowerPoint Library to convert pptx, ppt to PDF in C#.net, ASP.NET MVC, WinForms, WPF
Online C# Tutorial for Creating PDF from Microsoft PowerPoint Presentation
convert pdf slides to powerpoint; pdf page to powerpoint
How to change pdf to powerpoint - VB.NET Create PDF from PowerPoint Library to convert pptx, ppt to PDF in vb.net, ASP.NET MVC, WinForms, WPF
VB.NET Tutorial for Export PDF file from Microsoft Office PowerPoint
change pdf to ppt; convert pdf to editable ppt
404    Chapter 8  Design at the Register Transfer Level
parameter   
BC_size = 3; // Size of bit counter
parameter  
S_idle = 3'b001, // one-hot code
S_add = 3'b010,
S_shift = 3'b100;
reg  
[2: 0] 
state, next_state;
reg  
[dp_width -1: 0] 
A, B, Q; 
// Sized for datapath
reg   
C;
reg  
[BC_size -1: 0] 
P;
reg  
Load_regs, Decr_P, Add_regs, Shift_regs;
// Miscellaneous combinational logic
assign  
Product = {A, Q};
wire  
Zero = (P == 0); 
// counter is zero
// Zero = ~|P; 
// alternative
wire  
Ready = (state == S_idle); // controller status
// control unit
always   @  ( posedge  clock,  negedge  reset_b)
if  (~reset_b) state <= S_idle;  else  state <= next_state;
always   @  (state, Start, Q[0], Zero)  begin 
next_state = S_idle;
Load_regs = 0;
Decr_P = 0;
Add_regs = 0;
Shift_regs = 0;
case  (state)
S_idle: 
begin   if  (Start) next_state = S_add; Load_regs = 1;  end 
S_add: 
begin  next_state = S_shift; Decr_P = 1;  if ( Q[0]) Add_regs = 1;  end 
S_shift: 
begin  Shift_regs = 1;  if  (Zero) next_state = S_idle;
else  next_state = S_add;  end 
default : 
next_state = S_idle;
endcase 
end 
// datapath unit
always @  ( posedge  clock)  begin 
if  (Load_regs)  begin 
P <= dp_width;
A <= 0;
C <= 0;
B <= Multiplicand;
Q <= Multiplier;
end 
if  (Add_regs) {C, A} <= A + B;
Online Convert PowerPoint to PDF file. Best free online export
Online Powerpoint to PDF Converter. Download Free Trial. Then just wait until the conversion from Powerpoint to PDF is complete and download the file.
add pdf to powerpoint presentation; convert pdf pages into powerpoint slides
RasterEdge XDoc.PowerPoint for .NET - SDK for PowerPoint Document
Able to view and edit PowerPoint rapidly. Convert. Convert PowerPoint to PDF. Convert PowerPoint to HTML5. Convert PowerPoint to Tiff. Convert PowerPoint to Jpeg
convert pdf to ppt online without email; add pdf to powerpoint
Section 8.9  HDL Description of Binary Multiplier    405
Testing the Multiplier 
HDL Example 8.6 shows a test bench for testing the multiplier. The inputs and outputs 
are the same as those shown in the block diagram of  Fig.   8.14   (a). It is naive to conclude 
that an HDL description of a system is correct on the basis of the output it generates 
under the application of a few input signals. A more strategic approach to testing and 
verification exploits the partition of the design into its datapath and control unit. This 
partition supports separate verification of the controller and the datapath. A separate 
test bench can be developed to verify that the datapath executes each operation and 
generates status signals correctly. After the datapath unit is verified, the next step is to 
verify that each control signal is formed correctly by the control unit. A separate test 
bench can verify that the control unit exhibits the complete functionality specified by 
the ASMD chart (i.e., that it makes the correct state transitions and asserts its outputs 
in response to the external inputs and the status signals). 
A verified control unit and a verified datapath unit together do not guarantee that 
the system will operate correctly. The final step in the design process is to integrate 
the verified models within a parent module and verify the functionality of the overall 
machine. The interface between the controller and the datapath must be examined in 
order to verify that the ports are connected correctly. For example, a mismatch in the 
listed order of signals may not be detected by the compiler. After the datapath unit 
and the control unit have been verified, a third test bench should verify the specified 
functionality of the complete system. In practice, this requires writing a comprehensive 
test plan identifying that functionality. For example, the test plan would identify the 
need to verify that the sequential multiplier asserts the signal  Ready  in state  S_idle 
The exercise to write a test plan is not academic: The quality and scope of the test plan 
determine the worth of the verification effort. The test plan guides the development 
of the test bench and increases the likelihood that the final design will match its 
specification. 
Testing and verifying an HDL model usually requires access to more information 
than the inputs and outputs of the machine. Knowledge of the state of the control unit, 
the control signals, the status signals, and the internal registers of the datapath might 
all be necessary for debugging. Fortunately, Verilog provides a mechanism to hierarchi-
cally de‐reference identifiers so that any variable at any level of the design hierarchy 
can be visible to the test bench. Procedural statements can display the information 
required to support efforts to debug the machine. Simulators use this mechanism to 
display waveforms of any variable in the design hierarchy. To use the mechanism, we 
reference the variable by its hierarchical path name. For example, the register  P  within 
if  (Shift_regs) {C, A, Q} <= {C, A, Q} >> 1;
if  (Decr_P) P <= P -1;
end 
endmodule    
C# WinForms Viewer: Load, View, Convert, Annotate and Edit
to PDF; Convert PowerPoint to PDF; Convert Image to PDF; Convert Jpeg to PDF; Merge PDF Files; Split PDF Document; Remove Password from PDF; Change PDF Permission
image from pdf to ppt; how to convert pdf into powerpoint slides
How to C#: Overview of Using XDoc.PowerPoint
How to C#: Overview of Using XDoc.PowerPoint. Overview for How to Use XDoc.PowerPoint in C# .NET Programming Project. PowerPoint Conversion.
how to add pdf to powerpoint presentation; conversion of pdf to ppt online
406    Chapter 8  Design at the Register Transfer Level
the datapath unit is not an output port of the multiplier, but it can be referenced as 
M0.P . The hierarchical path name consists of the sequence of module identifiers or 
block names, separated by periods and specifying the location of the variable in the 
design hierarchy. We also note that simulators commonly have a graphical user interface 
that displays all levels of the hierarchy of a design. 
The first test bench in HDL Example 8.6 uses the system task  $strobe  to display the 
result of the computations. This task is similar to the  $display  and  $monitor  tasks 
explained in Section 4.12. The $strobe system task provides a synchronization mecha-
nism to ensure that data are displayed only after all assignments in a given time step are 
executed. This is very useful in synchronous sequential circuits, where the time step 
begins at a clock edge and multiple assignments may occur at the same time step of 
simulation. When the system is synchronized to the positive edge of the clock, using 
$strobe  after the always  @   (  posedge   clock)  statement ensures that the display shows 
values of the signal after the clock pulse. 
The test bench module  t_Sequential_Binary_Multiplier  in HDL Example 8.6 instan-
tiates the module  Sequential Binary_Multiplier  of HDL Example 8.5. Both modules 
must be included as source files when simulating the multiplier with a Verilog HDL 
simulator. The result of this simulation displays a simulation log with numbers identi-
cal to the ones in  Table   8.5   . The code includes a second test bench to exhaustively 
multiply five‐bit values of the multiplicand and the multiplier. Waveforms for a sample 
of simulation results are shown in  Fig.   8.19   . The numerical values of  Multiplicand,  
Multiplier and  Product  are displayed in decimal and hexadecimal formats. Insight can 
be gained by studying the displayed waveforms of the control state, the control signals, 
the status signals, and the register operations. Enhancements to the multiplier and its 
test bench are considered in the problems at the end of this chapter. In this example, 
19
10
* 23
10
= 437
10
,    and    17
H
+ 0b
H
=02
H
with C = 1. Note the need for the carry bit.      
HDL Example 8.6  
// Test bench for the binary multiplier
module  t_Sequential_Binary_Multiplier;
parameter  
dp_width = 5; 
// Set to width of datapath
wire   
[2*dp_width -1: 0] Product; 
// Output from multiplier
wire  
Ready;
reg   
[dp_width -1: 0] 
Multiplicand, Multiplier; // Inputs to multiplier
reg   
Start, clock, reset_b;
// Instantiate multiplier
Sequential_Binary_Multiplier M0 (Product, Ready, Multiplicand, Multiplier, Start, clock, 
reset_b);
// Generate stimulus waveforms
initial  #200  $finish ;
initial 
begin 
Start = 0;
C# HTML5 Viewer: Load, View, Convert, Annotate and Edit PowerPoint
Such as load and view PowerPoint without Microsoft Office software installed, convert PowerPoint to PDF file, Tiff image and HTML file, as well as add
changing pdf to powerpoint file; adding pdf to powerpoint slide
VB.NET PowerPoint: Read, Edit and Process PPTX File
create image on desired PowerPoint slide, merge/split PowerPoint file, change the order of How to convert PowerPoint to PDF, render PowerPoint to SVG
how to convert pdf to powerpoint; convert pdf file into ppt
Section 8.9  HDL Description of Binary Multiplier    407
 FIGURE 8.19  
Simulation waveforms for one‐hot state controller       
clock
Name
reset_b
Start
state[2: 0]
Load_regs
Decr_P
Add_regs
Shift_regs
P[2: 0]
Zero
B[4: 0]
A[4: 0]
Q[4: 0]
C
Multiplicand[4: 0]
Multiplicand[4: 0]
Multiplier[4: 0]
Multiplier[4: 0]
Product[9: 0]
Product[9: 0]
Ready
4
1
2
4
2
4
2
4
2
4
2
4
1
2
0
5
4
3
2
1
0
5
16
0d
02
13
19
0c
16
0b
15
13
00
17
0b
02
11
08
04
1b
0d
00
17
18
16
17
23
24
13
19
18
22
1a2 013
2j3 179 059
22c
11b
08b 36b 1b5 5 013
19
437
875
139
278
556
89
377
418
19
755
65885
65925
65965
66005
VB.NET PDF Password Library: add, remove, edit PDF file password
Add password to PDF. Change PDF original password. Remove password from PDF. Set PDF security level. VB: Change and Update PDF Document Password.
convert pdf file to powerpoint online; export pdf to powerpoint
C# powerpoint - Convert PowerPoint to PDF in C#.NET
C# PowerPoint - Convert PowerPoint to PDF in C#.NET. Online C# Tutorial for Converting PowerPoint to PDF (.pdf) Document. PowerPoint to PDF Conversion Overview.
pdf conversion to powerpoint; converting pdf to powerpoint
408    Chapter 8  Design at the Register Transfer Level
reset_b = 0;
#2 Start = 1; reset_b = 1;
Multiplicand = 5'b10111;  Multiplier = 5'b10011;
#10 Start = 0;
end 
initial 
begin 
clock = 0;
repeat  (26) #5 clock = ~clock;
end 
// Display results and compare with  Table   8.5   
always   @  ( posedge  clock)
$strobe  ("C=%b A=%b Q=%b P=%b time=%0d",M0.C,M0.A,M0.Q,M0.P,  $time );
endmodule 
Simulation log:
C=0 A=00000 Q=10011 P=101 time=5
C=0 A=10111 Q=10011 P=100 time=15
C=0 A=01011 Q=11001 P=100 time=25
C=1 A=00010 Q=11001 P=011 time=35
C=0 A=10001 Q=01100 P=011 time=45
C=0 A=10001 Q=01100 P=010 time=55
C=0 A=01000 Q=10110 P=010 time=65
C=0 A=01000 Q=10110 P=001 time=75
C=0 A=00100 Q=01011 P=001 time=85
C=0 A=11011 Q=01011 P=000 time=95
C=0 A=01101 Q=10101 P=000 time=105
C=0 A=01101 Q=10101 P=000 time=115
C=0 A=01101 Q=10101 P=000 time=125
/* Test bench for exhaustive simulation
module  t_Sequential_Binary_Multiplier;
parameter  
dp_width = 5; 
// Width of datapath
wire  
[2 * dp_width -1: 0] Product;
wire  
Ready;
reg   
[dp_width -1: 0] 
Multiplicand, Multiplier;
reg   
Start, clock, reset_b;
Sequential_Binary_Multiplier M0 (Product, Ready, Multiplicand, Multiplier, Start, clock, 
reset_b);
initial  #1030000  $finish ;
initial   begin  clock = 0; #5  forever  #5 clock = ~clock;  end 
initial   fork 
reset_b = 1;
#2 reset_b = 0;
#3 reset_b = 1;
join 
Section 8.9  HDL Description of Binary Multiplier    409
Behavioral Description of a Parallel Multiplier 
Structural modeling implicitly specifies the functionality of a digital machine by prescrib-
ing an interconnection of gate‐level hardware units. In this form of modeling, a synthesis 
tool performs Boolean optimization and translates the HDL description of a circuit into 
a netlist of gates in a particular technology, e.g., CMOS. Hardware design at this level often 
requires cleverness and accrued experience. It is the most tedious and detailed form of 
modeling. In contrast, behavioral RTL modeling specifies functionality abstractly, in terms 
of HDL operators. The RTL model does not specify a gate‐level implementation of the 
registers or the logic to control the operations that manipulate their contents—those tasks 
are accomplished by a synthesis tool. RTL modeling implicitly schedules operations by 
explicitly assigning them to clock cycles. The most abstract form of behavioral modeling 
describes only an algorithm, without any reference to a physical implementation, a set of 
resources, or a schedule for their use. Thus, algorithmic modeling allows a designer to 
explore trade‐offs in the space (hardware) and time domains, trading processing speed 
for hardware complexity. 
HDL Example 8.7 presents an RTL model and an algorithmic model of a binary 
multiplier. Both use a level‐sensitive cyclic behavior. The RTL model expresses the 
functionality of a multiplier in a single statement. A synthesis tool will associate with 
the multiplication operator a gate‐level circuit equivalent to that shown in Section 4.7. 
In simulation, when either the multiplier or the multiplicand changes, the product will 
be updated. The time required to form the product will depend on the propagation 
delays of the gates available in the library of standard cells used by the synthesis tool. 
The second model is an algorithmic description of the multiplier. A synthesis tool will 
unroll the loop of the algorithm and infer the need for a gate‐level circuit equivalent to 
that shown in Section 4.7. 
Be aware that a synthesis tool may not be able to synthesize a given algorithmic 
description, even though the associated HDL model will simulate and produce correct 
results. One difficulty is that the sequence of operations implied by an algorithm might 
not be physically realizable in a single clock cycle. It then becomes necessary to distrib-
ute the operations over multiple clock cycles. A tool for synthesizing RTL logic will not 
be able to automatically accomplish the required distribution of effort, but a tool that 
initial   begin  #5 Start = 1;  end 
initial   begin 
#5 Multiplicand = 0;
Multiplier = 0;
repeat  (32) #10  begin  Multiplier = Multiplier + 1;
repeat  (32) @ (posedge M0.Ready) 5 Multiplicand = Multiplicand + 1;
end 
end 
endmodule 
*/    
410    Chapter 8  Design at the Register Transfer Level
HDL Example 8.7  
// Behavioral (RTL) description of a parallel multiplier (n = 8)
module  Mult (Product, Multiplicand, Multiplier);
input  [7: 0]  Multiplicand, Multiplier;
output   reg  [15: 0] Product;
always  @ (Multiplicand, Multiplier)
Product = Multiplicand * Multiplier;
endmodule 
module  Algorithmic_Binary_Multiplier #( parameter  dp_width = 5) (
output  [2*dp_width -1: 0] Product,  input  [dp_width -1: 0] Multiplicand, Multiplier);
reg  [dp_width -1: 0] 
A, B, Q; 
// Sized for datapath
reg 
C;
integer  
k;
assign 
Product = {C, A, Q};
always  @ (Multiplier, Multiplicand) begin
Q = Multiplier;
B = Multiplicand;
C = 0;
A = 0;
for  (k = 0; k <= dp_width -1; k = k + 1)  begin 
if  (Q[0]) {C, A} = A + B;
{C, A, Q} = {C, A, Q} >> 1;
end 
end 
endmodule 
module  t_Algorithmic_Binary_Multiplier;
parameter  
dp_width = 5; 
// Width of datapath
wire  [2 
*
dp_width -1: 0]  
Product; 
reg  [dp_width -1: 0] 
Multiplicand, Multiplier;
integer  
Exp_Value;
reg  
Error; 
Algorithmic_Binary_Multiplier M0 (Product, Multiplicand, Multiplier);
// Error detection
initial #  1030000  finish ;
always  @ (Product) begin
Exp_Value = Multiplier * Multiplicand;
// Exp_Value = Multiplier * Multiplicand +1; // Inject error to confirm detection
Error = Exp_Value ^ Product;
end 
// Generate multiplier and multiplicand exhaustively for 5 bit operands
initial begin 
#5 Multiplicand = 0;
Multiplier = 0;
Section 8.10  Design with Multiplexers    411
is designed to synthesize algorithms should be successful. In effect, a behavioral synthe-
sis tool would have to allocate the registers and adders to implement multiplication. If 
only a single adder is to be shared by all of the operations that form a partial sum, the 
activity must be distributed over multiple clock cycles and in the correct sequence, ulti-
mately leading to the sequential binary multiplier for which we have explicitly designed 
the controller for its datapath. Behavioral synthesis tools require a different and more 
sophisticated style of modeling and are not within the scope of this text.      
8.10    DESIGN WITH MULTIPLEXERS 
The register‐and‐decoder scheme for the design of a controller has three parts: the 
flip‐flops that hold the binary state value, the decoder that generates the control outputs, 
and the gates that determine the next‐state and output signals. In Section 4.11, it was 
shown that a combinational circuit can be implemented with multiplexers instead of 
individual gates. Replacing the gates with multiplexers results in a regular pattern of 
three levels of components. The first level consists of multiplexers that determine the 
next state of the register. The second level contains a register that holds the present 
binary state. The third level has a decoder that asserts a unique output line for each 
control state. These three components are predefined standard cells in many integrated 
circuits. 
Consider, for example, the ASM chart of  Fig.   8.20   , consisting of four states and four 
control inputs. We are interested in only the control signals governing the state sequence. 
These signals are independent of the register operations of the datapath, so the edges of 
the graph are not annotated with datapath register operations, and the graph does not 
identify the output signals of the controller. The binary assignment for each state is indi-
cated at the upper right corner of the state boxes. The decision boxes specify the state 
transitions as a function of the four control inputs:  w,   x,   y and  z . The three‐level control 
implementation, shown in  Fig.   8.21   , consists of two multiplexers, MUX1 and MUX2; 
aregister with two flip‐flops,    G
1
and    G
0
;    and a decoder with four outputs—   d
0
d
1
d
2
,    and 
d
3
,    corresponding to  S_0,   S_1,   S_2 and  S_3 respectively. The outputs of the state‐register 
flip‐flops are applied to the decoder inputs and also to the select inputs of the multiplexers. 
In this way, the present state of the register is used to select one of the inputs from each 
multiplexer. The outputs of the multiplexers are then applied to the  D  inputs of    G
1
and 
G
0
. The purpose of each multiplexer is to produce an input to its corresponding flip‐flop 
equal to the binary value of that bit of the next‐state vector. The inputs of the multiplexers 
repeat  (32) #10  begin  Multiplier = Multiplier + 1;
repeat  (32) #5 Multiplicand = Multiplicand + 1;
end 
end 
endmodule    
412    Chapter 8  Design at the Register Transfer Level
are determined from the decision boxes and state transitions given in the ASM chart. For 
example, state 00 stays at 00 or goes to 01, depending on the value of input  w . Since the 
next state of    G
1
is 0 in either case, we place a signal equivalent to logic 0 in MUX1 input0. 
The next state of    G
0
is 0 if  w  = 0 and 1 if  w  = 1. Since the next state of    G
0
is equal to  w 
we apply control input  w  to MUX2 input 0. This means that when the select inputs of the 
multiplexers are equal to present state 00, the outputs of the multiplexers provide the 
binary value that is transferred to the register at the next clock pulse.   
 FIGURE 8.20  
Example of ASM chart with four control inputs       
w
x
y
z
y
z
S_0
S_1
S_3
S_2
00
01
11
10
0
1
0
0
1
1
0
1
1
0
1
0
Documents you may be interested
Documents you may be interested