gem5/ext/dsent/model/electrical/MuxTreeSerializer.cc

/* Copyright (c) 2012 Massachusetts Institute of Technology
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#include "model/electrical/MuxTreeSerializer.h"

#include <cmath>

#include "model/PortInfo.h"
#include "model/TransitionInfo.h"
#include "model/EventInfo.h"
#include "model/std_cells/StdCellLib.h"
#include "model/std_cells/StdCell.h"
#include "model/electrical/Multiplexer.h"
#include "model/timing_graph/ElectricalNet.h"

namespace DSENT
{
    using std::ceil;

    MuxTreeSerializer::MuxTreeSerializer(const String& instance_name_, const TechModel* tech_model_)
        : ElectricalModel(instance_name_, tech_model_)
    {
        initParameters();
        initProperties();
    }

    MuxTreeSerializer::~MuxTreeSerializer()
    {}

    void MuxTreeSerializer::initParameters()
    {
        addParameterName("InDataRate");
        addParameterName("OutDataRate");
        addParameterName("InBits");              //Output width will just be input width / serialization ratio
    }

    void MuxTreeSerializer::initProperties()
    {
        return;
    }

    MuxTreeSerializer* MuxTreeSerializer::clone() const
    {
        // TODO
        return NULL;
    }

    void MuxTreeSerializer::constructModel()
    {
        // Get parameters
        double in_data_rate = getParameter("InDataRate").toDouble();
        double out_data_rate = getParameter("OutDataRate").toDouble();
        unsigned int in_bits = getParameter("InBits").toUInt();
        
        // Calculate serialization ratio
        unsigned int serialization_ratio = (unsigned int) floor(out_data_rate / in_data_rate);    
        ASSERT(serialization_ratio == out_data_rate / in_data_rate,
            "[Error] " + getInstanceName() + " -> Cannot have non-integer serialization ratios " +
            "(" + (String) (in_data_rate / out_data_rate) + ")!");
                
        // Calculate output width
        ASSERT(floor((double) in_bits / serialization_ratio) == (double) in_bits / serialization_ratio,
            "[Error] " + getInstanceName() + " -> Input width (" + (String) in_bits + ") " +
            "must be a multiple of the serialization ratio (" + (String) serialization_ratio + ")!");
        unsigned int output_bits = in_bits / serialization_ratio;
        
        // Calculate the number of multiplexer stages
        unsigned int number_stages = (unsigned int)ceil(log2((double) serialization_ratio));                    
            
        // Store calculated values
        getGenProperties()->set("SerializationRatio", serialization_ratio);
        getGenProperties()->set("OutputBits", output_bits);
        getGenProperties()->set("NumberStages", number_stages);
                
        // Create ports
        createInputPort("In", makeNetIndex(0, in_bits-1));
        createInputPort("OutCK");
        createOutputPort("Out", makeNetIndex(0, output_bits-1));

        //Create energy, power, and area results
        createElectricalResults();
        createElectricalEventResult("Serialize");
        getEventInfo("Serialize")->setTransitionInfo("OutCK", TransitionInfo(0.0, (double) serialization_ratio / 2.0, 0.0));
        //Set conditions during idle state
        getEventInfo("Idle")->setStaticTransitionInfos();
        getEventInfo("Idle")->setTransitionInfo("OutCK", TransitionInfo(0.0, (double) serialization_ratio / 2.0, 0.0));
        
        // Mark OutCK as a false path (since timing tool will do strange stuff due to all the clock divides and stuff)
        getNet("OutCK")->setFalsePath(true);
        
        // Create mux-tree instance
        if (serialization_ratio == 1)
        {
            // No need to do anything, hohoho
            assign("Out", "In");
        }
        else
        {
            // Create multiplexer
            String mux_tree_name = "MuxTree";        
            ElectricalModel* mux_tree = new Multiplexer(mux_tree_name, getTechModel());
            mux_tree->setParameter("NumberInputs", serialization_ratio);
            mux_tree->setParameter("NumberBits", output_bits);
            mux_tree->setParameter("BitDuplicate", "TRUE");
            mux_tree->construct();
            // Create nets
            if (number_stages > 1)
                createNet("MuxSel_b", makeNetIndex(0, number_stages-2));
            createNet("MuxSel", makeNetIndex(0, number_stages-1));
            assign("MuxSel", makeNetIndex(number_stages-1), "OutCK");
            // Create reindexed net (to help out with indexing)
            createNet("InTmp", makeNetIndex(0, in_bits-1));            
            for (unsigned int i = 0; i < serialization_ratio; ++i)
                for (unsigned int j = 0; j < output_bits; ++j)
                    assign("InTmp", makeNetIndex(i*output_bits+j), "In", makeNetIndex(j*serialization_ratio+i));

            // Connect ports
            for (unsigned int i = 0; i < serialization_ratio; ++i)
                portConnect(mux_tree, "In" + (String) i, "InTmp", makeNetIndex(i*output_bits, (i+1)*output_bits-1));
            
            for (unsigned int i = 0; i < number_stages; ++i)
                portConnect(mux_tree, "Sel" + (String) i, "MuxSel", makeNetIndex(i));
            portConnect(mux_tree, "Out", "Out");

            // Add subinstance and events
            addSubInstances(mux_tree, 1.0);
            addElectricalSubResults(mux_tree, 1.0);
            // Add serialize event/power
            getEventResult("Serialize")->addSubResult(mux_tree->getEventResult("Mux"), mux_tree_name, 1.0);

            // Create clock dividers (assumes power of 2...), don't need divider for fastest output stage
            for (unsigned int i = 0; i < number_stages - 1; ++i)
            {
                // Clk dividing registers
                const String& clk_div_dff_name = "ClkDivDFF_" + (String) i;
                StdCell* clk_div_dff = getTechModel()->getStdCellLib()->createStdCell("DFFQ", clk_div_dff_name);                
                clk_div_dff->construct();
                portConnect(clk_div_dff, "D", "MuxSel_b", makeNetIndex(i));
                portConnect(clk_div_dff, "Q", "MuxSel", makeNetIndex(i));
                portConnect(clk_div_dff, "CK", "MuxSel", makeNetIndex(i+1));
                addSubInstances(clk_div_dff, 1.0);
                addElectricalSubResults(clk_div_dff, 1.0);
                
                // Inversions
                const String& clk_div_inv_name = "ClkDivINV_" + (String) i;
                StdCell* clk_div_inv = getTechModel()->getStdCellLib()->createStdCell("INV", clk_div_inv_name);
                clk_div_inv->construct();
                portConnect(clk_div_inv, "A", "MuxSel", makeNetIndex(i));
                portConnect(clk_div_inv, "Y", "MuxSel_b", makeNetIndex(i));
                addSubInstances(clk_div_inv, 1.0);
                addElectricalSubResults(clk_div_inv, 1.0);
                            
                getEventResult("Serialize")->addSubResult(clk_div_dff->getEventResult("CK"), clk_div_dff_name, 1.0); 
                getEventResult("Serialize")->addSubResult(clk_div_dff->getEventResult("DFFD"), clk_div_dff_name, 1.0); 
                getEventResult("Serialize")->addSubResult(clk_div_dff->getEventResult("DFFQ"), clk_div_dff_name, 1.0); 
                getEventResult("Serialize")->addSubResult(clk_div_inv->getEventResult("INV"), clk_div_inv_name, 1.0);
            }
        }

        return;
    }

    void MuxTreeSerializer::propagateTransitionInfo()
    {
        // Get some generated properties
        const unsigned int serialization_ratio = getGenProperties()->get("SerializationRatio");
        const unsigned int number_stages = getGenProperties()->get("NumberStages");
        
        // Set transition info of the mux tree and clock divide DFF
        if (serialization_ratio == 1)
        {
            // If no serialization, then just propagate input transition info to output port
            propagatePortTransitionInfo("Out", "In");
        }
        else
        {

            // Propagate transition probabilities to the mux tree
            ElectricalModel* mux_tree = (ElectricalModel*) getSubInstance("MuxTree");
            // All input ports of the mux have the same probability
            for (unsigned int i = 0; i < serialization_ratio; ++i)
                propagatePortTransitionInfo(mux_tree, "In" + (String) i, "In");
            // Connect last stage of the mux
            propagatePortTransitionInfo(mux_tree, "Sel" + (String) (number_stages - 1), "OutCK");                
            // Keep track of the last clock divider
            ElectricalModel* last_clk_div_dff = NULL;
            // Find P01 of OutCK
            double last_P01_CK = getInputPort("OutCK")->getTransitionInfo().getNumberTransitions01();
            // Start from the last stage (since it is the stage with no clock division)
            for (unsigned int i = 0; i < number_stages - 1; ++i)
            {
                const String& clk_div_dff_name = "ClkDivDFF_" + (String) (number_stages - i - 2);
                const String& clk_div_inv_name = "ClkDivINV_" + (String) (number_stages - i - 2);
                
                ElectricalModel* clk_div_dff = (ElectricalModel*) getSubInstance(clk_div_dff_name);
                if (last_clk_div_dff == NULL)
                    propagatePortTransitionInfo(clk_div_dff, "CK", "OutCK");
                else
                    propagatePortTransitionInfo(clk_div_dff, "CK", last_clk_div_dff, "Q");
                // Since it is a clock divider, P01 is D and Q are simply half the P01 of D and Q of
                // the input clock
                if (last_P01_CK != 0) clk_div_dff->getInputPort("D")->setTransitionInfo(TransitionInfo(0.0, last_P01_CK * 0.5, 0.0));
                else clk_div_dff->getInputPort("D")->setTransitionInfo(TransitionInfo(0.5, 0.0, 0.5));

                clk_div_dff->use();

                ElectricalModel* clk_div_inv = (ElectricalModel*) getSubInstance(clk_div_inv_name);
                propagatePortTransitionInfo(clk_div_inv, "A", clk_div_dff, "Q");
                clk_div_inv->use();
                
                // Connect select port of the mux
                propagatePortTransitionInfo(mux_tree, "Sel" + (String) (number_stages - i - 2), clk_div_dff, "Q");
                
                // Clk divide by 2;
                last_P01_CK = last_P01_CK * 0.5;
                // Remember the last clk div DFF
                last_clk_div_dff = clk_div_dff;
            }
            
            mux_tree->use();
            // Set output transition info to be the output transition info of the mux tree
            propagatePortTransitionInfo("Out", mux_tree, "Out");            
        }

        return;
    }

} // namespace DSENT