Subversion Repositories ht_tunnel

//history_buffer_l3_tb.cpp
/* ***** 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 ***** */
 
#include "history_buffer_l3_tb.h"
#include "../../../rtl/systemc/flow_control_l2/history_buffer_l3.h"
#include <cstdlib>
#include <sstream>
 
using namespace std;
 
history_buffer_l3_tb::history_buffer_l3_tb(sc_module_name name) : sc_module(name){
	SC_THREAD(simulate_memory);
	sensitive_pos(clk);
 
	SC_THREAD(stimulus);
	sensitive_pos(clk);
 
	srand(8955);
	write_ack_number = 0;
	read_ack_number = 0;
	current_history_size = 0;
	internal_write_pos = 0;
}
 
void history_buffer_l3_tb::simulate_memory(){
	while(true){
		wait();
		if(history_memory_read_address.read() >= HISTORY_MEMORY_SIZE){
			cout << "Error, read address outside valid range" << endl;
			break;
		}
		history_memory_output = (sc_uint<32>)history_memory[history_memory_read_address.read()];
 
		if(history_memory_write.read()){
			if(history_memory_write_address.read() >= HISTORY_MEMORY_SIZE){
				cout << "Error, write address outside valid range" << endl;
				break;
			}
			history_memory[history_memory_write_address.read()] = 
				(unsigned)(sc_uint<32>)history_memory_write_data.read();
		}
	}
}
 
/*
	sc_in <sc_bv<32> > history_packet;
	sc_in <bool > history_playback_done;
	sc_in <bool > room_available_in_history;
	sc_in <bool > history_playback_ready;
 
	sc_out <bool > consume_history;
	sc_out <bool > begin_history_playback;
	sc_out <bool > add_to_history;
	sc_out <bool > new_history_entry;
	sc_out <sc_uint<5> > new_history_entry_size_m1;
	sc_out<sc_bv<32> > fc_dword_lk;
	sc_out<bool>	nop_received;
	sc_out<sc_uint<8> >	ack_value;
 
	sc_out<bool>	resetx;
*/
 
void history_buffer_l3_tb::stimulus(){
	consume_history = false;
	begin_history_playback = false;
	add_to_history = false;
	new_history_entry = false;
	new_history_entry_size_m1 = 0;
	fc_dword_lk = 0;
	nop_received = false;
	write_ack_number = 0;
	read_ack_number = 0;
 
 
	///////////////////////////////////
	// Test two short retry sequences
	///////////////////////////////////
	resetx = false;
 
	for(int n = 0; n < 3; n++) wait();
	resetx = true;
 
	try{
		send_random_packets(4);
		ack_packets(2);
		send_random_packets(2);
		ack_packets(1);
		send_random_packets(2);
		ack_packets(3);
 
		playback_history();
 
		ack_packets(1);
		send_random_packets(4);
		ack_packets(3);
 
		ack_packets(1);
 
		while(internal_write_pos > 18){
			send_random_packets(1);
		}
 
		playback_history();
 
		///////////////////////////////////
		// Test room_available_in_history
		///////////////////////////////////
 
		while((HISTORY_MEMORY_SIZE - current_history_size) > 18){
			if(!room_available_in_history.read()){
				cout << "HISTORY_MEMORY_SIZE: " << HISTORY_MEMORY_SIZE << endl;
				cout << "current_history_size: " << current_history_size << endl;
				throw SimulationException(
				"room_available_in_history is false when it should be true");
			}
			send_random_packets(1);
 
		}
		if(room_available_in_history.read())
			throw SimulationException(
			"room_available_in_history is true when it should be false");
 
		cout << "SIMULATION COMPLETE" << endl;
	}
	catch(SimulationException se){
		cout << se.data << endl;
	}
}
 
void history_buffer_l3_tb::playback_history(){
 
	//Begin playback
	begin_history_playback = true;
	wait();
 
	//Wait for the history to be ready for playback
	int max_time = 32;
	while(!history_playback_ready.read()){
		if(max_time-- == 0){
			throw SimulationException("Error, playback did not get ready");
		}
		wait();
	}
	begin_history_playback = false;
 
	//Read and check packets in history
	RetryEntry entry;
	for(std::deque<RetryEntry>::iterator i = simulated_history.begin();
		i != simulated_history.end();i++)
	{
		entry = *i;
		int pos = 0;
		while(pos != entry.size){
			if(history_playback_done.read()){
				throw SimulationException(
					"ERROR: History playback done signal asserted before really done");
			}
			if(consume_history.read()){
				if(history_packet.read() != sc_uint<32>(entry.dwords[pos])){
					ostringstream o;
					o << "Error, invalid dword received: " 
						<< history_packet.read().to_string(SC_HEX)
						<< " expected: " << sc_uint<32>(entry.dwords[pos]).to_string(SC_HEX);
					throw SimulationException(o.str());
				}
				pos++;
			}
			consume_history = ((rand() % 10) < 8) && (pos != entry.size);
			wait();
		}
	}
 
	//Verify the playback done signal
	int max_count = 2;
	while(history_playback_done.read()){
		if(--max_count == 0){
			throw SimulationException(
				"ERROR: History playback done signal not asserted when actually done");
		}
		wait();
	}
 
 
}
 
void history_buffer_l3_tb::ack_packets(int number){
	read_ack_number = (read_ack_number + number) % 256;
	ack_value = read_ack_number;
	nop_received = true;
	wait();
	nop_received = false;
	for(int n = 0; n < number; n++){
		current_history_size -= simulated_history.front().size + 1;
		simulated_history.pop_front();
	}
}
 
 
void history_buffer_l3_tb::send_random_packets(int number){
	RetryEntry entry;
	for(int n = 0; n < number; n++){
		generateRandomEntry(&entry);
		simulated_history.push_back(entry);
		new_history_entry = true;
		new_history_entry_size_m1 = entry.size - 1;
		wait();
		new_history_entry = false;
 
		int dwords_sent = 0;
		while(dwords_sent < entry.size){
			bool send = rand() % 10 < 8;
			add_to_history = send;
			if(send) fc_dword_lk = entry.dwords[dwords_sent++];
			wait();
		}
		add_to_history = false;
		current_history_size += entry.size + 1;
		internal_write_pos = (internal_write_pos + entry.size + 1) % 128;
	}
}
 
 
/*
struct RetryEntry{
	int size;
	int identification;
	int	dwords[18];
}
 
*/
void history_buffer_l3_tb::generateRandomEntry(RetryEntry * e){
	e->size = (rand() % 18) + 1;
	e->identification = ++write_ack_number;
	for(int i = 0; i < e->size; i++){
		//Rand can have a MAX_VALUE as low as 32K on some compilers
		e->dwords[i] = rand() & 0xFFF | 
			((rand() & 0xFFF) << 12) |
			((rand() & 0xFF) << 24);
	}
 
	//Clear the last to facilitate detecting errors
	for(int i = e->size; i < 18; i++){
		e->dwords[i] = 0;
	}
 
}