Subversion Repositories ht_tunnel

//history_buffer_l3.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 HISTORY_BUFFER_L3_TB_H
#define HISTORY_BUFFER_L3_TB_H
 
#include "../../../rtl/systemc/core_synth/synth_datatypes.h"
#include <deque>
#include <string>
 
 
 
class history_buffer_l3_tb : public sc_module{
 
	struct RetryEntry{
		int size;
		int identification;
		int	dwords[18];
	};
 
public:
 
	///The output dword when playing back history
	sc_in <sc_bv<32> > history_packet;
	///When the complete history has finished playing back
	sc_in <bool > history_playback_done;
	///To begin the playback of the history from the last acked packet
	sc_out <bool > begin_history_playback;
	///If the playback of the history is ready
	sc_in <bool > history_playback_ready;
	///To consume the data produced by the history buffer
	sc_out <bool > consume_history;
	///The room left in the history, to allow the flow control to know if a packet can be sent
	sc_in <bool > room_available_in_history;
	///To add a dword to the history
	sc_out <bool > add_to_history;
	///To add a new entry to the history, to be done before starting to add to the history
	sc_out <bool > new_history_entry;
	///The size (minus 1) of the new history entry
	sc_out <sc_uint<5> > new_history_entry_size_m1;
 
	///dword being sent to the link, so it can be stored in the buffer
	sc_out<sc_bv<32> > fc_dword_lk;
 
	///When a nop was received : read the new ack_value
	sc_out<bool>	nop_received;
	///The value acked from the next HT node
	sc_out<sc_uint<8> >	ack_value;
 
	///Reset
	sc_out<bool>	resetx;
 
	///Clock
	sc_in<bool> clk;
 
	//////////////////////////////////////////
	//	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;
 
	///SystemC Macro	
	SC_HAS_PROCESS(history_buffer_l3_tb);
 
	///Consctructor
	history_buffer_l3_tb(sc_module_name name);
 
	///The memory that is accessed through the synchronous memory interface
	unsigned int history_memory[HISTORY_MEMORY_SIZE];
 
	///Takes care of writing and reading to memory
	void simulate_memory();
 
	///This is the main thread that stimulates the design to test it
	/** Other functinos are called from here*/
	void stimulus();
 
	///Plays back all the history and verifies that it is correct
	void playback_history();
 
	///Ack a certain number of packets that are in the history
	/** Acked packets are not played back in a replay sequence
		@param number The number of packets to ack
	*/
	void ack_packets(int number);
 
	///Sends random packet to store in the history buffer
	/** Warning : Does not check for memory overflow
	@param number The number of packets to send in history
	*/
	void send_random_packets(int number);
 
	///Generate a random entry (packet) to store in the history
	void generateRandomEntry(RetryEntry * e);
 
	///A software kept version of the history for comparison purpose
	std::deque<RetryEntry> simulated_history;
 
	///Number of elements stored in the history
	int current_history_size;
 
	///What the ack number for packets being written
	/** Increased whenever a packet is written to the buffer
	*/
	int write_ack_number;
	///What packets have beem acked
	/** Incremented whenever packets are acked
	*/
	int read_ack_number;
 
	///Simulated position of the write pointer of the history module
	int internal_write_pos;
 
};
 
///An exception class thrown when an error is detected
class SimulationException{
public:
	std::string data;
	SimulationException(std::string msg) : data(msg) {}
};
 
#endif