Swap Two Registers in Verilog: With and Without a Temporary Register

Welcome to another Verilog tutorial on VLSI 360! Today, we’re tackling a classic coding problem: Write Verilog code to swap contents of two registers with and without a temporary register. This challenge tests your understanding of Verilog assignments and arithmetic operations, which are key for VLSI design. We’ll explore multiple methods, provide clear code examples, and explain each approach in a beginner-friendly way. Let’s get started!

---

Question: Write Verilog code to swap contents of two registers with and without a temporary register?

Understanding the Problem

We need to swap the values of two registers, a and b, in Verilog. Initially, a = 100 and b = 200. After swapping, a should be 200 and b should be 100. We’ll solve this in two ways:

• With a Temporary Register: Use an extra register to hold one value during the swap.
• Without a Temporary Register: Use alternative methods like non-blocking assignments, arithmetic operations, or bitwise operations.

Approach to Solve the Problem

We’ll explore four methods:

1. With a Temporary Register: Use a temp register to swap values.
2. Without a Temporary Register (Non-Blocking Assignments): Use Verilog’s non-blocking assignments.
3. Without a Temporary Register (Addition/Subtraction): Use arithmetic to swap values.
4. Without a Temporary Register (Multiplication/Division): Use multiplication and division (ensure no division by zero).
5. Without a Temporary Register (Bitwise XOR): Use the XOR operator for swapping.

Solution 1: With a Temporary Register

This method uses a temp register to hold one value during the swap.

module with_temp;
  integer a, b, temp;
  
  initial begin
    a = 100;
    b = 200;
    
    temp = b;
    b = a;
    a = temp;
    $display("With Temp: a=%0d  || b=%0d", a, b);
  end
endmodule

Explanation:

• temp holds b’s value (200).
• b takes a’s value (100).
• a takes temp’s value (200).
• Output: a=200 || b=100.

Solution 2: Without a Temporary Register (Non-Blocking Assignments)

This method uses non-blocking assignments (<=) to swap values.

module without_temp_nonblocking;
  integer a, b;
  
  initial begin
    a = 100;
    b = 200;    
    
    b <= a;
    a <= b;
    #1;         // Delay to ensure non-blocking assignments complete
    $display("Non-Blocking: a=%0d  || b=%0d", a, b);
  end
endmodule

Explanation:

• Non-blocking assignments evaluate the right-hand side first, then update all left-hand sides at the end of the time step.
• b <= a schedules b to become 100.
• a <= b schedules a to become 200 (using b’s old value).
• Output: a=200 || b=100.
  Note: The #1 delay ensures the assignments are complete before displaying. In a testbench, this works, but non-blocking swaps may not synthesize correctly for hardware.

Solution 3: Without a Temporary Register (Addition/Subtraction)

This method uses addition and subtraction to swap values.

module without_temp_add_sub;
  integer a, b;
  
  initial begin
    a = 100;
    b = 200;
    
    a = a + b;     // a = 300
    b = a - b;     // b = 300 - 200 = 100
    a = a - b;     // a = 300 - 100 = 200
    $display("Add/Sub: a=%0d  || b=%0d", a, b);
  end
endmodule

Explanation:

• a = a + b: a becomes 300.
• b = a - b: b becomes 300 - 200 = 100.
• a = a - b: a becomes 300 - 100 = 200.
• Output: a=200 || b=100.
  Note: Ensure a + b doesn’t overflow the register size in real designs.

Solution 4: Without a Temporary Register (Multiplication/Division)

This method uses multiplication and division to swap values.

module without_temp_mult_div;
  integer a, b;
  
  initial begin
    a = 100;
    b = 200;
    
    // Ensure b is not zero to avoid division by zero
    if (b != 0) begin
      a = a * b;         // a = 100 * 200 = 20000
      b = a / b;         // b = 20000 / 200 = 100
      a = a / b;         // a = 20000 / 100 = 200
      $display("Mult/Div: a=%0d  || b=%0d", a, b);
    end 

    else begin
      $display("Error: b is zero, cannot divide!");
    end

  end
endmodule

Explanation:

• a = a * b: a becomes 100 * 200 = 20000.
• b = a / b: b becomes 20000 / 200 = 100.
• a = a / b: a becomes 20000 / 100 = 200.
• Output: a=200 || b=100.
  Note: Check for division by zero and ensure a * b doesn’t overflow.

Solution 5: Without a Temporary Register (Bitwise XOR)

This method uses the XOR operator (^) to swap values.

module without_temp_xor;
  integer a, b;
  
  initial begin
    a = 100;
    b = 200;
    
    a = a ^ b;         // a = 100 ^ 200
    b = a ^ b;         // b = (100 ^ 200) ^ 200 = 100
    a = a ^ b;         // a = (100 ^ 200) ^ 100 = 200
    $display("XOR: a=%0d  || b=%0d", a, b);
  end
endmodule

Explanation:

• a = a ^ b: a becomes 100 ^ 200.
• b = a ^ b: b becomes (100 ^ 200) ^ 200 = 100.
• a = a ^ b: a becomes (100 ^ 200) ^ 100 = 200.
• Output: a=200 || b=100.
  Note: XOR is efficient in hardware as it translates to simple logic gates.

Tips for Verilog Coding

1. Choose the Right Method: Use temporary registers for clarity, or XOR for hardware efficiency.
2. Check for Overflows: Arithmetic methods (add/sub, mult/div) can overflow—use appropriate bit widths.
3. Simulate: Test your code to verify the swap works.
4. Synthesize: Ensure your method is synthesizable for hardware.

Swapping two registers in Verilog is a fundamental skill for VLSI design. We explored five methods: using a temporary register, non-blocking assignments, addition/subtraction, multiplication/division, and bitwise XOR. Each has its use case—try simulating them to see what works best for your design! Explore more Verilog tutorials on VLSI 360, or join our training program for hands-on practice!