src/vppinfra/test/ip_csum.c

   1 /* SPDX-License-Identifier: Apache-2.0
   2  * Copyright(c) 2021 Cisco Systems, Inc.
   3  */
   4
   5 #include <vppinfra/format.h>
   6 #include <vppinfra/test/test.h>
   7 #include <vppinfra/vector/ip_csum.h>
   8
   9 typedef struct
  10 {
  11   struct
  12   {
  13     u8 *src;
  14     u32 count;
  15   } chunk[5];
  16   u16 result;
  17 } ip_csum_test_t;
  18
  19 static u8 test1[] = { 0x45, 0x00, 0x00, 0x73, 0x00, 0x00, 0x40,
  20                       0x00, 0x40, 0x11, 0x00, 0x00, 0xc0, 0xa8,
  21                       0x00, 0x01, 0xc0, 0xa8, 0x00, 0xc7, 0x00 };
  22 #define TEST_LEN(x) (ARRAY_LEN (x) - 1)
  23
  24 static ip_csum_test_t tests[] = { {
  25                                     .chunk[0].src = test1,
  26                                     .chunk[0].count = TEST_LEN (test1),
  27                                     .result = 0x61b8,
  28                                   },
  29                                   {
  30                                     .chunk[0].src = test1,
  31                                     .chunk[0].count = 1,
  32                                     .chunk[1].src = test1 + 1,
  33                                     .chunk[1].count = 2,
  34                                     .chunk[2].src = test1 + 3,
  35                                     .chunk[2].count = 3,
  36                                     .chunk[3].src = test1 + 6,
  37                                     .chunk[3].count = 4,
  38                                     .chunk[4].src = test1 + 10,
  39                                     .chunk[4].count = TEST_LEN (test1) - 10,
  40                                     .result = 0x61b8,
  41                                   },
  42                                   {
  43                                     .chunk[0].count = 1,
  44                                     .result = 0xff0f,
  45                                   },
  46                                   {
  47                                     .chunk[0].count = 2,
  48                                     .result = 0x080f,
  49                                   },
  50                                   {
  51                                     .chunk[0].count = 3,
  52                                     .result = 0x0711,
  53                                   },
  54                                   {
  55                                     .chunk[0].count = 4,
  56                                     .result = 0x1210,
  57                                   },
  58                                   {
  59                                     .chunk[0].count = 63,
  60                                     .result = 0xda01,
  61                                   },
  62                                   {
  63                                     .chunk[0].count = 64,
  64                                     .result = 0xe100,
  65                                   },
  66                                   {
  67                                     .chunk[0].count = 65,
  68                                     .result = 0xe010,
  69                                   },
  70                                   {
  71                                     .chunk[0].count = 65535,
  72                                     .result = 0xfc84,
  73                                   },
  74                                   {
  75                                     .chunk[0].count = 65536,
  76                                     .result = 0xffff,
  77                                   } };
  78
  79 static clib_error_t *
  80 test_clib_ip_csum (clib_error_t *err)
  81 {
  82   u8 *buf;
  83   buf = test_mem_alloc (65536);
  84   for (int i = 0; i < 65536; i++)
  85     buf[i] = 0xf0 + ((i * 7) & 0xf);
  86
  87   for (int i = 0; i < ARRAY_LEN (tests); i++)
  88     {
  89       clib_ip_csum_t c = {};
  90       ip_csum_test_t *t = tests + i;
  91       u16 rv;
  92
  93       for (int j = 0; j < ARRAY_LEN (((ip_csum_test_t *) 0)->chunk); j++)
  94         if (t->chunk[j].count > 0)
  95           {
  96             if (t->chunk[j].src == 0)
  97               clib_ip_csum_chunk (&c, buf, t->chunk[j].count);
  98             else
  99               clib_ip_csum_chunk (&c, t->chunk[j].src, t->chunk[j].count);
 100           }
 101       rv = clib_ip_csum_fold (&c);
 102
 103       if (rv != tests[i].result)
 104         {
 105           err = clib_error_return (err,
 106                                    "bad checksum in test case %u (expected "
 107                                    "0x%04x, calculated 0x%04x)",
 108                                    i, tests[i].result, rv);
 109           goto done;
 110         }
 111     }
 112 done:
 113   return err;
 114 }
 115
 116 void __test_perf_fn
 117 perftest_ip4_hdr (test_perf_t *tp)
 118 {
 119   u32 n = tp->n_ops;
 120   u8 *data = test_mem_alloc_and_splat (20, n, (void *) &test1);
 121   u16 *res = test_mem_alloc (n * sizeof (u16));
 122
 123   test_perf_event_enable (tp);
 124   for (int i = 0; i < n; i++)
 125     res[i] = clib_ip_csum (data + i * 20, 20);
 126   test_perf_event_disable (tp);
 127 }
 128
 129 void __test_perf_fn
 130 perftest_tcp_payload (test_perf_t *tp)
 131 {
 132   u32 n = tp->n_ops;
 133   volatile uword *lenp = &tp->arg0;
 134   u8 *data = test_mem_alloc_and_splat (20, n, (void *) &test1);
 135   u16 *res = test_mem_alloc (n * sizeof (u16));
 136
 137   test_perf_event_enable (tp);
 138   for (int i = 0; i < n; i++)
 139     res[i] = clib_ip_csum (data + i * lenp[0], lenp[0]);
 140   test_perf_event_disable (tp);
 141 }
 142
 143 void __test_perf_fn
 144 perftest_byte (test_perf_t *tp)
 145 {
 146   volatile uword *np = &tp->n_ops;
 147   u8 *data = test_mem_alloc_and_fill_inc_u8 (*np, 0, 0);
 148   u16 *res = test_mem_alloc (sizeof (u16));
 149
 150   test_perf_event_enable (tp);
 151   res[0] = clib_ip_csum (data, np[0]);
 152   test_perf_event_disable (tp);
 153 }
 154
 155 REGISTER_TEST (clib_ip_csum) = {
 156   .name = "clib_ip_csum",
 157   .fn = test_clib_ip_csum,
 158   .perf_tests = PERF_TESTS (
 159     { .name = "fixed size (per IPv4 Header)",
 160       .n_ops = 1024,
 161       .fn = perftest_ip4_hdr },
 162     { .name = "fixed size (per 1460 byte block)",
 163       .n_ops = 16,
 164       .arg0 = 1460,
 165       .fn = perftest_tcp_payload },
 166     { .name = "variable size (per byte)", .n_ops = 16384, .fn = perftest_byte }
 167
 168     ),
 169 };