Saturday, 31 August 2013

What is the difference between System Verilog Dynamic Array, Associative Array & Queue and their applications?


Ans: The following is the difference between Dynamic Array, Associative Array & Queue.

Dynamic Array:
  • We use dynamic array when we have no idea about the size of the array during compile time and we have to allocate its size for storage during run time.
  • We basically use this array when we have to store a contiguous or Sequential collection of data.
  • The array indexing should be always integer type.
  • To allocate size of a dynamic array, we have to use new[] operator.
            Example:
               int my_array [];
               initial
                   begin
                         my_array = new[4];                              //Allocated 4 elements
                    end
  • To resize a dynamic array, we have to do as follows:
             Example:              
               initial
                  begin
                       my_array = new[18](my_array);     //Resize the Array and Copy
                  end

  • To know the size of the array, we have to use size() operator.
             Example:
              my_array.size();                    //Returns the current size of the array, my_array as an integer.

  • To delete an element from a dynamic array, we have to use delete() operator.
             Example:
              initial
                  begin
                       my_array.delete();    //All the elements of array, my_array will be deleted.
                   end


Associative Array:
  • It is also allocated during run time.
  • This is the array, where data stored in random fashion.
  • It is used when we don’t have to allocate contiguous collection of data, or data in a proper sequence or index.
  • In associative array, the index itself associates the data. So it is called so.
  • Indexing is not regular, can be accessed using indexing like integer or string type or any scalar. 
Example:
my_array ["name"];           // “name”, Index type is a string
my_array[address];           // address, Index type is an integer (here address is an integer).
my_array[my_class];       // my_class, Index type is a class.
my_array[s_array];          // s_array, Index type is an array.
  • It is better to use associative array, when size of the array is unknown & data space is random or irregular or sparse.
  • Following are the methods associated with Associative array. 
          num()returns the number of entries in the Associative array
Eg: my_array.num()
first()assigns the value of the first index in the Associative array to the given index variable Eg:my_array.first(i);
last()assigns the value of the last index in the Associative array to the given index variable Eg:my_array.last(i);
next() — assigns the value of the next index in the Associative array to the given index variable Eg:my_array.next(i);
prev()assigns the value of the previous index in the Associative array to the given index variable Eg:my_array.prev(i);
delete()removes all the elements in the Associative array.
Eg: my_array.delete(i); If the index is specified, then the element at the specified index “i”is deleted
exists()checks if element exists at the specified index “i” in the Associative array Eg:my_array.exists(i);

 Queue:
  • Queue is a variable size, ordered collection of Homogenous Data.
  • It is flexible, as it is variable in size and analogous to an 1-dimensional Unpacked array that can shrink & grow automatically and can be of size zero.
  • The main advantage of queue over dynamic array is that, we don’t need new[] operator to allocate storage space for a queue.
  • The other advantages of queue over dynamic array is that we can manipulate the queue using various queue methods like: push, pop, delete, insert, size.
Example:
module test_example ;
int my_queue[$] = { 1, 2, 3 };
string s_queue [$] = {"first","second","third","fourth"};
string store;
initial
begin
// Use of the size() method/operator
$display("\n size() operator used");
for (int i = 0 ; i < my_queue.size(); i++ )
$display (my_queue[i]);
$display("\n\n Elements of s_queue is :");
for (int i = 0; i < s_queue.size; i++)
$write(s_queue[i]," ");
// Use of insert() method/operator
s_queue.insert(1,"next"); // Previous element 1 is now turned to element 2.
s_queue.insert(2,"somewhere");
$display("\n\n insert() operator used");
for (int i = 0; i < s_queue.size; i++)
$write(s_queue[i]," ");
// Use of delete() method/operator
s_queue.delete(1); // delete the element 1
s_queue.delete(3); // delete the element 3
$display("\n\n delete() operator used");
for (int i = 0; i < s_queue.size; i++)
$write(string_queue[i]," ");
// Use of pop_front() method/operator (it deletes the front of the queue)
store = s_queue.pop_front();
$display("\n\n pop_front() operator used");
$display(" %s",store);
for (int i = 0; i < s_queue.size; i++)
$write(s_queue[i]," ");
// Use of pop_back() method/operator (it deletes the back of the queue)
store= s_queue.pop_back();
$display("\n\n pop_back() operator used");
$display(" %s",store);
for (int i = 0; i < s_queue.size; i++)
$write(s_queue[i]," ");
// Use of push_front() and push_back() method/operator
s_queue.push_front("in-front");
s_queue.push_back("in-back");
$display("\n\n push_front() and push_back() operator used");
for (int i = 0; i < s_queue.size; i++)
$write(s_queue[i]," \n ");
end
endmodule

Result:
size() operator used
1
2
3

Elements of s_queue[$] is:
first second third fourth

insert() operator used
first next somewhere second third fourth

delete() operator used
first somewhere second fourth

pop_front() operator used
first
somewhere second fourth

pop_back() operator used
fourth
somewhere second

push_front() and push_back() operator used
in-front
somewhere
second
in-back

4 comments: