840 lines
46 KiB
C++
840 lines
46 KiB
C++
/*****************************************************************************
|
|
* McPAT
|
|
* SOFTWARE LICENSE AGREEMENT
|
|
* Copyright 2012 Hewlett-Packard Development Company, L.P.
|
|
* All Rights Reserved
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are
|
|
* met: redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer;
|
|
* redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution;
|
|
* neither the name of the copyright holders nor the names of its
|
|
* contributors may be used to endorse or promote products derived from
|
|
* this software without specific prior written permission.
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.”
|
|
*
|
|
***************************************************************************/
|
|
#include <algorithm>
|
|
#include <cassert>
|
|
#include <cmath>
|
|
#include <cstdio>
|
|
#include <cstring>
|
|
#include <fstream>
|
|
#include <iostream>
|
|
|
|
#include "XML_Parse.h"
|
|
#include "array.h"
|
|
#include "basic_circuit.h"
|
|
#include "const.h"
|
|
#include "parameter.h"
|
|
#include "processor.h"
|
|
#include "version.h"
|
|
|
|
Processor::Processor(ParseXML *XML_interface)
|
|
:XML(XML_interface),//TODO: using one global copy may have problems.
|
|
mc(0),
|
|
niu(0),
|
|
pcie(0),
|
|
flashcontroller(0)
|
|
{
|
|
/*
|
|
* placement and routing overhead is 10%, core scales worse than cache 40% is accumulated from 90 to 22nm
|
|
* There is no point to have heterogeneous memory controller on chip,
|
|
* thus McPAT only support homogeneous memory controllers.
|
|
*/
|
|
int i;
|
|
double pppm_t[4] = {1,1,1,1};
|
|
set_proc_param();
|
|
if (procdynp.homoCore)
|
|
numCore = procdynp.numCore==0? 0:1;
|
|
else
|
|
numCore = procdynp.numCore;
|
|
|
|
if (procdynp.homoL2)
|
|
numL2 = procdynp.numL2==0? 0:1;
|
|
else
|
|
numL2 = procdynp.numL2;
|
|
|
|
if (XML->sys.Private_L2 && numCore != numL2)
|
|
{
|
|
cout<<"Number of private L2 does not match number of cores"<<endl;
|
|
exit(0);
|
|
}
|
|
|
|
if (procdynp.homoL3)
|
|
numL3 = procdynp.numL3==0? 0:1;
|
|
else
|
|
numL3 = procdynp.numL3;
|
|
|
|
if (procdynp.homoNOC)
|
|
numNOC = procdynp.numNOC==0? 0:1;
|
|
else
|
|
numNOC = procdynp.numNOC;
|
|
|
|
// if (!procdynp.homoNOC)
|
|
// {
|
|
// cout<<"Current McPAT does not support heterogeneous NOC"<<endl;
|
|
// exit(0);
|
|
// }
|
|
|
|
if (procdynp.homoL1Dir)
|
|
numL1Dir = procdynp.numL1Dir==0? 0:1;
|
|
else
|
|
numL1Dir = procdynp.numL1Dir;
|
|
|
|
if (procdynp.homoL2Dir)
|
|
numL2Dir = procdynp.numL2Dir==0? 0:1;
|
|
else
|
|
numL2Dir = procdynp.numL2Dir;
|
|
|
|
for (i = 0;i < numCore; i++)
|
|
{
|
|
cores.push_back(new Core(XML,i, &interface_ip));
|
|
cores[i]->computeEnergy();
|
|
cores[i]->computeEnergy(false);
|
|
if (procdynp.homoCore){
|
|
core.area.set_area(core.area.get_area() + cores[i]->area.get_area()*procdynp.numCore);
|
|
set_pppm(pppm_t,cores[i]->clockRate*procdynp.numCore, procdynp.numCore,procdynp.numCore,procdynp.numCore);
|
|
core.power = core.power + cores[i]->power*pppm_t;
|
|
set_pppm(pppm_t,1/cores[i]->executionTime, procdynp.numCore,procdynp.numCore,procdynp.numCore);
|
|
core.rt_power = core.rt_power + cores[i]->rt_power*pppm_t;
|
|
area.set_area(area.get_area() + core.area.get_area());//placement and routing overhead is 10%, core scales worse than cache 40% is accumulated from 90 to 22nm
|
|
power = power + core.power;
|
|
rt_power = rt_power + core.rt_power;
|
|
}
|
|
else{
|
|
core.area.set_area(core.area.get_area() + cores[i]->area.get_area());
|
|
area.set_area(area.get_area() + cores[i]->area.get_area());//placement and routing overhead is 10%, core scales worse than cache 40% is accumulated from 90 to 22nm
|
|
|
|
set_pppm(pppm_t,cores[i]->clockRate, 1, 1, 1);
|
|
core.power = core.power + cores[i]->power*pppm_t;
|
|
power = power + cores[i]->power*pppm_t;
|
|
|
|
set_pppm(pppm_t,1/cores[i]->executionTime, 1, 1, 1);
|
|
core.rt_power = core.rt_power + cores[i]->rt_power*pppm_t;
|
|
rt_power = rt_power + cores[i]->rt_power*pppm_t;
|
|
}
|
|
}
|
|
|
|
if (!XML->sys.Private_L2)
|
|
{
|
|
if (numL2 >0)
|
|
for (i = 0;i < numL2; i++)
|
|
{
|
|
l2array.push_back(new SharedCache(XML,i, &interface_ip));
|
|
l2array[i]->computeEnergy();
|
|
l2array[i]->computeEnergy(false);
|
|
if (procdynp.homoL2){
|
|
l2.area.set_area(l2.area.get_area() + l2array[i]->area.get_area()*procdynp.numL2);
|
|
set_pppm(pppm_t,l2array[i]->cachep.clockRate*procdynp.numL2, procdynp.numL2,procdynp.numL2,procdynp.numL2);
|
|
l2.power = l2.power + l2array[i]->power*pppm_t;
|
|
set_pppm(pppm_t,1/l2array[i]->cachep.executionTime, procdynp.numL2,procdynp.numL2,procdynp.numL2);
|
|
l2.rt_power = l2.rt_power + l2array[i]->rt_power*pppm_t;
|
|
area.set_area(area.get_area() + l2.area.get_area());//placement and routing overhead is 10%, l2 scales worse than cache 40% is accumulated from 90 to 22nm
|
|
power = power + l2.power;
|
|
rt_power = rt_power + l2.rt_power;
|
|
}
|
|
else{
|
|
l2.area.set_area(l2.area.get_area() + l2array[i]->area.get_area());
|
|
area.set_area(area.get_area() + l2array[i]->area.get_area());//placement and routing overhead is 10%, l2 scales worse than cache 40% is accumulated from 90 to 22nm
|
|
|
|
set_pppm(pppm_t,l2array[i]->cachep.clockRate, 1, 1, 1);
|
|
l2.power = l2.power + l2array[i]->power*pppm_t;
|
|
power = power + l2array[i]->power*pppm_t;;
|
|
set_pppm(pppm_t,1/l2array[i]->cachep.executionTime, 1, 1, 1);
|
|
l2.rt_power = l2.rt_power + l2array[i]->rt_power*pppm_t;
|
|
rt_power = rt_power + l2array[i]->rt_power*pppm_t;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (numL3 >0)
|
|
for (i = 0;i < numL3; i++)
|
|
{
|
|
l3array.push_back(new SharedCache(XML,i, &interface_ip, L3));
|
|
l3array[i]->computeEnergy();
|
|
l3array[i]->computeEnergy(false);
|
|
if (procdynp.homoL3){
|
|
l3.area.set_area(l3.area.get_area() + l3array[i]->area.get_area()*procdynp.numL3);
|
|
set_pppm(pppm_t,l3array[i]->cachep.clockRate*procdynp.numL3, procdynp.numL3,procdynp.numL3,procdynp.numL3);
|
|
l3.power = l3.power + l3array[i]->power*pppm_t;
|
|
set_pppm(pppm_t,1/l3array[i]->cachep.executionTime, procdynp.numL3,procdynp.numL3,procdynp.numL3);
|
|
l3.rt_power = l3.rt_power + l3array[i]->rt_power*pppm_t;
|
|
area.set_area(area.get_area() + l3.area.get_area());//placement and routing overhead is 10%, l3 scales worse than cache 40% is accumulated from 90 to 22nm
|
|
power = power + l3.power;
|
|
rt_power = rt_power + l3.rt_power;
|
|
|
|
}
|
|
else{
|
|
l3.area.set_area(l3.area.get_area() + l3array[i]->area.get_area());
|
|
area.set_area(area.get_area() + l3array[i]->area.get_area());//placement and routing overhead is 10%, l3 scales worse than cache 40% is accumulated from 90 to 22nm
|
|
set_pppm(pppm_t,l3array[i]->cachep.clockRate, 1, 1, 1);
|
|
l3.power = l3.power + l3array[i]->power*pppm_t;
|
|
power = power + l3array[i]->power*pppm_t;
|
|
set_pppm(pppm_t,1/l3array[i]->cachep.executionTime, 1, 1, 1);
|
|
l3.rt_power = l3.rt_power + l3array[i]->rt_power*pppm_t;
|
|
rt_power = rt_power + l3array[i]->rt_power*pppm_t;
|
|
|
|
}
|
|
}
|
|
if (numL1Dir >0)
|
|
for (i = 0;i < numL1Dir; i++)
|
|
{
|
|
l1dirarray.push_back(new SharedCache(XML,i, &interface_ip, L1Directory));
|
|
l1dirarray[i]->computeEnergy();
|
|
l1dirarray[i]->computeEnergy(false);
|
|
if (procdynp.homoL1Dir){
|
|
l1dir.area.set_area(l1dir.area.get_area() + l1dirarray[i]->area.get_area()*procdynp.numL1Dir);
|
|
set_pppm(pppm_t,l1dirarray[i]->cachep.clockRate*procdynp.numL1Dir, procdynp.numL1Dir,procdynp.numL1Dir,procdynp.numL1Dir);
|
|
l1dir.power = l1dir.power + l1dirarray[i]->power*pppm_t;
|
|
set_pppm(pppm_t,1/l1dirarray[i]->cachep.executionTime, procdynp.numL1Dir,procdynp.numL1Dir,procdynp.numL1Dir);
|
|
l1dir.rt_power = l1dir.rt_power + l1dirarray[i]->rt_power*pppm_t;
|
|
area.set_area(area.get_area() + l1dir.area.get_area());//placement and routing overhead is 10%, l1dir scales worse than cache 40% is accumulated from 90 to 22nm
|
|
power = power + l1dir.power;
|
|
rt_power = rt_power + l1dir.rt_power;
|
|
|
|
}
|
|
else{
|
|
l1dir.area.set_area(l1dir.area.get_area() + l1dirarray[i]->area.get_area());
|
|
area.set_area(area.get_area() + l1dirarray[i]->area.get_area());
|
|
set_pppm(pppm_t,l1dirarray[i]->cachep.clockRate, 1, 1, 1);
|
|
l1dir.power = l1dir.power + l1dirarray[i]->power*pppm_t;
|
|
power = power + l1dirarray[i]->power;
|
|
set_pppm(pppm_t,1/l1dirarray[i]->cachep.executionTime, 1, 1, 1);
|
|
l1dir.rt_power = l1dir.rt_power + l1dirarray[i]->rt_power*pppm_t;
|
|
rt_power = rt_power + l1dirarray[i]->rt_power;
|
|
}
|
|
}
|
|
|
|
if (numL2Dir >0)
|
|
for (i = 0;i < numL2Dir; i++)
|
|
{
|
|
l2dirarray.push_back(new SharedCache(XML,i, &interface_ip, L2Directory));
|
|
l2dirarray[i]->computeEnergy();
|
|
l2dirarray[i]->computeEnergy(false);
|
|
if (procdynp.homoL2Dir){
|
|
l2dir.area.set_area(l2dir.area.get_area() + l2dirarray[i]->area.get_area()*procdynp.numL2Dir);
|
|
set_pppm(pppm_t,l2dirarray[i]->cachep.clockRate*procdynp.numL2Dir, procdynp.numL2Dir,procdynp.numL2Dir,procdynp.numL2Dir);
|
|
l2dir.power = l2dir.power + l2dirarray[i]->power*pppm_t;
|
|
set_pppm(pppm_t,1/l2dirarray[i]->cachep.executionTime, procdynp.numL2Dir,procdynp.numL2Dir,procdynp.numL2Dir);
|
|
l2dir.rt_power = l2dir.rt_power + l2dirarray[i]->rt_power*pppm_t;
|
|
area.set_area(area.get_area() + l2dir.area.get_area());//placement and routing overhead is 10%, l2dir scales worse than cache 40% is accumulated from 90 to 22nm
|
|
power = power + l2dir.power;
|
|
rt_power = rt_power + l2dir.rt_power;
|
|
|
|
}
|
|
else{
|
|
l2dir.area.set_area(l2dir.area.get_area() + l2dirarray[i]->area.get_area());
|
|
area.set_area(area.get_area() + l2dirarray[i]->area.get_area());
|
|
set_pppm(pppm_t,l2dirarray[i]->cachep.clockRate, 1, 1, 1);
|
|
l2dir.power = l2dir.power + l2dirarray[i]->power*pppm_t;
|
|
power = power + l2dirarray[i]->power*pppm_t;
|
|
set_pppm(pppm_t,1/l2dirarray[i]->cachep.executionTime, 1, 1, 1);
|
|
l2dir.rt_power = l2dir.rt_power + l2dirarray[i]->rt_power*pppm_t;
|
|
rt_power = rt_power + l2dirarray[i]->rt_power*pppm_t;
|
|
}
|
|
}
|
|
|
|
if (XML->sys.mc.number_mcs >0 && XML->sys.mc.memory_channels_per_mc>0)
|
|
{
|
|
mc = new MemoryController(XML, &interface_ip, MC);
|
|
mc->computeEnergy();
|
|
mc->computeEnergy(false);
|
|
mcs.area.set_area(mcs.area.get_area()+mc->area.get_area()*XML->sys.mc.number_mcs);
|
|
area.set_area(area.get_area()+mc->area.get_area()*XML->sys.mc.number_mcs);
|
|
set_pppm(pppm_t,XML->sys.mc.number_mcs*mc->mcp.clockRate, XML->sys.mc.number_mcs,XML->sys.mc.number_mcs,XML->sys.mc.number_mcs);
|
|
mcs.power = mc->power*pppm_t;
|
|
power = power + mcs.power;
|
|
set_pppm(pppm_t,1/mc->mcp.executionTime, XML->sys.mc.number_mcs,XML->sys.mc.number_mcs,XML->sys.mc.number_mcs);
|
|
mcs.rt_power = mc->rt_power*pppm_t;
|
|
rt_power = rt_power + mcs.rt_power;
|
|
|
|
}
|
|
|
|
if (XML->sys.flashc.number_mcs >0 )//flash controller
|
|
{
|
|
flashcontroller = new FlashController(XML, &interface_ip);
|
|
flashcontroller->computeEnergy();
|
|
flashcontroller->computeEnergy(false);
|
|
double number_fcs = flashcontroller->fcp.num_mcs;
|
|
flashcontrollers.area.set_area(flashcontrollers.area.get_area()+flashcontroller->area.get_area()*number_fcs);
|
|
area.set_area(area.get_area()+flashcontrollers.area.get_area());
|
|
set_pppm(pppm_t,number_fcs, number_fcs ,number_fcs, number_fcs );
|
|
flashcontrollers.power = flashcontroller->power*pppm_t;
|
|
power = power + flashcontrollers.power;
|
|
set_pppm(pppm_t,number_fcs , number_fcs ,number_fcs ,number_fcs );
|
|
flashcontrollers.rt_power = flashcontroller->rt_power*pppm_t;
|
|
rt_power = rt_power + flashcontrollers.rt_power;
|
|
|
|
}
|
|
|
|
if (XML->sys.niu.number_units >0)
|
|
{
|
|
niu = new NIUController(XML, &interface_ip);
|
|
niu->computeEnergy();
|
|
niu->computeEnergy(false);
|
|
nius.area.set_area(nius.area.get_area()+niu->area.get_area()*XML->sys.niu.number_units);
|
|
area.set_area(area.get_area()+niu->area.get_area()*XML->sys.niu.number_units);
|
|
set_pppm(pppm_t,XML->sys.niu.number_units*niu->niup.clockRate, XML->sys.niu.number_units,XML->sys.niu.number_units,XML->sys.niu.number_units);
|
|
nius.power = niu->power*pppm_t;
|
|
power = power + nius.power;
|
|
set_pppm(pppm_t,XML->sys.niu.number_units*niu->niup.clockRate, XML->sys.niu.number_units,XML->sys.niu.number_units,XML->sys.niu.number_units);
|
|
nius.rt_power = niu->rt_power*pppm_t;
|
|
rt_power = rt_power + nius.rt_power;
|
|
|
|
}
|
|
|
|
if (XML->sys.pcie.number_units >0 && XML->sys.pcie.num_channels >0)
|
|
{
|
|
pcie = new PCIeController(XML, &interface_ip);
|
|
pcie->computeEnergy();
|
|
pcie->computeEnergy(false);
|
|
pcies.area.set_area(pcies.area.get_area()+pcie->area.get_area()*XML->sys.pcie.number_units);
|
|
area.set_area(area.get_area()+pcie->area.get_area()*XML->sys.pcie.number_units);
|
|
set_pppm(pppm_t,XML->sys.pcie.number_units*pcie->pciep.clockRate, XML->sys.pcie.number_units,XML->sys.pcie.number_units,XML->sys.pcie.number_units);
|
|
pcies.power = pcie->power*pppm_t;
|
|
power = power + pcies.power;
|
|
set_pppm(pppm_t,XML->sys.pcie.number_units*pcie->pciep.clockRate, XML->sys.pcie.number_units,XML->sys.pcie.number_units,XML->sys.pcie.number_units);
|
|
pcies.rt_power = pcie->rt_power*pppm_t;
|
|
rt_power = rt_power + pcies.rt_power;
|
|
|
|
}
|
|
|
|
if (numNOC >0)
|
|
{
|
|
for (i = 0;i < numNOC; i++)
|
|
{
|
|
if (XML->sys.NoC[i].type)
|
|
{//First add up area of routers if NoC is used
|
|
nocs.push_back(new NoC(XML,i, &interface_ip, 1));
|
|
if (procdynp.homoNOC)
|
|
{
|
|
noc.area.set_area(noc.area.get_area() + nocs[i]->area.get_area()*procdynp.numNOC);
|
|
area.set_area(area.get_area() + noc.area.get_area());
|
|
}
|
|
else
|
|
{
|
|
noc.area.set_area(noc.area.get_area() + nocs[i]->area.get_area());
|
|
area.set_area(area.get_area() + nocs[i]->area.get_area());
|
|
}
|
|
}
|
|
else
|
|
{//Bus based interconnect
|
|
nocs.push_back(new NoC(XML,i, &interface_ip, 1, sqrt(area.get_area()*XML->sys.NoC[i].chip_coverage)));
|
|
if (procdynp.homoNOC){
|
|
noc.area.set_area(noc.area.get_area() + nocs[i]->area.get_area()*procdynp.numNOC);
|
|
area.set_area(area.get_area() + noc.area.get_area());
|
|
}
|
|
else
|
|
{
|
|
noc.area.set_area(noc.area.get_area() + nocs[i]->area.get_area());
|
|
area.set_area(area.get_area() + nocs[i]->area.get_area());
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Compute global links associated with each NOC, if any. This must be done at the end (even after the NOC router part) since the total chip
|
|
* area must be obtain to decide the link routing
|
|
*/
|
|
for (i = 0;i < numNOC; i++)
|
|
{
|
|
if (nocs[i]->nocdynp.has_global_link && XML->sys.NoC[i].type)
|
|
{
|
|
nocs[i]->init_link_bus(sqrt(area.get_area()*XML->sys.NoC[i].chip_coverage));//compute global links
|
|
if (procdynp.homoNOC)
|
|
{
|
|
noc.area.set_area(noc.area.get_area() + nocs[i]->link_bus_tot_per_Router.area.get_area()
|
|
* nocs[i]->nocdynp.total_nodes
|
|
* procdynp.numNOC);
|
|
area.set_area(area.get_area() + nocs[i]->link_bus_tot_per_Router.area.get_area()
|
|
* nocs[i]->nocdynp.total_nodes
|
|
* procdynp.numNOC);
|
|
}
|
|
else
|
|
{
|
|
noc.area.set_area(noc.area.get_area() + nocs[i]->link_bus_tot_per_Router.area.get_area()
|
|
* nocs[i]->nocdynp.total_nodes);
|
|
area.set_area(area.get_area() + nocs[i]->link_bus_tot_per_Router.area.get_area()
|
|
* nocs[i]->nocdynp.total_nodes);
|
|
}
|
|
}
|
|
}
|
|
//Compute energy of NoC (w or w/o links) or buses
|
|
for (i = 0;i < numNOC; i++)
|
|
{
|
|
nocs[i]->computeEnergy();
|
|
nocs[i]->computeEnergy(false);
|
|
if (procdynp.homoNOC){
|
|
set_pppm(pppm_t,procdynp.numNOC*nocs[i]->nocdynp.clockRate, procdynp.numNOC,procdynp.numNOC,procdynp.numNOC);
|
|
noc.power = noc.power + nocs[i]->power*pppm_t;
|
|
set_pppm(pppm_t,1/nocs[i]->nocdynp.executionTime, procdynp.numNOC,procdynp.numNOC,procdynp.numNOC);
|
|
noc.rt_power = noc.rt_power + nocs[i]->rt_power*pppm_t;
|
|
power = power + noc.power;
|
|
rt_power = rt_power + noc.rt_power;
|
|
}
|
|
else
|
|
{
|
|
set_pppm(pppm_t,nocs[i]->nocdynp.clockRate, 1, 1, 1);
|
|
noc.power = noc.power + nocs[i]->power*pppm_t;
|
|
power = power + nocs[i]->power*pppm_t;
|
|
set_pppm(pppm_t,1/nocs[i]->nocdynp.executionTime, 1, 1, 1);
|
|
noc.rt_power = noc.rt_power + nocs[i]->rt_power*pppm_t;
|
|
rt_power = rt_power + nocs[i]->rt_power*pppm_t;
|
|
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
// //clock power
|
|
// globalClock.init_wire_external(is_default, &interface_ip);
|
|
// globalClock.clk_area =area*1e6; //change it from mm^2 to um^2
|
|
// globalClock.end_wiring_level =5;//toplevel metal
|
|
// globalClock.start_wiring_level =5;//toplevel metal
|
|
// globalClock.l_ip.with_clock_grid=false;//global clock does not drive local final nodes
|
|
// globalClock.optimize_wire();
|
|
|
|
}
|
|
|
|
void Processor::displayDeviceType(int device_type_, uint32_t indent)
|
|
{
|
|
string indent_str(indent, ' ');
|
|
|
|
switch ( device_type_ ) {
|
|
|
|
case 0 :
|
|
cout <<indent_str<<"Device Type= "<<"ITRS high performance device type"<<endl;
|
|
break;
|
|
case 1 :
|
|
cout <<indent_str<<"Device Type= "<<"ITRS low standby power device type"<<endl;
|
|
break;
|
|
case 2 :
|
|
cout <<indent_str<<"Device Type= "<<"ITRS low operating power device type"<<endl;
|
|
break;
|
|
case 3 :
|
|
cout <<indent_str<<"Device Type= "<<"LP-DRAM device type"<<endl;
|
|
break;
|
|
case 4 :
|
|
cout <<indent_str<<"Device Type= "<<"COMM-DRAM device type"<<endl;
|
|
break;
|
|
default :
|
|
{
|
|
cout <<indent_str<<"Unknown Device Type"<<endl;
|
|
exit(0);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Processor::displayInterconnectType(int interconnect_type_, uint32_t indent)
|
|
{
|
|
string indent_str(indent, ' ');
|
|
|
|
switch ( interconnect_type_ ) {
|
|
|
|
case 0 :
|
|
cout <<indent_str<<"Interconnect metal projection= "<<"aggressive interconnect technology projection"<<endl;
|
|
break;
|
|
case 1 :
|
|
cout <<indent_str<<"Interconnect metal projection= "<<"conservative interconnect technology projection"<<endl;
|
|
break;
|
|
default :
|
|
{
|
|
cout <<indent_str<<"Unknown Interconnect Projection Type"<<endl;
|
|
exit(0);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Processor::displayEnergy(uint32_t indent, int plevel, bool is_tdp)
|
|
{
|
|
int i;
|
|
bool long_channel = XML->sys.longer_channel_device;
|
|
string indent_str(indent, ' ');
|
|
string indent_str_next(indent+2, ' ');
|
|
if (is_tdp)
|
|
{
|
|
|
|
if (plevel<5)
|
|
{
|
|
cout<<"\nMcPAT (version "<< VER_MAJOR <<"."<< VER_MINOR
|
|
<< " of " << VER_UPDATE << ") results (current print level is "<< plevel
|
|
<<", please increase print level to see the details in components): "<<endl;
|
|
}
|
|
else
|
|
{
|
|
cout<<"\nMcPAT (version "<< VER_MAJOR <<"."<< VER_MINOR
|
|
<< " of " << VER_UPDATE << ") results (current print level is 5)"<< endl;
|
|
}
|
|
cout <<"*****************************************************************************************"<<endl;
|
|
cout <<indent_str<<"Technology "<<XML->sys.core_tech_node<<" nm"<<endl;
|
|
//cout <<indent_str<<"Device Type= "<<XML->sys.device_type<<endl;
|
|
if (long_channel)
|
|
cout <<indent_str<<"Using Long Channel Devices When Appropriate"<<endl;
|
|
//cout <<indent_str<<"Interconnect metal projection= "<<XML->sys.interconnect_projection_type<<endl;
|
|
displayInterconnectType(XML->sys.interconnect_projection_type, indent);
|
|
cout <<indent_str<<"Core clock Rate(MHz) "<<XML->sys.core[0].clock_rate<<endl;
|
|
cout <<endl;
|
|
cout <<"*****************************************************************************************"<<endl;
|
|
cout <<"Processor: "<<endl;
|
|
cout << indent_str << "Area = " << area.get_area()*1e-6<< " mm^2" << endl;
|
|
cout << indent_str << "Peak Power = " << power.readOp.dynamic +
|
|
(long_channel? power.readOp.longer_channel_leakage:power.readOp.leakage) + power.readOp.gate_leakage <<" W" << endl;
|
|
cout << indent_str << "Total Leakage = " <<
|
|
(long_channel? power.readOp.longer_channel_leakage:power.readOp.leakage) + power.readOp.gate_leakage <<" W" << endl;
|
|
cout << indent_str << "Peak Dynamic = " << power.readOp.dynamic << " W" << endl;
|
|
cout << indent_str << "Subthreshold Leakage = " << (long_channel? power.readOp.longer_channel_leakage:power.readOp.leakage) <<" W" << endl;
|
|
//cout << indent_str << "Subthreshold Leakage = " << power.readOp.longer_channel_leakage <<" W" << endl;
|
|
cout << indent_str << "Gate Leakage = " << power.readOp.gate_leakage << " W" << endl;
|
|
cout << indent_str << "Runtime Dynamic = " << rt_power.readOp.dynamic << " W" << endl;
|
|
cout <<endl;
|
|
if (numCore >0){
|
|
cout <<indent_str<<"Total Cores: "<<XML->sys.number_of_cores << " cores "<<endl;
|
|
displayDeviceType(XML->sys.device_type,indent);
|
|
cout << indent_str_next << "Area = " << core.area.get_area()*1e-6<< " mm^2" << endl;
|
|
cout << indent_str_next << "Peak Dynamic = " << core.power.readOp.dynamic << " W" << endl;
|
|
cout << indent_str_next << "Subthreshold Leakage = "
|
|
<< (long_channel? core.power.readOp.longer_channel_leakage:core.power.readOp.leakage) <<" W" << endl;
|
|
//cout << indent_str_next << "Subthreshold Leakage = " << core.power.readOp.longer_channel_leakage <<" W" << endl;
|
|
cout << indent_str_next << "Gate Leakage = " << core.power.readOp.gate_leakage << " W" << endl;
|
|
cout << indent_str_next << "Runtime Dynamic = " << core.rt_power.readOp.dynamic << " W" << endl;
|
|
cout <<endl;
|
|
}
|
|
if (!XML->sys.Private_L2)
|
|
{
|
|
if (numL2 >0){
|
|
cout <<indent_str<<"Total L2s: "<<endl;
|
|
displayDeviceType(XML->sys.L2[0].device_type,indent);
|
|
cout << indent_str_next << "Area = " << l2.area.get_area()*1e-6<< " mm^2" << endl;
|
|
cout << indent_str_next << "Peak Dynamic = " << l2.power.readOp.dynamic << " W" << endl;
|
|
cout << indent_str_next << "Subthreshold Leakage = "
|
|
<< (long_channel? l2.power.readOp.longer_channel_leakage:l2.power.readOp.leakage) <<" W" << endl;
|
|
//cout << indent_str_next << "Subthreshold Leakage = " << l2.power.readOp.longer_channel_leakage <<" W" << endl;
|
|
cout << indent_str_next << "Gate Leakage = " << l2.power.readOp.gate_leakage << " W" << endl;
|
|
cout << indent_str_next << "Runtime Dynamic = " << l2.rt_power.readOp.dynamic << " W" << endl;
|
|
cout <<endl;
|
|
}
|
|
}
|
|
if (numL3 >0){
|
|
cout <<indent_str<<"Total L3s: "<<endl;
|
|
displayDeviceType(XML->sys.L3[0].device_type, indent);
|
|
cout << indent_str_next << "Area = " << l3.area.get_area()*1e-6<< " mm^2" << endl;
|
|
cout << indent_str_next << "Peak Dynamic = " << l3.power.readOp.dynamic << " W" << endl;
|
|
cout << indent_str_next << "Subthreshold Leakage = "
|
|
<< (long_channel? l3.power.readOp.longer_channel_leakage:l3.power.readOp.leakage) <<" W" << endl;
|
|
//cout << indent_str_next << "Subthreshold Leakage = " << l3.power.readOp.longer_channel_leakage <<" W" << endl;
|
|
cout << indent_str_next << "Gate Leakage = " << l3.power.readOp.gate_leakage << " W" << endl;
|
|
cout << indent_str_next << "Runtime Dynamic = " << l3.rt_power.readOp.dynamic << " W" << endl;
|
|
cout <<endl;
|
|
}
|
|
if (numL1Dir >0){
|
|
cout <<indent_str<<"Total First Level Directory: "<<endl;
|
|
displayDeviceType(XML->sys.L1Directory[0].device_type, indent);
|
|
cout << indent_str_next << "Area = " << l1dir.area.get_area()*1e-6<< " mm^2" << endl;
|
|
cout << indent_str_next << "Peak Dynamic = " << l1dir.power.readOp.dynamic << " W" << endl;
|
|
cout << indent_str_next << "Subthreshold Leakage = "
|
|
<< (long_channel? l1dir.power.readOp.longer_channel_leakage:l1dir.power.readOp.leakage) <<" W" << endl;
|
|
//cout << indent_str_next << "Subthreshold Leakage = " << l1dir.power.readOp.longer_channel_leakage <<" W" << endl;
|
|
cout << indent_str_next << "Gate Leakage = " << l1dir.power.readOp.gate_leakage << " W" << endl;
|
|
cout << indent_str_next << "Runtime Dynamic = " << l1dir.rt_power.readOp.dynamic << " W" << endl;
|
|
cout <<endl;
|
|
}
|
|
if (numL2Dir >0){
|
|
cout <<indent_str<<"Total First Level Directory: "<<endl;
|
|
displayDeviceType(XML->sys.L1Directory[0].device_type, indent);
|
|
cout << indent_str_next << "Area = " << l2dir.area.get_area()*1e-6<< " mm^2" << endl;
|
|
cout << indent_str_next << "Peak Dynamic = " << l2dir.power.readOp.dynamic << " W" << endl;
|
|
cout << indent_str_next << "Subthreshold Leakage = "
|
|
<< (long_channel? l2dir.power.readOp.longer_channel_leakage:l2dir.power.readOp.leakage) <<" W" << endl;
|
|
//cout << indent_str_next << "Subthreshold Leakage = " << l2dir.power.readOp.longer_channel_leakage <<" W" << endl;
|
|
cout << indent_str_next << "Gate Leakage = " << l2dir.power.readOp.gate_leakage << " W" << endl;
|
|
cout << indent_str_next << "Runtime Dynamic = " << l2dir.rt_power.readOp.dynamic << " W" << endl;
|
|
cout <<endl;
|
|
}
|
|
if (numNOC >0){
|
|
cout <<indent_str<<"Total NoCs (Network/Bus): "<<endl;
|
|
displayDeviceType(XML->sys.device_type, indent);
|
|
cout << indent_str_next << "Area = " << noc.area.get_area()*1e-6<< " mm^2" << endl;
|
|
cout << indent_str_next << "Peak Dynamic = " << noc.power.readOp.dynamic << " W" << endl;
|
|
cout << indent_str_next << "Subthreshold Leakage = "
|
|
<< (long_channel? noc.power.readOp.longer_channel_leakage:noc.power.readOp.leakage) <<" W" << endl;
|
|
//cout << indent_str_next << "Subthreshold Leakage = " << noc.power.readOp.longer_channel_leakage <<" W" << endl;
|
|
cout << indent_str_next << "Gate Leakage = " << noc.power.readOp.gate_leakage << " W" << endl;
|
|
cout << indent_str_next << "Runtime Dynamic = " << noc.rt_power.readOp.dynamic << " W" << endl;
|
|
cout <<endl;
|
|
}
|
|
if (XML->sys.mc.number_mcs >0 && XML->sys.mc.memory_channels_per_mc>0)
|
|
{
|
|
cout <<indent_str<<"Total MCs: "<<XML->sys.mc.number_mcs << " Memory Controllers "<<endl;
|
|
displayDeviceType(XML->sys.device_type, indent);
|
|
cout << indent_str_next << "Area = " << mcs.area.get_area()*1e-6<< " mm^2" << endl;
|
|
cout << indent_str_next << "Peak Dynamic = " << mcs.power.readOp.dynamic << " W" << endl;
|
|
cout << indent_str_next << "Subthreshold Leakage = "
|
|
<< (long_channel? mcs.power.readOp.longer_channel_leakage:mcs.power.readOp.leakage) <<" W" << endl;
|
|
cout << indent_str_next << "Gate Leakage = " << mcs.power.readOp.gate_leakage << " W" << endl;
|
|
cout << indent_str_next << "Runtime Dynamic = " << mcs.rt_power.readOp.dynamic << " W" << endl;
|
|
cout <<endl;
|
|
}
|
|
if (XML->sys.flashc.number_mcs >0)
|
|
{
|
|
cout <<indent_str<<"Total Flash/SSD Controllers: "<<flashcontroller->fcp.num_mcs << " Flash/SSD Controllers "<<endl;
|
|
displayDeviceType(XML->sys.device_type, indent);
|
|
cout << indent_str_next << "Area = " << flashcontrollers.area.get_area()*1e-6<< " mm^2" << endl;
|
|
cout << indent_str_next << "Peak Dynamic = " << flashcontrollers.power.readOp.dynamic << " W" << endl;
|
|
cout << indent_str_next << "Subthreshold Leakage = "
|
|
<< (long_channel? flashcontrollers.power.readOp.longer_channel_leakage:flashcontrollers.power.readOp.leakage) <<" W" << endl;
|
|
cout << indent_str_next << "Gate Leakage = " << flashcontrollers.power.readOp.gate_leakage << " W" << endl;
|
|
cout << indent_str_next << "Runtime Dynamic = " << flashcontrollers.rt_power.readOp.dynamic << " W" << endl;
|
|
cout <<endl;
|
|
}
|
|
if (XML->sys.niu.number_units >0 )
|
|
{
|
|
cout <<indent_str<<"Total NIUs: "<<niu->niup.num_units << " Network Interface Units "<<endl;
|
|
displayDeviceType(XML->sys.device_type, indent);
|
|
cout << indent_str_next << "Area = " << nius.area.get_area()*1e-6<< " mm^2" << endl;
|
|
cout << indent_str_next << "Peak Dynamic = " << nius.power.readOp.dynamic << " W" << endl;
|
|
cout << indent_str_next << "Subthreshold Leakage = "
|
|
<< (long_channel? nius.power.readOp.longer_channel_leakage:nius.power.readOp.leakage) <<" W" << endl;
|
|
cout << indent_str_next << "Gate Leakage = " << nius.power.readOp.gate_leakage << " W" << endl;
|
|
cout << indent_str_next << "Runtime Dynamic = " << nius.rt_power.readOp.dynamic << " W" << endl;
|
|
cout <<endl;
|
|
}
|
|
if (XML->sys.pcie.number_units >0 && XML->sys.pcie.num_channels>0)
|
|
{
|
|
cout <<indent_str<<"Total PCIes: "<<pcie->pciep.num_units << " PCIe Controllers "<<endl;
|
|
displayDeviceType(XML->sys.device_type, indent);
|
|
cout << indent_str_next << "Area = " << pcies.area.get_area()*1e-6<< " mm^2" << endl;
|
|
cout << indent_str_next << "Peak Dynamic = " << pcies.power.readOp.dynamic << " W" << endl;
|
|
cout << indent_str_next << "Subthreshold Leakage = "
|
|
<< (long_channel? pcies.power.readOp.longer_channel_leakage:pcies.power.readOp.leakage) <<" W" << endl;
|
|
cout << indent_str_next << "Gate Leakage = " << pcies.power.readOp.gate_leakage << " W" << endl;
|
|
cout << indent_str_next << "Runtime Dynamic = " << pcies.rt_power.readOp.dynamic << " W" << endl;
|
|
cout <<endl;
|
|
}
|
|
cout <<"*****************************************************************************************"<<endl;
|
|
if (plevel >1)
|
|
{
|
|
for (i = 0;i < numCore; i++)
|
|
{
|
|
cores[i]->displayEnergy(indent+4,plevel,is_tdp);
|
|
cout <<"*****************************************************************************************"<<endl;
|
|
}
|
|
if (!XML->sys.Private_L2)
|
|
{
|
|
for (i = 0;i < numL2; i++)
|
|
{
|
|
l2array[i]->displayEnergy(indent+4,is_tdp);
|
|
cout <<"*****************************************************************************************"<<endl;
|
|
}
|
|
}
|
|
for (i = 0;i < numL3; i++)
|
|
{
|
|
l3array[i]->displayEnergy(indent+4,is_tdp);
|
|
cout <<"*****************************************************************************************"<<endl;
|
|
}
|
|
for (i = 0;i < numL1Dir; i++)
|
|
{
|
|
l1dirarray[i]->displayEnergy(indent+4,is_tdp);
|
|
cout <<"*****************************************************************************************"<<endl;
|
|
}
|
|
for (i = 0;i < numL2Dir; i++)
|
|
{
|
|
l2dirarray[i]->displayEnergy(indent+4,is_tdp);
|
|
cout <<"*****************************************************************************************"<<endl;
|
|
}
|
|
if (XML->sys.mc.number_mcs >0 && XML->sys.mc.memory_channels_per_mc>0)
|
|
{
|
|
mc->displayEnergy(indent+4,is_tdp);
|
|
cout <<"*****************************************************************************************"<<endl;
|
|
}
|
|
if (XML->sys.flashc.number_mcs >0 && XML->sys.flashc.memory_channels_per_mc>0)
|
|
{
|
|
flashcontroller->displayEnergy(indent+4,is_tdp);
|
|
cout <<"*****************************************************************************************"<<endl;
|
|
}
|
|
if (XML->sys.niu.number_units >0 )
|
|
{
|
|
niu->displayEnergy(indent+4,is_tdp);
|
|
cout <<"*****************************************************************************************"<<endl;
|
|
}
|
|
if (XML->sys.pcie.number_units >0 && XML->sys.pcie.num_channels>0)
|
|
{
|
|
pcie->displayEnergy(indent+4,is_tdp);
|
|
cout <<"*****************************************************************************************"<<endl;
|
|
}
|
|
|
|
for (i = 0;i < numNOC; i++)
|
|
{
|
|
nocs[i]->displayEnergy(indent+4,plevel,is_tdp);
|
|
cout <<"*****************************************************************************************"<<endl;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
}
|
|
|
|
}
|
|
|
|
void Processor::set_proc_param()
|
|
{
|
|
bool debug = false;
|
|
|
|
procdynp.homoCore = bool(debug?1:XML->sys.homogeneous_cores);
|
|
procdynp.homoL2 = bool(debug?1:XML->sys.homogeneous_L2s);
|
|
procdynp.homoL3 = bool(debug?1:XML->sys.homogeneous_L3s);
|
|
procdynp.homoNOC = bool(debug?1:XML->sys.homogeneous_NoCs);
|
|
procdynp.homoL1Dir = bool(debug?1:XML->sys.homogeneous_L1Directories);
|
|
procdynp.homoL2Dir = bool(debug?1:XML->sys.homogeneous_L2Directories);
|
|
|
|
procdynp.numCore = XML->sys.number_of_cores;
|
|
procdynp.numL2 = XML->sys.number_of_L2s;
|
|
procdynp.numL3 = XML->sys.number_of_L3s;
|
|
procdynp.numNOC = XML->sys.number_of_NoCs;
|
|
procdynp.numL1Dir = XML->sys.number_of_L1Directories;
|
|
procdynp.numL2Dir = XML->sys.number_of_L2Directories;
|
|
procdynp.numMC = XML->sys.mc.number_mcs;
|
|
procdynp.numMCChannel = XML->sys.mc.memory_channels_per_mc;
|
|
|
|
// if (procdynp.numCore<1)
|
|
// {
|
|
// cout<<" The target processor should at least have one core on chip." <<endl;
|
|
// exit(0);
|
|
// }
|
|
|
|
// if (numNOCs<0 || numNOCs>2)
|
|
// {
|
|
// cout <<"number of NOCs must be 1 (only global NOCs) or 2 (both global and local NOCs)"<<endl;
|
|
// exit(0);
|
|
// }
|
|
|
|
/* Basic parameters*/
|
|
interface_ip.data_arr_ram_cell_tech_type = debug?0:XML->sys.device_type;
|
|
interface_ip.data_arr_peri_global_tech_type = debug?0:XML->sys.device_type;
|
|
interface_ip.tag_arr_ram_cell_tech_type = debug?0:XML->sys.device_type;
|
|
interface_ip.tag_arr_peri_global_tech_type = debug?0:XML->sys.device_type;
|
|
|
|
interface_ip.ic_proj_type = debug?0:XML->sys.interconnect_projection_type;
|
|
interface_ip.delay_wt = 100;//Fixed number, make sure timing can be satisfied.
|
|
interface_ip.area_wt = 0;//Fixed number, This is used to exhaustive search for individual components.
|
|
interface_ip.dynamic_power_wt = 100;//Fixed number, This is used to exhaustive search for individual components.
|
|
interface_ip.leakage_power_wt = 0;
|
|
interface_ip.cycle_time_wt = 0;
|
|
|
|
interface_ip.delay_dev = 10000;//Fixed number, make sure timing can be satisfied.
|
|
interface_ip.area_dev = 10000;//Fixed number, This is used to exhaustive search for individual components.
|
|
interface_ip.dynamic_power_dev = 10000;//Fixed number, This is used to exhaustive search for individual components.
|
|
interface_ip.leakage_power_dev = 10000;
|
|
interface_ip.cycle_time_dev = 10000;
|
|
|
|
interface_ip.ed = 2;
|
|
interface_ip.burst_len = 1;//parameters are fixed for processor section, since memory is processed separately
|
|
interface_ip.int_prefetch_w = 1;
|
|
interface_ip.page_sz_bits = 0;
|
|
interface_ip.temp = debug?360: XML->sys.temperature;
|
|
interface_ip.F_sz_nm = debug?90:XML->sys.core_tech_node;//XML->sys.core_tech_node;
|
|
interface_ip.F_sz_um = interface_ip.F_sz_nm / 1000;
|
|
|
|
//***********This section of code does not have real meaning, they are just to ensure all data will have initial value to prevent errors.
|
|
//They will be overridden during each components initialization
|
|
interface_ip.cache_sz =64;
|
|
interface_ip.line_sz = 1;
|
|
interface_ip.assoc = 1;
|
|
interface_ip.nbanks = 1;
|
|
interface_ip.out_w = interface_ip.line_sz*8;
|
|
interface_ip.specific_tag = 1;
|
|
interface_ip.tag_w = 64;
|
|
interface_ip.access_mode = 2;
|
|
|
|
interface_ip.obj_func_dyn_energy = 0;
|
|
interface_ip.obj_func_dyn_power = 0;
|
|
interface_ip.obj_func_leak_power = 0;
|
|
interface_ip.obj_func_cycle_t = 1;
|
|
|
|
interface_ip.is_main_mem = false;
|
|
interface_ip.rpters_in_htree = true ;
|
|
interface_ip.ver_htree_wires_over_array = 0;
|
|
interface_ip.broadcast_addr_din_over_ver_htrees = 0;
|
|
|
|
interface_ip.num_rw_ports = 1;
|
|
interface_ip.num_rd_ports = 0;
|
|
interface_ip.num_wr_ports = 0;
|
|
interface_ip.num_se_rd_ports = 0;
|
|
interface_ip.num_search_ports = 1;
|
|
interface_ip.nuca = 0;
|
|
interface_ip.nuca_bank_count = 0;
|
|
interface_ip.is_cache =true;
|
|
interface_ip.pure_ram =false;
|
|
interface_ip.pure_cam =false;
|
|
interface_ip.force_cache_config =false;
|
|
if (XML->sys.Embedded)
|
|
{
|
|
interface_ip.wt =Global_30;
|
|
interface_ip.wire_is_mat_type = 0;
|
|
interface_ip.wire_os_mat_type = 0;
|
|
}
|
|
else
|
|
{
|
|
interface_ip.wt =Global;
|
|
interface_ip.wire_is_mat_type = 2;
|
|
interface_ip.wire_os_mat_type = 2;
|
|
}
|
|
interface_ip.force_wiretype = false;
|
|
interface_ip.print_detail = 1;
|
|
interface_ip.add_ecc_b_ =true;
|
|
}
|
|
|
|
Processor::~Processor(){
|
|
while (!cores.empty())
|
|
{
|
|
delete cores.back();
|
|
cores.pop_back();
|
|
}
|
|
while (!l2array.empty())
|
|
{
|
|
delete l2array.back();
|
|
l2array.pop_back();
|
|
}
|
|
while (!l3array.empty())
|
|
{
|
|
delete l3array.back();
|
|
l3array.pop_back();
|
|
}
|
|
while (!nocs.empty())
|
|
{
|
|
delete nocs.back();
|
|
nocs.pop_back();
|
|
}
|
|
if (!mc)
|
|
{
|
|
delete mc;
|
|
}
|
|
if (!niu)
|
|
{
|
|
delete niu;
|
|
}
|
|
if (!pcie)
|
|
{
|
|
delete pcie;
|
|
}
|
|
if (!flashcontroller)
|
|
{
|
|
delete flashcontroller;
|
|
}
|
|
};
|