The-OpenROAD-Project_OpenROAD/src/rcx/rule_scripts/fasterCapParse.py

# SPDX-License-Identifier: BSD-3-Clause
# Copyright (c) 2024-2025, The OpenROAD Authors

import os
import re
import argparse
import math
import xlsxwriter
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np


def OpenFile(file_path, rw="r"):
    if rw == "r":
        if os.path.exists(file_path):
            # print(file_path)
            return open(file_path, rw)
        else:
            print(f"The file {file_path} does not exist.")
            exit()
    if rw == "w":
        return open(file_path, rw)


def getWSformat(sp):
    dist = "{:.4f}".format(sp)
    return dist


def getFF(cap):
    cc = "{:9.6f}".format(cap * 1e15)
    return cc


def getWS(word, SW, ii):
    # parsing W0.14_W0.14
    s1 = float(word.split("_")[ii].split(SW)[1])
    return s1


# g2_wire_M5_w0  -7.3632e-17 2.82679e-16 -1.01845e-16 -5.93445e-17 -5.83917e-17 -5.96175e-17 -1.01798e-16
# g3_wire_M4_w1  -1.41823e-16 -2.30241e-17 5.5345e-16 -2.76143e-16 -3.19856e-18 1.15872e-18 -2.70547e-20


def parseMatrixRow(row, met, matrixRowIndex, wireCnt, diagWireCnt, dbg=0):
    # process one row of cap matrix at a time
    # returns wire index last number of the first column
    # return diagonal cap value for the wire index
    # return total coupling left and right of diagonal
    # return 2 caps left and right after immediate left and right
    # return diag cap as the before last column

    capValues = row.split()
    ii = matrixRowIndex

    # g3_wire_M4_w1
    targetMetWord = "_M" + str(met) + "_"

    if dbg > 0:
        print("-------------------------------------------------")
        print(row)
    if dbg > 1:
        print("targetMetWord= ", targetMetWord)

    if targetMetWord not in capValues[0]:
        return []

    wireIndex = int(capValues[0].split("w")[2])
    if wireIndex == 0:
        return []

    preWireCnt = matrixRowIndex - wireIndex
    diagWireIndex = preWireCnt + wireCnt
    if dbg > 1:
        print("wire= ", wireIndex)
        print("preWireCnt= ", preWireCnt)
        print("diagWireIndex= ", diagWireIndex)

    # diagonal
    tot = float(capValues[ii])
    cc = 0.0
    if wireIndex > 1:
        cc += float(capValues[ii - 1])
    if wireIndex + 1 <= wireCnt:
        cc += float(capValues[ii + 1])

    cc2 = 0.0
    if wireIndex > 2:
        cc2 += float(capValues[ii - 2])
    if wireIndex + 2 <= wireCnt:
        cc2 += float(capValues[ii + 2])

    diagCC = []
    for i in range(1, diagWireCnt + 1):
        jj = i + diagWireIndex
        diagCC.append(-float(capValues[jj]))

    return [wireIndex, tot, -cc, -cc2, diagCC]


def getWireCnt(capMatrix, mets, dbg=0):
    # returns wireCnt of target met=met and cnt of diagonal wires
    # skipping the context conductors
    # traverses all the rows of the cap matrix looking for patterns like _M2_
    diag = mets[3]
    met = mets[0]
    metUnder = mets[1]
    metOver = mets[2]

    # _M3_
    targetMetWord = "_M" + str(met) + "_"
    targetDiagMetWord = ""
    if diag:
        targetDiagMetWord = "_M" + str(metOver) + "_"

    wireCnt = 0
    diagWireCnt = 0
    for i in range(len(capMatrix)):
        name = capMatrix[i].split()[0]
        if dbg > 0:
            print(name)

        if targetMetWord in name:
            wireCnt = wireCnt + 1
        if diag and targetDiagMetWord in name:
            diagWireCnt = diagWireCnt + 1
            continue
    if dbg > 0:
        print(targetMetWord, targetDiagMetWord, [wireCnt, diagWireCnt])

    return [wireCnt, diagWireCnt]


def getPatternName(word):
    # returns last 4 subwords of the Input Pattern Name
    n = len(word)
    name = ""
    for i in range(5, 1, -1):
        name += word[n - i]
        name += "/"
    return name


def getMets(word):
    # returns metal indices from the pattern
    diag = 0
    met = 0
    metOver = 0
    metUnder = 0

    over = word.split("o")
    # print(over)
    if len(over) > 1:
        met = over[0].split("M")[1]
        mu = over[1].split("u")
        metUnder = mu[0].split("M")[1]
        if len(mu) > 1:
            metOver = mu[1].split("M")[1]
    else:
        under = word.split("u")
        # Diag M1duM3
        if "d" in under[0]:
            diag = 1
            met = under[0].split("d")[0].split("M")[1]
        else:
            met = under[0].split("M")[1]

        metOver = under[1].split("M")[1]

    return [met, metUnder, metOver, diag]


def readFasterCapOutPutLog(in_file, out_file, warnFP, emptyFP, statsFP, dbg):
    # reads the log file and parses the cap values for all conductors from the last valid iteration

    if dbg > 1:
        print(in_file)

    iterCnt = 0
    dimension = 0
    capMatrixCompleted = 0
    lastIterationIndex = 0
    iteration = []
    rows = []
    patternName = ""
    spacings = []
    widths = []
    mets = []
    patternType = ""

    mbytes = 0
    secs = 0

    line_cnt = 0
    f = OpenFile(in_file)
    for line in f:
        line_cnt = line_cnt + 1
        # parsing OverUnder5/M4oM3uM5/W0.14_W0.14/S0.14_S0.14/wires.lst
        if "Input file:" in line:
            file_line = line.split()
            full_pattern_file = file_line[2]
            word = file_line[2].split("/")
            n = len(word)
            if dbg > 0:
                print("Parsing Pattern: ", file_line[2])

            # print(word)
            patternName = getPatternName(word)
            spacings = [getWS(word[n - 2], "S", 0), getWS(word[n - 2], "S", 1)]
            widths = [getWS(word[n - 3], "W", 0), getWS(word[n - 3], "W", 1)]
            len_in_widths = int(word[n - 2].split("L")[1])
            mets = getMets(word[n - 4])
            patternType = word[n - 5]
            if dbg > 1:
                print(patternName, spacings, widths, mets, len_in_widths)
            continue

        if "Iteration number" in line:
            iterCnt = iterCnt + 1
            rows = []
            continue

        if "Dimension" in line:
            capMatrixCompleted = 0
            dimension = int(line.split()[1])
            continue

        # Total allocated memory: 1439880 kilobytes
        # Total time: 375.292633s (0 days, 0 hours, 6 mins, 15 s)
        if "Weighted Frobenius" in line:
            capMatrixCompleted = 1

        if "Total allocated memory" in line:
            mbytes = int(line.split()[3]) / 1000

        if "Total time" in line:
            secs = int(line.split()[2].split("s")[0].split(".")[0])

        if dimension > 0:
            capMatrixCompleted = 0
            rows.append(line)
            dimension = dimension - 1
            if dimension == 0:
                iteration.append(rows)
            continue

    warning = ""
    if line_cnt == 0:
        warning = "Warning: Empty File " + in_file
        emptyFP.write(in_file + "\n")
        return [0, line_cnt, warning]

    if len(iteration) == 0:
        # warning= 'Warning: No Cap Matrix in File ' + in_file
        warning = "Warning: No Cap Matrix in File " + full_pattern_file
        warnFP.write(warning + "\n")
        return [0, line_cnt, warning]

    if dbg > 2:
        print("last iteration:")
        print(iteration)

    warning1 = ""
    warning = ""
    if capMatrixCompleted > 0:
        lastIterationIndex = len(iteration) - 1
    else:
        if dbg > 0:
            print("Warning -- iterations= ", iterCnt, len(iteration))
            print(iteration[lastIterationIndex])

        # warning1='Incomplete Last Iteration ' + in_file
        warning1 = "Incomplete Last Iteration " + full_pattern_file
        warnFP.write(warning1 + "\n")

        warning = "Incomplete"
        lastIterationIndex = lastIterationIndex - 2
        if lastIterationIndex < 0 or len(iteration[lastIterationIndex]) < dimension:
            if dbg > 0:
                print(
                    "Warning: Before last iteration: ",
                    lastIterationIndex,
                    " Incomplete",
                )
            # warning1='Incomplete Before Last Iteration ' + in_file
            warning1 = "Incomplete Before Last Iteration " + full_pattern_file
            warnFP.write(warning1 + "\n")
            return [0, line_cnt, warning1]

    wireCnt = getWireCnt(iteration[0], mets, dbg)
    met = mets[0]

    # parse last complete capacitance matrix
    initCapRowIndex = 0
    ii = 0
    for row in iteration[lastIterationIndex]:
        ii = ii + 1
        # print(row)
        caps = parseMatrixRow(row, met, ii, wireCnt[0], wireCnt[1])
        if len(caps) == 0:
            continue
        if dbg > 0:
            print("Caps = ", caps)

        diagUnder = " Under "
        diagCaps = ""
        if mets[3] > 0:
            diagUnder = " DiagUnder "
            dcc = getFF(caps[4][0])
            diagCaps = (
                " DiagDist "
                + str(spacings[1])
                + " DiagWidth "
                + str(widths[1])
                + " DiagCC "
                + dcc
            )

        dist = getWSformat(spacings[0])
        width1 = getWSformat(widths[0])
        out_line = (
            "Metal "
            + str(mets[0])
            + " Over "
            + str(mets[1])
            + diagUnder
            + str(mets[2])
            + "  Dist "
            + dist
            + " Width "
            + width1
        )
        cc = getFF(caps[2])
        fr = getFF(caps[1] - caps[2])
        tc = getFF(caps[1])
        cc2 = getFF(caps[3])
        full_net_name = patternName + "wire_" + str(caps[0])

        # print(out_line, "CC", cc, "FR", fr , 'TC', tc, 'CC2', cc2, ' ', diagCaps, full_net_name, run_stats, warning)
        out_file.write(
            out_line
            + "  LEN "
            + str(len_in_widths)
            + "  CC "
            + cc
            + "  FR "
            + fr
            + "  TC "
            + tc
            + "  CC2 "
            + cc2
            + "  "
            + diagCaps
            + " "
            + full_net_name
            + " "
            + warning
        )
        out_file.write("\n")
    run_stats = (
        str(mbytes)
        + " MB "
        + str(secs)
        + " secs "
        + str(len(iteration))
        + " iterations"
    )
    statsFP.write(run_stats + " " + full_pattern_file + "\n")
    return [1, line_cnt, warning1]


def main():
    arg_parser = argparse.ArgumentParser(description="Parser of a FasterCap file")
    arg_parser.add_argument(
        "-in_list_file",
        type=str,
        default="",
        help="Input Filename with list of input file paths, default= ",
    )
    arg_parser.add_argument(
        "-in_file",
        type=str,
        default="wires.log",
        help="Input Filename, default=wires.log",
    )
    arg_parser.add_argument(
        "-out_file",
        type=str,
        default="pattern.caps",
        help="Output Filename, default=pattern.caps",
    )
    arg_parser.add_argument(
        "-wire", type=int, default=3, help="target wire number, default=3"
    )
    arg_parser.add_argument("-dbg", type=int, default=0, help="debug level, default=0")

    args = arg_parser.parse_args()

    outFP = OpenFile(args.out_file, "w")
    warnFP = OpenFile("warnings", "w")
    emptyFP = OpenFile("empty_files", "w")
    statsFP = OpenFile("run_stats", "w")
    file_cnt = 0
    incompleteCnt = 0
    empty_file_cnt = 0
    successCnt = 0

    dbg = args.dbg
    # Single file
    if len(args.in_list_file) == 0:
        readFasterCapOutPutLog(args.in_file, outFP, warnFP, emptyFP, statsFP, dbg)
        file_cnt += 1

        if retCode[0] == 1:
            successCnt += 1
            if "Incomplete" in retCode[2]:
                incompleteCnt += 1

        if retCode[0] == 0 and "Empty" in retCode[2]:
            empty_file_cnt += 1
        if retCode[0] == 0 and "Incomplete" in retCode[2]:
            incompleteCnt += 1
        exit()

    # list of files
    f = OpenFile(args.in_list_file)
    for file_line in f:
        retCode = readFasterCapOutPutLog(
            file_line.split()[0], outFP, warnFP, emptyFP, statsFP, dbg
        )
        file_cnt += 1

        if retCode[0] == 1:
            successCnt += 1
            if "Incomplete" in retCode[2]:
                incompleteCnt += 1

        if retCode[0] == 0 and "Empty" in retCode[2]:
            empty_file_cnt += 1
        if retCode[0] == 0 and "Incomplete" in retCode[2]:
            incompleteCnt += 1

    outFP.close()
    warnFP.close()
    emptyFP.close()
    statsFP.close()

    print(file_cnt, " Files Parsed")
    print(empty_file_cnt, " Files are Empty -- look at file:empty_files")
    print(incompleteCnt, " Files were incomplete -- look at file: warnings")


if __name__ == "__main__":
    main()

# Dimension 7 x 7
# g1_wire_M3_w0  6.9136e-16 -5.40629e-17 -1.68603e-16 -1.02291e-16 -9.64771e-17 -1.05795e-16 -1.6943e-16
# g2_wire_M5_w0  -7.3632e-17 2.82679e-16 -1.01845e-16 -5.93445e-17 -5.83917e-17 -5.96175e-17 -1.01798e-16
# g3_wire_M4_w1  -1.41823e-16 -2.30241e-17 5.5345e-16 -2.76143e-16 -3.19856e-18 1.15872e-18 -2.70547e-20
# g4_wire_M4_w2  -9.1805e-17 -1.36862e-17 -2.73845e-16 7.20986e-16 -2.7526e-16 -4.54052e-18 1.38176e-18
# g5_wire_M4_w3  -9.05258e-17 -1.32927e-17 -3.24811e-18 -2.75761e-16 7.2318e-16 -2.80613e-16 -3.72233e-18
# g6_wire_M4_w4  -9.13211e-17 -1.37111e-17 1.56117e-18 -4.38767e-18 -2.81118e-16 7.2663e-16 -2.7262e-16
# g7_wire_M4_w5  -1.4171e-16 -2.30185e-17 -3.0492e-20 8.26274e-19 -5.05703e-18 -2.73595e-16 5.535e-16

# Solve statistics:
# Total allocated memory: 4950569 kilobytes
# Total time: 2578.236084s (0 days, 0 hours, 42 mins, 58 s)