siliconcompiler 0.34.1__py3-none-any.whl → 0.34.2__py3-none-any.whl

siliconcompiler/metrics/fpga.py

@@ -0,0 +1,220 @@
+from siliconcompiler import MetricSchema
+
+from siliconcompiler.schema import EditableSchema, Parameter, Scope, PerNode
+from siliconcompiler.schema.utils import trim
+
+
+class FPGAMetricsSchema(MetricSchema):
+    def __init__(self):
+        super().__init__()
+
+        schema = EditableSchema(self)
+
+        for item, description in [
+                ('unconstrained', 'unconstrained timing paths')]:
+            schema.insert(
+                item,
+                Parameter(
+                    'int',
+                    scope=Scope.JOB,
+                    shorthelp=f"Metric: total {item}",
+                    switch=f"-metric_{item} 'step index <int>'",
+                    example=[
+                        f"cli: -metric_{item} 'dfm 0 0'",
+                        f"api: chip.set('metric', '{item}', 0, step='dfm', index=0)"],
+                    pernode=PerNode.REQUIRED,
+                    help=trim(f"""Metric tracking the total number of {description} on a
+                    per step and index basis.""")))
+
+        for item, description in [
+                ('luts', 'FPGA LUTs used'),
+                ('dsps', 'FPGA DSP slices used'),
+                ('brams', 'FPGA BRAM tiles used')]:
+            schema.insert(
+                item,
+                Parameter(
+                    'int',
+                    scope=Scope.JOB,
+                    shorthelp=f"Metric: {description}",
+                    switch=f"-metric_{item} 'step index <int>'",
+                    example=[
+                        f"cli: -metric_{item} 'place 0 100'",
+                        f"api: chip.set('metric', '{item}', 100, step='place', index=0)"],
+                    pernode=PerNode.REQUIRED,
+                    help=trim(f"""
+                    Metric tracking the total {description} used by the design as reported
+                    by the implementation tool. There is no standardized definition
+                    for this metric across vendors, so metric comparisons can
+                    generally only be done between runs on identical tools and
+                    device families.""")))
+
+        schema.insert(
+            'utilization',
+            Parameter(
+                'float',
+                unit='%',
+                scope=Scope.JOB,
+                shorthelp="Metric: area utilization",
+                switch="-metric_utilization 'step index <float>'",
+                example=[
+                    "cli: -metric_utilization 'place 0 50.00'",
+                    "api: chip.set('metric', 'utilization', 50.00, step='place', index=0)"],
+                pernode=PerNode.REQUIRED,
+                help=trim("""
+                Metric tracking the area utilization of the design calculated as
+                100 * (cellarea/totalarea).""")))
+
+        schema.insert(
+            'logicdepth',
+            Parameter(
+                'int',
+                scope=Scope.JOB,
+                shorthelp="Metric: logic depth",
+                switch="-metric_logicdepth 'step index <int>'",
+                example=[
+                    "cli: -metric_logicdepth 'place 0 8'",
+                    "api: chip.set('metric', 'logicdepth', 8, step='place', index=0)"],
+                pernode=PerNode.REQUIRED,
+                help=trim("""
+                Metric tracking the logic depth of the design. This is determined
+                by the number of logic gates between the start of the critital timing
+                path to the end of the path.""")))
+
+        for item, description in [
+                ('peakpower', 'worst case total peak power'),
+                ('averagepower', 'average workload power'),
+                ('leakagepower', 'leakage power with rails active but without any dynamic '
+                                 'switching activity')]:
+            schema.insert(
+                item,
+                Parameter(
+                    'float',
+                    unit='mw',
+                    scope=Scope.JOB,
+                    shorthelp=f"Metric: {item}",
+                    switch=f"-metric_{item} 'step index <float>'",
+                    example=[
+                        f"cli: -metric_{item} 'place 0 0.01'",
+                        f"api: chip.set('metric', '{item}', 0.01, step='place', index=0)"],
+                    pernode=PerNode.REQUIRED,
+                    help=trim(f"""
+                    Metric tracking the {description} of the design specified on a per step
+                    and index basis. Power metric depend heavily on the method
+                    being used for extraction: dynamic vs static, workload
+                    specification (vcd vs saif), power models, process/voltage/temperature.
+                    The power {item} metric tries to capture the data that would
+                    usually be reflected inside a datasheet given the appropriate
+                    footnote conditions.""")))
+
+        for item, description in [
+                ('holdpaths', 'hold'),
+                ('setuppaths', 'setup')]:
+            schema.insert(
+                item,
+                Parameter(
+                    'int',
+                    scope=Scope.JOB,
+                    shorthelp=f"Metric: {item}",
+                    switch=f"-metric_{item} 'step index <int>'",
+                    example=[
+                        f"cli: -metric_{item} 'place 0 10'",
+                        f"api: chip.set('metric', '{item}', 10, step='place', index=0)"],
+                    pernode=PerNode.REQUIRED,
+                    help=trim(f"""
+                    Metric tracking the total number of timing paths violating {description}
+                    constraints.""")))
+
+        for item, description in [
+                ('holdslack', 'worst hold slack (positive or negative)'),
+                ('holdwns', 'worst negative hold slack (positive values truncated to zero)'),
+                ('holdtns', 'total negative hold slack (TNS)'),
+                ('holdskew', 'hold clock skew'),
+                ('setupslack', 'worst setup slack (positive or negative)'),
+                ('setupwns', 'worst negative setup slack (positive values truncated to zero)'),
+                ('setuptns', 'total negative setup slack (TNS)'),
+                ('setupskew', 'setup clock skew')]:
+            schema.insert(
+                item,
+                Parameter(
+                    'float',
+                    unit='ns',
+                    scope=Scope.JOB,
+                    shorthelp=f"Metric: {item}",
+                    switch=f"-metric_{item} 'step index <float>'",
+                    example=[
+                        f"cli: -metric_{item} 'place 0 0.01'",
+                        f"api: chip.set('metric', '{item}', 0.01, step='place', index=0)"],
+                    pernode=PerNode.REQUIRED,
+                    help=trim(f"""
+                    Metric tracking the {description} on a per step and index basis.""")))
+
+        for item, description in [
+                ('fmax', 'maximum clock frequency')]:
+            schema.insert(
+                item,
+                Parameter(
+                    'float',
+                    unit='Hz',
+                    scope=Scope.JOB,
+                    shorthelp=f"Metric: {item}",
+                    switch=f"-metric_{item} 'step index <float>'",
+                    example=[
+                        f"cli: -metric_{item} 'place 0 100e6'",
+                        f"api: chip.set('metric', '{item}', 100e6, step='place', index=0)"],
+                    pernode=PerNode.REQUIRED,
+                    help=trim(f"""
+                    Metric tracking the {description} on a per step and index basis.""")))
+
+        for item, description in [
+                ('macros', 'macros'),
+                ('cells', 'cell instances'),
+                ('registers', 'register instances'),
+                ('pins', 'pins'),
+                ('nets', 'nets')]:
+            schema.insert(
+                item,
+                Parameter(
+                    'int',
+                    scope=Scope.JOB,
+                    shorthelp=f"Metric: {item}",
+                    switch=f"-metric_{item} 'step index <int>'",
+                    example=[
+                        f"cli: -metric_{item} 'place 0 100'",
+                        f"api: chip.set('metric', '{item}', 50, step='place', index=0)"],
+                    pernode=PerNode.REQUIRED,
+                    help=trim(f"""
+                    Metric tracking the total number of {description} in the design
+                    on a per step and index basis.""")))
+
+        schema.insert(
+            'wirelength',
+            Parameter(
+                'float',
+                scope=Scope.JOB,
+                shorthelp="Metric: wirelength",
+                switch="-metric_wirelength 'step index <float>'",
+                example=[
+                    "cli: -metric_wirelength 'place 0 100.0'",
+                    "api: chip.set('metric', 'wirelength', 50.0, step='place', index=0)"],
+                pernode=PerNode.REQUIRED,
+                help=trim("""
+                Metric tracking the total wirelength of the design on a per step
+                and index basis.""")))
+
+        schema.insert(
+            'overflow',
+            Parameter(
+                'int',
+                scope=Scope.JOB,
+                shorthelp="Metric: overflow",
+                switch="-metric_overflow 'step index <int>'",
+                example=[
+                    "cli: -metric_overflow 'place 0 0'",
+                    "api: chip.set('metric', 'overflow', 50, step='place', index=0)"],
+                pernode=PerNode.REQUIRED,
+                help=trim("""
+                Metric tracking the total number of overflow tracks for the routing
+                on per step and index basis. Any non-zero number suggests an over
+                congested design. To analyze where the congestion is occurring
+                inspect the router log files for detailed per metal overflow
+                reporting and open up the design to find routing hotspots.""")))

siliconcompiler/package/__init__.py

@@ -1,12 +1,15 @@
 import contextlib
 import functools
+import hashlib
 import importlib
 import json
 import logging
 import os
+import random
 import re
 import time
 import threading
+import uuid
 
 import os.path
 
@@ -50,13 +53,16 @@ class Resolver:
     _RESOLVERS_LOCK = threading.Lock()
     _RESOLVERS = {}
 
+    __CACHE_LOCK = threading.Lock()
+    __CACHE = {}
+
     def __init__(self, name, root, source, reference=None):
         self.__name = name
         self.__root = root
         self.__source = source
         self.__reference = reference
         self.__changed = False
-        self.__cache = {}
+        self.__cacheid = None
 
         if self.__root and hasattr(self.__root, "logger"):
             self.__logger = self.__root.logger.getChild(f"resolver-{self.name}")
@@ -126,34 +132,80 @@ class Resolver:
         return self.urlparse.netloc
 
     @property
-    def changed(self):
+    def changed(self) -> bool:
         change = self.__changed
         self.__changed = False
         return change
 
+    @property
+    def cache_id(self) -> str:
+        if self.__cacheid is None:
+            hash = hashlib.sha1()
+            hash.update(self.__source.encode())
+            if self.__reference:
+                hash.update(self.__reference.encode())
+            else:
+                hash.update("".encode())
+
+            self.__cacheid = hash.hexdigest()
+        return self.__cacheid
+
     def set_changed(self):
         self.__changed = True
 
-    def set_cache(self, cache):
-        self.__cache = cache
-
     def resolve(self):
         raise NotImplementedError("child class must implement this")
 
+    @staticmethod
+    def __get_root_id(root):
+        STORAGE = "__Resolver_cache_id"
+        if not getattr(root, STORAGE, None):
+            setattr(root, STORAGE, uuid.uuid4().hex)
+        return getattr(root, STORAGE)
+
+    @staticmethod
+    def get_cache(root, name: str = None):
+        with Resolver.__CACHE_LOCK:
+            root_id = Resolver.__get_root_id(root)
+            if root_id not in Resolver.__CACHE:
+                Resolver.__CACHE[root_id] = {}
+
+            if name:
+                return Resolver.__CACHE[root_id].get(name, None)
+
+            return Resolver.__CACHE[root_id].copy()
+
+    @staticmethod
+    def set_cache(root, name: str, path: str):
+        with Resolver.__CACHE_LOCK:
+            root_id = Resolver.__get_root_id(root)
+            if root_id not in Resolver.__CACHE:
+                Resolver.__CACHE[root_id] = {}
+            Resolver.__CACHE[root_id][name] = path
+
+    @staticmethod
+    def reset_cache(root):
+        with Resolver.__CACHE_LOCK:
+            root_id = Resolver.__get_root_id(root)
+            if root_id in Resolver.__CACHE:
+                del Resolver.__CACHE[root_id]
+
     def get_path(self):
-        if self.name in self.__cache:
-            return self.__cache[self.name]
+        cache_path = Resolver.get_cache(self.__root, self.cache_id)
+        if cache_path:
+            return cache_path
 
         path = self.resolve()
         if not os.path.exists(path):
             raise FileNotFoundError(f"Unable to locate {self.name} at {path}")
 
-        if self.changed and self.name not in self.__cache:
+        if self.changed:
             self.logger.info(f'Saved {self.name} data to {path}')
         else:
             self.logger.info(f'Found {self.name} data at {path}')
-        self.__cache[self.name] = path
-        return self.__cache[self.name]
+
+        Resolver.set_cache(self.__root, self.cache_id, path)
+        return path
 
     def __resolve_env(self, path):
         env_save = os.environ.copy()
@@ -198,6 +250,7 @@ class RemoteResolver(Resolver):
         if not root:
             return Path(default_path)
 
+        path = None
         if root.valid('option', 'cachedir'):
             path = root.get('option', 'cachedir')
             if path:
@@ -249,32 +302,51 @@ class RemoteResolver(Resolver):
             return RemoteResolver._CACHE_LOCKS[self.name]
 
     @contextlib.contextmanager
-    def lock(self):
+    def __thread_lock(self):
         lock = self.thread_lock()
         lock_acquired = False
         try:
-            if lock.acquire_lock(timeout=self.timeout):
-                data_path_lock = InterProcessLock(self.lock_file)
-                sc_data_path_lock = None
-                try:
-                    lock_acquired = data_path_lock.acquire(timeout=self.timeout)
-                except (OSError, RuntimeError):
-                    if not lock_acquired:
-                        sc_data_path_lock = Path(self.sc_lock_file)
-                        max_seconds = self.timeout
-                        while sc_data_path_lock.exists():
-                            if max_seconds == 0:
-                                raise RuntimeError(f'Failed to access {self.cache_path}. '
-                                                   f'Lock {sc_data_path_lock} still exists.')
-                            time.sleep(1)
-                            max_seconds -= 1
-                        sc_data_path_lock.touch()
-                        lock_acquired = True
-                if lock_acquired:
-                    yield
+            timeout = self.timeout
+            while timeout > 0:
+                if lock.acquire_lock(timeout=1):
+                    lock_acquired = True
+                    break
+                sleep_time = random.randint(1, max(1, int(timeout / 10)))
+                timeout -= sleep_time + 1
+                time.sleep(sleep_time)
+            if lock_acquired:
+                yield
         finally:
             if lock.locked():
                 lock.release()
+
+        if not lock_acquired:
+            raise RuntimeError(f'Failed to access {self.cache_path}. '
+                               f'Another thread is currently holding the lock.')
+
+    @contextlib.contextmanager
+    def __file_lock(self):
+        data_path_lock = InterProcessLock(self.lock_file)
+        lock_acquired = False
+        sc_data_path_lock = None
+        try:
+            try:
+                lock_acquired = data_path_lock.acquire(timeout=self.timeout)
+            except (OSError, RuntimeError):
+                if not lock_acquired:
+                    sc_data_path_lock = Path(self.sc_lock_file)
+                    max_seconds = self.timeout
+                    while sc_data_path_lock.exists():
+                        if max_seconds == 0:
+                            raise RuntimeError(f'Failed to access {self.cache_path}. '
+                                               f'Lock {sc_data_path_lock} still exists.')
+                        time.sleep(1)
+                        max_seconds -= 1
+                    sc_data_path_lock.touch()
+                    lock_acquired = True
+            if lock_acquired:
+                yield
+        finally:
             if lock_acquired:
                 if data_path_lock.acquired:
                     data_path_lock.release()
@@ -286,6 +358,12 @@ class RemoteResolver(Resolver):
                                f'{self.lock_file} is still locked, if this is a mistake, '
                                'please delete it.')
 
+    @contextlib.contextmanager
+    def lock(self):
+        with self.__thread_lock():
+            with self.__file_lock():
+                yield
+
     def resolve_remote(self):
         raise NotImplementedError("child class must implement this")
 
@@ -324,11 +402,8 @@ class FileResolver(Resolver):
 
     @property
     def urlpath(self):
-        parse = self.urlparse
-        if parse.netloc:
-            return parse.netloc
-        else:
-            return parse.path
+        # Rebuild URL and remove scheme prefix
+        return self.urlparse.geturl()[7:]
 
     def resolve(self):
         return os.path.abspath(self.urlpath)
@@ -412,6 +487,34 @@ class PythonPathResolver(Resolver):
                              path=path,
                              ref=ref)
 
+    @staticmethod
+    def set_dataroot(root,
+                     package_name,
+                     python_module,
+                     alternative_path,
+                     alternative_ref=None,
+                     python_module_path_append=None):
+        '''
+        Helper function to register a python module as data source with an alternative in case
+        the module is not installed in an editable state
+        '''
+        # check if installed in an editable state
+        if PythonPathResolver.is_python_module_editable(python_module):
+            if python_module_path_append:
+                path = PythonPathResolver(
+                    python_module, root, f"python://{python_module}").resolve()
+                path = os.path.abspath(os.path.join(path, python_module_path_append))
+            else:
+                path = f"python://{python_module}"
+            ref = None
+        else:
+            path = alternative_path
+            ref = alternative_ref
+
+        root.set_dataroot(name=package_name,
+                          path=path,
+                          tag=ref)
+
     def resolve(self):
         module = importlib.import_module(self.urlpath)
         python_path = os.path.dirname(module.__file__)

siliconcompiler/package/github.py

@@ -53,17 +53,13 @@ class GithubResolver(HTTPResolver):
         if not release:
             release = repo.get_latest_release().tag_name
 
-        url = None
-        for repo_release in repo.get_releases():
-            if repo_release.tag_name == release:
-                for asset in repo_release.assets:
-                    if asset.name == artifact:
-                        url = asset.url
+        repo_release = repo.get_release(release)
+        if repo_release:
+            for asset in repo_release.assets:
+                if asset.name == artifact:
+                    return asset.url
 
-        if not url:
-            raise ValueError(f'Unable to find release asset: {repository}/{release}/{artifact}')
-
-        return url
+        raise ValueError(f'Unable to find release asset: {repository}/{release}/{artifact}')
 
     def __get_gh_auth(self):
         token_name = self.name.upper()