stratixv_get_parts.py

#! /usr/bin/env python3

import dataclasses
import enum
import re
from typing import List, Optional


@dataclasses.dataclass
class StratixVPart:
    name: str = None
    nr_alms: int = None
    nr_pins: int = None
    nr_dsp: int = None
    mem_bits: int = None
    nr_pcie: int = None
    nr_serdes: int = None


def parse_single_part(lines: List[str]) -> StratixVPart:
    """ first line must be "part ...", last line must be "end" """

    assert lines[0].find("part") == 0
    assert lines[-1].find("end") == 0

    part = StratixVPart()
    part.name = re.match(r"part\s+(\w+)", lines[0]).group(1)

    state_in_dev_resources = False

    for line in lines:
        if not state_in_dev_resources and line.find("DEV_RESOURCES") >= 0:
            state_in_dev_resources = True

        if state_in_dev_resources and line.find("}") >= 0:
            state_in_dev_resources = False

        if state_in_dev_resources:

            if m := re.match(r"\s*\"ALMs\"\s*=\s*(\d+)", line):
                part.nr_alms = int(m.group(1))
            elif m := re.match(r"\s*\"Pins\"\s*=\s*(\d+)", line):
                part.nr_pins = int(m.group(1))
            elif m := re.match(r"\s*\"DSP Blocks\"\s*=\s*(\d+)", line):
                part.nr_dsp = int(m.group(1))
            elif m := re.match(r"\s*\"Memory Bits\"\s*=\s*(\d+)", line):
                part.mem_bits = int(m.group(1))
            elif m := re.match(r"\s*\"PCIe Hard IP Blocks\"\s*=\s*(\d+)", line):
                part.nr_pcie = int(m.group(1))
            elif m := re.match(r"\s*\"GXB Channel PMA\"\s*=\s*(\d+)", line):
                part.nr_serdes = int(m.group(1))

    return part


def parse_all(filename) -> List[StratixVPart]:
    f = open(filename, "r")

    parts = []
    part_lines = []

    class State(enum.Enum):
        IDLE = enum.auto()
        IN_PART = enum.auto()
        END_PART = enum.auto()

    state = State.IDLE

    for line in f.readlines():
        # state transitions
        if state == State.IDLE:
            if line.find("part") == 0:
                state = State.IN_PART
        elif state == State.IN_PART:
            if line.find("end") == 0:
                state = State.END_PART
        elif state == State.END_PART:
            state = State.IDLE

        # capture
        if state == State.IN_PART or state == State.END_PART:
            part_lines.append(line)

        # process
        if state == State.END_PART:
            part = parse_single_part(part_lines)
            parts.append(part)
            part_lines = []

    return parts


def main():
    parts = parse_all("ddb_stratixv_parts.txt")

    # part_selection = lambda part: part.nr_alms == 172600 and part.nr_serdes == 36 and part.nr_dsp == 1590
    part_selection = (
        lambda part: part.nr_alms == 172600
        and part.nr_pcie == 2
    )

    parts_of_interest = [part for part in parts if part_selection(part)]

    for part in parts_of_interest:
        print(part)
    else:
        print("no parts found")


if __name__ == "__main__":
    main()