tools: ynltool: add qstats analysis for HW-GRO efficiency / savings

Extend ynltool to compute HW GRO savings metric - how many
packets has HW GRO been able to save the kernel from seeing.

Note that this definition does not actually take into account
whether the segments were or weren't eligible for HW GRO.
If a machine is receiving all-UDP traffic - new metric will show
HW-GRO savings of 0%. Conversely since the super-packet still
counts as a received packet, savings of 100% is not achievable.
Perfect HW-GRO on a machine with 4k MTU and 64kB super-frames
would show ~93.75% savings. With 1.5k MTU we may see up to
~97.8% savings (if my math is right).

Example after 10 sec of iperf on a freshly booted machine
with 1.5k MTU:

  $ ynltool qstats show
  eth0     rx-packets:  40681280               rx-bytes:   61575208437
        rx-alloc-fail:         0      rx-hw-gro-packets:       1225133
                                 rx-hw-gro-wire-packets:      40656633
  $ ynltool qstats hw-gro
  eth0: 96.9% savings

None of the NICs I have access to can report "missed" HW-GRO
opportunities so computing a true "effectiveness" metric
is not possible. One could also argue that effectiveness metric
is inferior in environments where we control both senders and
receivers, the savings metrics will capture both regressions
in receiver's HW GRO effectiveness but also regressions in senders
sending smaller TSO trains. And we care about both. The main
downside is that it's hard to tell at a glance how well the NIC
is doing because the savings will be dependent on traffic patterns.

Reviewed-by: Petr Machata <petrm@nvidia.com>
Link: https://patch.msgid.link/20260207003509.3927744-4-kuba@kernel.org
Signed-off-by: Jakub Kicinski <kuba@kernel.org>

diff --git a/tools/net/ynl/ynltool/qstats.c b/tools/net/ynl/ynltool/qstats.c
index d19acab0bf2ab6009284070ff13b5b87773cddcf..a6c28ba4f25ccde865fc03308c336b3badda1b41 100644 (file)
--- a/tools/net/ynl/ynltool/qstats.c
+++ b/tools/net/ynl/ynltool/qstats.c
@@ -568,6 +568,65 @@ exit_free_qstats:
        return ret;
 }
 
+static int do_hw_gro(int argc, char **argv __attribute__((unused)))
+{
+       struct netdev_qstats_get_list *qstats;
+
+       if (argc > 0) {
+               p_err("hw-gro command takes no arguments");
+               return -1;
+       }
+
+       qstats = qstats_dump(0);
+       if (!qstats)
+               return -1;
+
+       if (json_output)
+               jsonw_start_array(json_wtr);
+
+       ynl_dump_foreach(qstats, qs) {
+               char ifname[IF_NAMESIZE];
+               const char *name;
+               double savings;
+
+               if (!qs->_present.rx_packets ||
+                   !qs->_present.rx_hw_gro_packets ||
+                   !qs->_present.rx_hw_gro_wire_packets)
+                       continue;
+
+               if (!qs->rx_packets)
+                       continue;
+
+               /* How many skbs did we avoid allocating thanks to HW GRO */
+               savings = (double)(qs->rx_hw_gro_wire_packets -
+                                  qs->rx_hw_gro_packets) /
+                       qs->rx_packets * 100.0;
+
+               name = if_indextoname(qs->ifindex, ifname);
+
+               if (json_output) {
+                       jsonw_start_object(json_wtr);
+                       jsonw_uint_field(json_wtr, "ifindex", qs->ifindex);
+                       if (name)
+                               jsonw_string_field(json_wtr, "ifname", name);
+                       jsonw_float_field(json_wtr, "savings", savings);
+                       jsonw_end_object(json_wtr);
+               } else {
+                       if (name)
+                               printf("%s", name);
+                       else
+                               printf("ifindex:%u", qs->ifindex);
+                       printf(": %.1f%% savings\n", savings);
+               }
+       }
+
+       if (json_output)
+               jsonw_end_array(json_wtr);
+
+       netdev_qstats_get_list_free(qstats);
+       return 0;
+}
+
 static int do_help(int argc __attribute__((unused)),
                   char **argv __attribute__((unused)))
 {
@@ -577,9 +636,10 @@ static int do_help(int argc __attribute__((unused)),
        }
 
        fprintf(stderr,
-               "Usage: %s qstats { COMMAND | help }\n"
-               "       %s qstats [ show ] [ OPTIONS ]\n"
-               "       %s qstats balance\n"
+               "Usage: %1$s qstats { COMMAND | help }\n"
+               "       %1$s qstats [ show ] [ OPTIONS ]\n"
+               "       %1$s qstats balance\n"
+               "       %1$s qstats hw-gro\n"
                "\n"
                "       OPTIONS := { scope queue | group-by { device | queue } }\n"
                "\n"
@@ -588,9 +648,14 @@ static int do_help(int argc __attribute__((unused)),
                "       show scope queue      - Display per-queue statistics\n"
                "       show group-by device  - Display device-aggregated statistics (default)\n"
                "       show group-by queue   - Display per-queue statistics\n"
-               "       balance               - Analyze traffic distribution balance.\n"
+               "\n"
+               "  Analysis:\n"
+               "       balance               - Traffic distribution between queues.\n"
+               "       hw-gro                - HW GRO effectiveness analysis\n"
+               "                               - savings - delta between packets received\n"
+               "                                 on the wire and packets seen by the kernel.\n"
                "",
-               bin_name, bin_name, bin_name);
+               bin_name);
 
        return 0;
 }
@@ -598,6 +663,7 @@ static int do_help(int argc __attribute__((unused)),
 static const struct cmd qstats_cmds[] = {
        { "show",       do_show },
        { "balance",    do_balance },
+       { "hw-gro",     do_hw_gro },
        { "help",       do_help },
        { 0 }
 };