/*****************************************************************************
* McPAT
* SOFTWARE LICENSE AGREEMENT
* Copyright 2012 Hewlett-Packard Development Company, L.P.
* Copyright (c) 2010-2013 Advanced Micro Devices, Inc.
* 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 <iostream>
#include <string>
#include "basic_circuit.h"
#include "common.h"
#include "const.h"
#include "io.h"
#include "noc.h"
#include "parameter.h"
OnChipNetwork::OnChipNetwork(XMLNode* _xml_data, int ithNoC_,
InputParameter* interface_ip_)
: McPATComponent(_xml_data), router(NULL), link_bus(NULL), ithNoC(ithNoC_),
interface_ip(*interface_ip_), link_bus_exist(false),
router_exist(false) {
name = "On-Chip Network";
set_param_stats();
local_result = init_interface(&interface_ip, name);
scktRatio = g_tp.sckt_co_eff;
// TODO: Routers and links should be children of the NOC component
if (noc_params.type) {
init_router();
} else {
init_link_bus();
}
}
void OnChipNetwork::init_router() {
router = new Router(noc_params.flit_size,
noc_params.virtual_channel_per_port *
noc_params.input_buffer_entries_per_vc,
noc_params.virtual_channel_per_port,
&(g_tp.peri_global),
noc_params.input_ports, noc_params.output_ports,
noc_params.M_traffic_pattern);
// TODO: Make a router class within McPAT that descends from McPATComponent
// children.push_back(router);
area.set_area(area.get_area() + router->area.get_area() *
noc_params.total_nodes);
double long_channel_device_reduction = longer_channel_device_reduction(Uncore_device);
router->power.readOp.longer_channel_leakage = router->power.readOp.leakage * long_channel_device_reduction;
router->buffer.power.readOp.longer_channel_leakage = router->buffer.power.readOp.leakage * long_channel_device_reduction;
router->crossbar.power.readOp.longer_channel_leakage = router->crossbar.power.readOp.leakage * long_channel_device_reduction;
router->arbiter.power.readOp.longer_channel_leakage = router->arbiter.power.readOp.leakage * long_channel_device_reduction;
router_exist = true;
}
void OnChipNetwork::init_link_bus() {
if (noc_params.type) {
link_name = "Links";
} else {
link_name = "Bus";
}
interface_ip.throughput = noc_params.link_throughput /
noc_params.clockRate;
interface_ip.latency = noc_params.link_latency / noc_params.clockRate;
link_len /= (noc_params.horizontal_nodes + noc_params.vertical_nodes) / 2;
if (noc_params.total_nodes > 1) {
//All links are shared by neighbors
link_len /= 2;
}
link_bus = new Interconnect(xml_data, "Link", Uncore_device,
noc_params.link_base_width,
noc_params.link_base_height,
noc_params.flit_size, link_len, &interface_ip,
noc_params.link_start_wiring_level,
noc_params.clockRate, true/*pipelinable*/,
noc_params.route_over_perc);
children.push_back(link_bus);
link_bus_exist = true;
}
// TODO: This should use the McPATComponent::computeEnergy function to
// recursively calculate energy of routers and links and then add
void OnChipNetwork::computeEnergy() {
double pppm_t[4] = {1, 1, 1, 1};
// Initialize stats for TDP
tdp_stats.reset();
tdp_stats.readAc.access = noc_stats.duty_cycle;
if (router_exist) {
// TODO: Define a regression to exercise routers
// TODO: Clean this up: it is too invasive and breaks abstraction
set_pppm(pppm_t, 1 * tdp_stats.readAc.access, 1, 1, 1);
router->power = router->power * pppm_t;
set_pppm(pppm_t, noc_params.total_nodes,
noc_params.total_nodes,
noc_params.total_nodes,
noc_params.total_nodes);
}
if (link_bus_exist) {
if (noc_params.type) {
link_bus->int_params.active_ports = noc_params.min_ports - 1;
} else {
link_bus->int_params.active_ports = noc_params.min_ports;
}
link_bus->int_stats.duty_cycle =
noc_params.M_traffic_pattern * noc_stats.duty_cycle;
// TODO: Decide how to roll multiple routers into a single top-level
// NOC module. I would prefer not to, but it might be a nice feature
set_pppm(pppm_t, noc_params.total_nodes,
noc_params.total_nodes,
noc_params.total_nodes,
noc_params.total_nodes);
}
// Initialize stats for runtime energy and power
rtp_stats.reset();
rtp_stats.readAc.access = noc_stats.total_access;
set_pppm(pppm_t, 1, 0 , 0, 0);
if (router_exist) {
// TODO: Move this to a McPATComponent parent class of Router
router->buffer.rt_power.readOp.dynamic =
(router->buffer.power.readOp.dynamic +
router->buffer.power.writeOp.dynamic) * rtp_stats.readAc.access;
router->crossbar.rt_power.readOp.dynamic =
router->crossbar.power.readOp.dynamic * rtp_stats.readAc.access;
router->arbiter.rt_power.readOp.dynamic =
router->arbiter.power.readOp.dynamic * rtp_stats.readAc.access;
router->rt_power = router->rt_power +
(router->buffer.rt_power + router->crossbar.rt_power +
router->arbiter.rt_power) * pppm_t +
router->power * pppm_lkg;//TDP power must be calculated first!
}
if (link_bus_exist) {
link_bus->int_stats.accesses = noc_stats.total_access;
}
// Recursively compute energy
McPATComponent::computeEnergy();
}
void OnChipNetwork::set_param_stats() {
// TODO: Remove this or move initialization elsewhere
memset(&noc_params, 0, sizeof(OnChipNetworkParameters));
int num_children = xml_data->nChildNode("param");
int i;
int mat_type;
for (i = 0; i < num_children; i++) {
XMLNode* paramNode = xml_data->getChildNodePtr("param", &i);
XMLCSTR node_name = paramNode->getAttribute("name");
XMLCSTR value = paramNode->getAttribute("value");
if (!node_name)
warnMissingParamName(paramNode->getAttribute("id"));
ASSIGN_INT_IF("type", noc_params.type);
ASSIGN_FP_IF("clockrate", noc_params.clockRate);
ASSIGN_INT_IF("flit_bits", noc_params.flit_size);
ASSIGN_FP_IF("link_len", link_len);
ASSIGN_FP_IF("link_throughput", noc_params.link_throughput);
ASSIGN_FP_IF("link_latency", noc_params.link_latency);
ASSIGN_INT_IF("input_ports", noc_params.input_ports);
ASSIGN_INT_IF("output_ports", noc_params.output_ports);
ASSIGN_INT_IF("global_linked_ports", noc_params.global_linked_ports);
ASSIGN_INT_IF("horizontal_nodes", noc_params.horizontal_nodes);
ASSIGN_INT_IF("vertical_nodes", noc_params.vertical_nodes);
ASSIGN_FP_IF("chip_coverage", noc_params.chip_coverage);
ASSIGN_FP_IF("link_routing_over_percentage",
noc_params.route_over_perc);
ASSIGN_INT_IF("has_global_link", noc_params.has_global_link);
ASSIGN_INT_IF("virtual_channel_per_port",
noc_params.virtual_channel_per_port);
ASSIGN_INT_IF("input_buffer_entries_per_vc",
noc_params.input_buffer_entries_per_vc);
ASSIGN_FP_IF("M_traffic_pattern", noc_params.M_traffic_pattern);
ASSIGN_FP_IF("link_base_width", noc_params.link_base_width);
ASSIGN_FP_IF("link_base_height", noc_params.link_base_height);
ASSIGN_INT_IF("link_start_wiring_level",
noc_params.link_start_wiring_level);
ASSIGN_INT_IF("wire_mat_type", mat_type);
ASSIGN_ENUM_IF("wire_type", interface_ip.wt, Wire_type);
else {
warnUnrecognizedParam(node_name);
}
}
// Change from MHz to Hz
noc_params.clockRate *= 1e6;
interface_ip.wire_is_mat_type = mat_type;
interface_ip.wire_os_mat_type = mat_type;
num_children = xml_data->nChildNode("stat");
for (i = 0; i < num_children; i++) {
XMLNode* statNode = xml_data->getChildNodePtr("stat", &i);
XMLCSTR node_name = statNode->getAttribute("name");
XMLCSTR value = statNode->getAttribute("value");
if (!node_name)
warnMissingStatName(statNode->getAttribute("id"));
ASSIGN_FP_IF("duty_cycle", noc_stats.duty_cycle);
ASSIGN_FP_IF("total_accesses", noc_stats.total_access);
else {
warnUnrecognizedStat(node_name);
}
}
clockRate = noc_params.clockRate;
noc_params.min_ports =
min(noc_params.input_ports, noc_params.output_ports);
if (noc_params.type) {
noc_params.global_linked_ports = (noc_params.input_ports - 1) +
(noc_params.output_ports - 1);
}
noc_params.total_nodes =
noc_params.horizontal_nodes * noc_params.vertical_nodes;
assert(noc_params.chip_coverage <= 1);
assert(noc_params.route_over_perc <= 1);
assert(link_len > 0);
}
OnChipNetwork ::~OnChipNetwork() {
if (router) {
delete router;
router = 0;
}
if (link_bus) {
delete link_bus;
link_bus = 0;
}
}