Modernizing SystemVerilog Integration: Native Support for Structs, Interfaces, and Multidimensional Arrays
Rahul Parashar
Introduction
As more design teams move toward SystemVerilog, we naturally lean on structs, packages, and interfaces to keep signals organized and code readable. The catch, however, has always been the integration phase.
Even with well-structured RTL, tools often forced us to strip away those abstractions and manually wire individual signals. We ended up spending hours flattening connections just to get blocks to talk—an approach that was tedious and practically invited hard-to-find off-by-one errors.
With the latest update to IDS-Integrate, that gap is finally closing. The tool now understands structured connectivity much more deeply. You can define your structs and interfaces once and pass them through the entire hierarchy without breaking them apart. It treats these connections the same way you do in RTL, handling the background wiring and generating the necessary SystemVerilog code automatically.
Handling Complex, Multidimensional Designs
One of the most practical improvements in this update is how it handles multidimensional wiring. In modern SoC design, we aren’t just dealing with single signals; we are managing dozens of similar channels or complex data arrays that need to be routed across multiple blocks.
The tool now supports parameterized structs and multidimensional arrays natively. You can define dimensions using parameters—like data or width—and the tool scales the connections automatically.
Instead of seeing a wall of individual signals at the top level, your generated RTL remains exactly as organized as your architecture. Here is a quick look at how a multidimensional, parameterized struct is defined and used in the generated SystemVerilog:
Example:
package struct_pkg;
parameter data = 8;
parameter width = 16;
// Nested multidimensional array for complex data routing
typedef struct {
logic in_enb [data-1:0];
logic [7:0] in [width-1:0];
} input_struct_t;
typedef struct packed {
logic [width-1:0] [31:0] enb;
logic [7:0] [width/2:0] r [data-1:0][data-3:0];
} output_struct_t;
endpackage
// Clean, structured port in your child module
module child_block (
import struct_pkg::*;
input input_struct_t port_in,
output output_struct_t port_out
);
// Logic stays grouped and readable
endmodule
The Integration Flow
In the past, to make this work, we had to manually “explode” these clean structs into hundreds of individual wires in our integration scripts. Now, the Python flow stays as high-level as the design itself.
When you are working in the top-level script, you don’t need to worry about expanding the specific dimensions of every array inside the struct. You define your package with the parameters once, and the tool understands the hierarchy:
Python Script:
# Define the complex, multidimensional structs with parameters
param_dic = {"data": 8, "width": 16}
inp_struct = ["logic in_enb[data-1:0]", "logic [7:0] in[width-1:0]"]
opt_struct = ["logic [7:0][width/2:0] r [data-1:0][data-3:0]", "logic [width-1:0][31:0] enb"]
soc_create(type="package", name="struct_pkg", struct_def={"input_struct_t": inp_struct, "output_struct_t": opt_struct}, param=param_dic)
# At the top level, connecting a multidimensional port is just a single command
soc_connect(source="top.top_in", dest="u_child.port_in")
soc_connect(source="u_child.port_out", dest="top.top_out")
Even though port_out contains a 3D array and a 2D array, you aren’t writing loops or indexing every single signal. The tool looks at the struct_pkg definition, calculates the widths based on your parameters, and maps everything correctly.
Ultimately, this brings integration closer to how we think as designers. It keeps our top-level scripts incredibly short and easy to audit and our generated RTL readable and reusable. Instead of wasting time shuffling wires, we can keep our signals grouped the way they were intended to be, making the assembly of large designs much more intuitive.
Conclusion
This update brings IDS-Integrate closer to how designers actually work with modern SystemVerilog. Designs stay structured and reusable from start to finish.
With native support for structs, interfaces, and multidimensional connections, integration just feels more natural. Designers can keep signals grouped the way they were intended instead of flattening everything during assembly. This makes wiring clearer, reduces manual effort, and helps avoid small mistakes that usually show up in large designs with repeated channels or shared interfaces.
It’s not a big change in how you use the tool, but it does make everyday integration work simpler and less tedious.