7232792363

Committed 16 Dec 2023 03:32PM UTC coverage: 64.644% (+0.04%) from 64.603%

Build # 7232792363

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #4398 from dweymouth/list-reduce-allocs

Reduce allocations in list scroll updates

Run Details

89 of 89 new or added lines in 1 file covered. (100.0%)

1 existing line in 1 file now uncovered.

23230 of 35935 relevant lines covered (64.64%)

795.77 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

88.08

/internal/driver/glfw/loop.go

package glfw

import (
        "runtime"
        "sync"
        "sync/atomic"
        "time"

        "fyne.io/fyne/v2"
        "fyne.io/fyne/v2/internal/app"
        "fyne.io/fyne/v2/internal/cache"
        "fyne.io/fyne/v2/internal/driver/common"
        "fyne.io/fyne/v2/internal/painter"
        "fyne.io/fyne/v2/internal/scale"
)

type funcData struct {
        f    func()
        done chan struct{} // Zero allocation signalling channel
}

type drawData struct {
        f    func()
        win  *window
        done chan struct{} // Zero allocation signalling channel
}

// channel for queuing functions on the main thread
var funcQueue = make(chan funcData)
var drawFuncQueue = make(chan drawData)
var running uint32 // atomic bool, 0 or 1
var initOnce = &sync.Once{}

// Arrange that main.main runs on main thread.
func init() {
        runtime.LockOSThread()
        mainGoroutineID = goroutineID()
}

// force a function f to run on the main thread
func runOnMain(f func()) {
        // If we are on main just execute - otherwise add it to the main queue and wait.
        // The "running" variable is normally false when we are on the main thread.
        if onMain := atomic.LoadUint32(&running) == 0; onMain {
                f()
                return
        }

        done := common.DonePool.Get().(chan struct{})
        defer common.DonePool.Put(done)

        funcQueue <- funcData{f: f, done: done}

        <-done
}

// force a function f to run on the draw thread
func runOnDraw(w *window, f func()) {
        if drawOnMainThread {
                runOnMain(func() { w.RunWithContext(f) })
                return
        }
        done := common.DonePool.Get().(chan struct{})
        defer common.DonePool.Put(done)

        drawFuncQueue <- drawData{f: f, win: w, done: done}
        <-done
}

// Preallocate to avoid allocations on every drawSingleFrame.
// Note that the capacity of this slice can only grow,
// but its length will never be longer than the total number of
// window canvases that are dirty on a single frame.
// So its memory impact should be negligible and does not
// need periodic shrinking.
var refreshingCanvases []fyne.Canvas

func (d *gLDriver) drawSingleFrame() {
        for _, win := range d.windowList() {
                w := win.(*window)
                w.viewLock.RLock()
                canvas := w.canvas
                closing := w.closing
                visible := w.visible
                w.viewLock.RUnlock()

                // CheckDirtyAndClear must be checked after visibility,
                // because when a window becomes visible, it could be
                // showing old content without a dirty flag set to true.
                // Do the clear if and only if the window is visible.
                if closing || !visible || !canvas.CheckDirtyAndClear() {
                        continue
                }

                d.repaintWindow(w)
                refreshingCanvases = append(refreshingCanvases, canvas)
        }
        cache.CleanCanvases(refreshingCanvases)

        // cleanup refreshingCanvases slice
        for i := 0; i < len(refreshingCanvases); i++ {
                refreshingCanvases[i] = nil
        }
        refreshingCanvases = refreshingCanvases[:0]
}

func (d *gLDriver) runGL() {
        if !atomic.CompareAndSwapUint32(&running, 0, 1) {
                return // Run was called twice.
        }
        close(d.waitForStart) // Signal that execution can continue.

        d.initGLFW()
        if d.trayStart != nil {
                d.trayStart()
        }
        fyne.CurrentApp().Lifecycle().(*app.Lifecycle).TriggerStarted()
        eventTick := time.NewTicker(time.Second / 60)
        for {
                select {
                case <-d.done:
                        eventTick.Stop()
                        d.drawDone <- struct{}{} // wait for draw thread to stop
                        d.Terminate()
                        fyne.CurrentApp().Lifecycle().(*app.Lifecycle).TriggerStopped()
                        return
                case f := <-funcQueue:
                        f.f()
                        f.done <- struct{}{}
                case <-eventTick.C:
                        d.tryPollEvents()
                        windowsToRemove := 0
                        for _, win := range d.windowList() {
                                w := win.(*window)
                                if w.viewport == nil {
                                        continue
                                }

                                if w.viewport.ShouldClose() {
                                        windowsToRemove++
                                        continue
                                }

                                w.viewLock.RLock()
                                expand := w.shouldExpand
                                fullScreen := w.fullScreen
                                w.viewLock.RUnlock()

                                if expand && !fullScreen {
                                        w.fitContent()
                                        w.viewLock.Lock()
                                        shouldExpand := w.shouldExpand
                                        w.shouldExpand = false
                                        view := w.viewport
                                        w.viewLock.Unlock()
                                        if shouldExpand {
                                                view.SetSize(w.shouldWidth, w.shouldHeight)
                                        }
                                }

                                if drawOnMainThread {
                                        d.drawSingleFrame()
                                }
                        }
                        if windowsToRemove > 0 {
                                oldWindows := d.windowList()
                                newWindows := make([]fyne.Window, 0, len(oldWindows)-windowsToRemove)

                                for _, win := range oldWindows {
                                        w := win.(*window)
                                        if w.viewport == nil {
                                                continue
                                        }

                                        if w.viewport.ShouldClose() {
                                                w.viewLock.Lock()
                                                w.visible = false
                                                v := w.viewport
                                                w.viewLock.Unlock()

                                                // remove window from window list
                                                v.Destroy()
                                                w.destroy(d)
                                                continue
                                        }

                                        newWindows = append(newWindows, win)
                                }

                                d.windowLock.Lock()
                                d.windows = newWindows
                                d.windowLock.Unlock()

                                if len(newWindows) == 0 {
                                        d.Quit()
                                }
                        }
                }
        }
}

func (d *gLDriver) repaintWindow(w *window) {
        canvas := w.canvas
        w.RunWithContext(func() {
                if canvas.EnsureMinSize() {
                        w.viewLock.Lock()
                        w.shouldExpand = true
                        w.viewLock.Unlock()
                }
                canvas.FreeDirtyTextures()

                updateGLContext(w)
                canvas.paint(canvas.Size())

                w.viewLock.RLock()
                view := w.viewport
                visible := w.visible
                w.viewLock.RUnlock()

                if view != nil && visible {
                        view.SwapBuffers()
                }
        })
}

func (d *gLDriver) startDrawThread() {
        settingsChange := make(chan fyne.Settings)
        fyne.CurrentApp().Settings().AddChangeListener(settingsChange)
        var drawCh <-chan time.Time
        if drawOnMainThread {
                drawCh = make(chan time.Time) // don't tick when on M1
        } else {
                drawCh = time.NewTicker(time.Second / 60).C
        }

        go func() {
                runtime.LockOSThread()

                for {
                        select {
                        case <-d.drawDone:
                                return
                        case f := <-drawFuncQueue:
                                f.win.RunWithContext(f.f)
                                f.done <- struct{}{}
                        case set := <-settingsChange:
                                painter.ClearFontCache()
                                cache.ResetThemeCaches()
                                app.ApplySettingsWithCallback(set, fyne.CurrentApp(), func(w fyne.Window) {
                                        c, ok := w.Canvas().(*glCanvas)
                                        if !ok {
                                                return
                                        }
                                        c.applyThemeOutOfTreeObjects()
                                        go c.reloadScale()
                                })
                        case <-drawCh:
                                d.drawSingleFrame()
                        }
                }
        }()
}

// refreshWindow requests that the specified window be redrawn
func refreshWindow(w *window) {
        w.canvas.SetDirty()
}

func updateGLContext(w *window) {
        canvas := w.canvas
        size := canvas.Size()

        // w.width and w.height are not correct if we are maximised, so figure from canvas
        winWidth := float32(scale.ToScreenCoordinate(canvas, size.Width)) * canvas.texScale
        winHeight := float32(scale.ToScreenCoordinate(canvas, size.Height)) * canvas.texScale

        canvas.Painter().SetFrameBufferScale(canvas.texScale)
        w.canvas.Painter().SetOutputSize(int(winWidth), int(winHeight))
}

1	package glfw
2
3	import (
4	"runtime"
5	"sync"
6	"sync/atomic"
7	"time"
8
9	"fyne.io/fyne/v2"
10	"fyne.io/fyne/v2/internal/app"
11	"fyne.io/fyne/v2/internal/cache"
12	"fyne.io/fyne/v2/internal/driver/common"
13	"fyne.io/fyne/v2/internal/painter"
14	"fyne.io/fyne/v2/internal/scale"
15	)
16
17	type funcData struct {
18	f func()
19	done chan struct{} // Zero allocation signalling channel
20	}
21
22	type drawData struct {
23	f func()
24	win *window
25	done chan struct{} // Zero allocation signalling channel
26	}
27
28	// channel for queuing functions on the main thread
29	var funcQueue = make(chan funcData)
30	var drawFuncQueue = make(chan drawData)
31	var running uint32 // atomic bool, 0 or 1
32	var initOnce = &sync.Once{}
33
34	// Arrange that main.main runs on main thread.
35	func init() {	1✔
36	runtime.LockOSThread()	1✔
37	mainGoroutineID = goroutineID()	1✔
38	}	1✔
39
40	// force a function f to run on the main thread
41	func runOnMain(f func()) {	380✔
42	// If we are on main just execute - otherwise add it to the main queue and wait.	380✔
43	// The "running" variable is normally false when we are on the main thread.	380✔
44	if onMain := atomic.LoadUint32(&running) == 0; onMain {	383✔
45	f()	3✔
46	return	3✔
47	}	3✔
48
49	done := common.DonePool.Get().(chan struct{})	377✔
50	defer common.DonePool.Put(done)	377✔
51		377✔
52	funcQueue <- funcData{f: f, done: done}	377✔
53		377✔
54	<-done	377✔
55	}
56
57	// force a function f to run on the draw thread
58	func runOnDraw(w *window, f func()) {	126✔
59	if drawOnMainThread {	126✔
60	runOnMain(func() { w.RunWithContext(f) })	×
61	return	×
62	}
63	done := common.DonePool.Get().(chan struct{})	126✔
64	defer common.DonePool.Put(done)	126✔
65		126✔
66	drawFuncQueue <- drawData{f: f, win: w, done: done}	126✔
67	<-done	126✔
68	}
69
70	// Preallocate to avoid allocations on every drawSingleFrame.
71	// Note that the capacity of this slice can only grow,
72	// but its length will never be longer than the total number of
73	// window canvases that are dirty on a single frame.
74	// So its memory impact should be negligible and does not
75	// need periodic shrinking.
76	var refreshingCanvases []fyne.Canvas
77
78	func (d *gLDriver) drawSingleFrame() {	786✔
79	for _, win := range d.windowList() {	32,085✔
80	w := win.(*window)	31,299✔
81	w.viewLock.RLock()	31,299✔
82	canvas := w.canvas	31,299✔
83	closing := w.closing	31,299✔
84	visible := w.visible	31,299✔
85	w.viewLock.RUnlock()	31,299✔
86		31,299✔
87	// CheckDirtyAndClear must be checked after visibility,	31,299✔
88	// because when a window becomes visible, it could be	31,299✔
89	// showing old content without a dirty flag set to true.	31,299✔
90	// Do the clear if and only if the window is visible.	31,299✔
91	if closing \|\| !visible \|\| !canvas.CheckDirtyAndClear() {	62,597✔
92	continue	31,298✔
93	}
94
95	d.repaintWindow(w)	1✔
96	refreshingCanvases = append(refreshingCanvases, canvas)	1✔
97	}
98	cache.CleanCanvases(refreshingCanvases)	786✔
99		786✔
100	// cleanup refreshingCanvases slice	786✔
101	for i := 0; i < len(refreshingCanvases); i++ {	787✔
102	refreshingCanvases[i] = nil	1✔
103	}	1✔
104	refreshingCanvases = refreshingCanvases[:0]	786✔
105	}
106
107	func (d *gLDriver) runGL() {	1✔
108	if !atomic.CompareAndSwapUint32(&running, 0, 1) {	1✔
109	return // Run was called twice.	×
110	}	×
111	close(d.waitForStart) // Signal that execution can continue.	1✔
112		1✔
113	d.initGLFW()	1✔
114	if d.trayStart != nil {	1✔
115	d.trayStart()	×
116	}	×
117	fyne.CurrentApp().Lifecycle().(*app.Lifecycle).TriggerStarted()	1✔
118	eventTick := time.NewTicker(time.Second / 60)	1✔
119	for {	1,206✔
120	select {	1,205✔
121	case <-d.done:	×
122	eventTick.Stop()	×
123	d.drawDone <- struct{}{} // wait for draw thread to stop	×
124	d.Terminate()	×
125	fyne.CurrentApp().Lifecycle().(*app.Lifecycle).TriggerStopped()	×
126	return	×
127	case f := <-funcQueue:	377✔
128	f.f()	377✔
129	f.done <- struct{}{}	377✔
130	case <-eventTick.C:	827✔
131	d.tryPollEvents()	827✔
132	windowsToRemove := 0	827✔
133	for _, win := range d.windowList() {	32,030✔
134	w := win.(*window)	31,203✔
135	if w.viewport == nil {	31,203✔
UNCOV 136	continue	×
137	}
138
139	if w.viewport.ShouldClose() {	31,204✔
140	windowsToRemove++	1✔
141	continue	1✔
142	}
143
144	w.viewLock.RLock()	31,202✔
145	expand := w.shouldExpand	31,202✔
146	fullScreen := w.fullScreen	31,202✔
147	w.viewLock.RUnlock()	31,202✔
148		31,202✔
149	if expand && !fullScreen {	31,293✔
150	w.fitContent()	91✔
151	w.viewLock.Lock()	91✔
152	shouldExpand := w.shouldExpand	91✔
153	w.shouldExpand = false	91✔
154	view := w.viewport	91✔
155	w.viewLock.Unlock()	91✔
156	if shouldExpand {	182✔
157	view.SetSize(w.shouldWidth, w.shouldHeight)	91✔
158	}	91✔
159	}
160
161	if drawOnMainThread {	31,202✔
162	d.drawSingleFrame()	×
163	}	×
164	}
165	if windowsToRemove > 0 {	828✔
166	oldWindows := d.windowList()	1✔
167	newWindows := make([]fyne.Window, 0, len(oldWindows)-windowsToRemove)	1✔
168		1✔
169	for _, win := range oldWindows {	76✔
170	w := win.(*window)	75✔
171	if w.viewport == nil {	75✔
172	continue	×
173	}
174
175	if w.viewport.ShouldClose() {	76✔
176	w.viewLock.Lock()	1✔
177	w.visible = false	1✔
178	v := w.viewport	1✔
179	w.viewLock.Unlock()	1✔
180		1✔
181	// remove window from window list	1✔
182	v.Destroy()	1✔
183	w.destroy(d)	1✔
184	continue	1✔
185	}
186
187	newWindows = append(newWindows, win)	74✔
188	}
189
190	d.windowLock.Lock()	1✔
191	d.windows = newWindows	1✔
192	d.windowLock.Unlock()	1✔
193		1✔
194	if len(newWindows) == 0 {	1✔
195	d.Quit()	×
196	}	×
197	}
198	}
199	}
200	}
201
202	func (d gLDriver) repaintWindow(w window) {	42✔
203	canvas := w.canvas	42✔
204	w.RunWithContext(func() {	84✔
205	if canvas.EnsureMinSize() {	74✔
206	w.viewLock.Lock()	32✔
207	w.shouldExpand = true	32✔
208	w.viewLock.Unlock()	32✔
209	}	32✔
210	canvas.FreeDirtyTextures()	42✔
211		42✔
212	updateGLContext(w)	42✔
213	canvas.paint(canvas.Size())	42✔
214		42✔
215	w.viewLock.RLock()	42✔
216	view := w.viewport	42✔
217	visible := w.visible	42✔
218	w.viewLock.RUnlock()	42✔
219		42✔
220	if view != nil && visible {	43✔
221	view.SwapBuffers()	1✔
222	}	1✔
223	})
224	}
225
226	func (d *gLDriver) startDrawThread() {	1✔
227	settingsChange := make(chan fyne.Settings)	1✔
228	fyne.CurrentApp().Settings().AddChangeListener(settingsChange)	1✔
229	var drawCh <-chan time.Time	1✔
230	if drawOnMainThread {	1✔
231	drawCh = make(chan time.Time) // don't tick when on M1	×
232	} else {	1✔
233	drawCh = time.NewTicker(time.Second / 60).C	1✔
234	}	1✔
235
236	go func() {	2✔
237	runtime.LockOSThread()	1✔
238		1✔
239	for {	918✔
240	select {	917✔
241	case <-d.drawDone:	×
242	return	×
243	case f := <-drawFuncQueue:	126✔
244	f.win.RunWithContext(f.f)	126✔
245	f.done <- struct{}{}	126✔
246	case set := <-settingsChange:	4✔
247	painter.ClearFontCache()	4✔
248	cache.ResetThemeCaches()	4✔
249	app.ApplySettingsWithCallback(set, fyne.CurrentApp(), func(w fyne.Window) {	8✔
250	c, ok := w.Canvas().(*glCanvas)	4✔
251	if !ok {	8✔
252	return	4✔
253	}	4✔
254	c.applyThemeOutOfTreeObjects()	×
255	go c.reloadScale()	×
256	})
257	case <-drawCh:	786✔
258	d.drawSingleFrame()	786✔
259	}
260	}
261	}()
262	}
263
264	// refreshWindow requests that the specified window be redrawn
265	func refreshWindow(w *window) {	2✔
266	w.canvas.SetDirty()	2✔
267	}	2✔
268
269	func updateGLContext(w *window) {	42✔
270	canvas := w.canvas	42✔
271	size := canvas.Size()	42✔
272		42✔
273	// w.width and w.height are not correct if we are maximised, so figure from canvas	42✔
274	winWidth := float32(scale.ToScreenCoordinate(canvas, size.Width)) * canvas.texScale	42✔
275	winHeight := float32(scale.ToScreenCoordinate(canvas, size.Height)) * canvas.texScale	42✔
276		42✔
277	canvas.Painter().SetFrameBufferScale(canvas.texScale)	42✔
278	w.canvas.Painter().SetOutputSize(int(winWidth), int(winHeight))	42✔
279	}	42✔

fyne-io / fyne / 7232792363

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous