opencos-eda 0.3.15__py3-none-any.whl → 0.3.17__py3-none-any.whl

opencos/tools/verilator.py

@@ -7,14 +7,24 @@ Contains classes for ToolVerilator and VerilatorSim, VerilatorElab.
 
 import multiprocessing
 import os
+from pathlib import Path
 import subprocess
 
 
 from opencos import util
 from opencos.commands import CommandSim
 from opencos.eda_base import Tool
-from opencos.files import safe_shutil_which
+from opencos.files import safe_shutil_which, get_source_files_paths
+from opencos.util import Colors
 from opencos.utils.str_helpers import sanitize_defines_for_sh
+from opencos.utils.docker_checks import docker_ok, get_docker_run_command, \
+    get_error_str_cant_run_docker
+
+class Warned:
+    '''So we only make the same warnings once, ToolVerilator may be called > 1 times'''
+    tool_get_versions_docker: bool = False
+    tool_get_versions_verilator_coverage: bool = False
+
 
 class ToolVerilator(Tool):
     '''ToolVerilator used by opencos.eda for --tool=verilator'''
@@ -23,17 +33,32 @@ class ToolVerilator(Tool):
     _EXE = 'verilator'
     _URL = 'github.com/verilator/verilator'
 
+    DEFAULT_DOCKER_IMAGE = 'verilator/verilator:latest'
+
     verilator_base_path = ''
     verilator_exe = ''
     verilator_coverage_exe = ''
+    no_verilator_but_has_docker = False
 
-    def get_versions(self) -> str:
+    def get_versions(self, **kwargs) -> str: # pylint: disable=too-many-branches
         if self._VERSION:
             return self._VERSION
         # __init__ would have set self.EXE to full path.
         path = safe_shutil_which(self._EXE)
         if not path:
-            self.error(f'"{self._EXE}" not in path or not installed, see {self._URL})')
+            # but can we run via docker?
+            if docker_ok():
+                if not Warned.tool_get_versions_docker:
+                    Warned.tool_get_versions_docker = True
+                    util.info(f'{Colors.cyan}"verilator"{Colors.green} not in path,',
+                              f'may use {Colors.cyan}--docker-run{Colors.green}',
+                              f'to run with {self.DEFAULT_DOCKER_IMAGE}, see',
+                              f'{Colors.cyan}--help{Colors.green} for other options.')
+                self.verilator_exe = 'verilator'
+                self.verilator_base_path = ''
+                self.no_verilator_but_has_docker = True
+            else:
+                self.error(f'"{self._EXE}" not in path or not installed, see {self._URL})')
         else:
             self.verilator_exe = path
             self.verilator_base_path, _ = os.path.split(path)
@@ -43,27 +68,42 @@ class ToolVerilator(Tool):
             self.verilator_coverage_exe = safe_shutil_which(
                 os.path.join(self.verilator_base_path, 'verilator_coverage')
             )
-        if not self.verilator_coverage_exe:
+        if not self.verilator_coverage_exe and not docker_ok() and \
+           not Warned.tool_get_versions_verilator_coverage:
+            Warned.tool_get_versions_verilator_coverage = True
             util.warning('"verilator_coverage" not in path, need from same path',
                          f'as "{self.verilator_exe}"')
 
-        version_ret = subprocess.run(
-            [self.verilator_exe, '--version'],
-            capture_output=True,
-            check=False
-        )
+        if path:
+            version_ret = subprocess.run(
+                [self.verilator_exe, '--version'],
+                capture_output=True,
+                check=False
+            )
+        elif docker_ok():
+            version_ret = subprocess.run(
+                ['docker', 'run', self.DEFAULT_DOCKER_IMAGE, '--version'],
+                capture_output=True,
+                check=False
+            )
+        else:
+            self._VERSION = 'unknown'
+            return self._VERSION
+
         stdout = version_ret.stdout.decode('utf-8', errors='replace')
         util.debug(f'{path=} {version_ret=}')
         words = stdout.split() # 'Verilator 5.027 devel rev v5.026-92-g403a197e2
-        if len(words) < 1:
+        if len(words) < 2:
             util.warning(
                 f'{self.verilator_exe} --version: returned unexpected string {version_ret=}'
             )
-        version = words[1]
-        ver_list = version.split('.')
-        if len(ver_list) != 2:
-            util.warning(f'{self.verilator_exe} --version: returned unexpected',
-                         f'string {version_ret=} {version=}')
+            version = ''
+        else:
+            version = words[1]
+            ver_list = version.split('.')
+            if len(ver_list) != 2:
+                util.warning(f'{self.verilator_exe} --version: returned unexpected',
+                             f'string {version_ret=} {version=}')
         self._VERSION = version
         return self._VERSION
 
@@ -84,6 +124,7 @@ class VerilatorSim(CommandSim, ToolVerilator):
             'verilator-coverage-args': [],
             'x-assign': '',
             'x-initial': '',
+            'docker-image': self.DEFAULT_DOCKER_IMAGE
         })
 
         self.args_help.update({
@@ -137,6 +178,8 @@ class VerilatorSim(CommandSim, ToolVerilator):
         self.verilated_exec_command_lists = []
         self.verilated_post_exec_coverage_command_lists = []
 
+        self.docker_arg_set = False
+
 
     def set_tool_defines(self):
         ToolVerilator.set_tool_defines(self)
@@ -149,6 +192,27 @@ class VerilatorSim(CommandSim, ToolVerilator):
         self.set_tool_defines()
         self.update_library_map()
 
+        self.docker_arg_set = self.args['docker-run']
+        if self.no_verilator_but_has_docker and not self.docker_arg_set:
+            self.error('"verilator" was not found in PATH, but can be run with --docker-run',
+                       'and optionally --docker-image=verilator/verilator:vX.YYY')
+            return
+
+        if self.docker_arg_set:
+            # check that user can run docker?
+            if docker_ok():
+                # If this is docker, we cannot use the full path from self.verilator_exe,
+                # we have to simply use 'verilator' in the shell script that the docker image
+                # will run.
+                self.verilator_exe = 'verilator'
+                arg = '--docker-run'
+                util.info(
+                    f'Running with {arg} --docker-image={self.args["docker-image"]}',
+                    color=Colors.byellow
+                )
+            else:
+                self.error(get_error_str_cant_run_docker())
+
         # If there are C++ files here, then we will run Verilator in --cc mode:
         if self.files_cpp:
             self.args['cc-mode'] = True
@@ -164,12 +228,18 @@ class VerilatorSim(CommandSim, ToolVerilator):
         paths = ['obj_dir', 'logs']
         util.safe_mkdirs(base=self.args['work-dir'], new_dirs=paths)
 
-        util.write_shell_command_file(dirpath=self.args['work-dir'], filename='lint_only.sh',
-                                      command_lists=self.lint_only_command_lists, line_breaks=True)
 
-        sim_cmd_lists = self.verilated_exec_command_lists + \
-            (self.verilated_post_exec_coverage_command_lists
-             if self.args.get('coverage', True) else [])
+        util.write_shell_command_file(
+            dirpath=self.args['work-dir'], filename='lint_only.sh',
+            command_lists=self.lint_only_command_lists, line_breaks=True
+        )
+
+        if self.args.get('lint-only', False):
+            sim_cmd_lists = []
+        else:
+            sim_cmd_lists = self.verilated_exec_command_lists + \
+                (self.verilated_post_exec_coverage_command_lists
+                 if self.args.get('coverage', True) else [])
 
         self.write_sh_scripts_to_work_dir(
             compile_lists=self.verilate_command_lists,
@@ -177,6 +247,125 @@ class VerilatorSim(CommandSim, ToolVerilator):
             simulate_lists=sim_cmd_lists
         )
 
+        if self.docker_arg_set:
+            self.prepare_compile_docker()
+
+
+    def prepare_compile_docker(self) -> None:
+        '''Takes existing generated shell scripts, and saves out different ones.
+
+        will be used in compile() and simulate() steps.
+
+        1. Assume the existing compile.sh exists.
+           a. Create docker_wrap_compile.sh that has:
+               docker [run|exec] --entrypoint /bin/bash IMAGE \
+                   -c "cd WORK-DIR && ./copmile.sh"
+           b. where compile.sh is
+              i. The original contents from self.verilate_command_lists, but with
+                 'verilator' instead of '/path/to/verilator', which was handled
+                 elsewhere looking at self.args['docker']
+
+        2. Assume simulate.sh exists (or not)
+           a. Create docker_wrap_simulate.sh that has:
+               docker [run|exec] --entrypoint /bin/bash IMAGE \
+                  -c "cd WORK-DIR && ./in_docker_simulate.sh"
+           b. simulate.sh unchanged, should already have the coverage commands
+
+        3. Overwrite all.sh to call:
+           - docker_wrap_compile.sh
+           - docker_wrap_simulate.sh
+
+        4. Destroy the self.*_command_lists so they point to the bash scripts.
+        '''
+        if not self.docker_arg_set:
+            return
+
+        # TODO(drew): Windows friendly? Probably not. a lot of ./ going on here.
+
+        work_dir_abs = Path(self.args['work-dir']).resolve()
+
+        docker_command = 'run'
+        docker_run_base_cmd = get_docker_run_command(
+            image=self.args['docker-image'],
+            docker_command=docker_command,
+            env_dict={'CCACHE_DIR': '/tmp/ccache'}, # For macos verilator compatibility
+            ro_volumes=get_source_files_paths(cmd_des_obj=self, minimal_root_paths=True),
+            rw_volumes=[work_dir_abs],
+        )
+
+        util.write_shell_command_file(
+            dirpath=self.args['work-dir'],
+            filename='docker_wrap_compile.sh',
+            command_lists=[
+                util.ShellCommandList(docker_run_base_cmd + [
+                    '-c', f'\'cd {work_dir_abs} && ./compile.sh\'',
+                ], tee_fpath='compile.log')
+            ],
+            line_breaks=False
+        )
+
+        util.write_shell_command_file(
+            dirpath=self.args['work-dir'],
+            filename='docker_wrap_lint_only.sh',
+            command_lists=[
+                util.ShellCommandList(docker_run_base_cmd + [
+                    '-c', f'\'cd {work_dir_abs} && ./lint_only.sh\'',
+                ], tee_fpath='lint_only.log')
+            ],
+            line_breaks=False
+        )
+
+        util.write_shell_command_file(
+            dirpath=self.args['work-dir'],
+            filename='docker_wrap_simulate.sh',
+            command_lists=[
+                util.ShellCommandList(docker_run_base_cmd + [
+                    '-c', f'\'cd {work_dir_abs} && ./simulate.sh\'',
+                ], tee_fpath='sim.log')
+            ],
+            line_breaks=False
+        )
+
+
+        all_lists = [] # list - of - (command-list)
+        if self.has_pre_compile_dep_shell_commands:
+            all_lists.append(['./pre_compile_dep_shell_commands.sh'])
+        if self.args.get('lint-only', False):
+            all_lists.append(['./docker_wrap_lint_only.sh'])
+        else:
+            all_lists.append(['./docker_wrap_compile.sh'])
+            all_lists.append(['./docker_wrap_simulate.sh'])
+        if self.has_post_tool_dep_shell_commands:
+            all_lists.append(['./post_tool_dep_shell_commands.sh'])
+
+        util.write_shell_command_file(
+            dirpath=self.args['work-dir'], filename='all.sh',
+            command_lists=all_lists, line_breaks=True
+        )
+
+        # Overwrite our command lists so compile(), simulate() work correctly.
+        if self.verilate_command_lists:
+            self.verilate_command_lists = [
+                util.ShellCommandList(
+                    ['./docker_wrap_compile.sh'], tee_fpath='docker_wrap_compile.log'
+                )
+            ]
+        if self.lint_only_command_lists:
+            self.lint_only_command_lists = [
+                util.ShellCommandList(
+                    ['./docker_wrap_lint_only.sh'], tee_fpath='docker_wrap_lint_only.log'
+                )
+            ]
+        if self.verilated_exec_command_lists:
+            self.verilated_exec_command_lists = [
+                util.ShellCommandList(
+                    ['./docker_wrap_simulate.sh'], tee_fpath='docker_wrap_simulate.log'
+                )
+            ]
+        self.verilated_post_exec_coverage_command_lists = [ ] # clear, in docker_wrap_simulate
+
+        return
+
 
     def compile(self):
         if self.args['stop-before-compile']:

opencos/tools/vivado.py

@@ -46,7 +46,7 @@ class ToolVivado(Tool):
         })
 
 
-    def get_versions(self) -> str:
+    def get_versions(self, **kwargs) -> str:
         if self._VERSION:
             return self._VERSION
 

opencos/tools/yosys.py

@@ -9,11 +9,13 @@ import os
 import subprocess
 
 from opencos import util, eda_config
-from opencos.commands import CommandSynth, CommandLec
+from opencos.commands import CommandSynth, CommandLec, CommandFList
 from opencos.eda_base import Tool, get_eda_exec
 from opencos.files import safe_shutil_which
 from opencos.utils.markup_helpers import yaml_safe_load
 
+from opencos.commands.sim import parameters_dict_get_command_list
+
 
 def get_commands_to_run_scriptfiles(
         script_fnames_list: list, yosys_exe: str
@@ -37,6 +39,63 @@ def get_commands_to_run_scriptfiles(
     return yosys_cmdlists
 
 
+
+def get_yosys_defines_incdirs_files(
+        command_design_obj,
+        for_synthesis: bool = True,
+        **kwargs,
+) -> list:
+    '''
+    Returns a partial list of all the args for a read_verilog or read_slang command in yosys
+    Handles defines, incdirs, files_sv, files_v
+
+    command_design_obj is intended to be a opencos.eda_base.CommandDesign or derived class
+    object.
+
+    This should be used by CommandFList or CommandSynth derivations for yosys tools:
+      *Yosys, *SlangYosys
+
+    Valid kwargs bools (default True if ommitted) - defines, incdirs, verilog, systemverilog, top
+    '''
+
+    ret_list = []
+
+    defines = getattr(command_design_obj, 'defines', {})
+    incdirs = getattr(command_design_obj, 'incdirs', [])
+    files_v = getattr(command_design_obj, 'files_v', [])
+    files_sv = getattr(command_design_obj, 'files_sv', [])
+    top  = getattr(command_design_obj, 'args', {}).get('top', '')
+
+
+    if kwargs.get('defines', True):
+        for name, value in defines.items():
+            if not name:
+                continue
+            if for_synthesis and name in ['SIMULATION']:
+                continue
+
+            if value is None:
+                ret_list.append(f'--define-macro {name}')
+            else:
+                ret_list.append(f'--define-macro {name}={value}')
+
+        # We must define SYNTHESIS for oclib_defines.vh to work correctly.
+        if for_synthesis and 'SYNTHESIS' not in defines:
+            ret_list.append('--define-macro SYNTHESIS')
+
+    if kwargs.get('incdirs', True):
+        for path in incdirs:
+            ret_list.append(f'-I {path}')
+    if kwargs.get('verilog', True):
+        ret_list.extend(files_v)
+    if kwargs.get('systemverilog', True):
+        ret_list.extend(files_sv)
+    if kwargs.get('top', True) and top:
+        ret_list.append(f'--top {top}')
+
+    return ret_list
+
+
 class ToolYosys(Tool):
     '''Parent class for ToolTabbyCadYosys, ToolInvioYosys, ToolSlangYosys'''
 
@@ -48,7 +107,7 @@ class ToolYosys(Tool):
     sta_exe = ''
     sta_version = ''
 
-    def get_versions(self) -> str:
+    def get_versions(self, **kwargs) -> str:
         if self._VERSION:
             return self._VERSION
 
@@ -478,34 +537,7 @@ class CommonSynthYosys(CommandSynth, ToolYosys):
 
         Handles defines, incdirs, files_sv, files_v
         '''
-        ret_list = []
-
-        for name,value in self.defines.items():
-            if not name:
-                continue
-            if name in ['SIMULATION']:
-                continue
-
-            if value is None:
-                ret_list.append(f'--define-macro {name}')
-            else:
-                ret_list.append(f'--define-macro {name}={value}')
-
-        # We must define SYNTHESIS for oclib_defines.vh to work correctly.
-        if 'SYNTHESIS' not in self.defines:
-            ret_list.append('--define-macro SYNTHESIS')
-
-        for path in self.incdirs:
-            ret_list.append(f'-I {path}')
-
-        for path in self.files_v:
-            ret_list.append(path)
-
-        for path in self.files_sv:
-            ret_list.append(path)
-
-        ret_list.append(f'--top {self.args["top"]}')
-        return ret_list
+        return get_yosys_defines_incdirs_files(command_design_obj=self, for_synthesis=True)
 
 
 class CommandLecYosys(CommandLec, ToolYosys):
@@ -742,3 +774,96 @@ class CommandLecYosys(CommandLec, ToolYosys):
         lec_cmd_list = 'yosys --scriptfile yosys_lec.f'.split()
         util.info(f'LEC running {lec_cmd_list}')
         self.exec(self.args['work-dir'], lec_cmd_list)
+
+
+class CommonFListYosys(CommandFList, ToolYosys):
+    '''
+    Handler for: eda flist --tool=yosys
+
+    This will create a eda.yosys_read_verilog.f flist (or to std-out if --print-to-stdout),
+    suitable for args passed to a "read_verilog" command in yosys, such as:
+
+        read_verilog -f FILE_CREATED_BY_THIS_HANDLER [other args]
+
+    '''
+    def __init__(self, config: dict, **kwargs):
+        CommandFList.__init__(self, config=config,
+                              # Added bonus - remove some CommandFList args that we don't
+                              # need:
+                              include_prefix_args=False, include_quote_args=False,
+                              include_format_define_args=False)
+        ToolYosys.__init__(self, config=self.config)
+
+        self.args.update({
+            'force': True, # always overwrite the output
+            'out': 'eda_flist.yosys.read_verilog.f',
+
+            'emit-define'        : True,
+            'emit-parameter'     : True,
+            'emit-incdir'        : True,
+            'emit-plusargs'      : True,
+            'emit-v'             : True,
+            'emit-sv'            : True,
+            'emit-vhd'           : True,
+            'emit-cpp'           : False,
+            'emit-non-sources'   : False, # as comments, from DEPS 'reqs'
+        })
+
+    def get_flist_plusargs_list(self) -> list:
+        '''Overriden from CommandFList.'''
+        if self.args['unprocessed-plusargs']:
+            util.warning(f'Command "flist" for --tool={self._TOOL} is not intended for simulation',
+                         'and plusargs were present. They will NOT be included in the flist:',
+                         f'{self.args["unprocessed-plusargs"]}')
+
+        return []
+
+    def get_write_flist_lines(
+            self, add_comment_lines: bool = False
+    ) -> list:
+        '''Override from CommandFList'''
+
+        # Want: defines + parameters + incdirs + files + --top=VALUE, similar to
+        #    how we call CommonSynthYosys.get_yosys_read_verilog_defines_incdirs_files(),
+        #    but without the additional args
+
+        ret = []
+
+        # Use our overriden method to post warnings about brining simulation Plusargs to
+        # a Yosys tool:
+        _ = self.get_flist_plusargs_list()
+
+        if add_comment_lines:
+            ret.append(f"## {self.args=}")
+
+            if self.files_non_source:
+                ret.append('## reqs (non-source files that are dependencies):')
+                for f in self.files_non_source:
+                    if self.args['emit-rel-path']:
+                        f = os.path.relpath(f)
+                    ret.append(f'##   {f}')
+
+        # Note - top is included in this:
+        include_items = []
+        if self.args['emit-define']:
+            include_items.append('defines')
+        if self.args['emit-incdir']:
+            include_items.append('incdirs')
+
+        ret.extend(get_yosys_defines_incdirs_files(
+            command_design_obj=self,
+            for_synthesis=True,
+            # True/False kwargs if you want that emitted:
+            defines=self.args['emit-define'],
+            incdirs=self.args['emit-incdir'],
+            verilog=self.args['emit-v'],
+            systemverilog=self.args['emit-sv'],
+            top=True
+        ))
+
+        # and parameters:
+        ret.extend(parameters_dict_get_command_list(
+            params=self.parameters, arg_prefix='-G '
+        ))
+
+        return ret

opencos/util.py

@@ -20,6 +20,7 @@ from importlib import import_module
 from dotenv import load_dotenv
 from supports_color import supportsColor
 
+import opencos
 from opencos.files import safe_shutil_which
 from opencos.utils import status_constants
 from opencos.utils.str_helpers import strip_ansi_color
@@ -359,7 +360,10 @@ def get_argparser() -> argparse.ArgumentParser:
     #    boolean actions:
     bool_action_kwargs = get_argparse_bool_action_kwargs()
 
-    parser.add_argument('--version', default=False, action='store_true')
+    parser.add_argument('--version', default=False, action='store_true',
+                        help=('Shows our version:'
+                              f' {opencos.__version__} ({opencos.__pyproject_name__})')
+                        )
     parser.add_argument('--color', **bool_action_kwargs, default=bool(supportsColor.stdout),
                         help='Use shell colors for info/warning/error messaging')
     parser.add_argument('--emoji', **bool_action_kwargs, default=args['emoji'],