SystemVerilog Static Variables & Functions

Each class instance normally has its own independent copy of every internal variable and its own separate calls to every method. SystemVerilog's static keyword changes that default for a specific property or method — letting you share a single copy across every instance of a class instead, or call a method without ever needing an object at all.

10 min read | Intermediate Level

What You'll Learn

• The default behavior: every class instance gets its own independent copy of each property
• How a static property becomes one shared copy across every instance instead
• What a static method can and can't access, compared to a regular method
• Why a static method can never access a non-static (per-instance) member

The Default: Each Instance Gets Its Own Copy

Before introducing static, here's the default behavior it changes — each class instance holding its own independent copy of every internal variable:

class Packet;
	bit [15:0] 	addr;
	bit [7:0] 	data;

	function new (bit [15:0] ad, bit [7:0] d);
		addr = ad;
		data = d;
		$display ("addr=0x%0h data=0x%0h", addr, data);
	endfunction
endclass

module tb;
	initial begin
		Packet 	p1, p2, p3;
		p1 = new (16'hdead, 8'h12);
		p2 = new (16'hface, 8'hab);
		p3 = new (16'hcafe, 8'hfc);
	end
endmodule

Each of the class objects p1, p2, p3 has its own addr and data — changing one has no effect on the others.

Output

ncsim> run
addr=0xdead data=0x12
addr=0xface data=0xab
addr=0xcafe data=0xfc
ncsim: *W,RNQUIE: Simulation is complete.

Static Variables

When a variable inside a class is declared static, that variable becomes the only copy shared across every instance of the class. To demonstrate, here's a static counter compared against a normal (non-static) counter, both incremented inside new() so they update every time an object is created:

class Packet;
	bit [15:0] 	addr;
	bit [7:0] 	data;
	static int 	static_ctr = 0;
	int 	ctr = 0;

	function new (bit [15:0] ad, bit [7:0] d);
		addr = ad;
		data = d;
		static_ctr++;
		ctr++;
		$display ("static_ctr=%0d ctr=%0d addr=0x%0h data=0x%0h", static_ctr, ctr, addr, data);
	endfunction
endclass

module tb;
	initial begin
		Packet 	p1, p2, p3;
		p1 = new (16'hdead, 8'h12);
		p2 = new (16'hface, 8'hab);
		p3 = new (16'hcafe, 8'hfc);
	end
endmodule

Output

ncsim> run
static_ctr=1 ctr=1 addr=0xdead data=0x12
static_ctr=2 ctr=1 addr=0xface data=0xab
static_ctr=3 ctr=1 addr=0xcafe data=0xfc
ncsim: *W,RNQUIE: Simulation is complete.

static_ctr is shared between p1, p2, and p3, so it climbs to 3 as each new packet is created. ctr, on the other hand, is not static, so every object gets its own fresh copy — each one starts at 0 and is incremented exactly once inside its own constructor, which is why ctr shows 1 for every single object, never climbing higher.

Declaring a variable static is useful whenever you need to know the total number of objects (like packets) created so far, across the entire testbench, rather than just within one specific object.

Static Functions

A static method follows all the usual class scoping and access rules, with one key difference: it can be called even without any object of the class ever being instantiated. A static method has no access to non-static (per-instance) members, but it can directly access static class properties or call other static methods of the same class. Calling a static method by class name uses the scope resolution operator :::

class Packet;
	static int ctr=0;

   function new ();
      ctr++;
   endfunction

	static function get_pkt_ctr ();
		$display ("ctr=%0d", ctr);
	endfunction

endclass

module tb;
	Packet pkt [6];
	initial begin
		for (int i = 0; i < $size(pkt); i++) begin
			pkt[i] = new;
		end
		Packet::get_pkt_ctr(); 	// Static call using :: operator
		pkt[5].get_pkt_ctr(); 	// Normal call using instance
	end
endmodule

Output

ncsim> run
ctr=6
ctr=6
ncsim: *W,RNQUIE: Simulation is complete.

Both calls — Packet::get_pkt_ctr() and pkt[5].get_pkt_ctr() — print the exact same value, because there's only one shared ctr regardless of which syntax is used to reach it. Calling a static method through a specific instance doesn't give it any special access to that instance's own data — it's still the same static method operating on the same shared state either way.

Now let's add a non-static member called mode and try to reference it from the static function:

class Packet;
	static int ctr=0;
   bit [1:0] mode;

   function new ();
      ctr++;
   endfunction

	static function get_pkt_ctr ();
		$display ("ctr=%0d mode=%0d", ctr, mode);
	endfunction
endclass

This isn't allowed, and results in a compile-time error:

                $display ("ctr=%0d mode=%0d", ctr, mode);
                                                      |
ncvlog: *E,CLSNSU (static-function.sv,10|40): A static class method cannot access non static class members.

This makes sense once you consider that a static method can be called with no object ever having been created — get_pkt_ctr() has no specific instance to pull mode from, since mode only exists once an actual object exists to hold it.

A static method can never be declared virtual either — the same restriction covered for constructors in SystemVerilog Class Constructor. Virtual dispatch depends on an object's actual runtime type, but a static method call may not even involve an object at all.

Common Beginner Mistakes

class Packet;
	bit [15:0] 	addr;
	bit [7:0] 	data;
	static int 	static_ctr = 0;
	static int 	total_bytes = 0;

	function new (bit [15:0] ad, bit [7:0] d);
		addr = ad;
		data = d;
		static_ctr++;
		total_bytes++;    // 1 byte per packet, for simplicity
	endfunction

	static function report ();
		$display ("Packets created: %0d, Total bytes: %0d", static_ctr, total_bytes);
	endfunction
endclass

module tb;
	initial begin
		Packet 	p1, p2, p3;
		p1 = new (16'hdead, 8'h12);
		p2 = new (16'hface, 8'hab);
		p3 = new (16'hcafe, 8'hfc);

		Packet::report ();
	end
endmodule