Merge branch 'perf/subseq-dp' of https://github.com/4RH1T3CT0R7/kitty

This commit is contained in:
Kovid Goyal 2026-09-26 07:55:16 +05:30
commit 5f05ab7e00
No known key found for this signature in database
GPG key ID: 06BC317B515ACE7C
3 changed files with 154 additions and 64 deletions

View file

@ -221,6 +221,9 @@ Detailed list of changes
- diff kitten: Fix freezes and very high memory use when a very long line, such
as in a minified file, is changed
- themes and choose fonts kittens: Fix search freezing for many seconds when
typing a long query, such as the full name of a theme
0.49.1 [2026-09-24]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

View file

@ -53,7 +53,8 @@ func level_factor_for(current_lcase, last_lcase, current_cased, last_cased rune,
type workspace_type struct {
positions [][]int // positions of each needle char in haystack
level_factors []int
address []int
best []float64 // highest score of a match ending at each position of each needle char, flattened
prev []int // index into the positions of the previous needle char for that match
max_score_per_char float64
}
@ -75,62 +76,13 @@ func (w *workspace_type) initialize(haystack_sz, needle_sz int) {
w.positions[i] = w.positions[i][:0]
}
}
if cap(w.address) < needle_sz {
w.address = make([]int, needle_sz)
}
w.address = utils.Memset(w.address)
}
func (w *workspace_type) position(x int) int { // the position of xth needle char in the haystack for the current address
return w.positions[x][w.address[x]]
}
func (w *workspace_type) increment_address() bool {
pos := len(w.positions) - 1 // the last needle char
for {
w.address[pos]++
if w.address[pos] < len(w.positions[pos]) {
return true
}
if pos == 0 {
break
}
w.address[pos] = 0
pos--
func (w *workspace_type) char_score(pos, distance int) float64 {
if w.level_factors[pos] > 0 {
return (100.0 * w.max_score_per_char) / float64(w.level_factors[pos]) // at a special location
}
return false
}
func (w *workspace_type) address_is_monotonic() bool {
// Check if the character positions pointed to by the current address are monotonic
for i := 1; i < len(w.positions); i++ {
if w.position(i) <= w.position(i-1) {
return false
}
}
return true
}
func (w *workspace_type) calc_score() (ans float64) {
distance, pos := 0, 0
for i := range len(w.positions) {
pos = w.position(i)
if i == 0 {
distance = pos + 1
} else {
distance = pos - w.position(i-1)
if distance < 2 {
ans += w.max_score_per_char // consecutive chars
continue
}
}
if w.level_factors[pos] > 0 {
ans += (100.0 * w.max_score_per_char) / float64(w.level_factors[pos]) // at a special location
} else {
ans += (0.75 * w.max_score_per_char) / float64(distance)
}
}
return
return (0.75 * w.max_score_per_char) / float64(distance)
}
func has_atleast_one_match(w *workspace_type) (found bool) {
@ -177,21 +129,52 @@ func score_item(item string, idx int, needle []rune, opts *resolved_options_type
if !has_atleast_one_match(w) {
return ans
}
var score float64
for {
if w.address_is_monotonic() {
score = w.calc_score()
if score > ans.Score {
ans.Score = score
for i := range ans.Positions {
ans.Positions[i] = w.position(i)
// Find the highest scoring monotonic positions one needle char at a time
n := 0
for _, positions := range w.positions {
n += len(positions)
}
if cap(w.best) < n {
w.best, w.prev = make([]float64, 2*n), make([]int, 2*n)
}
for k, pos := range w.positions[0] {
w.best[k] = w.char_score(pos, pos+1)
}
off := 0 // offset of the entries for the previous needle char in best
for j := 1; j < len(w.positions); j++ {
prev_positions, next_off := w.positions[j-1], off+len(w.positions[j-1])
for k, pos := range w.positions[j] {
score, from := 0.0, 0
for i := 0; i < len(prev_positions) && prev_positions[i] < pos; i++ {
s := w.best[off+i]
if s == 0 { // no match ends here, all scores are > 0
continue
}
if distance := pos - prev_positions[i]; distance < 2 {
s += w.max_score_per_char // consecutive chars
} else {
s += w.char_score(pos, distance)
}
if s > score {
score, from = s, i
}
}
w.best[next_off+k], w.prev[next_off+k] = score, from
}
if !w.increment_address() {
break
off = next_off
}
last, k := len(w.positions)-1, 0
for i := range len(w.positions[last]) {
if w.best[off+i] > ans.Score {
ans.Score, k = w.best[off+i], i
}
}
for j := last; j > 0; j-- {
ans.Positions[j] = w.positions[j][k]
k = w.prev[off+k]
off -= len(w.positions[j-1])
}
ans.Positions[0] = w.positions[0][k]
if ans.Score > 0 {
adjust := utils.RuneOffsetsToByteOffsets(item)
for i := range ans.Positions {

View file

@ -5,6 +5,8 @@ package subseq
import (
"fmt"
"github.com/kovidgoyal/kitty/tools/utils"
"math/rand"
"slices"
"strconv"
"strings"
"testing"
@ -97,3 +99,105 @@ func TestSubseq(t *testing.T) {
}
simple(strings.Join(items, "\n"), "2", expected...)
}
var theme_names = []string{
"1984 Dark", "Adwaita darker", "Aquarium Light", "Atelier Plateau Dark", "Ayu Mirage", "Base2Tone Heath Dark",
"Base2Tone Sea Dark", "Base4Tone_Modern_W Dark", "Bluloco Dark", "C64", "Catppuccin-Latte", "Chalkboard",
"Copland OS", "Darkside", "Doom Vibrant", "Earthsong", "Everforest Light Hard", "Flexoki (Dark)",
"GitHub Dark Colorblind", "GitHub Light High Contrast", "Gnome-ish gray-on-black", "Gruvbox Light Soft",
"Gruvbox Material Light Medium", "HardHacker", "IC Green PPL", "Kanagawa_dragon", "Kibble", "Linh", "Mayukai",
"Modus Vivendi", "N0tch2k", "Nord", "One Half Dark", "Pastel EGA", "Red Alert", "Ryoccino", "Selenized White",
"Serendipity Sunset", "Soft Server", "Solarized Dark Higher Contrast", "Sonokai Sushia", "Spring", "Teerb",
"Tokyo Night", "Tomorrow", "Tomorrow Night Eighties", "Ubuntu", "Wez", "Yorumi Kraken", "ferra", "pink lavender",
"zenbones_light",
}
func score_positions(w *workspace_type, positions []int) (ans float64) {
for i, pos := range positions {
distance := pos + 1
if i > 0 {
distance = pos - positions[i-1]
if distance < 2 {
ans += w.max_score_per_char
continue
}
}
if w.level_factors[pos] > 0 {
ans += (100.0 * w.max_score_per_char) / float64(w.level_factors[pos])
} else {
ans += (0.75 * w.max_score_per_char) / float64(distance)
}
}
return
}
// Try every monotonic set of positions for the item last scored with w
func brute_force(w *workspace_type) (best float64) {
positions := make([]int, len(w.positions))
var recurse func(j int)
recurse = func(j int) {
if j == len(positions) {
best = max(best, score_positions(w, positions))
return
}
for _, pos := range w.positions[j] {
if j == 0 || pos > positions[j-1] {
positions[j] = pos
recurse(j + 1)
}
}
}
recurse(0)
return
}
func TestSubseqBruteForce(t *testing.T) {
opts := resolved_options_type{level1: []rune(" "), level2: []rune(LEVEL2), level3: []rune(LEVEL3)}
w := workspace_type{}
r := rand.New(rand.NewSource(1))
for range 200 {
name := []rune(strings.ToLower(theme_names[r.Intn(len(theme_names))]))
idx := r.Perm(len(name))[:1+r.Intn(min(6, len(name)))]
slices.Sort(idx)
needle := make([]rune, len(idx))
for i, x := range idx {
needle[i] = name[x]
}
for _, item := range theme_names {
m := score_item(item, 0, needle, &opts, &w)
if expected := brute_force(&w); m.Score != expected {
t.Fatalf("Score for %#v in %#v: %v != %v", string(needle), item, m.Score, expected)
}
if m.Score > 0 {
ok := score_positions(&w, m.Positions) == m.Score
for i, pos := range m.Positions {
ok = ok && strings.ToLower(item)[pos] == byte(needle[i]) && (i == 0 || pos > m.Positions[i-1])
}
if !ok {
t.Fatalf("Positions for %#v in %#v: %v do not give the score %v", string(needle), item, m.Positions, m.Score)
}
}
}
}
// the old code tried every combination of positions here, which never finishes
m := ScoreItems(strings.Repeat("a", 100), []string{strings.Repeat("a", 200)}, Options{})[0]
expected := make([]int, 100)
for i := range expected {
expected[i] = i
}
if diff := cmp.Diff(expected, m.Positions); diff != "" {
t.Fatalf("Failed positions for long needle:\n%s", diff)
}
}
func BenchmarkScoreItems(b *testing.B) {
for _, query := range []string{"dark", "tokyo night", "solarized dark higher contrast"} {
b.Run(query, func(b *testing.B) {
for b.Loop() {
for i := range len(query) { // as if typed one char at a time
ScoreItems(query[:i+1], theme_names, Options{Level1: " "})
}
}
})
}
}