def get_cores(system_name):
'''
Gets a list of core dependencies from a top level core name.
'''
vers = get_version()
if vers[:2] > [1, 6]:
flags = {
'flow': 'sim',
'tool': 'ghdl',
}
cores = cm.get_depends(Vlnv(system_name), flags=flags)
else:
cores = cm.get_depends(Vlnv(system_name))
return cores
def build(args):
system = Vlnv(args.system)
if str(system) in CoreManager().get_systems():
core = CoreManager().get_core(system)
try:
backend = BackendFactory(core)
except DependencyError as e:
pr_err("'" + args.system +
"' or any of its dependencies requires '" + e.value +
"', but this core was not found")
exit(1)
except RuntimeError as e:
pr_err("Failed to build '{}': {}".format(args.system, e))
exit(1)
try:
backend.configure(args.backendargs)
except RuntimeError as e:
pr_err(str(e))
exit(1)
print('')
try:
backend.build(args.backendargs)
except RuntimeError as e:
pr_err("Failed to build FPGA: " + str(e))
else:
pr_err("Can't find system '" + args.system + "'")
def test_virtual():
import os
import tempfile
from fusesoc.config import Config
from fusesoc.coremanager import CoreManager
from fusesoc.edalizer import Edalizer
from fusesoc.librarymanager import Library
from fusesoc.vlnv import Vlnv
flags = {"tool": "icarus"}
build_root = tempfile.mkdtemp(prefix="export_")
work_root = os.path.join(build_root, "work")
core_dir = os.path.join(os.path.dirname(__file__), "capi2_cores",
"virtual")
cm = CoreManager(Config())
cm.add_library(Library("virtual", core_dir))
root_core = cm.get_core(Vlnv("::user"))
edalizer = Edalizer(
toplevel=root_core.name,
flags=flags,
core_manager=cm,
work_root=work_root,
)
edalizer.run()
deps = cm.get_depends(root_core.name, {})
deps_names = [str(c) for c in deps]
assert deps_names == ["::impl2:0", "::user:0"]
def __init__(self, ttptttg, core, generators):
generator_name = ttptttg["generator"]
if not generator_name in generators:
raise RuntimeError(
"Could not find generator '{}' requested by {}".format(
generator_name, core.name))
self.generator = generators[generator_name]
self.name = ttptttg["name"]
self.pos = ttptttg["pos"]
parameters = ttptttg["config"]
vlnv_str = ":".join([
core.name.vendor,
core.name.library,
core.name.name + "-" + self.name,
core.name.version,
])
self.vlnv = Vlnv(vlnv_str)
self.generator_input = {
"files_root": os.path.abspath(core.files_root),
"gapi": "1.0",
"parameters": parameters,
"vlnv": vlnv_str,
}
def test_virtual():
from fusesoc.core import Core
from fusesoc.vlnv import Vlnv
core_file = os.path.join(tests_dir, "capi2_cores", "virtual", "impl1.core")
core = Core(core_file)
assert core.get_virtuals() == [Vlnv("::someinterface:0")]
def test_full_vlnv_revision():
assert vlnv_tuple(Vlnv("librecores.org:peripherals:uart16550:1.5-r5")) == (
"librecores.org",
"peripherals",
"uart16550",
"1.5",
5,
)
def test_full_vlnv_no_version():
assert vlnv_tuple(Vlnv("librecores.org:peripherals:uart16550")) == (
"librecores.org",
"peripherals",
"uart16550",
"0",
0,
)
def test_capi1_deprecation_warning():
from fusesoc.vlnv import Vlnv
tests_dir = os.path.dirname(__file__)
cores_root = os.path.join(tests_dir, "cores")
sockit_core = os.path.join(cores_root, "sockit", "sockit.core")
with pytest.warns(FutureWarning, match="is deprecated"):
core = Core(sockit_core)
assert core.name == Vlnv("::sockit:1.0")
def sim(args):
core = CoreManager().get_core(Vlnv(args.system))
if core == None:
pr_err("Can't find core '" + args.system + "'")
exit(1)
if args.sim:
sim_name = args.sim[0]
elif core.simulators:
sim_name = core.simulators[0]
else:
pr_err("No simulator was found in '" + args.system +
"' core description")
logger.error("No simulator was found in '" + args.system +
"' core description")
exit(1)
try:
CoreManager().tool = sim_name
sim = SimulatorFactory(sim_name, core)
except DependencyError as e:
pr_err("'" + args.system + "' or any of its dependencies requires '" +
e.value + "', but this core was not found")
exit(1)
except OptionSectionMissing as e:
pr_err("'" + args.system + "' miss a mandatory parameter for " +
sim_name + " simulation (" + e.value + ")")
exit(1)
except RuntimeError as e:
pr_err(str(e))
exit(1)
if (args.testbench):
sim.toplevel = args.testbench[0]
if not args.keep or not os.path.exists(sim.sim_root):
try:
sim.configure(args.plusargs)
print('')
except RuntimeError as e:
pr_err("Failed to configure the system")
pr_err(str(e))
exit(1)
try:
sim.build()
except Source as e:
pr_err("'" + e.value +
"' source type is not valid. Choose 'C' or 'systemC'")
exit(1)
except RuntimeError as e:
pr_err("Failed to build simulation model")
pr_err(str(e))
exit(1)
if not args.build_only:
try:
sim.run(args.plusargs)
except RuntimeError as e:
pr_err("Failed to run the simulation")
pr_err(str(e))
def _get_core(cm, name):
core = None
try:
core = cm.get_core(Vlnv(name))
except RuntimeError as e:
logger.error(str(e))
exit(1)
except DependencyError as e:
logger.error("'" + name + "' or any of its dependencies requires '" + e.value + "', but this core was not found")
exit(1)
return core
def test_core_parsing():
from fusesoc.vlnv import Vlnv
core = get_core("nomain")
assert core.name == Vlnv("::nomain:0")
from fusesoc.core import Core
import sys
if sys.version_info[0] > 2:
with pytest.raises(SyntaxError) as e:
core = Core("tests/cores/misc/duplicateoptions.core")
assert "option 'file_type' in section 'fileset dummy' already exists" in str(e.value)
def test_copyto():
import os
import tempfile
from fusesoc.config import Config
from fusesoc.coremanager import CoreManager
from fusesoc.edalizer import Edalizer
from fusesoc.librarymanager import Library
from fusesoc.vlnv import Vlnv
flags = {"tool": "icarus"}
work_root = tempfile.mkdtemp(prefix="copyto_")
core_dir = os.path.join(os.path.dirname(__file__), "cores", "misc", "copytocore")
lib = Library("misc", core_dir)
cm = CoreManager(Config())
cm.add_library(lib)
core = cm.get_core(Vlnv("::copytocore"))
edalizer = Edalizer(
toplevel=core.name,
flags=flags,
core_manager=cm,
cache_root=None,
work_root=work_root,
export_root=None,
system_name=None,
)
edalizer.run()
eda_api = edalizer.edalize
assert eda_api["files"] == [
{
"file_type": "user",
"core": "::copytocore:0",
"logical_name": "",
"name": "copied.file",
"is_include_file": False,
},
{
"file_type": "tclSource",
"core": "::copytocore:0",
"logical_name": "",
"name": "subdir/another.file",
"is_include_file": False,
},
]
assert os.path.exists(os.path.join(work_root, "copied.file"))
assert os.path.exists(os.path.join(work_root, "subdir", "another.file"))
def test_core_parsing():
from fusesoc.vlnv import Vlnv
cores_root = os.path.join(os.path.dirname(__file__), 'cores', 'misc')
core = Core(os.path.join(cores_root, 'nomain.core'))
assert core.name == Vlnv("::nomain:0")
import sys
if sys.version_info[0] > 2:
with pytest.raises(SyntaxError) as e:
core = Core(os.path.join(cores_root, "duplicateoptions.core"))
assert "option 'file_type' in section 'fileset dummy' already exists" in str(
e.value)
def _get_core(cm, name):
core = None
try:
core = cm.get_core(Vlnv(name))
except RuntimeError as e:
logger.error(str(e))
exit(1)
except DependencyError as e:
logger.error(
f"{name!r} or any of its dependencies requires {e.value!r}, but "
"this core was not found")
exit(1)
return core
def _get_core(name, has_system=False):
core = None
try:
core = CoreManager().get_core(Vlnv(name))
except RuntimeError as e:
pr_err(str(e))
exit(1)
except DependencyError as e:
pr_err("'" + name + "' or any of its dependencies requires '" + e.value + "', but this core was not found")
exit(1)
if has_system and not core.backend:
pr_err("Unable to find .system file for '{}'".format(name))
exit(1)
return core
def cmd_files(args):
cfg_file = _ConfigFile("")
cfg = Config(file=cfg_file)
# logging.basicConfig(level=logging.DEBUG)
cm = CoreManager(cfg)
packages_dir = get_packages_dir()
project_dir = os.path.dirname(packages_dir)
cm.add_library(Library("project", project_dir))
if args.library_path is not None:
for lib in args.library_path:
colon_i = lib.find(':')
if colon_i > 1:
path = lib[colon_i + 1:]
lib_name = lib[:colon_i]
else:
path = lib
lib_name = "cmdline"
cm.add_library(Library(lib_name, path))
top_flags = {"is_toplevel": True}
if hasattr(args, "target") and args.target is not None:
top_flags["target"] = args.target
# Use detailed arguments
core_deps = cm.get_depends(Vlnv(args.vlnv), flags=top_flags)
flags = {}
if hasattr(args, "flags") and args.flags is not None:
for f in args.flags:
subflags = f.split(',')
for sf in subflags:
flags[sf] = True
file_type = None
if args.file_type is not None:
file_type = set()
for t in args.file_type:
subtypes = t.split(',')
for st in subtypes:
file_type.add(st)
_extract_files(sys.stdout, core_deps, file_type, flags, args.include)
def _get_core(name, has_system=False):
core = None
try:
core = CoreManager().get_core(Vlnv(name))
except RuntimeError as e:
logger.error(str(e))
exit(1)
except DependencyError as e:
logger.error("'" + name + "' or any of its dependencies requires '" +
e.value + "', but this core was not found")
exit(1)
if has_system and not core.get_tool({'flow': 'synth', 'tool': None}):
logger.error("Unable to find synthesis info for '{}'".format(name))
exit(1)
return core
def test_eda_api_vpi():
import os.path
import tempfile
from fusesoc.config import Config
from fusesoc.coremanager import CoreManager
from fusesoc.vlnv import Vlnv
tests_dir = os.path.dirname(__file__)
build_root = tempfile.mkdtemp()
cache_root = os.path.join(tests_dir, 'cache')
cores_root = os.path.join(tests_dir, 'capi2_cores')
work_root = os.path.join(build_root, 'work')
export_root = os.path.join(build_root, 'src')
config = Config()
config.build_root = build_root
config.cache_root = cache_root
cm = CoreManager(config)
cm.add_cores_root(cores_root)
eda_api = cm.setup(Vlnv("vpi"), {'tool': 'icarus'}, work_root, export_root)
expected = {
'files': [],
'hooks': {},
'name':
'vpi_0',
'parameters': [],
'tool_options': {
'icarus': {}
},
'toplevel':
'not_used',
'version':
'0.1.2',
'vpi': [{
'src_files': ['../src/vpi_0/f1', '../src/vpi_0/f3'],
'include_dirs': ['../src/vpi_0/'],
'libs': ['some_lib'],
'name': 'vpi1'
}, {
'src_files': ['../src/vpi_0/f4'],
'include_dirs': [],
'libs': [],
'name': 'vpi2'
}]
}
assert eda_api == expected
def test_export():
import os
import tempfile
from fusesoc.config import Config
from fusesoc.coremanager import CoreManager
from fusesoc.edalizer import Edalizer
from fusesoc.librarymanager import Library
from fusesoc.vlnv import Vlnv
flags = {"tool": "icarus"}
build_root = tempfile.mkdtemp(prefix="export_")
export_root = os.path.join(build_root, "exported_files")
work_root = os.path.join(build_root, "work")
core_dir = os.path.join(os.path.dirname(__file__), "cores")
cm = CoreManager(Config())
cm.add_library(Library("cores", core_dir))
core = cm.get_core(Vlnv("::wb_intercon"))
edalizer = Edalizer(
toplevel=core.name,
flags=flags,
core_manager=cm,
cache_root=None,
work_root=work_root,
export_root=export_root,
system_name=None,
)
edalizer.run()
for f in [
"wb_intercon_1.0/dummy_icarus.v",
"wb_intercon_1.0/bench/wb_mux_tb.v",
"wb_intercon_1.0/bench/wb_upsizer_tb.v",
"wb_intercon_1.0/bench/wb_intercon_tb.v",
"wb_intercon_1.0/bench/wb_arbiter_tb.v",
"wb_intercon_1.0/rtl/verilog/wb_data_resize.v",
"wb_intercon_1.0/rtl/verilog/wb_mux.v",
"wb_intercon_1.0/rtl/verilog/wb_arbiter.v",
"wb_intercon_1.0/rtl/verilog/wb_upsizer.v",
]:
assert os.path.isfile(os.path.join(export_root, f))
def test_generators():
import os
import tempfile
from fusesoc.config import Config
from fusesoc.coremanager import CoreManager
from fusesoc.edalizer import Edalizer
from fusesoc.librarymanager import Library
from fusesoc.vlnv import Vlnv
tests_dir = os.path.dirname(__file__)
cores_dir = os.path.join(tests_dir, "capi2_cores", "misc", "generate")
lib = Library("edalizer", cores_dir)
cm = CoreManager(Config())
cm.add_library(lib)
core = cm.get_core(Vlnv("::generate"))
build_root = tempfile.mkdtemp(prefix="export_")
cache_root = tempfile.mkdtemp(prefix="export_cache_")
export_root = os.path.join(build_root, "exported_files")
edalizer = Edalizer(
toplevel=core.name,
flags={"tool": "icarus"},
core_manager=cm,
cache_root=cache_root,
work_root=os.path.join(build_root, "work"),
export_root=export_root,
system_name=None,
)
edalizer.run()
gendir = os.path.join(cache_root, "generated",
"generate-testgenerate_without_params_0")
assert os.path.isfile(os.path.join(gendir, "generated.core"))
assert os.path.isfile(
os.path.join(gendir, "testgenerate_without_params_input.yml"))
gendir = os.path.join(cache_root, "generated",
"generate-testgenerate_with_params_0")
assert os.path.isfile(os.path.join(gendir, "generated.core"))
assert os.path.isfile(
os.path.join(gendir, "testgenerate_with_params_input.yml"))
def test_deptree():
from fusesoc.coremanager import CoreManager
from fusesoc.config import Config
from fusesoc.librarymanager import Library
from fusesoc.vlnv import Vlnv
import os
tests_dir = os.path.dirname(__file__)
deptree_cores_dir = os.path.join(tests_dir, "capi2_cores", "deptree")
lib = Library("deptree", deptree_cores_dir)
cm = CoreManager(Config())
cm.add_library(lib)
root_core = cm.get_core(Vlnv("::deptree-root"))
# Check dependency tree
deps = cm.get_depends(root_core.name, {})
deps_names = [str(c) for c in deps]
deps_names_expected = [
"::deptree-child2:0",
"::deptree-child3:0",
"::deptree-child1:0",
"::deptree-root:0",
]
assert deps_names == deps_names_expected
# Check files in dependency tree
files_expected = [
"child2-fs1-f1.sv",
"child2-fs1-f2.sv",
"child3-fs1-f1.sv",
"child3-fs1-f2.sv",
"child1-fs1-f1.sv",
"child1-fs1-f2.sv",
"root-fs1-f1.sv",
"root-fs1-f2.sv",
"root-fs2-f1.sv",
"root-fs2-f2.sv",
]
files = []
for d in deps:
files += [f["name"] for f in d.get_files({})]
assert files == files_expected
def test_generators():
import os
import tempfile
from fusesoc.config import Config
from fusesoc.coremanager import CoreManager
from fusesoc.edalizer import Edalizer
from fusesoc.librarymanager import Library
from fusesoc.vlnv import Vlnv
tests_dir = os.path.dirname(__file__)
cores_dir = os.path.join(tests_dir, "capi2_cores", "misc", "generate")
lib = Library("edalizer", cores_dir)
cm = CoreManager(Config())
cm.add_library(lib)
core = cm.get_core(Vlnv("::generate"))
build_root = tempfile.mkdtemp(prefix="export_")
export_root = os.path.join(build_root, "exported_files")
edalizer = Edalizer(
toplevel=core.name,
flags={"tool": "icarus"},
core_manager=cm,
work_root=os.path.join(build_root, "work"),
export_root=export_root,
system_name=None,
)
edalizer.run()
name_to_core = {str(core.name): core for core in edalizer.cores}
for flavour in ["testgenerate_with_params", "testgenerate_without_params"]:
core_name = f"::generate-{flavour}:0"
assert core_name in name_to_core
core = name_to_core[core_name]
# ttptttg temporary directory should be removed by now
assert not os.path.isdir(core.core_root)
def process_vlnv_jobspec_path(self, vlnv_s):
if self.core_mgr is None:
raise Exception("No core-manager supplied to handle VLNV %s" % vlnv_s["vlnv"])
flags = { "is_toplevel": True }
if "target" in vlnv_s.keys():
flags["target"] = vlnv_s["target"]
core = self.core_mgr.get_depends(
Vlnv(vlnv_s["vlnv"]),
flags=flags)
for c in core:
c_files = c.get_files(flags)
for f in c_files:
if f['file_type'] == "testPlanYaml":
full_path = os.path.join(c.core_root, f['name'])
self.process_jobspec_path(full_path)
def __init__(self, ttptttg, core, generators):
generator_name = ttptttg['generator']
if not generator_name in generators:
raise RuntimeError("Could not find generator '{}' requested by {}".format(generator_name, core.name))
self.generator = generators[generator_name]
self.name = ttptttg['name']
self.pos = ttptttg['pos']
parameters = ttptttg['config']
vlnv_str = ':'.join([core.name.vendor,
core.name.library,
core.name.name+'-'+self.name,
core.name.version])
self.vlnv = Vlnv(vlnv_str)
self.generator_input = {
'files_root' : os.path.abspath(core.files_root),
'gapi' : '1.0',
'parameters' : parameters,
'vlnv' : vlnv_str,
}
def __new__(clk, *args, **kwargs):
if not args:
return list()
else:
return [Vlnv(p) for p in StringList(args[0])]
def __init__(self, core_file, cache_root=""):
basename = os.path.basename(core_file)
self.depend = []
self.simulators = []
self.plusargs = None
self.provider = None
self.backend = None
for s in section.SECTION_MAP:
assert not hasattr(self, s)
if section.SECTION_MAP[s].named:
setattr(self, s, OrderedDict())
else:
setattr(self, s, None)
self.core_root = os.path.dirname(core_file)
self.files_root = self.core_root
self.export_files = []
config = FusesocConfigParser(core_file)
# Add .system options to .core file
system_file = os.path.join(self.core_root,
basename.split(".core")[0] + ".system")
if os.path.exists(system_file):
self._merge_system_file(system_file, config)
# FIXME : Make simulators part of the core object
self.simulator = config.get_section("simulator")
if not "toplevel" in self.simulator:
self.simulator["toplevel"] = "orpsoc_tb"
for s in section.load_all(config, core_file):
if type(s) == tuple:
_l = getattr(self, s[0].TAG)
_l[s[1]] = s[0]
setattr(self, s[0].TAG, _l)
else:
setattr(self, s.TAG, s)
if not self.main:
self.main = section.MainSection()
if self.main.name:
self.name = Vlnv(self.main.name)
else:
self.name = Vlnv(basename.split(".core")[0])
self.sanitized_name = self.name.sanitized_name
self.depend = self.main.depend[:]
self.simulators = self.main.simulators
if self.main.backend:
try:
self.backend = getattr(self, self.main.backend)
except AttributeError:
raise SyntaxError('Invalid backend "{}"'.format(
self.main.backend))
self._collect_filesets()
cache_root = os.path.join(cache_root, self.sanitized_name)
if config.has_section("plusargs"):
self._warning(
"plusargs section is deprecated and will not be parsed by FuseSoC. Please migrate to parameters"
)
self.plusargs = Plusargs(dict(config.items("plusargs")))
if config.has_section("verilator") and config.has_option(
"verilator", "define_files"):
self._warning("verilator define_files are deprecated")
if config.has_section("provider"):
items = dict(config.items("provider"))
patch_root = os.path.join(self.core_root, "patches")
patches = self.main.patches
if os.path.exists(patch_root):
for p in sorted(os.listdir(patch_root)):
patches.append(os.path.join("patches", p))
items["patches"] = patches
provider_name = items.get("name")
if provider_name is None:
raise RuntimeError('Missing "name" in section [provider]')
self.provider = get_provider(provider_name)(items, self.core_root,
cache_root)
if self.provider:
self.files_root = self.provider.files_root
# We need the component file here, but it might not be
# available until the core is fetched. Try to fetch first if any
# of the component files are missing
if False in [os.path.exists(f) for f in self.main.component]:
self.setup()
for f in self.main.component:
self._parse_component(f)
def get_depends(self, flags): #Add use flags?
depends = []
self._debug("Getting dependencies for flags {}".format(str(flags)))
for fs in self._get_filesets(flags):
depends += [Vlnv(d) for d in self._parse_list(flags, fs.depend)]
return depends
def test_capi2_get_depends():
from fusesoc.core import Core
from fusesoc.vlnv import Vlnv
core = Core(os.path.join(tests_dir,
"capi2_cores",
"misc",
"depends.core"))
flags = {}
result = core.get_depends(flags)
expected = [
Vlnv('unversioned'),
Vlnv('versioned-1.0'),
Vlnv('<lt-1.0'),
Vlnv('<=lte-1.0'),
Vlnv('=eq-1.0'),
Vlnv('>gt-1.0'),
Vlnv('>=gte-1.0'),
Vlnv('::n'),
Vlnv('::nv:1.0'),
Vlnv(':l:nv:1.0'),
Vlnv('v:l:nv:1.0'),
Vlnv('<::vlnvlt:1.0'),
Vlnv('<=::vlnvlte:1.0'),
Vlnv('=::vlnveq:1.0'),
Vlnv('>::vlnvgt:1.0'),
Vlnv('>=::vlnvgte:1.0'),
]
assert len(result) == len(expected)
for i in range(len(result)):
assert result[i] == expected[i]
def test_capi2_get_depends():
from fusesoc.core import Core
from fusesoc.vlnv import Vlnv
core = Core(os.path.join(tests_dir, "capi2_cores", "misc", "depends.core"))
flags = {}
result = core.get_depends(flags)
expected = [
Vlnv("unversioned"),
Vlnv("versioned-1.0"),
Vlnv("<lt-1.0"),
Vlnv("<=lte-1.0"),
Vlnv("=eq-1.0"),
Vlnv(">gt-1.0"),
Vlnv(">=gte-1.0"),
Vlnv("::n"),
Vlnv("::nv:1.0"),
Vlnv(":l:nv:1.0"),
Vlnv("v:l:nv:1.0"),
Vlnv("<::vlnvlt:1.0"),
Vlnv("<=::vlnvlte:1.0"),
Vlnv("=::vlnveq:1.0"),
Vlnv(">::vlnvgt:1.0"),
Vlnv(">=::vlnvgte:1.0"),
Vlnv("^::vlnvmajor:1.0"),
Vlnv("~::vlnvminor:2.2.3"),
]
assert len(result) == len(expected)
for i in range(len(result)):
assert result[i] == expected[i]
def test_deptree(tmp_path):
import os
from fusesoc.config import Config
from fusesoc.coremanager import CoreManager
from fusesoc.edalizer import Edalizer
from fusesoc.librarymanager import Library
from fusesoc.vlnv import Vlnv
flags = {"tool": "icarus"}
tests_dir = os.path.dirname(__file__)
deptree_cores_dir = os.path.join(tests_dir, "capi2_cores", "deptree")
lib = Library("deptree", deptree_cores_dir)
cm = CoreManager(Config())
cm.add_library(lib)
root_core = cm.get_core(Vlnv("::deptree-root"))
# This is an array of (child, parent) core name tuples and
# is used for checking that the flattened list of core
# names is consistent with the dependencies.
dependencies = (
# Dependencies of the root core
("::deptree-child3:0", "::deptree-root:0"),
("::deptree-child2:0", "::deptree-root:0"),
("::deptree-child1:0", "::deptree-root:0"),
("::deptree-child-a:0", "::deptree-root:0"),
# Dependencies of child1 core
("::deptree-child3:0", "::deptree-child1:0"),
# Dependencies of child-a core
("::deptree-child4:0", "::deptree-child-a:0"),
)
# The ordered files that we expect from each core.
expected_core_files = {
"::deptree-child3:0": (
"child3-fs1-f1.sv",
"child3-fs1-f2.sv",
),
"::deptree-child2:0": (
"child2-fs1-f1.sv",
"child2-fs1-f2.sv",
),
"::deptree-child1:0": (
"child1-fs1-f1.sv",
"child1-fs1-f2.sv",
),
"::deptree-child4:0": ("child4.sv", ),
"::deptree-child-a:0": (
# Files from filesets are always included before any
# files from generators with "position: append".
# This is because generated files are often dependent on files
# that are not generated, and it convenient to be able to
# include them in the same core.
"child-a2.sv",
"generated-child-a.sv",
"generated-child-a-append.sv",
),
"::deptree-root:0": (
"root-fs1-f1.sv",
"root-fs1-f2.sv",
"root-fs2-f1.sv",
"root-fs2-f2.sv",
),
}
# Use Edalizer to get the files.
# This is necessary because we need to run generators.
work_root = str(tmp_path / "work")
os.mkdir(work_root)
edalizer = Edalizer(
toplevel=root_core.name,
flags=flags,
work_root=work_root,
core_manager=cm,
)
edam = edalizer.run()
# Check dependency tree (after running all generators)
deps = cm.get_depends(root_core.name, {})
deps_names = [str(c) for c in deps]
all_core_names = set()
for child, parent in dependencies:
assert child in deps_names
assert parent in deps_names
all_core_names.add(child)
all_core_names.add(parent)
# Confirm that we don't have any extra or missing core names.
assert all_core_names == set(deps_names)
# Make sure there are no repeats in deps_names
assert len(all_core_names) == len(deps_names)
# Now work out what order we expect to get the filenames.
# The order of filenames within each core in deterministic.
# Each fileset in order. Followed by each generator in order.
# The order between the cores is taken the above `dep_names`.
expected_filenames = []
# A generator-created core with "position: first"
expected_filenames.append("generated-child-a-first.sv")
for dep_name in deps_names:
expected_filenames += list(expected_core_files[dep_name])
# A generator-created core with "position: last"
expected_filenames.append("generated-child-a-last.sv")
edalized_filenames = [os.path.basename(f["name"]) for f in edam["files"]]
assert edalized_filenames == expected_filenames
