Subversion Repositories ht_tunnel

//flow_control_l2_tb.h
/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is HyperTransport Tunnel IP Core.
 *
 * The Initial Developer of the Original Code is
 * Ecole Polytechnique de Montreal.
 * Portions created by the Initial Developer are Copyright (C) 2005
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *   Ami Castonguay <acastong@grm.polymtl.ca>
 *
 * Alternatively, the contents of this file may be used under the terms
 * of the Polytechnique HyperTransport Tunnel IP Core Source Code License 
 * (the  "PHTICSCL License", see the file PHTICSCL.txt), in which case the
 * provisions of PHTICSCL License are applicable instead of those
 * above. If you wish to allow use of your version of this file only
 * under the terms of the PHTICSCL License and not to allow others to use
 * your version of this file under the MPL, indicate your decision by
 * deleting the provisions above and replace them with the notice and
 * other provisions required by the PHTICSCL License. If you do not delete
 * the provisions above, a recipient may use your version of this file
 * under either the MPL or the PHTICSCL License."
 *
 * ***** END LICENSE BLOCK ***** */
 
#ifndef FLOW_CONTROL_L2_TB_H
#define FLOW_CONTROL_L2_TB_H
 
#include "../../../rtl/systemc/core_synth/synth_datatypes.h"	
#include "../../../rtl/systemc/core_synth/constants.h"
#include <deque>
#include <string>
 
#define NOP_COUNTER_DELAY 20
 
///Testbench for the complete flow_control_l2 module
/** The flow_control_l2 module is BIG, so testing it is a HUGE job.
    This testbench covers a couple of simple cases but in no way
	covers all the functionality.
*/
class flow_control_l2_tb : public sc_module
{
public:
	///Delay before nop frees buffers
	/**
	   The testbench simulates the flow control credits, so when packets are received,
	   flow control credits are eventually freed and sent to the flow control module.
	   This is number of cycles of delay there is between the time packets are received
	   and the moment credit are freed
	*/
	static const int nop_counter_delay;
 
	///Maximum number of data buffers there are in the simulated next node
	static const unsigned next_node_databuffers_maximum[3];
 
	///Maximum number of command buffers there are in the simulated next node
	static const unsigned next_node_buffers_maximum[3];
 
 
	///A structure that represents a packet of data
	struct PacketData{
		int size;///< Size (number of dwords), from 1 to 16
		int dwords[16];///< actual data
		sc_bv<64> associated_control_pkt;///< The command packet associated with this data
	};
 
	///A structure to identify an entry in the data buffers
	struct DataBufferEntry{
		sc_uint<BUFFERS_ADDRESS_WIDTH> address;///<Unique address of the entry
		VirtualChannel vc;///<Virtual channel of the entry
		int size;///< Size (number of dwords), from 1 to 16
		int dwords[16];///< actual data
	};
 
	///From what source is the flow control currently sending a packet
	enum FlowControlStatus{
		FC_SENDING_CSR,
		FC_SENDING_EH,
		FC_SENDING_FWD,
		FC_SENDING_UI,
		FC_NONE	
	};
 
	///An output value of the flow control module, contains 32 bits dword and CTL values
	struct OutputDword{
		sc_bv<32> dword;
		bool lctl;
		bool hctl;
	};
 
	///Flow control informatino contained in a nop packet
	struct NopInfo{
		sc_bv<12> nop_information;
		sc_uint<8> nop_ack_value;
		bool nop_received;
	};
 
	///Structure representing a history entry
	struct HistoryEntry{
		sc_bv<64> pkt;///<The command packet
		sc_uint<8> nop_ack_value;///<Ack value of the entry (part of HT spec!)
		unsigned data_size;///<Number of dwords of data
		unsigned data[16];///<The actual data
		unsigned crc;///Per packet CRC of the entry
	};
 
	///Exception that can be thrown
	struct TestbenchError{
		std::string message;
	};
 
	/// The Clock
	sc_in<bool> clk;
	/// Reset signal
	sc_out<bool> resetx;
	///LDTSTOP# signal
	sc_out<bool> ldtstopx;
 
    // USER_FIFO
	///The packet the user interface wants to send
    sc_out <sc_bv<64> >			ui_packet_fc;
	///If it there is a packet available to be sent
	sc_out <bool>				ui_available_fc;
	///The VC's that can accept packets currently
	sc_in <sc_bv<3> >			fc_user_fifo_ge2_ui;
 
	///The VC in which the flow control wants to read data from the UI data buffer
	sc_in <VirtualChannel>		fc_data_vc_ui;
	///The data from the UI buffers
	sc_out <sc_bv<32> >			ui_data_fc; 
	///To consume the data from the UI buffers
	sc_in <bool>				fc_consume_data_ui;
 
	// Forward -- FC
    //If there is a packet to be sent from the reordering from the other side
    sc_out <bool> ro_available_fwd;
	///The packet to send
    sc_out <syn_ControlPacketComplete > ro_packet_fwd;
	///The VirtualChannel of the packet to send
	sc_out <VirtualChannel > ro_packet_vc_fwd;
	///To acknoledge that the packet has been consumed
    sc_in <bool> fwd_ack_ro;
 
   	//LINK
	///The dword to send to the other link
    sc_in <sc_bv<32> > fc_dword_lk;
	///The LCTL control signal to send along with the data
    sc_in <bool> fc_lctl_lk;
	///The HCTL control signal to send along with the data
    sc_in <bool> fc_hctl_lk;
	///The link consumes the data we are sending
    sc_out  <bool> lk_consume_fc;
#ifdef RETRY_MODE_ENABLED
	///Force the link to disconnect
    sc_in <bool> fc_disconnect_lk;
	///This signal is active when the RX side of the link is connected
	sc_out  <bool> lk_rx_connected;
	///If the link wants to initiate a retry disconnect
	sc_out  <bool> lk_initiate_retry_disconnect;
	///If we are in the mode retry
	sc_out <bool> csr_retry;
	//Command decoder
	/**Turns on when a disconnect sequence is initiated
	All buffer counts are zeroed and we must replay all packets
	that have not been acked*/
	sc_out <bool>	cd_initiate_retry_disconnect;
#endif
 
	//DATA BUFFER
	///The address where to read the data
    sc_in <sc_uint<BUFFERS_ADDRESS_WIDTH> > fwd_address_db;
	///The VC in which to read the data
    sc_in <VirtualChannel>  fwd_vctype_db;
	///To read (consume) the data at the address specified
    sc_in <bool> fwd_read_db;
	///The data received from the data buffer
    sc_out <sc_bv<32> > db_data_fwd;
 
 
    ///Buffer count information from RO and DB for sending nop's
	///The buffers the ro can notify as being free to the HT node we are connected to
    sc_out <sc_bv<6> > ro_buffer_cnt_fc;
	///The buffers the ro can notify as being free to the HT node we are connected to
    sc_out <sc_bv<6> > db_buffer_cnt_fc;
 
    //Connexion Error handler FLOW control
	///Acknoledge that the dword has been read
	sc_in <bool> fc_ack_eh;
	///The dword to send (command packet or data payload)
	sc_out <sc_bv<32> > eh_cmd_data_fc;
	///If there is a dword to send
	sc_out <bool> eh_available_fc;
 
	//Connexion CSR -- FLOW control
	///Acknoledge that the dword has been read
	sc_in <bool> fc_ack_csr;	
	///If there is a dword to send
	sc_out <bool> csr_available_fc;
	///The dword to send (command packet or data payload)
	sc_out <sc_bv<32> > csr_dword_fc;
 
	///If we are to turn the transmitter off
	sc_out <bool> csr_transmitteroff;
 
	///This bit forces a single stomp to be sent
	sc_out<bool>			csr_force_single_stomp_fc;
	///This bit forces a single CRC error to be sent
	sc_out<bool>			csr_force_single_error_fc;
	///Once a stomp is sent, we clear the signal to send the stomp
	sc_in<bool>		fc_clear_single_error_csr;
	///Once a CRC error is sent, we clear the signal to send the error
	sc_in<bool>		fc_clear_single_stomp_csr;
 
 
 
	//Connexion pour les NOP request
	///Databuffer requests that a nop be sent.
	sc_out <bool> db_nop_req_fc;
	///Reordering requests that a nop be sent.
	sc_out <bool> ro_nop_req_fc;
	///A nop was just sent
	sc_in <bool> fc_nop_sent;
 
	// NOP info packet
	///The buffer information received in a nop
	sc_out<sc_bv<12> > cd_nopinfo_fc;
	///If a nop was just received
    sc_out<bool> cd_nop_received_fc;
 
    ///Let the reordering know which buffers are free in the next node
	sc_in <sc_bv<6> > fwd_next_node_buffer_status_ro;
 
#ifdef RETRY_MODE_ENABLED
	///The packet that is acked in the nop (for retry mode)
	/**
		When we receive this ack value, we can erase the packet associated with
		that number (and all the previous ones) from our buffers.
	*/
	sc_out<sc_uint<8> > cd_nop_ack_value_fc;
 
	///CD maitains a count of valid packet received, that count is then sent in nops
	sc_out<sc_uint<8> > cd_rx_next_pkt_to_ack_fc;
 
	//////////////////////////////////////////
	//	Memory interface - synchronous
	/////////////////////////////////////////
	sc_in<bool> history_memory_write;
	sc_in<sc_uint<LOG2_HISTORY_MEMORY_SIZE> > history_memory_write_address;
	sc_in<sc_bv<32> > history_memory_write_data;
	sc_in<sc_uint<LOG2_HISTORY_MEMORY_SIZE> > history_memory_read_address;
	sc_out<sc_bv<32> > history_memory_output;
 
	///Actual content of the simulated memory
	unsigned	history_memory[HISTORY_MEMORY_SIZE];
#endif
 
	///This containes packets sent to the user fifo
	/** The TB does not strictly test that the user fifo extracts the correct
	    packet (the user_fifo testbench is there for that), but it does keep 
		track of all packet sent and extracted from the user_fifo to make sure
		they are valid
	*/
	std::deque<sc_bv<64> > user_packets;
	///Data associated with the user packets
	/**This will be used to generate inputs to the flow_control when it wants
	   to access the data associated with the packets read from the user_fifo*/
	std::deque<PacketData> user_data[3];
	///VC of the data being read by the flow_control
	VirtualChannel current_user_data_vc;
	///VC of the data currently being received by the UI
	/** UI takes a cycle to update it's output, so this variable keeps track of
	    what is currently on the ouput (what was requested last cycle)
	*/
	VirtualChannel current_user_data_vc_output;
	///Packet that are expected to be outputed
	/**Most packet are read from various sources, so once they are read, we
	   can expect what it is going to be outputed.  This does not cover all
	   packets though : for example user packets are internal to the
	   flow_control_2 module so there is no way to predict that it will
	   be output, at least with black box testing.*/
	std::deque<OutputDword> expected_output;
 
	///History structure of the design
	std::deque<HistoryEntry> history;
 
	///Status of the design : what it is currently sending
	FlowControlStatus fc_status;
 
	///Data of the databuffer entry
	/**
		A real databuffer is not simulated.  When a packet is sent from the
		command buffers, the address is noted and stored and checking when
		the flow control module tries to check the data.  This variable
		stores the data of the entry
	*/
	DataBufferEntry databuffer_data;
	///Virtual channel of the databuffer entry currently being output
	/** Databuffer has a latency of 1 cycle before data is correct on the output.
	    This variable store information about what is currently being output (what
		was requested last cycle)*/
	VirtualChannel databuffer_output_vc;
	///Address of the databuffer entry currently being output
	/** Databuffer has a latency of 1 cycle before data is correct on the output.
	    This variable store information about what is currently being output (what
		was requested last cycle)*/
	unsigned	databuffer_output_addr;
 
	///SystemC Macro
	SC_HAS_PROCESS(flow_control_l2_tb);
 
	///Module constructor
	flow_control_l2_tb(sc_module_name name);
 
	///Controls percentage of change of generating packet from different sources
	/**
		Will vary throughout different stages of the testbench
	*/
	//@{
	int percent_chance_from_eh;
	int percent_chance_from_csr;
	int percent_chance_from_fwd;
	int percent_chance_from_ui;
	//@{
 
	///Number of dwords of data left to send (or sent) from the different sources
	//@{
	unsigned data_left_eh;
	unsigned data_left_csr;
	unsigned data_sent_ui;
	unsigned data_sent_db;
	//@{
 
	///Controls percentage of change of requesting nop packet to be sent
	/**
		Will vary throughout different stages of the testbench
	*/
	//@{
	int percent_chance_nop_req_db;
	int percent_chance_nop_req_ro;
	//@{
 
	///Controls percentage of change of requesting nop packet to received
	/**
		Will vary throughout different stages of the testbench
	*/
	int percent_chance_nop_received;
 
	///Per packet CRC calcualted for packets with no data associated
	unsigned crc1;
	///Per packet CRC calcualted for packets with data associated
	unsigned crc2;
 
	//This is the number of buffers that are free (command and data)
	unsigned next_node_buffers_free[3];
	unsigned next_node_databuffers_free[3];
 
	//This is the number of buffers that have been advertised as being free through
	//nops as seen by the next node (does not take into account the nop delay)
	unsigned next_node_buffers_advertised[3];
	unsigned next_node_databuffers_advertised[3];
 
	//This is the number of buffers that have been advertised as being free through
	//nops as seen by the current node (takes into account the nop delay)
	unsigned buffers_available[3];
	unsigned databuffers_available[3];
 
	/**  verify_output() MUST run after produce_inputs, 
	     so when produce_inputs is done, do a notification
	*/
	sc_event input_produced;
 
	///Nop delay is done simply be shifting data inside an array
	NopInfo nop_delay[NOP_COUNTER_DELAY];
 
	///<Variable used to track the construction of the history structure
	/** The history structure is build from reading the output of the
		flow_control module.  All these variables are used to build up
		the current_history_entry which is then stored in the history\
		structure
	*/
	HistoryEntry current_history_entry;
	bool history_second_dword_next;
	bool history_crc_next;
	int history_data_count;
	bool history_ignore_nop_crc;
	int history_ack_value;
 
	///The count of packet received (for the retry mode)
	sc_uint<8>	next_node_ack_value_pending;
	sc_uint<8>	next_node_ack_value;
 
	///If the dword of the flow control should be ignored when calculating the ack valeu
	/** For the history structure, every entry has an ack value.  This value is updated
		by observing the control packets sent from flow_control output.  When the first
		dword of a quad word packet is sent, ignore_next_dword_for_ack is set so that the
		second dword is simply ignored.
	*/
	bool ignore_next_dword_for_ack;
 
	///If we are in a retry sequence (set by start retry sequence)
	bool retry_sequence;
	///The simulated history structure
	std::deque<HistoryEntry> retry_playback_history;
	///Next dword will be second dword of command packet
	bool retry_second_dword_next;
	///CRC of entry is next
	bool retry_crc_next;
	///Nop can be inserted in stream, after a nop, we expect a Nop CRC
	/**Nop crc will be contained in expected dword structure*/
	bool retry_expect_nop_crc;
	///The amount of data that has been received for an entry
	int retry_data_count;
	///Set after a command packet, if it has data associated to it (in retry sequence)
	/**Cleared when all data is received*/
	bool retry_receive_data;
 
	///Link is disconnected for retry reasons
	/**  When the flow_control says to the link to disconnect, it takes some cycles
	     before the output is correct again (the link would take some cycles to
		 correctly reconnect.  So when a retry sequence is started, retry_disconnect is
		 set until fc_disconnect_lk is false so that the flow_control output is ignored.
	*/
	bool retry_disconnect;
 
	///Becomes true when an error is detected
	bool error;
 
	///Simulates the history memory as if it was a real memory
	void simulate_memory();
 
	///Set some variables that control global behavious of Testbench over time
	/** It set the percentage of chance of all the */
	void control_testbench();
	///Produces random packets for all inputs of the flow_control
	void produce_inputs();
	///Verifies that the output of the design is correct
	void verify_output();
	///Generate a random response packet
	/**
		@param pkt The generated packet returned by address
		@param data_size The generated packet data size returned by address
	*/
	void generate_random_response(sc_bv<32> &pkt, unsigned &data_size);
	///Generate a random posted packet
	/**
		@param pkt The generated packet returned by address
		@param data_size The generated packet data size returned by address
	*/
	void generate_random_posted(sc_bv<64> &pkt, unsigned &data_size);
	///Generate a random non posted packet
	/**
		@param pkt The generated packet returned by address
		@param data_size The generated packet data size returned by address
	*/
	void generate_random_nposted(sc_bv<64> &pkt, unsigned &data_size);
 
	///Generate a random packet of any Virtual Channel
	/**
		@param pkt The generated packet returned by address
		@param data_size The generated packet data size returned by address
	*/
	VirtualChannel generate_random_packet(sc_bv<64> &pkt, unsigned &data_size);
 
	///Generate a random 32-bit vecgtor
	/**
		@param vector The random vector returned by address
	*/
	void getRandomVector(sc_bv<32> &vector);
 
	///Generate a random 64-bit vecgtor
	/**
		@param vector The random vector returned by address
	*/
	void getRandomVector(sc_bv<64> &vector);
 
	///Add data packet to the list of packet sent to FC from UI
	/**
		@param datalength The number of dwords of data
		@param ui_vc The virtual channel of the packet
		@param associated_control_packet The command packet associated to the data packet
	*/
	void add_ui_data_packet(unsigned datalength,
							VirtualChannel ui_vc,
							sc_bv<64> &associated_control_packet);
 
	///Sets the databuffer_data variable
	/**
		@param datalength The number of dwords of data
		@param ui_vc The virtual channel of the packet
		@param associated_control_packet The command packet associated to the data packet
	*/
	void update_databuffer_entry(unsigned datalength,
								VirtualChannel ui_vc,
								sc_uint<4> &data_address);
 
	///Update CRC1
	/**
		@param dword Dword to use to calculate the new value of CRC1
		@param dword LCTL value to use to calculate the new value of CRC1
		@param dword HCTL value to use to calculate the new value of CRC1
	*/
	void calculate_crc1(sc_bv<32> dword,bool lctl, bool hctl);
 
	///Update CRC2
	/**
		@param dword Dword to use to calculate the new value of CRC2
		@param dword LCTL value to use to calculate the new value of CRC2
		@param dword HCTL value to use to calculate the new value of CRC2
	*/
	void calculate_crc2(sc_bv<32> dword,bool lctl, bool hctl);
 
	///Updates a CRC with 34 bits of data
	/**
		@param crc The CRC to update (by address)
		@param data The 34 bits to calculate the CRC on
	*/
	void calculate_crc(unsigned &crc,sc_bv<34> &data);
 
	///Clears all next node buffer status
	/** This clears all information about the number of free buffers and
	    the number of advertised buffers
	*/
	void clear_next_node_information();
 
	///Adds the CRC of a data packet to the list of expected dwords
	/**@param data The data packet with it's associated command packet
	*/
	void add_expected_crc_for_packet(PacketData &data);
 
	///Takes care of everything necessary to verify when a retry sequence is start
	/** Should be called when a disconnect nop is received in retry mode : it will
	    take care of expecting the CRC that will follow the NOP*/
	void start_retry_sequence();
 
	///Checks correctness of what is sent in retry sequence
	/** Called by verify_output when in the retry sequence */
	void manage_retry_sequence();
	///Manages the history of packet sent
	/** From the output of the flow_control , a history of packet sent is build so 
	    that when a retry sequence occurs, what is resent by the flow control can
		be compared to what is stored in that history*/
	void manage_history();
 
	///Frees random number of buffers in the next node
	/** Flow control sends packets to the next node, which would fill buffers in a
	    real system.  These real packets would eventually be read and the buffers
		freed.  So this method randomly frees buffers*/
	void free_buffers();
	///Updates the buffers count and ack number on the other side when packets are received
	void manage_ack_buffer_count();
	///Generates nops from the next node (acks history and frees buffers)
	void send_next_node_nops();
 
};
 
///Function to allow to output the status to an outputstream
ostream &operator<<(ostream &out,const flow_control_l2_tb::FlowControlStatus fc_status);
 
#endif