Sunday, 29 March 2015

Different types of Arrays in SystemVerilog

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 arrayEg: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[] operatorto 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

No comments:

Post a Comment