(line-profiler) Optimize performance by removing unnecessary QObject inheritance and adding font key caching

Author: PierreRaybaut

qwt/scale_draw.py

@@ -51,10 +51,22 @@
 _ALIGN_BOTTOM = int(Qt.AlignBottom)
 
 
-class QwtAbstractScaleDraw_PrivateData(QObject):
-    def __init__(self):
-        QObject.__init__(self)
+class QwtAbstractScaleDraw_PrivateData(object):
+    # See QwtText_PrivateData: ``QObject`` inheritance is unused and the
+    # base class' ``__init__`` is a measurable cost in tick-heavy renders.
+    __slots__ = (
+        "spacing",
+        "penWidth",
+        "minExtent",
+        "components",
+        "tick_length",
+        "tick_lighter_factor",
+        "map",
+        "scaleDiv",
+        "labelCache",
+    )
 
+    def __init__(self):
         self.spacing = 4
         self.penWidth = 0
         self.minExtent = 0.0
@@ -481,12 +493,25 @@ def invalidateCache(self):
         self.__data.labelCache.clear()
 
 
-class QwtScaleDraw_PrivateData(QObject):
-    def __init__(self):
-        QObject.__init__(self)
+class QwtScaleDraw_PrivateData(object):
+    # See QwtText_PrivateData: ``QObject`` inheritance is unused and the
+    # base class' ``__init__`` is a measurable cost in tick-heavy renders.
+    __slots__ = (
+        "len",
+        "alignment",
+        "orientation",
+        "labelAlignment",
+        "labelRotation",
+        "labelAutoSize",
+        "pos",
+    )
 
+    def __init__(self):
         self.len = 0
         self.alignment = QwtScaleDraw.BottomScale
+        # Cached orientation - kept in sync by ``QwtScaleDraw.setAlignment``
+        # so that the very hot ``orientation()`` accessor avoids any test.
+        self.orientation = Qt.Horizontal
         self.labelAlignment = 0
         self.labelRotation = 0.0
         self.labelAutoSize = True
@@ -565,6 +590,11 @@ def setAlignment(self, align):
             :py:meth:`alignment()`
         """
         self.__data.alignment = align
+        # Keep cached orientation in sync (see ``orientation()``).
+        if align == self.BottomScale or align == self.TopScale:
+            self.__data.orientation = Qt.Horizontal
+        else:
+            self.__data.orientation = Qt.Vertical
 
     def orientation(self):
         """
@@ -579,13 +609,8 @@ def orientation(self):
 
             :py:meth:`alignment()`
         """
-        # Direct comparisons (no tuple ``in`` membership check) — this is
-        # called per-tick in label layout and shows up in profiles.
-        align = self.__data.alignment
-        if align == self.BottomScale or align == self.TopScale:
-            return Qt.Horizontal
-        if align == self.LeftScale or align == self.RightScale:
-            return Qt.Vertical
+        # Pre-computed by ``setAlignment`` - this method is called per tick.
+        return self.__data.orientation
 
     def getBorderDistHint(self, font):
         """

qwt/text.py

@@ -189,6 +189,31 @@ def draw(self, painter, rect, flags, text):
 
 ASCENTCACHE = {}
 
+# Module-level cache: ``id(font) -> (font_strong_ref, font.key())``.
+# Computing ``QFont.key()`` is one of the dominant per-tick costs (it shows
+# up around 25% of ``QwtText.textSize`` total time and 60% of
+# ``QwtPlainTextEngine.textMargins``). We can avoid the call entirely as long
+# as we cache by the QFont's Python id; we keep a strong reference next to
+# the cached key so the id cannot be reused for a different live QFont.
+# The cache is bounded; once it grows past the limit it is rebuilt to keep
+# only the most recently inserted entry. Tick-rendering uses a tiny number
+# of fonts in practice so a small cap is sufficient.
+_FONT_KEY_CACHE: dict = {}
+_FONT_KEY_CACHE_LIMIT = 1024
+
+
+def font_key_cached(font) -> str:
+    """Return ``font.key()`` using a process-wide id-keyed cache."""
+    fid = id(font)
+    entry = _FONT_KEY_CACHE.get(fid)
+    if entry is not None:
+        return entry[1]
+    if len(_FONT_KEY_CACHE) >= _FONT_KEY_CACHE_LIMIT:
+        _FONT_KEY_CACHE.clear()
+    key = font.key()
+    _FONT_KEY_CACHE[fid] = (font, key)
+    return key
+
 
 def get_screen_resolution():
     """Return screen resolution: tuple of floats (DPIx, DPIy)"""
@@ -275,7 +300,7 @@ def textSize(self, font, flags, text):
 
     def effectiveAscent(self, font):
         global ASCENTCACHE
-        fontKey = font.key()
+        fontKey = font_key_cached(font)
         ascent = ASCENTCACHE.get(fontKey)
         if ascent is not None:
             return ascent
@@ -326,7 +351,7 @@ def textMargins(self, font):
         font_id = id(font)
         if font_id == self._margins_last_id:
             return self._margins_last_value
-        fkey = font.key()
+        fkey = font_key_cached(font)
         cached = self._margins_cache.get(fkey)
         if cached is None:
             fm = self.fontmetrics(font)
@@ -477,10 +502,26 @@ def textMargins(self, font):
         return 0, 0, 0, 0
 
 
-class QwtText_PrivateData(QObject):
-    def __init__(self):
-        QObject.__init__(self)
+class QwtText_PrivateData(object):
+    # ``QObject`` was previously used as the base class but no Qt signals
+    # or events are ever emitted from ``_PrivateData`` containers and the
+    # ``QObject.__init__`` call dominates ``QwtText.__init__`` (it is the
+    # single most expensive line for tick-label-heavy renders, see
+    # https://github.com/PlotPyStack/PythonQwt/issues/93).
+    __slots__ = (
+        "renderFlags",
+        "borderRadius",
+        "borderPen",
+        "backgroundBrush",
+        "paintAttributes",
+        "layoutAttributes",
+        "textEngine",
+        "text",
+        "font",
+        "color",
+    )
 
+    def __init__(self):
         self.renderFlags = Qt.AlignCenter
         self.borderRadius = 0
         self.borderPen = Qt.NoPen
@@ -1016,7 +1057,7 @@ def textSize(self, defaultFont):
         if cache.textSize is not None and cache.fontId == font_id:
             sz = QSizeF(cache.textSize)
         else:
-            fkey = font.key()
+            fkey = font_key_cached(font)
             if (
                 cache.textSize is None
                 or not cache.textSize.isValid()

scripts/lineprofile_loadtest.py

@@ -0,0 +1,64 @@
+"""Line-profile the hot functions identified by cProfile.
+
+Run with the active Qt binding selected via QT_API.
+
+Usage::
+
+    python scripts/lineprofile_loadtest.py [funcname1 funcname2 ...]
+
+If no function names are given, a default set of hotspots is profiled.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+
+os.environ.setdefault("PYTHONQWT_UNATTENDED_TESTS", "1")
+
+from line_profiler import LineProfiler  # noqa: E402
+
+import qwt.scale_div  # noqa: E402
+import qwt.scale_draw  # noqa: E402
+import qwt.scale_engine  # noqa: E402
+import qwt.scale_map  # noqa: E402
+import qwt.text  # noqa: E402
+from qwt.tests import test_loadtest  # noqa: E402
+
+# (module, qualified-name) — only methods listed here are line-profiled.
+HOTSPOTS = {
+    "textSize": qwt.text.QwtText.textSize,
+    "textEngine": qwt.text.QwtText.textEngine,
+    "QwtText.__init__": qwt.text.QwtText.__init__,
+    "PlainTextEngine.textMargins": qwt.text.QwtPlainTextEngine.textMargins,
+    "labelRect": qwt.scale_draw.QwtScaleDraw.labelRect,
+    "labelPosition": qwt.scale_draw.QwtScaleDraw.labelPosition,
+    "labelTransformation": qwt.scale_draw.QwtScaleDraw.labelTransformation,
+    "getBorderDistHint": qwt.scale_draw.QwtScaleDraw.getBorderDistHint,
+    "draw": qwt.scale_draw.QwtScaleDraw.draw,
+    "drawLabel": qwt.scale_draw.QwtScaleDraw.drawLabel,
+    "drawTick": qwt.scale_draw.QwtScaleDraw.drawTick,
+    "drawBackbone": qwt.scale_draw.QwtScaleDraw.drawBackbone,
+    "scale_map.transform": qwt.scale_map.QwtScaleMap.transform,
+    "scale_engine.strip": qwt.scale_engine.QwtScaleEngine.strip,
+    "scale_engine.contains": qwt.scale_engine.QwtScaleEngine.contains,
+    "scale_div.contains": qwt.scale_div.QwtScaleDiv.contains,
+    "orientation": qwt.scale_draw.QwtScaleDraw.orientation,
+}
+
+
+def main() -> None:
+    selected = sys.argv[1:] or list(HOTSPOTS)
+    profiler = LineProfiler()
+    for name in selected:
+        if name not in HOTSPOTS:
+            print(f"Unknown hotspot: {name!r}", file=sys.stderr)
+            continue
+        profiler.add_function(HOTSPOTS[name])
+
+    profiler.runcall(test_loadtest.test_loadtest)
+    profiler.print_stats(stream=sys.stdout, output_unit=1e-6)
+
+
+if __name__ == "__main__":
+    main()