Verilog Arrays Tutorial: From Basics to Advanced SystemVerilog Techniques

By 佐川 直弘 | Naohiro Sagawa (運営者)

※記事内に広告を含みます。Amazonアソシエイトとして適格販売により収入を得ています。

1. Introduction

Verilog is widely used as a hardware description language (HDL) and is indispensable in circuit design for FPGA and ASIC development. To design efficiently with Verilog, a solid understanding of arrays is crucial.

By leveraging arrays, you can manage collections of data in a concise and intuitive way, which improves the readability and maintainability of your circuit descriptions. Arrays are especially effective when grouping multiple signals or representing memory structures such as RAM.

This article focuses on the keyword “Verilog arrays” and provides a comprehensive explanation ranging from the basics of array definition to practical application techniques. We will cover array types, SystemVerilog enhancements, common errors, and FAQs to help deepen your understanding.

Even beginners will find this guide accessible, as we include practical code examples throughout. Read on to the end for a complete overview.

2. Basic Data Types in Verilog

Before working with arrays in Verilog, it’s essential to understand the fundamental data types. Verilog provides several key data types for handling logic signals used in circuit design.

Difference Between reg and wire

The most commonly used data types in Verilog are “reg” (register) and “wire.” They must be used appropriately depending on the behavior of the logic signals.

• wire type
  A wire is used as a connection line between modules or circuits. It must always be driven by another signal, and assignments are made using the assign statement. Suitable for combinational circuit outputs. Example:

  wire a;
  assign a = b & c;

• reg type
  A reg is used as a variable to temporarily hold values. It is assigned inside process blocks such as always, and is typically used to model storage elements (latches or flip-flops). Example:

  reg q;
  always @(posedge clk) begin
      q <= d;
  end

Data Types Usable in Arrays

In Verilog, arrays are often defined using the reg type, though wire arrays can also be used in some cases. However, earlier versions of Verilog did not support multidimensional arrays. This limitation was significantly improved in SystemVerilog.

Here is a simple example of array syntax:

reg [7:0] data_array [0:15];  // An array storing 16 elements, each 8 bits wide

By understanding the basics of data types, you can avoid confusion when declaring and using arrays. Misusing reg and wire can lead to simulation or synthesis errors, so be cautious.

3. Basic Concepts of Arrays

In Verilog, an array is used when you want to manage multiple signals of the same type collectively. Arrays make it easier to organize signals, improving code readability and reusability.

Declaring Arrays

Verilog primarily supports one-dimensional arrays. The syntax is as follows:

reg [bit-width] array_name [index-range];

Example:

reg [7:0] data_array [0:15];  // An array of 16 elements, each storing 8-bit data

In this case, data_array has 16 elements indexed from 0 to 15, with each element storing an 8-bit value (1 byte).

Accessing Array Elements

You can access each element of an array by specifying its index number. Similar to C, array indices start from 0.

data_array[0] = 8'hFF;   // Assign hexadecimal FF to the first element
data_array[1] = 8'd12;   // Assign decimal 12 to the second element

You can also use a loop inside an always block to initialize or manipulate arrays.

integer i;
always @(posedge clk) begin
    for (i = 0; i < 16; i = i + 1) begin
        data_array[i] <= 8'd0;
    end
end

Advantages of Arrays

• Batch processing: With a for loop, you can apply the same operation to multiple signals at once.
• Structured circuits: Arrays help organize multiple registers or signals, keeping the circuit representation clear.
• Memory modeling: You can implement simple memory structures such as RAM or ROM (explained in the next chapter).

Points to Note

In Verilog, you cannot assign a value to the entire array directly (e.g., data_array = value). Instead, operations must be performed element by element. Also, only one-dimensional arrays were officially supported in early Verilog, so for multidimensional arrays you need Verilog 2001 or SystemVerilog.

4. Using Multidimensional Arrays

Arrays in Verilog simplify design and help organize circuit structures. By using multidimensional arrays, you can efficiently handle more complex data structures.

However, note that older Verilog (IEEE 1364-1995) did not support multidimensional arrays. They were officially introduced in Verilog 2001. For even more flexibility, SystemVerilog is recommended.

Declaring Multidimensional Arrays

Since Verilog 2001, you can define multidimensional arrays by specifying multiple indices for a single variable. The basic syntax is:

reg [7:0] matrix [0:3][0:3];  // Defines a 4×4 matrix of 8-bit elements

This declaration creates a 2D array named matrix, containing 16 elements, each 8 bits wide.

Accessing and Assigning Elements

You can access and assign specific elements of a multidimensional array using indices:

matrix[0][0] = 8'hA5;
matrix[2][3] = 8'd255;

Using for Loops

Multidimensional arrays can be manipulated using nested for loops. Example of initialization:

integer i, j;
always @(posedge clk) begin
    for (i = 0; i < 4; i = i + 1) begin
        for (j = 0; j < 4; j = j + 1) begin
            matrix[i][j] <= 8'd0;
        end
    end
end

Applications of Multidimensional Arrays

• Useful in designs requiring matrix operations or filter processing.
• Can be applied in image processing or digital signal processing (DSP), for pixel-level data handling.
• Used in ROM/RAM block structures and for organizing address-data pairs.

Limitations and Considerations

• Check synthesis tool compatibility, as some tools may not fully support multidimensional arrays.
• Restrictions may apply when combined with instantiations or interfaces.
• Understand differences from SystemVerilog to avoid compatibility issues (explained later).

5. Modeling Memory with Arrays

In Verilog, you can model simple memory structures using arrays. This allows you to describe and simulate storage circuits such as RAM and ROM in a concise and flexible way.

In particular, one-dimensional array-based memory models are frequently used in CPU design and communication systems.

Basic Syntax for Memory Models

The following example represents a simple RAM with 32-bit words and 1024 addresses (0–1023):

reg [31:0] memory [0:1023];  // 32-bit × 1024-word memory

This declaration creates an array named memory, where each index (address) stores a 32-bit word.

Writing to and Reading from Memory

Memory read/write operations using arrays can be described as follows:

// Write operation
always @(posedge clk) begin
    if (we) begin
        memory[addr] <= data_in;
    end
end

// Read operation
assign data_out = memory[addr];

Key points:

• Write operations are synchronous with posedge clk and conditional (controlled by we, write enable).
• Read operations are typically implemented using assign for combinational (asynchronous) reads.

Memory Initialization

For testbenches or initial state setup, you can initialize arrays inside an initial block:

integer i;
initial begin
    for (i = 0; i < 1024; i = i + 1) begin
        memory[i] = 32'd0;
    end
end

You can also load initial values from an external file using $readmemh or $readmemb:

initial begin
    $readmemh("rom_init.hex", memory);  // Initialize from a hex file
end

Practical Use Cases

• Register files in CPUs or microcontrollers
• Behavioral simulation of Block RAM (BRAM) inside FPGAs
• Cache memory behavior verification
• ROM data readout simulation

Points to Note

• As array size increases, simulation time and synthesis resources also grow.
• Choose read timing (synchronous vs. asynchronous) carefully based on design specs and tools.
• When targeting synthesis, follow specific memory inference rules recommended by the tool vendor.

6. Array Enhancements in SystemVerilog

Up to Verilog 2001, array functionality was limited, often making designs cumbersome. To address this, SystemVerilog introduced significant enhancements, enabling more flexible and powerful array handling.

This section explains the three main types of arrays available in SystemVerilog: dynamic arrays, associative arrays, and queues. We will cover their features and use cases.

Dynamic Arrays

Features

• Array size can be changed at runtime.
• Useful when the size is unknown beforehand or variable during execution.

Declaration and Example

int dyn_array[];             // Declare a dynamic array
dyn_array = new[10];         // Initialize with 10 elements
dyn_array[0] = 100;

Use Cases

• Temporary data storage in testbenches
• Managing variable-sized buffers

Associative Arrays

Features

• Indices can be arbitrary values (integers, strings, etc.).
• Works like a hash table.

Declaration and Example

int assoc_array[string];     // Associative array using strings as keys
assoc_array["id_001"] = 42;

Use Cases

• Storing configuration values for parameters
• Looking up values by ID or name

Queues

Features

• Behaves like a FIFO (First-In, First-Out) structure.
• Supports easy insertion and removal, ideal for dynamic data streams.

Declaration and Example

int queue_array[$];          // Declare a queue array

queue_array.push_back(10);   // Add element at the end
queue_array.push_front(5);   // Add element at the front
int val = queue_array.pop_front();  // Remove element from the front

Use Cases

• Temporary data storage (FIFO buffers)
• Event handling and transaction management

Comparison and Usage

Points to Note

• These enhanced arrays are SystemVerilog-only features and not available in Verilog.
• The extent of synthesis support is tool-dependent, and they are mostly used for testbenches.
• If targeting FPGA or ASIC, always check if these features are supported before implementation.

7. Best Practices for Array Operations

When working with arrays in Verilog or SystemVerilog, focusing on efficient and readable coding directly leads to higher-quality hardware designs. This chapter highlights best practices for handling arrays safely and effectively.

Clarify Intent with Comments and Naming

Although arrays are scalable and convenient, it may not always be obvious what each element represents. To avoid confusion, follow these guidelines:

• Use meaningful names for arrays: reg [7:0] sensor_data [0:7];
• Add comments to describe purpose or units:

// Stores 8-bit data from 8 sensors
reg [7:0] sensor_data [0:7];

Be Careful with Loop Boundaries

When using for loops to manipulate arrays, it is critical to define index boundaries correctly:

• Incorrect upper limits → out-of-range access (logic errors or simulator warnings)
• Carefully decide whether to use < or <= for loop termination

Example:

integer i;
always @(posedge clk) begin
    for (i = 0; i < 8; i = i + 1) begin
        sensor_data[i] <= 8'd0;
    end
end

Always Initialize Explicitly

Leaving arrays uninitialized can affect simulation results. This is especially critical for arrays modeling RAM or register banks. Always initialize explicitly:

initial begin
    for (i = 0; i < 256; i = i + 1)
        mem[i] = 32'd0;
end

In SystemVerilog, constructors or foreach loops allow even simpler initialization.

Design Reusable Modules

Array-based designs can adapt flexibly to changes in instance count or bit width. To maximize reusability, consider:

• Using parameter to make array sizes configurable:

parameter DEPTH = 16;
reg [7:0] buffer [0:DEPTH-1];

• Allowing external parameter passing improves module reusability.

Consider Synthesizability

When using arrays, always take synthesis tool compatibility into account:

• Verilog one-dimensional reg arrays: generally synthesizable
• SystemVerilog dynamic/associative/queue arrays: not synthesizable (for simulation only)

Therefore, for synthesizable circuits, stick to traditional reg arrays.

Use Arrays vs. Modules Appropriately

While arrays can reduce code size, overly complex designs may benefit more from splitting functionality into separate modules for maintainability.

• Small, identical operations → arrays with for loops
• Different functionality or large-scale designs → modular and hierarchical design

8. Frequently Asked Questions (FAQ)

When using arrays in Verilog or SystemVerilog, beginners to intermediate users often encounter the same stumbling blocks. Here we address three common questions about “Verilog arrays,” providing practical answers and insights from real-world design experience.

Q1. I get an error when using multidimensional arrays in Verilog. Why?

A1.

This happens because Verilog 1995 and earlier versions of Verilog 2001 either did not support multidimensional arrays at all or only supported them in a limited way.

For example, the following code will cause a compile error in Verilog 1995:

reg [7:0] matrix [0:3][0:3];  // Supported only in Verilog 2001 or later

Solution:

• Ensure your development environment is compliant with Verilog 2001 or later.
• If limitations remain, rewrite using one-dimensional arrays with calculated indices.

reg [7:0] matrix_1d [0:15];  // Flattened 4x4 array, accessed with (i*4 + j)

Q2. If I describe RAM using arrays in Verilog, will it work on hardware?

A2.

Yes. RAM described using arrays in Verilog is supported by most synthesis tools. A common example:

reg [31:0] mem [0:255];  // 32-bit × 256-word RAM

Points to watch:

• The synthesis tool must recognize this description as a block RAM inference.
• Read/write timing (synchronous vs. asynchronous) and access style must follow specific templates or the tool may not infer memory correctly.

Solution:

• Follow the synthesis guide provided by your FPGA/ASIC vendor.
• If behavior differs between simulation and hardware, check logs and debug step by step.

Q3. Can I use SystemVerilog’s dynamic arrays, associative arrays, or queues in actual hardware?

A3.

In general, dynamic arrays, associative arrays, and queues are not synthesizable (simulation only). Although they provide flexible coding, they cannot be directly mapped to hardware logic.

Therefore, these arrays are mainly used for:

• Temporary data storage in testbenches
• Randomization or scoreboard implementations in verification environments
• Complex transaction descriptions

Implementation Notes:

• Any design code using these array types will be ignored or cause errors in synthesis tools.
• If hardware implementation is required, convert them into reg or fixed-length one-dimensional arrays.

9. Conclusion

In this article, we focused on the keyword “Verilog arrays” and explained their usage from the basics to advanced applications. Mastering arrays in circuit design directly contributes to efficiency, readability, and maintainability.

Key Takeaways

• By understanding the basic Verilog data types (reg and wire), you can avoid errors when working with arrays.
• One-dimensional arrays are essential structures for grouping data and modeling memory.
• Multidimensional arrays are supported in Verilog 2001 and later, enabling matrix-style designs.
• SystemVerilog introduces flexible structures such as dynamic arrays, associative arrays, and queues (primarily for simulation and verification).
• By following array-handling best practices (initialization, naming, reusability, synthesis considerations), you can write higher-quality code.

Practical Tips

Arrays are powerful, but they should not be used blindly for everything. When writing synthesizable code or collaborating in teams, always follow constraints and style guides.

SystemVerilog’s advanced array features should be used with simulation in mind, to maximize their benefits. Good designers know how to choose the right structure for the right purpose.

Recommended Next Topics

If you now understand the basics of arrays, we recommend exploring the following related topics:

• Using generate statements for dynamic circuit generation with arrays
• Combining interface with arrays for bus design
• Implementing FIFO, ring buffers, and ROM optimizations using arrays

Mastering arrays is a key first step as a Verilog designer. By deepening your understanding, you will be able to handle increasingly complex circuit designs with confidence.