refactor: improve data models

Make sure variant is available for report generation. This is done by
reusing existing models better. We can still tidy this up further, but
this gets us to a bit better place.

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

Author: machshev

src/dvsim/flow/base.py

@@ -459,7 +459,7 @@ def gen_results(self, results: Sequence[CompletedJobStatus]) -> None:
 
         for item in self.cfgs:
             project = item.name
-            item_results = [r for r in results if r.project == project]
+            item_results = [r for r in results if r.block.name == project]
 
             flow_results: FlowResults = item._gen_json_results(item_results)
             all_flow_results[project] = flow_results

src/dvsim/job/data.py

@@ -15,6 +15,7 @@
 from pydantic import BaseModel, ConfigDict
 
 from dvsim.launcher.base import ErrorMessage, Launcher
+from dvsim.report.data import IPMeta, ToolMeta
 
 __all__ = (
     "CompletedJobStatus",
@@ -28,8 +29,6 @@ class WorkspaceConfig(BaseModel):
 
     model_config = ConfigDict(frozen=True, extra="forbid")
 
-    project: str
-    """Name of the project"""
     timestamp: str
     """Time stamp of the run."""
 
@@ -46,32 +45,31 @@ class JobSpec(BaseModel):
 
     model_config = ConfigDict(frozen=True, extra="forbid")
 
+    name: str
+    """Name of the job"""
+
     job_type: str
     """Deployment type"""
-
     target: str
     """run phase [build, run, ...]"""
-    flow: str
-    """Name of the flow config (e.g. tl_agent)"""
-    tool: str
-    """EDA tool used"""
 
-    name: str
-    """Name of the job"""
     seed: int | None
     """Seed if there is one."""
 
     full_name: str
     """Full name disambiguates across multiple cfg being run (example:
     'aes:default', 'uart:default' builds.
     """
-
     qual_name: str
     """Qualified name disambiguates the instance name with other instances
     of the same class (example: 'uart_smoke' reseeded multiple times
     needs to be disambiguated using the index -> '0.uart_smoke'.
     """
 
+    block: IPMeta
+    """IP block metadata."""
+    tool: ToolMeta
+    """Tool used in the simulation run."""
     workspace_cfg: WorkspaceConfig
     """Workspace configuration."""
 
@@ -119,15 +117,20 @@ class CompletedJobStatus(BaseModel):
 
     model_config = ConfigDict(frozen=True, extra="forbid")
 
-    project: str
-    """Name of the project"""
-    job_type: str
-    """Deployment type"""
     name: str
     """Name of the job"""
+    job_type: str
+    """Deployment type"""
     seed: int | None
     """Seed if there is one."""
 
+    block: IPMeta
+    """IP block metadata."""
+    tool: ToolMeta
+    """Tool used in the simulation run."""
+    workspace_cfg: WorkspaceConfig
+    """Workspace configuration."""
+
     full_name: str
     """Full name disambiguates across multiple cfg being run (example:
     'aes:default', 'uart:default' builds.

src/dvsim/job/deploy.py

@@ -17,6 +17,7 @@
 from dvsim.job.time import JobTime
 from dvsim.launcher.base import Launcher
 from dvsim.logging import log
+from dvsim.report.data import IPMeta, ToolMeta
 from dvsim.tool.utils import get_sim_tool_plugin
 from dvsim.utils import (
     clean_odirs,
@@ -101,40 +102,46 @@ def __init__(self, sim_cfg: "SimCfg") -> None:
         # Construct the job's command.
         self.cmd = self._construct_cmd()
 
-        self.workspace_cfg = WorkspaceConfig(
-            project=sim_cfg.name,
-            project_root=sim_cfg.proj_root,
-            scratch_root=Path(sim_cfg.scratch_root),
-            scratch_path=Path(sim_cfg.scratch_path),
-            timestamp=sim_cfg.args.timestamp,
-        )
-
     def get_job_spec(self) -> "JobSpec":
         """Get the job spec for this deployment."""
         return JobSpec(
+            name=self.name,
             job_type=self.__class__.__name__,
             target=self.target,
-            flow=self.flow,
-            tool=self.sim_cfg.tool,
-            name=self.name,
             seed=getattr(self, "seed", None),
             full_name=self.full_name,
             qual_name=self.qual_name,
-            workspace_cfg=self.workspace_cfg,
+            block=IPMeta(
+                name=self.sim_cfg.name,
+                variant=self.sim_cfg.variant,
+                commit=self.sim_cfg.revision,
+                branch=self.sim_cfg.branch,
+                url="",
+            ),
+            tool=ToolMeta(
+                name=self.sim_cfg.tool,
+                version="",
+            ),
+            workspace_cfg=WorkspaceConfig(
+                timestamp=self.sim_cfg.args.timestamp,
+                project_root=self.sim_cfg.proj_root,
+                scratch_root=Path(self.sim_cfg.scratch_root),
+                scratch_path=Path(self.sim_cfg.scratch_path),
+            ),
             dependencies=[d.full_name for d in self.dependencies],
+            needs_all_dependencies_passing=self.needs_all_dependencies_passing,
             weight=self.weight,
             timeout_mins=self.get_timeout_mins(),
             cmd=self.cmd,
             exports=self.exports,
             dry_run=self.dry_run,
             interactive=self.sim_cfg.interactive,
             gui=self.gui,
-            needs_all_dependencies_passing=self.needs_all_dependencies_passing,
-            pre_launch=self.pre_launch(),
-            post_finish=self.post_finish(),
             odir=self.odir,
-            links=self.sim_cfg.links,
             log_path=Path(f"{self.odir}/{self.target}.log"),
+            links=self.sim_cfg.links,
+            pre_launch=self.pre_launch(),
+            post_finish=self.post_finish(),
             pass_patterns=self.pass_patterns,
             fail_patterns=self.fail_patterns,
         )

src/dvsim/launcher/base.py

@@ -107,7 +107,7 @@ def __init__(self, job_spec: "JobSpec") -> None:
             Launcher.workspace_prepared = True
 
         # One-time preparation of the workspace, specific to the cfg.
-        project = workspace_cfg.project
+        project = job_spec.block.name
         if project not in Launcher.workspace_prepared_for_cfg:
             self.prepare_workspace_for_cfg(workspace_cfg)
             Launcher.workspace_prepared_for_cfg.add(project)
@@ -339,7 +339,7 @@ def _find_patterns(patterns: Sequence[str], line: str) -> Sequence[str] | None:
         # since it is devoid of the delays incurred due to infrastructure and
         # setup overhead.
 
-        plugin = get_sim_tool_plugin(tool=self.job_spec.tool)
+        plugin = get_sim_tool_plugin(tool=self.job_spec.tool.name)
 
         try:
             time, unit = plugin.get_job_runtime(log_text=lines)

src/dvsim/launcher/lsf.py

@@ -214,10 +214,10 @@ def _do_launch(self) -> None:
             job_array += "%100"
 
         # TODO: This needs to be moved to a HJson.
-        if self.job_spec.tool == "vcs":
+        if self.job_spec.tool.name == "vcs":
             job_rusage = "'rusage[vcssim=1,vcssim_dynamic=1:duration=1]'"
 
-        elif self.job_spec.tool == "xcelium":
+        elif self.job_spec.tool.name == "xcelium":
             job_rusage = "'rusage[xcelium=1,xcelium_dynamic=1:duration=1]'"
 
         else:

src/dvsim/launcher/nc.py

@@ -53,7 +53,7 @@ def create_run_sh(self, full_path, cmd) -> None:
         pathlib.Path(run_file).chmod(0o755)
 
     def get_submit_cmd(self):
-        exetool = self.job_spec.tool
+        exetool = self.job_spec.tool.name
         job_name = self.job_spec.full_name
         cmd = self.job_spec.cmd
         odir = self.job_spec.odir

src/dvsim/scheduler.py

@@ -237,18 +237,20 @@ def on_signal(signal_received: int, _: FrameType | None) -> None:
 
             results.append(
                 CompletedJobStatus(
-                    project=job_spec.workspace_cfg.project,
-                    job_type=job_spec.job_type,
                     name=job_spec.name,
+                    job_type=job_spec.job_type,
                     seed=job_spec.seed,
+                    block=job_spec.block,
+                    tool=job_spec.tool,
+                    workspace_cfg=job_spec.workspace_cfg,
                     full_name=name,
                     qual_name=job_spec.qual_name,
                     target=job_spec.target,
-                    status=status,
-                    fail_msg=launcher.fail_msg,
+                    log_path=job_spec.log_path,
                     job_runtime=launcher.job_runtime.with_unit("s").get()[0],
                     simulated_time=launcher.simulated_time.with_unit("us").get()[0],
-                    log_path=job_spec.log_path,
+                    status=status,
+                    fail_msg=launcher.fail_msg,
                 )
             )
 
@@ -263,7 +265,7 @@ def add_to_scheduled(self, jobs: Mapping[str, JobSpec]) -> None:
         """
         for full_name, job_spec in jobs.items():
             target_dict = self._scheduled.setdefault(job_spec.target, {})
-            cfg_list = target_dict.setdefault(job_spec.flow, [])
+            cfg_list = target_dict.setdefault(job_spec.block.name, [])
 
             if job_spec not in cfg_list:
                 cfg_list.append(full_name)
@@ -272,7 +274,7 @@ def _unschedule_item(self, job_name: str) -> None:
         """Remove deploy item from the schedule."""
         job = self._jobs[job_name]
         target_dict = self._scheduled[job.target]
-        cfg_list = target_dict.get(job.flow)
+        cfg_list = target_dict.get(job.block.name)
 
         if cfg_list is not None:
             with contextlib.suppress(ValueError):
@@ -281,7 +283,7 @@ def _unschedule_item(self, job_name: str) -> None:
             # When all items in _scheduled[target][cfg] are finally removed,
             # the cfg key is deleted.
             if not cfg_list:
-                del target_dict[job.flow]
+                del target_dict[job.block.name]
 
     def _enqueue_successors(self, job_name: str | None = None) -> None:
         """Move an item's successors from _scheduled to _queued.
@@ -363,7 +365,7 @@ def _get_successors(self, job_name: str | None = None) -> Sequence[str]:
             if target is None:
                 return []
 
-            cfgs = {job.flow}
+            cfgs = {job.block.name}
 
         # Find item's successors that can be enqueued. We assume here that
         # only the immediately succeeding target can be enqueued at this