Section 8.2  Register Transfer Level Notation    353
inputs of the destination register and that the destination register has a parallel load 
capability. Data can be transferred serially between registers, too, by repeatedly shifting 
their contents along a single wire, one bit at a time. Normally, we want a register transfer 
operation to occur, not with every clock cycle, but only under a predetermined condition. 
A conditional statement governing a register transfer operation is symbolized with an 
if–then statement such as 
If (T1 = 1) then (R2
d
R1)   
where  T1  is a control signal generated in the control section. Note that the clock is not 
included as a variable in the register transfer statements. It is assumed that all transfers 
occur at a clock‐edge transition (i.e., a transition from 0 to 1 or from 1 to 0). Although 
a control condition such as  T1  may become true before the clock transition, the actual 
transfer does not occur until the clock transition does. The transfers are initiated and 
synchronized by the action of the clock signal, but the actual transition of the outputs 
(in a physical system) does not result in instantaneous transitions at the outputs of the 
registers. Propagation delays depend on the physical characteristics of the transistors 
implementing the flip‐flops of the register and the wires connecting devices. There is 
always a delay, however small, between a cause and its effect in a physical system. 
A comma may be used to separate two or more operations that are executed at the 
same time (concurrently). Consider the statement 
If (T3= 1) then (R2
d
R1R1
d
R2)   
This statement specifies an operation that exchanges the contents of two registers; more-
over, the operation in both registers is triggered by the same clock edge, provided that 
T3 =1.    This simultaneous (concurrent) operation is possible with registers that have 
edge‐triggered flip‐flops controlled by a common clock (synchronizing signal). Other 
examples of register transfers are as follows: 
R1
d
R1 R2     Add contents of  R2  to  R1  ( R1  gets  R1  +  R2 ) 
R3
d
R3 + 1     
Increment  R3  by 1 (count upwards) 
R4
d
shr R4     
Shift right  R4  
R5
d
0     
Clear  R5  to 0 
In hardware, addition is done with a binary parallel adder, incrementing is done with a 
counter, and the shift operation is implemented with a shift register. The type of opera-
tions most often encountered in digital systems can be classified into four categories: 
 
1.   Transfer operations, which transfer (i.e., copy) data from one register to another.  
 
2.   Arithmetic operations, which perform arithmetic (e.g., multiplication) on data in 
registers.  
 
3.   Logic operations, which perform bit manipulation (e.g., logical OR) of non numeric 
data in registers.  
 
4.   Shift operations, which shift data between registers.   
The transfer operation does not change the information content of the data being moved 
from the source register to the destination register unless the source and destination are 
Table from 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
converter pdf to powerpoint; convert pdf pages into powerpoint slides
Table from 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
how to convert pdf to ppt; how to convert pdf to powerpoint
354    Chapter 8  Design at the Register Transfer Level
the same. The other three operations change the information content during the trans-
fer. The register transfer notation and the symbols used to represent the various regis-
ter transfer operations are not standardized. In this text, we employ two types of 
notation. The notation introduced in this section will be used informally to specify and 
explain digital systems at the register transfer level. The next section introduces the 
RTL symbols used in the Verilog HDL, which is standardized.  
8.3    REGISTER TRANSFER LEVEL IN HDL 
Digital systems can be described at the register transfer level by means of a HDL. In the 
Verilog HDL, descriptions of RTL operations use a combination of behavioral and data-
flow constructs and are employed to specify the register operations and the combina-
tional logic functions implemented by hardware. Register transfers are specified by 
means of procedural assignment statements within an  edge‐sensitive cyclic behavior.  
Combinational circuit functions are specified at the RTL level by means of continuous 
assignment statements or by procedural assignment statements within a  level‐sensitive 
cyclic behavior.  The symbol used to designate a register transfer is either an equals sign 
(=) or an arrow (6=); the symbol used to specify a combinational circuit function is an 
equals sign. Synchronization with the clock is represented by associating with an  always  
statement an event control expression in which sensitivity to the clock event is qualified 
by  posedge  or  negedge . The  always  keyword indicates that the associated block of state-
ments will be executed repeatedly, for the life of the simulation. The  @  operator and the 
event control expression preceding the block of statements synchronize the execution 
of the statements to the clock event. 
The following examples show the various ways to specify a register transfer operation 
in Verilog:  
(a) assign  S = A + B; 
// Continuous assignment for addition operation
(b) always   @  (A, B) 
// Level-sensitive cyclic behavior
S = A + B;  
// Combinational logic for addition operation
(c) always   @  ( negedge  clock) 
// Edge-sensitive cyclic behavior
begin 
RA = RA + RB; 
// Blocking procedural assignment for addition
RD = RA; 
// Register transfer operation
end 
(d) always   @  ( negedge  clock) 
// Edge-sensitive cyclic behavior
begin 
RA <= RA + RB; 
// Nonblocking procedural assignment for addition
RD <= RA; 
// Register transfer operation
end    
Continuous assignments (e.g.,  assign  S = A + B;) are used to represent and specify 
combinational logic circuits. In simulation, a continuous assignment statement executes 
when the expression on the right‐hand side changes. The effect of execution is immediate. 
C# Word - Table Processing in C#.NET
C# Word - Table Processing in C#.NET. Provide C# Users with Variety of Methods to Setup and Modify Table in Word Document. Overview. Create Table in Word.
embed pdf into powerpoint; image from pdf to ppt
C# Word - Table Row Processing in C#.NET
C# Word - Table Row Processing in C#.NET. How to Set and Modify Table Rows in Word Document with C#.NET Solutions. Overview. Create and Add Rows in Table.
pdf to ppt; pdf conversion to powerpoint
Section 8.3  Register Transfer Level in HDL    355
(The variable on the left‐hand side is updated.) Similarly, a level‐sensitive cyclic behav-
ior (e.g.,  always  @ (A, B)) executes during simulation when a change is detected by its 
event control expression (sensitivity list). The effect of assignments made by the = oper-
ator is immediate. The continuous assignment statement ( assign  S = A + B) describes a 
binary adder with inputs  A  and  B  and output  S . The target operand in a continuous 
assignment statement ( S  in this case) cannot be a register data type, but must be a type 
of net, for example,  wire . The procedural assignment made in the level‐sensitive cyclic 
behavior in the second example shows an alternative way of specifying a combinational 
circuit for addition. Within the cyclic behavior, the mechanism of the sensitivity list 
ensures that the output,  S will be updated whenever  A or  B or both change. 
There are two kinds of procedural assignments:  blocking  and  nonblocking . The two 
are distinguished by their symbols and by their operation.  Blocking  assignments use the 
equals symbol (=) as the assignment operator, and  nonblocking  assignments use the left 
arrow (6=) as the operator. Blocking assignment statements are executed  sequentially  
in the order that they are listed in a sequential block; when they execute, they have an 
immediate effect on the contents of memory before the next statement can be executed. 
Nonblocking assignments are made  concurrently . This feature is implemented by evalu-
ating the expression on the right‐hand side of each statement in the list of statements 
before making the assignment to their left‐hand sides. Consequently,  there is no interac-
tion between the result of any assignment and the evaluation of an expression affecting 
another assignment Also, the statements associated with an edge‐sensitive cyclic behav-
ior do not execute until the indicated edge condition occurs. Consider (c) in the example 
given above. In the list of blocking procedural assignment, the first statement transfers the 
sum ( RA + RB ) to  RA and the second statement transfers the new value of  RA  into  RD . 
The value in  RA  after the clock event is the sum of the values in  RA  and  RB  immediately 
before the clock event. At the completion of the operation, both  RA  and  RD  have the 
same value. In the nonblocking procedural assignment ((d) above), the two assignments 
are performed concurrently, so that  RD  receives the original value of  RA . The activity 
in both examples is launched by the clock undergoing a falling edge transition. 
The registers in a system are clocked simultaneously (concurrently). The  D ‐input of 
each flip‐flop determines the value that will be assigned to its output, independently of 
the input to any other flip‐flop. To ensure synchronous operations in RTL design, and 
to ensure a match between an HDL model and the circuit synthesized from the model, 
it is necessary that nonblocking procedural assignments be used for all variables that 
are assigned a value within an edge‐sensitive cyclic behavior ( always  clocked). The non-
blocking assignment that appears in an edge‐sensitive cyclic behavior models the behav-
ior of the hardware of a synchronous sequential circuit accurately. In general, the 
blocking assignment operator (=) is used in a procedural assignment statement only 
when it is necessary to specify a sequential ordering of multiple assignment statements. 
HDL Operators 
The Verilog HDL operators and their symbols used in RTL design are listed in  Table  8.1   . 
The arithmetic, logic, and shift operators describe register transfer operations. The 
C# Word - Table Cell Processing in C#.NET
C# Word - Table Cell Processing in C#.NET. Online Tutorial for Users to Set and Modify Table Cells in Word Document. Overview. Create and Add Cells in Table.
add pdf to powerpoint; pdf to powerpoint converter
How to C#: Convert PDF, Excel, PPT to Word
Footnote & Endnote Processing. Table Row Processing. Table Cell Processing. VB.NET How-to, VB.NET PDF, VB.NET Word, VB.NET Excel, VB.NET PowerPoint, VB.NET Tiff
pdf page to powerpoint; converting pdf to powerpoint slides
356    Chapter 8  Design at the Register Transfer Level
logical and relational operators specify control conditions and have Boolean expres-
sions as their arguments. 
The operands of the arithmetic operators are numbers. The +, -, *, and / operators 
form the sum, difference, product, and quotient, respectively, of a pair of operands. 
The exponentiation operator (**) was added to the language in 2001 and forms a 
double‐precision floating‐point value from a base and exponent having a real, integer, 
Table 8.1 
Verilog 2001 HDL Operators 
Operator Type 
Symbol 
Operation Performed 
Arithmetic 
addition 
– 
subtraction 
multiplication 
division 
modulus 
** 
exponentiation 
Bitwise or Reduction 
negation (complement) 
AND 
OR 
exclusive‐OR (XOR) 
Logical 
negation 
&& 
AND 
|| 
OR 
Shift 
>> 
logical right shift 
<< 
logical left shift 
>>> 
arithmetic right shift 
<<< 
arithmetic left shift 
{ , } 
concatenation 
Relational 
greater than 
less than 
== 
equality 
!= 
inequality 
=== 
case equality 
!== 
case inequality 
>= 
greater than or equal 
<= 
less than or equal 
C# Word - Header & Footer Processing in C#.NET
Create and Add Table to Footer & Header. The following demo code shows how to create table in footer and header. String docFilePath
converting pdf to ppt online; how to change pdf to powerpoint on
How to C#: Overview of Using XDoc.Word
Rapidly load, create, and edit Word document (pages) in C# class library. Able to render and convert Word document to/from supported document (PDF and ODT).
how to convert pdf into powerpoint on; how to change pdf to powerpoint
Section 8.3  Register Transfer Level in HDL    357
or signed value. Negative numbers are represented in 2’s‐complement form. The mod-
ulus operator produces the remainder from the division of two numbers. For example, 
14 % 3 evaluates to 2. 
There are two types of binary operators for binary words: bitwise and reduction. The 
bitwise operators perform a bit‐by‐bit operation on two vector operands to form a vec-
tor result. They take each bit in one operand and perform the operation with the cor-
responding bit in the other operand. Negation (~) is a unary operator; it complements 
the bits of a single vector operand to form a vector result. The reduction operators are 
also unary, acting on a single operand and producing a scalar (one‐bit) result. They oper-
ate pairwise on the bits of a word, from right to left, and yield a one‐bit result. For 
example, the reduction NOR (~|) results in 0 with operand 00101 and in 1 with operand 
00000. The result of applying the NOR operation on the first two bits is used with the 
third bit, and so forth. Negation is not used as a reduction operator — its operation on 
a vector produces a vector. Truth tables for the bitwise operators acting on a pair of 
scalar operands are the same as those listed in Table 4.9 in Section 4.12 for the corre-
sponding Verilog primitive (e.g., the  and  primitive and the  &  bitwise operator have the 
same truth table). The output of an AND gate with two scalar inputs is the same as the 
result produced by operating on the two bits with the  &  operator. 
The logical and relational operators are used to form Boolean expressions and can 
take variables or expressions as operands. ( Note : A variable is also an expression.) Used 
basically for determining true or false conditions, the logical and relational operators 
evaluate to 1 if the condition expressed is true and to 0 if the condition is false. If the 
condition is ambiguous, they evaluate to x. An operand that is a variable evaluates to 0 
if the value of the variable is equal to zero and to 1 if the value is not equal to zero. For 
example, if  A  = 1010 and  B  = 0000, then the expression  A  has the Boolean value 1 (the 
number in question is not equal to 0) and the expression  B  has the Boolean value 0. 
Results of other operations with these values are as follows:    
A && B = 0 
// Logical AND: 
(1010) && (0000) = 0 
A & B = 0000 
// Bitwise AND: 
(1010) & (1010) = (0000) 
A || B = 1 
// Logical OR: 
(1010) || (0000) = 1 
A | B = 1010 
// Bitwise OR: 
(1010) | (0000) = (1010) 
!A = 0 
// Logical negation 
!(1010) = !(1) = 0 
~A = 0101 
// Bitwise negation 
~(1010) = (0101) 
!B = 1 
// Logical negation 
!(0000) = !(0) = 1 
~B = 1111 
// Bitwise negation 
~(0000) = 1111 
(A > B) = 1 
// is greater than 
(A == B) = 0 
// identity (equality) 
The relational operators = = = and ! = = test for bitwise equality (identity) and inequal-
ity in Verilog’s four‐valued logic system. For example, if  A  = 0xx0 and  B  = 0xx0, the test 
A  = = =  B  would evaluate to true, but the test  A  = =  B  would evaluate to x. 
C# Word - Document Processing in C#.NET
0); //Save the document doc0.Save(@""). Create, Add, Delete or Modify Paragraph and Table in Word Document. If you want to create
convert pdf to editable ppt; convert pdf into powerpoint
C# Word - Word Create or Build in C#.NET
Create Word Document from Existing Files Using C#. Create Word From PDF. Create Word From PowerPoint. Create Word From Open Office Files. Table Processing.
add pdf to powerpoint presentation; online pdf converter to powerpoint
358    Chapter 8  Design at the Register Transfer Level
Verilog 2001 has logical and arithmetic shift operators. The logical shift operators shift 
a vector operand to the right or the left by a specified number of bits. The vacated bit 
positions are filled with zeros. For example, if  R  = 11010, then the statement 
R = R >> 1;  
shifts  R  to the right one position. The value of  R  that results from the logical right‐shift 
operation (11010) >> 1 is 01101. In contrast, the arithmetic right‐shift operator fills the 
vacated cell (the most significant bit (MSB)) with its original contents when the word 
is shifted to the right. The arithmetic left‐shift operator fills the vacated cell with a 0 
when the word is shifted to the left. The arithmetic right‐shift operator is used when the 
sign extension of a number is important. If  R  = 11010, then the statement 
R >>> 1;  
produces the result  R  = 11101; if  R  = 01101, it produces the result  R  = 00110. There is 
no distinction between the logical left‐shift and the arithmetic left‐shift operators. 
The concatenation operator provides a mechanism for appending multiple oper-
ands. It can be used to specify a shift, including the bits transferred into the vacant 
positions. This aspect of its operation was shown in HDL Example 6.1 for the shift 
register. 
Expressions are evaluated from left to right, and their operators associate from left 
to right (with the exception of the conditional operator) according to the precedence 
shown in  Table   8.2   . For example, in the expression  A + B – C , the value of  B  is added 
to  A and then  C  is subtracted from the result. In the expression  A + B/C the value of 
B  is divided by  C and then the result is added to A because the division operator ( / ) 
has a higher precedence than the addition operator (+). Use parentheses to establish 
precedence. For example, the expression ( A + B )/ C  is not the same as the expression 
A + B/C.   
Loop Statements 
Verilog HDL has four types of loops that execute procedural statements repeatedly: 
repeat, forever, while and  for All looping statements must appear inside an  initial  or 
always  block. 
The repeat loop executes the associated statements a specified number of times. The 
following is an example that was used previously:  
initial 
begin 
clock = 1'b0;
repeat  (16)
#5 clock = ~ clock;
end    
This code toggles the clock 16 times and produces eight clock cycles with a cycle time 
of 10 time units.  
C# Word - Footnote & Endnote Processing in C#.NET
Create or Add Table in Footnote & Endnote. The following demo code shows how to create table in the footnote. String docFilePath
convert pdf to ppt online without email; how to change pdf to ppt on
C# Word - Convert Word to PDF in C#.NET
Word: Convert Word to PDF. C# Word - Convert Word to PDF in C#.NET. Online C# Tutorial for Converting Word to PDF (.pdf) Document. Word to PDF Conversion Overview
convert pdf file to powerpoint online; how to convert pdf to powerpoint in
Section 8.3  Register Transfer Level in HDL    359
The  forever  loop causes unconditional, repetitive execution of a procedural statement 
or a block of procedural statements. For example, the following loop produces a con-
tinuous clock having a cycle time of 20 time units:  
initial 
begin 
clock = 1'b0;
forever 
#10 clock = ~ clock;
end    
The  while  loop executes a statement or a block of statements repeatedly while an 
expression is true. If the expression is false to begin with, the statement is never exe-
cuted. The following example illustrates the use of the  while  loop:  
integer  count;
initial 
begin 
count = 0;
while  (count < 64)
#5 count = count + 1;
end    
Table 8.2 
Verilog Operator Precedence 
+ − ! ~ & ~& | ~ | ^ ~^ ^~ (unary) 
Highest precedence 
** 
* / % 
+ − (binary) 
<< >> <<< >>> 
< < = > > = 
== != === !== 
& (binary) 
^ ^~  ~^ (binary) 
| (binary) 
&& 
|| 
?: (conditional operator) 
{ } { { } } 
Lowest precedence 
360    Chapter 8  Design at the Register Transfer Level
The value of count is incremented from 0 to 63. Each increment is delayed by five time 
units, and the loop exits at the count of 64. 
In dealing with looping statements, it is sometimes convenient to use the  integer  data 
type to index the loop. Integers are declared with the keyword  integer as in the previous 
example. Although it is possible to use a  reg  variable to index a loop, sometimes it is 
more convenient to declare an integer variable, rather than a  reg for counting purposes. 
Variables declared as data type  reg  are stored as unsigned numbers. Those declared as 
data type  integer  are store as signed numbers in 2’s‐complement format. The default 
width of an integer is a minimum of 32 bits. 
The  for  loop is a compact way to express the operations implied by a list of state-
ments whose variables are indexed. The for loop contains three parts separated by two 
semicolons: 
•   An initial condition.  
•   An expression to check for the terminating condition.  
•   An assignment to change the control variable.   
The following is an example of a  for  loop:  
for  (j = 0; j < 8; j = j + 1)
begin 
// procedural statements go here
end    
The  for  loop statement repeats the execution of the procedural statements eight times. The 
control variable is  j the initial condition is  j  = 0, and the loop is repeated as long as  j  is less 
than 8. After each execution of the loop statement, the value of  j  is incremented by 1. 
A description of a two‐to‐four‐line decoder using a  for  loop is shown in HDL Exam-
ple 8.1. Since output  Y  is evaluated in a procedural statement, it must be declared as 
type  reg . The control variable for the loop is the  integer   k . When the loop is expanded 
(unrolled), we get the following four conditions ( IN  and  Y  are in binary, and the index 
for  Y  is in decimal): 
if IN = 00 then Y(0) = 1; else Y(0) = 0; 
if IN = 01 then Y(1) = 1; else Y(1) = 0; 
if IN = 10 then Y(2) = 1; else Y(2) = 0; 
if IN = 11 then Y(3) = 1; else Y(3) = 0;  
HDL Example 8.1 (Decoder) 
// Description of 2 x 4 decoder using a  for  loop statement
module  decoder (IN, Y);
input   
[1: 0] IN;  
// Two binary inputs
output   
[3: 0]  Y;  
// Four binary outputs
reg  
[3: 0]  Y;
integer  
k;  
// Control (index) variable for loop
Section 8.3  Register Transfer Level in HDL    361
Logic Synthesis 
Logic synthesis is the automatic process by which a computer‐based program (i.e., a 
synthesis tool) transforms an HDL model of a logic circuit into an optimized netlist of 
gates that perform the operations specified by the source code. There are various target 
technologies that implement the synthesized design in hardware. The effective use of 
an HDL description requires that designers adopt a vendor‐specific style suitable for 
the particular synthesis tools. The type of ICs that implement the design may be an 
application‐specific integrated circuit (ASIC), a programmable logic device (PLD), or 
a field‐programmable gate array (FPGA). Logic synthesis is widely used in industry to 
design and implement large circuits efficiently, correctly, and rapidly. 
Logic synthesis tools interpret the source code of the HDL and translate it into 
anoptimized gate structure, accomplishing (correctly) all of the work that would be 
done by manual methods using Karnaugh maps. Designs written in Verilog or a compa-
rable language for the purpose of logic synthesis tend to be at the register transfer level. 
This is because the HDL constructs used in an RTL description can be converted into 
a gate‐level description in a straightforward manner. The following examples discuss 
how a logic synthesizer can interpret an HDL construct and convert it into a gate 
structure. 
The continuous assignment ( assign ) statement is used to describe combinational 
circuits. In an HDL, it represents a Boolean equation for a logic circuit. A continuous 
assignment with a Boolean expression for the right‐hand side of the assignment state-
ment is synthesized into the corresponding gate circuit implementing the expression. 
An expression with an addition operator (+) is interpreted as a binary adder using 
full‐adder circuits. An expression with a subtraction operator (−) is converted into a 
gate‐level subtractor consisting of full adders and exclusive‐OR gates (Fig. 4.13). 
Astatement with a conditional operator such as  
assign  Y = S ? In_1 : In_0;  
translates into a two‐to‐one‐line multiplexer with control input  S  and data inputs  In_1  
and  In_0 . A statement with multiple conditional operators specifies a larger multiplexer. 
A cyclic behavior ( always  . . .) may imply a combinational or sequential circuit, 
depending on whether the event control expression is level sensitive or edge sensitive. 
A synthesis tool will interpret as combinational logic a level‐sensitive cyclic behavior 
whose event control expression is sensitive to every variable that is referenced within 
the behavior (e.g., by the variable’s appearing in the right‐hand side of an assignment 
always   @  (IN)
for  (k = 0; k <= 3; k = k + 1)
if  (IN == k) Y[k] = 1;
else  Y[k] = 0;
endmodule        
362    Chapter 8  Design at the Register Transfer Level
statement). The event control expression in a description of combinational logic may 
not be sensitive to an edge of any signal. For example,  
always @  (In_1  or  In_0  or  S) 
// Alternative: (In_1, In_0, S) 
if  (S) Y = In_1; 
else  Y = In_0;  
translates into a two‐to‐one‐line multiplexer. As an alternative, the  case  statement may 
be used to imply large multiplexers. The  casex  statement treats the logic values x and z 
as don’t‐cares when they appear in either the case expression or a case item. 
An edge‐sensitive cyclic behavior (e.g.,  always @  ( posedge  clock)) specifies a syn-
chronous (clocked) sequential circuit. The implementation of the corresponding circuit 
consists of  D  flip‐flops and the gates that implement the synchronous register transfer 
operations specified by the statements associated with the event control expression. 
Examples of such circuits are registers and counters. A sequential circuit description 
with a  case  statement translates into a control circuit with  D  flip‐flops and gates that 
form the inputs to the flip‐flops. Thus, each statement in an RTL description is inter-
preted by the synthesizer and assigned to a corresponding gate and flip‐flop circuit. For 
synthesizable sequential circuits, the event control expression must be sensitive to the 
positive or the negative edge of the clock (synchronizing signal), but not to both. 
A simplified flowchart of the process used by industry to design digital systems is 
shown in  Fig.   8.1   . The RTL description of the HDL design is simulated and checked for 
proper operation. Its operational features must match those given in the specification 
for the behavior of the circuit. The test bench provides the stimulus signals to the simu-
lator. If the result of the simulation is not satisfactory, the HDL description is corrected 
and checked again. After the simulation run shows a valid design, the RTL description 
is ready to be compiled by the logic synthesizer. All errors (syntax and functional) in 
the description must be eliminated before synthesis. The synthesis tool generates a 
netlist equivalent to a gate‐level description of the design as it is represented by the 
model. If the model fails to express the functionality of the specification, the circuit will 
fail to do so also. The gate‐level circuit is simulated with the same set of stimuli used to 
check the RTL design. If any corrections are needed, the process is repeated until a 
satisfactory simulation is achieved. The results of the two simulations are compared to 
see if they match. If they do not, the designer must change the RTL description to correct 
any errors in the design. Then the description is compiled again by the logic synthesizer 
to generate a new gate‐level description. Once the designer is satisfied with the results 
of all simulation tests, the design of the circuit is ready for physical implementation in a 
technology. In practice, additional testing will be performed to verify that the timing 
specifications of the circuit can be met in the chosen hardware technology. That issue is 
not within the scope of this text.  
Logic synthesis provides several advantages to the designer. It takes less time to write 
an HDL description and synthesize a gate‐level realization than it does to develop the 
circuit by manual entry from schematic diagrams. The ease of changing the description 
facilitates exploration of design alternatives. It is faster, easier, less expensive, and less 
risky to check the validity of the design by simulation than it is to produce a hardware 
Documents you may be interested
Documents you may be interested