Verilog

Verilog, standardized as IEEE 1364, is a hardware description language (HDL) used to model electronic systems.

Uses your system voice; voice and rate in settings.

≈ 15 min read

Cite, export and learn8 citation formats · 8 exports · lesson and quiz

Names in other languages

No names in other languages are held for this entry yet.

Article bodies are English and are not machine-translated. A name in another language is not a translation of the article.

Verilog, standardized as IEEE 1364, is a hardware description language (HDL) used to model electronic systems. It is most commonly used in the design and verification of digital circuits, with the highest level of abstraction being at the register-transfer level.

It is also used in the verification of analog circuits and mixed-signal circuits, as well as in the design of genetic circuits. In 2009, the Verilog standard (IEEE 1364-2005) was merged into the SystemVerilog standard, creating IEEE Standard 1800-2009. Since then, Verilog has been officially part of the SystemVerilog language.

The current version is IEEE standard 1800-2023.

Overview

Hardware description languages such as Verilog use software-like syntax, but unlike software programming languages they model physical hardware, including concurrent operation, signal timing, and electrical behavior. There are two types of assignment operators; a blocking assignment (=), and a non-blocking ( >>.

A generate–endgenerate construct (similar to VHDL's generate–endgenerate) allows Verilog-2001 to control instance and statement instantiation through normal decision operators (case–if–else). Using generate–endgenerate, Verilog-2001 can instantiate an array of instances, with control over the connectivity of the individual instances.

File I/O has been improved by several new system tasks. And finally, a few syntax additions were introduced to improve code readability (e.g. always @*, named parameter override, C-style function/task/module header declaration). Verilog-2001 is the version of Verilog supported by the majority of commercial EDA software packages.

Verilog 2005

Not to be confused with SystemVerilog, Verilog 2005 (IEEE Standard 1364-2005) consists of minor corrections, spec clarifications, and a few new language features (such as the uwire keyword). A separate part of the Verilog standard, Verilog-AMS, attempts to integrate analog and mixed signal modeling with traditional Verilog.

SystemVerilog

The advent of hardware verification languages such as OpenVera, and Verisity's e language encouraged the development of Superlog by Co-Design Automation Inc (acquired by Synopsys). The foundations of Superlog and Vera were donated to Accellera, which later became the IEEE standard P1800-2005: SystemVerilog.

SystemVerilog is a superset of Verilog-2005, with many new features and capabilities to aid design verification and design modeling. As of 2009, the SystemVerilog and Verilog language standards were merged into SystemVerilog 2009 (IEEE Standard 1800-2009).

Updates since 2009

The SystemVerilog standard was subsequently updated in 2012, 2017, and most recently in December 2023.

Example

A simple example of two flip-flops follows: module toplevel(clock,reset); input clock; input reset; reg flop1; reg flop2; always @ (posedge reset or posedge clock) if (reset) begin flop1 The operator in Verilog is another aspect of its being a hardware description language as opposed to a normal procedural language. This is known as a "non-blocking" assignment.

Its action does not register until after the always block has executed. This means that the order of the assignments is irrelevant and will produce the same result: flop1 and flop2 will swap values every clock. The other assignment operator = is referred to as a blocking assignment.

When = assignment is used, for the purposes of logic, the target variable is updated immediately. In the above example, had the statements used the = blocking operator instead of , flop1 and flop2 would not have been swapped.

Instead, as in traditional programming, the compiler would understand to simply set flop1 equal to flop2 (and subsequently ignore the redundant logic to set flop2 equal to flop1). An example counter circuit follows: module Div20x (rst, clk, cet, cep, count, tc); // TITLE 'Divide-by-20 Counter with enables' // enable CEP is a clock enable only // enable CET is a clock enable and // enables the TC output // a counter using the Verilog language parameter size = 5; parameter length = 20; input rst; // These inputs/outputs represent input clk; // connections to the module. input cet; input cep;

output [size-1:0] count; output tc; reg [size-1:0] count; // Signals assigned // within an always // (or initial)block // must be of type reg wire tc; // Other signals are of type wire // The always statement below is a parallel // execution statement that // executes any time the signals // rst or clk transition from low to high always @ (posedge clk or posedge rst) if (rst) // This causes reset of the cntr count An example of delays: ... reg a, b, c, d; wire e; ... always @(b or e) begin a = b & e; b = a | b; #5 c = b; d = #6 c ^ e;

end The always clause above illustrates the other type of method of use, i.e. it executes whenever any of the entities in the list (the b or e) changes.

When one of these changes, a is immediately assigned a new value, and due to the blocking assignment, b is assigned a new value afterward (taking into account the new value of a). After a delay of 5 time units, c is assigned the value of b and the value of c ^ e is tucked away in an invisible store. Then after 6 more time units, d is assigned the value that was tucked away.

Signals that are driven from within a process (an initial or always block) must be of type reg. Signals that are driven from outside a process must be of type wire. The keyword reg does not necessarily imply a hardware register.

Definition of constants

The definition of constants in Verilog supports the addition of a width parameter. The basic syntax is: ' Where: size: The bit-width of the constant (optional, but strongly recommended) base: The radix specifier - b (binary), o (octal), d (decimal), h (hexadecimal) value: The numeric value in the specified base Examples: 16'h1A23 or 16'h1a23 – Hexadecimal 1A23 lower and upper case are allowed (using 16 bits) 20'd44 – Decimal 44 (using 20 bits – 0 extension is automatic) 4'b1010 – Binary 1010 (using 4 bits) 6'o77 – Octal 77 (using 6 bits)

Synthesizable constructs

There are several statements in Verilog that have no analog in real hardware, such as the $display command. However, the examples presented here are the classic (and limited) subset of the language that has a direct mapping to real gates. // Mux examples — Three ways to do the same thing. // The first example uses continuous assignment wire out; assign out = sel ? a : b; // the second example uses a procedure // to accomplish the same thing. reg out; always @(a or b or sel) begin case(sel) 1'b0: out = b; 1'b1: out = a; endcase end // Finally — you can use if/else in a // procedural structure. reg out; always @(a or b or sel) if (sel) out = a; else out = b; The next interesting structure is a transparent latch; it will pass the input to the output when the gate signal is set for "pass-through", and captures the input and stores it upon transition of the gate signal to "hold".

The output will remain stable regardless of the input signal while the gate is set to "hold". In the example below the "pass-through" level of the gate would be when the value of the if clause is true, i.e. gate = 1. This is read "if gate is true, the din is fed to latch_out continuously."

Once the if clause is false, the last value at latch_out will remain and is independent of the value of din. // Transparent latch example reg latch_out; always @(gate or din) if(gate) latch_out = din; // Pass through state // Note that the else isn't required here. The variable // latch_out will follow the value of din while gate is // high.

When gate goes low, latch_out will remain constant. The flip-flop is the next significant template; in Verilog, the D-flop is the simplest, and it can be modeled as: reg q; always @(posedge clk) q The significant thing to notice in the example is the use of the non-blocking assignment.

A basic rule of thumb is to use reg q; always @(posedge clk or posedge reset) if(reset) q The next variant is including both an asynchronous reset and asynchronous set condition; again the convention comes into play, i.e. the reset term is followed by the set term. reg q; always @(posedge clk or posedge reset or posedge set) if(reset) q Note: If this model is used to model a Set/Reset flip flop then simulation errors can result. Consider the following test sequence of events.

1) reset goes high 2) clk goes high 3) set goes high 4) clk goes high again 5) reset goes low followed by 6) set going low. Assume no setup and hold violations. In this example the always @ statement would first execute when the rising edge of reset occurs which would place q to a value of 0.

The next time the always block executes would be the rising edge of clk which again would keep q at a value of 0. The always block then executes when set goes high which because reset is high forces q to remain at 0. This condition may or may not be correct depending on the actual flip flop.

However, this is not the main problem with this model. Notice that when reset goes low, that set is still high. In a real flip flop this will cause the output to go to a 1.

However, in this model it will not occur because the always block is triggered by rising edges of set and reset – not levels. A different approach may be necessary for set/reset flip flops. The final basic variant is one that implements a D-flop with a mux feeding its input.

The mux has a d-input and feedback from the flop itself. This allows a gated load function. // Basic structure with an EXPLICIT feedback path always @(posedge clk) if(gate) q Note that there are no "initial" blocks mentioned in this description. There is a split between FPGA and ASIC synthesis tools on this structure.

FPGA tools allow initial blocks where reg values are established instead of using a "reset" signal. ASIC synthesis tools don't support such a statement. The reason is that an FPGA's initial state is something that is downloaded into the memory tables of the FPGA.

An ASIC is an actual hardware implementation.

Initial and always

There are two separate ways of declaring a Verilog process. These are the always and the initial keywords. The always keyword indicates a free-running process.

The initial keyword indicates a process executes exactly once. Both constructs begin execution at simulator time 0, and both execute until the end of the block. Once an always block has reached its end, it is rescheduled (again).

It is a common misconception to believe that an initial block will execute before an always -block. In fact, it is better to think of the initial-block as a special-case of the always-block, one which terminates after it completes for the first time. //Examples: initial begin a = 1; // Assign a value to reg a at time 0 #1; // Wait 1 time unit b = a; // Assign the value of reg a to reg b end always @(a or b) // Any time a or b CHANGE, run the process begin if (a) c = b; else d = ~b; end // Done with this block, now return to the top (i.e. the @ event-control) always @(posedge a)// Run whenever reg a has a low to high change a These are the classic uses for these two keywords, but there are two significant additional uses.

The most common of these is an always keyword without the @(...) sensitivity list. It is possible to use always as shown below: always begin // Always begins executing at time 0 and NEVER stops clk = 0; // Set clk to 0 #1; // Wait for 1 time unit clk = 1; // Set clk to 1 #1; // Wait 1 time unit end // Keeps executing — so continue back at the top of the begin The always keyword acts similar to the C language construct while(1) {..} in the sense that it will execute forever.

The other interesting exception is the use of the initial keyword with the addition of the forever keyword. The example below is functionally identical to the always example above. initial forever // Start at time 0 and repeat the begin/end forever begin clk = 0; // Set clk to 0 #1; // Wait for 1 time unit clk = 1; // Set clk to 1 #1; // Wait 1 time unit end

Fork/join

The fork/join pair are used by Verilog to create parallel processes. All statements (or blocks) between a fork/join pair begin execution simultaneously upon execution flow hitting the fork.

Execution continues after the join upon completion of the longest running statement or block between the fork and join. initial fork $write("A"); // Print char A $write("B"); // Print char B begin #1; // Wait 1 time unit $write("C"); // Print char C end join The way the above is written, it is possible to have either the sequences "ABC" or "BAC" print out. The order of simulation between the first $write and the second $write depends on the simulator implementation, and may purposefully be randomized by the simulator.

This allows the simulation to contain both accidental race conditions as well as intentional non-deterministic behavior. Notice that VHDL cannot dynamically spawn multiple processes like Verilog.

Race conditions

The order of execution is not always guaranteed within Verilog. This can best be illustrated by a classic example.

Consider the code snippet below: initial a = 0; initial b = a; initial begin #1; $display("Value a=%d Value of b=%d",a,b); end Depending on the order of execution of the initial blocks, it could be zero and zero, or alternately zero and some other arbitrary uninitialized value. The $display statement will always execute after both assignment blocks have completed, due to the #1 delay.

Operators

Note: These operators are not shown in order of precedence.

Four-valued logic

The IEEE 1364 standard defines a four-valued logic with four states: 0, 1, Z (high impedance), and X (unknown logic value). For the competing VHDL, a dedicated standard for multi-valued logic exists as IEEE 1164 with nine levels.

System tasks

System tasks are available to handle simple I/O and various design measurement functions during simulation. All system tasks are prefixed with $ to distinguish them from user tasks and functions. This section presents a short list of the most frequently used tasks.

It is by no means a comprehensive list. $display – Print to screen a line followed by an automatic newline. $write – Print to screen a line without the newline. $swrite – Print to variable a line without the newline. $sscanf – Read from variable a format-specified string. (*Verilog-2001) $fopen – Open a handle to a file (read or write) $fdisplay – Print a line from a file followed by an automatic newline. $fwrite – Print to file a line without the newline. $fscanf – Read from file a format-specified string.

(*Verilog-2001) $fclose – Close and release an open file handle. $readmemh – Read hex file content into a memory array. $readmemb – Read binary file content into a memory array. $monitor – Print out all the listed variables when any change value. $time – Value of current simulation time. $dumpfile – Declare the VCD (Value Change Dump) format output file name. $dumpvars – Turn on and dump the variables. $dumpports – Turn on and dump the variables in Extended-VCD format. $random – Return a random value.

Program Language Interface (PLI)

The PLI provides a programmer with a mechanism to transfer control from Verilog to a program function written in C language. It is officially deprecated by IEEE Std 1364-2005 in favor of the newer Verilog Procedural Interface, which completely replaces the PLI.

The PLI (now VPI) enables Verilog to cooperate with other programs written in the C language such as test harnesses, instruction set simulators of a microcontroller, debuggers, and so on. For example, it provides the C functions tf_putlongp() and tf_getlongp() which are used to write and read the 64-bit integer argument of the current Verilog task or function, respectively.

For 32-bit integers, tf_putp() and tf_getp() are used.

Simulation software

For information on Verilog simulators, see the list of Verilog simulators.

Additional material

(VPI)

Similar languages

, the main competitor to Verilog and SystemVerilog. and providing HDL event-driven semantics built on top of Scala

References

Notes Cornell ECE576 Course illustrating synthesis constructs (The HDL Testbench Bible)

Standards development

– The official standard for Verilog 2005 (not free). IEEE P1364 – working group for Verilog (inactive) IEEE P1800. – Working group for SystemVerilog (replaces above). Verilog syntax – A 1995 description of the syntax in Backus-Naur form. This predates the IEEE-1364 standard.

Language extensions

Verilog AUTOs — an open-source meta-comment used by industry IP to simplify maintaining Verilog code

Text derived from https://en.wikipedia.org/w/index.php?oldid=1378373800 under CC BY-SA 4.0; modifications have been made.

Words in each sectionSynthesizable constructsSynthesizable constructsSynthesizable constructs: 743 words743ExampleExampleExample: 481 words481Initial and alwaysInitial and alwaysInitial and always: 356 words356System tasksSystem tasksSystem tasks: 202 words202Fork/joinFork/joinFork/join: 154 words154OverviewOverviewOverview: 136 words136Program Language Interf…Program Language Interface (PLI)Program Language Interface (PLI): 113 words113Definition of constantsDefinition of constantsDefinition of constants: 97 words97Race conditionsRace conditionsRace conditions: 88 words88SystemVerilogSystemVerilogSystemVerilog: 81 words81Verilog 2005Verilog 2005Verilog 2005: 47 words47Standards developmentStandards developmentStandards development: 39 words39Four-valued logicFour-valued logicFour-valued logic: 38 words38Language extensionsLanguage extensionsLanguage extensions: 35 words35Similar languagesSimilar languagesSimilar languages: 17 words17Updates since 2009Updates since 2009Updates since 2009: 15 words15Simulation softwareSimulation softwareSimulation software: 11 words11OperatorsOperatorsOperators: 10 words10Additional materialAdditional materialAdditional material: 1 words1
Words in each section. Measured from the stored article body; sections below the minimum are not plotted.

Provenance

snapshot enwiki-001378373800 · captured 2026-10-04 · ledger · version history

Cite this page as: encyclopegia.org, “Verilog”, snapshot enwiki-001378373800. https://encyclopegia.org/a/verilog

Sources cited in this revision

7 named source(s) extracted from the cited revision. A source with no author is shown by its publication; nothing is invented.