Merge pull request #7771 from trlemon/trlemon/add_forbidden_channel_cache_keithley3706a

Add forbidden channels and _validator caches to Keithley3706a to improve performance

Author: astafan8

docs/changes/newsfragments/7771.improved_driver

@@ -0,0 +1,3 @@
+On Keithly3706A, allow users to cache forbidden channels in order to bypass unnecessary `_validator()` calls when closing channels.
+Added a cache for `_validator()` results. Both of these changes results in significant time savings when running measurements
+with repeated calls to `close_channel()`.

docs/examples/driver_examples/QCoDeS example with Keithley 3706A System Switch.ipynb

@@ -1447,7 +1447,18 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "In certain cases, we may want to keep certain channels always open. We can achieve desired behavior by setting the specified channels (and analog backplane relays) as `forbidden` to close."
+    "In certain cases, we may want to keep certain channels always open. We can achieve desired behavior by setting the specified channels (and analog backplane relays) as `forbidden` to close.\n",
+    "\n",
+    "**Note on Forbidden Channels Cache:**\n",
+    "\n",
+    "When closing channels, there is a check to make sure the channel isn't forbidden to close, which can become quite \"expensive\" if many close operations are required in our measurement. To remedy this, we can set a class attribute that toggles usage of a forbidden channels cache.\n",
+    "```\n",
+    "smatrix.use_forbidden_channels_cache = True\n",
+    "```\n",
+    "\n",
+    "When this cache is active, setting forbidden channels will both update the forbidden channels on the instrument and update the cache.\n",
+    "\n",
+    "Please use with caution since the local cache may become out of sync with the instrument in the case of an instrument reset and/or powercycle. If intending to set forbidden channels, always do so before running a measurement to minimize risk of cache being out of sync."
    ]
   },
   {
@@ -1459,6 +1470,16 @@
     "smatrix.set_forbidden_channels(\"1101:1105\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "By default, `Keithley3706A.get_forbidden_channels()` will query the instrument, but if you'd like to query the forbidden channels cache instead, you can set the argument `fetch_from_cache` to True.\n",
+    "```\n",
+    "smatrix.get_forbidden_channels(\"allslots\", fetch_from_cache=True)\n",
+    "```"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 50,
@@ -1553,7 +1574,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We can clear the forbidden list when we desire to do so."
+    "We can clear the forbidden list when we desire to do so. If using the forbidden channels cache, calling `Keithley3706A.clear_forbidden_channels()` will update the cache with the forbidden channels on the instrument (via `Keithley3706A.get_forbidden_channels(\"allslots\")`)."
    ]
   },
   {

src/qcodes/instrument_drivers/Keithley/Keithley_3706A.py

@@ -1,6 +1,8 @@
+import functools
 import itertools
 import textwrap
 import warnings
+from time import sleep
 from typing import TYPE_CHECKING
 
 import qcodes.validators as vals
@@ -31,16 +33,23 @@ def __init__(
         self,
         name: str,
         address: str,
+        use_forbidden_channels_cache: bool = False,
         **kwargs: "Unpack[VisaInstrumentKWArgs]",
     ) -> None:
         """
         Args:
             name: Name to use internally in QCoDeS
             address: VISA resource address
+            use_forbidden_channels_cache: If True, use local
+                forbidden channel cache instead of querying instrument.
+                See `Keithley3706A.get_forbidden_channels()` for
+                usage details and warnings.
             **kwargs: kwargs are forwarded to base class.
 
         """
         super().__init__(name, address, **kwargs)
+        self.use_forbidden_channels_cache: bool = use_forbidden_channels_cache
+        self._forbidden_channels_cache: str = ""
 
         self.channel_connect_rule: Parameter = self.add_parameter(
             "channel_connect_rule",
@@ -155,7 +164,9 @@ def close_channel(self, val: str) -> None:
 
         """
         slots = ["allslots", *self._get_slot_names()]
-        forbidden_channels = self.get_forbidden_channels("allslots")
+        forbidden_channels = self.get_forbidden_channels(
+            "allslots", fetch_from_cache=self.use_forbidden_channels_cache
+        )
         if val in slots:
             raise Keithley3706AInvalidValue("Slots cannot be closed all together.")
         if not self._validator(val):
@@ -331,7 +342,10 @@ def set_forbidden_channels(self, val: str) -> None:
             )
         self.write(f"channel.setforbidden('{val}')")
 
-    def get_forbidden_channels(self, val: str) -> str:
+        if self.use_forbidden_channels_cache:
+            self._forbidden_channels_cache = val
+
+    def get_forbidden_channels(self, val: str, fetch_from_cache: bool = False) -> str:
         """
         Returns a string that lists the channels and backplane relays
         that are forbidden to close.
@@ -340,8 +354,23 @@ def get_forbidden_channels(self, val: str) -> str:
             val: A string representing the channels,
                 backplane relays or channel patterns to be queried to see
                 if they are forbidden to close.
+            fetch_from_cache: If True, will fetch forbidden channels from cache,
+                otherwise, it will query the instrument.
+                May save time during measurements
+                where closing channels happens frequently. Please use with
+                caution since the local cache may become out of sync with
+                the instrument in the case of an instrument reset and/or
+                powercycle. If intending to set forbidden channels, always
+                do so before running a measurement to minimize risk of
+                cache being out of sync.
 
         """
+
+        # NOTE: The cache string should already be validated from
+        # calling set_forbidden_channels, so we can just return it
+        if fetch_from_cache:
+            return self._forbidden_channels_cache
+
         if not self._validator(val):
             raise Keithley3706AInvalidValue(
                 f"{val} is not a valid specifier. "
@@ -367,6 +396,11 @@ def clear_forbidden_channels(self, val: str) -> None:
             )
         self.write(f"channel.clearforbidden('{val}')")
 
+        if self.use_forbidden_channels_cache:
+            wait_to_clear_forbidden_channels_delay = 0.25
+            sleep(wait_to_clear_forbidden_channels_delay)
+            self._forbidden_channels_cache = self.get_forbidden_channels("allslots")
+
     def set_delay(self, val: str, delay_time: float) -> None:
         """
         Sets an additional delay time for the specified channels.
@@ -899,21 +933,25 @@ def load_setup(self, val: int | str) -> None:
         """
         self.write(f"setup.recall('{val}')")
 
-    def _validator(self, val: str) -> bool:
+    @functools.cached_property
+    def _valid_specifiers(self) -> frozenset[str]:
         """
-        Instrument specific validator. As the number of validation points
-        are around 15k, to avoid QCoDeS parameter validation to print them all,
-        we shall raise a custom exception.
+        Cache valid channel specifiers for fast validation.
+        This property is computed once on first access and cached.
         """
         ch = self.get_channels()
         ch_range = self._get_channel_ranges()
         slots = ["allslots", *self._get_slot_names()]
         backplanes = self.get_analog_backplane_specifiers()
-        specifier = val.split(",")
-        for element in specifier:
-            if element not in (*ch, *ch_range, *slots, *backplanes):
-                return False
-        return True
+        return frozenset((*ch, *ch_range, *slots, *backplanes))
+
+    def _validator(self, val: str) -> bool:
+        """
+        Instrument specific validator. As the number of validation points
+        are around 15k, to avoid QCoDeS parameter validation to print them all,
+        we shall raise a custom exception.
+        """
+        return all(element in self._valid_specifiers for element in val.split(","))
 
     def connect_message(
         self, idn_param: str = "IDN", begin_time: float | None = None