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 +++++++++++++++------------- src/ot_fullscrape.c | 4 +- src/ot_stats.c | 14 +++---- src/ot_vector.c | 47 ++++++++++----------- src/ot_vector.h | 2 +- src/trackerlogic.c | 118 ++++++++++++++++++++++++---------------------------- src/trackerlogic.h | 39 +++++++++++------ 7 files changed, 150 insertions(+), 138 deletions(-) (limited to 'src') 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 diff --git a/src/ot_fullscrape.c b/src/ot_fullscrape.c index 9fae444..787b508 100644 --- a/src/ot_fullscrape.c +++ b/src/ot_fullscrape.c @@ -90,8 +90,8 @@ static void fullscrape_write_one( ot_tasktype mode, char **cursor, ot_torrent *t exactly that size */ char *r = *cursor; const char *r_end = r + OT_SCRAPE_MAXENTRYLEN; - size_t seed_count = peerlist_seed_count(torrent->peer_list6) + peerlist_seed_count(torrent->peer_list4); - size_t peer_count = peerlist_peer_count(torrent->peer_list6) + peerlist_peer_count(torrent->peer_list4); + size_t seed_count = torrent_seed_count(torrent); + size_t peer_count = torrent_peer_count(torrent); size_t down_count = torrent->down_count; switch (mode & TASK_TASK_MASK) { diff --git a/src/ot_stats.c b/src/ot_stats.c index 9e2eabe..0e2fc67 100644 --- a/src/ot_stats.c +++ b/src/ot_stats.c @@ -243,15 +243,15 @@ static void stats_slash24s_txt(char **reply, const char *reply_end, size_t amoun for (bucket = 0; bucket < OT_BUCKET_COUNT; ++bucket) { ot_vector *torrents_list = mutex_bucket_lock(bucket); for (i = 0; i < torrents_list->size; ++i) { - ot_peerlist *peer_list = (((ot_torrent *)(torrents_list->data))[i]).peer_list4; + ot_peerlist *peer_list = (((ot_torrent *)(torrents_list->data))[i]).peer_list; ot_vector *bucket_list; int num_buckets = 1; if (!peer_list) continue; - bucket_list = &peer_list->peers; + bucket_list = &peer_list->peers4; /* /24 networks are an IPv4 notion */ - if (OT_PEERLIST_HASBUCKETS(peer_list)) { + if (OT_VECTOR_HASBUCKETS(bucket_list)) { num_buckets = bucket_list->size; bucket_list = (ot_vector *)bucket_list->data; } @@ -303,8 +303,8 @@ typedef struct { static int torrent_statter(ot_torrent *torrent, uintptr_t data) { torrent_stats *stats = (torrent_stats *)data; stats->torrent_count++; - stats->peer_count += peerlist_peer_count(torrent->peer_list6) + peerlist_peer_count(torrent->peer_list4); - stats->seed_count += peerlist_seed_count(torrent->peer_list6) + peerlist_seed_count(torrent->peer_list4); + stats->peer_count += torrent_peer_count(torrent); + stats->seed_count += torrent_seed_count(torrent); return 0; } @@ -347,8 +347,8 @@ void stats_top_txt(char **reply, const char *reply_end, size_t amount) { ot_vector *torrents_list = mutex_bucket_lock(bucket); for (j = 0; j < torrents_list->size; ++j) { ot_torrent *torrent = (ot_torrent *)(torrents_list->data) + j; - size_t peer_count = peerlist_peer_count(torrent->peer_list6) + peerlist_peer_count(torrent->peer_list4); - size_t seed_count = peerlist_seed_count(torrent->peer_list6) + peerlist_seed_count(torrent->peer_list4); + size_t peer_count = torrent_peer_count(torrent); + size_t seed_count = torrent_seed_count(torrent); size_t leech_count = peer_count - seed_count; stats_insert_into_highscore(peer_count, top100c, amount, &torrent->hash); diff --git a/src/ot_vector.c b/src/ot_vector.c index 23dfb10..ef38919 100644 --- a/src/ot_vector.c +++ b/src/ot_vector.c @@ -160,8 +160,7 @@ void vector_remove_torrent(ot_vector *vector, ot_torrent *match) { end = ((ot_torrent *)vector->data) + vector->size; - free_peerlist(match->peer_list6); - free_peerlist(match->peer_list4); + free_peerlist(match->peer_list); memmove(match, match + 1, sizeof(ot_torrent) * (end - match - 1)); if ((--vector->size * OT_VECTOR_SHRINK_THRESH < vector->space) && (vector->space >= OT_VECTOR_SHRINK_RATIO * OT_VECTOR_MIN_MEMBERS)) { @@ -180,27 +179,27 @@ void vector_clean_list(ot_vector *vector, size_t num_buckets) { return; } -void vector_redistribute_buckets(ot_peerlist *peer_list, size_t peer_size) { +void vector_redistribute_buckets(ot_vector *peer_vector, size_t peer_size, size_t peer_count) { size_t bucket, bucket_size_new, num_buckets_new, num_buckets_old = 1; - ot_vector *bucket_list_new, *bucket_list_old = &peer_list->peers; + ot_vector *bucket_list_new, *bucket_list_old = peer_vector; int (*sort_func)(const void *, const void *) = peer_size == OT_PEER_SIZE6 ? &vector_compare_peer6 : &vector_compare_peer4; - if (OT_PEERLIST_HASBUCKETS(peer_list)) { - num_buckets_old = peer_list->peers.size; - bucket_list_old = peer_list->peers.data; + if (OT_VECTOR_HASBUCKETS(peer_vector)) { + num_buckets_old = peer_vector->size; + bucket_list_old = peer_vector->data; } - if (peer_list->peer_count < 255) + if (peer_count < 255) num_buckets_new = 1; - else if (peer_list->peer_count > 8192) + else if (peer_count > 8192) num_buckets_new = 64; - else if (peer_list->peer_count >= 512 && peer_list->peer_count < 4096) + else if (peer_count >= 512 && peer_count < 4096) num_buckets_new = 16; - else if (peer_list->peer_count < 512 && num_buckets_old <= 16) + else if (peer_count < 512 && num_buckets_old <= 16) num_buckets_new = num_buckets_old; - else if (peer_list->peer_count < 512) + else if (peer_count < 512) num_buckets_new = 1; - else if (peer_list->peer_count < 8192 && num_buckets_old > 1) + else if (peer_count < 8192 && num_buckets_old > 1) num_buckets_new = num_buckets_old; else num_buckets_new = 16; @@ -214,7 +213,7 @@ void vector_redistribute_buckets(ot_peerlist *peer_list, size_t peer_size) { return; bucket_size_new = OT_VECTOR_MIN_MEMBERS; - while (bucket_size_new * num_buckets_new < peer_list->peer_count) + while (bucket_size_new * num_buckets_new < peer_count) bucket_size_new *= OT_VECTOR_GROW_RATIO; /* preallocate vectors to hold all peers */ @@ -253,20 +252,20 @@ void vector_redistribute_buckets(ot_peerlist *peer_list, size_t peer_size) { for (bucket = 0; bucket < num_buckets_new; ++bucket) qsort(bucket_list_new[bucket].data, bucket_list_new[bucket].size, peer_size, sort_func); - /* Everything worked fine. Now link new bucket_list to peer_list */ - if (OT_PEERLIST_HASBUCKETS(peer_list)) - vector_clean_list((ot_vector *)peer_list->peers.data, peer_list->peers.size); + /* Everything worked fine. Now link new bucket_list to the vector */ + if (OT_VECTOR_HASBUCKETS(peer_vector)) + vector_clean_list((ot_vector *)peer_vector->data, peer_vector->size); else - free(peer_list->peers.data); + free(peer_vector->data); if (num_buckets_new > 1) { - peer_list->peers.data = bucket_list_new; - peer_list->peers.size = num_buckets_new; - peer_list->peers.space = 0; /* Magic marker for "is list of buckets" */ + peer_vector->data = bucket_list_new; + peer_vector->size = num_buckets_new; + peer_vector->space = 0; /* Magic marker for "is list of buckets" */ } else { - peer_list->peers.data = bucket_list_new->data; - peer_list->peers.size = bucket_list_new->size; - peer_list->peers.space = bucket_list_new->space; + peer_vector->data = bucket_list_new->data; + peer_vector->size = bucket_list_new->size; + peer_vector->space = bucket_list_new->space; free(bucket_list_new); } } diff --git a/src/ot_vector.h b/src/ot_vector.h index 8a5ba86..1a73fcf 100644 --- a/src/ot_vector.h +++ b/src/ot_vector.h @@ -32,7 +32,7 @@ int vector_remove_peer(ot_vector *vector, ot_peer const *peer, size_t peer_ void vector_remove_torrent(ot_vector *vector, ot_torrent *match); /* For ot_clean.c */ -void vector_redistribute_buckets(ot_peerlist *peer_list, size_t peer_size); +void vector_redistribute_buckets(ot_vector *peer_vector, size_t peer_size, size_t peer_count); void vector_fixup_peers(ot_vector *vector, size_t peer_size); void vector_clean_list(ot_vector *vector, size_t num_buckets); diff --git a/src/trackerlogic.c b/src/trackerlogic.c index 6b0659c..4ba3a41 100644 --- a/src/trackerlogic.c +++ b/src/trackerlogic.c @@ -28,13 +28,18 @@ /* Forward declaration */ size_t return_peers_for_torrent(struct ot_workstruct *ws, ot_torrent *torrent, size_t amount, char *reply, PROTO_FLAG proto); +void free_peer_vector(ot_vector *peer_vector) { + if (OT_VECTOR_HASBUCKETS(peer_vector)) + vector_clean_list((ot_vector *)peer_vector->data, peer_vector->size); + else + free(peer_vector->data); /* free(NULL) on an absent family is fine */ +} + void free_peerlist(ot_peerlist *peer_list) { - if (peer_list && peer_list->peers.data) { - if (OT_PEERLIST_HASBUCKETS(peer_list)) - vector_clean_list((ot_vector *)peer_list->peers.data, peer_list->peers.size); - else - free(peer_list->peers.data); - } + if (!peer_list) + return; + free_peer_vector(&peer_list->peers6); + free_peer_vector(&peer_list->peers4); free(peer_list); } @@ -113,20 +118,17 @@ size_t add_peer_to_torrent_and_return_peers(PROTO_FLAG proto, struct ot_workstru torrent->base = time_now_minutes(); - /* The announcing peer's family list is created on first use */ - { - ot_peerlist **slot = peer_size == OT_PEER_SIZE6 ? &torrent->peer_list6 : &torrent->peer_list4; - if (!*slot && !(*slot = calloc(1, sizeof(ot_peerlist)))) { - if (delta_torrentcount) - vector_remove_torrent(torrents_list, torrent); - mutex_bucket_unlock_by_hash(*ws->hash, 0); - return 0; - } - peer_list = *slot; + /* The peerlist, holding both families, is created on the first peer */ + if (!torrent->peer_list && !(torrent->peer_list = calloc(1, sizeof(ot_peerlist)))) { + if (delta_torrentcount) + vector_remove_torrent(torrents_list, torrent); + mutex_bucket_unlock_by_hash(*ws->hash, 0); + return 0; } + peer_list = torrent->peer_list; - /* Check for peer in torrent */ - peer_dest = vector_find_or_insert_peer(&(peer_list->peers), peer_src, peer_size, &exactmatch); + /* Check for peer in its family's vector */ + peer_dest = vector_find_or_insert_peer(peer_size == OT_PEER_SIZE6 ? &peer_list->peers6 : &peer_list->peers4, peer_src, peer_size, &exactmatch); if (!peer_dest) { mutex_bucket_unlock_by_hash(*ws->hash, delta_torrentcount); return 0; @@ -149,7 +151,6 @@ size_t add_peer_to_torrent_and_return_peers(PROTO_FLAG proto, struct ot_workstru livesync_tell(ws); #endif - peer_list->peer_count++; if (OT_PEERFLAG(ws->peer) & PEER_FLAG_COMPLETED) { torrent->down_count++; stats_issue_event(ws, EVENT_COMPLETED, 0, 0); @@ -198,14 +199,14 @@ size_t add_peer_to_torrent_and_return_peers(PROTO_FLAG proto, struct ot_workstru return ws->reply_size; } -static size_t return_peers_all(ot_peerlist *peer_list, size_t peer_size, char *reply) { +static size_t return_peers_all(ot_vector *peer_vector, size_t peer_size, size_t peer_count, char *reply) { size_t bucket, num_buckets = 1; - ot_vector *bucket_list = &peer_list->peers; + ot_vector *bucket_list = peer_vector; size_t compare_size = OT_PEER_COMPARE_SIZE_FROM_PEER_SIZE(peer_size); - size_t result = compare_size * peer_list->peer_count; + size_t result = compare_size * peer_count; char *r_end = reply + result; - if (OT_PEERLIST_HASBUCKETS(peer_list)) { + if (OT_VECTOR_HASBUCKETS(peer_vector)) { num_buckets = bucket_list->size; bucket_list = (ot_vector *)bucket_list->data; } @@ -227,17 +228,17 @@ static size_t return_peers_all(ot_peerlist *peer_list, size_t peer_size, char *r return result; } -static size_t return_peers_selection(struct ot_workstruct *ws, ot_peerlist *peer_list, size_t peer_size, size_t amount, char *reply) { +static size_t return_peers_selection(struct ot_workstruct *ws, ot_vector *peer_vector, size_t peer_size, size_t amount, size_t peer_count, char *reply) { size_t bucket_offset, bucket_index = 0, num_buckets = 1; - ot_vector *bucket_list = &peer_list->peers; - unsigned int shifted_pc = peer_list->peer_count; + ot_vector *bucket_list = peer_vector; + unsigned int shifted_pc = peer_count; unsigned int shifted_step = 0; unsigned int shift = 0; size_t compare_size = OT_PEER_COMPARE_SIZE_FROM_PEER_SIZE(peer_size); size_t result = compare_size * amount; char *r_end = reply + result; - if (OT_PEERLIST_HASBUCKETS(peer_list)) { + if (OT_VECTOR_HASBUCKETS(peer_vector)) { num_buckets = bucket_list->size; bucket_list = (ot_vector *)bucket_list->data; } @@ -253,7 +254,7 @@ static size_t return_peers_selection(struct ot_workstruct *ws, ot_peerlist *peer /* Initialize somewhere in the middle of peers so that fixpoint's aliasing doesn't alway miss the same peers */ - bucket_offset = nrand48(ws->rand48_state) % peer_list->peer_count; + bucket_offset = nrand48(ws->rand48_state) % peer_count; while (amount--) { ot_peer *peer; @@ -281,10 +282,11 @@ static size_t return_peers_selection(struct ot_workstruct *ws, ot_peerlist *peer static size_t return_peers_for_torrent_udp(struct ot_workstruct *ws, ot_torrent *torrent, size_t amount, char *reply) { char *r = reply; size_t peer_size = peer_size_from_peer6(&ws->peer); - ot_peerlist *peer_list = peer_size == OT_PEER_SIZE6 ? torrent->peer_list6 : torrent->peer_list4; - size_t list_count = peerlist_peer_count(peer_list); - size_t peer_count = peerlist_peer_count(torrent->peer_list6) + peerlist_peer_count(torrent->peer_list4); - size_t seed_count = peerlist_seed_count(torrent->peer_list6) + peerlist_seed_count(torrent->peer_list4); + ot_peerlist *peer_list = torrent->peer_list; + ot_vector *family = peer_size == OT_PEER_SIZE6 ? &peer_list->peers6 : &peer_list->peers4; + size_t list_count = vector_peer_count(family); + size_t peer_count = torrent_peer_count(torrent); + size_t seed_count = torrent_seed_count(torrent); if (amount > list_count) amount = list_count; @@ -296,9 +298,9 @@ static size_t return_peers_for_torrent_udp(struct ot_workstruct *ws, ot_torrent if (amount) { if (amount == list_count) - r += return_peers_all(peer_list, peer_size, r); + r += return_peers_all(family, peer_size, list_count, r); else - r += return_peers_selection(ws, peer_list, peer_size, amount, r); + r += return_peers_selection(ws, family, peer_size, amount, list_count, r); } return r - reply; } @@ -307,9 +309,10 @@ static size_t return_peers_for_torrent_tcp(struct ot_workstruct *ws, ot_torrent char *r = reply; const char *r_end = ws->outbuf + G_OUTBUF_SIZE; int erval = OT_CLIENT_REQUEST_INTERVAL_RANDOM; - size_t count6 = peerlist_peer_count(torrent->peer_list6); - size_t count4 = peerlist_peer_count(torrent->peer_list4); - size_t seed_count = peerlist_seed_count(torrent->peer_list6) + peerlist_seed_count(torrent->peer_list4); + ot_peerlist *peer_list = torrent->peer_list; + size_t count6 = vector_peer_count(&peer_list->peers6); + size_t count4 = vector_peer_count(&peer_list->peers4); + size_t seed_count = peer_list->seed_count; size_t down_count = torrent->down_count; size_t peer_count = count6 + count4 - seed_count; @@ -355,17 +358,17 @@ static size_t return_peers_for_torrent_tcp(struct ot_workstruct *ws, ot_torrent if (amount_v4) { fmt_append(&r, r_end, PEERS_BENCODED4 "%zd:", OT_PEER_COMPARE_SIZE4 * amount_v4); if (amount_v4 == count4) - r += return_peers_all(torrent->peer_list4, OT_PEER_SIZE4, r); + r += return_peers_all(&peer_list->peers4, OT_PEER_SIZE4, count4, r); else - r += return_peers_selection(ws, torrent->peer_list4, OT_PEER_SIZE4, amount_v4, r); + r += return_peers_selection(ws, &peer_list->peers4, OT_PEER_SIZE4, amount_v4, count4, r); } if (amount_v6) { fmt_append(&r, r_end, PEERS_BENCODED6 "%zd:", OT_PEER_COMPARE_SIZE6 * amount_v6); if (amount_v6 == count6) - r += return_peers_all(torrent->peer_list6, OT_PEER_SIZE6, r); + r += return_peers_all(&peer_list->peers6, OT_PEER_SIZE6, count6, r); else - r += return_peers_selection(ws, torrent->peer_list6, OT_PEER_SIZE6, amount_v6, r); + r += return_peers_selection(ws, &peer_list->peers6, OT_PEER_SIZE6, amount_v6, count6, r); } fmt_append(&r, r_end, "e"); @@ -401,9 +404,9 @@ size_t return_udp_scrape_for_torrent(ot_hash const hash, char *reply) { memset(reply, 0, 12); delta_torrentcount = -1; } else { - r[0] = htonl(peerlist_seed_count(torrent->peer_list6) + peerlist_seed_count(torrent->peer_list4)); + r[0] = htonl(torrent_seed_count(torrent)); r[1] = htonl(torrent->down_count); - r[2] = htonl(peerlist_peer_count(torrent->peer_list6) + peerlist_peer_count(torrent->peer_list4) - peerlist_seed_count(torrent->peer_list6) - peerlist_seed_count(torrent->peer_list4)); + r[2] = htonl(torrent_peer_count(torrent) - torrent_seed_count(torrent)); } } mutex_bucket_unlock_by_hash(hash, delta_torrentcount); @@ -430,8 +433,8 @@ void return_tcp_scrape_for_torrent(ot_hash const *hash_list, size_t amount, char } else { fmt_append(reply, reply_end, "20:"); fmt_bytes(reply, reply_end, hash, sizeof(ot_hash)); - size_t seed_count = peerlist_seed_count(torrent->peer_list6) + peerlist_seed_count(torrent->peer_list4); - size_t peer_count = peerlist_peer_count(torrent->peer_list6) + peerlist_peer_count(torrent->peer_list4); + size_t seed_count = torrent_seed_count(torrent); + size_t peer_count = torrent_peer_count(torrent); fmt_append(reply, reply_end, "d8:completei%zde10:downloadedi%zde10:incompletei%zdee", seed_count, (size_t)torrent->down_count, peer_count - seed_count); } } @@ -441,12 +444,10 @@ void return_tcp_scrape_for_torrent(ot_hash const *hash_list, size_t amount, char fmt_append(reply, reply_end, "ee"); } -static ot_peerlist dummy_list; size_t remove_peer_from_torrent(PROTO_FLAG proto, struct ot_workstruct *ws) { int exactmatch; ot_vector *torrents_list = mutex_bucket_lock_by_hash(*ws->hash); ot_torrent *torrent = vector_binary_search(ws->hash, torrents_list->data, torrents_list->size, sizeof(ot_torrent), OT_HASH_COMPARE_SIZE, &exactmatch); - ot_peerlist *peer_list = &dummy_list; size_t peer_size; /* initialized in next line */ ot_peer const *peer_src = peer_from_peer6(&ws->peer, &peer_size); size_t peer_count = 0, seed_count = 0; @@ -458,21 +459,13 @@ size_t remove_peer_from_torrent(PROTO_FLAG proto, struct ot_workstruct *ws) { } #endif - if (exactmatch) { - peer_list = peer_size == OT_PEER_SIZE6 ? torrent->peer_list6 : torrent->peer_list4; - if (peer_list) { - switch (vector_remove_peer(&peer_list->peers, peer_src, peer_size)) { - case 2: - peer_list->seed_count--; /* Intentional fallthrough */ - case 1: - peer_list->peer_count--; /* Intentional fallthrough */ - default: - break; - } - } + if (exactmatch && torrent->peer_list) { + ot_vector *family = peer_size == OT_PEER_SIZE6 ? &torrent->peer_list->peers6 : &torrent->peer_list->peers4; + if (vector_remove_peer(family, peer_src, peer_size) == 2) + torrent->peer_list->seed_count--; - peer_count = peerlist_peer_count(torrent->peer_list6) + peerlist_peer_count(torrent->peer_list4); - seed_count = peerlist_seed_count(torrent->peer_list6) + peerlist_seed_count(torrent->peer_list4); + peer_count = torrent_peer_count(torrent); + seed_count = torrent_seed_count(torrent); } if (proto == FLAG_TCP) { @@ -621,8 +614,7 @@ void trackerlogic_deinit(void) { if (torrents_list->size) { for (j = 0; j < torrents_list->size; ++j) { ot_torrent *torrent = ((ot_torrent *)(torrents_list->data)) + j; - free_peerlist(torrent->peer_list6); - free_peerlist(torrent->peer_list4); + free_peerlist(torrent->peer_list); delta_torrentcount -= 1; } free(torrents_list->data); diff --git a/src/trackerlogic.h b/src/trackerlogic.h index c4b7774..dd8a48c 100644 --- a/src/trackerlogic.h +++ b/src/trackerlogic.h @@ -170,26 +170,40 @@ struct ot_peerlist; typedef struct ot_peerlist ot_peerlist; typedef struct { ot_hash hash; - ot_peerlist *peer_list6; /* NULL until the torrent has a v6 peer */ - ot_peerlist *peer_list4; /* NULL until the torrent has a v4 peer */ - uint32_t base; /* minutes, when the torrent was last cleaned */ - uint32_t down_count; /* completed events, summed over both families */ + ot_peerlist *peer_list; /* NULL until the torrent has a peer in either family */ + uint32_t base; /* epoch minutes, when the torrent was last cleaned */ + uint32_t down_count; /* completed events */ } ot_torrent; #include "ot_vector.h" struct ot_peerlist { uint32_t seed_count; - uint32_t peer_count; - /* normal peers vector or - pointer to ot_vector[32] buckets if data != NULL and space == 0 - */ - ot_vector peers; + /* each family's peers: a normal vector, or a pointer to ot_vector[] buckets + when data != NULL and space == 0 (size then holds the bucket count) */ + ot_vector peers6; + ot_vector peers4; }; -#define OT_PEERLIST_HASBUCKETS(peer_list) ((peer_list)->peers.size > (peer_list)->peers.space) -static inline uint32_t peerlist_peer_count(const ot_peerlist *peer_list) { return peer_list ? peer_list->peer_count : 0; } -static inline uint32_t peerlist_seed_count(const ot_peerlist *peer_list) { return peer_list ? peer_list->seed_count : 0; } +/* A peer vector becomes a bucket list of peer vectors, marker is size > space (usually 0) */ +#define OT_VECTOR_HASBUCKETS(v) ((v)->size > (v)->space) + +/* Peers in one family: a plain vector's size is the count, a bucket list's is + the sum of its buckets. O(1) for the small torrents that dominate a table. */ +static inline size_t vector_peer_count(const ot_vector *v) { + const ot_vector *b; + size_t n, total = 0; + if (!OT_VECTOR_HASBUCKETS(v)) + return v->size; + b = (const ot_vector *)v->data; + for (n = 0; n < v->size; ++n) + total += b[n].size; + return total; +} +static inline size_t torrent_peer_count(const ot_torrent *t) { + return t->peer_list ? vector_peer_count(&t->peer_list->peers6) + vector_peer_count(&t->peer_list->peers4) : 0; +} +static inline uint32_t torrent_seed_count(const ot_torrent *t) { return t->peer_list ? t->peer_list->seed_count : 0; } /* The http replies the tracker counts when it has to refuse a request. */ enum { @@ -314,5 +328,6 @@ void iterate_all_torrents(int (*for_each)(ot_torrent *torrent, uintptr_t data), /* Helper, before it moves to its own object */ void free_peerlist(ot_peerlist *peer_list); +void free_peer_vector(ot_vector *peer_vector); #endif -- cgit v1.3