quicklogic/common/utils/gather_lib_data.py

#!/usr/bin/env python3
"""
Gather data from given lib file. This data is then used to populate JSON file
that has delay numbers for some parameters related to F2A and A2F pins.
"""
import argparse
from collections import defaultdict

# =============================================================================


def main():
    """
    Gather lib information from the given library file
    """
    parser = argparse.ArgumentParser(
        description='Gather lib information from the given library file.'
    )
    parser.add_argument(
        "--lib",
        "-l",
        "-L",
        type=str,
        required=True,
        help='Specify input lib file'
    )

    args = parser.parse_args()

    lib_fp = open(args.lib, newline='')

    for line in lib_fp:
        if line.find("bus ( gfpga_pad_IO_A2F") != -1:
            a2f_process_lib_data(lib_fp)
        elif line.find("bus ( gfpga_pad_IO_F2A") != -1:
            f2a_process_lib_data(lib_fp)


# =============================================================================


def f2a_process_lib_data(lib_fp):
    """
    Process F2A pin lib_data
    """
    f2a_data_max = defaultdict(set)
    f2a_data_min = defaultdict(set)
    max_transition = set()
    capacitance = set()
    for f2a_line in lib_fp:

        pin_pos = f2a_line.find("pin(\"")
        if pin_pos != -1:

            for pin_line in lib_fp:
                if pin_line.find("rising_edge") != -1:
                    f2a_data_max, f2a_data_min = f2a_timing_type(
                        lib_fp, pin_line, "rising_edge", f2a_data_max,
                        f2a_data_min
                    )
                elif pin_line.find("max_transition") != -1:
                    val_list = pin_line.split(' : ')
                    max_transition.add(
                        float(val_list[1].split(' ;')[0].strip())
                    )
                elif pin_line.find("capacitance") != -1:
                    val_list = pin_line.split(' : ')
                    capacitance.add(float(val_list[1].split(' ;')[0].strip()))
                elif pin_line.find("end of bus") != -1:
                    break

            print(
                'F2A {} least_val: {}, highest_val: {}'.format(
                    "max_transition", next(iter(sorted(max_transition))),
                    sorted(max_transition).pop()
                )
            )
            print(
                'F2A {} least_val: {}, highest_val: {}'.format(
                    "capacitance", next(iter(sorted(capacitance))),
                    sorted(capacitance).pop()
                )
            )
            print(
                'F2A {} least_val: {}, highest_val: {}'.format(
                    "rising_edge_cell_rise_val",
                    next(iter(sorted(f2a_data_min['rising_edge_cell_rise']))),
                    sorted(f2a_data_max['rising_edge_cell_rise']).pop()
                )
            )
            print(
                'F2A {} least_val: {}, highest_val: {}'.format(
                    "rising_edge_cell_fall_val",
                    next(iter(sorted(f2a_data_min['rising_edge_cell_fall']))),
                    sorted(f2a_data_max['rising_edge_cell_fall']).pop()
                )
            )
            print(
                'F2A {} least_val: {}, highest_val: {}'.format(
                    "rising_edge_rise_tran_val",
                    next(iter(sorted(f2a_data_min['rising_edge_rise_tran']))),
                    sorted(f2a_data_max['rising_edge_rise_tran']).pop()
                )
            )
            print(
                'F2A {} least_val: {}, highest_val: {}'.format(
                    "rising_edge_fall_tran_val",
                    next(iter(sorted(f2a_data_min['rising_edge_fall_tran']))),
                    sorted(f2a_data_max['rising_edge_fall_tran']).pop()
                )
            )
            break


# =============================================================================


def a2f_process_lib_data(lib_fp):
    """
    Process A2F pin lib_data
    """
    a2f_data_max = defaultdict(set)
    a2f_data_min = defaultdict(set)

    max_transition = set()
    capacitance = set()
    for a2f_line in lib_fp:

        pin_pos = a2f_line.find("pin(\"")
        if pin_pos != -1:

            for pin_line in lib_fp:
                if pin_line.find("setup_rising") != -1:
                    a2f_data_max, a2f_data_min = a2f_timing_type(
                        lib_fp, pin_line, "setup_rising", a2f_data_max,
                        a2f_data_min
                    )
                elif pin_line.find("hold_rising") != -1:
                    a2f_data_max, a2f_data_min = a2f_timing_type(
                        lib_fp, pin_line, "hold_rising", a2f_data_max,
                        a2f_data_min
                    )
                elif pin_line.find("max_transition") != -1:
                    val_list = pin_line.split(' : ')
                    max_transition.add(
                        float(val_list[1].split(' ;')[0].strip())
                    )
                elif pin_line.find("capacitance") != -1:
                    val_list = pin_line.split(' : ')
                    capacitance.add(float(val_list[1].split(' ;')[0].strip()))
                elif pin_line.find("end of bus gfpga_pad_IO_A2F") != -1:
                    break

            print(
                'A2F {} least_val: {}, highest_val: {}'.format(
                    "max_transition", next(iter(sorted(max_transition))),
                    sorted(max_transition).pop()
                )
            )
            print(
                'A2F {} least_val: {}, highest_val: {}'.format(
                    "capacitance", next(iter(sorted(capacitance))),
                    sorted(capacitance).pop()
                )
            )
            print(
                'A2F {} least_val: {}, highest_val: {}'.format(
                    "setup_rising_rise_constraint_val",
                    next(
                        iter(
                            sorted(
                                a2f_data_min['setup_rising_rise_constraint']
                            )
                        )
                    ),
                    sorted(a2f_data_max['setup_rising_rise_constraint']).pop()
                )
            )
            print(
                'A2F {} least_val: {}, highest_val: {}'.format(
                    "setup_rising_fall_constraint_val",
                    next(
                        iter(
                            sorted(
                                a2f_data_min['setup_rising_fall_constraint']
                            )
                        )
                    ),
                    sorted(a2f_data_max['setup_rising_fall_constraint']).pop()
                )
            )
            print(
                'A2F {} least_val: {}, highest_val: {}'.format(
                    "hold_rising_rise_constraint_val",
                    next(
                        iter(
                            sorted(
                                a2f_data_min['hold_rising_rise_constraint']
                            )
                        )
                    ),
                    sorted(a2f_data_max['hold_rising_rise_constraint']).pop()
                )
            )
            print(
                'A2F {} least_val: {}, highest_val: {}'.format(
                    "hold_rising_fall_constraint_val",
                    next(
                        iter(
                            sorted(
                                a2f_data_min['hold_rising_fall_constraint']
                            )
                        )
                    ),
                    sorted(a2f_data_max['hold_rising_fall_constraint']).pop()
                )
            )
            break


# =============================================================================


def a2f_timing_type(lib_fp, pin_line, type_str, a2f_data_max, a2f_data_min):
    """
    Collect A2F pin data
    """
    type_pos = pin_line.find(type_str)
    if type_pos != -1:
        for type_line in lib_fp:
            rise_pos = type_line.find("rise_constraint")
            if rise_pos != -1:
                for constraint_line in lib_fp:
                    if constraint_line.find("}") != -1:
                        break

                    if constraint_line.find('values') != -1:
                        val_set = set()
                        val_set = populate_set(constraint_line, val_set)

                        for val_line in lib_fp:
                            if val_line.find(");") != -1:
                                val_set = populate_set(val_line, val_set)
                                break

                            val_set = populate_set(val_line, val_set)

                        if type_str == "setup_rising":
                            a2f_data_max['setup_rising_rise_constraint'].add(
                                sorted(val_set).pop()
                            )
                            a2f_data_min['setup_rising_rise_constraint'].add(
                                next(iter(sorted(val_set)))
                            )
                        else:
                            a2f_data_max['hold_rising_rise_constraint'].add(
                                sorted(val_set).pop()
                            )
                            a2f_data_min['hold_rising_rise_constraint'].add(
                                next(iter(sorted(val_set)))
                            )
                        break
                break

        for type_line in lib_fp:
            fall_pos = type_line.find("fall_constraint")
            if fall_pos != -1:
                for constraint_line in lib_fp:
                    if constraint_line.find("}") != -1:
                        break

                    if constraint_line.find('values') != -1:
                        val_set = set()
                        val_set = populate_set(constraint_line, val_set)

                        for val_line in lib_fp:
                            if val_line.find(");") != -1:
                                val_set = populate_set(val_line, val_set)
                                break

                            val_set = populate_set(val_line, val_set)

                        if type_str == "setup_rising":
                            a2f_data_max['setup_rising_fall_constraint'].add(
                                sorted(val_set).pop()
                            )
                            a2f_data_min['setup_rising_fall_constraint'].add(
                                next(iter(sorted(val_set)))
                            )
                        else:
                            a2f_data_max['hold_rising_fall_constraint'].add(
                                sorted(val_set).pop()
                            )
                            a2f_data_min['hold_rising_fall_constraint'].add(
                                next(iter(sorted(val_set)))
                            )
                        break
                break

    return a2f_data_max, a2f_data_min


# =============================================================================


def f2a_timing_type(lib_fp, pin_line, type_str, f2a_data_max, f2a_data_min):
    """
    Collect F2A pin data
    """
    type_pos = pin_line.find(type_str)
    if type_pos != -1:
        for type_line in lib_fp:
            rise_pos = type_line.find("cell_rise")
            if rise_pos != -1:
                for constraint_line in lib_fp:
                    if constraint_line.find("}") != -1:
                        break

                    if constraint_line.find('values') != -1:
                        val_set = set()
                        val_set = populate_set(constraint_line, val_set)

                        for val_line in lib_fp:
                            if val_line.find(");") != -1:
                                val_set = populate_set(val_line, val_set)
                                break

                            val_set = populate_set(val_line, val_set)

                        f2a_data_max['rising_edge_cell_rise'].add(
                            sorted(val_set).pop()
                        )
                        f2a_data_min['rising_edge_cell_rise'].add(
                            next(iter(sorted(val_set)))
                        )

                        break
                break

        for type_line in lib_fp:
            fall_pos = type_line.find("rise_transition")
            if fall_pos != -1:
                for constraint_line in lib_fp:
                    if constraint_line.find("}") != -1:
                        break

                    if constraint_line.find('values') != -1:
                        val_set = set()
                        val_set = populate_set(constraint_line, val_set)

                        for val_line in lib_fp:
                            if val_line.find(");") != -1:
                                val_set = populate_set(val_line, val_set)
                                break

                            val_set = populate_set(val_line, val_set)

                        f2a_data_max['rising_edge_rise_tran'].add(
                            sorted(val_set).pop()
                        )
                        f2a_data_min['rising_edge_rise_tran'].add(
                            next(iter(sorted(val_set)))
                        )
                        break
                break

        for type_line in lib_fp:
            fall_pos = type_line.find("cell_fall")
            if fall_pos != -1:
                for constraint_line in lib_fp:
                    if constraint_line.find("}") != -1:
                        break

                    if constraint_line.find('values') != -1:
                        val_set = set()
                        val_set = populate_set(constraint_line, val_set)

                        for val_line in lib_fp:
                            if val_line.find(");") != -1:
                                val_set = populate_set(val_line, val_set)
                                break

                            val_set = populate_set(val_line, val_set)

                        f2a_data_max['rising_edge_cell_fall'].add(
                            sorted(val_set).pop()
                        )
                        f2a_data_min['rising_edge_cell_fall'].add(
                            next(iter(sorted(val_set)))
                        )
                        break
                break

        for type_line in lib_fp:
            fall_pos = type_line.find("fall_transition")
            if fall_pos != -1:
                for constraint_line in lib_fp:
                    if constraint_line.find("}") != -1:
                        break

                    if constraint_line.find('values') != -1:
                        val_set = set()
                        val_set = populate_set(constraint_line, val_set)

                        for val_line in lib_fp:
                            if val_line.find(");") != -1:
                                val_set = populate_set(val_line, val_set)
                                break

                            val_set = populate_set(val_line, val_set)

                        f2a_data_max['rising_edge_fall_tran'].add(
                            sorted(val_set).pop()
                        )
                        f2a_data_min['rising_edge_fall_tran'].add(
                            next(iter(sorted(val_set)))
                        )
                        break
                break

    return f2a_data_max, f2a_data_min


# =============================================================================


def populate_set(line, val_set):
    """
    Collects values and put it in a set
    """
    pos = line.find("\"")
    pos1 = line.rfind("\"")
    sub = line[pos + 1:pos1]
    val_list = sub.split(',')
    for val in val_list:
        val_set.add(float(val.strip()))

    return val_set


# =============================================================================

if __name__ == '__main__':
    main()