Livt packages
Livt.Math
Version 1.7.2
Reusable integer and fixed-point arithmetic, complex numbers, trigonometry, and statistics for FPGA applications written in Livt.
Published files (90)
- CordicAtan2MagnitudeQ15LifecycleTb.vhd
- CordicSinCosQ15LifecycleTb.vhd
- CordicSinCosQ15SynthesisTop.vhd
- cordic_q15_oracle.py
- cordic_vectoring_q15_oracle.py
- IntegerDivisionResetTb.vhd
- measure_cordic_ice40.py
- special_functions_oracle.py
- test_cordic_sincos_q15.py
- test_cordic_structure.py
- test_cordic_vectoring_lifecycle.py
- test_cordic_vectoring_structure.py
- test_special_function_structure.py
- test_wide_pipeline.py
- WideArithmeticResetTb.vhd
tests/rtl/CordicSinCosQ15LifecycleTb.vhd
library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
use std.env.all;
use work.livt_lang_icontext_package.all;
use work.livt_math_trigonometry_cordicsincosq15_package.all;
-- Measure public-call latency and exercise reset, overlap, retention, and recovery.
entity cordic_sin_cos_q15_lifecycle_tb is
end;
architecture test of cordic_sin_cos_q15_lifecycle_tb is
signal ctx : t_icontext_in := (
'0', '1', to_unsigned(100000000, 32), to_unsigned(10, 32),
to_unsigned(5, 32), to_unsigned(5, 32));
signal compute_request : t_cordicsincosq15_compute_in := (to_signed(0, 32), '0');
signal compute_response : t_cordicsincosq15_compute_out;
signal sine_request : t_cordicsincosq15_getsin_in := (run => '0');
signal sine_response : t_cordicsincosq15_getsin_out;
signal cosine_request : t_cordicsincosq15_getcos_in := (run => '0');
signal cosine_response : t_cordicsincosq15_getcos_out;
begin
ctx.clk <= not ctx.clk after 5 ns;
dut : entity work.livt_math_trigonometry_cordicsincosq15
port map (
ctor_lvt_context_in => ctx,
compute_in => compute_request,
compute_out => compute_response,
getsin_in => sine_request,
getsin_out => sine_response,
getcos_in => cosine_request,
getcos_out => cosine_response);
process
procedure tick is
begin
wait until rising_edge(ctx.clk);
wait for 1 ns;
end;
procedure read_results(
expected_sine : integer;
expected_cosine : integer;
tolerance : natural := 4) is
variable difference : integer;
begin
sine_request.run <= '1';
tick;
assert sine_response.busy = '1' report "sine read not accepted" severity failure;
sine_request.run <= '0';
while sine_response.busy = '1' loop
tick;
end loop;
cosine_request.run <= '1';
tick;
assert cosine_response.busy = '1' report "cosine read not accepted" severity failure;
cosine_request.run <= '0';
while cosine_response.busy = '1' loop
tick;
end loop;
difference := abs(to_integer(sine_response.return_value) - expected_sine);
assert difference <= tolerance report "sine result outside tolerance" severity failure;
difference := abs(to_integer(cosine_response.return_value) - expected_cosine);
assert difference <= tolerance report "cosine result outside tolerance" severity failure;
end;
procedure run_compute(
phase : integer;
expected_success : boolean;
expected_sine : integer;
expected_cosine : integer;
variable cycles : out natural) is
begin
compute_request.phase <= to_signed(phase, 32);
compute_request.run <= '1';
tick;
assert compute_response.busy = '1' report "compute request not accepted" severity failure;
compute_request.run <= '0';
cycles := 0;
while compute_response.busy = '1' loop
tick;
cycles := cycles + 1;
assert cycles < 100 report "compute timeout" severity failure;
end loop;
assert compute_response.return_value = expected_success report "unexpected compute status" severity failure;
read_results(expected_sine, expected_cosine);
end;
variable reference_cycles, measured_cycles : natural;
begin
tick;
tick;
ctx.rst <= '0';
tick;
run_compute(0, true, 0, 32767, reference_cycles);
assert reference_cycles = 32 report "valid public-call latency changed" severity failure;
report "CORDIC valid public-call latency: " & integer'image(reference_cycles) & " cycles";
run_compute(8192, true, 23170, 23170, measured_cycles);
assert measured_cycles = reference_cycles report "quadrant-one latency differs" severity failure;
run_compute(24576, true, 23170, -23170, measured_cycles);
assert measured_cycles = reference_cycles report "quadrant-two latency differs" severity failure;
run_compute(-24576, true, -23170, -23170, measured_cycles);
assert measured_cycles = reference_cycles report "negative-quadrant latency differs" severity failure;
run_compute(32768, false, 0, 0, measured_cycles);
assert measured_cycles = 14 report "invalid public-call latency changed" severity failure;
report "CORDIC invalid public-call latency: " & integer'image(measured_cycles) & " cycles";
-- A one-cycle request pulse while busy is not accepted or replayed.
compute_request.phase <= to_signed(8192, 32);
compute_request.run <= '1';
tick;
compute_request.run <= '0';
for cycle in 1 to 8 loop
tick;
end loop;
compute_request.phase <= to_signed(0, 32);
compute_request.run <= '1';
tick;
compute_request.run <= '0';
while compute_response.busy = '1' loop
tick;
end loop;
assert compute_response.return_value report "original overlapped call failed" severity failure;
read_results(23170, 23170);
for cycle in 1 to 10 loop
tick;
assert compute_response.busy = '0' report "overlapped request was replayed" severity failure;
end loop;
-- Reset in the iterative region cancels the call and clears observations.
compute_request.phase <= to_signed(12345, 32);
compute_request.run <= '1';
tick;
compute_request.run <= '0';
for cycle in 1 to 12 loop
tick;
end loop;
assert compute_response.busy = '1' report "compute finished before reset point" severity failure;
ctx.rst <= '1';
tick;
assert compute_response.busy = '0' and not compute_response.return_value
report "reset did not cancel compute" severity failure;
ctx.rst <= '0';
tick;
read_results(0, 0, 0);
run_compute(-8192, true, -23170, 23170, measured_cycles);
assert measured_cycles = reference_cycles report "post-reset latency differs" severity failure;
-- The next request is accepted on the first clock after completion.
compute_request.phase <= to_signed(0, 32);
compute_request.run <= '1';
tick;
compute_request.run <= '0';
while compute_response.busy = '1' loop
tick;
end loop;
compute_request.phase <= to_signed(8192, 32);
compute_request.run <= '1';
tick;
assert compute_response.busy = '1' report "next request not accepted immediately" severity failure;
compute_request.run <= '0';
while compute_response.busy = '1' loop
tick;
end loop;
read_results(23170, 23170);
report "CORDIC minimum acceptance interval: 33 cycles";
report "PASS CORDIC lifecycle, fixed latency, overlap rejection, reset, and recovery";
stop;
end process;
process
begin
wait for 50 us;
assert false report "watchdog" severity failure;
end process;
end;