ext/dsent/model/electrical/BarrelShifter.cc - public/gem5 - Git at Google

 /* 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/BarrelShifter.h"
 #include "model/electrical/Multiplexer.h"

 #include <cmath>

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

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

     BarrelShifter::~BarrelShifter()
     {}

     void BarrelShifter::initParameters()
     {
         addParameterName("NumberBits");
         addParameterName("ShiftIndexMin");
         addParameterName("ShiftIndexMax");
         addParameterName("BitDuplicate", "TRUE");
         return;
     }

     void BarrelShifter::initProperties()
     {
         return;
     }

     BarrelShifter* BarrelShifter::clone() const
     {
         return NULL;
     }

     void BarrelShifter::constructModel()
     {
         // Get parameters
         unsigned int number_bits = getParameter("NumberBits");
         unsigned int number_shift_bits = (unsigned int)ceil(log2((double) number_bits));
         unsigned int shift_index_min = getParameter("ShiftIndexMin");
         unsigned int shift_index_max = getParameter("ShiftIndexMax");
         bool bit_duplicate = (bool) getParameter("BitDuplicate");

         ASSERT(number_bits > 0, "[Error] " + getInstanceName() + " -> Number of bits must be > 0!");
         // No need to check these if there arent any shifts
         if (number_shift_bits > 0)
         {
             ASSERT(shift_index_min <= number_shift_bits,
                 "[Error] " + getInstanceName() + " -> Min shift index must be >= 0 and <= " +
                 "the total number of shift bits!");
             ASSERT(shift_index_max >= shift_index_min && shift_index_max <= number_shift_bits,
                 "[Error] " + getInstanceName() + " -> Max shift index must be >= minimum shift index and <= " +
                 "the total number of shift bits!");
         }

         //Construct electrical ports
         //Create each input port
         createInputPort(    "In", makeNetIndex(0, number_bits-1));
         //Create output
         createOutputPort(   "Out", makeNetIndex(0, number_bits-1));

         //Create shift ports (which only exists if there is something to shift)
         if (shift_index_min != number_shift_bits)
             for (unsigned int i = shift_index_min; i <= shift_index_max; ++i)
                 createInputPort(    "Shift" + (String) i);

         //Create energy, power, and area results
         createElectricalResults();
         createElectricalEventResult("BarrelShift");
         //Set conditions during idle event
         getEventInfo("Idle")->setStaticTransitionInfos();

         //If the input is only 1-bit, connect input to output and be done
         if (number_shift_bits == 0 || (shift_index_min == number_shift_bits))
             assign("Out", "In");
         else
         {
             for (unsigned int i = shift_index_min; i <= shift_index_max; ++i)
             {
                 //Create internally buffered shift select signals
                 createNet("Shift_b" + (String) i);
                 createNet("Shift_i" + (String) i);
             }

             // Create shift and shifted signals
             for (unsigned int i = shift_index_min; i <= shift_index_max; ++i)
             {
                 unsigned int current_shifts = (unsigned int)pow(2, i);
                 const String& n = (String) current_shifts;
                 //Instantiate and connect intermediate nets. In a barrel-shifter, the nets do
                 //all the "shifting" and the muxes just select which to take
                 createNet("R_" + n, makeNetIndex(0, number_bits-1));               //wire R_n[number_bits-1:0]
                 createNet("RS_" + n, makeNetIndex(0, number_bits-1));              //wire RS_n[number_bits-1:0]

                 //Implements the shifts
                 //assign RS_n[number_bits-1:number_bits-current_shifts] = R_n[current_shifts-1:0];
                 assign("RS_" + n, makeNetIndex(number_bits-current_shifts, number_bits-1),
                         "R_" + n, makeNetIndex(0, current_shifts-1));
                 //assign RS_n[number_bits-current_shifts-1:0] = R_n[current_shifts:number_bits-1];
                 assign("RS_" + n, makeNetIndex(0, number_bits-current_shifts-1),
                         "R_" + n, makeNetIndex(current_shifts, number_bits-1));
             }

             const String& n_max = (String) pow(2, shift_index_max+1);
             const String& n_min = (String) pow(2, shift_index_min);
             // Create the R_(max) net
             createNet("R_" + n_max, makeNetIndex(0, number_bits-1));
             // Set R_1 to be the input
             assign("R_" + n_min, "In");
             // Set R_(max) to be the output
             assign("Out", "R_" + n_max, makeNetIndex(0, number_bits-1));

             for (unsigned int i = shift_index_min; i <= shift_index_max; ++i)
             {
                 unsigned int current_shifts = (unsigned int)pow(2, i);
                 const String& n = (String) current_shifts;
                 const String& n_next = (String) (current_shifts * 2);

                 const String& buf_inv_0_name = "ShiftBufInv0_" + (String) n;
                 const String& buf_inv_1_name = "ShiftBufInv1_" + (String) n;
                 // Create shift buffer inverters
                 StdCell* buf_inv_0 = getTechModel()->getStdCellLib()->createStdCell("INV", buf_inv_0_name);
                 buf_inv_0->construct();
                 StdCell* buf_inv_1 = getTechModel()->getStdCellLib()->createStdCell("INV", buf_inv_1_name);
                 buf_inv_1->construct();

                 // Connect up shift buffer inverters
                 portConnect(buf_inv_0, "A", "Shift" + (String) i);
                 portConnect(buf_inv_0, "Y", "Shift_b" + (String) i);
                 portConnect(buf_inv_1, "A", "Shift_b" + (String) i);
                 portConnect(buf_inv_1, "Y", "Shift_i" + (String) i);

                 // Add area, power, and event results for inverters
                 addSubInstances(buf_inv_0, 1.0);
                 addSubInstances(buf_inv_1, 1.0);
                 addElectricalSubResults(buf_inv_0, 1.0);
                 addElectricalSubResults(buf_inv_1, 1.0);
                 getEventResult("BarrelShift")->addSubResult(buf_inv_0->getEventResult("INV"), buf_inv_0_name, 1.0);
                 getEventResult("BarrelShift")->addSubResult(buf_inv_1->getEventResult("INV"), buf_inv_1_name, 1.0);

                 //Instantiate 2:1 multiplexers, one for each shift bit.
                 const String& mux_name = "SRL" + n;
                 Multiplexer* mux = new Multiplexer(mux_name, getTechModel());
                 mux->setParameter("NumberInputs", 2);
                 mux->setParameter("NumberBits", number_bits);
                 mux->setParameter("BitDuplicate", bit_duplicate);
                 mux->construct();

                 //Just have to connect the In0 and In1 inputs of the mux to the
                 //non-shifted and shifted intermediate signals, respectively.
                 portConnect(mux, "In0", "R_" + n);
                 portConnect(mux, "In1", "RS_" + n);
                 //Selector connects to the shift signal for that index
                 portConnect(mux, "Sel0", "Shift_i" + (String) i);
                 //Connect mux output
                 portConnect(mux, "Out", "R_" + n_next);

                 //Add area, power, and event results for each mux
                 addSubInstances(mux, 1.0);
                 addElectricalSubResults(mux, 1.0);
                 getEventResult("BarrelShift")->addSubResult(mux->getEventResult("Mux"), mux_name, 1.0);
             }
         }
         return;
     }

     void BarrelShifter::propagateTransitionInfo()
     {
         // The only thing can be updated are the input probabilities...so we will update them
         unsigned int number_bits = (unsigned int) getParameter("NumberBits");
         unsigned int number_shift_bits = (unsigned int) ceil(log2((double) number_bits));
         unsigned int shift_index_min = getParameter("ShiftIndexMin");
         unsigned int shift_index_max = getParameter("ShiftIndexMax");

         // Keep track of the multiplexer of the last stage
         ElectricalModel* last_mux = NULL;
         // We only need to update stuff if we are not shifting by exact multiples
         // of number of input bits
         if (shift_index_min < number_shift_bits)
         {
             for (unsigned int i = shift_index_min; i <= shift_index_max; ++i)
             {
                 unsigned int current_shifts = (unsigned int)pow(2, i);
                 String n = (String) current_shifts;

                 // Set the
                 const String& buf_inv_0_name = "ShiftBufInv0_" + (String) n;
                 const String& buf_inv_1_name = "ShiftBufInv1_" + (String) n;
                 const String& mux_name = "SRL" + n;

                 // Set the transition infos for the inverter buffers
                 ElectricalModel* buf_inv_0 = (ElectricalModel*) getSubInstance(buf_inv_0_name);
                 propagatePortTransitionInfo(buf_inv_0, "A", "Shift" + (String) i);
                 buf_inv_0->use();

                 ElectricalModel* buf_inv_1 = (ElectricalModel*) getSubInstance(buf_inv_1_name);
                 propagatePortTransitionInfo(buf_inv_1, "A", buf_inv_0, "Y");
                 buf_inv_1->use();

                 // Set the transition infos for the shift multiplexers
                 ElectricalModel* mux = (ElectricalModel*) getSubInstance(mux_name);
                 propagatePortTransitionInfo(mux, "Sel0", buf_inv_1, "Y");
                 if (last_mux == NULL)
                 {
                     propagatePortTransitionInfo(mux, "In0", "In");
                     propagatePortTransitionInfo(mux, "In1", "In");
                 }
                 else
                 {
                     propagatePortTransitionInfo(mux, "In0", last_mux, "Out");
                     propagatePortTransitionInfo(mux, "In1", last_mux, "Out");
                 }
                 mux->use();

                 // Set this to be the last mux visted
                 last_mux = mux;
             }
         }

         // If there isn't anything to shift
         if (last_mux == NULL)
             propagatePortTransitionInfo("Out", "In");
         // Take the transition info of the last mux
         else
             propagatePortTransitionInfo("Out", last_mux, "Out");

         return;
     }

 } // namespace DSENT
	/* 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/BarrelShifter.h"
	#include "model/electrical/Multiplexer.h"

	#include <cmath>

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

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

	BarrelShifter::~BarrelShifter()
	{}

	void BarrelShifter::initParameters()
	{
	addParameterName("NumberBits");
	addParameterName("ShiftIndexMin");
	addParameterName("ShiftIndexMax");
	addParameterName("BitDuplicate", "TRUE");
	return;
	}

	void BarrelShifter::initProperties()
	{
	return;
	}

	BarrelShifter* BarrelShifter::clone() const
	{
	return NULL;
	}

	void BarrelShifter::constructModel()
	{
	// Get parameters
	unsigned int number_bits = getParameter("NumberBits");
	unsigned int number_shift_bits = (unsigned int)ceil(log2((double) number_bits));
	unsigned int shift_index_min = getParameter("ShiftIndexMin");
	unsigned int shift_index_max = getParameter("ShiftIndexMax");
	bool bit_duplicate = (bool) getParameter("BitDuplicate");

	ASSERT(number_bits > 0, "[Error] " + getInstanceName() + " -> Number of bits must be > 0!");
	// No need to check these if there arent any shifts
	if (number_shift_bits > 0)
	{
	ASSERT(shift_index_min <= number_shift_bits,
	"[Error] " + getInstanceName() + " -> Min shift index must be >= 0 and <= " +
	"the total number of shift bits!");
	ASSERT(shift_index_max >= shift_index_min && shift_index_max <= number_shift_bits,
	"[Error] " + getInstanceName() + " -> Max shift index must be >= minimum shift index and <= " +
	"the total number of shift bits!");
	}

	//Construct electrical ports
	//Create each input port
	createInputPort( "In", makeNetIndex(0, number_bits-1));
	//Create output
	createOutputPort( "Out", makeNetIndex(0, number_bits-1));

	//Create shift ports (which only exists if there is something to shift)
	if (shift_index_min != number_shift_bits)
	for (unsigned int i = shift_index_min; i <= shift_index_max; ++i)
	createInputPort( "Shift" + (String) i);

	//Create energy, power, and area results
	createElectricalResults();
	createElectricalEventResult("BarrelShift");
	//Set conditions during idle event
	getEventInfo("Idle")->setStaticTransitionInfos();

	//If the input is only 1-bit, connect input to output and be done
	if (number_shift_bits == 0 \|\| (shift_index_min == number_shift_bits))
	assign("Out", "In");
	else
	{
	for (unsigned int i = shift_index_min; i <= shift_index_max; ++i)
	{
	//Create internally buffered shift select signals
	createNet("Shift_b" + (String) i);
	createNet("Shift_i" + (String) i);
	}

	// Create shift and shifted signals
	for (unsigned int i = shift_index_min; i <= shift_index_max; ++i)
	{
	unsigned int current_shifts = (unsigned int)pow(2, i);
	const String& n = (String) current_shifts;
	//Instantiate and connect intermediate nets. In a barrel-shifter, the nets do
	//all the "shifting" and the muxes just select which to take
	createNet("R_" + n, makeNetIndex(0, number_bits-1)); //wire R_n[number_bits-1:0]
	createNet("RS_" + n, makeNetIndex(0, number_bits-1)); //wire RS_n[number_bits-1:0]

	//Implements the shifts
	//assign RS_n[number_bits-1:number_bits-current_shifts] = R_n[current_shifts-1:0];
	assign("RS_" + n, makeNetIndex(number_bits-current_shifts, number_bits-1),
	"R_" + n, makeNetIndex(0, current_shifts-1));
	//assign RS_n[number_bits-current_shifts-1:0] = R_n[current_shifts:number_bits-1];
	assign("RS_" + n, makeNetIndex(0, number_bits-current_shifts-1),
	"R_" + n, makeNetIndex(current_shifts, number_bits-1));
	}

	const String& n_max = (String) pow(2, shift_index_max+1);
	const String& n_min = (String) pow(2, shift_index_min);
	// Create the R_(max) net
	createNet("R_" + n_max, makeNetIndex(0, number_bits-1));
	// Set R_1 to be the input
	assign("R_" + n_min, "In");
	// Set R_(max) to be the output
	assign("Out", "R_" + n_max, makeNetIndex(0, number_bits-1));

	for (unsigned int i = shift_index_min; i <= shift_index_max; ++i)
	{
	unsigned int current_shifts = (unsigned int)pow(2, i);
	const String& n = (String) current_shifts;
	const String& n_next = (String) (current_shifts * 2);

	const String& buf_inv_0_name = "ShiftBufInv0_" + (String) n;
	const String& buf_inv_1_name = "ShiftBufInv1_" + (String) n;
	// Create shift buffer inverters
	StdCell* buf_inv_0 = getTechModel()->getStdCellLib()->createStdCell("INV", buf_inv_0_name);
	buf_inv_0->construct();
	StdCell* buf_inv_1 = getTechModel()->getStdCellLib()->createStdCell("INV", buf_inv_1_name);
	buf_inv_1->construct();

	// Connect up shift buffer inverters
	portConnect(buf_inv_0, "A", "Shift" + (String) i);
	portConnect(buf_inv_0, "Y", "Shift_b" + (String) i);
	portConnect(buf_inv_1, "A", "Shift_b" + (String) i);
	portConnect(buf_inv_1, "Y", "Shift_i" + (String) i);

	// Add area, power, and event results for inverters
	addSubInstances(buf_inv_0, 1.0);
	addSubInstances(buf_inv_1, 1.0);
	addElectricalSubResults(buf_inv_0, 1.0);
	addElectricalSubResults(buf_inv_1, 1.0);
	getEventResult("BarrelShift")->addSubResult(buf_inv_0->getEventResult("INV"), buf_inv_0_name, 1.0);
	getEventResult("BarrelShift")->addSubResult(buf_inv_1->getEventResult("INV"), buf_inv_1_name, 1.0);

	//Instantiate 2:1 multiplexers, one for each shift bit.
	const String& mux_name = "SRL" + n;
	Multiplexer* mux = new Multiplexer(mux_name, getTechModel());
	mux->setParameter("NumberInputs", 2);
	mux->setParameter("NumberBits", number_bits);
	mux->setParameter("BitDuplicate", bit_duplicate);
	mux->construct();

	//Just have to connect the In0 and In1 inputs of the mux to the
	//non-shifted and shifted intermediate signals, respectively.
	portConnect(mux, "In0", "R_" + n);
	portConnect(mux, "In1", "RS_" + n);
	//Selector connects to the shift signal for that index
	portConnect(mux, "Sel0", "Shift_i" + (String) i);
	//Connect mux output
	portConnect(mux, "Out", "R_" + n_next);

	//Add area, power, and event results for each mux
	addSubInstances(mux, 1.0);
	addElectricalSubResults(mux, 1.0);
	getEventResult("BarrelShift")->addSubResult(mux->getEventResult("Mux"), mux_name, 1.0);
	}
	}
	return;
	}

	void BarrelShifter::propagateTransitionInfo()
	{
	// The only thing can be updated are the input probabilities...so we will update them
	unsigned int number_bits = (unsigned int) getParameter("NumberBits");
	unsigned int number_shift_bits = (unsigned int) ceil(log2((double) number_bits));
	unsigned int shift_index_min = getParameter("ShiftIndexMin");
	unsigned int shift_index_max = getParameter("ShiftIndexMax");

	// Keep track of the multiplexer of the last stage
	ElectricalModel* last_mux = NULL;
	// We only need to update stuff if we are not shifting by exact multiples
	// of number of input bits
	if (shift_index_min < number_shift_bits)
	{
	for (unsigned int i = shift_index_min; i <= shift_index_max; ++i)
	{
	unsigned int current_shifts = (unsigned int)pow(2, i);
	String n = (String) current_shifts;

	// Set the
	const String& buf_inv_0_name = "ShiftBufInv0_" + (String) n;
	const String& buf_inv_1_name = "ShiftBufInv1_" + (String) n;
	const String& mux_name = "SRL" + n;

	// Set the transition infos for the inverter buffers
	ElectricalModel* buf_inv_0 = (ElectricalModel*) getSubInstance(buf_inv_0_name);
	propagatePortTransitionInfo(buf_inv_0, "A", "Shift" + (String) i);
	buf_inv_0->use();

	ElectricalModel* buf_inv_1 = (ElectricalModel*) getSubInstance(buf_inv_1_name);
	propagatePortTransitionInfo(buf_inv_1, "A", buf_inv_0, "Y");
	buf_inv_1->use();

	// Set the transition infos for the shift multiplexers
	ElectricalModel* mux = (ElectricalModel*) getSubInstance(mux_name);
	propagatePortTransitionInfo(mux, "Sel0", buf_inv_1, "Y");
	if (last_mux == NULL)
	{
	propagatePortTransitionInfo(mux, "In0", "In");
	propagatePortTransitionInfo(mux, "In1", "In");
	}
	else
	{
	propagatePortTransitionInfo(mux, "In0", last_mux, "Out");
	propagatePortTransitionInfo(mux, "In1", last_mux, "Out");
	}
	mux->use();

	// Set this to be the last mux visted
	last_mux = mux;
	}
	}

	// If there isn't anything to shift
	if (last_mux == NULL)
	propagatePortTransitionInfo("Out", "In");
	// Take the transition info of the last mux
	else
	propagatePortTransitionInfo("Out", last_mux, "Out");

	return;
	}

	} // namespace DSENT