Pure vs impure functions in VHDL - Hands-On Comparison

Pure vs Impure Functions in VHDL

📖 Scenario: You are designing a simple digital circuit in VHDL. You want to understand the difference between pure and impure functions by creating examples of each. This will help you write better VHDL code for your projects.

🎯 Goal: Build two VHDL functions: one pure function that calculates the square of a number, and one impure function that uses a global variable to add an offset to a number. Then, observe their behavior in a testbench.

📋 What You'll Learn

Create a pure function called square that returns the square of an integer input.

Create an impure function called add_offset that adds a global offset variable to an integer input.

Declare a global variable offset of type integer.

Write a simple testbench process that calls both functions with the input value 4.

Print the results of both function calls.

💡 Why This Matters

🌍 Real World

In digital design, pure functions are used for predictable calculations without side effects, while impure functions can access shared state or hardware signals.

💼 Career

Understanding pure vs impure functions in VHDL is important for FPGA and ASIC designers to write clean, maintainable, and testable hardware description code.

1

Create a pure function to calculate square

Write a pure function called square that takes an integer n and returns n * n.

VHDL

-- Your code here

Hint

Remember, pure functions in VHDL do not read or write any global variables and always return the same output for the same input.

2

Declare a global variable and impure function

Declare a global variable called offset of type integer initialized to 3. Then write an impure function called add_offset that takes an integer n and returns n + offset.

VHDL

library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;

package math_pkg is
    pure function square(n : integer) return integer is
    begin
        return n * n;
    end function;

    -- Your code here

Hint

Impure functions can read global variables like offset. Use the keyword impure before the function.

3

Write a testbench process to call both functions

Write a VHDL process called test_process that calls square(4) and add_offset(4) and stores the results in signals sq_result and offset_result of type integer.

VHDL

library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;

package math_pkg is
    pure function square(n : integer) return integer is
    begin
        return n * n;
    end function;

    impure function add_offset(n : integer) return integer is
    begin
        return n + offset;
    end function;

    shared variable offset : integer := 3;
end package math_pkg;

entity testbench is
end entity;

architecture behavior of testbench is
    signal sq_result : integer := 0;
    signal offset_result : integer := 0;
begin
    test_process : process
    begin
        -- Your code here
    end process test_process;
end architecture behavior;

Hint

Use signal assignments inside the process to store function results.

4

Print the results of both functions

Add a print statement inside the test_process process to display the values of sq_result and offset_result using report statements.

VHDL

library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;

package math_pkg is
    pure function square(n : integer) return integer is
    begin
        return n * n;
    end function;

    impure function add_offset(n : integer) return integer is
    begin
        return n + offset;
    end function;

    shared variable offset : integer := 3;
end package math_pkg;

entity testbench is
end entity;

architecture behavior of testbench is
    signal sq_result : integer := 0;
    signal offset_result : integer := 0;
begin
    test_process : process
    begin
        sq_result <= math_pkg.square(4);
        offset_result <= math_pkg.add_offset(4);
        report "Square result: " & integer'image(sq_result);
        report "Offset result: " & integer'image(offset_result);
        wait;
    end process test_process;
end architecture behavior;

Hint

Use report statements to print messages in VHDL testbenches. Wait some time before reporting to allow signals to update.

Practice

1. Which statement best describes a pure function in VHDL?

easy

A. It always returns the same output for the same inputs and does not modify any external signals.

B. It can modify signals outside its scope and may return different outputs for the same inputs.

C. It only reads external signals but does not modify them.

D. It is a function that uses variables inside a process.

Solution

1. Step 1: Understand pure function behavior

   A pure function in VHDL must always return the same result for the same inputs and cannot change any external signals or variables.

2. Step 2: Compare options with definition

   It always returns the same output for the same inputs and does not modify any external signals. matches this definition exactly, while others describe impure or unrelated behaviors.

3. Final Answer:

   It always returns the same output for the same inputs and does not modify any external signals. -> Option A

4. Quick Check:

   Pure function = consistent output, no side effects [OK]

Hint: Pure means no side effects and consistent output [OK]

Common Mistakes:

• Confusing pure with impure functions
• Thinking pure functions can modify signals
• Assuming pure functions can read external signals

2. Which of the following is the correct way to declare a pure function in VHDL?

easy

A. procedure add(a: in integer; b: in integer);

B. function add(a: integer; b: integer) return integer is pure;

C. function add(a: integer; b: integer) return integer is impure;

D. function add(a: integer; b: integer) return integer;

Solution

1. Step 1: Recall VHDL function declaration syntax

   In VHDL, to declare a pure function explicitly, you add the keyword pure after the function signature.

2. Step 2: Identify correct syntax

   function add(a: integer; b: integer) return integer is pure; correctly uses is pure; to declare a pure function. The procedure declaration is not a function, function add(a: integer; b: integer) return integer is impure; declares an impure function, and function add(a: integer; b: integer) return integer; lacks purity specification.

3. Final Answer:

   function add(a: integer; b: integer) return integer is pure; -> Option B

4. Quick Check:

   Pure function declaration includes 'is pure;' [OK]

Hint: Pure functions use 'is pure;' in declaration [OK]

Common Mistakes:

• Omitting 'pure' keyword for pure functions
• Confusing procedures with functions
• Using 'impure' when pure is needed

3. Consider this VHDL function:

function get_value(x: integer) return integer is
  variable count: integer := 0;
begin
  count := count + 1;
  return x + count;
end function;

What is true about this function?

medium

A. It is impure because it uses a variable that changes each call.

B. It is impure because it modifies an external signal.

C. It is impure because it uses variables inside a function.

D. It is a pure function because it returns a value based on input only.

Solution

1. Step 1: Analyze variable usage inside function

   The local variable count is initialized to 0 each time the function is called, incremented to 1, and x + count always returns x + 1 for the same x.

2. Step 2: Determine purity based on output consistency

   Same inputs always produce the same output with no external modifications, making it pure. The claim about a changing variable ignores reinitialization, using variables inside is allowed, and there are no external signals.

3. Final Answer:

   It is a pure function because it returns a value based on input only. -> Option D

4. Quick Check:

   Local variables reinitialized each call = pure [OK]

Hint: Local variables reset each call, pure function [OK]

Common Mistakes:

• Thinking local variables make function impure
• Confusing external signals with local variables
• Believing the function output changes across calls

4. This VHDL function is intended to be pure:

function multiply(a: integer; b: integer) return integer is pure;
begin
  result := a * b;
  return result;
end function;

What is the error in this code?

medium

A. The function cannot have parameters.

B. The function should be declared impure because it modifies result.

C. The function uses an undeclared variable result.

D. The function lacks a return statement.

Solution

1. Step 1: Check variable declarations inside function

   The function uses result without declaring it as a variable or signal inside the function.

2. Step 2: Understand VHDL variable scope rules

   All variables must be declared before use. Since result is undeclared, this causes a compilation error.

3. Final Answer:

   The function uses an undeclared variable result. -> Option C

4. Quick Check:

   All variables must be declared before use [OK]

Hint: Declare all variables before using them [OK]

Common Mistakes:

• Assuming implicit variable declaration
• Confusing pure/impure with variable declaration errors
• Ignoring missing return statements

5. You want to create a function in VHDL that returns the current value of a global signal clk_count and increments it each call. Which is true about this function?

hard

A. It must be declared impure because it reads and modifies external signals.

B. It can be pure if it only returns the value without incrementing.

C. It can be pure if it uses a local variable to track increments.

D. It must be a procedure, not a function.

Solution

1. Step 1: Understand function interaction with external signals

   Reading and modifying a global signal clk_count means the function has side effects and depends on external state.

2. Step 2: Determine purity based on side effects

   Because the function changes external data, it cannot be pure and must be declared impure.

3. Final Answer:

   It must be declared impure because it reads and modifies external signals. -> Option A

4. Quick Check:

   Modifying external signals means impure function [OK]

Hint: Modifying external signals requires impure functions [OK]

Common Mistakes:

• Thinking local variables can replace external signal changes
• Assuming functions can modify signals without impure keyword
• Confusing functions with procedures for side effects