The difference between static and automatic variables


We were discussing the difference between static and automatic variables in a SystemVerilog class.

Whether a variable is static and automatic is called its lifetime. IEEE 1800-2012 gives the syntax for a variable declaration:

data_declaration10 ::= [ const ] [ var ] [ lifetime ] data_type_or_implicit list_of_variable_decl_assignments ; | type_declaration

A static variable exists for the whole simulation; an automatic variable exists only for the lifetime of the task, function or block - they are created when the task, function or block is entered and destroyed when it is left.  This has consequences:
  • An automatic variable is initialized every time the task, function or block containing it is entered. When you think about it, how could it be any other way? The variable didn't exist until the task, function or block was entered. A static variable already exists before the task, function or block is entered and so is not initialized when that task, function or block is entered.
Here is some code that illustrates the difference between static and automatic variables:

module M; 
  initial begin
    static    int os_count_s = 1;
    automatic int os_count_a = 1;
    do
      begin
        static    int is_count_s = 1;
        automatic int is_count_a = 1;
        #1ns $display("os_count_s = ", os_count_s);
             $display("os_count_a = ", os_count_a);
             $display("is_count_s = ", is_count_s);
             $display("is_count_a = ", is_count_a);
        os_count_s += 1;
        os_count_a += 1;
        is_count_s += 1;
        is_count_a += 1;
      end
    while ($time < 10ns);
  end
endmodule       

https://www.edaplayground.com/x/4yxv

If we run this code (eg on EDA Playground) then we see that is_count_a the automatic variable inside the loop is constantly re-initialized to 1, whereas the static variable inside the loop - is_count_s - is only initialized once (at time zero). We also see that the behavior of the variables declared outside the loop ( os_count_s and os_count_a ) is identical:

os_count_s = 1
os_count_a = 1
is_count_s = 1
is_count_a = 1
os_count_s = 2
os_count_a = 2
is_count_s = 2
is_count_a = 1
os_count_s = 3
os_count_a = 3
is_count_s = 3
is_count_a = 1
os_count_s = 4
os_count_a = 4
is_count_s = 4
is_count_a = 1
os_count_s = 5
os_count_a = 5
is_count_s = 5
is_count_a = 1
os_count_s = 6
os_count_a = 6
is_count_s = 6
is_count_a = 1
os_count_s = 7
os_count_a = 7
is_count_s = 7
is_count_a = 1
os_count_s = 8
os_count_a = 8
is_count_s = 8
is_count_a = 1
os_count_s = 9
os_count_a = 9
is_count_s = 9
is_count_a = 1
os_count_s = 10
os_count_a = 10
is_count_s = 10
is_count_a = 1
  
A customer asked me about this. I didn't know the answer, so I wrote a few lines of code on EDA Playground. EDA Playground is great for that, because it's always on. You don't have to queue for licences, wait for EDA tools to start, create new files, fire up editors...

Comments

Post a Comment

Popular posts from this blog

Bit Width Casting in SystemVerilog

Image
I must have taught SystemVerilog more than 20 times. My customers this week are privileged: they are the first to be taught after I have thought of a use for SystemVerilog bit width casting : in Verilog (and hence SystemVerilog), the simulator (and hence the synthesiser) must decide how many bits to use when calculating an arithmetic expression. This     logic [7:0] A, B, F;     F = (A * B) >> 8; is an example of a so-called context sensitive expression . With a context sensitive expression, the simulator looks at the widths of the operands (to the right of the assignment operator) and the result (to its left) and finds the widest. It then uses this as the number of bits to use in the calculation. So, in the example above, the simulator will look at the widths of A , B and F , discover that they are all 8, and so will do 8-bit arithmetic. (So, it is highly likely that the result of (A * B) will be truncated, because the result of the multiplication will be truncated to
Read more

How to convert a std_logic_vector to a hex string?

I was asked how to easily convert a std_logic_vector to a hex string . This is easy: there's a procedure in the ieee.std_logic_textio package caled hwrite which does most of the hard work for us. The ieee.std_logic_textio package is an add on to the std.textio package, which enables std_logic and associated types to be written to files (you need both packages to do this). Both packages first write to a variable of type line , which is declared in the textio package. The line type is an access type , which points to a string ; this is a line of code from the textio package: type line is access string;         So, let's write a function to convert a std_logic_vector to a string . Our input is a std_logic_vector and our return value is a string : function to_hstring (SLV : std_logic_vector) return string is Notice that both the function input and the return type are unconstrained - they are arrays with no bounds. This is legal for function inputs and return type
Read more

Can you add/remove more than 1 item from a queue?

Can you add more than one item to a SystemVerilog queue using the concatenation operator? Yes, you can. Here's some code: module M;     initial begin     // Here's a queue, initialised with 3 members. (And a maximum     // index of 8 - more on that story later).     int i, numbers[$:8] = {1,2,3};         // Let's add a member to the front and another to the back     // using concatenation.       numbers = {numbers, 4};      $display("numbers= %p", numbers);     numbers = {0, numbers};      $display("numbers= %p", numbers);         // I told you you couldn't do this. I don't know where I got     // that idea from. (I do remember trying and it not working).     // Anyway, it works.       numbers = {numbers, 5, 6};   $display("numbers= %p", numbers);     numbers = {-2, -1, numbers}; $display("numbers= %p", numbers);         // We know we can do this.     numbers = numbers[1:$];      $display("numbers= %p", number
Read more