FuseSoC Integration

This module provides integration with FuseSoC for IP core management.

fusesoc_manager

class dv_flow.libfusesoc.fusesoc_manager.FuseSoCManager(config_dir: Path | None = None, data_dir: Path | None = None)[source]

Bases: object

Wrapper around FuseSoC’s CoreManager and LibraryManager. Provides isolated workspace management for DV Flow integration.

__init__(config_dir: Path | None = None, data_dir: Path | None = None)[source]

Initialize FuseSoC manager with optional isolated directories.

Parameters:

config_dir – Directory for FuseSoC configuration
data_dir – Directory for FuseSoC data (cores, cache)

get_core_manager() → CoreManager[source]: Get or create CoreManager instance

add_library(name: str, path: Path, sync_uri: str | None = None)[source]

Add a core library to the manager.

Parameters:

name – Library name
path – Local path to library
sync_uri – Optional remote URI for library sync

resolve_core(core_name: str, flags: Dict | None = None)[source]

Resolve a core by name/VLNV.

Parameters:

core_name – Core name in VLNV format (vendor:library:name:version)
flags – Optional flags for core resolution (e.g., tool, target)

Returns:

Resolved core object with file lists and metadata

get_core_files(core, flags: Dict | None = None)[source]

Get file lists from a resolved core.

Parameters:

core – Resolved core object
flags – Optional flags for target selection (e.g., {‘tool’: ‘icarus’, ‘target’: ‘sim’})

Returns:

Dictionary containing file lists with attributes, include directories, and metadata

get_dependencies(core, flags: Dict | None = None)[source]

Get dependency tree for a core.

Parameters:

core – Resolved core object
flags – Optional flags for dependency resolution

Returns:

List of dependent cores

resolve_dependencies(core_name: str, flags: Dict | None = None)[source]

Recursively resolve all dependencies for a core.

Parameters:

core_name – Core name in VLNV format
flags – Optional flags for resolution

Returns:

List of all resolved cores including dependencies

The FuseSoC Manager provides a wrapper around FuseSoC’s core functionality, enabling:

Core discovery and resolution
Library management
Dependency tracking
File list extraction
Workspace isolation

Key Features

Core Resolution: Parse VLNV (Vendor:Library:Name:Version) identifiers and resolve cores with their dependencies.
Library Management: Add and manage FuseSoC libraries, with support for multiple core sources.
File Extraction: Extract file lists filtered by target, tool, and flags.
Workspace Isolation: All operations are performed within a configured workspace directory, ensuring no interference with user’s global FuseSoC configuration.

fusesoc_fileset

class dv_flow.libfusesoc.fusesoc_fileset.FilesetConverter(core_root: Path, files_root: Path | None = None)[source]

Bases: object

Converts FuseSoC core filesets to DV Flow file collection format. Handles file type mapping and attribute conversion.

FILE_TYPE_MAP = {'LPF': 'constraint', 'PCF': 'constraint', 'SDC': 'constraint', 'UCF': 'constraint', 'systemVerilogSource': 'systemverilog', 'tclSource': 'tcl', 'user': 'user', 'verilogSource': 'verilog', 'vhdlSource': 'vhdl', 'vhdlSource-2008': 'vhdl', 'xdc': 'constraint'}

__init__(core_root: Path, files_root: Path | None = None)[source]

Initialize fileset converter.

Parameters:

core_root – Root directory of the core file
files_root – Root directory for fetched files (if different from core_root)

convert_files(fusesoc_files: List[Dict]) → List[Dict][source]

Convert FuseSoC file list to DV Flow format.

Parameters:: fusesoc_files – List of files from FuseSoC core (from core.get_files())
Returns:: List of file dictionaries in DV Flow format

extract_include_dirs(fusesoc_files: List[Dict]) → List[str][source]

Extract include directories from file list.

Parameters:: fusesoc_files – List of files from FuseSoC core
Returns:: List of include directory paths

filter_by_type(converted_files: List[Dict], file_types: List[str]) → List[Dict][source]

Filter files by type.

Parameters:

converted_files – List of converted file dictionaries
file_types – List of file types to include

Returns:

Filtered list of files

get_source_files(converted_files: List[Dict]) → List[Dict][source]

Get only source files (exclude constraints, scripts, etc).

Parameters:: converted_files – List of converted file dictionaries
Returns:: List of source files

The Fileset Converter transforms FuseSoC file structures into DV Flow compatible formats.

Conversion Features

Maps FuseSoC file types to standard categories (Verilog, SystemVerilog, VHDL, constraints)
Extracts include directories
Handles logical names and library specifications
Supports separate files_root for file path resolution
Preserves file metadata and attributes

File Type Mapping

FuseSoC	DV Flow
verilogSource	verilog
systemVerilogSource	systemverilog
vhdlSource	vhdl
tclSource	tcl
SDC	sdc
xdc	xdc
user	user

fusesoc_core_resolve

class dv_flow.libfusesoc.fusesoc_core_resolve.CoreResolveParams(*, core: str, target: str | None = None, tool: str | None = None, libraries: ~typing.Dict[str, str] = <factory>, workspace: str | None = None)[source]

Bases: BaseModel

Parameters for CoreResolve task.

Resolves a FuseSoC core and extracts file lists.

core: str

target: str | None

tool: str | None

libraries: Dict[str, str]

workspace: str | None

model_config: ClassVar[ConfigDict] = {}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class dv_flow.libfusesoc.fusesoc_core_resolve.CoreResolveOutput(*, core_name: str, core_root: str, files_root: str, files: ~typing.List[~typing.Dict] = <factory>, dependencies: ~typing.List[str] = <factory>, parameters: ~typing.Dict = <factory>, include_dirs: ~typing.List[str] = <factory>)[source]

Bases: BaseModel

Output from CoreResolve task.

Contains resolved core information and file lists.

core_name: str

core_root: str

files_root: str

files: List[Dict]

dependencies: List[str]

parameters: Dict

include_dirs: List[str]

model_config: ClassVar[ConfigDict] = {}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class dv_flow.libfusesoc.fusesoc_core_resolve.CoreResolveMemento(*, core: str, target: str | None, tool: str | None, core_name: str, last_resolution: float)[source]

Bases: BaseModel

Memento for CoreResolve task.

Caches resolved core information.

core: str

target: str | None

tool: str | None

core_name: str

last_resolution: float

model_config: ClassVar[ConfigDict] = {}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

async dv_flow.libfusesoc.fusesoc_core_resolve.CoreResolve(runner, input: TaskDataInput[CoreResolveParams]) → TaskDataResult[source]

Resolve a FuseSoC core and extract file lists.

This task: 1. Initializes FuseSoC in the specified workspace 2. Adds any additional libraries 3. Resolves the specified core 4. Extracts and converts file lists 5. Returns file information for downstream tasks

Parameters:

runner – Task runner context
input – Task input with CoreResolveParams

Returns:

TaskDataResult with CoreResolveOutput

The CoreResolve task is the main entry point for resolving FuseSoC cores in DV Flow.

Task Parameters

The task accepts the following parameters through CoreResolveParams:

class CoreResolveParams(BaseModel):
    core: str  # VLNV identifier
    target: str = "sim"  # Target configuration
    tool: Optional[str] = None  # Tool name
    libraries: Dict[str, str] = {}  # Additional libraries
    workspace: str  # FuseSoC workspace path
    flags: List[str] = []  # Build flags

Task Outputs

Returns CoreResolveOutput containing:

class CoreResolveOutput(BaseModel):
    core_name: str  # Resolved core name
    core_root: str  # Core root directory
    files: List[Dict]  # Converted file list
    dependencies: List[str]  # Core dependencies
    parameters: Dict[str, Any]  # Core parameters
    include_dirs: List[str]  # Include directories

Usage Example

from dv_flow.libfusesoc.fusesoc_core_resolve import CoreResolve, CoreResolveParams

params = CoreResolveParams(
    core="vendor:lib:uart:1.0",
    target="sim",
    workspace="/path/to/workspace",
    libraries={"mylib": "/path/to/mylib"}
)

result = await CoreResolve(runner, params)

print(f"Resolved core: {result.output['core_name']}")
print(f"Files: {len(result.output['files'])}")
print(f"Dependencies: {result.output['dependencies']}")