Implementando suporte ao fluxo do OpenRoad

Author: JN513

.gitignore

@@ -182,4 +182,5 @@ repositories.txt
 work-obj93.cf
 rvx.txt
 execution_trace.txt
-blink2/
+blink2/
+demo/

constraints/openroad.sdc

@@ -0,0 +1,7 @@
+set clk_name main_clk
+set clk_port clk
+set clk_ports_list [list $clk_port]
+set clk_period 10
+set input_delay 0.46
+set output_delay 0.11
+create_clock [get_ports $clk_port] -name $clk_name -period $clk_period

core/__init__.py

@@ -0,0 +1,76 @@
+import os
+import re
+import csv
+import json
+import subprocess
+from core.log import print_blue, print_red, print_yellow, print_green
+from typing import Any, Dict, List, Optional
+from jinja2 import Environment, FileSystemLoader, Template
+from abc import ABC, abstractmethod
+
+
+# Diretórios principais
+CORE_DIR: str = os.path.dirname(os.path.abspath(__file__))
+TEMPLATES_DIR: str = os.path.normpath(
+    os.path.join(CORE_DIR, '..', 'templates')
+)
+CONSTRAINTS_DIR: str = os.path.normpath(
+    os.path.join(CORE_DIR, '..', 'constraints')
+)
+
+
+def write_template_to_file(
+    env: Environment,
+    template_name: str,
+    context: Dict[str, Any],
+    filename: str,
+) -> str:
+    template: Template = env.get_template(template_name)
+    output: str = template.render(context)
+    with open(filename, 'w') as f:
+        f.write(output)
+    return filename
+
+
+def run_cmd(command: List[str], cwd: Optional[str] = None) -> None:
+    print_yellow(f"Running command: {' '.join(command)}")
+    subprocess.run(command, cwd=cwd, check=True)
+
+
+# -------------------------
+# Classe base para flows
+# -------------------------
+class ImplementationFlow(ABC):
+    def __init__(
+        self,
+        technology: str,
+        project_files: List[str],
+        constraint_file: str,
+        top_module: str,
+        env: Environment,
+    ) -> None:
+        self.technology: str = technology
+        self.project_files: List[str] = project_files
+        self.constraint_file: str = constraint_file
+        self.top_module: str = top_module
+        self.env: Environment = env
+
+    @abstractmethod
+    def generate_project(self) -> None:
+        pass
+
+    @abstractmethod
+    def run_tool(self) -> None:
+        pass
+
+    @abstractmethod
+    def clean(self) -> None:
+        pass
+
+    @abstractmethod
+    def report(self, report_path: str = 'reports') -> None:
+        pass
+
+    def run(self) -> None:
+        self.generate_project()
+        self.run_tool()

core/asic.py

@@ -1,10 +1,115 @@
 import os
-import subprocess
 from core.pdk_defines import DEFINES_BY_PDK, SUPPORTED_PDKS
+from core.log import print_blue, print_red, print_yellow, print_green
+from core import run_cmd, write_template_to_file
+from jinja2 import Environment, FileSystemLoader
+from core import ImplementationFlow
+from typing import Any, Dict
+from core import TEMPLATES_DIR, CONSTRAINTS_DIR
 
 
-def run_asic_flow(pdk_name: str, project_files: list[str]) -> None:
-    pdk_name = pdk_name.lower()
+TOOLCHAINS_INSTALL_PATH = {
+    'openroad': os.getenv('OPENROAD_INSTALL_PATH', '/eda/asic/OpenROAD-flow-scripts/'),
+}
+
+
+# -------------------------
+# OpenRoad Flow
+# -------------------------
+class OpenRoadFlow(ImplementationFlow):
+    def generate_project(self) -> None:
+        print_blue(f"Running OpenRoad flow for PDK: '{self.technology}'")
+
+        constraints: str = (
+            f'{CONSTRAINTS_DIR}/openroad.sdc'
+            if self.constraint_file == 'default'
+            else self.constraint_file
+        )
+
+        context: Dict[str, Any] = {
+            'design_name': self.top_module,
+            'verilog_files': self.project_files,
+            'sdc_file': constraints,
+            'design_nickname': self.top_module,
+            'platform': self.technology,
+            'core_utilization': 5,
+            'place_density': 0.10,
+            'synth_hdl_frontend': 'slang',
+            'synth_hierarchical': False,
+            'synth_min_keep_size': 0,
+            'additional_lefs': False,
+            'additional_lef_files': DEFINES_BY_PDK[self.technology].get(
+                'additional_lef_files', []
+            ),
+            'additional_libs': False,
+            'additional_lib_files': DEFINES_BY_PDK[self.technology].get(
+                'additional_lib_files', []
+            ),
+        }
+
+        write_template_to_file(self.env, 'openroad.j2', context, 'openroad.mk')
+        print_green(
+            f"OpenRoad project files generated for '{self.technology}' PDK."
+        )
+
+    def run_tool(self) -> None:
+        openroad_path = TOOLCHAINS_INSTALL_PATH.get('openroad', '')
+        if not openroad_path or not os.path.exists(openroad_path):
+            raise EnvironmentError(
+                'OpenRoad toolchain path is not set or does not exist.'
+            )
+
+        openroad_makefile_path = os.path.join(openroad_path, 'flow/Makefile')
+
+        run_cmd(
+            [
+                'make',
+                f'--file={openroad_makefile_path}',
+                'DESIGN_CONFIG=openroad.mk',
+            ]
+        )
+
+    def clean(self) -> None:
+        run_cmd(['rm', '-rf', 'build', 'reports', '*.jou', '*.log', '*.bit'])
 
+    def report(self, report_path: str = 'reports') -> None:
+        pass
+
+
+def run_asic_flow(
+    pdk_name: str,
+    project_files: list[str],
+    constraint_file: str = 'default',
+    top_module: str = 'processorci_top',
+    get_reports: bool = False,
+    clean: bool = False,
+    report_path: str = 'reports',
+) -> None:
+
+    pdk_name = pdk_name.lower()
     if pdk_name not in SUPPORTED_PDKS:
-        raise ValueError(f"PDK '{pdk_name}' is not supported.")
+        raise ValueError(
+            f"PDK '{pdk_name}' is not supported. Supported PDKs: {SUPPORTED_PDKS}"
+        )
+
+    env: Environment = Environment(
+        loader=FileSystemLoader(TEMPLATES_DIR),
+        trim_blocks=True,
+        lstrip_blocks=True,
+    )
+
+    flow = OpenRoadFlow(
+        technology=pdk_name,
+        project_files=project_files,
+        constraint_file=constraint_file,
+        top_module=top_module,
+        env=env,
+    )
+
+    flow.run()
+
+    if get_reports:
+        flow.report(report_path=report_path)
+
+    if clean:
+        flow.clean()