(cProfile) Improve performance and add benchmarking scripts for load testing

Author: PierreRaybaut

.gitignore

@@ -69,3 +69,7 @@ docs/_build/
 
 # PyBuilder
 target/
+
+# Local benchmark venvs (issue #93)
+.venvs/
+

qwt/scale_div.py

@@ -235,9 +235,11 @@ def contains(self, value):
         :param float value: Value
         :return: True/False
         """
-        min_ = min([self.__lowerBound, self.__upperBound])
-        max_ = max([self.__lowerBound, self.__upperBound])
-        return value >= min_ and value <= max_
+        lb = self.__lowerBound
+        ub = self.__upperBound
+        if lb <= ub:
+            return lb <= value <= ub
+        return ub <= value <= lb
 
     def invert(self):
         """

qwt/scale_draw.py

@@ -39,6 +39,17 @@
 from qwt.scale_map import QwtScaleMap
 from qwt.text import QwtText
 
+# Plain-int aliases for Qt alignment flags. Qt6 exposes alignment flags as
+# IntEnum members and bitwise operations on them go through Python's
+# enum machinery (`__and__`/`__call__`), which is one of the dominant costs
+# of label layout. Casting to int once and using these constants makes the
+# bitwise tests in `labelTransformation` ~10x cheaper without changing
+# semantics.
+_ALIGN_LEFT = int(Qt.AlignLeft)
+_ALIGN_RIGHT = int(Qt.AlignRight)
+_ALIGN_TOP = int(Qt.AlignTop)
+_ALIGN_BOTTOM = int(Qt.AlignBottom)
+
 
 class QwtAbstractScaleDraw_PrivateData(QObject):
     def __init__(self):
@@ -568,9 +579,12 @@ def orientation(self):
 
             :py:meth:`alignment()`
         """
-        if self.__data.alignment in (self.TopScale, self.BottomScale):
+        # 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
-        elif self.__data.alignment in (self.LeftScale, self.RightScale):
+        if align == self.LeftScale or align == self.RightScale:
             return Qt.Vertical
 
     def getBorderDistHint(self, font):
@@ -597,34 +611,36 @@ def getBorderDistHint(self, font):
         if len(ticks) == 0:
             return start, end
 
+        scale_map = self.scaleMap()
+        transform = scale_map.transform
         minTick = ticks[0]
-        minPos = self.scaleMap().transform(minTick)
+        minPos = transform(minTick)
         maxTick = minTick
         maxPos = minPos
 
         for tick in ticks:
-            tickPos = self.scaleMap().transform(tick)
+            tickPos = transform(tick)
             if tickPos < minPos:
                 minTick = tick
                 minPos = tickPos
-            if tickPos > self.scaleMap().transform(maxTick):
+            if tickPos > maxPos:
                 maxTick = tick
                 maxPos = tickPos
 
         s = 0.0
         e = 0.0
         if self.orientation() == Qt.Vertical:
             s = -self.labelRect(font, minTick).top()
-            s -= abs(minPos - round(self.scaleMap().p2()))
+            s -= abs(minPos - round(scale_map.p2()))
 
             e = self.labelRect(font, maxTick).bottom()
-            e -= abs(maxPos - self.scaleMap().p1())
+            e -= abs(maxPos - scale_map.p1())
         else:
             s = -self.labelRect(font, minTick).left()
-            s -= abs(minPos - self.scaleMap().p1())
+            s -= abs(minPos - scale_map.p1())
 
             e = self.labelRect(font, maxTick).right()
-            e -= abs(maxPos - self.scaleMap().p2())
+            e -= abs(maxPos - scale_map.p2())
 
         return max(math.ceil(s), 0), max(math.ceil(e), 0)
 
@@ -763,27 +779,22 @@ def labelPosition(self, value):
         """
         tval = self.scaleMap().transform(value)
         dist = self.spacing()
-        if self.hasComponent(QwtAbstractScaleDraw.Backbone):
-            dist += max([1, self.penWidth()])
-        if self.hasComponent(QwtAbstractScaleDraw.Ticks):
+        hasComponent = self.hasComponent
+        if hasComponent(QwtAbstractScaleDraw.Backbone):
+            dist += max(1, self.penWidth())
+        if hasComponent(QwtAbstractScaleDraw.Ticks):
             dist += self.tickLength(QwtScaleDiv.MajorTick)
 
-        px = 0
-        py = 0
-        if self.alignment() == self.RightScale:
-            px = self.__data.pos.x() + dist
-            py = tval
-        elif self.alignment() == self.LeftScale:
-            px = self.__data.pos.x() - dist
-            py = tval
-        elif self.alignment() == self.BottomScale:
-            px = tval
-            py = self.__data.pos.y() + dist
-        elif self.alignment() == self.TopScale:
-            px = tval
-            py = self.__data.pos.y() - dist
-
-        return QPointF(px, py)
+        alignment = self.alignment()
+        pos = self.__data.pos
+        if alignment == self.RightScale:
+            return QPointF(pos.x() + dist, tval)
+        if alignment == self.LeftScale:
+            return QPointF(pos.x() - dist, tval)
+        if alignment == self.BottomScale:
+            return QPointF(tval, pos.y() + dist)
+        # TopScale
+        return QPointF(tval, pos.y() - dist)
 
     def drawTick(self, painter, value, len_):
         """
@@ -1007,17 +1018,19 @@ def labelTransformation(self, pos, size):
         flags = self.labelAlignment()
         if flags == 0:
             flags = self.Flags[self.alignment()]
+        # Cast to plain int once to avoid the per-bit Qt6 enum overhead.
+        flags = int(flags)
 
-        if flags & Qt.AlignLeft:
+        if flags & _ALIGN_LEFT:
             x = -size.width()
-        elif flags & Qt.AlignRight:
+        elif flags & _ALIGN_RIGHT:
             x = 0.0
         else:
             x = -(0.5 * size.width())
 
-        if flags & Qt.AlignTop:
+        if flags & _ALIGN_TOP:
             y = -size.height()
-        elif flags & Qt.AlignBottom:
+        elif flags & _ALIGN_BOTTOM:
             y = 0
         else:
             y = -(0.5 * size.height())
@@ -1039,6 +1052,31 @@ def labelRect(self, font, value):
         lbl, labelSize = self.tickLabel(font, value)
         if not lbl or lbl.isEmpty():
             return QRectF(0.0, 0.0, 0.0, 0.0)
+        # Fast path: when the label is not rotated, the contribution of
+        # ``pos`` cancels out (transform.translate(pos) followed by
+        # br.translate(-pos)). This avoids ``labelPosition``,
+        # ``labelTransformation`` and ``QTransform.mapRect`` entirely - all
+        # of which are dominant costs in tick-heavy layouts.
+        if self.labelRotation() == 0.0:
+            flags = self.labelAlignment()
+            if flags == 0:
+                flags = self.Flags[self.alignment()]
+            flags = int(flags)
+            w = labelSize.width()
+            h = labelSize.height()
+            if flags & _ALIGN_LEFT:
+                x = -w
+            elif flags & _ALIGN_RIGHT:
+                x = 0.0
+            else:
+                x = -0.5 * w
+            if flags & _ALIGN_TOP:
+                y = -h
+            elif flags & _ALIGN_BOTTOM:
+                y = 0.0
+            else:
+                y = -0.5 * h
+            return QRectF(x, y, w, h)
         pos = self.labelPosition(value)
         transform = self.labelTransformation(pos, labelSize)
         br = transform.mapRect(QRectF(QPointF(0, 0), labelSize))

qwt/scale_engine.py

@@ -324,11 +324,10 @@ def contains(self, interval, value):
         """
         if not interval.isValid():
             return False
-        eps = abs(1.0e-6 * interval.width())
-        if interval.minValue() - value > eps or value - interval.maxValue() > eps:
-            return False
-        else:
-            return True
+        min_v = interval.minValue()
+        max_v = interval.maxValue()
+        eps = abs(1.0e-6 * (max_v - min_v))
+        return not (min_v - value > eps or value - max_v > eps)
 
     def strip(self, ticks, interval):
         """
@@ -340,9 +339,17 @@ def strip(self, ticks, interval):
         """
         if not interval.isValid() or not ticks:
             return []
-        if self.contains(interval, ticks[0]) and self.contains(interval, ticks[-1]):
+        # Inline ``contains`` to avoid one Python call per tick: ``strip`` is
+        # called by buildTicks for every layout pass and is one of the
+        # dominant costs in tick-heavy plots.
+        min_v = interval.minValue()
+        max_v = interval.maxValue()
+        eps = abs(1.0e-6 * (max_v - min_v))
+        lo = min_v - eps
+        hi = max_v + eps
+        if lo <= ticks[0] and ticks[-1] <= hi:
             return ticks
-        return [tick for tick in ticks if self.contains(interval, tick)]
+        return [tick for tick in ticks if lo <= tick <= hi]
 
     def buildInterval(self, value):
         """

qwt/scale_map.py

@@ -249,13 +249,18 @@ def transform(self, *args):
 
             :py:meth:`invTransform()`
         """
-        if len(args) == 1:
-            # Scalar transform
-            return self.transform_scalar(args[0])
-        elif len(args) == 3 and isinstance(args[2], QPointF):
+        nargs = len(args)
+        if nargs == 1:
+            # Scalar transform: inline the fast path for the dominant case
+            # (avoids one Python call frame per tick label).
+            s = args[0]
+            if self.__transform:
+                s = self.__transform.transform(s)
+            return self.__p1 + (s - self.__ts1) * self.__cnv
+        elif nargs == 3 and isinstance(args[2], QPointF):
             xMap, yMap, pos = args
             return QPointF(xMap.transform(pos.x()), yMap.transform(pos.y()))
-        elif len(args) == 3 and isinstance(args[2], QRectF):
+        elif nargs == 3 and isinstance(args[2], QRectF):
             xMap, yMap, rect = args
             x1 = xMap.transform(rect.left())
             x2 = xMap.transform(rect.right())

qwt/text.py

@@ -226,6 +226,11 @@ def __init__(self):
         self.qrectf_max = QRectF(0, 0, QWIDGETSIZE_MAX, QWIDGETSIZE_MAX)
         self._fm_cache = {}
         self._fm_cache_f = {}
+        self._margins_cache = {}
+        # Fast path: when textMargins is called repeatedly with the same
+        # QFont instance, skip the (expensive) font.key() Qt call.
+        self._margins_last_id = -1
+        self._margins_last_value = None
 
     def fontmetrics(self, font):
         fid = font.toString()
@@ -317,11 +322,19 @@ def textMargins(self, font):
         :param QFont font: Font of the text
         :return: tuple (left, right, top, bottom) representing margins
         """
-        left = right = 0
-        fm = self.fontmetrics(font)
-        top = fm.ascent() - self.effectiveAscent(font)
-        bottom = fm.descent()
-        return left, right, top, bottom
+        # Fast path: same QFont object as the previous call.
+        font_id = id(font)
+        if font_id == self._margins_last_id:
+            return self._margins_last_value
+        fkey = font.key()
+        cached = self._margins_cache.get(fkey)
+        if cached is None:
+            fm = self.fontmetrics(font)
+            cached = (0, 0, fm.ascent() - self.effectiveAscent(font), fm.descent())
+            self._margins_cache[fkey] = cached
+        self._margins_last_id = font_id
+        self._margins_last_value = cached
+        return cached
 
     def draw(self, painter, rect, flags, text):
         """
@@ -484,10 +497,13 @@ def __init__(self):
 class QwtText_LayoutCache(object):
     def __init__(self):
         self.textSize = None
-        self.font = None
+        self.fontKey = None
+        self.fontId = -1
 
     def invalidate(self):
         self.textSize = None
+        self.fontKey = None
+        self.fontId = -1
 
 
 class QwtText(object):
@@ -994,17 +1010,24 @@ def textSize(self, defaultFont):
         :param QFont defaultFont Font, used for the calculation if the text has no font
         :return: Caluclated size
         """
-        font = QFont(self.usedFont(defaultFont))
-        if (
-            self.__layoutCache.textSize is None
-            or not self.__layoutCache.textSize.isValid()
-            or self.__layoutCache.font is not font
-        ):
-            self.__layoutCache.textSize = self.__data.textEngine.textSize(
-                font, self.__data.renderFlags, self.__data.text
-            )
-            self.__layoutCache.font = font
-        sz = self.__layoutCache.textSize
+        font = self.usedFont(defaultFont)
+        cache = self.__layoutCache
+        font_id = id(font)
+        if cache.textSize is not None and cache.fontId == font_id:
+            sz = QSizeF(cache.textSize)
+        else:
+            fkey = font.key()
+            if (
+                cache.textSize is None
+                or not cache.textSize.isValid()
+                or cache.fontKey != fkey
+            ):
+                cache.textSize = self.__data.textEngine.textSize(
+                    font, self.__data.renderFlags, self.__data.text
+                )
+                cache.fontKey = fkey
+            cache.fontId = font_id
+            sz = QSizeF(cache.textSize)
         if self.__data.layoutAttributes & self.MinimumLayout:
             (left, right, top, bottom) = self.__data.textEngine.textMargins(font)
             sz -= QSizeF(left + right, top + bottom)
@@ -1072,7 +1095,13 @@ def textEngine(self, text=None, format_=None):
             return self.__map.get(format_)
         elif format_ is not None:
             if format_ == QwtText.AutoText:
-                for key, engine in list(self.__map.items()):
+                # Fast path: a string with no ``<`` cannot be rich text, so
+                # we can return the plain engine without iterating the map
+                # and calling Qt.mightBeRichText (which is a hot Qt call
+                # for tick labels like " 1.5").
+                if "<" not in text:
+                    return self.__map[QwtText.PlainText]
+                for key, engine in self.__map.items():
                     if key != QwtText.PlainText:
                         if engine and engine.mightRender(text):
                             return engine