12036879208

Committed 26 Nov 2024 06:30PM UTC coverage: 60.021% (+0.04%) from 59.983%

Build # 12036879208

Build Type

Pull #5285

github

Committed by

andydotxyz

Commit Message

Reverting this forced refresh of all child images

The reason was thread related and we are about to move from that problem anyway.
Reverts https://github.com/fyne-io/fyne/commit/4efaa1be9

Pull Request Pull Request #5285: Fix performance of file dialog scrolling in large folders

Run Details

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

2 existing lines in 2 files now uncovered.

25405 of 42327 relevant lines covered (60.02%)

702.86 hits per line

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

85.86

/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 atomic.Bool
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 !running.Load() {
                f()
                return
        }

        done := common.DonePool.Get()
        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()
        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 !running.CompareAndSwap(false, true) {
                return // Run was called twice.
        }
        close(d.waitForStart) // Signal that execution can continue.

        d.initGLFW()
        if d.trayStart != nil {
                d.trayStart()
        }
        if f := fyne.CurrentApp().Lifecycle().(*app.Lifecycle).OnStarted(); f != nil {
                go f() // don't block main, we don't have window event queue
        }
        eventTick := time.NewTicker(time.Second / 60)
        for {
                select {
                case <-d.done:
                        eventTick.Stop()
                        d.drawDone <- struct{}{} // wait for draw thread to stop
                        d.Terminate()
                        l := fyne.CurrentApp().Lifecycle().(*app.Lifecycle)
                        if f := l.OnStopped(); f != nil {
                                l.QueueEvent(f)
                        }
                        return
                case f := <-funcQueue:
                        f.f()
                        f.done <- struct{}{}
                case <-eventTick.C:
                        d.pollEvents()
                        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 && runtime.GOOS != "js" {
                                                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 atomic.Bool
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()) {	370✔
42	// If we are on main just execute - otherwise add it to the main queue and wait.	370✔
43	// The "running" variable is normally false when we are on the main thread.	370✔
44	if !running.Load() {	373✔
45	f()	3✔
46	return	3✔
47	}	3✔
48
49	done := common.DonePool.Get()	367✔
50	defer common.DonePool.Put(done)	367✔
51		367✔
52	funcQueue <- funcData{f: f, done: done}	367✔
53		367✔
54	<-done	367✔
55	}
56
57	// force a function f to run on the draw thread
58	func runOnDraw(w *window, f func()) {	125✔
59	if drawOnMainThread {	125✔
60	runOnMain(func() { w.RunWithContext(f) })	×
61	return	×
62	}
63	done := common.DonePool.Get()	125✔
64	defer common.DonePool.Put(done)	125✔
65		125✔
66	drawFuncQueue <- drawData{f: f, win: w, done: done}	125✔
67	<-done	125✔
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() {	774✔
79	for _, win := range d.windowList() {	33,485✔
80	w := win.(*window)	32,711✔
81	w.viewLock.RLock()	32,711✔
82	canvas := w.canvas	32,711✔
83	closing := w.closing	32,711✔
84	visible := w.visible	32,711✔
85	w.viewLock.RUnlock()	32,711✔
86		32,711✔
87	// CheckDirtyAndClear must be checked after visibility,	32,711✔
88	// because when a window becomes visible, it could be	32,711✔
89	// showing old content without a dirty flag set to true.	32,711✔
90	// Do the clear if and only if the window is visible.	32,711✔
91	if closing \|\| !visible \|\| !canvas.CheckDirtyAndClear() {	65,421✔
92	continue	32,710✔
93	}
94
95	d.repaintWindow(w)	1✔
96	refreshingCanvases = append(refreshingCanvases, canvas)	1✔
97	}
98	cache.CleanCanvases(refreshingCanvases)	774✔
99		774✔
100	// cleanup refreshingCanvases slice	774✔
101	for i := 0; i < len(refreshingCanvases); i++ {	775✔
102	refreshingCanvases[i] = nil	1✔
103	}	1✔
104	refreshingCanvases = refreshingCanvases[:0]	774✔
105	}
106
107	func (d *gLDriver) runGL() {	1✔
108	if !running.CompareAndSwap(false, true) {	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	if f := fyne.CurrentApp().Lifecycle().(*app.Lifecycle).OnStarted(); f != nil {	1✔
118	go f() // don't block main, we don't have window event queue	×
119	}	×
120	eventTick := time.NewTicker(time.Second / 60)	1✔
121	for {	1,172✔
122	select {	1,171✔
123	case <-d.done:	×
124	eventTick.Stop()	×
125	d.drawDone <- struct{}{} // wait for draw thread to stop	×
126	d.Terminate()	×
127	l := fyne.CurrentApp().Lifecycle().(*app.Lifecycle)	×
128	if f := l.OnStopped(); f != nil {	×
129	l.QueueEvent(f)	×
130	}	×
131	return	×
132	case f := <-funcQueue:	367✔
133	f.f()	367✔
134	f.done <- struct{}{}	367✔
135	case <-eventTick.C:	803✔
136	d.pollEvents()	803✔
137	windowsToRemove := 0	803✔
138	for _, win := range d.windowList() {	31,715✔
139	w := win.(*window)	30,912✔
140	if w.viewport == nil {	30,912✔
UNCOV 141	continue	×
142	}
143
144	if w.viewport.ShouldClose() {	30,913✔
145	windowsToRemove++	1✔
146	continue	1✔
147	}
148
149	w.viewLock.RLock()	30,911✔
150	expand := w.shouldExpand	30,911✔
151	fullScreen := w.fullScreen	30,911✔
152	w.viewLock.RUnlock()	30,911✔
153		30,911✔
154	if expand && !fullScreen {	31,003✔
155	w.fitContent()	92✔
156	w.viewLock.Lock()	92✔
157	shouldExpand := w.shouldExpand	92✔
158	w.shouldExpand = false	92✔
159	view := w.viewport	92✔
160	w.viewLock.Unlock()	92✔
161	if shouldExpand && runtime.GOOS != "js" {	184✔
162	view.SetSize(w.shouldWidth, w.shouldHeight)	92✔
163	}	92✔
164	}
165
166	if drawOnMainThread {	30,911✔
167	d.drawSingleFrame()	×
168	}	×
169	}
170	if windowsToRemove > 0 {	804✔
171	oldWindows := d.windowList()	1✔
172	newWindows := make([]fyne.Window, 0, len(oldWindows)-windowsToRemove)	1✔
173		1✔
174	for _, win := range oldWindows {	75✔
175	w := win.(*window)	74✔
176	if w.viewport == nil {	74✔
177	continue	×
178	}
179
180	if w.viewport.ShouldClose() {	75✔
181	w.viewLock.Lock()	1✔
182	w.visible = false	1✔
183	v := w.viewport	1✔
184	w.viewLock.Unlock()	1✔
185		1✔
186	// remove window from window list	1✔
187	v.Destroy()	1✔
188	w.destroy(d)	1✔
189	continue	1✔
190	}
191
192	newWindows = append(newWindows, win)	73✔
193	}
194
195	d.windowLock.Lock()	1✔
196	d.windows = newWindows	1✔
197	d.windowLock.Unlock()	1✔
198		1✔
199	if len(newWindows) == 0 {	1✔
200	d.Quit()	×
201	}	×
202	}
203	}
204	}
205	}
206
207	func (d gLDriver) repaintWindow(w window) {	42✔
208	canvas := w.canvas	42✔
209	w.RunWithContext(func() {	84✔
210	if canvas.EnsureMinSize() {	74✔
211	w.viewLock.Lock()	32✔
212	w.shouldExpand = true	32✔
213	w.viewLock.Unlock()	32✔
214	}	32✔
215	canvas.FreeDirtyTextures()	42✔
216		42✔
217	updateGLContext(w)	42✔
218	canvas.paint(canvas.Size())	42✔
219		42✔
220	w.viewLock.RLock()	42✔
221	view := w.viewport	42✔
222	visible := w.visible	42✔
223	w.viewLock.RUnlock()	42✔
224		42✔
225	if view != nil && visible {	43✔
226	view.SwapBuffers()	1✔
227	}	1✔
228	})
229	}
230
231	func (d *gLDriver) startDrawThread() {	1✔
232	settingsChange := make(chan fyne.Settings)	1✔
233	fyne.CurrentApp().Settings().AddChangeListener(settingsChange)	1✔
234	var drawCh <-chan time.Time	1✔
235	if drawOnMainThread {	1✔
236	drawCh = make(chan time.Time) // don't tick when on M1	×
237	} else {	1✔
238	drawCh = time.NewTicker(time.Second / 60).C	1✔
239	}	1✔
240
241	go func() {	2✔
242	runtime.LockOSThread()	1✔
243		1✔
244	for {	905✔
245	select {	904✔
246	case <-d.drawDone:	×
247	return	×
248	case f := <-drawFuncQueue:	125✔
249	f.win.RunWithContext(f.f)	125✔
250	f.done <- struct{}{}	125✔
251	case set := <-settingsChange:	4✔
252	painter.ClearFontCache()	4✔
253	cache.ResetThemeCaches()	4✔
254	app.ApplySettingsWithCallback(set, fyne.CurrentApp(), func(w fyne.Window) {	8✔
255	c, ok := w.Canvas().(*glCanvas)	4✔
256	if !ok {	8✔
257	return	4✔
258	}	4✔
259	c.applyThemeOutOfTreeObjects()	×
260	go c.reloadScale()	×
261	})
262	case <-drawCh:	774✔
263	d.drawSingleFrame()	774✔
264	}
265	}
266	}()
267	}
268
269	// refreshWindow requests that the specified window be redrawn
270	func refreshWindow(w *window) {	2✔
271	w.canvas.SetDirty()	2✔
272	}	2✔
273
274	func updateGLContext(w *window) {	42✔
275	canvas := w.canvas	42✔
276	size := canvas.Size()	42✔
277		42✔
278	// w.width and w.height are not correct if we are maximised, so figure from canvas	42✔
279	winWidth := float32(scale.ToScreenCoordinate(canvas, size.Width)) * canvas.texScale	42✔
280	winHeight := float32(scale.ToScreenCoordinate(canvas, size.Height)) * canvas.texScale	42✔
281		42✔
282	canvas.Painter().SetFrameBufferScale(canvas.texScale)	42✔
283	w.canvas.Painter().SetOutputSize(int(winWidth), int(winHeight))	42✔
284	}	42✔

fyne-io / fyne / 12036879208

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