Logic Design - Packages in SystemVerilog

in STEMGeeks10 months ago (edited)

[Edit of Image1]


Hey it's a me again @drifter1!

Today we continue with the Logic Design series on SystemVerilog in order to talk about Packages.

So, without further ado, let's get straight into it!

Design Hierarchy

In Verilog all data and methods (functions, tasks) are defined in modules. Only system tasks and functions are global and can be accessed from anywhere. Thus, modules contain instances of other modules. But, this module hierarchy can easily becomes complicated, which leads to much time being spent in port list maintenance.

SystemVerilog enhances the hierarchical design introducing the module ports, that we've already discussed. These allow any data type to be passed. Additionally;

  • modules can be nested (module declared within another module)
  • port connections are named far simpler
  • interfaces allow for bundled connections between modules
  • time and precision specs are bound to modules

and then there are also packages, which we will discuss today.


Packages are introduced for sharing common code across multiple modules, programs, interfaces etc. This basically allows code to be re-usable by definition.

Package Definition

Packages are defined within the package and endpackage keywords:

package name;

They can contain parameters, data, types, tasks, functions, sequences, properties, but not assign statements. Variables need to be declared before any initial and always blocks.

Hierarchical definitions are also forbidden, except if they are created within the package or are the cause of importing another package.

Importing Packages

Packages are imported using the import keyword followed by the package name and the scope resolution operator ::, which specifies what to import. Importing everything is as simple as adding a * after that operator.

For example:

import package1::myFunc;
import package2::*;

imports only the function myFunc from package1, and everything from package2.

Definition Collision

If the same definition (identifier) exists in both the top level and the imported package, we are talking about a collision of definitions. From these two the top level definition will be preferred by the simulator. For example, this could mean that the initial value of the top level would be used instead of the package's value for some variable.

In order to "apply" the package's value the package name has to be explicitly mentioned by using the :: operator, as shown below.

value = var;                // use top level definition
value = packageName::var;   // use package definition



  1. https://www.chipverify.com/systemverilog/systemverilog-tutorial
  2. https://www.asic-world.com/systemverilog/tutorial.html


  1. https://www.flickr.com/photos/creative_stock/5227842611

Block diagrams and other visualizations were made using draw.io

Previous articles of the series



  • From Verilog To SystemVerilog → Data Types, Arrays, Structures, Operators and Expressions
  • Control Flow → Additional Procedural Blocks, Loops, Conditional Statements, Functions and Task Features
  • Processes → Fork - Join in Verilog and SystemVerilog, Process Control (wait fork, disable fork)
  • Events → Interprocess Communication, Events (Definition, Triggering, Waiting, Sequencing, Merging, as Arguments)
  • Semaphores and Mailboxes → Semaphores (Creation, Methods), Mailboxes (Definition, Methods)
  • Interfaces (part 1) → Interfaces (Definition, Port and Signal Lists, Instantiation), Modports
  • Interfaces (part 2) → Parameters, Tasks and Functions (Importing, Exporting), Clocking Blocks (Input and Output Skews)
  • Classes (part 1) → Classes (Definition, Constructor Function, Creating Objects, Accessing Class Members, Static and Constant Class Members, Arrays)
  • Classes (part 2) → Copying Objects (Shallow and Deep Copy), Inheritance, Polymorphism, Virtual Methods
  • Classes (part 3) → Parameterized Classes, Out-of-Block Method Declaration, Data Accessibility, Abstract / Virtual Classes
  • Program Blocks → Design and Testbench, Program Block (Reactive Region, Allowed Constructs)

Final words | Next up

And this is actually it for today's post!

Next time we might start covering Constraints...

See Ya!

Keep on drifting!

Posted with STEMGeeks