Track request block sizes in stats filter.

Nikratio · Nikratio · commit 99a9aa94404f · 2022-05-05T14:13:47.000+01:00
Keep track of every encountered blocksize. This is useful for analyzing client behavior
and choosing appropriate plugin options.

Example output:

total: 1207 ops, 24.756059 s, 25.13 GiB, 1.02 GiB/s
read: 101 ops, 0.000322 s, 1.64 MiB, 4.99 GiB/s op, 68.02 KiB/s total
write: 1088 ops, 0.067040 s, 132.38 MiB, 1.93 GiB/s op, 5.35 MiB/s total
trim: 14 ops, 0.002605 s, 25.00 GiB, 9596.93 GiB/s op, 1.01 GiB/s total
flush: 4 ops, 0.000001 s, 0 bytes, 0 bytes/s op, 0 bytes/s total

READ Request sizes (top 28):
    blocksize     request count
         4096                67 (66.34%)
        16384                 7 (6.93%)
         8192                 3 (2.97%)
        24576                 3 (2.97%)
        61440                 3 (2.97%)
        20480                 2 (1.98%)
        28672                 2 (1.98%)
        36864                 2 (1.98%)
        40960                 2 (1.98%)
        57344                 2 (1.98%)
        65536                 2 (1.98%)
        69632                 2 (1.98%)
        32768                 1 (0.99%)
       122880                 1 (0.99%)
       126976                 1 (0.99%)
       131072                 1 (0.99%)

WRITE Request sizes (top 28):
    blocksize     request count
       131072              1056 (97.06%)
         4096                18 (1.65%)
        20480                10 (0.92%)
        24576                 2 (0.18%)
         8192                 1 (0.09%)
        65536                 1 (0.09%)

TRIM Request sizes (top 28):
    blocksize     request count
   2147483648                12 (85.71%)
     16777216                 1 (7.14%)
   1056964608                 1 (7.14%)

ZERO Request sizes (top 28):
    blocksize     request count
diff --git a/common/utils/cleanup.h b/common/utils/cleanup.h
@@ -33,6 +33,10 @@
 #ifndef NBDKIT_CLEANUP_H
 #define NBDKIT_CLEANUP_H
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <pthread.h>
 #include <assert.h>
 
@@ -90,4 +94,8 @@ struct nbdkit_exports;
 extern void cleanup_exports_free (struct nbdkit_exports **ptr);
 #define CLEANUP_EXPORTS_FREE __attribute__((cleanup (cleanup_exports_free)))
 
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
 #endif /* NBDKIT_CLEANUP_H */
diff --git a/filters/stats/Makefile.am b/filters/stats/Makefile.am
@@ -33,10 +33,12 @@ include $(top_srcdir)/common-rules.mk
 
 EXTRA_DIST = nbdkit-stats-filter.pod
 
+if HAVE_CXX
+
 filter_LTLIBRARIES = nbdkit-stats-filter.la
 
 nbdkit_stats_filter_la_SOURCES = \
-	stats.c \
+	stats.cpp \
 	$(top_srcdir)/include/nbdkit-filter.h \
 	$(NULL)
 
@@ -68,3 +70,4 @@ nbdkit-stats-filter.1: nbdkit-stats-filter.pod \
 	    $<
 
 endif HAVE_POD
+endif HAVE_CXX
diff --git a/filters/stats/nbdkit-stats-filter.pod b/filters/stats/nbdkit-stats-filter.pod
@@ -12,24 +12,55 @@ C<nbdkit-stats-filter> is a filter that displays statistics about NBD
 operations, such as the number of bytes read and written.  Statistics
 are written to a file once when nbdkit exits.
 
-=head1 EXAMPLE
-
-In this example we run L<guestfish(1)> over nbdkit to create an ext4
-filesystem on a RAM disk, and use the stats filter to display the
-number of read, write and trim operations involved:
-
- $ nbdkit -U - --filter=stats memory 1G statsfile=/dev/stderr \
-          --run '
-       guestfish add-drive "" protocol:nbd server:unix:$unixsocket \
-                              discard:enable format:raw : \
-                 run : \
-                 mkfs ext4 /dev/sda
- '
- total: 370 ops, 1.282993 s, 1.04 GiB, 827.29 MiB/s
- read: 250 ops, 0.000364 s, 4.76 MiB, 12.78 GiB/s op, 3.71 MiB/s total
- write: 78 ops, 0.175715 s, 32.64 MiB, 185.78 MiB/s op, 25.44 MiB/s total
- trim: 33 ops, 0.000252 s, 1.00 GiB, 3968.25 GiB/s op, 798.13 MiB/s total
- flush: 9 ops, 0.000002 s, 0 bytes, 0 bytes/s op, 0 bytes/s total
+=head1 EXAMPLE OUTPUT
+
+ # nbdkit --filter=exitfirst --filter=stats memory 25G statsfile=example.txt
+ # nbd-client localhost /dev/nbd1 && mkfs.ext4 /dev/nbd1 && nbd-client -d /dev/nbd1
+ [....]
+ # cat example.txt
+ total: 1207 ops, 24.756059 s, 25.13 GiB, 1.02 GiB/s
+ read: 101 ops, 0.000322 s, 1.64 MiB, 4.99 GiB/s op, 68.02 KiB/s total
+ write: 1088 ops, 0.067040 s, 132.38 MiB, 1.93 GiB/s op, 5.35 MiB/s total
+ trim: 14 ops, 0.002605 s, 25.00 GiB, 9596.93 GiB/s op, 1.01 GiB/s total
+ flush: 4 ops, 0.000001 s, 0 bytes, 0 bytes/s op, 0 bytes/s total
+
+ READ Request sizes (top 28):
+     blocksize     request count
+          4096                67 (66.34%)
+         16384                 7 (6.93%)
+          8192                 3 (2.97%)
+         24576                 3 (2.97%)
+         61440                 3 (2.97%)
+         20480                 2 (1.98%)
+         28672                 2 (1.98%)
+         36864                 2 (1.98%)
+         40960                 2 (1.98%)
+         57344                 2 (1.98%)
+         65536                 2 (1.98%)
+         69632                 2 (1.98%)
+         32768                 1 (0.99%)
+        122880                 1 (0.99%)
+        126976                 1 (0.99%)
+        131072                 1 (0.99%)
+
+ WRITE Request sizes (top 28):
+     blocksize     request count
+        131072              1056 (97.06%)
+          4096                18 (1.65%)
+         20480                10 (0.92%)
+         24576                 2 (0.18%)
+          8192                 1 (0.09%)
+         65536                 1 (0.09%)
+
+ TRIM Request sizes (top 28):
+     blocksize     request count
+    2147483648                12 (85.71%)
+      16777216                 1 (7.14%)
+    1056964608                 1 (7.14%)
+
+ ZERO Request sizes (top 28):
+     blocksize     request count
+
 
 =head1 PARAMETERS
 
diff --git a/filters/stats/stats.cpp b/filters/stats/stats.cpp
@@ -32,6 +32,10 @@
 
 #include <config.h>
 
+#include <map>
+#include <vector>
+#include <algorithm>
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdint.h>
@@ -47,6 +51,7 @@
 #include <nbdkit-filter.h>
 
 #include "cleanup.h"
+
 #include "tvdiff.h"
 #include "windows-compat.h"
 
@@ -62,6 +67,8 @@ typedef struct {
   uint64_t usecs;
 } nbdstat;
 
+typedef std::map<size_t, size_t> blksize_hist_t;
+
 /* This lock protects all the stats. */
 static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
 static nbdstat pread_st   = { "read" };
@@ -71,6 +78,10 @@ static nbdstat zero_st    = { "zero" };
 static nbdstat extents_st = { "extents" };
 static nbdstat cache_st   = { "cache" };
 static nbdstat flush_st   = { "flush" };
+static blksize_hist_t blksize_pread_st;
+static blksize_hist_t blksize_pwrite_st;
+static blksize_hist_t blksize_trim_st;
+static blksize_hist_t blksize_zero_st;
 
 #define KiB 1024
 #define MiB 1048576
@@ -143,6 +154,50 @@ print_totals (uint64_t usecs)
   free (rate);
 }
 
+static void
+print_histogram (const blksize_hist_t hist, int count)
+{
+  double total = 0;
+  for (auto el : hist) {
+    total += static_cast<double> (el.second);
+  }
+
+  // Sort
+  auto pairs = std::vector<std::pair<size_t, size_t>> (hist.begin(), hist.end());
+  std::sort(pairs.begin(), pairs.end(),
+    [](decltype(pairs[0]) a, decltype(pairs[0]) b) {
+      return a.second > b.second;
+    });
+
+  int i = 0;
+  for (auto el : pairs) {
+    if (++i >= count)
+      break;
+    fprintf (fp, "%13zu         %9zu (%.2f%%)\n",
+      el.first, el.second, static_cast<double>(el.second) / total * 100);
+  }
+}
+
+static void
+print_blocksize_stats (void)
+{
+  fprintf (fp, "\nREAD Request sizes (top 28):\n");
+  fprintf (fp, "    blocksize     request count\n");
+  print_histogram (blksize_pread_st, 28);
+  
+  fprintf (fp, "\nWRITE Request sizes (top 28):\n");
+  fprintf (fp, "    blocksize     request count\n");
+  print_histogram (blksize_pwrite_st, 28);
+
+  fprintf (fp, "\nTRIM Request sizes (top 28):\n");
+  fprintf (fp, "    blocksize     request count\n");
+  print_histogram (blksize_trim_st, 28);
+  
+  fprintf (fp, "\nZERO Request sizes (top 28):\n");
+  fprintf (fp, "    blocksize     request count\n");
+  print_histogram (blksize_zero_st, 28);
+}
+
 static inline void
 print_stats (int64_t usecs)
 {
@@ -154,6 +209,7 @@ print_stats (int64_t usecs)
   print_stat (&extents_st, usecs);
   print_stat (&cache_st,   usecs);
   print_stat (&flush_st,   usecs);
+  print_blocksize_stats();
   fflush (fp);
 }
 
@@ -268,6 +324,11 @@ stats_pread (nbdkit_next *next,
   struct timeval start;
   int r;
 
+  {
+    ACQUIRE_LOCK_FOR_CURRENT_SCOPE (&lock);
+    blksize_pread_st[count]++;
+  }
+
   gettimeofday (&start, NULL);
   r = next->pread (next, buf, count, offset, flags, err);
   if (r == 0) record_stat (&pread_st, count, &start);
@@ -284,6 +345,11 @@ stats_pwrite (nbdkit_next *next,
   struct timeval start;
   int r;
 
+  {
+    ACQUIRE_LOCK_FOR_CURRENT_SCOPE (&lock);
+    blksize_pwrite_st[count]++;
+  }
+  
   gettimeofday (&start, NULL);
   r = next->pwrite (next, buf, count, offset, flags, err);
   if (r == 0) record_stat (&pwrite_st, count, &start);
@@ -300,6 +366,11 @@ stats_trim (nbdkit_next *next,
   struct timeval start;
   int r;
 
+  {
+    ACQUIRE_LOCK_FOR_CURRENT_SCOPE (&lock);
+    blksize_trim_st[count]++;
+  }
+
   gettimeofday (&start, NULL);
   r = next->trim (next, count, offset, flags, err);
   if (r == 0) record_stat (&trim_st, count, &start);
@@ -331,6 +402,11 @@ stats_zero (nbdkit_next *next,
   struct timeval start;
   int r;
 
+  {
+    ACQUIRE_LOCK_FOR_CURRENT_SCOPE (&lock);
+    blksize_zero_st[count]++;
+  }
+
   gettimeofday (&start, NULL);
   r = next->zero (next, count, offset, flags, err);
   if (r == 0) record_stat (&zero_st, count, &start);
@@ -373,21 +449,24 @@ stats_cache (nbdkit_next *next,
   return r;
 }
 
-static struct nbdkit_filter filter = {
-  .name              = "stats",
-  .longname          = "nbdkit stats filter",
-  .unload            = stats_unload,
-  .config            = stats_config,
-  .config_complete   = stats_config_complete,
-  .config_help       = stats_config_help,
-  .get_ready         = stats_get_ready,
-  .pread             = stats_pread,
-  .pwrite            = stats_pwrite,
-  .trim              = stats_trim,
-  .flush             = stats_flush,
-  .zero              = stats_zero,
-  .extents           = stats_extents,
-  .cache             = stats_cache,
-};
+static struct nbdkit_filter filter = []() -> nbdkit_filter {
+	auto f = nbdkit_filter();
+  f.name = "stats";
+  f.longname = "nbdkit stats filter";
+  f.unload = stats_unload;
+  f.config = stats_config;
+  f.config_complete = stats_config_complete;
+  f.config_help = stats_config_help;
+  f.get_ready = stats_get_ready;
+  f.pread = stats_pread;
+  f.pwrite = stats_pwrite;
+  f.flush = stats_flush;
+  f.trim = stats_trim;
+  f.zero = stats_zero;
+  f.extents = stats_extents;
+  f.cache = stats_cache;
+
+    return f;
+}();
 
 NBDKIT_REGISTER_FILTER(filter)
diff --git a/plugins/torrent/torrent.cpp b/plugins/torrent/torrent.cpp
@@ -52,9 +52,7 @@
 #include <libtorrent/torrent_info.hpp>
 #include <libtorrent/version.hpp>
 
-extern "C" {
 #include "cleanup.h"
-};
 
 static bool seen_torrent = false;
 
