alu_tb.vhd

It is the code for implementing the project titled "The Reconfigurable Instruction Cell Array(IEEE 2

LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
USE ieee.numeric_std.ALL;
USE std.textio.ALL;
USE ieee.std_logic_textio.ALL;
-- use package
USE work.procmem_definitions.ALL;
-------------------------------------------------------------------------------
ENTITY t_alu IS
END t_alu;
-------------------------------------------------------------------------------
ARCHITECTURE tbenchfileio OF t_alu IS
-- component generics
CONSTANT width : NATURAL := 32;
COMPONENT alu
PORT (
a, b : IN STD_ULOGIC_VECTOR(width-1 DOWNTO 0);
opcode : IN STD_ULOGIC_VECTOR(2 DOWNTO 0);
result : OUT STD_ULOGIC_VECTOR(width-1 DOWNTO 0);
zero : OUT STD_ULOGIC);
END COMPONENT;
-- component ports
SIGNAL a, b : STD_ULOGIC_VECTOR(width-1 DOWNTO 0);
SIGNAL opcode : STD_ULOGIC_VECTOR(2 DOWNTO 0);
SIGNAL result : STD_ULOGIC_VECTOR(width-1 DOWNTO 0);
SIGNAL zero : STD_ULOGIC;
-- definition of a clock period
CONSTANT period : time := 10 ns;
FUNCTION TO_string(arg : std_ulogic) RETURN string IS
VARIABLE result_string : string(1 DOWNTO 1);
BEGIN
CASE arg IS
WHEN 'U' => result_string(1) := 'U';
WHEN 'X' => result_string(1) := 'X';
WHEN '0' => result_string(1) := '0';
WHEN '1' => result_string(1) := '1';
WHEN 'Z' => result_string(1) := 'Z';
WHEN 'W' => result_string(1) := 'W';
WHEN 'L' => result_string(1) := 'L';
WHEN 'H' => result_string(1) := 'H';
WHEN '-' => result_string(1) := '-';
END CASE;
RETURN result_string;
END TO_string;
FUNCTION TO_string(arg : unsigned) RETURN string IS
ALIAS u : unsigned(arg'length DOWNTO 1) IS arg;
VARIABLE result_string : string(arg'length DOWNTO 1);
BEGIN
FOR i IN u'range LOOP
CASE u(i) IS
WHEN 'U' => result_string(i) := 'U';
WHEN 'X' => result_string(i) := 'X';
WHEN '0' => result_string(i) := '0';
WHEN '1' => result_string(i) := '1';
WHEN 'Z' => result_string(i) := 'Z';
WHEN 'W' => result_string(i) := 'W';
WHEN 'L' => result_string(i) := 'L';
WHEN 'H' => result_string(i) := 'H';
WHEN '-' => result_string(i) := '-';
END CASE;
END LOOP;
RETURN result_string;
END TO_string;
BEGIN -- tbenchfileio

-- component instantiation
DUT: alu
PORT MAP (
a => a,
b => b,
opcode => opcode,
result => result,
zero => zero);
stimuli_observer : PROCESS
VARIABLE errflag : boolean := false;
VARIABLE Li : line; -- pointer to file input buffer
VARIABLE Lo : line; -- pointer to file output buffer
FILE vectorfile : text OPEN read_mode IS "./stimuli/testpattern-ALU.in";
-- definition of input file structure:
-- # comment line starts with hash character
-- otherwise a space is required for the first character !
-- following definition of corresponding temp input buffer variables
CONSTANT commentchar : character := '#'; -- comment character
VARIABLE vectorfirstc : character := commentchar; -- first character
VARIABLE vectornum : integer := 0; -- vector number
VARIABLE vectordelimit : character := ' '; -- delimiter character between vectors
-- variables used in file-io
VARIABLE opcode_fio : STD_ULOGIC_VECTOR(2 DOWNTO 0);
VARIABLE a_fio : INTEGER;
VARIABLE b_fio : INTEGER;
VARIABLE result_fio : INTEGER;
VARIABLE zero_fio : STD_ULOGIC;
BEGIN
WHILE NOT endfile(vectorfile) LOOP
-- read stimuli line by line
readline(vectorfile, Li);
IF (Li /= NULL) AND (Li'length > 0) THEN
read(Li, vectorfirstc);
IF (vectorfirstc /= commentchar) THEN
read(Li, vectornum);
read(Li, vectordelimit);
-- read opcode
read(Li, opcode_fio);
opcode <= opcode_fio;
-- read operand a
read(Li, vectordelimit);
read(Li, a_fio);
a <= STD_ULOGIC_VECTOR(TO_UNSIGNED(a_fio, width));
-- read operand b
read(Li, vectordelimit);
read(Li, b_fio);
b <= STD_ULOGIC_VECTOR(TO_UNSIGNED(b_fio, width));
-- read result
read(Li, vectordelimit);
read(Li, result_fio);
-- read zero bit
read(Li, vectordelimit);
read(Li, zero_fio);
WAIT FOR period;
-- compare expected result
IF result /= STD_ULOGIC_VECTOR(TO_UNSIGNED(result_fio, width)) THEN
write(Lo, string'("Pattern No. "));
write(Lo, vectornum);
writeline(OUTPUT, Lo);
REPORT "Error: Wrong result!" & lf &
to_string(UNSIGNED(result)) & " = result" & lf &
to_string(TO_UNSIGNED(result_fio, width)) & " = expected result" & lf
SEVERITY failure;
errflag := true;
END IF;
-- compare zero-bit
write(Lo, string'("Pattern No. "));
write(Lo, vectornum);
writeline(OUTPUT, Lo);
REPORT "Error: Wrong zero-bit!" & lf &
to_string(zero) & " = zero-bit" & lf &
to_string(zero_fio) & " = expected zero-bit"
SEVERITY failure;
errflag := true;
END IF;
--END IF; -- first character is a comment
END IF; -- line is not null
END LOOP; -- while not end of FILE
ASSERT errflag
REPORT "No errors !"
SEVERITY note;
WAIT;
END PROCESS;
END tbenchfileio;