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 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 init_coremanager(config, args_cores_root):
logger.debug("Initializing core manager")
cm = CoreManager(config)
args_libs = [Library(acr, acr) for acr in args_cores_root]
# Add libraries from config file, env var and command-line
for library in config.libraries + args_libs:
try:
cm.add_library(library)
except (RuntimeError, IOError) as e:
_s = "Failed to register library '{}'"
logger.warning(_s.format(str(e)))
return cm
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 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_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_")
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_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 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
def cmd_filespec(args):
cfg_file = _ConfigFile("")
cfg = Config(file=cfg_file)
if args.debug:
logging.basicConfig(level=logging.DEBUG)
cm = CoreManager(cfg)
if not hasattr(args, "output") or args.output is None:
args.output = "-"
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}
filepath_m = {}
template_m = _find_builtin_templates()
if not hasattr(args, "template") or args.template is None:
# Report on available templates
raise Exception("No template specified. Avaiable: %s" %
" ".join(list(template_m.keys())))
if os.path.isfile(args.template):
template = args.template
else:
if args.template not in template_m.keys():
raise Exception("Template %s not present. Avaiable: %s" %
(args.template, " ".join(list(template_m.keys()))))
else:
template = template_m[args.template]
with open(args.filespec, "r") as fp:
filespec = yaml.load(fp, Loader=yaml.loader.FullLoader)
if "filespec" not in filespec.keys():
raise Exception("YAML filespec does not contain 'filespec'")
fs = filespec["filespec"]
for v in fs:
out = v["out"]
for e in out:
top_flags = {"is_toplevel": True}
if "flags" in e.keys():
f = e["flags"]
if isinstance(f, list):
for fi in f:
top_flags[fi] = True
else:
top_flags[f] = True
core_deps = cm.get_depends(Vlnv(v["vlnv"]), flags=top_flags)
name = e["name"]
flags = {}
file_type = set()
t = e["type"]
if isinstance(t, list):
for ti in t:
file_type.add(ti)
else:
file_type.add(t)
if "flags" in e.keys():
f = e["flags"]
if isinstance(f, list):
for fi in f:
flags[fi] = True
else:
flags[f] = True
if "include" in e.keys():
include = e["include"]
else:
include = False
# print("file_type: %s ; include=%s" % (str(file_type), str(include)))
files = _collect_files(core_deps, file_type, flags, include)
filepath_m[name] = files
# Now, generate the output
t_loader = _TemplateLoader(template)
env = jinja2.Environment(loader=t_loader)
templ = env.get_template(template)
out = templ.render({"files": filepath_m})
if args.output == "-":
sys.stdout.write(out)
else:
with open(args.output, "w") as fp:
fp.write(out)
