Split reflists to share their contents across snapshots [take 2]

[refi64]

Description of the Change

(See the bottom of this message for the changes since #1235.)

In current aptly, each repository and snapshot has its own reflist in the database. This brings a few problems with it:

• Given a sufficiently large repositories and snapshots, these lists can get enormous, reaching >1MB. This is a problem for LevelDB's overall performance, as it tends to prefer values around the confiruged block size (defaults to just 4KiB).
• When you take these large repositories and snapshot them, you have a full, new copy of the reflist, even if only a few packages changed. This means that having a lot of snapshots with a few changes causes the database to basically be full of largely duplicate reflists.
• All the duplication also means that many of the same refs are being loaded repeatedly, which can cause some slowdown but, more notably, eats up huge amounts of memory.
• Adding on more and more new repositories and snapshots will cause the time and memory spent on things like cleanup and publishing to grow roughly linearly.

At the core, there are two problems here:

• Reflists get very big because there are just a lot of packages.
• Different reflists can tend to duplicate much of the same contents.

Split reflists aim at solving this by separating reflists into 64 buckets. Package refs are sorted into individual buckets according to the following system:

• Take the first 3 letters of the package name, after dropping a lib prefix. (Using only the first 3 letters will cause packages with similar prefixes to end up in the same bucket, under the assumption that packages with similar names tend to be updated together.)
• Take the 64-bit xxhash of these letters. (xxhash was chosen because it relatively good distribution across the individual bits, which is important for the next step.)
• Use the first 6 bits of the hash (range [0:63]) as an index into the buckets.

Once refs are placed in buckets, a sha256 digest of all the refs in the bucket is taken. These buckets are then stored in the database, split into roughly block-sized segments, and all the repositories and snapshots simply store an array of bucket digests.

This approach means that repositories and snapshots can share their reflist buckets. If a snapshot is taken of a repository, it will have the same contents, so its split reflist will point to the same buckets as the base repository, and only one copy of each bucket is stored in the database. When some packages in the repository change, only the buckets containing those packages will be modified; all the other buckets will remain unchanged, and thus their contents will still be shared. Later on, when these reflists are loaded, each bucket is only loaded once, short-cutting loaded many megabytes of data. In effect, split reflists are essentially copy-on-write, with only the changed buckets stored individually.

Changing the disk format means that a migration needs to take place, so that task is moved into the database cleanup step, which will migrate reflists over to split reflists, as well as delete any unused reflist buckets.

All the reflist tests are also changed to additionally test out split reflists; although the internal logic is all shared (since buckets are, themselves, just normal reflists), some special additions are needed to have native versions of the various reflist helper methods.

In our tests, we've observed the following improvements:

• Memory usage during publish and database cleanup, with GOMEMLIMIT=2GiB, goes down from ~3.2GiB (larger than the memory limit!) to ~0.7GiB, a decrease of ~4.5x.
• Database size decreases from 1.3GB to 367MB.

In my local tests, publish times had also decreased down to mere seconds but the same effect wasn't observed on the server, with the times staying around the same. My suspicions are that this is due to I/O performance: my local system is an M1 MBP, which almost certainly has much faster disk speeds than our DigitalOcean block volumes. Split reflists include a side effect of requiring more random accesses from reading all the buckets by their keys, so if your random I/O performance is slower, it might cancel out the benefits. That being said, even in that case, the memory usage and database size advantages still persist.

---

Since #1235 and #1282, there were a few improvements:

• I did a fresh rebase on the latest git branch.
• Some strange / problematic edge-case behavior and error handling was fixed.
• Tests were improved.

During this time, we've kept split reflists running on our infra, with no major issues stemming from it. Additionally, the number of snapshots in the database grew to over 200k, with nearly 70k of those actually published (the reason for this difference is some gaps in our cleanup, oops). Despite that growth, the total database size is ~1.5GiB, which is barely larger than our original database was with just a few thousand snapshots.

Checklist

• allow Maintainers to edit PR (rebase, run coverage, help with tests, ...)
• unit-test added (if change is algorithm)
• functional test added/updated (if change is functional)
• man page updated (if applicable)
• bash completion updated (if applicable)
• documentation updated
• author name in AUTHORS

[codecov]

Codecov Report

❌ Patch coverage is 81.75270% with 152 lines in your changes missing coverage. Please review.
✅ Project coverage is 77.17%. Comparing base (f59b0d2) to head (3315dd1).

Files with missing lines	Patch %	Lines
deb/reflist.go	86.49%	31 Missing and 21 partials ⚠️
api/db.go	17.02%	35 Missing and 4 partials ⚠️
cmd/db_cleanup.go	67.04%	20 Missing and 9 partials ⚠️
deb/publish.go	78.26%	5 Missing and 5 partials ⚠️
deb/local.go	76.47%	2 Missing and 2 partials ⚠️
deb/remote.go	75.00%	2 Missing and 2 partials ⚠️
deb/snapshot.go	78.94%	2 Missing and 2 partials ⚠️
api/repos.go	88.00%	3 Missing ⚠️
cmd/mirror_show.go	85.71%	1 Missing and 1 partial ⚠️
cmd/snapshot_show.go	87.50%	1 Missing and 1 partial ⚠️
... and 2 more

Additional details and impacted files

@@            Coverage Diff             @@
##           master    #1606      +/-   ##
==========================================
- Coverage   77.37%   77.17%   -0.21%     
==========================================
  Files         165      165              
  Lines       15747    16275     +528     
==========================================
+ Hits        12185    12560     +375     
- Misses       2356     2478     +122     
- Partials     1206     1237      +31     

☔ View full report in Codecov by Harness.
📢 Have feedback on the report? Share it here.

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.