Subversion Repositories open_hitter

--////////////////////////////////////////////////////////////////////
--//                                                              ////
--// search_control_sim.vhd                                       ////
--//                                                              ////
--// This file is part of the open_hitter opencores effort.       ////
--// <http://www.opencores.org/cores/open_hitter/>                ////
--//                                                              ////
--// Module Description:                                          ////
--// Simulation program (synthesizable)                           ////
--// Unit test for search_control.vhd                             ////
--//                                                              ////
--// To Do:                                                       ////
--//    #LOTS                                                     ////
--//                                                              ////
--// Author(s):                                                   ////
--// - Stephen Hawes                                              ////
--//                                                              ////
--////////////////////////////////////////////////////////////////////
--//                                                              ////
--// Copyright (C) 2015 Stephen Hawes and OPENCORES.ORG           ////
--//                                                              ////
--// This source file may be used and distributed without         ////
--// restriction provided that this copyright statement is not    ////
--// removed from the file and that any derivative work contains  ////
--// the original copyright notice and the associated disclaimer. ////
--//                                                              ////
--// This source file is free software; you can redistribute it   ////
--// and/or modify it under the terms of the GNU Lesser General   ////
--// Public License as published by the Free Software Foundation; ////
--// either version 2.1 of the License, or (at your option) any   ////
--// later version.                                               ////
--//                                                              ////
--// This source is distributed in the hope that it will be       ////
--// useful, but WITHOUT ANY WARRANTY; without even the implied   ////
--// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR      ////
--// PURPOSE. See the GNU Lesser General Public License for more  ////
--// details.                                                     ////
--//                                                              ////
--// You should have received a copy of the GNU Lesser General    ////
--// Public License along with this source; if not, download it   ////
--// from <http://www.opencores.org/lgpl.shtml>                   ////
--//                                                              ////
--////////////////////////////////////////////////////////////////////
--//
--// \$Id\$  TAKE OUT THE \'s and this comment in order to get this to work
--//
--// CVS Revision History
--//
--// \$Log\$  TAKE OUT THE \'s and this comment in order to get this to work
--//
library ieee;
use ieee.std_logic_1164.all;     
use ieee.numeric_std.ALL;
 
entity search_control_sim is
  port (
            RX_CLK: in std_logic;
            restart: in std_logic;        
            processing: out std_logic;  
            result_one: out std_logic;
            result_two: out std_logic;
            result_all_ok: out std_logic
  );
end search_control_sim;
 
architecture behav of search_control_sim is
   component search_control is
      generic ( searchitems : integer );
      port (
           RX_CLK: in std_logic;
           -- control flag(s) on the incoming bus
              search_px_valid_i: in std_logic;
           -- pxdata: in price_packet
              search_px_type_i: in std_logic_vector(4 downto 0);
              search_buy_sell_i: in std_logic_vector(2 downto 0);   -- 111 buy, 000 sell
              search_px_i: in std_logic_vector(15 downto 0);     -- price
              search_qty_i: in std_logic_vector(15 downto 0);    -- quantity
              search_sec_i: in std_logic_vector(55 downto 0);    -- 7x 8bits securities identifier
              search_id_i: in std_logic_vector(15 downto 0);    -- unique/identifier/counter
           -- pxdata: out price_packet
              order_px_type_o: out std_logic_vector(4 downto 0);
              order_buy_sell_o: out std_logic_vector(2 downto 0);   -- 111 buy, 000 sell
              order_px_o: out std_logic_vector(15 downto 0);     -- price
              order_qty_o: out std_logic_vector(15 downto 0);    -- quantity
              order_sec_o: out std_logic_vector(55 downto 0);    -- 7x 8bits securities identifier
              order_id_o: out std_logic_vector(15 downto 0);     -- unique/identifier/counter
           -- control flag(s) on the outgoing bus
              order_px_valid_o: out std_logic
        );
   end component;
   for search_control_0: search_control use entity work.search_control;
        -- control flag(s) on the incoming bus
           signal search_px_valid_i: std_logic;
        -- pxdata: in price_packet
           signal search_px_type_i: std_logic_vector(4 downto 0);
           signal search_buy_sell_i: std_logic_vector(2 downto 0);   -- 111 buy, 000 sell
           signal search_px_i: std_logic_vector(15 downto 0);     -- price
           signal search_qty_i: std_logic_vector(15 downto 0);    -- quantity
           signal search_sec_i: std_logic_vector(55 downto 0);    -- 7x 8bits securities identifier
           signal search_id_i: std_logic_vector(15 downto 0);    -- unique/identifier/counter
        -- pxdata: out price_packet
           signal order_px_type_o: std_logic_vector(4 downto 0);
           signal order_buy_sell_o: std_logic_vector(2 downto 0);   -- 111 buy, 000 sell
           signal order_px_o: std_logic_vector(15 downto 0);     -- price
           signal order_qty_o: std_logic_vector(15 downto 0);    -- quantity
           signal order_sec_o: std_logic_vector(55 downto 0);    -- 7x 8bits securities identifier
           signal order_id_o: std_logic_vector(15 downto 0);     -- unique/identifier/counter
        -- control
           signal order_px_valid_o: std_logic;
begin
    --  Component instantiation.
        search_control_0: search_control
    --       generic map ( searchitems => 4 )   -- for test case when full at 4 orders
           generic map ( searchitems => 200 )   -- a bit bigger
           port map (
              RX_CLK => RX_CLK,
           -- control flag(s) on the incoming bus
              search_px_valid_i => search_px_valid_i,
           -- pxdata: in price_packet
              search_px_type_i => search_px_type_i,
              search_buy_sell_i => search_buy_sell_i,
              search_px_i => search_px_i,
              search_qty_i => search_qty_i,
              search_sec_i => search_sec_i,
              search_id_i => search_id_i,
           -- pxdata: out price_packet
              order_px_type_o => order_px_type_o,
              order_buy_sell_o => order_buy_sell_o,
              order_px_o => order_px_o,
              order_qty_o => order_qty_o,
              order_sec_o => order_sec_o,
              order_id_o => order_id_o,
           -- control
              order_px_valid_o => order_px_valid_o
           );
    --
    process (RX_CLK) is
        type input_pattern_type is record
           -- control flag(s) on the incoming bus
              search_px_valid_i: std_logic;
           -- pxdata: in price_packet
              search_px_type_i: std_logic_vector(4 downto 0);
              search_buy_sell_i: std_logic_vector(2 downto 0);   -- 111 buy, 000 sell
              search_px_i: std_logic_vector(15 downto 0);     -- price
              search_qty_i: std_logic_vector(15 downto 0);    -- quantity
              search_sec_i: std_logic_vector(55 downto 0);    -- 7x 8bits securities identifier
              -- search_id_i: std_logic_vector(15 downto 0);    -- unique/identifier/counter
         end record;
         type output_pattern_type is record
            -- pxdata: out price_packet
              order_px_type_o: std_logic_vector(4 downto 0);
              order_buy_sell_o: std_logic_vector(2 downto 0);   -- 111 buy, 000 sell
              order_px_o: std_logic_vector(15 downto 0);     -- price
              order_qty_o: std_logic_vector(15 downto 0);    -- quantity
              order_sec_o: std_logic_vector(55 downto 0);    -- 7x 8bits securities identifier
              order_id_o: std_logic_vector(15 downto 0);      -- unique/identifier/counter
         end record;
 
         --  The patterns to apply.
         constant zz_px: std_logic_vector(15 downto 0) := (others => 'Z');
         constant zz_qty: std_logic_vector(15 downto 0) := (others => 'Z');
         constant zz_sec: std_logic_vector(55 downto 0) := (others => 'Z');
         constant zz_id: std_logic_vector(15 downto 0) := (others => 'Z');
         constant set_qty: std_logic_vector(15 downto 0) := std_logic_vector'("0000000000010000");
         constant test_px: std_logic_vector(15 downto 0) := std_logic_vector'("0000000011100000");
         constant test_qty: std_logic_vector(15 downto 0) := std_logic_vector'("0000000000001100");
         constant remain_qty: std_logic_vector(15 downto 0) := std_logic_vector'("0000000000000100");
         constant test_sec0: std_logic_vector(55 downto 0) := std_logic_vector'(X"ABA544223478DC");
         constant test_sec1: std_logic_vector(55 downto 0) := std_logic_vector'(X"ABA543332178DC");
         constant test_sec2: std_logic_vector(55 downto 0) := std_logic_vector'(X"ABA234234378DC");
         constant test_sec3: std_logic_vector(55 downto 0) := std_logic_vector'(X"ABA534534578DC");
         constant test_id: std_logic_vector(15 downto 0) := std_logic_vector'("0110011001100110");
         constant other_id: std_logic_vector(15 downto 0) := std_logic_vector'("0000010001100010");
         constant other_px: std_logic_vector(15 downto 0) := std_logic_vector'("0000000000001110");
         constant other_sec: std_logic_vector(55 downto 0) := std_logic_vector'(X"CDC423354634AA");
         type input_pattern_array is array (natural range <>) of input_pattern_type;
           constant input_patterns : input_pattern_array :=
             ( ('1', std_logic_vector'("00000"), std_logic_vector'("ZZZ"), zz_px, zz_qty, zz_sec), -- 0 reset
               ('1', std_logic_vector'("10000"), std_logic_vector'("ZZZ"), zz_px, zz_qty, zz_sec), -- 1 nothing
               ('1', std_logic_vector'("00110"), std_logic_vector'("000"), test_px, set_qty, test_sec0),  -- 2 sec/set
               ('1', std_logic_vector'("00110"), std_logic_vector'("000"), test_px, set_qty, test_sec1),  -- 3 sec/set
               ('1', std_logic_vector'("00110"), std_logic_vector'("000"), test_px, set_qty, test_sec1),  -- 4 sec/set - repeat
               ('1', std_logic_vector'("00110"), std_logic_vector'("111"), test_px, set_qty, test_sec2),  -- 5 sec/set
               ('1', std_logic_vector'("00110"), std_logic_vector'("000"), test_px, set_qty, test_sec2),  -- 6 sec/set - diff buysell
               ('1', std_logic_vector'("00110"), std_logic_vector'("000"), test_px, set_qty, test_sec3),  -- 7 too many sec/set
               ('1', std_logic_vector'("11100"), std_logic_vector'("111"), test_px, test_qty, test_sec1),   -- 8 incoming px
               ('1', std_logic_vector'("11100"), std_logic_vector'("111"), test_px, zz_qty, other_sec),   -- 9 incoming px (wrong security)
               ('1', std_logic_vector'("11100"), std_logic_vector'("111"), other_px, test_qty, test_sec1),   -- 10incoming px (too low sale price)
               ('1', std_logic_vector'("11100"), std_logic_vector'("111"), test_px, test_qty, test_sec1) ); -- 11incoming px (part qty)
         type output_pattern_array is array (natural range <>) of output_pattern_type;
           constant output_patterns : output_pattern_array :=
             ( (std_logic_vector'("00000"), std_logic_vector'("ZZZ"), zz_px, zz_qty, zz_sec, zz_id),  -- 0 reset
               (std_logic_vector'("10000"), std_logic_vector'("ZZZ"), zz_px, zz_qty, zz_sec, zz_id),  -- 1 nothing
               (std_logic_vector'("01010"), std_logic_vector'("ZZZ"), zz_px, zz_qty, zz_sec, std_logic_vector'(X"0000")),  -- 2 sec/set
               (std_logic_vector'("01010"), std_logic_vector'("ZZZ"), zz_px, zz_qty, zz_sec, std_logic_vector'(X"0001")),  -- 3 sec/set
               (std_logic_vector'("00110"), std_logic_vector'("ZZZ"), zz_px, zz_qty, zz_sec, std_logic_vector'(X"0001")),  -- 4 sec/set
               (std_logic_vector'("01010"), std_logic_vector'("ZZZ"), zz_px, zz_qty, zz_sec, std_logic_vector'(X"0002")),  -- 5 sec/set
               (std_logic_vector'("01010"), std_logic_vector'("ZZZ"), zz_px, zz_qty, zz_sec, std_logic_vector'(X"0003")),  -- 6 sec/set
               (std_logic_vector'("11111"), std_logic_vector'("ZZZ"), zz_px, zz_qty, zz_sec, zz_id),  -- 7 bad sec/set (too many)
               (std_logic_vector'("11100"), std_logic_vector'("000"), test_px, test_qty, test_sec1, std_logic_vector'(X"0001")),  -- 8 incoming px
               (std_logic_vector'("11110"), std_logic_vector'("ZZZ"), zz_px, zz_qty, zz_sec, zz_id),  -- 9 incoming px (wrong security)
               (std_logic_vector'("11101"), std_logic_vector'("ZZZ"), zz_px, zz_qty, zz_sec, zz_id),  -- 10incoming px (too low sale price)
               (std_logic_vector'("11100"), std_logic_vector'("000"), test_px, remain_qty, test_sec1, std_logic_vector'(X"0001")) );  -- 11incoming px (part qty)
 
       -- process control
       variable pos: integer;
       variable i: integer := 99;   -- pattern id
       variable subcount: integer := 99;   -- pattern step
       variable res: integer;
       variable res_ok: std_logic;
    begin
       if rising_edge(RX_CLK) then
           if restart = '1'  then
              i := 0;
              subcount := 0;
              --
              result_all_ok <= '0';
              result_one <= '0';
              result_two <= '0';
              processing <= '1';
           else
 
             --  Pattern step
             if i < input_patterns'right+1 then
              -- diagnostics (uncomment)
              -- write (l, String'("Wrapper start loop i: "));
              -- write (l, i);
              -- writeline (output, l);
 
           --   processing <= '1';
 
              if subcount = 0 then
                 --  Set the inputs.
                 search_px_valid_i <= input_patterns(i).search_px_valid_i;
                 search_px_type_i <= input_patterns(i).search_px_type_i;
                 search_buy_sell_i <= input_patterns(i).search_buy_sell_i;
                 search_px_i <= input_patterns(i).search_px_i;
                 search_qty_i <= input_patterns(i).search_qty_i;
                 search_sec_i <= input_patterns(i).search_sec_i;
                 --search_id_i <= input_patterns(i).search_id_i;
                 res := 0;
                 res_ok := '1';
                 subcount := 1;
              else
                 -- reset the go instruction
                 search_px_valid_i <= '0';
                 --  Check the outputs.
 
                 -- diagnostics (uncomment)
                 -- write (l, String'("  Wrapper wait results r: "));
                 -- write (l, r);
                 -- write (l, String'(" order_px_valid_o: "));
                 -- write (l, std_logic'image(order_px_valid_o));
                 -- writeline (output, l);
 
                 -- got a return .. check it
                 if order_px_valid_o = '1' then
 
--                    result_one <= '1';
 
                    if i = 4 then
                       if order_px_type_o = output_patterns(i).order_px_type_o then
                          result_one <= '1';
                       end if;
                    end if;
 
                    if i = 8 then
                       if order_px_type_o = output_patterns(i).order_px_type_o then
                          result_two <= '1';
                       end if;
                    end if;
 
                    if i = 11 then
                       if order_px_type_o = output_patterns(i).order_px_type_o then
                          result_all_ok <= '1';
                       end if;
                    end if;
 
 
--                       if order_px_type_o /= output_patterns(i).order_px_type_o
--                        or order_buy_sell_o /= output_patterns(i).order_buy_sell_o 
--                        or order_px_o /= output_patterns(i).order_px_o 
--                        or order_qty_o /= output_patterns(i).order_qty_o then
--                        or order_sec_o /= output_patterns(i).order_sec_o 
--                        or order_id_o /= output_patterns(i).order_id_o  then
                       --
 
--                        res_ok := '0';
--                      else
--                         result_all_ok <= '1';                    
--                      end if;
 
                    res := res + 1;
                 end if;
 
                 if subcount = 6 then
                    -- check result
--                    if res /= 1 then
--                       res_ok := '0';
--                    end if;
 
                    -- reporting
--                    if i = 11 then
--                       result_all_ok <= res_ok;  -- success!
--                    elsif i = 6 then
--                       result_two <= res_ok;     -- loader tasks oka
--                    elsif i = 0 then
--                       result_one <= res_ok;     -- initial reset worked
--                    end if;
 
                    -- next pattern
                    i := i + 1;
                    subcount := 0;
                 else 
                    subcount := subcount + 1;
                 end if;
              end if;
           else
              -- not processing (done or not started)
              processing <= '0';
           end if;   -- i
         end if;
       end if;        -- RX_CLK
    end process;
end behav;