Subversion Repositories ht_tunnel

//databuffer_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 "databuffer_l2_tb.h"

#include <cstdlib>

databuffer_l2_tb::databuffer_l2_tb(sc_module_name name) : sc_module(name){

        SC_THREAD(manage_memories);

        sensitive_pos(clk);

        SC_THREAD(store_data);

        sensitive_pos(clk);

        SC_THREAD(read_data);

        sensitive_pos(clk);

        SC_THREAD(manage_nops);

        sensitive_pos(clk);

        SC_THREAD(manage_reset);

        sensitive_pos(clk);

        SC_THREAD(convert_vcs);

        sensitive << cd_vctype_db

        << eh_vctype_db

        << csr_vctype_db

        << ui_vctype_db

        << fwd_vctype_db;

        //Flag testbench entries as free

        for(int n = 3 * DATABUFFER_NB_BUFFERS - 1; n >= 0; n--)

                ((int*)data_packets_size)[n] = 0;

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

                data_packets_count[n] = 0;

                data_packets_allowed[n] = 0;

        }

        allow_overflow = false;

        srand(11843);

}

void databuffer_l2_tb::store_data(){

        ldtstopx = true;

        //The count of dwords to send to the databuffer

        int data_left_to_send = 0;

        //The total size of the packet being sent

        int current_packet_size = 0;

        //The count of data sent

        int data_sent = 0;

        //The address given by databuffer for packet currently being sent

        int address;

        //The virtual channel of the data packet

        int vc;

        //If we are allowed to drop the packet

        bool droppable = false;

        //This is synchrous process, so when get_addr is driven, the address given must be stored

        //the next cycle.  The cycle store_address_next_cycle is set, address should be read.

        bool store_address_next_cycle = false;;

        cd_write_db = false;

        cd_getaddr_db = false;

        cd_drop_db = false;

        cd_initiate_retry_disconnect = false;

        int clock_cycle = 0;

        while(true){

                //Wait until next clock cycle

                wait();

                clock_cycle++;

                //Randomly drop packets

                bool drop = (rand()/((float)RAND_MAX) ) < 0.02;

                //Chance of writing data to the databuffer when packet is started

                bool proceed = (rand()/((float)RAND_MAX) ) < 0.9 ;

                //Chance of starting a packet

                bool proceed2 = (rand()/((float)RAND_MAX) ) < 0.7;

                cd_write_db = false;

                cd_getaddr_db = false;

                cd_drop_db = false;

                cd_initiate_retry_disconnect = false;

                //If the last cycle, we outputed a new packet, store the adress

                //from the databuffer this cycle

                if(store_address_next_cycle){

                        store_address_next_cycle = false;

                        address = db_address_cd.read();

                        //Check if there is already a packet at that address

                        if(data_packets_size[vc][address]){

                                cout << "Error, data packet stored where it is not allowed" << endl;

                                cout  << "VC: " << vc << " address: " << address << " clock_cycle: " << clock_cycle << endl;

                        }

                }

                //The dropping the current packet

                if(drop && droppable){

                        cd_drop_db = true;

                        droppable = false;

                        data_packets_size[vc][address] = 0;

                        data_packets_count[vc]--;

                        data_left_to_send = 0;

                }

                //If a new packet can be started

                else if(proceed2 && !data_left_to_send){

                        cd_write_db = false;

                        cd_drop_db = false;

                        //Start by seing in which VC's packets can be sent

                        int vc_available[3];

                        int pos = 0;

                        int vc_count = 0;

                        //Iterate over the three vcs

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

                                //If more data can be sent in that vc (or if overflow is allowed), add the

                                //vc to the list of available vcs!

                                if(data_packets_allowed[n] != 0 || allow_overflow){

                                        vc_available[pos++] = n;

                                        vc_count++;

                                }

                        }

                        //If we found a vc (count is not 0)

                        if( (bool)(vc_count)){

                                //Randomly select the size

                                data_left_to_send = (int)(rand() / (RAND_MAX + 1.0) * 16 + 1);

                                current_packet_size = data_left_to_send;

                                data_sent = 0;

                                //Randomly choose a vc from the list of available vc's

                                int vc_to_send = vc_available[(int)(rand() / (RAND_MAX + 1.0) * vc_count)];

                                vc = vc_to_send;

                                //Update the buffer counts

                                data_packets_allowed[vc_to_send]--;

                                data_packets_count[vc_to_send]++;

                                //Request an address for the packet from the databuffer

                                cd_datalen_db = data_left_to_send - 1;

                                cd_vctype_db = (VirtualChannel)vc_to_send;

                                cd_getaddr_db = true;

                                droppable = true;

                                store_address_next_cycle = true;

                        }

                }

                //Actually send the data 

                else if(proceed && data_left_to_send){

                        //start by generating a random 32-bit integer

                        //RAND_MAX may be as low as 32k in some librairies (VC++ for example),

                        //so to be uniform, mask the higher 17 bits

                        int r  = rand() & 0x7FFF;

                        int r1 = rand() & 0x7FFF;

                        int r2 = rand() & 0x7FFF;

                        r = r | (r1 << 15) | (r2 << 30);

                        cd_data_db = sc_uint<32>(r);

                        data_packets[vc][address][data_sent] = r;

                        cd_write_db = true;

                        data_left_to_send--;

                        data_sent++;

                        if(!data_left_to_send)

                                data_packets_size[vc][address] = current_packet_size;

                }

        }

}

void databuffer_l2_tb::read_data(){

        int fwd_read_left = 0;

        int fwd_address = 0;

        int fwd_vc = 0;

        int accepted_read_left = 0;

        int accepted_address = 0;

        int accepted_vc = 0;

        bool csr_access = false;

        csr_read_db = false;

        ui_read_db = false;

        fwd_read_db = false;

        eh_erase_db = false;

        csr_erase_db = false;

        ui_erase_db = false;

        fwd_erase_db = false;

        int debug_read_count = 0;

        cout << "If there are no error message, test is successful!" << endl;

        while(true){

                wait();

                csr_read_db = false;

                ui_read_db = false;

                fwd_read_db = false;

                eh_erase_db = false;

                csr_erase_db = false;

                ui_erase_db = false;

                fwd_erase_db = false;

                //If the last packet sent from command decoder should be dropped

                bool drop_proceed = (rand()/((float)RAND_MAX) ) < 0.01;

                //If a read should be done from the accepted port

                bool accepted_proceed = (rand()/((float)RAND_MAX) ) < 0.2 ;

                //If a read should be done from the forward port

                bool fwd_proceed = (rand()/((float)RAND_MAX) ) < 0.3;

                //Fin some random packets to extract

                int entries_address[3 * DATABUFFER_NB_BUFFERS];

                int entries_vc[3 * DATABUFFER_NB_BUFFERS];

                //Start by finding all valid entries

                int entries_count = 0;

                //for all 3 vc

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

                        //for every packet in the vc

                        for(int y = 0 ; y < DATABUFFER_NB_BUFFERS; y++){

                                //Check if there is packet (size is non zero) and is not currently being

                                //read by the forward of the accepted read ports

                                if(data_packets_size[x][y] && !(

                                        x == fwd_vc && y == fwd_address && (fwd_read_left || fwd_erase_db.read())  ||

                                        x == accepted_vc && y == accepted_address && (accepted_read_left || csr_erase_db.read() || ui_erase_db.read())))

                                {

                                        entries_address[entries_count] = y;

                                        entries_vc[entries_count++] = x;

                                }

                        }

                }

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

                //      Test If output is correct

                //

                //      Read signals were set by the randomly set "proceed"

                //  variables on the LAST cycle.  Now we check if the

                //  output from those reads are correct.

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

                //Check if the dababuffer output on the Forward port is correct

                if(fwd_read_db.read()){

                        //Check if db_data_fwd is correct

                        if( data_packets[fwd_vc][fwd_address]

                                        [data_packets_size[fwd_vc][fwd_address]-fwd_read_left-1]

                                != (int)((sc_uint<32>)db_data_fwd.read()))

                        {

                                cout << "Data signal has wrong value on Forward port" << endl;

                                cout << "Data VC: "<< (int)fwd_vc  << " Address: " << fwd_address <<

                                        " Pos: " << data_packets_size[fwd_vc][fwd_address]-fwd_read_left-1 << endl;

                                cout << "Data expected: " << ((sc_uint<32>)data_packets[fwd_vc][fwd_address]

                                        [data_packets_size[fwd_vc][fwd_address]-fwd_read_left-1]).to_string(SC_HEX) << endl;

                                cout << "Data received: " << ((sc_uint<32>)db_data_fwd.read()).to_string(SC_HEX) << endl;

                        }

                        //On last read, clear the value

                        if(!fwd_read_left)

                                data_packets_size[fwd_vc][fwd_address] = 0;

                }

                //Check if the dababuffer output on the Forward port is correct

                if(csr_read_db.read() || ui_read_db.read()){

                        //Check if db_data_fwd is correct

                        if( data_packets[accepted_vc][accepted_address]

                                        [data_packets_size[accepted_vc][accepted_address]-accepted_read_left-1]

                                != (int)((sc_uint<32>)db_data_accepted.read()))

                        {

                                cout << "Data signal has wrong value on Accepted port" << endl;

                                cout << "Data VC: "<< (int)accepted_vc  << " Address: " << accepted_address <<

                                        " Pos: " << data_packets_size[accepted_vc][accepted_address]-accepted_read_left-1 << endl;

                                cout << "Data expected: " << ((sc_uint<32>)data_packets[accepted_vc][accepted_address]

                                        [data_packets_size[accepted_vc][accepted_address]-accepted_read_left-1]

                                        ).to_string(SC_HEX) << endl;

                                cout << "Data received: " << ((sc_uint<32>)db_data_accepted.read()).to_string(SC_HEX) << endl;

                        }

                        //On last read, clear the value

                        if(!accepted_read_left)

                                data_packets_size[accepted_vc][accepted_address] = 0;

                }

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

                //      Activate the correct read signals

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

                //Do the read on the Forward port

                if(fwd_proceed){

                        //If no packet has been started

                        if(!fwd_read_left && entries_count > 0){

                                //Find one in the list of valid entries

                                int pos = (int)(rand() / (RAND_MAX + 1.0) * entries_count);

                                fwd_address_db = entries_address[pos];

                                fwd_vctype_db = (VirtualChannel)entries_vc[pos];

                                fwd_read_left = data_packets_size[entries_vc[pos]][entries_address[pos]];

                                fwd_address = entries_address[pos];

                                fwd_vc = entries_vc[pos];

                                //Remove that entry

                                entries_count--;

                                for(int n = pos; n < entries_count;n++){

                                        entries_address[n] = entries_address[n+1];

                                        entries_vc[n] = entries_vc[n+1];

                                }

                        }

                        else if(fwd_read_left > 0){

                                fwd_read_db = true;

                                fwd_read_left--;

                                fwd_erase_db = fwd_read_left == 0;

                        }

                }

                //Do the read on the Forward port

                if(accepted_proceed){

                        //If no packet has been started

                        if(!accepted_read_left && entries_count > 0){

                                //Decide if it's the CSR or UI reading

                                csr_access = (rand()/((float)RAND_MAX) ) < 0.5;

                                //Find one in the list of valid entries

                                int pos = (int)(rand() / (RAND_MAX + 1.0) * entries_count);

                                accepted_read_left = data_packets_size[entries_vc[pos]][entries_address[pos]];

                                //Activate the correct address and vc signals depending on if it is the CSR or the

                                //UI accessing the data.

                                if(csr_access){

                                        csr_address_db = entries_address[pos];

                                        csr_vctype_db = (VirtualChannel)entries_vc[pos];

                                        ui_address_db = 0;

                                        ui_vctype_db = VC_NONE;

                                        ui_grant_csr_access_db = true;

                                }

                                else{

                                        csr_address_db = 0;

                                        csr_vctype_db = VC_NONE;

                                        ui_address_db = entries_address[pos];

                                        ui_vctype_db = (VirtualChannel)entries_vc[pos];

                                        ui_grant_csr_access_db = false;

                                }

                                accepted_address = entries_address[pos];

                                accepted_vc = entries_vc[pos];

                                //Remove that entry

                                entries_count--;

                                for(int n = pos; n < entries_count;n++){

                                        entries_address[n] = entries_address[n+1];

                                        entries_vc[n] = entries_vc[n+1];

                                }

                        }

                        else if(accepted_read_left > 0){

                                accepted_read_left--;

                                if(csr_access){

                                        ui_read_db = false;

                                        csr_read_db = true;

                                        csr_erase_db = accepted_read_left == 0;

                                }

                                else{

                                        ui_read_db = true;

                                        csr_read_db = false;

                                        ui_erase_db = accepted_read_left == 0;

                                }

                        }

                }

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

                //      Test the Error drop Port

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

                if(drop_proceed && entries_count != 0){

                        //Find one in the list of valid entries

                        int pos = (int)(rand() / (RAND_MAX + 1.0) * entries_count);

                        int address = entries_address[pos];

                        int vc = entries_vc[pos];

                        data_packets_size[vc][address] = 0;

                        eh_address_db = address;

                        eh_vctype_db = (VirtualChannel) vc;

                        eh_erase_db = true;

                }

        }

}

void databuffer_l2_tb::manage_nops(){

        fc_nop_sent = false;

        bool nop_requested = false;

        error = false;

        bool should_request = false;

        while(true){

                wait();

                fc_nop_sent = false;

                if(!resetx.read()){

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

                                data_packets_count[n] = 0;

                                data_packets_allowed[n] = 0;

                        }

                }

                else{

                        //Add a tad bit of randomness, just for fun!

                        bool proceed = (rand()/((float)RAND_MAX) ) < 0.2 ;

                        bool dont_proceed = (rand()/((float)RAND_MAX) ) < 0.2 ;

                        //Remember when a nop is requested

                        if(db_nop_req_fc.read()){

                                nop_requested = true;

                        }

                        //When a nop is being sent out, update the free buffers

                        if(fc_nop_sent.read()){

                                sc_uint<2> nonposted_freed = (sc_bv<2>)db_buffer_cnt_fc.read().range(5,4);

                                sc_uint<2> posted_freed = (sc_bv<2>)db_buffer_cnt_fc.read().range(1,0);

                                sc_uint<2> response_freed = (sc_bv<2>)db_buffer_cnt_fc.read().range(3,2);

                                data_packets_allowed[VC_NON_POSTED] += nonposted_freed;

                                data_packets_allowed[VC_POSTED] += posted_freed;

                                data_packets_allowed[VC_RESPONSE] += response_freed;

                        }

                        if(should_request && !nop_requested && !fc_nop_sent.read()){

                                cout << "ERROR: Databuffer not correctly requesting nops to be sent" << endl;

                                error = true;

                        }

                        //When there is a request, send a nop

                        if(db_nop_req_fc.read() && !dont_proceed || proceed){

                                fc_nop_sent = true;

                                nop_requested = false;//Reset when sent

                        }

                        //Verify that the databuffer correctly requests sending nops when

                        //necessary.  Do it at the end so that it has a delay of one cycle because

                        //the databuffer also takes a cycle to answer

                        should_request = false;

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

                                if(data_packets_allowed[n] < (DATABUFFER_NB_BUFFERS - data_packets_count[n] - 2))

                                        should_request = true;

                        }

                }

        }

}

void databuffer_l2_tb::manage_memories(){

        //Initialise memory

        for(int n = 3 * DATABUFFER_NB_BUFFERS * 16 - 1

                ; n >= 0; n--)

                ((int*)memory)[n] = 0;

        while(true){

                wait();

                //Manage writing

                if(memory_write.read()){

                        if(memory_write_address_vc.read() != 3)

                                memory[memory_write_address_vc.read()][memory_write_address_buffer.read()]

                                [memory_write_address_pos.read()] = (int)(sc_uint<32>)(memory_write_data.read());

                        else

                                cout << "Critical ERROR : writing to VC 3 in memory (doesn't exist)" << endl;

                }

                //Manage reading

                for(int port = 0; port < 2; port++){

                        memory_output[port] = memory[memory_read_address_vc[port].read()]

                                [memory_read_address_buffer[port].read()][memory_read_address_pos[port].read()];

                }

        }

}

void databuffer_l2_tb::manage_reset(){

        resetx = false;

        int count = 0;

        while(count++ < 5)wait();

        resetx = true;

        while(true) wait();

}

void databuffer_l2_tb::convert_vcs(){

        while(true){

                cd_vctype_db_trace = (int)cd_vctype_db.read();

                eh_vctype_db_trace = (int)eh_vctype_db.read();

                csr_vctype_db_trace = (int)csr_vctype_db.read();

                ui_vctype_db_trace = (int)ui_vctype_db.read();

                fwd_vctype_db_trace = (int)fwd_vctype_db.read();

                wait();

        }

}