@shraddha_pawankar Date : 6/8/23

Codes on TASK AND FUNCTION

Q.1) How do you define a task in Verilog?

In Verilog, a task is a construct used to define a reusable block of procedural code that can
contain multiple statements and can have input/output arguments.

They are commonly used for behavioral modeling and organizing complex procedures.

Syntax:

task task_name;

// Local variable declarations

// Procedural statements

Endtask

EX: module tb;

task display();

$display("This is task");

endtask

initial

begin

display();

end

endmodule

OUTPUT : # KERNEL: This is task

https://edaplayground.com/x/8f95

Q.2) How do you define a function in Verilog?

@shraddha_pawankar Date : 6/8/23

In Verilog, a function is a construct used to define a reusable block of procedural code that
can take input arguments and return a value.

module tb;

int x;

function int sum(input int a,b);

sum=a+b;

$display("a=%0d b=%0d sum=%0d",a,b,sum);

endfunction

initial begin

x= sum(10,20);

$display("x=%0d",x);

end

endmodule

OUTPUT: # KERNEL: a=10 b=20 sum=30

# KERNEL: x=30

https://edaplayground.com/x/p_RU

Q.3) Can a task return a value? If yes, how?

NO task cannot return any value

In Verilog, tasks cannot return a value directly, but you can achieve a similar effect by using
an output argument.

By passing a variable as an output argument to the task, you can modify the value of that
variable within the task, effectively returning a value.

EX:

module testbench;

// Task to calculate the square of a number and return the result through an output argument

task calculate_square(input int num, output int squared_num);

begin

squared_num = num * num;

end
@shraddha_pawankar Date : 6/8/23

endtask

initial begin

int input_num = 5;

int squared_num;

// Call the task to calculate the square and get the result through the output argument

calculate_square(input_num, squared_num);

$display("The square of %d is %d", input_num, squared_num);

end

endmodule

https://edaplayground.com/x/GE3U

Que 4) Can a function modify input arguments? If yes, how?

No, in Verilog, a function cannot modify input arguments directly.

The input arguments of a function are treated as read-only, and any attempt to modify them
inside the function will result in a compile-time error.

If you need to modify variables or perform any procedural actions, you should use a task
instead of a function.

Q.5) Can tasks and functions call each other in Verilog?

No, in Verilog, tasks and functions cannot directly call each other. A task can call another
task, and a function can call another function, but a task cannot call a function, and a
function cannot call a task.

EX:

module tb;

task display();

$display("This is task");

endtask
@shraddha_pawankar Date : 6/8/23

function int add(input int num);

return num+1;

endfunction

initial begin

int num=2;

int result;

result=add(num);

$display("num=%0d result=%0d",num,result);

display();

end

endmodule

OUTPUT :
# KERNEL: num=2 result=3
# KERNEL: This is task
https://edaplayground.com/x/M64F

Q 6) How do you pass arguments to a task in Verilog?

In Verilog, you can pass arguments to a task using input and/or output arguments. Input
arguments are used to pass data into the task, and output arguments are used to pass data
out of the task.

Example :

module tb;

task multiply(input int a,input int b,output int out);//argument

begin

out=a*b;

$display("a=%0d b=%0d out=%0d",a,b,out);

end
@shraddha_pawankar Date : 6/8/23

endtask

initial begin

int a=2;

int b=3;

int out;

multiply(a,b,out);

end

endmodule

OUTPUT: # KERNEL: a=2 b=3 out=6

https://edaplayground.com/x/HMfg

Q 7) What are the different types of arguments that can be passed to tasks and
functions?

Scalar arguments: These are single values of basic data types such as int , bit , logic , reg ,
byte , shortint , longint , time , etc.

Vector arguments: These are arrays of basic data types. They can be passed as individual
vectors or as packed and unpacked arrays.

User-defined data types: You can pass variables or objects of user-defined data types such as
structures, unions, enumerated types, and classes.

Q.8) Can tasks and functions have local variables in Verilog?

Yes, both tasks and functions in Verilog can have local variables. Local variables are variables
declared within the scope of the task or function and are accessible only within that specific
task or function.

They are useful for storing temporary values or intermediate results during the execution of
the task or function.

module tb;

task display();

int x; //local variable

@shraddha_pawankar Date : 6/8/23

begin

x=10;

$display("value of x=%0d",x);

end

endtask

function int my_func();

int y;//local variable

begin

y=15;

return y;

end

endfunction

initial begin

int result=my_func();

$display("value of result=%0d",result);

display();//calling task

end

endmodule

output :
# KERNEL: value of result=15
# KERNEL: value of x=10

https://edaplayground.com/x/Uh2n

Q 9) How do you call a task in Verilog?

the syntax to call a task:

task_name;

Or with arguments:

task_name(arg1, arg2, ...);

@shraddha_pawankar Date : 6/8/23

Q.10) How do you call a function in Verilog?

the syntax to call a function:

result_variable = function_name;

Or with arguments:

result_variable = function_name(arg1, arg2, ...);

Q.11) Explain the difference between task and function calls using the "#" operator and
without it.

Task call without "#" operator:

When you call a task without the "#" operator, it executes immediately, meaning it starts
executing the procedural statements inside the task without any delay.

Task call with "#" operator:

When you call a task with the "#" operator, it schedules the task to execute after the
specified time delay.

Function call without "#" operator:

Function calls do not support the "#" operator. Functions are intended to be purely
functional and should not introduce any time delay.

Example:

module tb;

task task_without_delay();

begin

$display("without delay at time %0t",$time);

end

endtask

task task_with_delay();

begin

#10;

$display("with delay at time %0t",$time);

end

endtask
@shraddha_pawankar Date : 6/8/23

/*function void my_function_with_delay();

begin

#20

$display("Function: with delay at time %0t",$time);

end

endfunction*/

//output:"The ""my_function_with_delay"" function cannot contain time-controlled

statements."

function void my_function_without_delay();

begin

$display("Function: without delay at time %0t",$time);

end

endfunction

initial begin

//my_function_with_delay();

my_function_without_delay();

task_without_delay();

task_with_delay();

end

endmodule

OUTPUT : # KERNEL: Function: without delay at time 0

# KERNEL: without delay at time 0
# KERNEL: with delay at time 10

https://edaplayground.com/x/M658

Q 12) Can tasks and functions have their own modules and port connections?
@shraddha_pawankar Date : 6/8/23

No, tasks and functions in Verilog cannot have their own modules and port connections.
Tasks and functions are not physical entities in the design;

they are purely behavioral constructs used for procedural modeling, calculations, and
organization of code.

A module is a structural construct in Verilog that represents a hardware component and

contains port connections to interface with other modules or the testbench

On the other hand, tasks and functions are used for modeling behavior within a module or
testbench, but they do not have their own hierarchy, port connections, or physical
instantiation.

Q 13) How do you pass strings to tasks and functions in Verilog?

In Verilog, you can pass strings to tasks and functions using string-type arguments. String-
type arguments allow you to pass strings as input to tasks and functions for processing and
manipulation.

EX:

module tb;

// Task to display a string

task display_string(input string message);

begin

$display("Message from task=%0s",message);

end

endtask

// Function to concatenate two strings

function string concatenated_strings(input string str1,input string str2);

begin

return {str1," ",str2};

end

endfunction

initial begin
@shraddha_pawankar Date : 6/8/23

string msg="Hello";

string name="JOHN";

string result;

result=concatenated_strings(msg,name);//calling function

$display("concatenated string=%0s",result);

display_string(name);//calling task

end

endmodule

Output :
# KERNEL: concatenated string=Hello JOHN
# KERNEL: Message from task=JOHN

https://edaplayground.com/x/dtGM

Q 14) What happens if a task or function has no "return" statement?

If a task or function in Verilog has no "return" statement, it will still execute normally, but a
default value will be returned for functions, and no value will be returned for tasks.

Task with no "return" statement:

module tb;

task my_task;

begin

$display("Executing my_task");

end

endtask

initial begin

my_task;

end

endmodule
@shraddha_pawankar Date : 6/8/23

Output : # KERNEL: Executing my_task

In this example, the my_task does not have a "return" statement. When it is called from the
initial block, it will execute the $display statement and print "Executing my_task" to the
console.

https://edaplayground.com/x/TcU2

Function with no "return" statement:

If a function does not have a "return" statement, it will still execute the procedural
statements within it, but it will return a default value based on its return type.

For numeric return types, the default value is usually 0,

and for string return types, the default value is an empty string ("").

Example :

module tb;

function int my_function();

begin

$display("Executing my_function");

//no return statement

end

endfunction

initial begin

int result=my_function();

$display("Result of my_function=%0d",result);

end

endmodule

OUTPUT : # KERNEL: Executing my_function

https://edaplayground.com/x/jpqb
@shraddha_pawankar Date : 6/8/23

Q 15) Explain the difference between tasks and functions for synthesizable and non-
synthesizable code.

The main difference between tasks and functions in Verilog lies in their usage and behavior,
which affects their synthesizability.

Tasks are used for procedural operations and do not produce a return value, while functions
are used for computations and calculations and must return a value.generally non-
synthesizable, while functions can be both synthesizable and non-synthesizable.

Q 16) Can tasks and functions have different access modifiers like "static," "protected,"
or "local"?

In Verilog, tasks and functions do not have access modifiers like "static," "protected," or
"local" as seen in other programming languages.

Access modifiers are typically used to control the visibility and accessibility of members
within classes or objects in object-oriented programming languages.

Verilog, being a hardware description language, does not support the object-oriented
programming paradigm, and as a result, access modifiers are not applicable to tasks and
functions.

In Verilog, tasks and functions are global in nature, meaning they can be called and accessed
from any part of the module or testbench in which they are defined, regardless of the
hierarchical level. There are no access restrictions based on scope or visibility.

Example

module my_module;

// This task is accessible from any part of the module and its testbench

task my_task;

// Task body with procedural statements

endtask

// This function is also accessible from any part of the module and its testbench

function int my_function;

// Function body with procedural statements

endfunction

initial begin
@shraddha_pawankar Date : 6/8/23

// Tasks and functions can be called from any procedural block within the module or
testbench

my_task;

int result = my_function;

end

endmodule

Q 17) How do you handle functions with multiple return statements?

In Verilog, functions can have multiple return statements to return different values based on
different conditions or paths within the function.

Example:

module tb;

function int absolute_value(input int x);

if(x>=0)

return x;

else

return -x;

endfunction

initial begin

int x1=5;

int x2=-8;

int result_1;

int result_2;

result_1=absolute_value(x1);

result_2=absolute_value(x2);

$display("Absolute value of %0d is %0d ",x1,result_1);

@shraddha_pawankar Date : 6/8/23

$display("Absolute value of %0d is %0d ",x2,result_2);

end

endmodule

Output: # KERNEL: Absolute value of 5 is 5

# KERNEL: Absolute value of -8 is 8

https://edaplayground.com/x/M66M

Q 18) Explain the usage of the "disable" statement with tasks and functions.

In Verilog, the "disable" statement is used to stop the execution of a specific task or function
that is currently active.

It is typically used in combination with the "fork-join" construct, where multiple tasks or
functions are executed concurrently using the "fork" keyword.

The "disable" statement allows you to terminate a particular task or function before it
completes its execution.

SYNTAX

disable task_name;

disable function_name;

Example:

module tb;

task count_numbers(input int N);

begin

for(int i=0;i<=N; i++) begin

$display("count=%0d",i);

#1;

end

end

endtask
@shraddha_pawankar Date : 6/8/23

initial begin

fork

count_numbers(10);

disable count_numbers;

join

end

endmodule

OUTPUT : # KERNEL: count=0

https://edaplayground.com/x/fYfx

Q 19) Can tasks and functions have multiple levels of hierarchy?

No, tasks and functions in Verilog cannot have multiple levels of hierarchy. They are not
hierarchical constructs and do not define modules or submodules.

Tasks and functions are procedural constructs used for code organization and calculations
within a module or testbench, but they do not create any hierarchical relationships.

Hierarchical relationships in Verilog are established using modules, which can contain other
modules, tasks, and functions, forming a hierarchy of design components.

Tasks and functions are typically defined within a module or at the testbench level and are
used to perform procedural operations within that scope.

Q 20) How do you use the "void" keyword in tasks and functions in Verilog?

In Verilog, the "void" keyword is used to indicate that a task or function does not return any
value.

It is used as a return type for tasks and functions that do not have a return statement or do
not need to produce a result.

Void task:
task task_name;
// Task body with procedural statements
// No return statement needed
endtask

Void function:

function void function_name;

@shraddha_pawankar Date : 6/8/23

// function body with procedural statements

// no return statement needed

endfunction

Example :

module tb;

task display_message;

begin

$display("Hello from task");

//no return statement

end

endtask

//void function

function void show_notification;

begin

$display("This is a notification");

//no return statement

end

endfunction

initial begin

display_message;

show_notification;

end

endmodule
@shraddha_pawankar Date : 6/8/23

# KERNEL: Hello from task

# KERNEL: This is a notification

https://edaplayground.com/x/hhnV

Q 21) How do you use the "wait" statement inside tasks and functions?

In Verilog, the "wait" statement is used inside a task or function to introduce a delay in
simulation time.

It suspends the execution of the task or function for a specified amount of time, allowing
other processes in the simulation to proceed.

The "wait" statement is typically used in testbenches to model time-dependent behavior and
control the simulation flow.

Syntax:

task task_name;

// Task body with procedural statements

wait (time_expression);

endtask

function return_type function_name;

// Function body with procedural statements

wait (time_expression);

return value; // The function must have a return statement

endfunction

The "time_expression" in the "wait" statement can be a constant value, a variable, or an

expression that evaluates to a time value.

Q 22) What is the purpose of "automatic" keyword in tasks and functions?

The "automatic" keyword in Verilog is used to declare local variables inside a task or function.

When you use the "automatic" keyword to declare a variable, it indicates that the variable
has a local scope and is local to the task or function where it is defined.

It is a way to create temporary variables that are only valid within the context of the task or
function and are not visible outside of it.

The purpose of the "automatic" keyword is to allow tasks and functions to have their own
local data, which is separate from any data declared at the module or testbench level.
@shraddha_pawankar Date : 6/8/23

This helps in organizing code and prevents unintended side effects caused by using global
variables.

Automatic variable in a task:

task task_name;
automatic data_type variable_name1, variable_name2, ...;
// Task body with procedural statements using the local variables
endtask

Automatic variable in a function:

function return_type function_name;

automatic data_type variable_name1, variable_name2, ...;

// Function body with procedural statements using the local variables

// Must have a return statement

Endfunction

Example :

module tb;

task my_task;

automatic int a=5;

automatic int b;

automatic int c;

b=a+10;

c=b+20;

$display("a=%0d b=%0d c=%0d",a,b,c);

endtask

function increment();

automatic int x;
@shraddha_pawankar Date : 6/8/23

x++;

$display("x=%0d",x);

endfunction

initial begin

my_task;

increment();

end

endmodule

OUTPUT : # KERNEL: a=5 b=15 c=35

# KERNEL: x=1

https://edaplayground.com/x/8wXG

Q 23) How do you use the "automatic" keyword with arrays in tasks and functions?

To use the "automatic" keyword with arrays in tasks and functions, you simply declare the
array with the "automatic" keyword before the data type and variable name.

This allows you to create local arrays that are specific to the task or function and have a local
scope, making them independent of any other arrays defined at higher levels in the module
or testbench.

Automatic array in a task:

task task_name;

automatic data_type array_name[size];

// Task body with procedural statements using the local array

Endtask

Automatic array in a function:

function return_type function_name;

automatic data_type array_name[size];

// Function body with procedural statements using the local array

// Must have a return statement

Endfunction
@shraddha_pawankar Date : 6/8/23

Example :

module testbench;

// Task to process an array using automatic arrays

task process_array;

automatic int data[4] = '{1, 2, 3, 4};

automatic int result[4];

// Perform some operations with local automatic arrays

for (int i = 0; i < 4; i++)

result[i] = data[i] * 2;

$display("Input array: %p", data);

$display("Result array: %p", result);

endtask

initial begin

// Call the task

process_array;

end

endmodule

OUTPUT : # KERNEL: Input array: '{1, 2, 3, 4}

# KERNEL: Result array: '{2, 4, 6, 8}

https://edaplayground.com/x/M6CV

Q 23) Example of task inside the function in verilog

In Verilog, it is not directly possible to define a task inside a function. Tasks and functions are
separate procedural constructs, and they cannot be nested within each other in the language
syntax.
@shraddha_pawankar Date : 6/8/23

However, you can call a task from within a function, effectively achieving a similar result.

Ex:

module tb;

task display();

begin

$display("TASK:Hello from task");

end

endtask

function void function_with_task;

begin

$display("Function : start of function with task");

display();

$display("Function : End of function_with_task");

end

endfunction

initial begin

function_with_task;

end

endmodule

output : ERROR VCP2802 "Function cannot enable a task." "testbench.sv" 14 14

https://edaplayground.com/x/ppb4

Q 24) Example of task inside the function in verilog

module tb;
@shraddha_pawankar Date : 6/8/23

function void display();

begin

$display("Function : start of function with task");

$display("Function : End of function_with_task");

end

endfunction

task task_inside_function();

begin

$display("TASK:Hello from task");

display();

end

endtask

initial begin

task_inside_function();

end

endmodule

OUTPUT : # KERNEL: TASK:Hello from task

# KERNEL: Function : start of function with task
# KERNEL: Function : End of function_with_task

https://edaplayground.com/x/M6Cf