Performance issues?

[kengruven]

When writing my first Racket GUI program, I've noticed that scrolling is really slow, at least when there are many controls in a panel. For example:

#lang racket

(require racket/gui)

(define frame (new frame% [label "Example"]))

(define panel (new horizontal-panel%
                   [parent frame]
                   [style '(auto-hscroll)]))

(define sliders (for/list ([i (in-range 100)])
                  (new slider%
                       [label ""]
                       [min-value 0]
                       [max-value 100]
                       [parent panel]
                       [style '(vertical)])))

(send frame show #t)

Scrolling this window is very sluggish, taking between 1 and several seconds per frame. (This is on a recent AMD CPU, running Debian stable, and X11.)

My understanding is that racket/gui uses GTK3, so to see if this might be an issue with GTK3, I wrote a similar program in Python:

import gi

gi.require_version("Gtk", "3.0")
from gi.repository import Gtk

win = Gtk.Window()

scrolled = Gtk.ScrolledWindow()
scrolled.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.NEVER)

box = Gtk.Box(spacing=6)

for _ in range(100):
    slider = Gtk.Scale()
    slider.set_orientation(Gtk.Orientation.VERTICAL)
    slider.set_range(0, 100)
    box.add(slider)

win.add(scrolled)
scrolled.add(box)

win.connect("destroy", Gtk.main_quit)
win.show_all()
Gtk.main()

Scrolling this window is perfectly smooth, and it never has trouble keeping up with my mouse cursor at all -- even with 1000 controls.

(This isn't a language-X-versus-language-Y comparison. I'm simply demonstrating that GTK is capable of good performance with this many controls in a window.)

Moving the sliders is also an issue. With the PyGTK version, it's perfectly smooth, and with the racket/gui version, it's not as bad as scrolling but still noticably jerky.

Is there something I'm missing? Racket performance is fine (at least as good as Python, it seems), and GTK performance is fine, but racket/gui is a couple orders of magnitude slower than it seems like it ought to be.

[kengruven]

Using GTK_DEBUG=interactive, the fast implementation has a widget tree (from the window to the slider) that looks like this:

GtkWindow
  GtkScrolledWindow
    GtkViewport
      GtkBox          [one of these]
        GtkScale      [many of these]

while the slower (racket/gui) implementation has a widget tree that looks like this:

GtkWindow
  GtkVBox
    GtkLayout
      GtkFixed
        GtkEventBox
          GtkFixed
            GtkEventBox
              GtkFixed
                GtkEventBox
                  GtkHBox
                    GtkVBox
                      GtyLayout
                        GtkFixed           [one of these]
                          GtkEventBox      [many of these]
                            GtkFixed
                              GtkVScale

Searching the source for "event box" turns up this comment in panel.rkt, which I admit I don't understand.

Thoughts/observations:

1. racket/gui isn't using GtkScrolledWindow for scrolling (except for list-box%). Is there a reason for this? Gtk.PolicyType seems to cover all of the racket/gui scrolling style options. Could this eliminate the need for some of the extra layers?
2. There's one scrolling panel here (and no tab panels, list boxes, or canvases, which are the only other users of GtkEventBox). So why are there 4 levels of event boxes? I haven't figured that out yet.

I think we're getting flooded with events which the program doesn't ask for, or use. I've only got 2 layers of widgets inside my window, so I don't know how I'd use events from the other event boxes even if I wanted to.

[benknoble]

Notably, I cannot reproduce the slowdown from the example on macOS 12.7.6, which isn't using GTK. I didn't twiddle the size, though

That leads me to think the diagnosis RE widget tree and events is a valuable path worth exploring.