siliconcompiler 0.31.0__py3-none-any.whl → 0.31.1__py3-none-any.whl

siliconcompiler/_metadata.py

@@ -1,5 +1,5 @@
 # Version number following semver standard.
-version = '0.31.0'
+version = '0.31.1'
 
 # Default server address for remote runs, if unspecified.
 default_server = 'https://server.siliconcompiler.com'

siliconcompiler/apps/sc_install.py

@@ -101,6 +101,19 @@ def print_machine_info():
     print("Scripts:  ", _get_tool_script_dir())
 
 
+def __print_summary(successful, failed):
+    max_len = 64
+    print("#"*max_len)
+    if successful:
+        msg = f"Installed: {', '.join(sorted(successful))}"
+        print(f"# {msg}")
+
+    if failed:
+        msg = f"Failed to install: {failed}"
+        print(f"# {msg}")
+    print("#"*max_len)
+
+
 def _get_tool_script_dir():
     return Path(siliconcompiler.__file__).parent / "toolscripts"
 
@@ -242,6 +255,7 @@ To system debugging information (this should only be used to debug):
                 args.tool.extend(tool_groups[group])
 
     tools_handled = set()
+    tools_completed = set()
     for tool in args.tool:
         if tool in tools_handled:
             continue
@@ -250,9 +264,14 @@ To system debugging information (this should only be used to debug):
             show_tool(tool, tools[tool])
         else:
             if not install_tool(tool, tools[tool], args.build_dir, args.prefix):
+                __print_summary(tools_completed, tool)
                 return 1
+            else:
+                tools_completed.add(tool)
 
     if not args.show:
+        __print_summary(tools_completed, None)
+
         msgs = []
         for env, path in (
                 ("PATH", "bin"),
@@ -262,7 +281,6 @@ To system debugging information (this should only be used to debug):
                 os.path.expandvars(os.path.expanduser(p))
                 for p in os.getenv(env, "").split(":")
             ]
-            print(envs)
             if check_path not in envs:
                 msgs.extend([
                     "",

siliconcompiler/core.py

@@ -2950,7 +2950,7 @@ class Chip:
                 elif os.path.isfile(results_html):
                     _open_html_report(self, results_html)
                 else:
-                    self._dashboard(wait=False)
+                    self.dashboard(wait=False)
 
     ###########################################################################
     def clock(self, pin, period, jitter=0, mode='global'):

siliconcompiler/{package.py → package/__init__.py}

@@ -1,25 +1,20 @@
 import os
-import requests
-import tarfile
-import zipfile
-from git import Repo, GitCommandError
 from urllib.parse import urlparse
 import importlib
-import shutil
 import re
 from siliconcompiler import SiliconCompilerError
 from siliconcompiler.utils import default_cache_dir, _resolve_env_vars
 import json
 from importlib.metadata import distributions, distribution
 import functools
-import fasteners
 import time
 from pathlib import Path
-from io import BytesIO
 
 from github import Github
 import github.Auth
 
+from siliconcompiler.utils import get_plugins
+
 
 def get_cache_path(chip):
     cache_path = chip.get('option', 'cachedir')
@@ -33,10 +28,45 @@ def get_cache_path(chip):
     return cache_path
 
 
-def _path(chip, package, download_handler):
-    if package in chip._packages:
-        return chip._packages[package]
+def get_download_cache_path(chip, package, ref):
+    cache_path = get_cache_path(chip)
+    if not os.path.exists(cache_path):
+        os.makedirs(cache_path, exist_ok=True)
+
+    if ref is None:
+        raise SiliconCompilerError(f'Reference is required for cached data: {package}', chip=chip)
+
+    return \
+        os.path.join(cache_path, f'{package}-{ref}'), \
+        os.path.join(cache_path, f'{package}-{ref}.lock')
+
+
+def _file_path_resolver(chip, package, path, ref, url):
+    return os.path.abspath(path.replace('file://', ''))
+
+
+def _python_path_resolver(chip, package, path, ref, url):
+    return path_from_python(chip, url.netloc)
 
+
+def _get_path_resolver(path):
+    url = urlparse(path)
+
+    for resolver in get_plugins("path_resolver"):
+        func = resolver(url)
+        if func:
+            return func, url
+
+    if url.scheme == "file":
+        return _file_path_resolver, url
+
+    if url.scheme == "python":
+        return _python_path_resolver, url
+
+    raise ValueError(f"{path} is not supported")
+
+
+def _path(chip, package):
     # Initially try retrieving data source from schema
     data = {}
     data['path'] = chip.get('package', 'source', package, 'path')
@@ -48,48 +78,13 @@ def _path(chip, package, download_handler):
 
     data['path'] = _resolve_env_vars(chip, data['path'], None, None)
 
-    url = urlparse(data['path'])
-
-    # check network drive for package data source
-    if data['path'].startswith('file://') or os.path.exists(data['path']):
-        path = os.path.abspath(data['path'].replace('file://', ''))
-        chip.logger.info(f'Found {package} data at {path}')
-        chip._packages[package] = path
-        return path
-    elif data['path'].startswith('python://'):
-        path = path_from_python(chip, url.netloc)
-        chip.logger.info(f'Found {package} data at {path}')
-        chip._packages[package] = path
-        return path
-
-    # location of the python package
-    cache_path = get_cache_path(chip)
-    if not os.path.exists(cache_path):
-        os.makedirs(cache_path, exist_ok=True)
-    project_id = f'{package}-{data.get("ref")}'
-    if url.scheme not in ['git', 'git+https', 'https', 'git+ssh', 'ssh'] or not project_id:
-        raise SiliconCompilerError(
-            f'Could not find data path in package {package}: {data["path"]}',
-            chip=chip)
-
-    data_path = os.path.join(cache_path, project_id)
-
-    if download_handler:
-        download_handler(chip,
-                         package,
-                         data,
-                         url,
-                         data_path,
-                         os.path.join(cache_path, f'{project_id}.lock'))
-
-    if os.path.exists(data_path):
-        if package not in chip._packages:
-            chip.logger.info(f'Saved {package} data to {data_path}')
-            chip._packages[package] = data_path
-        return data_path
+    if os.path.exists(data['path']):
+        # Path is already a path
+        return os.path.abspath(data['path'])
 
-    raise SiliconCompilerError(f'Extracting {package} data to {data_path} failed',
-                               chip=chip)
+    path_resolver, url = _get_path_resolver(data['path'])
+
+    return path_resolver(chip, package, data['path'], data['ref'], url)
 
 
 def path(chip, package):
@@ -102,40 +97,25 @@ def path(chip, package):
         path: Location of data source on the local system
     """
 
-    return _path(chip, package, __download_data)
-
+    if package not in chip._packages:
+        changed = False
+        data_path = _path(chip, package)
 
-def __download_data(chip, package, data, url, data_path, data_path_lock):
-    data_lock = fasteners.InterProcessLock(data_path_lock)
+        if isinstance(data_path, tuple) and len(data_path) == 2:
+            data_path, changed = data_path
 
-    _aquire_data_lock(data_path, data_lock)
+        if os.path.exists(data_path):
+            if package not in chip._packages and changed:
+                chip.logger.info(f'Saved {package} data to {data_path}')
+            else:
+                chip.logger.info(f'Found {package} data at {data_path}')
 
-    # check cached package data source
-    if os.path.exists(data_path):
-        chip.logger.info(f'Found cached {package} data at {data_path}')
-        if url.scheme in ['git', 'git+https', 'ssh', 'git+ssh']:
-            try:
-                repo = Repo(data_path)
-                if repo.untracked_files or repo.index.diff("HEAD"):
-                    chip.logger.warning('The repo of the cached data is dirty.')
-                _release_data_lock(data_lock)
-                chip._packages[package] = data_path
-                return
-            except GitCommandError:
-                chip.logger.warning('Deleting corrupted cache data.')
-                shutil.rmtree(path)
-        else:
-            _release_data_lock(data_lock)
             chip._packages[package] = data_path
-            return
-
-    # download package data source
-    if url.scheme in ['git', 'git+https', 'ssh', 'git+ssh']:
-        clone_synchronized(chip, package, data, data_path)
-    elif url.scheme == 'https':
-        extract_from_url(chip, package, data, data_path)
+        else:
+            raise SiliconCompilerError(f'Unable to locate {package} data in {data_path}',
+                                       chip=chip)
 
-    _release_data_lock(data_lock)
+    return chip._packages[package]
 
 
 def __get_filebased_lock(data_lock):
@@ -143,7 +123,7 @@ def __get_filebased_lock(data_lock):
     return Path(f'{base}.sc_lock')
 
 
-def _aquire_data_lock(data_path, data_lock):
+def aquire_data_lock(data_path, data_lock):
     # Wait a maximum of 10 minutes for other processes to finish
     max_seconds = 10 * 60
     try:
@@ -168,7 +148,7 @@ def _aquire_data_lock(data_path, data_lock):
                                'please delete it.')
 
 
-def _release_data_lock(data_lock):
+def release_data_lock(data_lock):
     # Check if file based locking method was used
     lock_file = __get_filebased_lock(data_lock)
     if lock_file.exists():
@@ -178,100 +158,6 @@ def _release_data_lock(data_lock):
     data_lock.release()
 
 
-def clone_synchronized(chip, package, data, data_path):
-    url = urlparse(data['path'])
-    try:
-        clone_from_git(chip, package, data, data_path)
-    except GitCommandError as e:
-        if 'Permission denied' in repr(e):
-            if url.scheme in ['ssh', 'git+ssh']:
-                chip.logger.error('Failed to authenticate. Please setup your git ssh.')
-            elif url.scheme in ['git', 'git+https']:
-                chip.logger.error('Failed to authenticate. Please use a token or ssh.')
-        else:
-            chip.logger.error(str(e))
-
-
-def clone_from_git(chip, package, data, repo_path):
-    url = urlparse(data['path'])
-    if url.scheme in ['git', 'git+https'] and url.username:
-        chip.logger.warning('Your token is in the data source path and will be stored in the '
-                            'schema. If you do not want this set the env variable GIT_TOKEN '
-                            'or use ssh for authentication.')
-    if url.scheme in ['git+ssh', 'ssh']:
-        chip.logger.info(f'Cloning {package} data from {url.netloc}:{url.path[1:]}')
-        # Git requires the format git@github.com:org/repo instead of git@github.com/org/repo
-        repo = Repo.clone_from(f'{url.netloc}:{url.path[1:]}',
-                               repo_path,
-                               recurse_submodules=True)
-    else:
-        if os.environ.get('GIT_TOKEN') and not url.username:
-            url = url._replace(netloc=f'{os.environ.get("GIT_TOKEN")}@{url.hostname}')
-        url = url._replace(scheme='https')
-        chip.logger.info(f'Cloning {package} data from {url.geturl()}')
-        repo = Repo.clone_from(url.geturl(), repo_path, recurse_submodules=True)
-    chip.logger.info(f'Checking out {data["ref"]}')
-    repo.git.checkout(data["ref"])
-    for submodule in repo.submodules:
-        submodule.update(init=True)
-
-
-def extract_from_url(chip, package, data, data_path):
-    url = urlparse(data['path'])
-    data_url = data.get('path')
-    headers = {}
-    if os.environ.get('GIT_TOKEN') or url.username:
-        headers['Authorization'] = f'token {os.environ.get("GIT_TOKEN") or url.username}'
-    if "github" in data_url:
-        headers['Accept'] = 'application/octet-stream'
-    data_url = data['path']
-    if data_url.endswith('/'):
-        data_url = f"{data_url}{data['ref']}.tar.gz"
-    chip.logger.info(f'Downloading {package} data from {data_url}')
-    response = requests.get(data_url, stream=True, headers=headers)
-    if not response.ok:
-        raise SiliconCompilerError(f'Failed to download {package} data source.', chip=chip)
-
-    fileobj = BytesIO(response.content)
-    try:
-        with tarfile.open(fileobj=fileobj, mode='r|gz') as tar_ref:
-            tar_ref.extractall(path=data_path)
-    except tarfile.ReadError:
-        fileobj.seek(0)
-        # Try as zip
-        with zipfile.ZipFile(fileobj) as zip_ref:
-            zip_ref.extractall(path=data_path)
-
-    if 'github' in url.netloc and len(os.listdir(data_path)) == 1:
-        # Github inserts one folder at the highest level of the tar file
-        # this compensates for this behavior
-        gh_url = urlparse(data_url)
-
-        repo = gh_url.path.split('/')[2]
-
-        ref = gh_url.path.split('/')[-1]
-        if repo.endswith('.git'):
-            ref = data['ref']
-        elif ref.endswith('.tar.gz'):
-            ref = ref[0:-7]
-        elif ref.endswith('.tgz'):
-            ref = ref[0:-4]
-        else:
-            ref = ref.split('.')[0]
-
-        if ref.startswith('v'):
-            ref = ref[1:]
-
-        github_folder = f"{repo}-{ref}"
-
-        if github_folder in os.listdir(data_path):
-            # This moves all files one level up
-            git_path = os.path.join(data_path, github_folder)
-            for data_file in os.listdir(git_path):
-                shutil.move(os.path.join(git_path, data_file), data_path)
-            os.removedirs(git_path)
-
-
 def path_from_python(chip, python_package, append_path=None):
     try:
         module = importlib.import_module(python_package)

siliconcompiler/package/git.py

@@ -0,0 +1,81 @@
+import shutil
+
+import os.path
+
+from git import Repo, GitCommandError
+from fasteners import InterProcessLock
+
+from siliconcompiler.package import get_download_cache_path
+from siliconcompiler.package import aquire_data_lock, release_data_lock
+
+
+def get_resolver(url):
+    if url.scheme in ("git", "git+https", "git+ssh", "ssh"):
+        return git_resolver
+    return None
+
+
+def git_resolver(chip, package, path, ref, url):
+    data_path, data_path_lock = get_download_cache_path(chip, package, ref)
+
+    # Acquire lock
+    data_lock = InterProcessLock(data_path_lock)
+    aquire_data_lock(data_path, data_lock)
+
+    if os.path.exists(data_path):
+        try:
+            repo = Repo(data_path)
+            if repo.untracked_files or repo.index.diff("HEAD"):
+                chip.logger.warning('The repo of the cached data is dirty.')
+            release_data_lock(data_lock)
+            return data_path, False
+        except GitCommandError:
+            chip.logger.warning('Deleting corrupted cache data.')
+            shutil.rmtree(data_path)
+
+    clone_synchronized(chip, package, path, ref, url, data_path)
+
+    release_data_lock(data_lock)
+
+    return data_path, True
+
+
+def clone_synchronized(chip, package, path, ref, url, data_path):
+    try:
+        clone_from_git(chip, package, path, ref, url, data_path)
+    except GitCommandError as e:
+        if 'Permission denied' in repr(e):
+            if url.scheme in ['ssh', 'git+ssh']:
+                chip.logger.error('Failed to authenticate. Please setup your git ssh.')
+            elif url.scheme in ['git', 'git+https']:
+                chip.logger.error('Failed to authenticate. Please use a token or ssh.')
+        else:
+            chip.logger.error(str(e))
+
+
+def clone_from_git(chip, package, path, ref, url, data_path):
+    if url.scheme in ['git', 'git+https'] and url.username:
+        chip.logger.warning('Your token is in the data source path and will be stored in the '
+                            'schema. If you do not want this set the env variable GIT_TOKEN '
+                            'or use ssh for authentication.')
+    if url.scheme in ['git+ssh']:
+        chip.logger.info(f'Cloning {package} data from {url.netloc}:{url.path[1:]}')
+        # Git requires the format git@github.com:org/repo instead of git@github.com/org/repo
+        repo = Repo.clone_from(f'{url.netloc}/{url.path[1:]}',
+                               data_path,
+                               recurse_submodules=True)
+    elif url.scheme in ['ssh']:
+        chip.logger.info(f'Cloning {package} data from {path}')
+        repo = Repo.clone_from(path,
+                               data_path,
+                               recurse_submodules=True)
+    else:
+        if os.environ.get('GIT_TOKEN') and not url.username:
+            url = url._replace(netloc=f'{os.environ.get("GIT_TOKEN")}@{url.hostname}')
+        url = url._replace(scheme='https')
+        chip.logger.info(f'Cloning {package} data from {url.geturl()}')
+        repo = Repo.clone_from(url.geturl(), data_path, recurse_submodules=True)
+    chip.logger.info(f'Checking out {ref}')
+    repo.git.checkout(ref)
+    for submodule in repo.submodules:
+        submodule.update(init=True)

siliconcompiler/package/https.py

@@ -0,0 +1,93 @@
+import requests
+import shutil
+import tarfile
+import zipfile
+
+import os.path
+
+from fasteners import InterProcessLock
+from io import BytesIO
+from urllib.parse import urlparse
+
+from siliconcompiler import SiliconCompilerError
+from siliconcompiler.package import get_download_cache_path
+from siliconcompiler.package import aquire_data_lock, release_data_lock
+
+
+def get_resolver(url):
+    if url.scheme in ("http", "https"):
+        return http_resolver
+
+    return None
+
+
+def http_resolver(chip, package, path, ref, url):
+    data_path, data_path_lock = get_download_cache_path(chip, package, ref)
+
+    if os.path.exists(data_path):
+        return data_path, False
+
+    # Acquire lock
+    data_lock = InterProcessLock(data_path_lock)
+    aquire_data_lock(data_path, data_lock)
+
+    extract_from_url(chip, package, path, ref, url, data_path)
+
+    release_data_lock(data_lock)
+
+    return data_path, True
+
+
+def extract_from_url(chip, package, path, ref, url, data_path):
+    data_url = path
+    headers = {}
+    if os.environ.get('GIT_TOKEN') or url.username:
+        headers['Authorization'] = f'token {os.environ.get("GIT_TOKEN") or url.username}'
+    if "github" in data_url:
+        headers['Accept'] = 'application/octet-stream'
+    data_url = path
+    if data_url.endswith('/'):
+        data_url = f"{data_url}{ref}.tar.gz"
+    chip.logger.info(f'Downloading {package} data from {data_url}')
+    response = requests.get(data_url, stream=True, headers=headers)
+    if not response.ok:
+        raise SiliconCompilerError(f'Failed to download {package} data source.', chip=chip)
+
+    fileobj = BytesIO(response.content)
+    try:
+        with tarfile.open(fileobj=fileobj, mode='r|gz') as tar_ref:
+            tar_ref.extractall(path=data_path)
+    except tarfile.ReadError:
+        fileobj.seek(0)
+        # Try as zip
+        with zipfile.ZipFile(fileobj) as zip_ref:
+            zip_ref.extractall(path=data_path)
+
+    if 'github' in url.netloc and len(os.listdir(data_path)) == 1:
+        # Github inserts one folder at the highest level of the tar file
+        # this compensates for this behavior
+        gh_url = urlparse(data_url)
+
+        repo = gh_url.path.split('/')[2]
+
+        gh_ref = gh_url.path.split('/')[-1]
+        if repo.endswith('.git'):
+            gh_ref = ref
+        elif gh_ref.endswith('.tar.gz'):
+            gh_ref = gh_ref[0:-7]
+        elif gh_ref.endswith('.tgz'):
+            gh_ref = gh_ref[0:-4]
+        else:
+            gh_ref = gh_ref.split('.')[0]
+
+        if gh_ref.startswith('v'):
+            gh_ref = gh_ref[1:]
+
+        github_folder = f"{repo}-{gh_ref}"
+
+        if github_folder in os.listdir(data_path):
+            # This moves all files one level up
+            git_path = os.path.join(data_path, github_folder)
+            for data_file in os.listdir(git_path):
+                shutil.move(os.path.join(git_path, data_file), data_path)
+            os.removedirs(git_path)

siliconcompiler/scheduler/__init__.py

@@ -1865,6 +1865,22 @@ def kill_process(chip, proc, tool, poll_interval, msg=""):
         utils.terminate_process(proc.pid)
 
 
+def get_check_node_keys(chip, step, index):
+    tool, task = get_tool_task(chip, step, index)
+
+    # Collect keys to check for changes
+    required = chip.get('tool', tool, 'task', task, 'require', step=step, index=index)
+
+    tool_task_key = ('tool', tool, 'task', task)
+    for key in ('option', 'threads', 'prescript', 'postscript', 'refdir', 'script',):
+        required.append(",".join([*tool_task_key, key]))
+
+    for env_key in chip.getkeys(*tool_task_key, 'env'):
+        required.append(",".join([*tool_task_key, 'env', env_key]))
+
+    return set(sorted(required))
+
+
 def check_node_inputs(chip, step, index):
     from siliconcompiler import Chip  # import here to avoid circular import
 
@@ -1918,15 +1934,8 @@ def check_node_inputs(chip, step, index):
         return False
 
     # Collect keys to check for changes
-    required = chip.get('tool', tool, 'task', task, 'require', step=step, index=index)
-    required.extend(input_chip.get('tool', tool, 'task', task, 'require', step=step, index=index))
-
-    tool_task_key = ('tool', tool, 'task', task)
-    for key in ('option', 'threads', 'prescript', 'postscript', 'refdir', 'script',):
-        required.append(",".join([*tool_task_key, key]))
-    for check_chip in (chip, input_chip):
-        for env_key in check_chip.getkeys(*tool_task_key, 'env'):
-            required.append(",".join([*tool_task_key, 'env', env_key]))
+    required = get_check_node_keys(chip, step, index)
+    required.update(get_check_node_keys(input_chip, step, index))
 
     def print_warning(key, extra=None):
         if extra:
@@ -1937,7 +1946,7 @@ def check_node_inputs(chip, step, index):
                                 'from previous run')
 
     # Check if keys have been modified
-    for check_key in sorted(set(required)):
+    for check_key in required:
         key = check_key.split(',')
 
         if not chip.valid(*key) or not input_chip.valid(*key):

siliconcompiler/scheduler/docker_runner.py

@@ -1,7 +1,7 @@
 import docker
 import os
 from siliconcompiler.package import get_cache_path
-from siliconcompiler.package import _path as sc_path
+from siliconcompiler.package import path as sc_path
 from siliconcompiler.utils import default_email_credentials_file
 from pathlib import Path
 import sys
@@ -47,7 +47,7 @@ def get_volumes_directories(chip, cache_dir, workdir, step, index):
 
     # Collect caches
     for package in chip.getkeys('package', 'source'):
-        all_dirs.add(sc_path(chip, package, None))
+        all_dirs.add(sc_path(chip, package))
 
     all_dirs = [
         Path(cache_dir),
@@ -215,7 +215,7 @@ def run(chip, step, index, replay):
 
         cachemap = []
         for package in chip.getkeys('package', 'source'):
-            cachemap.append(f'{package}:{sc_path(chip, package, None)}')
+            cachemap.append(f'{package}:{sc_path(chip, package)}')
 
         chip.logger.info(f'Running in docker container: {container.name} ({container.short_id})')
         args = [

siliconcompiler/scheduler/run_node.py

@@ -5,7 +5,7 @@ import os
 import sys
 import tarfile
 from siliconcompiler import Chip, Schema
-from siliconcompiler.package import _path as sc_path
+from siliconcompiler.package import path as sc_path
 from siliconcompiler.scheduler import _runtask, _executenode
 from siliconcompiler import __version__
 
@@ -103,9 +103,9 @@ def main():
             package, path = cachepair.split(':')
             chip._packages[package] = path
 
-    # Populate cache without downloading
+    # Populate cache
     for package in chip.getkeys('package', 'source'):
-        sc_path(chip, package, None)
+        sc_path(chip, package)
 
     # Run the task.
     error = True

siliconcompiler/schema/schema_obj.py

@@ -1092,6 +1092,10 @@ class Schema:
 
         tcl_set_cmds = []
         for key in self.allkeys():
+            # print out all non default values
+            if 'default' in key:
+                continue
+
             typestr = self.get(*key, field='type')
             pernode = self.get(*key, field='pernode')
 
@@ -1110,19 +1114,11 @@ class Schema:
 
             valstr = escape_val_tcl(value, typestr)
 
-            # Turning scalars into lists
-            if not (typestr.startswith('[') or typestr.startswith('(')):
-                valstr = f'[list {valstr}]'
-
-            # TODO: Temp fix to get rid of empty args
+            # Ensure empty values get something
             if valstr == '':
-                valstr = '[list ]'
-
-            outstr = f"{prefix} {keystr} {valstr}"
+                valstr = '{}'
 
-            # print out all non default values
-            if 'default' not in key:
-                tcl_set_cmds.append(outstr)
+            tcl_set_cmds.append(f"{prefix} {keystr} {valstr}")
 
         if template:
             fout.write(template.render(manifest_dict='\n'.join(tcl_set_cmds),

siliconcompiler/templates/tcl/manifest.tcl.j2

@@ -34,7 +34,7 @@ proc sc_cfg_exists { args } {
 
 proc sc_top {} {
     set sc_entrypoint [sc_cfg_get option entrypoint]
-    if {$sc_entrypoint == ""} {
+    if {$sc_entrypoint == {{ '{}' }}} {
         return [sc_cfg_get design]
     }
     return $sc_entrypoint

siliconcompiler/tools/_common/tcl/sc_pin_constraints.tcl

@@ -15,22 +15,20 @@ proc sc_collect_pin_constraints {
         set side [dict get $params side]
         set place [dict get $params placement]
 
-        if { [llength $place] != 0 } {
+        if { $place != {} } {
             # Pin has placement information
-            if { [llength $order] != 0 } {
+            if { $order != {} } {
                 # Pin also has order information
                 $print_func "Pin $name has placement specified in constraints, but also order."
             }
             lappend placement_pins $name
         } else {
             # Pin doesn't have placement
-            if { [llength $side] == 0 || [llength $order] == 0 } {
+            if { $side == {} || $order == {} } {
                 # Pin information is incomplete
                 $print_func \
                     "Warning: Pin $name doesn't have enough information to perform placement."
             } else {
-                set side [lindex $side 0]
-                set order [lindex $order 0]
                 if { ![dict exists $pin_order $side $order] } {
                     dict set pin_order $side $order []
                 }

siliconcompiler/tools/genfasm/genfasm.py

@@ -24,7 +24,7 @@ def make_docs(chip):
 def setup(chip):
     chip.set('tool', 'genfasm', 'exe', 'genfasm', clobber=False)
     chip.set('tool', 'genfasm', 'vswitch', '--version')
-    chip.set('tool', 'genfasm', 'version', '>=8.1.0', clobber=False)
+    chip.set('tool', 'genfasm', 'version', '>=9.0.0', clobber=False)
 
     add_tool_requirements(chip)
 

siliconcompiler/tools/openroad/rdlroute.py

@@ -75,6 +75,10 @@ def setup(chip):
                              'if enabled by the PDK, to the design',
                       skip='lib')
 
+    chip.set('tool', tool, 'task', task, 'var', 'debug_level',
+             'list of "tool key level" to enable debugging of OpenROAD',
+             field='help')
+
     if f'{design}.v' in input_provides(chip, step, index):
         chip.add('tool', tool, 'task', task, 'input', design + '.v', step=step, index=index)
     elif f'{design}.vg' in input_provides(chip, step, index):

siliconcompiler/tools/openroad/scripts/apr/sc_init_floorplan.tcl

@@ -121,11 +121,11 @@ if { [sc_cfg_exists constraint pin] } {
         global sc_vpinmetal
 
         set layer [sc_cfg_get constraint pin $pin layer]
-        if { [llength $layer] != 0 } {
-            return [sc_get_layer_name [lindex $layer 0]]
+        if { $layer != {} } {
+            return [sc_get_layer_name $layer]
         }
         set side [sc_cfg_get constraint pin $pin side]
-        if { [llength $side] != 0 } {
+        if { $side != {} } {
             switch -regexp $side {
                 "1|3" {
                     return [lindex $sc_hpinmetal 0]

siliconcompiler/tools/openroad/scripts/sc_rdlroute.tcl

@@ -35,21 +35,11 @@ set sc_threads [sc_cfg_tool_task_get threads]
 # MACROS
 set sc_macrolibs [sc_get_asic_libraries macro]
 
-###############################
-# Suppress messages if requested
+##############################
+# Setup debugging
 ###############################
 
-foreach msg [sc_cfg_tool_task_get warningoff] {
-    set or_msg [split $msg "-"]
-    if { [llength $or_msg] != 2 } {
-        utl::warn FLW 1 "$msg is not a valid message id"
-    } else {
-        set or_tool [lindex $or_msg 0]
-        set or_msg_id [expr { int([lindex $or_msg 1]) }]
-        utl::info FLW 1 "Suppressing $msg messages"
-        suppress_message $or_tool $or_msg_id
-    }
-}
+source -echo "$sc_refdir/common/debugging.tcl"
 
 ###############################
 # Source helper functions

siliconcompiler/tools/vpr/vpr.py

@@ -16,6 +16,7 @@ Sources: https://github.com/verilog-to-routing/vtr-verilog-to-routing
 Installation: https://github.com/verilog-to-routing/vtr-verilog-to-routing
 '''
 
+import glob
 import os
 import shutil
 import json
@@ -42,7 +43,7 @@ def setup_tool(chip, clobber=True):
 
     chip.set('tool', 'vpr', 'exe', 'vpr', clobber=clobber)
     chip.set('tool', 'vpr', 'vswitch', '--version')
-    chip.set('tool', 'vpr', 'version', '>=8.1.0', clobber=clobber)
+    chip.set('tool', 'vpr', 'version', '>=9.0.0', clobber=clobber)
 
     step = chip.get('arg', 'step')
     index = chip.get('arg', 'index')
@@ -80,6 +81,16 @@ def add_tool_requirements(chip):
     chip.add('tool', tool, 'task', task, 'require', f'fpga,{part_name},var,vpr_device_code',
              step=step, index=index)
 
+    chip.set('tool', tool, 'task', task, 'var', 'timing_paths',
+             'number of timing paths to report', field='help')
+    chip.set('tool', tool, 'task', task, 'var', 'timing_paths', '20',
+             step=step, index=index, clobber=False)
+
+    chip.set('tool', tool, 'task', task, 'var', 'timing_report_type',
+             'type of timing report', field='help')
+    chip.set('tool', tool, 'task', task, 'var', 'timing_report_type', 'aggregated',
+             step=step, index=index, clobber=False)
+
 
 def runtime_options(chip):
 
@@ -163,13 +174,22 @@ def runtime_options(chip):
                 'vpr_clock model must be set to ideal, route, or dedicated_clock_network',
                 chip=chip)
 
+    sdc_file = None
     if chip.valid('input', 'constraint', 'sdc'):
         sdc_file = find_single_file(chip, 'input', 'constraint', 'sdc',
                                     step=step, index=index,
                                     file_not_found_msg="SDC file not found")
-        if (sdc_file is not None):
-            sdc_arg = f"--sdc_file {sdc_file}"
-            options.append(sdc_arg)
+
+    if sdc_file:
+        sdc_arg = f"--sdc_file {sdc_file}"
+        options.append(sdc_arg)
+
+        report_type = chip.get('tool', tool, 'task', task, 'var', 'timing_report_type',
+                               step=step, index=index)[0]
+        options.append(f'--timing_report_detail {report_type}')
+        report_paths = chip.get('tool', tool, 'task', task, 'var', 'timing_paths',
+                                step=step, index=index)[0]
+        options.append(f'--timing_report_npaths {report_paths}')
     else:
         options.append("--timing_analysis off")
 
@@ -295,8 +315,8 @@ def vpr_post_process(chip):
     step = chip.get('arg', 'step')
     index = chip.get('arg', 'index')
 
-    if os.path.exists('packing_pin_util.rpt'):
-        shutil.move('packing_pin_util.rpt', 'reports')
+    for report in glob.glob("*.rpt"):
+        shutil.move(report, 'reports')
 
     part_name = chip.get('fpga', 'partname')
     dff_cells = []
@@ -379,6 +399,66 @@ def vpr_post_process(chip):
 
             record_metric(chip, step, index, "pins", io, __block_file)
 
+    for setup_report in ("reports/report_timing.setup.rpt",
+                         "reports/pre_pack.report_timing.setup.rpt"):
+        if not os.path.exists(setup_report):
+            continue
+
+        slack = _parse_timing_report(setup_report)
+        if slack is not None:
+            wns = min([slack, 0])
+            record_metric(chip, step, index, "setupslack", slack, setup_report, source_unit="ns")
+            record_metric(chip, step, index, "setupwns", wns, setup_report, source_unit="ns")
+            break
+
+    for hold_report in ("reports/report_timing.hold.rpt", ):
+        if not os.path.exists(hold_report):
+            continue
+
+        slack = _parse_timing_report(hold_report)
+        if slack is not None:
+            wns = min([slack, 0])
+            record_metric(chip, step, index, "holdslack", slack, hold_report, source_unit="ns")
+            record_metric(chip, step, index, "holdwns", wns, hold_report, source_unit="ns")
+            break
+
+    unconstrained = None
+    unconstrained_reports = []
+    for unconstrained_report in ("reports/report_unconstrained_timing.hold.rpt",
+                                 "reports/report_unconstrained_timing.setup.rpt"):
+        if not os.path.exists(unconstrained_report):
+            continue
+
+        paths = _parse_unconstrained_report(unconstrained_report)
+        if unconstrained is None:
+            unconstrained = paths
+
+        unconstrained = max([paths, unconstrained])
+        unconstrained_reports.append(unconstrained_report)
+
+    if unconstrained is not None:
+        record_metric(chip, step, index, "unconstrained", unconstrained, unconstrained_reports)
+
+
+def _parse_timing_report(report):
+    slack = re.compile(r"slack \(.*\)\s+(-?\d+\.?\d*)")
+    with sc_open(report) as f:
+        for line in f:
+            match_slack = slack.findall(line)
+            if match_slack:
+                return float(match_slack[0])
+    return None
+
+
+def _parse_unconstrained_report(report):
+    path = re.compile(r"\d+ .*")
+    count = 0
+    with sc_open(report) as f:
+        for line in f:
+            if path.match(line):
+                count += 1
+    return count
+
 
 ##################################################
 if __name__ == "__main__":

siliconcompiler/toolscripts/_tools.json

@@ -1,7 +1,7 @@
 {
   "openroad": {
     "git-url": "https://github.com/The-OpenROAD-Project/OpenROAD.git",
-    "git-commit": "6e6fccbbe0ffbe683a51de3ecac2a24958a53fa1",
+    "git-commit": "1d7f91584c040b73089e415ec12fd806da1c1161",
     "docker-cmds": [
       "# Remove OR-Tools files",
       "RUN rm -f $SC_PREFIX/Makefile $SC_PREFIX/README.md",
@@ -66,7 +66,7 @@
   },
   "vpr": {
     "git-url": "https://github.com/verilog-to-routing/vtr-verilog-to-routing.git",
-    "git-commit": "de31f094aa4f894a5e6e0dc32c66365f4b341190",
+    "git-commit": "v9.0.0",
     "auto-update": false
   },
   "icepack": {
@@ -139,7 +139,7 @@
   },
   "yosys-slang": {
     "git-url": "https://github.com/povik/yosys-slang.git",
-    "git-commit": "0adba99ea43331235506b9b154c78a401f4fe9b6",
+    "git-commit": "8f2239b2b12dac43f8f47f56deef1095d5262fa2",
     "docker-depends": "yosys",
     "auto-update": true
   },

{siliconcompiler-0.31.0.dist-info → siliconcompiler-0.31.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: siliconcompiler
-Version: 0.31.0
+Version: 0.31.1
 Summary: A compiler framework that automates translation from source code to silicon.
 Author-email: Andreas Olofsson <andreas.d.olofsson@gmail.com>
 License: Apache License 2.0
@@ -99,19 +99,19 @@ SiliconCompiler is a modular hardware build system ("make for silicon"). The pro
 
 | Type | Supported|
 |------|----------|
-|**Design Languages**| C, Verilog, SV, VHDL, Chisel, Migen/Amaranth, Bluespec
+|**Design Languages**| C, Verilog, SV, VHDL, Chisel, Migen/Amaranth, Bluespec, [MLIR](https://en.wikipedia.org/wiki/MLIR_(software))
 |**Simulation Tools**| Verilator, Icarus, GHDL, Xyce
 |**Synthesis**| Yosys, Vivado, Synopsys, Cadence
-|**ASIC APR**| OpenRoad, Synopsys, Cadence
+|**ASIC APR**| OpenROAD, Synopsys, Cadence
 |**FPGA APR**| VPR, nextpnr, Vivado
-|**Layout Viewer**| Klayout, OpenRoad, Cadence, Synopsys
-|**DRC/LVS**| Magic, Synopsys, Siemens
-|**PDKs**| sky130, gf180, asap7, freepdk45, gf12lp, gf22fdx, intel16, ihp130
+|**Layout Viewer**| Klayout, OpenROAD, Cadence, Synopsys
+|**DRC/LVS**| Klayout, Magic, Synopsys, Siemens
+|**PDKs**| sky130, ihp130, gf180, asap7, freepdk45, gf12lp, gf22fdx, intel16
 
 # Getting Started
 
 SiliconCompiler is available as wheel packages on PyPI for macOS, Windows and
-Linux platforms. For working Python 3.8-3.12 environment, just use pip.
+Linux platforms. For working Python 3.8-3.13 environment, just use pip.
 
 ```sh
 python3 -m pip install --upgrade siliconcompiler
@@ -166,17 +166,15 @@ A. Olofsson, W. Ransohoff, N. Moroze, "[Invited: A Distributed Approach to Silic
 Bibtex:
 ```
 @inproceedings{10.1145/3489517.3530673,
-author = {Olofsson, Andreas and Ransohoff, William and Moroze, Noah},
-title = {A Distributed Approach to Silicon Compilation: Invited},
-year = {2022},
-booktitle = {Proceedings of the 59th ACM/IEEE Design Automation Conference},
-pages = {1343–1346},
-location = {San Francisco, California}
+  author = {Olofsson, Andreas and Ransohoff, William and Moroze, Noah},
+  title = {A Distributed Approach to Silicon Compilation: Invited},
+  year = {2022},
+  booktitle = {Proceedings of the 59th ACM/IEEE Design Automation Conference},
+  pages = {1343–1346},
+  location = {San Francisco, California}
 }
 ```
 
-
-
 # Installation
 
 Complete installation instructions are available in the [Installation Guide](https://docs.siliconcompiler.com/en/stable/user_guide/installation.html).
@@ -194,14 +192,14 @@ python3 -m pip install -e .[docs,test]  # Optional install step for generating d
 
 Installation instructions for all external tools can be found in the
 [External Tools](https://docs.siliconcompiler.com/en/stable/user_guide/installation.html#external-tools) section
-of the user guide. We have included shell setup scripts (Ubuntu) for most of the supported tools.
+of the user guide. We have included shell setup scripts (Ubuntu) for most of the supported tools, which can be accessed via [sc-install](https://docs.siliconcompiler.com/en/latest/reference_manual/apps.html#apps-sc-install-ref).
 See the [./siliconcompiler/toolscripts](./siliconcompiler/toolscripts) directory for a complete set of scripts and [./siliconcompiler/toolscripts/_tools.json](./siliconcompiler/toolscripts/_tools.json) for the currently recommended tool versions.
 
 # Contributing
 
 SiliconCompiler is an open-source project and welcomes contributions. To find out
 how to contribute to the project, see our
-[Contributing Guidelines.](./CONTRIBUTING.md)
+[Contributing Guidelines](./CONTRIBUTING.md).
 
 # Issues / Bugs
 

{siliconcompiler-0.31.0.dist-info → siliconcompiler-0.31.1.dist-info}/RECORD

@@ -1,18 +1,17 @@
 siliconcompiler/__init__.py,sha256=Ke_Bcryj9N6MoUq_5z_IDW3qMrUzR-3-kJVsvUenYzY,511
 siliconcompiler/__main__.py,sha256=JwWkcvaNngqgMWprEQ1cFy2Wdq9GMvk46UGTHyh_qvM,170
 siliconcompiler/_common.py,sha256=c6r0SbI2xTpNOZayFsyCDo0riJGNJSPN-0zW8R7rDBI,1488
-siliconcompiler/_metadata.py,sha256=jCk7lB0BP8YDprLuf_4ZDvPTCIZ7fKMgczTWTb2Foyw,1264
-siliconcompiler/core.py,sha256=qOJukvP4UxT4NJ_lKQDnAPNey0orJ3QTMNuB-f15Urs,139775
+siliconcompiler/_metadata.py,sha256=i_Lo3T11LBCBNlSyyLdOKcVrSbKRGv-UmYl4l1ROY4w,1264
+siliconcompiler/core.py,sha256=CA7SEpDkVHucYaD8c8tctObqtep3cEcasJN1SmESMxg,139774
 siliconcompiler/flowgraph.py,sha256=Z_c4DEh1JvHE_u0O2M2Y1_dn6aGOAECX-HzrIjn0ky4,22084
 siliconcompiler/issue.py,sha256=9ZpdEBh8QB56-bZ1YXRnjqgg9hwnFty2u1o5oI66W7M,11125
-siliconcompiler/package.py,sha256=RvFbX51o77j0fwNdFueKwsO-lqWWJsjzjFSdUGZd-jU,14123
 siliconcompiler/units.py,sha256=SHQWTKuiaYHqqTbhspsED0gw-4Lb7f5VKunWy9dhS3s,5810
 siliconcompiler/use.py,sha256=t5TodYt9tkYjNIdB6Ak-P3Gf2dgpX9Q-WXGBTLtVdQo,6058
 siliconcompiler/apps/__init__.py,sha256=6LuAljPtVB6g5yXl_58ODoB4Svb6UfKaDbX1e0aNZfE,668
 siliconcompiler/apps/_common.py,sha256=Ph-cD-t9lCzavak3s4YCXXmA_ouf-jJ-7WIEGkSsjOg,3770
 siliconcompiler/apps/sc.py,sha256=DAhhyfpHEN0mDmQ3YcFWpGk7R64OEpguZ2QCEFGxyr4,3235
 siliconcompiler/apps/sc_dashboard.py,sha256=kGyMYbgKgZMBUrTyft6mEvRnmcrKA7JunrkWZ8VwSwM,3478
-siliconcompiler/apps/sc_install.py,sha256=duwi5ypm1V9K0xbhzNXzaYF7kZWNXuQcvMi0ZEM2h8M,8104
+siliconcompiler/apps/sc_install.py,sha256=qz6Dni7HcYrl9V7mDk2hqMYY4BwqRceNb-Gd2UE5zzk,8569
 siliconcompiler/apps/sc_issue.py,sha256=PUXFWne6MWY0Ntak3PnMZ84tpEZ5S1Pta5B3AkxMdoY,6404
 siliconcompiler/apps/sc_remote.py,sha256=vMdh9LdFJ-0vFzYMFttcERXCFwzNMmAQyXPIxoNCmhg,7168
 siliconcompiler/apps/sc_server.py,sha256=d3SCfKtNneIBiAk7Udc5SqXvSIoFSK40iHWcKuY7unk,894
@@ -48,6 +47,9 @@ siliconcompiler/fpgas/vpr_example.py,sha256=xcTgCvxSadcBnYVrglAi5XM4nn_raXWFvr_o
 siliconcompiler/libs/__init__.py,sha256=KXw1vU0KP83fg3rB8iKkpDhJZBLz_PWGZG65L3lAQ1Q,86
 siliconcompiler/optimizer/__init__.py,sha256=wdSuv3U7hoSdZn-TkaQtYehVdhS5F35Mb1McgaUw3hc,6599
 siliconcompiler/optimizer/vizier.py,sha256=-JF3E28SLhfkjluz2R5dFnjg5NjU1z7Okb-K_ZK9H3s,9035
+siliconcompiler/package/__init__.py,sha256=Dg_GBWERdCGRPjBNxcUHBB8Zf2ns-PgLy2Xqo0tARVw,9054
+siliconcompiler/package/git.py,sha256=L6J7H8s8LNdhrhlhuEw0eU4nHx7o6iOIjIf91OcmX80,3200
+siliconcompiler/package/https.py,sha256=8jXjNUA21p4fMW9WVbystk_HZTc0KgUUiIwfq-ziuk0,2919
 siliconcompiler/pdks/__init__.py,sha256=bWhtNR-Kq3fEyknon-x5vQX877b88g9EJXAHBMiDyGM,81
 siliconcompiler/remote/__init__.py,sha256=MoYnC1lkgbT5hN5Qi-0gTItaTWI2U1E8OuleffdTDSQ,977
 siliconcompiler/remote/client.py,sha256=qwZaKSt-ScYjfBFpL9Np9Z0nDytYRJHgvNJnrXHGhok,32848
@@ -87,16 +89,16 @@ siliconcompiler/report/dashboard/layouts/vertical_flowgraph_node_tab.py,sha256=0
 siliconcompiler/report/dashboard/layouts/vertical_flowgraph_sac_tabs.py,sha256=g6lrnXJVEkTh7OQY1xCgl_q0So0XewItuY0sjnjaBCA,4086
 siliconcompiler/report/dashboard/utils/__init__.py,sha256=mkcBAlfPovfgoRv9nPbtgQSeFglwlxlSIXsEQmdsDz8,2540
 siliconcompiler/report/dashboard/utils/file_utils.py,sha256=5MKAyf7TGXQIc3yxwbP1H6xi0NGwUfzu2j3LOv1Yei0,3333
-siliconcompiler/scheduler/__init__.py,sha256=6g_z6_2hd9FPNJ4kizzIY8u-9RdfSxMXQbewTYnRNY8,87167
-siliconcompiler/scheduler/docker_runner.py,sha256=VAyzVsVClOVD5-DY9zgRLl8O0ZBuwbeI3wf8SmEGk8E,8065
-siliconcompiler/scheduler/run_node.py,sha256=IWodOtT6b_MO5oXpEiF0th1Q3v7AD66jE182lY-aGv4,5063
+siliconcompiler/scheduler/__init__.py,sha256=goiNHGe41JjCKoMWIh6i3fcw9kuC7lXcAziA_bFeun4,87291
+siliconcompiler/scheduler/docker_runner.py,sha256=zeAPHgthkoR8ATY6zmV2kCJWpD13fuq2DCzzG66Ubm8,8052
+siliconcompiler/scheduler/run_node.py,sha256=XEY3SNIstK8SLnD7uiHmQ_9maCgdfTECQAJr5OT9rQI,5036
 siliconcompiler/scheduler/send_messages.py,sha256=mWmkfPVDEfzOawVq6At6fi0JgFkzyFNwAA29lYkN5Xw,6618
 siliconcompiler/scheduler/slurm.py,sha256=CAuN5xmiWhk_k3CW6yMe5iukex4CWxp5Ox6_qAzgV5Q,7097
 siliconcompiler/scheduler/validation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 siliconcompiler/scheduler/validation/email_credentials.json,sha256=hkJs0U2h2Bgm1zxeXvanIJ-prPhpn_aU6e3qwIs7qA0,1997
 siliconcompiler/schema/__init__.py,sha256=Gdny2AwDdg-X3RvghOHQYl3aG2alvMuK5CsSkFGKuYU,120
 siliconcompiler/schema/schema_cfg.py,sha256=oHE1hEgLFgU2r4sValymY_-84SCchU_6j0BGkXFwdjw,188876
-siliconcompiler/schema/schema_obj.py,sha256=Q8FOuZ1FFNhXszTX8vV-L_BXtV30L8U8CFzESScqDJ0,76339
+siliconcompiler/schema/schema_obj.py,sha256=BHMr00Et57iukxTI9hiJUHkhAw1LRbsWJcDCejeCBDg,76158
 siliconcompiler/schema/utils.py,sha256=qeAICnQuuzrcJSyotFGWA6gmunpu63AOaEtuhIcBi5c,4504
 siliconcompiler/sphinx_ext/__init__.py,sha256=nXMFqWewqjy8FZbExAp2wtVu8EmZ3cXKvomlpxnzKUE,1859
 siliconcompiler/sphinx_ext/dynamicgen.py,sha256=QwrigvFqj900Sud4qICNlKYAxqLQOxSvzqRKwNAz02o,34575
@@ -130,7 +132,7 @@ siliconcompiler/templates/report/sc_report.j2,sha256=azDmB57TVt_g0-lYchp3OVca1JL
 siliconcompiler/templates/slurm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 siliconcompiler/templates/slurm/run.sh,sha256=uXs91H0vjLB8G8vaezxXSr3XNR2EUiXH1dyfOSHYYnk,214
 siliconcompiler/templates/tcl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-siliconcompiler/templates/tcl/manifest.tcl.j2,sha256=XT2pKuPSaa2GPJj1IpEl3Al5N70yqQS8jZecmpyeV4o,3547
+siliconcompiler/templates/tcl/manifest.tcl.j2,sha256=mwH-deAUkYN3zOKS7g8l2R53nl2PnqR4EVaOQG5D-h0,3555
 siliconcompiler/tools/__init__.py,sha256=dulw1XiU58QYllrHuQU3hZOKyO4Hm_AQ-brSC9ZD5OY,1929
 siliconcompiler/tools/_common/__init__.py,sha256=erec5qPEXVJInHXT5fKbLDytQXx2y0-W6QmefKLeQ-8,15194
 siliconcompiler/tools/_common/asic.py,sha256=1pLODTy0fznHh3D9LpidWOz-MtqY4MouSFJUoP0uAV0,9084
@@ -138,7 +140,7 @@ siliconcompiler/tools/_common/asic_clock.py,sha256=JSd4Ne0TxISqcZGICNLQCVfPNdUYv
 siliconcompiler/tools/_common/sdc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 siliconcompiler/tools/_common/sdc/sc_constraints.sdc,sha256=Hz6OLebi14UTcfGXgJoNJeFo0BH_4N5XwjFe2mrey8g,2827
 siliconcompiler/tools/_common/tcl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-siliconcompiler/tools/_common/tcl/sc_pin_constraints.tcl,sha256=Q6L9hd3rP2h71dGoxWDAYyHSfgeja2JqNJpQhfvJGYw,2102
+siliconcompiler/tools/_common/tcl/sc_pin_constraints.tcl,sha256=PDuriCKS_jv6UkwWFL1EAhx5dew8tiwsqR4IPx6vhKM,1980
 siliconcompiler/tools/bambu/__init__.py,sha256=hodIBmILSE7xvfIc74r0Qc0dZI42TwHhrKmWLom-hc0,1159
 siliconcompiler/tools/bambu/convert.py,sha256=issKBrrQBs4aLxN-7F8xPNwKlDD4Kk-TxORFDCVNKPs,6026
 siliconcompiler/tools/bluespec/__init__.py,sha256=A9LGMUG7fconBkkeVRr_cXOpKQcib2Isc8hta0SJues,1150
@@ -163,7 +165,7 @@ siliconcompiler/tools/execute/exec_input.py,sha256=oYI4kfVxKN3RhFv2gg1uWW59Tqm5e
 siliconcompiler/tools/execute/execute.py,sha256=hzppu1rpNMNkqQK2KnuoIkjHzA2sijQO_QHzXeLdlZQ,525
 siliconcompiler/tools/genfasm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 siliconcompiler/tools/genfasm/bitstream.py,sha256=SNrilNrB5HiibBbsdK_J1CUaiq-DKJgLaSnvij081ig,1910
-siliconcompiler/tools/genfasm/genfasm.py,sha256=ysiFWhfoZ6F551dnE4BTgdbG7VHdCxwIAl_yjdiKGk8,1432
+siliconcompiler/tools/genfasm/genfasm.py,sha256=nHRSwL8JNDxMBYvr5nadJ0lXjdPq_o3X5eAdrZuiQps,1432
 siliconcompiler/tools/ghdl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 siliconcompiler/tools/ghdl/convert.py,sha256=OXwohmi30_4Bb_XiMFodKRVFL6W1V_H21ilEW0eHRtM,3008
 siliconcompiler/tools/ghdl/ghdl.py,sha256=E0YJtb6ounqnW34hpz_bpLCIeNFxF429DJMHswMs4xE,1186
@@ -228,14 +230,14 @@ siliconcompiler/tools/openroad/pin_placement.py,sha256=zuqqlsDJx9K_CvAsc8GkJP1yN
 siliconcompiler/tools/openroad/power_grid.py,sha256=CRoa1UEd3W8oJerT29zl1pRtz804IcNS_6sEAdQrfiM,2469
 siliconcompiler/tools/openroad/rcx_bench.py,sha256=6ASma7QGgM4Hk5oXYdDAR1BgElxhYN9L7RoDbQi9LBE,3655
 siliconcompiler/tools/openroad/rcx_extract.py,sha256=ANj46BR3bzlTlI-wl45hD0HODTGRd03SfsM7gnEDJsg,1338
-siliconcompiler/tools/openroad/rdlroute.py,sha256=xocIuor51xUHSvWFBwpqT9crC-nMShqaPEx5U1QoA48,3798
+siliconcompiler/tools/openroad/rdlroute.py,sha256=NNdqYYZRC9HMi_SkWMLPK-oTzv1bkXE8g14rHLKPUU8,3962
 siliconcompiler/tools/openroad/repair_design.py,sha256=Fty-8NUgt5VwxReVoDQj6KE3UWoj-Sc9F-8BDBIcybk,1596
 siliconcompiler/tools/openroad/repair_timing.py,sha256=1OwwLdhErWOyNNZBwcD02mMhBWRqbAQk6WUJc_NYpfI,1665
 siliconcompiler/tools/openroad/screenshot.py,sha256=76IEYFy2CkmvCRbRYND1H-xhF0Jgjmu96HgQE6ttZV4,1574
 siliconcompiler/tools/openroad/show.py,sha256=fABmvb9Y3bRwgvTorQR4w25ioCoLROvM0_VQlOTBap8,3874
 siliconcompiler/tools/openroad/write_data.py,sha256=-COViTockYNz6ik77dHy22GC0XrRIplnp-fOHHHhHUQ,5297
 siliconcompiler/tools/openroad/scripts/sc_rcx.tcl,sha256=eLbIVoKo9RgxZUcVAmkVMylxDUi7kSeIF1x518c_cZA,1254
-siliconcompiler/tools/openroad/scripts/sc_rdlroute.tcl,sha256=5levTU6FUwtURW_UfSfdki2zWnr15-5ixkhbNPE3rYw,4992
+siliconcompiler/tools/openroad/scripts/sc_rdlroute.tcl,sha256=_DLf65pt0A9slReRWnANVme0Djb2C6XYN6f5SiCdezk,4636
 siliconcompiler/tools/openroad/scripts/sc_show.tcl,sha256=JYgw9nRMqP-LzvS9ZAM-JzEy6XPvPvgPKDrPPm1WEoE,2657
 siliconcompiler/tools/openroad/scripts/apr/postamble.tcl,sha256=9CLpG_DLvRKMgFRQMR5xWSzGIF9QERIBMkKTxcDYaWA,1130
 siliconcompiler/tools/openroad/scripts/apr/preamble.tcl,sha256=K_ChMVU0Rs3bbB_xKsekw7XBPa-nHVrT9_Nqumbxm3s,2625
@@ -248,7 +250,7 @@ siliconcompiler/tools/openroad/scripts/apr/sc_fillercell_insertion.tcl,sha256=uc
 siliconcompiler/tools/openroad/scripts/apr/sc_fillmetal_insertion.tcl,sha256=Qk16mhbcVo1g4wBKjYwV4aNr2zAEFXsF8XnehA9xbWY,896
 siliconcompiler/tools/openroad/scripts/apr/sc_global_placement.tcl,sha256=I36F4XY0beyrf58HM0cwsPvTzI7kYV1lAdr7ENHrEb4,2608
 siliconcompiler/tools/openroad/scripts/apr/sc_global_route.tcl,sha256=oeA0DUEWQa0iq_LIivUH0z8InIP_pdvg8gRf71G62GQ,2252
-siliconcompiler/tools/openroad/scripts/apr/sc_init_floorplan.tcl,sha256=opvE_hbM6bXsKoTFE52ET_6DSw4WSowiTBcZvI-nk_E,10496
+siliconcompiler/tools/openroad/scripts/apr/sc_init_floorplan.tcl,sha256=uFJMPuANpbF_V871vdf1AOS6YdXc5Q1glIV8qc51QiU,10467
 siliconcompiler/tools/openroad/scripts/apr/sc_macro_placement.tcl,sha256=R8n5YNADrKZkLRnjdvPLISDtvkgJ1eSbhp8v05ypjiY,4774
 siliconcompiler/tools/openroad/scripts/apr/sc_metrics.tcl,sha256=Y3EtUBTT1XJIM6CgnXqGAoRg46GNYuMG3dJ6tw-2ShE,500
 siliconcompiler/tools/openroad/scripts/apr/sc_pin_placement.tcl,sha256=FpHZ7b88rH-sxlg0w9PpWrmAZIj3Q6yLNiEFFm9wzkw,1114
@@ -316,7 +318,7 @@ siliconcompiler/tools/vpr/place.py,sha256=A3yIngDtMIhx8MqgLefLAzONneXlYpb_yuzUYT
 siliconcompiler/tools/vpr/route.py,sha256=k4B5ZZuLov0_t-z3jlfp9tfxMzszozOtKLwqpa4lRss,4907
 siliconcompiler/tools/vpr/screenshot.py,sha256=5Ji6J9p0R0C7C9WkuCwLu2InGQpeCo_Ciif7wUXz9ng,1818
 siliconcompiler/tools/vpr/show.py,sha256=u6YNdtH6CL7C49CJqglGuS7r6HbftCQPK6wN4MmaIQ8,3161
-siliconcompiler/tools/vpr/vpr.py,sha256=tg6D_RqZXB7aRGnQInV01v92qnSFTwA7-3vB1x88s54,14641
+siliconcompiler/tools/vpr/vpr.py,sha256=8rD3AzjafPdPmX8zCm2rYSHDdTYiIKZe33SoDgsMO0o,17696
 siliconcompiler/tools/xdm/__init__.py,sha256=uEo7uTPRdoARmk0E5U8yQ_MZOntO-cWJfGb6_pPA0ZQ,729
 siliconcompiler/tools/xdm/convert.py,sha256=rlirszWfNs2x9KApd3AiKpx78B3bfQ5VVWv5Nk_LSuU,2371
 siliconcompiler/tools/xyce/__init__.py,sha256=YTSk-XGtviqthGmGHb6RCDEAIMUQ7ElYZjZzpa1aSBg,1297
@@ -338,7 +340,7 @@ siliconcompiler/tools/yosys/techmaps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeu
 siliconcompiler/tools/yosys/techmaps/lcu_kogge_stone.v,sha256=M4T-ygiKmlsprl5eGGLaV5w6HVqlEepn0wlUDmOkapg,773
 siliconcompiler/tools/yosys/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 siliconcompiler/tools/yosys/templates/abc.const,sha256=TAq9ThdLMYCJGrtToEU0gWcLuEtjE4Gk8huBbTm1v-I,116
-siliconcompiler/toolscripts/_tools.json,sha256=arJyD3ThQSrDf28IeUSeqV9fhz1xzRbq4OS2J9wTR-0,4437
+siliconcompiler/toolscripts/_tools.json,sha256=EKdv-EQ_xdD3AacY73aM4sr39gtDY71zOcffQOriQ44,4403
 siliconcompiler/toolscripts/_tools.py,sha256=P30KY_xbbjl8eHGsPAxDcAzWvJJpiL07ZfGZZDQbdR8,7174
 siliconcompiler/toolscripts/rhel8/install-chisel.sh,sha256=lPORZN7vlBX6sJSv01JOIiDE9-_7GcCZGA7EP5ri3MQ,525
 siliconcompiler/toolscripts/rhel8/install-ghdl.sh,sha256=xCLeEUuJVI_6PVEvnTwBsTWoEHiQg0TY3x-tJXfg6Zk,459
@@ -454,9 +456,9 @@ siliconcompiler/utils/__init__.py,sha256=y4S1sRW2C3oYXN6PMZOHFO8-ytQ8yJvUoQtqKln
 siliconcompiler/utils/asic.py,sha256=cMLs7dneSmh5BlHS0-bZ1tLUpvghTw__gNaUCMpyBds,4986
 siliconcompiler/utils/logging.py,sha256=5tabLIVEftStGDeDulhfBdw4SFp5nHa4J3ZTJKHny8Q,2325
 siliconcompiler/utils/showtools.py,sha256=gaAvjMTFlx_0qLKOtpRJx8Bs51TEeQ-4Pjj8kHfFf3o,1871
-siliconcompiler-0.31.0.dist-info/LICENSE,sha256=lbLR6sRo_CYJOf7SVgHi-U6CZdD8esESEZE5TZazOQE,10766
-siliconcompiler-0.31.0.dist-info/METADATA,sha256=GQL9pDyXtimoItoCWY0CAUnXqkuAU8jxirT7NChqPoc,11257
-siliconcompiler-0.31.0.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-siliconcompiler-0.31.0.dist-info/entry_points.txt,sha256=asA4fgXLVcZtdoZ16bL4z8t229gnA6MxO_cFFlaBtGs,947
-siliconcompiler-0.31.0.dist-info/top_level.txt,sha256=H8TOYhnEUZAV1RJTa8JRtjLIebwHzkQUhA2wkNU2O6M,16
-siliconcompiler-0.31.0.dist-info/RECORD,,
+siliconcompiler-0.31.1.dist-info/LICENSE,sha256=lbLR6sRo_CYJOf7SVgHi-U6CZdD8esESEZE5TZazOQE,10766
+siliconcompiler-0.31.1.dist-info/METADATA,sha256=cHiZiRkjqUahZpw7pq-Sxrfr-mVrbVgiIG71F0swDjo,11462
+siliconcompiler-0.31.1.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+siliconcompiler-0.31.1.dist-info/entry_points.txt,sha256=69hHdWZQBugdza9dYdxodDySxmq6TgwpRYMeH2KfD4Q,1078
+siliconcompiler-0.31.1.dist-info/top_level.txt,sha256=H8TOYhnEUZAV1RJTa8JRtjLIebwHzkQUhA2wkNU2O6M,16
+siliconcompiler-0.31.1.dist-info/RECORD,,

{siliconcompiler-0.31.0.dist-info → siliconcompiler-0.31.1.dist-info}/entry_points.txt

@@ -19,6 +19,10 @@ pdks = siliconcompiler.sphinx_ext:pdks
 targets = siliconcompiler.sphinx_ext:targets
 tools = siliconcompiler.sphinx_ext:tools
 
+[siliconcompiler.path_resolver]
+git = siliconcompiler.package.git:get_resolver
+https = siliconcompiler.package.https:get_resolver
+
 [siliconcompiler.show]
 scsetup = siliconcompiler.utils.showtools:setup