Subversion Repositories ht_tunnel

//reordering_l2.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>
 *   Laurent Aubray
 *
 * 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 "reordering_l2.h"
 
#include "entrance_reordering_l3.h"
#include "final_reordering_l3.h"
#include "posted_vc_l3.h"
#include "nposted_vc_l3.h"
#include "response_vc_l3.h"
#include "nophandler_l3.h"
#include "address_manager_l3.h"
#include "fetch_packet_l3.h"
 
/// Main constructor
reordering_l2::reordering_l2(sc_module_name name): sc_module(name)
{
 
	SC_METHOD(doOrFwdEhAck);
	sensitive << fwd_ack_ro << eh_ack_ro;
 
	SC_METHOD(or_overflows);
	sensitive << vc_overflow[0] << vc_overflow[1] << vc_overflow[2];
 
	SC_METHOD(wire_through);
	sensitive << cd_available_ro << ro_packet_accepted;
 
	/***********************************************
		vcBuffersLinking
	***********************************************/
 
 
	/////////////////////////////////////////
	//POSTED Buffer
	/////////////////////////////////////////
	vc_pc_module = new posted_vc_l3("VC_PC");
 
	vc_pc_module->clk(clk);
	vc_pc_module->resetx(resetx);
	vc_pc_module->buffers_cleared(buffers_cleared[VC_POSTED]);
 
	for(int n = 0; n < 2; n++){
		vc_pc_module->out_packet_addr[n](posted_packet_addr[n]);
#ifdef ENABLE_REORDERING
		vc_pc_module->out_packet_passpw[n](posted_packet_passpw[n]);
		vc_pc_module->out_packet_seqid[n](posted_packet_seqid[n]);
		vc_pc_module->out_packet_chain[n](posted_packet_chain[n]);
		vc_pc_module->out_packet_nposted_refid[n](posted_packet_nposted_refid[n]);
		vc_pc_module->out_packet_response_refid[n](posted_packet_response_refid[n]);
#endif
		vc_pc_module->packet_available[n](posted_available[n]);
		vc_pc_module->acknowledge[n](ack_posted[n]);
 
		vc_pc_module->in_packet_destination[n](destination_pc[n]);
	}
 
 
	vc_pc_module->in_packet_addr(new_packet_addr);
#ifdef ENABLE_REORDERING
	vc_pc_module->in_packet_chain(new_packet_chain);
	vc_pc_module->in_packet_passpw(new_packet_passpw);
	vc_pc_module->in_packet_seqid(new_packet_seqid);
 
	vc_pc_module->in_packet_clumped_unitid(new_packet_clumped_unitid);
	vc_pc_module->unitid_reorder_disable(csr_unitid_reorder_disable);
	vc_pc_module->nposted_refid_rejected(nposted_refid_rejected);
	vc_pc_module->response_refid_rejected(response_refid_rejected);
	vc_pc_module->nposted_refid_accepted(nposted_refid_accepted);
	vc_pc_module->response_refid_accepted(response_refid_accepted);
#endif
 
	vc_pc_module->vc_overflow(vc_overflow[VC_POSTED]);
 
	/////////////////////////////////////////
	//NON POSTED Buffer
	/////////////////////////////////////////
	vc_npc_module = new nposted_vc_l3("VC_NPC");
 
	vc_npc_module->clk(clk);
	vc_npc_module->resetx(resetx);
 
	vc_npc_module->buffers_cleared(buffers_cleared[VC_NON_POSTED]);
 
	for(int n = 0; n < 2; n++){
		vc_npc_module->out_packet_addr[n](nposted_packet_addr[n]);
#ifdef ENABLE_REORDERING
		vc_npc_module->out_packet_passpw[n](nposted_packet_passpw[n]);
		vc_npc_module->out_packet_seqid[n](nposted_packet_seqid[n]);
#endif
		vc_npc_module->packet_available[n](nposted_available[n]);
		vc_npc_module->acknowledge[n](ack_nposted[n]);
 
		vc_npc_module->in_packet_destination[n](destination_npc[n]);
	}
 
 
	vc_npc_module->in_packet_addr(new_packet_addr);
#ifdef ENABLE_REORDERING
	vc_npc_module->in_packet_passpw(new_packet_passpw);
	vc_npc_module->in_packet_seqid(new_packet_seqid);
 
	vc_npc_module->in_packet_clumped_unitid(new_packet_clumped_unitid);
	vc_npc_module->unitid_reorder_disable(csr_unitid_reorder_disable);
#endif
 
	vc_npc_module->vc_overflow(vc_overflow[VC_NON_POSTED]);
 
	/////////////////////////////////////////
	//RESPONSE Buffer
	/////////////////////////////////////////
	vc_rc_module = new response_vc_l3("VC_RC");
 
	vc_rc_module->clk(clk);
	vc_rc_module->resetx(resetx);
 
	vc_rc_module->buffers_cleared(buffers_cleared[VC_RESPONSE]);
 
	for(int n = 0; n < 2; n++){
		vc_rc_module->out_packet_addr[n](response_packet_addr[n]);
#ifdef ENABLE_REORDERING
		vc_rc_module->out_packet_passpw[n](response_packet_passpw[n]);
#endif
		vc_rc_module->packet_available[n](response_available[n]);
		vc_rc_module->acknowledge[n](ack_response[n]);
 
		vc_rc_module->in_packet_destination[n](destination_rc[n]);
 
	}
 
	vc_rc_module->in_packet_addr(new_packet_addr);
#ifdef ENABLE_REORDERING
	vc_rc_module->in_packet_passpw(new_packet_passpw);
	vc_rc_module->unitid_reorder_disable(csr_unitid_reorder_disable);
#endif
 
	vc_rc_module->vc_overflow(vc_overflow[VC_RESPONSE]);
 
 
	/*****************************************
		entranceReorderingLinking
	*****************************************/
 
	entranceReorderingModule = new entrance_reordering_l3("The_Entrance_Reordering");
 
	entranceReorderingModule->clk(clk);
	entranceReorderingModule->resetx(resetx);
 
	entranceReorderingModule->in_packet(cd_packet_ro);
	entranceReorderingModule->packet_available(cd_available_ro);
	entranceReorderingModule->unit_id(csr_unit_id);
#ifdef ENABLE_DIRECTROUTE
	entranceReorderingModule->csr_direct_route_enable(csr_direct_route_enable);
#endif
	entranceReorderingModule->csr_memory_space_enable(csr_memory_space_enable);
	entranceReorderingModule->csr_io_space_enable(csr_io_space_enable);
 
#ifdef ENABLE_REORDERING
	entranceReorderingModule->new_packet_passPW(new_packet_passpw);
	entranceReorderingModule->new_packet_chain(new_packet_chain);
	entranceReorderingModule->new_packet_seqid(new_packet_seqid);
	entranceReorderingModule->nposted_refid_rejected(nposted_refid_rejected);
	entranceReorderingModule->response_refid_rejected(response_refid_rejected);
	entranceReorderingModule->nposted_refid_accepted(nposted_refid_accepted);
	entranceReorderingModule->response_refid_accepted(response_refid_accepted);
#endif
 
	entranceReorderingModule->ro_command_packet_wr_data(ro_command_packet_wr_data);
 
	for(int n = 0; n < NbRegsBars; n++){
		entranceReorderingModule->csr_bar[n](csr_bar[n]);
	}
 
	for(int n = 0; n < 2; n++){
		entranceReorderingModule->destination_pc[n](destination_pc[n]);
		entranceReorderingModule->destination_npc[n](destination_npc[n]);
		entranceReorderingModule->destination_rc[n](destination_rc[n]);
	}
 
	for(int n = 0; n < 3; n++){
		entranceReorderingModule->new_packet_available[n](new_packet_available[n]);
	}
 
#ifdef ENABLE_REORDERING
 
 
	entranceReorderingModule->new_packet_clumped_unitid(new_packet_clumped_unitid);
	for(int n = 0; n < 32; n++){
		entranceReorderingModule->clumped_unit_id[n](clumped_unit_id[n]);
	}
#else
	for(int n = 0; n < 4; n++){
		entranceReorderingModule->clumped_unit_id[n](clumped_unit_id[n]);
	}
#endif
 
#ifdef RETRY_MODE_ENABLED
	entranceReorderingModule->input_packet_vc(input_packet_vc);
#endif
 
	/***************************************
		finalReorderingLinking
	***************************************/
 
	finalReorderingModule = new final_reordering_l3("final_reordering");
 
	finalReorderingModule->clk(clk);
	finalReorderingModule->resetx(resetx);
 
	for(int destination = 0; destination <2 ; destination++){
		finalReorderingModule->posted_requested[destination](posted_requested[destination]);
		finalReorderingModule->nposted_requested[destination](nposted_requested[destination]);
		finalReorderingModule->response_requested[destination](response_requested[destination]);
 
		finalReorderingModule->fetched_packet[destination](fetched_packet[destination]);
		finalReorderingModule->fetched_packet_available[destination](fetched_packet_available[destination]);
		finalReorderingModule->fetched_packet_vc[destination](fetched_packet_vc[destination]);
 
		finalReorderingModule->fetched_packet_nposted_refid[destination](fetched_packet_nposted_refid[destination]);
		finalReorderingModule->fetched_packet_response_refid[destination](fetched_packet_response_refid[destination]);
	}
 
	finalReorderingModule->out_packet_accepted(ro_packet_accepted);
	finalReorderingModule->out_packet_fwd(ro_packet_fwd);
	finalReorderingModule->out_packet_vc_fwd(ro_packet_vc_fwd);
 
 
 
	finalReorderingModule->out_packet_available_csr(ro_available_csr);
	finalReorderingModule->out_packet_available_ui(ro_available_ui);
	finalReorderingModule->out_packet_available_fwd(ro_available_fwd);
 
	finalReorderingModule->ack[FWD_DEST](orFwdEhAck);
	finalReorderingModule->ack[CSR_DEST](csr_ack_ro);
	finalReorderingModule->ack[UI_DEST](ui_ack_ro);
 
	finalReorderingModule->cd_data_pending_ro(cd_data_pending_ro);
	finalReorderingModule->cd_data_pending_addr_ro(cd_data_pending_addr_ro);
 
	finalReorderingModule->csr_sync(csr_sync);
	finalReorderingModule->fwd_next_node_buffer_status_ro(fwd_next_node_buffer_status_ro);
 
	/**************************************
		nopHandlerLinking
	**************************************/
 
	nopHandlerModule = new nophandler_l3("The_Nop_Handler");
 
	nopHandlerModule->clk(clk);
	nopHandlerModule->resetx(resetx);
	nopHandlerModule->fc_nop_sent(fc_nop_sent);
 
	for(int n = 0; n < 3; n++){
		nopHandlerModule->received_packet[n](new_packet_available[n]);
		nopHandlerModule->buffers_cleared[n](buffers_cleared[n]);
	}
 
	nopHandlerModule->ro_nop_req_fc(ro_nop_req_fc);
	nopHandlerModule->ro_buffer_cnt_fc(ro_buffer_cnt_fc);
 
#ifdef RETRY_MODE_ENABLED
	nopHandlerModule->lk_rx_connected(lk_rx_connected);
	nopHandlerModule->csr_retry(csr_retry);
	nopHandlerModule->cd_received_non_flow_stomped_ro(cd_received_non_flow_stomped_ro);
	nopHandlerModule->input_packet_vc(input_packet_vc);
#endif
 
	/**************************************
		Address Manager Linking
	**************************************/
 
	addressManagerModule = new address_manager_l3("CMD_Address_Manager");
	addressManagerModule->clk(clk);
	addressManagerModule->resetx(resetx);
	addressManagerModule->use_address(cd_available_ro);
	for(int n = 0; n < 3; n++){
		addressManagerModule->new_packet_available[n](new_packet_available[n]);
		addressManagerModule->buffers_cleared[n](buffers_cleared[n]);
	}
	addressManagerModule->ro_command_packet_wr_addr(ro_command_packet_wr_addr);
	addressManagerModule->new_packet_addr(new_packet_addr);
 
	addressManagerModule->ro_command_packet_rd_addr[0](ro_command_packet_rd_addr[0]);
	addressManagerModule->ro_command_packet_rd_addr[1](ro_command_packet_rd_addr[1]);
 
	/**************************************
		Fetch Packet Module Linking
	**************************************/
	fetchPacketModule = new fetch_packet_l3("CMD_fetch_packet");
 
	fetchPacketModule->clk(clk);
	fetchPacketModule->resetx(resetx);
 
	for(int destination = 0; destination < 2; destination++){
		//Packet from posted buffers
		fetchPacketModule->posted_packet_addr[destination](posted_packet_addr[destination]);
#ifdef ENABLE_REORDERING
		fetchPacketModule->posted_packet_passpw[destination](posted_packet_passpw[destination]);
		fetchPacketModule->posted_packet_seqid[destination](posted_packet_seqid[destination]);
		fetchPacketModule->posted_packet_chain[destination](posted_packet_chain[destination]);
		fetchPacketModule->posted_packet_nposted_refid[destination](posted_packet_nposted_refid[destination]);
		fetchPacketModule->posted_packet_response_refid[destination](posted_packet_response_refid[destination]);
#endif
		fetchPacketModule->posted_available[destination](posted_available[destination]);
 
		//Packet from nposted buffers
		fetchPacketModule->nposted_packet_addr[destination](nposted_packet_addr[destination]);
#ifdef ENABLE_REORDERING
		fetchPacketModule->nposted_packet_passpw[destination](nposted_packet_passpw[destination]);
		fetchPacketModule->nposted_packet_seqid[destination](nposted_packet_seqid[destination]);
#endif
		fetchPacketModule->nposted_available[destination](nposted_available[destination]);
 
		//Packet from response buffers
		fetchPacketModule->response_packet_addr[destination](response_packet_addr[destination]);
#ifdef ENABLE_REORDERING
		fetchPacketModule->response_packet_passpw[destination](response_packet_passpw[destination]);
#endif
		fetchPacketModule->response_available[destination](response_available[destination]);
 
		//Data from memory
		fetchPacketModule->command_packet_rd_data_ro[destination](command_packet_rd_data_ro[destination]);
 
		//Packet types requested
		fetchPacketModule->posted_requested[destination](posted_requested[destination]);
		fetchPacketModule->nposted_requested[destination](nposted_requested[destination]);
		fetchPacketModule->response_requested[destination](response_requested[destination]);
 
		fetchPacketModule->ack_posted[destination](ack_posted[destination]);
		fetchPacketModule->ack_nposted[destination](ack_nposted[destination]);
		fetchPacketModule->ack_response[destination](ack_response[destination]);
 
		//Actual retrieved packet
		fetchPacketModule->fetched_packet[destination](fetched_packet[destination]);
		fetchPacketModule->fetched_packet_available[destination](fetched_packet_available[destination]);
		fetchPacketModule->fetched_packet_vc[destination](fetched_packet_vc[destination]);
 
		fetchPacketModule->fetched_packet_nposted_refid[destination](fetched_packet_nposted_refid[destination]);
		fetchPacketModule->fetched_packet_response_refid[destination](fetched_packet_response_refid[destination]);
 
	}
 
	//Address to retrieve data from memory
	fetchPacketModule->ro_command_packet_rd_addr[0](ro_command_packet_rd_addr[0]);
	fetchPacketModule->ro_command_packet_rd_addr[1](ro_command_packet_rd_addr[1]);
}
 
 
void reordering_l2::doOrFwdEhAck(){
	orFwdEhAck = fwd_ack_ro.read() || eh_ack_ro.read();
}
 
void reordering_l2::or_overflows(){
	ro_overflow_csr = vc_overflow[0].read() || vc_overflow[1].read() || vc_overflow[2].read();
}
 
void reordering_l2::wire_through(){
	ro_command_packet_write = cd_available_ro;
	ro_packet_ui = ro_packet_accepted;
	ro_packet_csr = ro_packet_accepted;
}
 
#ifdef SYSTEMC_SIM
reordering_l2::~reordering_l2(){
	delete vc_pc_module;
	delete vc_npc_module;
	delete vc_rc_module;
	delete entranceReorderingModule;
	delete finalReorderingModule;
	delete nopHandlerModule;
}
#endif