refactor: move sim related modules to top level package

Improve the clarity on what is simulation flow specific and what is
common. This makes way to fix the linting and formal flows, and creates
more clarity on what is required to be implemented to add a new flow.

Signed-off-by: James McCorrie <[email protected]>

Author: machshev

src/dvsim/flow/base.py

@@ -10,7 +10,6 @@
 import sys
 from abc import ABC, abstractmethod
 from collections.abc import Mapping, Sequence
-from datetime import datetime, timezone
 from pathlib import Path
 from typing import TYPE_CHECKING, ClassVar
 
@@ -20,15 +19,12 @@
 from dvsim.job.data import CompletedJobStatus
 from dvsim.launcher.factory import get_launcher_cls
 from dvsim.logging import log
-from dvsim.report.data import FlowResults, IPMeta, ResultsSummary
-from dvsim.report.generate import gen_block_report, gen_reports
 from dvsim.scheduler import Scheduler
 from dvsim.utils import (
     find_and_substitute_wildcards,
     rm_path,
     subst_wildcards,
 )
-from dvsim.utils.git import git_commit_hash
 
 if TYPE_CHECKING:
     from dvsim.job.deploy import Deploy
@@ -447,75 +443,14 @@ def deploy_objects(self) -> Sequence[CompletedJobStatus]:
             interactive=self.interactive,
         ).run()
 
+    @abstractmethod
     def gen_results(self, results: Sequence[CompletedJobStatus]) -> None:
         """Generate flow results.
 
         Args:
             results: completed job status objects.
 
         """
-        reports_dir = Path(self.scratch_base_path) / "reports"
-        commit = git_commit_hash(path=Path(self.proj_root))
-        url = f"https://github.com/lowrisc/opentitan/tree/{commit}"
-
-        all_flow_results: Mapping[str, FlowResults] = {}
-
-        for item in self.cfgs:
-            item_results = [
-                res
-                for res in results
-                if res.block.name == item.name and res.block.variant == item.variant
-            ]
-
-            flow_results: FlowResults = item._gen_json_results(
-                run_results=item_results,
-                commit=commit,
-                url=url,
-            )
-
-            # Convert to lowercase to match filename
-            block_result_index = (
-                f"{item.name}_{item.variant}" if item.variant else item.name
-            ).lower()
-
-            all_flow_results[block_result_index] = flow_results
-
-            # Generate the block's JSON/HTML reports to the report area.
-            gen_block_report(
-                results=flow_results,
-                path=reports_dir,
-            )
-
-            self.errors_seen |= item.errors_seen
-
-        if self.is_primary_cfg:
-            # The timestamp for this run has been taken with `utcnow()` and is
-            # stored in a custom format.  Store it in standard ISO format with
-            # explicit timezone annotation.
-            timestamp = (
-                datetime.strptime(self.timestamp, "%Y%m%d_%H%M%S")
-                .replace(tzinfo=timezone.utc)
-                .isoformat()
-            )
-
-            results_summary = ResultsSummary(
-                top=IPMeta(
-                    name=self.name,
-                    variant=self.variant,
-                    commit=commit,
-                    branch=self.branch,
-                    url=url,
-                ),
-                timestamp=timestamp,
-                flow_results=all_flow_results,
-                report_path=reports_dir,
-            )
-
-            # Generate all the JSON/HTML reports to the report area.
-            gen_reports(
-                summary=results_summary,
-                path=reports_dir,
-            )
 
     def has_errors(self) -> bool:
         """Return error state."""

src/dvsim/flow/factory.py

@@ -11,9 +11,9 @@
 from dvsim.flow.hjson import load_hjson
 from dvsim.flow.lint import LintCfg
 from dvsim.flow.rdc import RdcCfg
-from dvsim.flow.sim import SimCfg
 from dvsim.flow.syn import SynCfg
 from dvsim.logging import log
+from dvsim.sim.flow import SimCfg
 
 FLOW_HANDLERS = {
     "cdc": CdcCfg,

src/dvsim/flow/one_shot.py

@@ -6,8 +6,10 @@
 
 import pathlib
 from collections import OrderedDict
+from collections.abc import Sequence
 
 from dvsim.flow.base import FlowCfg
+from dvsim.job.data import CompletedJobStatus
 from dvsim.job.deploy import CompileOneShot
 from dvsim.logging import log
 from dvsim.modes import BuildMode, Mode
@@ -149,3 +151,11 @@ def _create_deploy_objects(self) -> None:
 
         # Create initial set of directories before kicking off the regression.
         self._create_dirs()
+
+    def gen_results(self, results: Sequence[CompletedJobStatus]) -> None:
+        """Generate flow results.
+
+        Args:
+            results: completed job status objects.
+
+        """

src/dvsim/report/data.py

@@ -4,17 +4,11 @@
 
 """Report data models."""
 
-from collections.abc import Mapping
-from datetime import datetime
-from pathlib import Path
-
 from pydantic import BaseModel, ConfigDict
 
-from dvsim.sim_results import BucketedFailures
-
 __all__ = (
     "IPMeta",
-    "ResultsSummary",
+    "ToolMeta",
 )
 
 
@@ -45,197 +39,3 @@ class ToolMeta(BaseModel):
     """Name of the tool."""
     version: str
     """Version of the tool."""
-
-
-class TestResult(BaseModel):
-    """Test result."""
-
-    model_config = ConfigDict(frozen=True, extra="forbid")
-
-    max_time: float
-    """Run time."""
-    sim_time: float
-    """Simulation time."""
-
-    passed: int
-    """Number of tests passed."""
-    total: int
-    """Total number of tests run."""
-    percent: float
-    """Percentage test pass rate."""
-
-
-class Testpoint(BaseModel):
-    """Testpoint."""
-
-    model_config = ConfigDict(frozen=True, extra="forbid")
-
-    tests: Mapping[str, TestResult]
-    """Test results."""
-
-    passed: int
-    """Number of tests passed."""
-    total: int
-    """Total number of tests run."""
-    percent: float
-    """Percentage test pass rate."""
-
-
-class TestStage(BaseModel):
-    """Test stages."""
-
-    model_config = ConfigDict(frozen=True, extra="forbid")
-
-    testpoints: Mapping[str, Testpoint]
-    """Results by test point."""
-
-    passed: int
-    """Number of tests passed."""
-    total: int
-    """Total number of tests run."""
-    percent: float
-    """Percentage test pass rate."""
-
-
-class CodeCoverageMetrics(BaseModel):
-    """CodeCoverage metrics."""
-
-    model_config = ConfigDict(frozen=True, extra="forbid")
-
-    block: float | None
-    """Block Coverage (%) - did this part of the code execute?"""
-    line_statement: float | None
-    """Line/Statement Coverage (%) - did this part of the code execute?"""
-    branch: float | None
-    """Branch Coverage (%) - did this if/case take all paths?"""
-    condition_expression: float | None
-    """Condition/Expression Coverage (%) - did the logic evaluate to 0 & 1?"""
-    toggle: float | None
-    """Toggle Coverage (%) - did the signal wiggle?"""
-    fsm: float | None
-    """FSM Coverage (%) - did the state machine transition?"""
-
-    @property
-    def average(self) -> float | None:
-        """Average code coverage (%)."""
-        all_cov = [
-            c
-            for c in [
-                self.line_statement,
-                self.branch,
-                self.condition_expression,
-                self.toggle,
-                self.fsm,
-            ]
-            if c is not None
-        ]
-
-        if len(all_cov) == 0:
-            return None
-
-        return sum(all_cov) / len(all_cov)
-
-
-class CoverageMetrics(BaseModel):
-    """Coverage metrics."""
-
-    code: CodeCoverageMetrics | None
-    """Code Coverage."""
-    assertion: float | None
-    """Assertion Coverage."""
-    functional: float | None
-    """Functional coverage."""
-
-    @property
-    def average(self) -> float | None:
-        """Average code coverage (%) or None if there is no coverage."""
-        code = self.code.average if self.code is not None else None
-        all_cov = [
-            c
-            for c in [
-                code,
-                self.assertion,
-                self.functional,
-            ]
-            if c is not None
-        ]
-
-        if len(all_cov) == 0:
-            return None
-
-        return sum(all_cov) / len(all_cov)
-
-
-class FlowResults(BaseModel):
-    """Flow results data."""
-
-    model_config = ConfigDict(frozen=True, extra="forbid")
-
-    block: IPMeta
-    """IP block metadata."""
-    tool: ToolMeta
-    """Tool used in the simulation run."""
-    timestamp: datetime
-    """Timestamp for when the test ran."""
-
-    stages: Mapping[str, TestStage]
-    """Results per test stage."""
-    coverage: CoverageMetrics | None
-    """Coverage metrics."""
-
-    failed_jobs: BucketedFailures
-    """Bucketed failed job overview."""
-
-    passed: int
-    """Number of tests passed."""
-    total: int
-    """Total number of tests run."""
-    percent: float
-    """Percentage test pass rate."""
-
-    @staticmethod
-    def load(path: Path) -> "FlowResults":
-        """Load results from JSON file.
-
-        Transform the fields of the loaded JSON into a more useful schema for
-        report generation.
-
-        Args:
-            path: to the json file to load.
-
-        """
-        return FlowResults.model_validate_json(path.read_text())
-
-
-class ResultsSummary(BaseModel):
-    """Summary of results."""
-
-    model_config = ConfigDict(frozen=True, extra="forbid")
-
-    top: IPMeta
-    """Meta data for the top level config."""
-
-    timestamp: datetime
-    """Run time stamp."""
-
-    flow_results: Mapping[str, FlowResults]
-    """Flow results."""
-
-    report_path: Path
-    """Path to the report JSON file."""
-
-    @staticmethod
-    def load(path: Path) -> "ResultsSummary":
-        """Load results from JSON file.
-
-        Transform the fields of the loaded JSON into a more useful schema for
-        report generation.
-
-        Args:
-            path: to the json file to load.
-
-        Returns:
-            The loaded ResultsSummary from JSON.
-
-        """
-        return ResultsSummary.model_validate_json(path.read_text())

src/dvsim/sim/__init__.py

@@ -0,0 +1,5 @@
+# Copyright lowRISC contributors (OpenTitan project).
+# Licensed under the Apache License, Version 2.0, see LICENSE for details.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Simulation workflow."""