From 6a6a4993338262f87df34c9be051bfaac75c1829 Mon Sep 17 00:00:00 2001 From: kim <89579420+NyaaaWhatsUpDoc@users.noreply.github.com> Date: Sat, 26 Apr 2025 09:56:15 +0000 Subject: [performance] rewrite timelines to rely on new timeline cache type (#3941) * start work rewriting timeline cache type * further work rewriting timeline caching * more work integration new timeline code * remove old code * add local timeline, fix up merge conflicts * remove old use of go-bytes * implement new timeline code into more areas of codebase, pull in latest go-mangler, go-mutexes, go-structr * remove old timeline package, add local timeline cache * remove references to old timeline types that needed starting up in tests * start adding page validation * fix test-identified timeline cache package issues * fix up more tests, fix missing required changes, etc * add exclusion for test.out in gitignore * clarify some things better in code comments * tweak cache size limits * fix list timeline cache fetching * further list timeline fixes * linter, ssssssssshhhhhhhhhhhh please * fix linter hints * reslice the output if it's beyond length of 'lim' * remove old timeline initialization code, bump go-structr to v0.9.4 * continued from previous commit * improved code comments * don't allow multiple entries for BoostOfID values to prevent repeated boosts of same boosts * finish writing more code comments * some variable renaming, for ease of following * change the way we update lo,hi paging values during timeline load * improved code comments for updated / returned lo , hi paging values * finish writing code comments for the StatusTimeline{} type itself * fill in more code comments * update go-structr version to latest with changed timeline unique indexing logic * have a local and public timeline *per user* * rewrite calls to public / local timeline calls * remove the zero length check, as lo, hi values might still be set * simplify timeline cache loading, fix lo/hi returns, fix timeline invalidation side-effects missing for some federated actions * swap the lo, hi values :facepalm: * add (now) missing slice reverse of tag timeline statuses when paging ASC * remove local / public caches (is out of scope for this work), share more timeline code * remove unnecessary change * again, remove more unused code * remove unused function to appease the linter * move boost checking to prepare function * fix use of timeline.lastOrder, fix incorrect range functions used * remove comments for repeat code * remove the boost logic from prepare function * do a maximum of 5 loads, not 10 * add repeat boost filtering logic, update go-structr, general improvements * more code comments * add important note * fix timeline tests now that timelines are returned in page order * remove unused field * add StatusTimeline{} tests * add more status timeline tests * start adding preloading support * ensure repeat boosts are marked in preloaded entries * share a bunch of the database load code in timeline cache, don't clear timelines on relationship change * add logic to allow dynamic clear / preloading of timelines * comment-out unused functions, but leave in place as we might end-up using them * fix timeline preload state check * much improved status timeline code comments * more code comments, don't bother inserting statuses if timeline not preloaded * shift around some logic to make sure things aren't accidentally left set * finish writing code comments * remove trim-after-insert behaviour * fix-up some comments referring to old logic * remove unsetting of lo, hi * fix preload repeatBoost checking logic * don't return on status filter errors, these are usually transient * better concurrency safety in Clear() and Done() * fix test broken due to addition of preloader * fix repeatBoost logic that doesn't account for already-hidden repeatBoosts * ensure edit submodels are dropped on cache insertion * update code-comment to expand CAS accronym * use a plus1hULID() instead of 24h * remove unused functions * add note that public / local timeline requester can be nil * fix incorrect visibility filtering of tag timeline statuses * ensure we filter home timeline statuses on local only * some small re-orderings to confirm query params in correct places * fix the local only home timeline filter func --- vendor/codeberg.org/gruf/go-structr/timeline.go | 44 ++++++++++++++++++++----- 1 file changed, 35 insertions(+), 9 deletions(-) (limited to 'vendor/codeberg.org/gruf/go-structr/timeline.go') diff --git a/vendor/codeberg.org/gruf/go-structr/timeline.go b/vendor/codeberg.org/gruf/go-structr/timeline.go index 0eb1e3aa5..0014e69ee 100644 --- a/vendor/codeberg.org/gruf/go-structr/timeline.go +++ b/vendor/codeberg.org/gruf/go-structr/timeline.go @@ -190,7 +190,8 @@ func (t *Timeline[T, PK]) Select(min, max *PK, length *int, dir Direction) (valu // Insert will insert the given values into the timeline, // calling any set invalidate hook on each inserted value. -func (t *Timeline[T, PK]) Insert(values ...T) { +// Returns current list length after performing inserts. +func (t *Timeline[T, PK]) Insert(values ...T) int { // Acquire lock. t.mutex.Lock() @@ -269,6 +270,10 @@ func (t *Timeline[T, PK]) Insert(values ...T) { // Get func ptrs. invalid := t.invalid + // Get length AFTER + // insert to return. + len := t.list.len + // Done with lock. t.mutex.Unlock() @@ -279,6 +284,8 @@ func (t *Timeline[T, PK]) Insert(values ...T) { invalid(value) } } + + return len } // Invalidate invalidates all entries stored in index under given keys. @@ -336,8 +343,8 @@ func (t *Timeline[T, PK]) Invalidate(index *Index, keys ...Key) { // // Please note that the entire Timeline{} will be locked for the duration of the range // operation, i.e. from the beginning of the first yield call until the end of the last. -func (t *Timeline[T, PK]) Range(dir Direction) func(yield func(T) bool) { - return func(yield func(T) bool) { +func (t *Timeline[T, PK]) Range(dir Direction) func(yield func(index int, value T) bool) { + return func(yield func(int, T) bool) { if t.copy == nil { panic("not initialized") } else if yield == nil { @@ -348,7 +355,9 @@ func (t *Timeline[T, PK]) Range(dir Direction) func(yield func(T) bool) { t.mutex.Lock() defer t.mutex.Unlock() + var i int switch dir { + case Asc: // Iterate through linked list from bottom (i.e. tail). for prev := t.list.tail; prev != nil; prev = prev.prev { @@ -360,9 +369,12 @@ func (t *Timeline[T, PK]) Range(dir Direction) func(yield func(T) bool) { value := t.copy(item.data.(T)) // Pass to given function. - if !yield(value) { + if !yield(i, value) { break } + + // Iter + i++ } case Desc: @@ -376,9 +388,12 @@ func (t *Timeline[T, PK]) Range(dir Direction) func(yield func(T) bool) { value := t.copy(item.data.(T)) // Pass to given function. - if !yield(value) { + if !yield(i, value) { break } + + // Iter + i++ } } } @@ -390,8 +405,8 @@ func (t *Timeline[T, PK]) Range(dir Direction) func(yield func(T) bool) { // // Please note that the entire Timeline{} will be locked for the duration of the range // operation, i.e. from the beginning of the first yield call until the end of the last. -func (t *Timeline[T, PK]) RangeUnsafe(dir Direction) func(yield func(T) bool) { - return func(yield func(T) bool) { +func (t *Timeline[T, PK]) RangeUnsafe(dir Direction) func(yield func(index int, value T) bool) { + return func(yield func(int, T) bool) { if t.copy == nil { panic("not initialized") } else if yield == nil { @@ -402,7 +417,9 @@ func (t *Timeline[T, PK]) RangeUnsafe(dir Direction) func(yield func(T) bool) { t.mutex.Lock() defer t.mutex.Unlock() + var i int switch dir { + case Asc: // Iterate through linked list from bottom (i.e. tail). for prev := t.list.tail; prev != nil; prev = prev.prev { @@ -411,9 +428,12 @@ func (t *Timeline[T, PK]) RangeUnsafe(dir Direction) func(yield func(T) bool) { item := (*timeline_item)(prev.data) // Pass to given function. - if !yield(item.data.(T)) { + if !yield(i, item.data.(T)) { break } + + // Iter + i++ } case Desc: @@ -424,9 +444,12 @@ func (t *Timeline[T, PK]) RangeUnsafe(dir Direction) func(yield func(T) bool) { item := (*timeline_item)(next.data) // Pass to given function. - if !yield(item.data.(T)) { + if !yield(i, item.data.(T)) { break } + + // Iter + i++ } } } @@ -1033,6 +1056,9 @@ indexing: // checking for collisions. if !idx.add(key, i_item) { + // This key already appears + // in this unique index. So + // drop new timeline item. t.delete(t_item) free_buffer(buf) return last -- cgit v1.2.3