Fixed Arrays/Static Arrays:#
1) Fixed Arrays Over All Arrays:
- Fixed Arrays execute faster than all other types of arrays (i.e Associative arrays, dynamic arrays, queues) because it will store in uninitialized data segment (bss segment) of memory, so it will consume less simulation time to execute. And the heap is the segment where dynamic, associative and queue memory allocation takes place.
The below figure shows the memory layout.
Figure.1. Memory Layout
- Size is known previously then we can choose fixed arrays over all other types of arrays.
Dynamic Arrays:#
1) Dynamic Arrays Over Fixed Arrays:
- Memories allocated at run time, so memory will not be wasted but in fixed array memories would be wasted when we don’t know the actual size.
- We can easily add elements using new() method but in fixed arrays we can’t add elements after the declaration.
- We can delete entire arrays after allocating the memories to it but in fixed arrays we can’t delete the memories after declaring array.
Note: In fixed arrays, there is no methods like new(),delete().
2) Dynamic Arrays Over Associative Arrays:
- Indexing is in continues manner but in associative arrays it’s non continuous. it’s show in below figure.
Figure.2. continuous and non continuous indexing
- We can find relation between indexing so travelling through arrays with ease using loops but in associative arrays keys are required.
3) Dynamic Arrays Over Queues:
- According to footprint, dynamic array executes faster and it will required less simulation time but queues will required more time to execute.
Figure.3. dynamic array execution time
Figure.4. queue execution time
- Dynamic array used to trace the each and every element in the array using the loops but in queue with pop and push operation. we can’t trace the all element of array using fooreach loop. for pop operation the size of the array is decrement and i is increment and for push operation the size of the array is increment and i is also increment it result in Killing process.
code:
module dynamic;
int dyn [];
initial
begin
dyn = new[8];
dyn = '{2,7,0,6,1,9,9,7};
foreach(dyn[i])begin
$display("verifying the values of each index, dyn[%0d] = %0d", i, dyn[i]);
end
end
endmodule
OUTPUT:
run -all
verifying the values of each index, dyn[0] = 2
verifying the values of each index, dyn[1] = 7
verifying the values of each index, dyn[2] = 0
verifying the values of each index, dyn[3] = 6
verifying the values of each index, dyn[4] = 1
verifying the values of each index, dyn[5] = 9
verifying the values of each index, dyn[6] = 9
verifying the values of each index, dyn[7] = 7
exit
code: using pop operation
`module queue;
int que[$];
initial
begin
que = '{2,7,0,6,1,9,9,7};
foreach(que[i])begin
$display("verifying the values of each index, que[%0d] = %0d", i, que[i]);
que.pop_back();
end
end
endmodule
OUTPUT:
run -all
verifying the values of each index, que[0] = 2
verifying the values of each index, que[1] = 7
verifying the values of each index, que[2] = 0
verifying the values of each index, que[3] = 6
exit
code: using push operation in queue
module queue;
int que[$];
initial
begin
que = '{2,7,0,6,1,9,9,7};
foreach(que[i])begin
$display("verifying the values of each index, que[%0d] = %0d", i, que[i]);
que.push_back(6);
end
end
endmodule
OUTPUT:
`run -all
verifying the values of each index, que[0] = 2
verifying the values of each index, que[1] = 7
verifying the values of each index, que[2] = 0
verifying the values of each index, que[3] = 6
verifying the values of each index, que[4] = 1
verifying the values of each index, que[5] = 9
verifying the values of each index, que[6] = 9
verifying the values of each index, que[7] = 7
verifying the values of each index, que[8] = 6
verifying the values of each index, que[9] = 6
verifying the values of each index, que[10] = 6
verifying the values of each index, que[11] = 6
verifying the values of each index, que[12] = 6
Result reached the maximum of 5000 lines. Killing process.
Execution interrupted or reached maximum runtime.
Associative Arrays:#
1) Advantages of Associative array over all arrays:
- The function exists(input index); method is used in the associative array to find the index element where this method is not used in associative and dynamic array.
code:
module associative;
int id[int];
int name[string];
int value[int];
initial
begin
id = '{4275:25, 4278:12};
name = '{"Dilip":12};
value = '{50000:25};
//check whether the name exist
name.exists("Dilip");
$display("the element exist= %0p", name);
end
endmodule
OUTPUT:
run -all
the element exist= {"Dilip":12}
exit
- In Dynamic array & queue there is no such method like function exists(input index) to find the array element if we use function exists(input index); in dynamic array the following error is occur
Dynamic array:
code:
module dynamic;
int dyn [];
initial
begin
dyn = new[8];
dyn = '{2,7,0,6,1,9,9,7};
dyn.exists(0);
$display("the element of the dyn=%0p", dyn);
end
endmodule
OUTPUT:
-- Compiling module dynamic
** Error (suppressible): (vlog-13276) testbench.sv(7): Could not find field/method name (exists) in 'dyn' of 'dyn.exists'.
** Error (suppressible): (vlog-13276) testbench.sv(7): Could not find field/method name (exists) in 'dyn' of 'dyn.exists.$0'.
End time: 02:35:57 on Sep 03,2022, Elapsed time: 0:00:00
Errors: 2, Warnings: 0
Queue :
code:
module queue;
int que[$];
initial
begin
que = '{2,7,0,6,1,9,9,7};
que.exists(0);
$display("the element of the que=%0p", que);
end
endmodule
OUTPUT:
-- Compiling module queue
** Error (suppressible): (vlog-13276) testbench.sv(6): Could not find field/method name (exists) in 'que' of 'que.exists'.
** Error (suppressible): (vlog-13276) testbench.sv(6): Could not find field/method name (exists) in 'que' of 'que.exists.$0'.
End time: 02:43:56 on Sep 03,2022, Elapsed time: 0:00:00
Errors: 2, Warnings: 0
2) Associative array over dynamic array and queue:
- In Associative array the index type is of any data_type can used but while in dynamic and queue we can’t use different data types for indexing.
code:
module associative;
int id[int];
int name[string];
int value[int];
initial
begin
id = '{4275:25, 4278:12};
name = '{"Dilip":12};
value = '{50000:25};
$display("The id is = {%0p}", id);
$display("The name is = %0p", name);
$display("The value is = %0p", value);
end
endmodule
OUTPUT:
run -all
The id is = {{4275:25} {4278:12} }
The name is = {"Dilip":12}
The value is = {50000:25}
exit
3) Associative array over dynamic array and fixed array:
- We can delete the particular index element in Associative array by using function void delete(input index); but in dynamic and fixed type we can’t use function void delete(input index); to delete the particular index.
code:
module associative;
int id[int];
int name[string];
int value[int];
initial
begin
id = '{4275:25, 4278:12};
name = '{"Dilip":12};
value = '{50000:25};
$display("The id is = {%0p}", id);
$display("The name is = %0p", name);
$display("The value is = %0p", value);
$display("The size of the id is=%0d", id.size());
id.delete(4278);
$display("The size of 'id' after deleting = %0d", id.size());
$display("The id is = {%0p}", id);
end
endmodule
OUTPUT:
run -all
The id is = {{4275:25} {4278:12} }
The name is = {"Dilip":12}
The value is = {50000:25}
The size of the id is=2
The size of 'id' after deleting = 1
The id is = {{4275:25} }
exit
- The Associative array is memory friendly we can store the value of the array in any memory location.
Queues:#
1) Advantages of Queue over all arrays
- In queue the main advantage is push & pop operation.
- The push used to insert the element in to queue.
- The push as two methods function push_back(input element_t); & function push_front(input element_t);
- The pop as two methods function pop_front(); & function pop_back();
code:
`module queue_data_type;
string queue1[$];
initial
begin
queue1 = {"manipal", "banglaore", "udupi"};
$display("\nRemove the array element at first index position of queue1:%p",queue1.pop_front());
$display("\n After removing the 'manipal' from queue1 is :%p", queue1);
$display("\nRemove the array element at last index position of queue1: %p", queue1.pop_back());
$display("\n After removing the 'udupi' from queue1 is :%p", queue1);
queue1.push_front("Yelahanka");
$display("\ninsert the array element at first index position of queue1:output");
$display("\n queue1: %p", queue1);
queue1.push_back("udupi");
$display("\ninsert the array element at last index position of queue1: ouptut");
$display("\n queue1 : %p", queue1);
end
endmodule
OUTPUT:
`run -all
// Remove the array element at first index position of queue1:"manipal"
// After removing the 'manipal' from queue1 is :'{"banglaore", "udupi"}
// Remove the array element at last index position of queue1: "udupi"
// After removing the 'udupi' from queue1 is :'{"banglaore"}
// insert the array element at first index position of queue1:output
// queue1: '{"Yelahanka", "banglaore"}
// insert the array element at last index position of queue1: ouptut
// queue1 : '{"Yelahanka", "banglaore", "udupi"}
exit
2) Advantages of Queue over Dynamic & Associative Array:
- In queue we can insert the element at any index position using the method function insert(index , queue_element);. So we can say inserting is easy. Thus the queue length increases and shrinks even if we remove or add elements from the middle, but in dynamic and associative array we can’t insert the element in the array.
code:
`module queue_data_type;
string queue1[$];
int queue2[$];
initial
begin
queue1 = {"banglaore", "udupi"};
queue1.insert(0, "manipal");
$display("Insert the array element at 0 index position of queue1: {%0p}", queue1);
end
endmodule
OUTPUT:
`run -all
// Insert the array element at 0 index position of queue1: {{manipal} {banglaore} {udupi}}
exit