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.

1 files changed, 23 insertions, 24 deletions

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);
   }
 }