Subversion Repositories ht_tunnel

//reordering_l2_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 "reordering_l2_tb.h"

using namespace std;

reordering_l2_tb::reordering_l2_tb(sc_module_name name){

        SC_THREAD(simulate);

        sensitive_pos(clk);

        SC_METHOD(consume_data);

        sensitive << ro_available_csr << ro_available_ui << ro_available_fwd;

        sensitive << read_csr << read_fwd << read_ui;

        SC_METHOD(manage_memories);

        sensitive_pos << clk;

        srand(7941);

}

void reordering_l2_tb::simulate(){

        //Start with a reset

        resetx = false;

        //Randomly set par addresses

        sc_uint<40> tmp_40b[NbRegsBars];

        for(int n = 0; n < NbRegsBars; n++){

                //Generate a random 40-bit vector

                tmp_40b[n].range(14,0) = sc_uint<32>(rand()).range(14,0);

                tmp_40b[n].range(29,15) = sc_uint<32>(rand()).range(14,0);

                tmp_40b[n].range(39,30) = sc_uint<32>(rand()).range(9,0);

        }

        //Lower part of bar is zero, set the random part to zero

        tmp_40b[0].range(Header_BarSlotHarwireSize0_m1,0) = 0;

        if(NbRegsBars > 0) tmp_40b[1].range(Header_BarSlotHarwireSize1_m1,0) = 0;

        if(NbRegsBars > 1) tmp_40b[2].range(Header_BarSlotHarwireSize2_m1,0) = 0;

        if(NbRegsBars > 2) tmp_40b[3].range(Header_BarSlotHarwireSize3_m1,0) = 0;

        if(NbRegsBars > 3) tmp_40b[4].range(Header_BarSlotHarwireSize4_m1,0) = 0;

        if(NbRegsBars > 4) tmp_40b[5].range(Header_BarSlotHarwireSize5_m1,0) = 0;

        for(int n = 0; n < NbRegsBars; n++){

                //Set the bar address

                csr_bar[n] = tmp_40b[n];

        }

        //Choose a random unitID for this node

        csr_unit_id = (sc_uint<5>)sc_uint<32>(rand()).range(4,0);

        //////////////////////////////////////////////

        // Set some initial values

        //////////////////////////////////////////////  

        csr_ack_ro = false;

        ui_ack_ro = false;

        fwd_ack_ro = false;

        eh_ack_ro = false;

        fc_nop_sent = true;

        cd_available_ro = false;

        cd_data_pending_ro = false;

        csr_memory_space_enable = true;

        csr_io_space_enable = true;

        csr_direct_route_enable = true;

        csr_sync = false;

        //csr_clumping_configuration = "00000000111000000000000000000000";

        /**ID's 20 to 23 are clumped together*/

        for(int n = 0; n < 32; n++)

                clumped_unit_id[n] = n;

        clumped_unit_id[21] = 20;

        clumped_unit_id[22] = 20;

        clumped_unit_id[23] = 20;

    //The unitID's that have directRoute enabled

        csr_direct_route_enable =    "00000000000000000000000000000000";

#ifdef ENABLE_REORDERING

        csr_unitid_reorder_disable = false;

#endif

        fwd_next_node_buffer_status_ro = "111111";

#ifdef RETRY_MODE_ENABLED

        lk_rx_connected = true;

        csr_retry = false;

#endif

        //Hold reset for a some cycles

        for(int n = 0; n < 3; n++)

                wait();

        //Stop reset

        resetx = true;

        //A temporary packet variable to reuse

        ReorderTBPacket tb_pkt;

        /////////////////////////////////////////

        // Send Misc packets, no reordering

        // Test one VC at the time

        // This tests the proper operation of the entrance reordering

        // dans the buffers when not being reordered

        /////////////////////////////////////////

        fc_nop_sent = true;

        cd_data_pending_ro = false;

        cout << "Begin test: Send Misc packets, no reordering" << endl;

        for(int vc = 0; vc < 3; vc++){

                cout << "Begin test for vc: " << vc << endl;

                int packet_to_send = 25;

                int packets_received = 0;

                int idle_counter = 0;

                while(packets_received != 25){

                        ////////////////////////////////////////////

                        // Read reordering output

                        ////////////////////////////////////////////

                        //Make sure we don't fall in an infinite loop

                        if(!ro_available_csr.read() &&

                                !ro_available_ui.read() &&

                                !ro_available_fwd.read() &&

                                !packet_sent.empty())

                        {

                                idle_counter++;

                                if(idle_counter > 10){

                                        cout << "ERROR: No packets are being received!" << endl;

                                        return;

                                }

                        }

                        else{

                                idle_counter = 0;

                        }

                        //80% chance of reading from the many destination

                        read_csr = (rand() % 10) < 8;

                        read_fwd = (rand() % 10) < 8;

                        read_ui = (rand() % 10) < 8;

                        //Find the first packet in the list of packets 

                        //Start by creating an iterator

                        deque<ReorderTBPacket>::iterator first_accepted = packet_sent.begin();

                        bool found_accepted = false;

                        //loop over all elements until an accepted is found

                        while(first_accepted != packet_sent.end()){

                                if(first_accepted->accepted){

                                        found_accepted = true;

                                        break;

                                }

                                first_accepted++;

                        }

                        //Accepted packet can only be sent to one destination, CSR or UI

                        if(ui_ack_ro.read() && csr_ack_ro.read()){

                                cout << "ERROR: Packets sent to UI and CSR simulaneoulsy" << endl;

                                return;

                        }

                        //If CSR acks a packet

                        if(csr_ack_ro.read()){

                                //Check if there is a packet to send

                                if(packet_sent.size() == 0 || !found_accepted){

                                        cout << "ERROR: Packet available when none in buffers..." << endl;

                                        return;

                                }

                                //If not the correct packet, display an error 

                                if(ro_packet_csr.read().packet != first_accepted->pkt.packet

                                        || ! first_accepted->csr)

                                {

                                        cout << "ERROR: Packet sent to CSR by error" << endl;

                                        return;

                                }

                                //If correct, remove from queue

                                else{

                                        packet_sent.erase(first_accepted);

                                        packets_received++;

                                }

                        }

                        //If UI acks 

                        if(ui_ack_ro.read()){

                                //Check if there was a packet to sent

                                if(packet_sent.size() == 0 || !found_accepted){

                                        cout << "ERROR: Packet available when none in buffers..." << endl;

                                        return;

                                }

                                //If not the correct packet, display an error 

                                if(ro_packet_ui.read().packet != first_accepted->pkt.packet

                                        || first_accepted->csr)

                                {

                                        cout << "ERROR: Packet sent to UI by error, " <<

                                                ro_packet_ui.read().packet.to_string(SC_HEX) << endl;

                                        cout << "   expected: " <<

                                                first_accepted->pkt.packet.to_string(SC_HEX) << endl;

                                        resetx = false;

                                        return;

                                }

                                else{

                                        //If the packet must also go to forward (like for a broadcast), just

                                        //erase the fact that it must go to accepted

                                        if(first_accepted->forward) first_accepted->accepted = false;

                                        //Otherwise, erase the packet

                                        else{

                                                packet_sent.erase(first_accepted);

                                                packets_received++;

                                        }

                                }

                        }

                        //Find the first packet for the forward destination in the list of packet sent

                        deque<ReorderTBPacket>::iterator first_forward = packet_sent.begin();;

                        bool found_forward = false;

                        while(first_forward != packet_sent.end()){

                                if(first_forward->forward){

                                        found_forward = true;

                                        break;

                                }

                                first_forward++;

                        }

                        //If packet is acked

                        if(fwd_ack_ro.read()){

                                //Check that there is a packet to ack

                                if(packet_sent.size() == 0 || !found_forward){

                                        cout << "ERROR: Packet available when none in buffers..." << endl;

                                        return;

                                }

                                //If it is not the correct packet, display error

                                if(ro_packet_fwd.read().packet != first_forward->pkt.packet)

                                {

                                        cout << "ERROR: Packet sent to FWD by error, " <<

                                                ro_packet_fwd.read().packet.to_string(SC_HEX) <<

                                                " expected: " << first_forward->pkt.packet.to_string(SC_HEX) << endl;

                                        return;

                                }

                                else{

                                        //If the packet must also go to accepted (like for a broadcast), just

                                        //erase the fact that it must go to forward

                                        if(first_forward->accepted) first_forward->forward = false;

                                        //Otherwise, erase the packet

                                        else{

                                                packet_sent.erase(first_forward);

                                                packets_received++;

                                        }

                                }

                        }

                        ////////////////////////////////////////////

                        // Send packets

                        ////////////////////////////////////////////

                        //80% chance of sending packet

                        bool send = (rand() % 10) < 8;

                        //If there is room in buffers, we still have packet to send (from the initial

                        //number that was set and we want to send

                        if(packet_sent.size() < NB_OF_BUFFERS && packet_to_send > 0 && send){

                                if(vc == VC_POSTED){

                                        generate_random_posted_pkt(tb_pkt,POSTED_ANY);

                                        //Make sure  passpw = false

                                        tb_pkt.pkt.packet[15] = false;

                                }

                                else if(vc == VC_NON_POSTED){

                                        generate_random_nposted_pkt(tb_pkt,NPOSTED_ANY);

                                        //Make sure  passpw = false

                                        tb_pkt.pkt.packet[15] = false;

                                }

                                else{

                                        generate_random_response_pkt(tb_pkt,RESPONSE_ANY);

                                        //Make sure  passpw = false

                                        tb_pkt.pkt.packet[15] = false;

                                }

                                cd_available_ro = true;

                                cd_packet_ro = tb_pkt.pkt;

                                packet_to_send--;

                                packet_sent.push_back(tb_pkt);

                        }

                        else{

                                cd_available_ro = false;

                        }

                        wait();

                }

                cout << "Test done for vc: " << vc << endl;

        }

        cout << "Test successful" << endl << endl;

        /////////////////////////////////////////

        // Send Misc packets, reordering

        /////////////////////////////////////////

        /**

                The previous tests sent completely random packets and checked

                that they were still in order and correct.  For the reordering,

                it is not so easy, so this sends a series of pre-defined

                vectors and makes sure they are received in the also pre-defined

                correct order.

                Only send packets for the forward destination to simplify tests.

        */

        wait();

        cout << "Begin packet reordering test"<< endl;

        read_csr = false;

        read_fwd = false;

        read_ui = false;

        //There are 4 tests to make

        deque<ReorderTBPacket> to_send[4];

        deque<ReorderTBPacket> to_receive[4];

        //Test 1 & 2 - passPW and sequence for posted and non-posted

        //Create a bunch of packets alternating passPW = true and false

        tb_pkt.pkt.isPartOfChain = false;

        tb_pkt.pkt.data_address = sc_uint<32>(rand()).range(BUFFERS_ADDRESS_WIDTH-1,0);

        tb_pkt.accepted = false;

        tb_pkt.forward = true;

        tb_pkt.pkt.error64BitExtension = false;

        for(int n = 0; n < 8; n++){

                generate_random_forward_posted_pkt(tb_pkt.pkt.packet,false);

                tb_pkt.pkt.packet[15] = n % 2 || n == 0;

                to_send[0].push_back(tb_pkt);

                generate_random_forward_nposted_pkt(tb_pkt.pkt.packet);

                tb_pkt.pkt.packet[15] = n % 2 || n == 0;

                to_send[1].push_back(tb_pkt);

        }

        //Insert a sequence in the packets, also testing unitID clumping

        for(int n = 3; n < 6; n++){

                to_send[0][n].pkt.packet.range(7,6) = "01";

                to_send[0][n].pkt.packet.range(14,10) = "10101";

                //Different unitID, but same clumped UnitID

                to_send[0][n].pkt.packet.range(9,8) = sc_uint<2>(n-3);

                to_send[1][n].pkt.packet.range(7,6) = "01";

                to_send[1][n].pkt.packet.range(14,10) = "10101";

                //Different unitID, but same clumped UnitID

                to_send[1][n].pkt.packet.range(9,8) = sc_uint<2>(n-3);

        }

        //Generate the order which the packet should be received

        to_receive[0].push_back(to_send[0][0]);

        to_receive[1].push_back(to_send[1][0]);

        to_receive[0].push_back(to_send[0][1]);

        to_receive[1].push_back(to_send[1][1]);

        to_receive[0].push_back(to_send[0][3]);

        to_receive[1].push_back(to_send[1][3]);

        to_receive[0].push_back(to_send[0][2]);

        to_receive[1].push_back(to_send[1][2]);

        to_receive[0].push_back(to_send[0][4]);

        to_receive[1].push_back(to_send[1][4]);

        to_receive[0].push_back(to_send[0][5]);

        to_receive[1].push_back(to_send[1][5]);

        to_receive[0].push_back(to_send[0][7]);

        to_receive[1].push_back(to_send[1][7]);

        to_receive[0].push_back(to_send[0][6]);

        to_receive[1].push_back(to_send[1][6]);

        //Test 3 - posted chains

        //Create a bunch of packets alternating passPW = true and false

        for(int n = 0; n < 8; n++){

                generate_random_forward_posted_pkt(tb_pkt.pkt.packet,n == 4 || n==5);

                tb_pkt.pkt.packet[15] = n % 2 || n == 0;

                to_send[2].push_back(tb_pkt);

        }

        //Generate the order which the packet should be received

        to_receive[2].push_back(to_send[2][0]);

        to_receive[2].push_back(to_send[2][1]);

        to_receive[2].push_back(to_send[2][3]);

        to_receive[2].push_back(to_send[2][2]);

        to_receive[2].push_back(to_send[2][4]);

        to_receive[2].push_back(to_send[2][5]);

        to_receive[2].push_back(to_send[2][6]);

        to_receive[2].push_back(to_send[2][7]);

        //Test 4 - PassPW responses

        //Create a bunch of responses with different passPW values

        for(int n = 0; n < 8; n++){

                generate_random_forward_response_pkt(tb_pkt.pkt.packet);

                tb_pkt.pkt.packet[15] = (n == 0 || n == 1 || n == 4 || n == 5 || n == 7);

                to_send[3].push_back(tb_pkt);

        }

        to_receive[3].push_back(to_send[3][0]);

        to_receive[3].push_back(to_send[3][1]);

        to_receive[3].push_back(to_send[3][4]);

        to_receive[3].push_back(to_send[3][5]);

        to_receive[3].push_back(to_send[3][7]);

        to_receive[3].push_back(to_send[3][2]);

        to_receive[3].push_back(to_send[3][3]);

        to_receive[3].push_back(to_send[3][6]);

        //Run through the 4 tests

        for(int test = 0; test < 4; test++){

                //Send packets until they are all sent

                while(!to_send[test].empty()){

                        cd_available_ro = true;

                        cd_packet_ro = to_send[test].front().pkt;

                        to_send[test].pop_front();

                        wait();

                }

                cd_available_ro = false;

                //Wait for packets to reorganize

                for(int n = 0; n < 16; n++) wait();

                int idle = 0;

                //until all packet are ceived

                while(!to_receive[test].empty()){

                        //80% chance of reading the packet if available

                        read_fwd = (rand() % 10) < 8;

                        //If it is acked

                        if(fwd_ack_ro.read()){

                                idle = 0;

                                //display error if not the correct packet received

                                if(ro_packet_fwd.read().packet !=

                                        to_receive[test].front().pkt.packet)

                                {

                                        cout << "ERROR in reordering test: " << test << endl

                                                 << "    Received: " << ro_packet_fwd.read().packet.to_string(SC_HEX)

                                                 << " Expected: " << to_receive[test].front().pkt.packet.to_string(SC_HEX)

                                                 << endl;

                                        return;

                                }

                                to_receive[test].pop_front();

                        }

                        else{

                                //If read is active but no packet available, increment an idle counter to make

                                //sure the reordering doesn't just sit idle until the end of the simulation

                                if(read_fwd.read()){

                                        idle++;

                                }

                                if(idle > 5){

                                        cout << "ERROR: reordering idle for too long in test: " << test << endl;

                                        return;

                                }

                        }

                        wait();

                }

                read_fwd = false;

        }

        cout << "Test successful" << endl << endl;

        /////////////////////////////////////////

        // Test data packet not commited before

        // completely received

        /////////////////////////////////////////

        cout << "Test waiting for data to be commited"<< endl;

        cd_data_pending_ro = true;

        sc_uint<BUFFERS_ADDRESS_WIDTH> pending_addr = rand() % DATABUFFER_NB_BUFFERS;

        cd_data_pending_addr_ro = pending_addr;

        generate_random_posted_pkt(tb_pkt,POSTED_FORWARD);

        generate_random_64b_vector(tb_pkt.pkt.packet);

        //Posted write, not configured in BARs

        tb_pkt.pkt.packet.range(5,3) = "101";

        sc_bv<40> addr;

        generate_random_not_bar_address(addr);

        tb_pkt.pkt.packet.range(63,25) = addr.range(39,2);

        tb_pkt.pkt.data_address = pending_addr;

        cd_available_ro = true;

        cd_packet_ro = tb_pkt.pkt;

        read_ui = false;

        wait();

        cd_available_ro = false;

        for(int n = 0; n <5; n++){

                if(ro_available_fwd.read()){

                        cout << "ERROR: Packet sent out even if data not fully commited"<< endl;

                        return;

                }

                wait();

        }

        cd_data_pending_addr_ro = pending_addr + 1;

        bool received = false;

        read_ui = true;

        for(int n = 5; !received; n--){

                if(ro_available_fwd.read()) received = true;

                if(n == 0){

                        cout << "ERROR: Packet not sent out even if data fully commited"<< endl;

                        return;

                }

                wait();

        }

        read_ui = false;

        cout << "Test successful" << endl << endl;

        /////////////////////////////////////////

        // Test directroute

        /////////////////////////////////////////

        cout << "Test DirectRoute" << endl ;

        csr_direct_route_enable =    "00000000000001110000000000000000";

        generate_random_64b_vector(tb_pkt.pkt.packet);

        //Write to bar address

        int bar = rand() % NbRegsBars;

        tb_pkt.pkt.packet.range(5,3) = "101";

        tb_pkt.pkt.packet.range(63,63-Header_BarLength[bar] + 1) =

                csr_bar[bar].read().range(39,Header_BarSlotSize[bar]);

        //Don't want compat on

        tb_pkt.pkt.packet[21] = 0;

        //make it from 

        tb_pkt.pkt.packet.range(12,8) = sc_uint<5>(17);

        //adjust if chain

        tb_pkt.pkt.packet[19] = false;

        tb_pkt.pkt.error64BitExtension = false;

        cd_available_ro = true;

        cd_packet_ro = tb_pkt.pkt;

        read_ui = false;

        wait();

        cd_available_ro = false;

        received = false;

        read_ui = true;

        for(int n = 5; !received; n--){

                if(ro_available_ui.read()) received = true;

                if(n == 0){

                        cout << "ERROR: Packet not correctly directrouted to UI: "

                                << tb_pkt.pkt.packet.to_string(SC_HEX) << endl;

                        return;

                }

                wait();

        }

        read_ui = false;

        csr_direct_route_enable =    "00000000000000000000000000000000";

        cout << "Test successful" << endl << endl;

        /////////////////////////////////////////

        // Test overflow

        /////////////////////////////////////////

        cout << "Test overflow" << endl;

        generate_random_posted_pkt(tb_pkt,POSTED_ANY);

        cd_packet_ro = tb_pkt.pkt;

        read_ui = false;

        read_fwd = false;

        read_csr = false;

        for(int n = 0; n < 9; n++){

                cd_available_ro = true;

                wait();

        }

        for(int n = 0; n <3; n++){