gem5/ext/mcpat/processor.cc
Anthony Gutierrez e553a7bfa7 ext: add McPAT source
this patch adds the source for mcpat, a power, area, and timing modeling
framework.
2014-04-01 12:44:30 -04:00

839 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;
}
};