hw_component.py

import math
import numpy as np
import util
from topology_hack import Topology

kilo = 1024.0
giga = 1024.0 * 1024.0 * 1024.0


class System:
    def __init__(self, exp_config):
        self.num_nodes_per_wafer = exp_config.system_hierarchy.num_nodes_per_wafer


class Base:
    def __init__(self, exp_config):
        self.exp_config = exp_config
        self._precision_cfg = exp_config.sw_config.precision
        self.precision = self._precision_cfg.activations
        self.proc_chip_area_budget = exp_config.area_breakdown.proc_chip_area_budget
        self.TDP = exp_config.power_breakdown.TDP
        self.throughput = -1
        node_width = math.sqrt(self.proc_chip_area_budget)
        self.core_perimeter = node_width * 4

    def calcThroughput(self):
        print("Each class should have its own calcThroughput")

    def getThroughput(self):
        assert self.throughput != -1
        return self.throughput

    def solve_poly(self, p0, p1, p2, p3):
        # solve p0.x^3 + p1.x^2 + p2.x + p3 = 0
        roots = np.roots([p0, p1, p2, p3])
        real_roots = roots.real[
            abs(roots.imag) < 1e-10
        ]  # where I chose 1-e10 as a threshold
        return real_roots[0]


class Memory(Base):
    def __init__(self, exp_config, level):
        super().__init__(exp_config)
        self.size = -1
        self.tile_dim = -1
        self.latency = -1
        self.core = Core(self.exp_config)
        self.level = level

    def getSize(self):
        assert self.size != -1
        return self.size

    def getTileDim(self):
        assert self.tile_dim != -1
        return self.tile_dim

    def getLatency(self):
        assert self.latency != -1
        return self.latency

    def getTileDims(self):
        return self.getPower2TileDims()
        # return self.getArbitraryTileDims(self):

    def getGEMMBasedTileDims(self, M, K, N):
        m_dims = [ M >> i for i in range(M.bit_length()) if (M >> i) >= 1 ]
        k_dims = [ K >> i for i in range(K.bit_length()) if (K >> i) >= 1 ]
        n_dims = [ N >> i for i in range(N.bit_length()) if (N >> i) >= 1 ]

        valid_tiles = []
        for m in m_dims[::-1]:
            for k in k_dims[::-1]:
                for n in n_dims[::-1]:
                    bytes_required = self.precision * (m * k + k * n + m * n)
                    if bytes_required <= self.size_per_bundle:
                        valid_tiles.append((m, k, n))
        final_tiles = set()
        for candidate in valid_tiles:
            is_dominated = False
            for tile in final_tiles:
                m, k, n = candidate
                if ((m, k) == tile[:2] and n < tile[2]
                    or (k, n) == tile[1:] and m < tile[0]
                    or (m, n) == (tile[0], tile[2]) and k < tile[1]):
                    is_dominated = True
                    break

            if not is_dominated:
                to_remove = {
                    tile for tile in final_tiles
                    if ((m, k) == tile[:2] and n > tile[2]
                        or (k, n) == tile[1:] and m > tile[0]
                        or (m, n) == (tile[0], tile[2]) and k > tile[1])
                }
                final_tiles.difference_update(to_remove)
                final_tiles.add(candidate)
        return final_tiles

    def getPower2TileDims(self):
        np.random.seed(1)
        tile_dim_candidates = set()
        num_candidates = 20
        M = self.size_per_bundle / self.precision
        max_power = int(math.floor(math.log2(M)))

        self.calcTileDim()
        square_tile = self.getTileDim()
        # print("square_tile = ", square_tile)
        tile_dim_candidates.add((square_tile, square_tile, square_tile))
        tile_dim_candidates.add((square_tile // 2, square_tile, square_tile * 2))
        # print("tile_dim_candidates = ", tile_dim_candidates)
        while len(tile_dim_candidates) < num_candidates:
            z = -1
            while z < 0:
                s = [pow(2, i) for i in np.random.randint(0, max_power, 2)]
                # store goes through cache at level 0 and 1 (register and shared memory)
                assert self.level >= 0 and self.level <= 3
                if self.level <= 1:
                    z = math.floor((M - s[0] * s[1]) / (s[0] + s[1]))
                else:
                    # store bypasses cache, directly goes to memory
                    z = math.floor((M - s[0] * s[1]) / s[1])

                if z <= 0:
                    continue

                z = int(math.pow(2, math.floor(math.log2(z))))
                tile_dim = (s[0], s[1], z)
                tile_dim_candidates.add(tile_dim)

        # print("tile_dim_candidates_2 = ", tile_dim_candidates, "s[0]=", s[0], "s[1]=", s[1], "z=", z)
        return list(tile_dim_candidates)

    def getArbitraryTileDims(self):
        np.random.seed(0)
        tile_dim_candidates = []
        self.calcTileDim()
        square_tile = self.getTileDim()
        mu, sigma = square_tile, square_tile
        M = self.size_per_bundle / self.precision
        tile_dim_candidates.append((square_tile, square_tile, square_tile))
        for i in range(0, 0):
            z = -1
            while z < 0:
                s = [int(abs(i)) for i in np.random.normal(mu, sigma, 2)]
                z = int(math.floor((M - s[0] * s[1]) / (s[0] + s[1])))
            tile_dim = (s[0], s[1], z)
            tile_dim_candidates.append(tile_dim)

        # print(tile_dim_candidates)
        return tile_dim_candidates

    def calcTileDim(self):
        self.tile_dim = 0

        if self.scope == "global":
            divisor = 1
        elif self.scope == "mcu-bundle":
            divisor = self.core.num_bundle
        elif self.scope == "mcu":
            divisor = self.core.num_mcu
        else:
            NotImplemented()

        self.size_per_bundle = 0 if (divisor == 0) else self.size / divisor

        # print("INSIDE calcTileDim\n")

        if self.size > 0:
            self.tile_dim = math.ceil(
                math.pow(
                    2,
                    math.floor(
                        math.log(
                            math.sqrt((self.size_per_bundle / self.precision) / 2), 2
                        )
                    ),
                )
            )
            # self.tile_dim = math.floor(math.sqrt((self.size_per_bundle / self.precision) / 3))
        # print("tile_dim =", self.tile_dim, "size_per_bundle = ", self.size_per_bundle)


class Core(Base):
    def __init__(self, exp_config):
        super().__init__(exp_config)
        self.tot_power = exp_config.power_breakdown.core  # * self.TDP
        self.tot_area = exp_config.area_breakdown.core  # * self.proc_chip_area_budget

        self.FMA_dims = exp_config.tech_config.core.FMA_dims
        self.dataflow = exp_config.tech_config.core.dataflow

        self.nominal_flop_rate_per_mcu = exp_config.tech_config.core.nominal_flop_rate_per_mcu # TODO: Define it as a function of precision
        self.nominal_energy_per_flop = exp_config.tech_config.core.nominal_energy_per_flop
        self.nominal_power_per_mcu = exp_config.tech_config.core.nominal_power_per_mcu
        self.util = exp_config.tech_config.core.util

        # self.operating_voltage            = exp_config.tech_config.core.operating_voltage
        self.nominal_voltage = exp_config.tech_config.core.nominal_voltage
        self.threshold_voltage = exp_config.tech_config.core.threshold_voltage
        self.margin_voltage = exp_config.tech_config.core.margin_voltage

        # Assumption: performance scales linearly with area
        self.operating_area_per_mcu = exp_config.tech_config.core.operating_area_per_mcu
        if exp_config.tech_config.core.nominal_area_per_mcu:
            self.nominal_area_per_mcu = exp_config.tech_config.core.nominal_area_per_mcu
            self.area_scaling = self.operating_area_per_mcu / self.nominal_area_per_mcu
        else:
            self.area_scaling = 1
            self.nominal_area_per_mcu = self.operating_area_per_mcu

        self.num_mcu_per_bundle = exp_config.tech_config.core.num_mcu_per_bundle
        if exp_config.tech_config.core.num_bundles:
            self.num_bundle = exp_config.tech_config.core.num_bundles
            self.num_mcu = self.num_bundle * self.num_mcu_per_bundle
        else:
            self.num_mcu = int(self.tot_area // self.operating_area_per_mcu)
            self.num_bundle = int(self.num_mcu // self.num_mcu_per_bundle)

        self.operating_flop_rate_per_mcu = self.nominal_flop_rate_per_mcu * self.area_scaling
        self.nominal_power = self.nominal_power_per_mcu * self.num_mcu * self.area_scaling
        
        if self.tot_power > 0 and self.nominal_power > 0:
            self.calcOperatingVoltage()
            if exp_config.tech_config.core.operating_frequency:
                self.operating_freq = exp_config.tech_config.core.operating_frequency
                self.operating_power_per_mcu = self.tot_power / self.num_mcu
            elif exp_config.tech_config.core.nominal_frequency:
                self.nominal_freq = exp_config.tech_config.core.nominal_frequency
                self.calcOperatingFrequency()
        else:
            self.operating_freq = 0

        self.calcThroughput()

    def calcOperatingVoltage(self):
        # minimum voltage that meets power constraints
        self.operating_voltage = self.solve_poly(
            p0=1,
            p1=-2 * self.threshold_voltage,
            p2=self.threshold_voltage**2,
            p3=-1
            * self.tot_power
            / self.nominal_power
            * self.nominal_voltage
            * (self.nominal_voltage - self.threshold_voltage) ** 2,
        )

        self.frequency_scaling_factor = 1
        if self.operating_voltage < (self.threshold_voltage + self.margin_voltage):
            self.scaled_voltage = self.threshold_voltage + self.margin_voltage
            self.frequency_scaling_factor = (
                self.operating_voltage / self.scaled_voltage
            ) ** 2
            self.operating_voltage = self.scaled_voltage

    def calcOperatingFrequency(self):
        # Calculate operating frequency at minimum voltage
        self.operating_freq = self.nominal_freq * (
            (
                (self.operating_voltage - self.threshold_voltage) ** 2
                / (self.operating_voltage)
            )
            / (
                (self.nominal_voltage - self.threshold_voltage) ** 2
                / self.nominal_voltage
            )
        )

        self.operating_freq = self.frequency_scaling_factor * self.operating_freq

        self.operating_power_per_mcu = (
            self.nominal_power_per_mcu
            * (self.operating_freq / self.nominal_freq)
            * (self.operating_voltage / self.nominal_voltage) ** 2
        )

    def calcThroughput(self):
        self.operating_throughput = self.operating_flop_rate_per_mcu * self.operating_freq * self.num_mcu
        self.throughput = self.operating_throughput * self.util

    def printStats(self, f):
        self.eff_power = self.num_mcu * self.operating_power_per_mcu
        self.eff_area = self.num_mcu * self.operating_area_per_mcu
        f.write("\n\n=============\n")
        f.write("Core\n")
        f.write("=============\n")
        f.write(
            "operating_voltage: {0:.2f}, operating_freq: {1:.2f} (Ghz)\n".format(
                self.operating_voltage, self.operating_freq / 1e9
            )
        )
        f.write(
            "voltage_lowerbound: {0:.2f}\n".format(
                self.threshold_voltage + self.margin_voltage
            )
        )
        f.write(
            "#mcu: {0:5d}, #bundles: {1:5d}\n".format(self.num_mcu, self.num_bundle)
        )
        f.write(
            "eff_area: {0:.2f} (mm2), tot_area: {1:.2f} (mm2), util: {2:.2f}%\n".format(
                self.eff_area, self.tot_area, self.eff_area / self.tot_area * 100
            )
        )
        f.write(
            "eff_power: {0:.2f} (watt), tot_power: {1:.2f} (watt), util: {2:.2f}%\n".format(
                self.eff_power, self.tot_power, self.eff_power / self.tot_power * 100
            )
        )


class MemoryHierarchy(Base):
    def __init__(self, exp_config):
        super().__init__(exp_config)
        self.num_levels = exp_config.memory_hierarchy.num_levels
        self.memLayer = [None] * self.num_levels

        for level in range(0, self.num_levels):
            mem_config = exp_config.memory_hierarchy.mem_hr[level]

            if mem_config.type == "DRAM":
                self.memLayer[level] = DRAM(exp_config, mem_config, level)
            elif mem_config.type == "SRAM-R":
                self.memLayer[level] = SRAM(
                    exp_config,
                    exp_config.power_breakdown.reg_mem / exp_config.power_breakdown.TDP,
                    exp_config.area_breakdown.reg_mem
                    / exp_config.area_breakdown.proc_chip_area_budget,
                    exp_config.tech_config.SRAMR,
                    mem_config,
                    level,
                )
            elif mem_config.type == "SRAM-L1":
                self.memLayer[level] = SRAM(
                    exp_config,
                    exp_config.power_breakdown.L1 / exp_config.power_breakdown.TDP,
                    exp_config.area_breakdown.L1
                    / exp_config.area_breakdown.proc_chip_area_budget,
                    exp_config.tech_config.SRAML1,
                    mem_config,
                    level,
                )
            elif mem_config.type == "SRAM-L2":
                self.memLayer[level] = SRAM(
                    exp_config,
                    exp_config.power_breakdown.L2 / exp_config.power_breakdown.TDP,
                    exp_config.area_breakdown.L2
                    / exp_config.area_breakdown.proc_chip_area_budget,
                    exp_config.tech_config.SRAML2,
                    mem_config,
                    level,
                )
            else:
                NotImplemented()


class DRAM(Memory):
    def __init__(self, exp_config, mem_config, level):
        super().__init__(exp_config, level)
        self.tot_power = exp_config.power_breakdown.DRAM  # * self.TDP
        self.tot_area = exp_config.area_breakdown.node_area_budget - self.proc_chip_area_budget
        self.tot_mem_ctrl_area = exp_config.area_breakdown.DRAM  # * self.proc_chip_area_budget
        self.mem_ctrl_area = exp_config.tech_config.DRAM.mem_ctrl_area
        self.dynamic_energy_per_bit = exp_config.tech_config.DRAM.dynamic_energy_per_bit
        self.static_power_per_byte = exp_config.tech_config.DRAM.static_power_per_bit * 8
        self.area_per_byte = exp_config.tech_config.DRAM.area_per_bit * 8
        self.stack_capacity = exp_config.tech_config.DRAM.stack_capacity
        self.area_per_stack = exp_config.tech_config.DRAM.area_per_stack
        self.latency = exp_config.tech_config.DRAM.latency
        self.scope = mem_config.scope
        self.util = exp_config.tech_config.DRAM.util
        
        if exp_config.tech_config.DRAM.nominal_frequency:
            self.nominal_freq = exp_config.tech_config.DRAM.nominal_frequency
        elif exp_config.tech_config.DRAM.operating_frequency:
            self.nominal_freq = exp_config.tech_config.DRAM.operating_frequency
        else:
            self.nominal_freq = 0.1

        self.nominal_voltage = exp_config.tech_config.DRAM.nominal_voltage
        self.threshold_voltage = exp_config.tech_config.DRAM.threshold_voltage
        self.margin_voltage = exp_config.tech_config.DRAM.margin_voltage
        self.max_voltage = exp_config.tech_config.DRAM.max_voltage

        if exp_config.tech_config.DRAM.num_stacks:
            self.num_stacks = exp_config.tech_config.DRAM.num_stacks
        else:
            self.num_stacks = int(
                min(
                    self.tot_area // self.area_per_stack,
                    self.tot_mem_ctrl_area // self.mem_ctrl_area,
                )
            )

        self.num_links_per_mm = exp_config.tech_config.DRAM.num_links_per_mm
        self.num_links_per_stack = exp_config.tech_config.DRAM.num_links_per_stack

        self.perimeter_bound = int(
            self.core_perimeter
            * exp_config.perimeter_breakdown.DRAM
            * self.num_links_per_mm
        )
        self.num_links = min(
            self.perimeter_bound, self.num_links_per_stack * self.num_stacks
        )

        self.size = exp_config.tech_config.DRAM.size
        self.dynamic_throughput = exp_config.tech_config.DRAM.bandwidth

        self.calcSize()
        self.calcActiveEnergy()

        self.nominal_power = self.dynamic_energy_per_bit * self.num_links * self.nominal_freq

        if self.dynamic_power > 0 and self.nominal_power > 0:
            self.calcOperatingVoltage()
            if exp_config.tech_config.DRAM.operating_frequency:
                self.operating_freq = exp_config.tech_config.DRAM.operating_frequency
            else:
                self.calcOperatingFrequency()
        else:
            self.operating_freq = 0

        # if self.dynamic_power > 0 and self.nominal_power > 0:
        #     self.calcOperatingVoltageFrequency()
        # else:
        #     self.operating_freq = 0

        self.calcThroughput()

        if self.dynamic_throughput <= 0:
            assert self.dynamic_throughput == 0
            self.num_stacks = 0

        self.calcSize()
        self.calcTileDim()

    def calcOperatingVoltage(self):
        self.operating_voltage = self.solve_poly(
            p0=1,
            p1=-2 * self.threshold_voltage,
            p2=self.threshold_voltage**2,
            p3=-1
            * self.dynamic_power
            / self.nominal_power
            * self.nominal_voltage
            * (self.nominal_voltage - self.threshold_voltage) ** 2,
        )

        self.frequency_scaling_factor = 1
        self.max_freq = None
        if self.operating_voltage < (self.threshold_voltage + self.margin_voltage):
            self.scaled_voltage = self.threshold_voltage + self.margin_voltage
            self.frequency_scaling_factor = (self.operating_voltage / self.scaled_voltage) ** 2
            self.operating_voltage = self.scaled_voltage
        elif self.operating_voltage > self.max_voltage:
            self.max_freq = self.operating_freq * (
                ((self.max_voltage - self.threshold_voltage) ** 2 / (self.max_voltage))
                / (
                    (self.operating_voltage - self.threshold_voltage) ** 2
                    / self.operating_voltage
                )
            )
            self.operating_voltage = self.max_voltage

    def calcOperatingFrequency(self):
        # operating frequency at minimum voltage
        self.operating_freq = self.nominal_freq * (
            (
                (self.operating_voltage - self.threshold_voltage) ** 2
                / (self.operating_voltage)
            )
            / (
                (self.nominal_voltage - self.threshold_voltage) ** 2
                / self.nominal_voltage
            )
        )
        self.operating_freq = self.frequency_scaling_factor * self.operating_freq
        if self.max_freq:
            self.operating_freq = self.max_freq

    def calcActiveEnergy(self):
        self.dynamic_power = (
            0
            if (self.tot_power < self.static_power_per_byte * self.size)
            else (self.tot_power - self.static_power_per_byte * self.size)
        )

    def calcThroughput(self):
        if not self.dynamic_throughput:
            self.dynamic_throughput = (
                0 if (self.size == 0) else self.num_links * self.operating_freq / 8
            )
        self.stack_bw = (
            0 if self.num_stacks == 0 else self.dynamic_throughput / self.num_stacks
        )
        self.throughput = self.dynamic_throughput * self.util

    def calcSize(self):
        # self.nominal_throughput         = self.tot_power / self.dynamic_energy_per_byte
        # self.size                       = min((self.nominal_throughput / self.stack_bw) * self.stack_capacity,
        #                                         self.cell_area / self.area_per_byte)
        if self.size:
            self.num_stacks = self.size // self.stack_capacity
            self.num_links = self.num_links_per_stack * self.num_stacks
        else:
            self.size = self.num_stacks * self.stack_capacity

    def printStats(self, f):
        self.operating_dynamic_energy_per_bit = (
            self.dynamic_energy_per_bit
            * (self.operating_voltage / self.nominal_voltage) ** 2
        )
        self.dynamic_power = (
            self.num_links * self.operating_dynamic_energy_per_bit * self.operating_freq
        )
        self.static_power = self.static_power_per_byte * self.size
        self.eff_power = self.dynamic_power + self.static_power
        self.eff_ctrl_area = self.num_stacks * self.mem_ctrl_area  # _per_stack
        self.eff_stack_area = self.num_stacks * self.area_per_stack
        f.write("\n\n=============\n")
        f.write("DRAM\n")
        f.write("=============\n")
        f.write(
            "operating_voltage: {0:6.2f}\t\t operating_freq: {1:9.2f} (Ghz)\n".format(
                self.operating_voltage, self.operating_freq / 1e9
            )
        )
        f.write(
            "voltage_lowerbound: {0:5.2f}\t\t voltage_upperbound: {1:5.2f}\n".format(
                self.threshold_voltage + self.margin_voltage, self.max_voltage
            )
        )
        f.write(
            "num_stacks: {0:10d}\t\t\t node_area_limit: {1:5d}\t\t\t chip_area_limit: {2:5d}\n".format(
                self.num_stacks,
                int(self.tot_area // self.area_per_stack),
                int(self.tot_mem_ctrl_area // self.mem_ctrl_area),
            )
        )
        f.write(
            "num_links: {0:14d}\t\t stack_limit: {1:13d}\t\t perimeter_limit: {2:8d}\n".format(
                self.num_links,
                self.perimeter_bound,
                self.num_links_per_stack * self.num_stacks,
            )
        )
        f.write(
            "stack_bandwidth: {0:9.2f} (GB/s)\t stack_capacity: {1:9.2f} (GB)\n".format(
                self.stack_bw / giga, self.stack_capacity / giga
            )
        )
        f.write(
            "eff_ctrl_area: {0:11.2f} (mm2)\t tot_ctrl_area: {1:11.2f} (mm2)\t\t\t\t\t\t\t\t\t\t util: {2:.2f}%\n".format(
                self.eff_ctrl_area,
                self.tot_mem_ctrl_area,
                self.eff_ctrl_area / self.tot_mem_ctrl_area * 100,
            )
        )
        f.write(
            "eff_stack_area: {0:11.2f} (mm2)\t tot_stack_area: {1:11.2f} (mm2)\t\t\t\t\t\t\t\t\t\t util: {2:.2f}%\n".format(
                self.eff_stack_area,
                self.tot_area,
                self.eff_stack_area / self.tot_area * 100,
            )
        )
        f.write(
            "dynamic_power: {0:11.2f}\t\t static_power: {1:11.2f}\t\t eff_power: {2:15.2f} (watt)\t tot_power: {3:.2f} (watt)\t\t util: {4:.2f}%\n".format(
                self.dynamic_power,
                self.static_power,
                self.eff_power,
                self.tot_power,
                self.eff_power / self.tot_power * 100,
            )
        )


class SRAM(Memory):
    def __init__(
        self,
        exp_config,
        power_config,
        area_config,
        tech_config,
        mem_hierarchy_config,
        level,
    ):
        super().__init__(exp_config, level)
        self.tot_power = power_config * self.TDP
        self.tot_area = area_config * self.proc_chip_area_budget
        self.dynamic_energy_per_bit = tech_config.dynamic_energy_per_bit
        self.dynamic_energy_per_byte = self.dynamic_energy_per_bit * 8
        self.static_power_per_byte = tech_config.static_power_per_bit * 8
        self.area_per_byte = tech_config.area_per_bit * 8
        self.bank_capacity = tech_config.bank_capacity
        self.controller_area_per_link = tech_config.controller_area_per_link
        self.latency = tech_config.latency
        self.overhead = (
            tech_config.overhead
        )  # percetage of cells dedicated to cicuitry overhead for SRAM cells
        self.cell_percentage = 1 - self.overhead
        self.util = tech_config.util
        self.scope = mem_hierarchy_config.scope
        self.type = mem_hierarchy_config.type
        self.bank_area = self.bank_capacity * self.area_per_byte
        self.num_banks = int(
            math.floor(
                (self.cell_percentage * self.tot_area)
                // (
                    self.bank_area
                    + self.cell_percentage
                    * self.core.num_bundle
                    * self.controller_area_per_link
                )
            )
        )

        self.core = Core(self.exp_config)

        self.size = tech_config.size
        self.dynamic_throughput = tech_config.bandwidth

        self.calcSize()

        self.calcArea()
        self.calcActiveEnergy()
        self.calcThroughput()

        if self.dynamic_throughput <= 0:
            self.num_banks = 0

        self.calcSize()
        self.calcTileDim()

    def calcArea(self):
        self.overhead_area = (
            self.num_banks * self.core.num_bundle * self.controller_area_per_link
        )
        self.cell_area = (self.tot_area - self.overhead_area) * self.cell_percentage
        if self.overhead_area > self.tot_area:
            self.cell_area = 0

    def calcSize(self):
        if self.size:
            self.num_banks = self.size // self.bank_capacity
        else:
            self.size = self.num_banks * self.bank_capacity

    def calcActiveEnergy(self):
        self.static_power = self.static_power_per_byte * self.size
        self.dynamic_power = (
            0
            if (self.tot_power < self.static_power)
            else (self.tot_power - self.static_power)
        )

    def calcThroughput(self):
        if not self.dynamic_throughput:
            self.dynamic_throughput = (
                0
                if (self.num_banks == 0)
                else self.dynamic_power / self.dynamic_energy_per_byte
            )
        self.throughput = self.dynamic_throughput * self.util

        self.bank_bw = (
            0 if (self.num_banks == 0) else self.dynamic_throughput / self.num_banks
        )

    def printStats(self, f):
        self.dynamic_power = self.dynamic_throughput * self.dynamic_energy_per_byte
        self.eff_power = self.dynamic_power + self.static_power
        self.ctrl_area = (
            self.num_banks * self.core.num_bundle * self.controller_area_per_link
        )
        self.tot_bank_area = self.num_banks * self.bank_area / self.cell_percentage
        f.write("\n\n=============\n")
        f.write("{}\n".format(self.type))
        f.write("=============\n")
        f.write("num_banks: {0:17d}\n".format(self.num_banks))
        f.write(
            "bank_bandwidth: {0:13.2f} (GB/s)\t bank_capacity: {1:9.2f} (KB)\n".format(
                self.bank_bw / giga, self.bank_capacity / kilo
            )
        )
        f.write(
            "ctrl_area: {0:17.2f} (mm2)\t\t bank_area: {1:11.2f} (mm2)\t tot_area: {2:11.2f}(mm2)\t\t\t util: {3:.2f}%\n".format(
                self.ctrl_area,
                self.tot_bank_area,
                self.tot_area,
                (self.ctrl_area + self.tot_bank_area) / self.tot_area * 100,
            )
        )
        f.write(
            "dynamic_power: {0:13.2f} (watt)\t\t static_power: {1:11.2f} (watt)\t\t eff_power: {2:15.2f} (watt)\t tot_power: {3:.2f} (watt)\t\t util: {4:.2f}%\n".format(
                self.dynamic_power,
                self.static_power,
                self.eff_power,
                self.tot_power,
                self.eff_power / self.tot_power * 100,
            )
        )


class Network(Base):
    def __init__(self, exp_config):
        super().__init__(exp_config)
        self.intra_network = SubNetwork(
            exp_config,
            exp_config.tech_config.network.intra_node,
            exp_config.power_breakdown.network.intra_node,
            exp_config.area_breakdown.network.intra_node,
            "intra",
        )
        self.inter_network = SubNetwork(
            exp_config,
            exp_config.tech_config.network.inter_node,
            exp_config.power_breakdown.network.inter_node,
            exp_config.area_breakdown.network.inter_node,
            "inter",
        )

    def calcThroughput(self):
        inter_throughput = self.inter_network.calcThroughput()
        intra_throughput = self.intra_network.calcThroughput()

        return intra_throughput, inter_throughput

    def calcLatency(self):
        inter_latency = self.inter_network.latency
        intra_latency = self.intra_network.latency

        return intra_latency, inter_latency

    def printStats(self, f):
        self.inter_network.printStats(f, "inter")
        self.intra_network.printStats(f, "intra")


class SubNetwork(Base):
    def __init__(
        self, exp_config, net_config, power_breakdown, area_breakdown, netLevel
    ):
        super().__init__(exp_config)
        self.tot_power = power_breakdown  # * self.TDP
        self.tot_area = area_breakdown  # * self.proc_chip_area_budget
        # TODO: Rename core_perimeter to proc_chip_perimeter
        self.latency = net_config.latency
        self.nominal_freq = net_config.nominal_freq
        self.nominal_voltage = net_config.nominal_voltage
        self.nominal_energy_per_link = net_config.nominal_energy_per_link
        self.nominal_area_per_link = net_config.nominal_area_per_link
        self.threshold_voltage = net_config.threshold_voltage
        self.margin_voltage = net_config.margin_voltage
        self.num_links_per_mm = net_config.num_links_per_mm
        self.util = net_config.util
        self.config_operating_frequency = net_config.operating_frequency  # Master parameter
        self.config_bandwidth = net_config.bandwidth  # Master parameter - overrides all
        self.inter = True if netLevel == "inter" else False
        self.intra = True if netLevel == "intra" else False

        inter_frac = exp_config.perimeter_breakdown.inter_node
        intra_frac = exp_config.perimeter_breakdown.intra_node
        perimeter_fraction = inter_frac if self.inter else intra_frac
        self.tot_perimeter = perimeter_fraction * self.core_perimeter
        self.num_links = int(
            min(
                self.tot_area / self.nominal_area_per_link,
                perimeter_fraction * self.core_perimeter * self.num_links_per_mm,
            )
        )

        self.throughput = 0
        self.operating_freq = 0
        self.operating_voltage = 0

        # If bandwidth is explicitly set, use it directly (master parameter - overrides everything)
        if self.config_bandwidth:
            self.throughput = self.config_bandwidth * self.util
            # Set nominal values when bandwidth is overridden (actual freq/voltage don't matter)
            self.operating_freq = self.nominal_freq
            self.operating_voltage = self.nominal_voltage
        elif self.num_links > 0:
            self.calcOperatingVoltageFrequency()
            # Calculate throughput based on topology
            # 4 edges for intra (mesh), 1 edge for inter (mesh extension)
            degree = 4 if self.intra else 1
            self.throughput = (self.num_links * self.operating_freq * self.util) / (8 * degree)

        # self.energy_per_bit             = self.calcEnergyPerBit()

    def calcOperatingVoltageFrequency(self):
        # If operating_frequency is explicitly set, use it directly (master parameter)
        if self.config_operating_frequency:
            self.operating_freq = self.config_operating_frequency
            self.operating_voltage = self.nominal_voltage  # Assume nominal voltage when freq is overridden
            return

        # Otherwise, calculate from voltage scaling based on power constraints
        self.nominal_power = (
            self.nominal_energy_per_link * self.num_links * self.nominal_freq
        )
        # minimum voltage to meet the power constraint
        self.operating_voltage = self.solve_poly(
            p0=1,
            p1=-2 * self.threshold_voltage,
            p2=self.threshold_voltage**2,
            p3=-1
            * self.tot_power
            / self.nominal_power
            * self.nominal_voltage
            * (self.nominal_voltage - self.threshold_voltage) ** 2,
        )
        # operating frequency at minimum voltage
        self.operating_freq = self.nominal_freq * (
            (
                (self.operating_voltage - self.threshold_voltage) ** 2
                / (self.operating_voltage)
            )
            / (
                (self.nominal_voltage - self.threshold_voltage) ** 2
                / self.nominal_voltage
            )
        )
        self.frequency_scaling_factor = 1
        if self.operating_voltage < (self.threshold_voltage + self.margin_voltage):
            self.scaled_voltage = self.threshold_voltage + self.margin_voltage
            self.frequency_scaling_factor = (
                self.operating_voltage / self.scaled_voltage
            ) ** 2

        self.operating_freq = self.frequency_scaling_factor * self.operating_freq

    def calcEnergyPerBit(self):
        self.operating_energy_per_link = (
            self.nominal_energy_per_link
            * (self.operating_voltage / self.nominal_voltage) ** 2
        )
        energy_per_bit = self.operating_energy_per_link
        return energy_per_bit

    # Return P2P bw
    def calcThroughput(self):
        return self.throughput

    def printStats(self, f, name):
        self.calcEnergyPerBit()
        self.eff_power = (
            self.num_links * self.operating_freq * self.operating_energy_per_link
        )
        self.eff_area = self.num_links * self.nominal_area_per_link
        self.eff_perimeter = self.num_links / self.num_links_per_mm

        if self.eff_power > 0 and self.eff_area > 0:
            f.write("\n\n=============\n")
            f.write("Network: {}\n".format(name))
            f.write("=============\n")
            f.write(
                "operating_voltage: {0:.2f}, operating_freq: {1:.2f} (Ghz)\n".format(
                    self.operating_voltage, self.operating_freq / 1e9
                )
            )
            f.write(
                "voltage_lowerbound: {0:.2f}\n".format(
                    self.threshold_voltage + self.margin_voltage
                )
            )
            f.write("#links: {0:5d}\n".format(self.num_links))
            if self.tot_area != 0:
                f.write(
                    "eff_area: {0:.2f} (mm2), tot_area: {1:.2f} (mm2), util: {2:.2f}%\n".format(
                        self.eff_area,
                        self.tot_area,
                        self.eff_area / self.tot_area * 100,
                    )
                )
            if self.tot_power != 0:
                f.write(
                    "eff_power: {0:.2f} (watt), tot_power: {1:.2f} (watt), util: {2:.2f}%\n".format(
                        self.eff_power,
                        self.tot_power,
                        self.eff_power / self.tot_power * 100,
                    )
                )
            if self.tot_perimeter != 0:
                f.write(
                    "eff_perimeter: {0:.2f} (mm), tot_perimeter: {1:.2f} (mm), util: {2:.2f}%\n".format(
                        self.eff_perimeter,
                        self.tot_perimeter,
                        self.eff_perimeter / self.tot_perimeter * 100,
                    )
                )