d1a6612 perf(overview): lay the stash pile out without per-frame allocations · neferwl

M internal/core/overview.go +52 -45


@@ -60,8 +60,9 @@ type rowSnapshot struct {
60	60		// unfolds along the overview axis into a strip of every card (unfold), the
61	61		// selection framed, and the moves along that axis walk it. A vertical
62	62		// overview pins the pile to the left edge of its row, which takes the width
63		-	// the pile leaves. A horizontal one centres it on its row, straddling the
64		-	// bottom edge of the selected lane, over the tiles.
	63	+	// the pile leaves. A horizontal one centres it on its row, in a band
	64	+	// reserved under the selected lane (pileBand): the lane and the band are
	65	+	// centred together.
65	66		const (
66	67		overviewCardZoom = 0.2
67	68		overviewCards = 4

@@ -650,7 +651,7 @@ func (m *Monitor) overviewAxis() layoutAxis { return m.Current().policy().worksp
650	651		//
651	652		// Vertical axis: full-width slots, the current one centred; the rule is
652	653		// horizontal. Horizontal axis: full-height slots as wide as their content,
653		-	// stack peeks included (the stash pile sits over the row), the current one
	654	+	// stack peeks included (the stash pile takes a band of the slot), the current one
654	655		// centred; the rule is vertical, in the spacing between two slots.
655	656		func (m Monitor) overviewRows() (map[Workspace]Rect, []ports.Separator) {
656	657		cur := m.Current()

@@ -733,7 +734,8 @@ func (m *Monitor) overviewLayout(result []Placement) []Placement {
733	734		axis := m.overviewAxis()
734	735		// The unfolded stash goes last: its strip may run over the neighbor
735	736		// rows, which must not cover it.
736		-	var unfolded []Placement
	737	+	var unfolded *Workspace
	738	+	var unfoldedSlot Rect
737	739		for w := range m.all() {
738	740		slot, shown := rows[w]
739	741		if shown {

@@ -742,12 +744,10 @@ func (m *Monitor) overviewLayout(result []Placement) []Placement {
742	744		slot.H -= w.pileBand(axis)
743	745		at := m.cardAt(w)
744	746		result = append(result, m.stackRow(w, axis, slot, w != cur, at < 0)...)
745		-	if len(w.Stash) > 0 {
746		-	if cards := w.pile(axis, slot, w != cur, at); at >= 0 {
747		-	unfolded = cards
748		-	} else {
749		-	result = append(result, cards...)
750		-	}
	747	+	if at >= 0 {
	748	+	unfolded, unfoldedSlot = w, slot
	749	+	} else {
	750	+	result = w.pile(result, axis, slot, w != cur, -1)
751	751		}
752	752		}
753	753		for _, f := range w.Floats {

@@ -760,13 +760,16 @@ func (m *Monitor) overviewLayout(result []Placement) []Placement {
760	760		result = w.appendHidden(result, false)
761	761		}
762	762		}
763		-	return append(result, unfolded...)
	763	+	if unfolded != nil {
	764	+	result = unfolded.pile(result, axis, unfoldedSlot, false, m.cardAt(unfolded))
	765	+	}
	766	+	return result
764	767		}
765	768
766	769		// fan places front and neighboring cards, farthest visible first and front
767	770		// last. A card may contain several tiles; omitted cards stay in the layout
768	771		// hidden so their clients are not left showing on screen.
769		-	func fan(cards [][]Placement, front, maxBehind, maxBefore int, circular bool,
	772	+	func fan(cards [][]Placement, front, maxBehind, maxBefore int,
770	773		behind, before func(int) (int, int), dim, lit bool) []Placement {
771	774		n := len(cards)
772	775		if n == 0 {

@@ -792,9 +795,6 @@ func fan(cards [][]Placement, front, maxBehind, maxBefore int, circular bool,
792	795		// Behind and before are in nearest-first order; paint farthest first.
793	796		for d := min(maxBehind, n-1); d >= 1; d-- {
794	797		i := front + d
795		-	if circular {
796		-	i = (front + d) % n
797		-	}
798	798		if i >= n {
799	799		continue
800	800		}

@@ -803,13 +803,7 @@ func fan(cards [][]Placement, front, maxBehind, maxBefore int, circular bool,
803	803		}
804	804		for d := min(maxBefore, n-1); d >= 1; d-- {
805	805		i := front - d
806		-	if circular {
807		-	i = (front - d + n) % n
808		-	}
809		-	if i < 0 {
810		-	continue
811		-	}
812		-	if shown[i] {
	806	+	if i < 0 \|\| shown[i] {
813	807		continue
814	808		}
815	809		add(i, d, before, true)

@@ -837,7 +831,7 @@ func (w *Workspace) pileWidth() int {
837	831		if len(w.Stash) == 0 {
838	832		return 0
839	833		}
840		-	card := int(math.Round(float64(w.stashRect().W) * overviewCardZoom))
	834	+	card, _ := w.cardSize()
841	835		// Never more than a third of the width: the columns keep the rest.
842	836		a := w.overviewArea()
843	837		return min(card+(min(len(w.Stash), overviewCards)-1)w.cardStep()+a.W2/100, a.W/3)

@@ -867,14 +861,15 @@ func (w *Workspace) cardStep() int {
867	861		return min(overviewCardStep, a.W/100, a.H/50)
868	862		}
869	863
870		-	// pile places the stash of w as cards in its slot along axis (see the
871		-	// overview's stash comment). With entry at selected (at >= 0, on the
872		-	// current row: dim false) the pile unfolds; else it is folded, the stash
873		-	// selection in front, the next ones behind it, dimmed, the rest hidden.
874		-	func (w *Workspace) pile(axis layoutAxis, slot Rect, dim bool, at int) []Placement {
	864	+	// pile appends the stash of w to dst as cards in its slot along axis (see
	865	+	// the overview's stash comment). With entry at selected (at >= 0, on the
	866	+	// current row: dim false) the pile unfolds; else it is folded: the stash
	867	+	// selection in front, painted last, up to overviewCards-1 next ones
	868	+	// (wrapping round) behind it, farthest first, dimmed; the rest hidden.
	869	+	func (w *Workspace) pile(dst []Placement, axis layoutAxis, slot Rect, dim bool, at int) []Placement {
875	870		n := len(w.Stash)
876	871		if n == 0 {
877		-	return nil
	872	+	return dst
878	873		}
879	874		u := w.overviewArea()
880	875		cw, ch := w.cardSize()

@@ -897,16 +892,28 @@ func (w *Workspace) pile(axis layoutAxis, slot Rect, dim bool, at int) []Placeme
897	892		}
898	893		folded := Rect{X: x0, Y: y0, W: cw, H: ch}
899	894		if at >= 0 && !dim {
900		-	return w.unfold(axis, folded, min(at, n-1))
	895	+	return w.unfold(dst, axis, folded, min(at, n-1))
	896	+	}
	897	+	front, behind, step := min(max(w.stashAt, 0), n-1), min(n, overviewCards)-1, w.cardStep()
	898	+	card := func(i, d int) Placement {
	899	+	p := Placement{ID: w.Stash[i].ID, Rect: folded, Preview: overviewCardZoom, Card: true}
	900	+	p.Rect.X, p.Rect.Y = p.Rect.X+dstep, p.Rect.Y-dstep
	901	+	if d > 0 \|\| dim {
	902	+	p.peeking(1)
	903	+	}
	904	+	return p
	905	+	}
	906	+	for d := behind; d >= 0; d-- {
	907	+	dst = append(dst, card((front+d)%n, d))
901	908		}
902		-	cards := make([][]Placement, n)
903	909		for i := range w.Stash {
904		-	cards[i] = []Placement{{ID: w.Stash[i].ID, Rect: folded, Preview: overviewCardZoom, Card: true}}
	910	+	// The cards neither in front nor behind it: hidden, so their
	911	+	// clients are not left showing.
	912	+	if (i-front+n)%n > behind {
	913	+	dst = append(dst, Placement{ID: w.Stash[i].ID, Rect: folded, Card: true, Hidden: true})
	914	+	}
905	915		}
906		-	step := w.cardStep()
907		-	return fan(cards, min(max(w.stashAt, 0), n-1), min(n, overviewCards)-1, 0, true,
908		-	func(d int) (int, int) { return d * step, -d * step },
909		-	func(int) (int, int) { return 0, 0 }, dim, false)
	916	+	return dst
910	917		}
911	918
912	919		// unfold lays the stash of w out as a strip of every card along axis, from

@@ -914,8 +921,9 @@ func (w *Workspace) pile(axis layoutAxis, slot Rect, dim bool, at int) []Placeme
914	921		// a vertical one. The strip is centred on the pile and kept in the overview
915	922		// area. Longer than the area, it scrolls like a wide row: the selected card
916	923		// at is centred, the strip stopping at the area's edges. The other cards
917		-	// are dimmed; those out of the area are hidden.
918		-	func (w *Workspace) unfold(axis layoutAxis, folded Rect, at int) []Placement {
	924	+	// are dimmed; those out of the area are hidden. The cards are appended to
	925	+	// dst.
	926	+	func (w *Workspace) unfold(dst []Placement, axis layoutAxis, folded Rect, at int) []Placement {
919	927		n := len(w.Stash)
920	928		u := w.overviewArea()
921	929		size, origin, lo, hi := folded.W, folded.X, u.X, u.X+u.W

@@ -931,7 +939,6 @@ func (w *Workspace) unfold(axis layoutAxis, folded Rect, at int) []Placement {
931	939		} else {
932	940		start = min(max(start, lo), hi-total)
933	941		}
934		-	out := make([]Placement, n)
935	942		for i := range w.Stash {
936	943		r := folded
937	944		if axis == verticalAxis {

@@ -946,9 +953,9 @@ func (w *Workspace) unfold(axis layoutAxis, folded Rect, at int) []Placement {
946	953		if !r.Overlaps(u) {
947	954		p.Hidden, p.Preview, p.Focused = true, 0, false
948	955		}
949		-	out[i] = p
	956	+	dst = append(dst, p)
950	957		}
951		-	return out
	958	+	return dst
952	959		}
953	960
954	961		// overviewZoom is the scale that fits every column of w in the usable

@@ -1138,7 +1145,8 @@ func (w *Workspace) previewRowTiles(axis layoutAxis, slot Rect, dim, lit, lanes
1138	1145		}
1139	1146		// Rows stay centred on the output like rows without a stash; in a
1140	1147		// vertical overview the pile only pushes a row right when they would
1141		-	// overlap. A horizontal one draws the pile over the row.
	1148	+	// overlap. A horizontal one gives the pile a band under the selected
	1149	+	// lane (pileBand).
1142	1150		left := 0
1143	1151		if axis == verticalAxis {
1144	1152		left = w.pileWidth()

@@ -1312,9 +1320,8 @@ func overviewIn(layout []Placement, x, y float64) WindowID {
1312	1320		return 0
1313	1321		}
1314	1322
1315		-	// overviewHit is overviewIn with the stash piles first: a pile is drawn
1316		-	// over its row (a horizontal overview), the cards behind its front one
1317		-	// included.
	1323	+	// overviewHit is overviewIn with the stash piles first: the cards behind a
	1324	+	// folded pile's front one peek out where tiles may be drawn over them.
1318	1325		func (m *Monitor) overviewHit(layout []Placement, x, y float64) WindowID {
1319	1326		var piles []Placement
1320	1327		for _, p := range layout {

 // unfolds along the overview axis into a strip of every card (unfold), the
 // selection framed, and the moves along that axis walk it. A vertical
 // overview pins the pile to the left edge of its row, which takes the width
-// the pile leaves. A horizontal one centres it on its row, straddling the
+// the pile leaves. A horizontal one centres it on its row, in a band
-// bottom edge of the selected lane, over the tiles.
+// reserved under the selected lane (pileBand): the lane and the band are
+// centred together.
 const (
 	overviewCardZoom = 0.2
 	overviewCards    = 4
 //
 // Vertical axis: full-width slots, the current one centred; the rule is
 // horizontal. Horizontal axis: full-height slots as wide as their content,
-// stack peeks included (the stash pile sits over the row), the current one
+// stack peeks included (the stash pile takes a band of the slot), the current one
 // centred; the rule is vertical, in the spacing between two slots.
 func (m *Monitor) overviewRows() (map[*Workspace]Rect, []ports.Separator) {
 	cur := m.Current()
 	axis := m.overviewAxis()
 	// The unfolded stash goes last: its strip may run over the neighbor
 	// rows, which must not cover it.
-	var unfolded []Placement
+	var unfolded *Workspace
+	var unfoldedSlot Rect
 	for w := range m.all() {
 		slot, shown := rows[w]
 		if shown {
 			slot.H -= w.pileBand(axis)
 			at := m.cardAt(w)
 			result = append(result, m.stackRow(w, axis, slot, w != cur, at < 0)...)
-			if len(w.Stash) > 0 {
+			if at >= 0 {
-				if cards := w.pile(axis, slot, w != cur, at); at >= 0 {
+				unfolded, unfoldedSlot = w, slot
-					unfolded = cards
+			} else {
-				} else {
+				result = w.pile(result, axis, slot, w != cur, -1)
-					result = append(result, cards...)
-				}
 			}
 		}
 		for _, f := range w.Floats {
 			result = w.appendHidden(result, false)
 		}
 	}
-	return append(result, unfolded...)
+	if unfolded != nil {
+		result = unfolded.pile(result, axis, unfoldedSlot, false, m.cardAt(unfolded))
+	}
+	return result
 }
 // fan places front and neighboring cards, farthest visible first and front
 // last. A card may contain several tiles; omitted cards stay in the layout
 // hidden so their clients are not left showing on screen.
-func fan(cards [][]Placement, front, maxBehind, maxBefore int, circular bool,
+func fan(cards [][]Placement, front, maxBehind, maxBefore int,
 	behind, before func(int) (int, int), dim, lit bool) []Placement {
 	n := len(cards)
 	if n == 0 {
 	// Behind and before are in nearest-first order; paint farthest first.
 	for d := min(maxBehind, n-1); d >= 1; d-- {
 		i := front + d
-		if circular {
-			i = (front + d) % n
-		}
 		if i >= n {
 			continue
 		}
 	}
 	for d := min(maxBefore, n-1); d >= 1; d-- {
 		i := front - d
-		if circular {
+		if i < 0 || shown[i] {
-			i = (front - d + n) % n
-		}
-		if i < 0 {
-			continue
-		}
-		if shown[i] {
 			continue
 		}
 		add(i, d, before, true)
 	if len(w.Stash) == 0 {
 		return 0
 	}
-	card := int(math.Round(float64(w.stashRect().W) * overviewCardZoom))
+	card, _ := w.cardSize()
 	// Never more than a third of the width: the columns keep the rest.
 	a := w.overviewArea()
 	return min(card+(min(len(w.Stash), overviewCards)-1)*w.cardStep()+a.W*2/100, a.W/3)
 	return min(overviewCardStep, a.W/100, a.H/50)
 }
-// pile places the stash of w as cards in its slot along axis (see the
+// pile appends the stash of w to dst as cards in its slot along axis (see
-// overview's stash comment). With entry at selected (at >= 0, on the
+// the overview's stash comment). With entry at selected (at >= 0, on the
-// current row: dim false) the pile unfolds; else it is folded, the stash
+// current row: dim false) the pile unfolds; else it is folded: the stash
-// selection in front, the next ones behind it, dimmed, the rest hidden.
+// selection in front, painted last, up to overviewCards-1 next ones
-func (w *Workspace) pile(axis layoutAxis, slot Rect, dim bool, at int) []Placement {
+// (wrapping round) behind it, farthest first, dimmed; the rest hidden.
+func (w *Workspace) pile(dst []Placement, axis layoutAxis, slot Rect, dim bool, at int) []Placement {
 	n := len(w.Stash)
 	if n == 0 {
-		return nil
+		return dst
 	}
 	u := w.overviewArea()
 	cw, ch := w.cardSize()
 	}
 	folded := Rect{X: x0, Y: y0, W: cw, H: ch}
 	if at >= 0 && !dim {
-		return w.unfold(axis, folded, min(at, n-1))
+		return w.unfold(dst, axis, folded, min(at, n-1))
+	}
+	front, behind, step := min(max(w.stashAt, 0), n-1), min(n, overviewCards)-1, w.cardStep()
+	card := func(i, d int) Placement {
+		p := Placement{ID: w.Stash[i].ID, Rect: folded, Preview: overviewCardZoom, Card: true}
+		p.Rect.X, p.Rect.Y = p.Rect.X+d*step, p.Rect.Y-d*step
+		if d > 0 || dim {
+			p.peeking(1)
+		}
+		return p
+	}
+	for d := behind; d >= 0; d-- {
+		dst = append(dst, card((front+d)%n, d))
 	}
-	cards := make([][]Placement, n)
 	for i := range w.Stash {
-		cards[i] = []Placement{{ID: w.Stash[i].ID, Rect: folded, Preview: overviewCardZoom, Card: true}}
+		// The cards neither in front nor behind it: hidden, so their
+		// clients are not left showing.
+		if (i-front+n)%n > behind {
+			dst = append(dst, Placement{ID: w.Stash[i].ID, Rect: folded, Card: true, Hidden: true})
+		}
 	}
-	step := w.cardStep()
+	return dst
-	return fan(cards, min(max(w.stashAt, 0), n-1), min(n, overviewCards)-1, 0, true,
-		func(d int) (int, int) { return d * step, -d * step },
-		func(int) (int, int) { return 0, 0 }, dim, false)
 }
 // unfold lays the stash of w out as a strip of every card along axis, from
 // a vertical one. The strip is centred on the pile and kept in the overview
 // area. Longer than the area, it scrolls like a wide row: the selected card
 // at is centred, the strip stopping at the area's edges. The other cards
-// are dimmed; those out of the area are hidden.
+// are dimmed; those out of the area are hidden. The cards are appended to
-func (w *Workspace) unfold(axis layoutAxis, folded Rect, at int) []Placement {
+// dst.
+func (w *Workspace) unfold(dst []Placement, axis layoutAxis, folded Rect, at int) []Placement {
 	n := len(w.Stash)
 	u := w.overviewArea()
 	size, origin, lo, hi := folded.W, folded.X, u.X, u.X+u.W
 	} else {
 		start = min(max(start, lo), hi-total)
 	}
-	out := make([]Placement, n)
 	for i := range w.Stash {
 		r := folded
 		if axis == verticalAxis {
 		if !r.Overlaps(u) {
 			p.Hidden, p.Preview, p.Focused = true, 0, false
 		}
-		out[i] = p
+		dst = append(dst, p)
 	}
-	return out
+	return dst
 }
 // overviewZoom is the scale that fits every column of w in the usable
 	}
 	// Rows stay centred on the output like rows without a stash; in a
 	// vertical overview the pile only pushes a row right when they would
-	// overlap. A horizontal one draws the pile over the row.
+	// overlap. A horizontal one gives the pile a band under the selected
+	// lane (pileBand).
 	left := 0
 	if axis == verticalAxis {
 		left = w.pileWidth()
 	return 0
 }
-// overviewHit is overviewIn with the stash piles first: a pile is drawn
+// overviewHit is overviewIn with the stash piles first: the cards behind a
-// over its row (a horizontal overview), the cards behind its front one
+// folded pile's front one peek out where tiles may be drawn over them.
-// included.
 func (m *Monitor) overviewHit(layout []Placement, x, y float64) WindowID {
 	var piles []Placement
 	for _, p := range layout {

M internal/core/overview_stack.go +1 -1


@@ -366,6 +366,6 @@ func (m Monitor) stackRow(w Workspace, axis layoutAxis, slot Rect, dim, lit bo
366	366		}
367	367
368	368		// fan's behind side advances through the linear stack.
369		-	return fan(cards, at, 2, 2, false,
	369	+	return fan(cards, at, 2, 2,
370	370		func(d int) (int, int) { return along(-d) }, along, dim, lit)
371	371		}


@@ -366,6 +366,6 @@ func (m Monitor) stackRow(w Workspace, axis layoutAxis, slot Rect, dim, lit bo
366		}	366		}
367			367
368		// fan's behind side advances through the linear stack.	368		// fan's behind side advances through the linear stack.
369	-	return fan(cards, at, 2, 2, false,	369	+	return fan(cards, at, 2, 2,
370		func(d int) (int, int) { return along(-d) }, along, dim, lit)	370		func(d int) (int, int) { return along(-d) }, along, dim, lit)
371		}	371		}

M internal/core/overview_unfold_test.go +24 -0


@@ -159,6 +159,30 @@ func TestOverviewStashUnfoldScrolls(t *testing.T) {
159	159		}
160	160		}
161	161
	162	+	// The stash pile, folded or unfolded, is laid out straight into the
	163	+	// overview layout every frame: it adds no allocation to the same layout
	164	+	// without a stash.
	165	+	func TestOverviewStashLayoutAllocations(t *testing.T) {
	166	+	allocs := func(m *Monitor) float64 {
	167	+	buf := m.layoutInto(nil)
	168	+	return testing.AllocsPerRun(50, func() { buf = m.layoutInto(buf) })
	169	+	}
	170	+	bare := cascadeOverview()
	171	+	bare.ToggleOverview()
	172	+	want := allocs(bare)
	173	+	for _, unfolded := range []bool{false, true} {
	174	+	m := cascadeOverview()
	175	+	withStash(m, 6)
	176	+	m.ToggleOverview()
	177	+	if unfolded {
	178	+	m.selectCard(m.Current(), 0)
	179	+	}
	180	+	if got := allocs(m); got > want {
	181	+	t.Errorf("unfolded %v: %v allocs per layout, %v without a stash", unfolded, got, want)
	182	+	}
	183	+	}
	184	+	}
	185	+
162	186		// A scroll overview unfolds its pile into a column on the left of the row;
163	187		// up and down walk it, right goes back to the columns.
164	188		func TestOverviewScrollStashUnfolds(t *testing.T) {


@@ -159,6 +159,30 @@ func TestOverviewStashUnfoldScrolls(t *testing.T) {
159	}	159		}
160	}	160		}
161		161
		162	+	// The stash pile, folded or unfolded, is laid out straight into the
		163	+	// overview layout every frame: it adds no allocation to the same layout
		164	+	// without a stash.
		165	+	func TestOverviewStashLayoutAllocations(t *testing.T) {
		166	+	allocs := func(m *Monitor) float64 {
		167	+	buf := m.layoutInto(nil)
		168	+	return testing.AllocsPerRun(50, func() { buf = m.layoutInto(buf) })
		169	+	}
		170	+	bare := cascadeOverview()
		171	+	bare.ToggleOverview()
		172	+	want := allocs(bare)
		173	+	for _, unfolded := range []bool{false, true} {
		174	+	m := cascadeOverview()
		175	+	withStash(m, 6)
		176	+	m.ToggleOverview()
		177	+	if unfolded {
		178	+	m.selectCard(m.Current(), 0)
		179	+	}
		180	+	if got := allocs(m); got > want {
		181	+	t.Errorf("unfolded %v: %v allocs per layout, %v without a stash", unfolded, got, want)
		182	+	}
		183	+	}
		184	+	}
		185	+
162	// A scroll overview unfolds its pile into a column on the left of the row;	186		// A scroll overview unfolds its pile into a column on the left of the row;
163	// up and down walk it, right goes back to the columns.	187		// up and down walk it, right goes back to the columns.
164	func TestOverviewScrollStashUnfolds(t *testing.T) {	188		func TestOverviewScrollStashUnfolds(t *testing.T) {