Subversion Repositories openhmc

/*

 *                              .--------------. .----------------. .------------.

 *                             | .------------. | .--------------. | .----------. |

 *                             | | ____  ____ | | | ____    ____ | | |   ______ | |

 *                             | ||_   ||   _|| | ||_   \  /   _|| | | .' ___  || |

 *       ___  _ __   ___ _ __  | |  | |__| |  | | |  |   \/   |  | | |/ .'   \_|| |

 *      / _ \| '_ \ / _ \ '_ \ | |  |  __  |  | | |  | |\  /| |  | | || |       | |

 *       (_) | |_) |  __/ | | || | _| |  | |_ | | | _| |_\/_| |_ | | |\ `.___.'\| |

 *      \___/| .__/ \___|_| |_|| ||____||____|| | ||_____||_____|| | | `._____.'| |

 *           | |               | |            | | |              | | |          | |

 *           |_|               | '------------' | '--------------' | '----------' |

 *                              '--------------' '----------------' '------------'

 *

 *  openHMC - An Open Source Hybrid Memory Cube Controller

 *  (C) Copyright 2014 Computer Architecture Group - University of Heidelberg

 *  www.ziti.uni-heidelberg.de

 *  B6, 26

 *  68159 Mannheim

 *  Germany

 *

 *  Contact: openhmc@ziti.uni-heidelberg.de

 *  http://ra.ziti.uni-heidelberg.de/openhmc

 *

 *   This source file is free software: you can redistribute it and/or modify

 *   it under the terms of the GNU Lesser General Public License as published by

 *   the Free Software Foundation, either version 3 of the License, or

 *   (at your option) any later version.

 *

 *   This source file is distributed in the hope that it will be useful,

 *   but WITHOUT ANY WARRANTY; without even the implied warranty of

 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *   GNU Lesser General Public License for more details.

 *

 *   You should have received a copy of the GNU Lesser General Public License

 *   along with this source file.  If not, see .

 *

 *

 */

//

//

// axi4_stream_packet hmc_monitor

//

//

`ifndef AXI4_STREAM_HMC_MONITOR_SV

`define AXI4_STREAM_HMC_MONITOR_SV

class axi4_stream_hmc_monitor #(parameter DATA_BYTES = 16, parameter TUSER_WIDTH = 16) extends  hmc_module_mon ;

        int FPW ;

        int HEADERS ;

        int TAILS ;

        int VALIDS ;

        int valids_per_cycle            = 0;

        int current_packet_length       = 0;

        bit request = 1;

        int flit_delay [$];

        //-- uvm_analysis_port #(hmc_packet) item_collected_port;

        uvm_analysis_imp #(

          axi4_stream_valid_cycle #(.DATA_BYTES(DATA_BYTES), .TUSER_WIDTH(TUSER_WIDTH)),

          axi4_stream_hmc_monitor  #(.DATA_BYTES(DATA_BYTES), .TUSER_WIDTH(TUSER_WIDTH))

          ) axi4_port;

        int n_valids                            = 0;

        int headers_seen        = 0;

        int tails_seen          = 0;

        typedef bit [127:0] flit_t;

        flit_t flit_queue[$];

        int packets_per_cycle = 0;

        hmc_packet packet_queue[$];

        //-- covergroup definition

        `uvm_component_param_utils(axi4_stream_hmc_monitor #(.DATA_BYTES(DATA_BYTES), .TUSER_WIDTH(TUSER_WIDTH)))

        function new ( string name="axi4_stream_hmc_monitor", uvm_component parent );

                super.new(name, parent);

                axi4_port = new("axi4_port",this);

                hmc_pkt_cg              = new();

        endfunction : new

        function void build_phase(uvm_phase phase);

                super.build_phase(phase);

                FPW     = DATA_BYTES/16;//-- convert to variables!

                HEADERS = FPW;

                TAILS   = 2*FPW;

                VALIDS  = 0;

        endfunction : build_phase

        //-- Stuff FLITs into a FIFO, separate control signals

        function void collect_flits(input axi4_stream_valid_cycle #(.DATA_BYTES(DATA_BYTES), .TUSER_WIDTH(TUSER_WIDTH)) vc);

                //-- read tuser flags for valid flags

                flit_t tmp_flit;

                flit_t current_flit;

                packets_per_cycle = 0;

                valids_per_cycle =0;

                for (int i = 0; i

                //-- Check if valid

                        if (vc.tuser[VALIDS+i] == 1) begin

                                valids_per_cycle ++;

                                //-- Write 2 flit queue

                                for (int b=0; b<128; b++)

                                        tmp_flit[b] = vc.tdata[128*i+b];

                                flit_queue.push_back(tmp_flit);

                                if (vc.tuser[HEADERS+i] == 1'b1) begin

                                        headers_seen++; //-- Complete hmc_packets to assemble

                                        packets_per_cycle++;

                                        flit_delay.push_back(n_valids);

                                        n_valids = 0;

                                end

                                //-- Check if tail for complete hmc packet

                                if (vc.tuser[TAILS+i] == 1'b1) begin

                                        tails_seen++; //-- Complete hmc_packets to assemble

                                        assert (n_valids == 0)

                                        else `uvm_fatal(get_type_name(), $psprintf("Non valid flits in pkt detected!"))

                                end

                                //-- Check complete hmc packets

                                assert (tails_seen<= headers_seen)

                                else  `uvm_fatal(get_type_name(), $psprintf("packet is null"))

                                assert (headers_seen <= tails_seen+1)

                                else  `uvm_fatal(get_type_name(), $psprintf("Packet without Tail detected"))

                        end

                        else begin

                                n_valids ++;

                        end

                end

                `uvm_info(get_type_name(),$psprintf("%d header and %d tails available", headers_seen, tails_seen)  ,UVM_HIGH)

        endfunction : collect_flits

        //-- Use FLITs to form packets

        function void collect_packet();

                flit_t current_flit;

                bit bitstream[];

                //-- Assemble 1 hmc packet

                flit_queue_underflow : assert (flit_queue.size() > 0);

                //-- First flit is always header

                current_flit = flit_queue.pop_front();

                no_length_mismatches_allowed : assert (current_flit[14:11] == current_flit[10:7]);      //--check internal hmc_packet length

                current_packet_length = current_flit[10:7];

                flit_queue_underflow2 : assert (flit_queue.size() >= current_packet_length - 1);                //--check check hmc_packet complete received

                //-- pack flits 2 bitstream

                bitstream = new[current_packet_length*128];

                //-- Pack first flit

                for (int i=0; i<128; i=i+1)

                        bitstream[i] = current_flit[i];

                //-- Get and pack the remaining flits

                for (int flit=1; flit < current_packet_length; flit ++) begin

                        current_flit = flit_queue.pop_front();

                        `uvm_info(get_type_name(),$psprintf("pop flit %0d (%0x)", flit, current_flit), UVM_HIGH)

                        for (int i=0; i<128; i=i+1) begin

                                bitstream[flit*128+i] = current_flit[i];

                        end

                end

                packet = hmc_packet::type_id::create("packet", this);

                void'(packet.unpack(bitstream));

                packet.flit_delay = flit_delay.pop_front();

                hmc_pkt_cg.sample();

                //-- assembled a packet

                headers_seen--;

                tails_seen--;

                if (packet == null) begin

                  `uvm_fatal(get_type_name(), $psprintf("packet is null"))

                end

                packet_queue.push_back(packet);

                if(packet.get_command_type() == HMC_RESPONSE_TYPE)begin

                `uvm_info("RESPONSE collected",$psprintf("Rsp %0d : %s",rsp_rcvd, packet.command.name()), UVM_LOW)

                rsp_rcvd++;

                end else begin

                `uvm_info("REQUEST collected",$psprintf("Req %0d : %s",req_rcvd, packet.command.name()), UVM_LOW)

                req_rcvd++;

                end

                `uvm_info("AXI4 to HMC Monitor",$psprintf("\n%s", packet.sprint()), UVM_HIGH)

        endfunction : collect_packet

        function void write(input axi4_stream_valid_cycle #(.DATA_BYTES(DATA_BYTES), .TUSER_WIDTH(TUSER_WIDTH)) vc);

                hmc_packet packet;

                `uvm_info(get_type_name(),$psprintf("got valid cycle"), UVM_HIGH)

                collect_flits(vc);

                `uvm_info(get_type_name(),$psprintf("got %0d tails and %0d flits",tails_seen, flit_queue.size() ), UVM_HIGH)

                //-- Convert flit_queue to hmc_packets

                while (tails_seen >0) begin

                        collect_packet();

                end

                //-- If flit queue is not empty -> hmc packet striped over 2 axi cycles

                while (packet_queue.size()>0) begin

                        packet = packet_queue.pop_front();

                        //if (packet.command != HMC_ERROR_RESPONSE)

                                item_collected_port.write(packet);

                end

        endfunction

        function void check_phase(uvm_phase phase);

                if (flit_queue.size() >0)

                        `uvm_fatal(get_type_name(),$psprintf("flit_queue is not empty: %0d", flit_queue.size()))

        endfunction : check_phase

endclass : axi4_stream_hmc_monitor

`endif // AXI4_STREAM_HMC_MONITOR_SV