URL
https://opencores.org/ocsvn/ht_tunnel/ht_tunnel/trunk
Subversion Repositories ht_tunnel
[/] [ht_tunnel/] [trunk/] [bench/] [decoder_l2/] [main.cpp] - Rev 19
Compare with Previous | Blame | View Log
//main.cpp for decoder_l2 testbench /* ***** 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 "../../rtl/systemc/core_synth/synth_datatypes.h" #include "../../rtl/systemc/core_synth/constants.h" #include "decoder_l2_tb.h" #include "../../rtl/systemc/decoder_l2/decoder_l2.h" #include "../../rtl/systemc/decoder_l2/cd_counter_l3.h" #include "../../rtl/systemc/decoder_l2/cd_packet_crc_l3.h" #include <iostream> #include <string> #include <sstream> #include <iomanip> #include <time.h> using namespace std; int sc_main( int argc, char* argv[] ){ //The Design Under Test decoder_l2* dut = new decoder_l2("decoder_l2"); //The TestBench decoder_l2_tb* tb = new decoder_l2_tb("decoder_l2_tb"); //Signals used to link the design to the testbench sc_clock clk("clk", 1); // system clk ///Warm Reset to initialize module sc_signal < bool > resetx; //******************************* // Signals for Control Buffer //******************************* /**Packet to be transmitted to control buffer module*/ sc_signal< syn_ControlPacketComplete > cd_packet_ro; /**Enables control buffer module to read cd_packet_ro port*/ sc_signal< bool > cd_available_ro; /**If we're currently receiving data. This is used by the ro to know if we have finished receiving the data of a packet, so it can know if it can send it.*/ sc_signal<bool> cd_data_pending_ro; /**Where we are storing data. This is used by the ro to know if we have finished receiving the data of a packet, so it can know if it can send it.*/ sc_signal<sc_uint<BUFFERS_ADDRESS_WIDTH> > cd_data_pending_addr_ro; //******************************* // Signals for Data Buffer //******************************* ///ddress of data in data buffer module sc_signal< sc_uint<BUFFERS_ADDRESS_WIDTH> > db_address_cd; ///Get an address form data buffer module sc_signal< bool > cd_getaddr_db; ///Size of data packet to be written sc_signal< sc_uint<4> > cd_datalen_db; ///Virtual channel where data will be written sc_signal< VirtualChannel > cd_vctype_db; ///Data to be written in data buffer module sc_signal< sc_bv<32> > cd_data_db; ///Enables data buffer to read cd_data_db port sc_signal< bool > cd_write_db; #ifdef RETRY_MODE_ENABLED ///Erase signal for packet stomping sc_signal< bool > cd_drop_db; #endif //************************************* // Signals to CSR //************************************* ///A protocol error has been detected sc_signal< bool > cd_protocol_error_csr; ///A sync packet has been received sc_signal< bool > cd_sync_detected_csr; #ifdef RETRY_MODE_ENABLED ///If retry mode is active sc_signal< bool > csr_retry; #endif //******************************* // Signals from link //******************************* ///Bit vector input from the FIFO sc_signal< sc_bv<32> > lk_dword_cd; ///Control bit sc_signal< bool > lk_hctl_cd; ///Control bit sc_signal< bool > lk_lctl_cd; ///FIFO is ready to be read from sc_signal< bool > lk_available_cd; #ifdef RETRY_MODE_ENABLED ///If a retry sequence is initiated by link sc_signal< bool > lk_initiate_retry_disconnect; #endif //******************************* // Signals for Forwarding module //******************************* #ifdef RETRY_MODE_ENABLED ///History count sc_signal< sc_uint<8> > cd_rx_next_pkt_to_ack_fc; ///rxPacketToAck (retry mode) sc_signal< sc_uint<8> > cd_nop_ack_value_fc; #endif ///Info registered from NOP word sc_signal< sc_bv<12> > cd_nopinfo_fc; ///Signal that new nop info are available sc_signal< bool > cd_nop_received_fc; #ifdef RETRY_MODE_ENABLED ///Start the sequence for a retry disconnect sc_signal< bool > cd_initiate_retry_disconnect; ///A stomped packet has been received sc_signal<bool> cd_received_stomped_csr; ///Let the reordering know we received a non flow control stomped packet /** When this situation happens, packet available bit does not become asserted but the correct packet is sent, which can be used to know from which VC to free a flow control credit. */ sc_signal<bool> cd_received_non_flow_stomped_ro; #endif ///The link can start a sequence for a ldtstop disconnect sc_signal< bool > cd_initiate_nonretry_disconnect_lk; //////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////// // DUT connections //////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////// //Signals used to link the design to the testbench dut->clk(clk); dut->resetx(resetx); dut->cd_packet_ro(cd_packet_ro); dut->cd_available_ro(cd_available_ro); dut->cd_data_pending_ro(cd_data_pending_ro); dut->cd_data_pending_addr_ro(cd_data_pending_addr_ro); dut->db_address_cd(db_address_cd); dut->cd_getaddr_db(cd_getaddr_db); dut->cd_datalen_db(cd_datalen_db); dut->cd_vctype_db(cd_vctype_db); dut->cd_data_db(cd_data_db); dut->cd_write_db(cd_write_db); #ifdef RETRY_MODE_ENABLED dut->cd_drop_db(cd_drop_db); #endif dut->cd_protocol_error_csr(cd_protocol_error_csr); dut->cd_sync_detected_csr(cd_sync_detected_csr); #ifdef RETRY_MODE_ENABLED dut->csr_retry(csr_retry); #endif dut->lk_dword_cd(lk_dword_cd); dut->lk_hctl_cd(lk_hctl_cd); dut->lk_lctl_cd(lk_lctl_cd); dut->lk_available_cd(lk_available_cd); #ifdef RETRY_MODE_ENABLED dut->lk_initiate_retry_disconnect(lk_initiate_retry_disconnect); #endif #ifdef RETRY_MODE_ENABLED dut->cd_rx_next_pkt_to_ack_fc(cd_rx_next_pkt_to_ack_fc); dut->cd_nop_ack_value_fc(cd_nop_ack_value_fc); #endif dut->cd_nopinfo_fc(cd_nopinfo_fc); dut->cd_nop_received_fc(cd_nop_received_fc); #ifdef RETRY_MODE_ENABLED dut->cd_initiate_retry_disconnect(cd_initiate_retry_disconnect); dut->cd_received_stomped_csr(cd_received_stomped_csr); dut->cd_received_non_flow_stomped_ro(cd_received_non_flow_stomped_ro); #endif dut->cd_initiate_nonretry_disconnect_lk(cd_initiate_nonretry_disconnect_lk); //////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////// // TB connections //////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////// tb->clk(clk); tb->resetx(resetx); tb->cd_packet_ro(cd_packet_ro); tb->cd_available_ro(cd_available_ro); tb->cd_data_pending_ro(cd_data_pending_ro); tb->cd_data_pending_addr_ro(cd_data_pending_addr_ro); tb->db_address_cd(db_address_cd); tb->cd_getaddr_db(cd_getaddr_db); tb->cd_datalen_db(cd_datalen_db); tb->cd_vctype_db(cd_vctype_db); tb->cd_data_db(cd_data_db); tb->cd_write_db(cd_write_db); #ifdef RETRY_MODE_ENABLED tb->cd_drop_db(cd_drop_db); #endif tb->cd_protocol_error_csr(cd_protocol_error_csr); tb->cd_sync_detected_csr(cd_sync_detected_csr); #ifdef RETRY_MODE_ENABLED tb->csr_retry(csr_retry); #endif tb->lk_dword_cd(lk_dword_cd); tb->lk_hctl_cd(lk_hctl_cd); tb->lk_lctl_cd(lk_lctl_cd); tb->lk_available_cd(lk_available_cd); #ifdef RETRY_MODE_ENABLED tb->lk_initiate_retry_disconnect(lk_initiate_retry_disconnect); #endif #ifdef RETRY_MODE_ENABLED tb->cd_rx_next_pkt_to_ack_fc(cd_rx_next_pkt_to_ack_fc); tb->cd_nop_ack_value_fc(cd_nop_ack_value_fc); #endif tb->cd_nopinfo_fc(cd_nopinfo_fc); tb->cd_nop_received_fc(cd_nop_received_fc); #ifdef RETRY_MODE_ENABLED tb->cd_initiate_retry_disconnect(cd_initiate_retry_disconnect); tb->cd_received_stomped_csr(cd_received_stomped_csr); tb->cd_received_non_flow_stomped_ro(cd_received_non_flow_stomped_ro); #endif tb->cd_initiate_nonretry_disconnect_lk(cd_initiate_nonretry_disconnect_lk); //////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////// // Trace signals //////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////// sc_trace_file *tf = sc_create_vcd_trace_file("sim_decoder_l2"); sc_trace(tf,clk,"clk"); sc_trace(tf,resetx,"resetx"); sc_trace(tf,cd_packet_ro,"cd_packet_ro"); sc_trace(tf,cd_available_ro,"cd_available_ro"); sc_trace(tf,cd_data_pending_ro,"cd_data_pending_ro"); sc_trace(tf,cd_data_pending_addr_ro,"cd_data_pending_addr_ro"); sc_trace(tf,db_address_cd,"db_address_cd"); sc_trace(tf,cd_getaddr_db,"cd_getaddr_db"); sc_trace(tf,cd_datalen_db,"cd_datalen_db"); sc_trace(tf,cd_vctype_db,"cd_vctype_db"); sc_trace(tf,cd_data_db,"cd_data_db"); sc_trace(tf,cd_write_db,"cd_write_db"); #ifdef RETRY_MODE_ENABLED sc_trace(tf,cd_drop_db,"cd_drop_db"); #endif sc_trace(tf,cd_protocol_error_csr,"cd_protocol_error_csr"); sc_trace(tf,cd_sync_detected_csr,"cd_sync_detected_csr"); #ifdef RETRY_MODE_ENABLED sc_trace(tf,csr_retry,"csr_retry"); #endif sc_trace(tf,lk_dword_cd,"lk_dword_cd"); sc_trace(tf,lk_hctl_cd,"lk_hctl_cd"); sc_trace(tf,lk_lctl_cd,"lk_lctl_cd"); sc_trace(tf,lk_available_cd,"lk_available_cd"); #ifdef RETRY_MODE_ENABLED sc_trace(tf,lk_initiate_retry_disconnect,"lk_initiate_retry_disconnect"); #endif #ifdef RETRY_MODE_ENABLED sc_trace(tf,cd_rx_next_pkt_to_ack_fc,"cd_rx_next_pkt_to_ack_fc"); sc_trace(tf,cd_nop_ack_value_fc,"cd_nop_ack_value_fc"); #endif sc_trace(tf,cd_nopinfo_fc,"cd_nopinfo_fc"); sc_trace(tf,cd_nop_received_fc,"cd_nop_received_fc"); #ifdef RETRY_MODE_ENABLED sc_trace(tf,cd_initiate_retry_disconnect,"cd_initiate_retry_disconnect"); sc_trace(tf,cd_received_stomped_csr,"cd_received_stomped_csr"); #endif sc_trace(tf,cd_initiate_nonretry_disconnect_lk,"cd_initiate_nonretry_disconnect_lk"); sc_trace(tf,dut->CNT->setCnt,"CNT.setCnt"); sc_trace(tf,dut->CNT->decrCnt,"CNT.decrCnt"); sc_trace(tf,dut->CNT->data,"CNT.data"); sc_trace(tf,dut->CNT->end_of_count,"CNT.end_of_count"); sc_trace(tf,dut->packet_crc_unit->crc1_enable,"CRC.crc1_enable"); sc_trace(tf,dut->packet_crc_unit->crc2_enable,"CRC.crc2_enable"); sc_trace(tf,dut->packet_crc_unit->crc1_reset,"CRC.crc1_reset"); sc_trace(tf,dut->packet_crc_unit->crc2_reset,"CRC.crc2_reset"); sc_trace(tf,dut->packet_crc_unit->crc1_good,"CRC.crc1_good"); sc_trace(tf,dut->packet_crc_unit->crc2_good,"CRC.crc2_good"); sc_trace(tf,dut->packet_crc_unit->crc1_stomped,"CRC.crc1_stomped"); sc_trace(tf,dut->packet_crc_unit->crc2_stomped,"CRC.crc2_stomped"); //------------------------------------------ // Start simulation //------------------------------------------ cout << "Start of Decoder simulation" << endl; sc_start(200); sc_close_vcd_trace_file(tf); cout << "End of simulation" << endl; delete dut; delete tb; return 0; }