From 589cb500fa5a6df13fa9634d0071922ec11fce17 Mon Sep 17 00:00:00 2001 From: Dirk Engling Date: Sat, 7 Nov 2026 19:39:01 +0100 Subject: Unify the peerlists for v4 and v6 This commit finishes what started with unifying v4 and v6 trackers, from then on, torrents carried a peer list per family, with obvious redundancies. With the race to save memory, these became burdening enough that now these peerlist pointers have been moved into a single struct, holding both v4 and v6 peers in their respective ot_vectors, so the per- torrent cost shrunk by another pointer's size. Each peerlist also lost its peer count cache, as in most cases, it's trivial to load it directly from the ot_vector's entry count. The seed counts that were kept per family only to be aggregated later for every consumer, are also merged now. Total savings depend on the tracker's actual load. In some corner cases, where only one address family dominates the torrents, we actually use a few bytes more in the ot_vector for the absent family, but even that mostly becomes noise: before it actually adds to the memory load, the peer payload will be the deciding factor. Most wins are on what often is experienced on trackers: A long tail of abandoned torrents now needs eight fewer bytes, slipping into a smaller allocation unit on glibc's allocator. --- src/ot_clean.c | 64 ++++++++++++++++++++++++++++++++-------------------------- 1 file changed, 35 insertions(+), 29 deletions(-) (limited to 'src/ot_clean.c') diff --git a/src/ot_clean.c b/src/ot_clean.c index 9e2186f..130bd2a 100644 --- a/src/ot_clean.c +++ b/src/ot_clean.c @@ -51,51 +51,48 @@ static ssize_t clean_single_bucket(ot_peer *peers, size_t peer_count, size_t pee return (peers - insert_point) / peer_size; } -/* Age one family's peers by timedout minutes. Frees the list and clears the - slot once its last peer is gone, so an absent family costs nothing. */ -static void clean_peer_list_family(ot_peerlist **slot, size_t peer_size, ot_time timedout) { - ot_peerlist *peer_list = *slot; - ot_vector *peer_vector; - size_t num_buckets = 1, removed_seeders = 0; - - if (!peer_list) - return; +/* Age one family's peers by timedout minutes. Releases and zeroes the vector + once its last peer is gone, so an empty family costs nothing. */ +static void clean_family_vector(ot_vector *peer_vector, size_t peer_size, ot_time timedout, size_t *removed_seeders) { + ot_vector *bucket = peer_vector; + size_t num_buckets = 1, peer_count; - peer_vector = &peer_list->peers; - if (OT_PEERLIST_HASBUCKETS(peer_list)) { + if (OT_VECTOR_HASBUCKETS(peer_vector)) { num_buckets = peer_vector->size; - peer_vector = (ot_vector *)peer_vector->data; + bucket = (ot_vector *)peer_vector->data; } while (num_buckets--) { - size_t removed_peers = clean_single_bucket(peer_vector->data, peer_vector->size, peer_size, timedout, &removed_seeders); - peer_list->peer_count -= removed_peers; - peer_vector->size -= removed_peers; + size_t removed_peers = clean_single_bucket(bucket->data, bucket->size, peer_size, timedout, removed_seeders); + bucket->size -= removed_peers; if (removed_peers) - vector_fixup_peers(peer_vector, peer_size); + vector_fixup_peers(bucket, peer_size); /* Skip to next bucket, a vector containing peers */ - ++peer_vector; + ++bucket; } - peer_list->seed_count -= removed_seeders; + peer_count = vector_peer_count(peer_vector); - if (!peer_list->peer_count) { - free_peerlist(peer_list); - *slot = NULL; + /* Run dry: release the family (a collapsed bucket list or a plain vector) */ + if (!peer_count) { + free_peer_vector(peer_vector); + memset(peer_vector, 0, sizeof(*peer_vector)); return; } - /* See if we need to convert the list from simple vector to bucket list */ - if ((peer_list->peer_count > OT_PEER_BUCKET_MINCOUNT) || OT_PEERLIST_HASBUCKETS(peer_list)) - vector_redistribute_buckets(peer_list, peer_size); + /* See if we need to convert the vector from simple to bucket list or back */ + if ((peer_count > OT_PEER_BUCKET_MINCOUNT) || OT_VECTOR_HASBUCKETS(peer_vector)) + vector_redistribute_buckets(peer_vector, peer_size, peer_count); } /* Clean a single torrent return 1 if torrent timed out */ int clean_single_torrent(ot_torrent *torrent) { - ot_time timedout = time_since_minutes(torrent->base); + ot_time timedout = time_since_minutes(torrent->base); + ot_peerlist *peer_list = torrent->peer_list; + size_t removed_seeders = 0; /* Touched since the last sweep: nothing to do */ if (!timedout) @@ -107,7 +104,7 @@ int clean_single_torrent(ot_torrent *torrent) { /* Already empty and nothing arrived before the peer timeout: keep it only while a down count is worth remembering */ - if (timedout > OT_PEER_TIMEOUT && !torrent->peer_list6 && !torrent->peer_list4) + if (timedout > OT_PEER_TIMEOUT && !peer_list) return (torrent->down_count && timedout <= g_empty_torrent_timeout) ? 0 : 1; /* Peers past the peer timeout are gone regardless, which caps how far the @@ -115,10 +112,19 @@ int clean_single_torrent(ot_torrent *torrent) { if (timedout > OT_PEER_TIMEOUT) timedout = OT_PEER_TIMEOUT; - clean_peer_list_family(&torrent->peer_list6, OT_PEER_SIZE6, timedout); - clean_peer_list_family(&torrent->peer_list4, OT_PEER_SIZE4, timedout); + if (peer_list) { + clean_family_vector(&peer_list->peers6, OT_PEER_SIZE6, timedout, &removed_seeders); + clean_family_vector(&peer_list->peers4, OT_PEER_SIZE4, timedout, &removed_seeders); + peer_list->seed_count -= removed_seeders; + + /* Both families gone: drop the peerlist, the torrent keeps only its count */ + if (!vector_peer_count(&peer_list->peers6) && !vector_peer_count(&peer_list->peers4)) { + free_peerlist(peer_list); + torrent->peer_list = peer_list = NULL; + } + } - if (torrent->peer_list6 || torrent->peer_list4) + if (peer_list) torrent->base = time_now_minutes(); /* still carrying peers */ else { /* Fell empty: hold base a peer timeout back so a later idle sweep makes -- cgit v1.3