640235e2c2
- Some of the lib/libc and lib/thr tests fail - lib/msun/exp_test:exp2_values now passes with clang 3.8.0 The Makefiles in contrib/netbsd-tests were pruned as they have no value Sponsored by: EMC / Isilon Storage Division
271 lines
6.1 KiB
C
271 lines
6.1 KiB
C
/* $NetBSD: in_cksum.c,v 1.5 2015/10/18 18:27:25 christos Exp $ */
|
|
/*-
|
|
* Copyright (c) 2008 Joerg Sonnenberger <joerg@NetBSD.org>.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in
|
|
* the documentation and/or other materials provided with the
|
|
* distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
|
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
|
* COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
|
|
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
|
|
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__KERNEL_RCSID(0, "$NetBSD: in_cksum.c,v 1.5 2015/10/18 18:27:25 christos Exp $");
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/mbuf.h>
|
|
#include <sys/resource.h>
|
|
#include <err.h>
|
|
#include <stdbool.h>
|
|
#include <stdio.h>
|
|
#include <stdarg.h>
|
|
#include <unistd.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#define cpu_in_cksum portable_cpu_in_cksum
|
|
#include "cpu_in_cksum.c"
|
|
|
|
#ifdef HAVE_CPU_IN_CKSUM
|
|
#undef cpu_in_cksum
|
|
int cpu_in_cksum(struct mbuf*, int, int, uint32_t);
|
|
#endif
|
|
|
|
static bool random_aligned;
|
|
|
|
void panic(const char *, ...) __printflike(1, 2);
|
|
void
|
|
panic(const char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
va_start(ap, fmt);
|
|
verrx(1, fmt, ap);
|
|
va_end(ap);
|
|
}
|
|
|
|
static void
|
|
free_mbuf_chain(struct mbuf *m)
|
|
{
|
|
struct mbuf *next;
|
|
|
|
if (m == NULL)
|
|
return;
|
|
|
|
next = m->m_next;
|
|
free(m);
|
|
free_mbuf_chain(next);
|
|
}
|
|
|
|
static struct mbuf *
|
|
allocate_mbuf_chain(char **lens)
|
|
{
|
|
int len, off;
|
|
struct mbuf *m;
|
|
|
|
if (*lens == NULL)
|
|
return NULL;
|
|
|
|
len = atoi(*lens);
|
|
off = random_aligned ? rand() % 64 : 0;
|
|
|
|
m = malloc(sizeof(struct m_hdr) + len + off);
|
|
if (m == NULL)
|
|
err(EXIT_FAILURE, "malloc failed");
|
|
|
|
m->m_data = (char *)m + sizeof(struct m_hdr) + off;
|
|
m->m_len = len;
|
|
|
|
m->m_next = allocate_mbuf_chain(lens + 1);
|
|
|
|
return m;
|
|
}
|
|
|
|
#ifdef MBUFDUMP
|
|
static void
|
|
dump_mbuf(const struct mbuf *m, int len, int off)
|
|
{
|
|
int x = 0;
|
|
if (len <= 0)
|
|
return;
|
|
|
|
printf("Starting len=%d off=%d:\n", len, off);
|
|
if (off > 0) {
|
|
for (; m; m = m->m_next)
|
|
if (off > m->m_len)
|
|
off -= m->m_len;
|
|
else
|
|
break;
|
|
if (m == NULL || off > m->m_len)
|
|
errx(1, "out of data");
|
|
}
|
|
|
|
unsigned char *ptr = mtod(m, unsigned char *) + off;
|
|
unsigned char *eptr = ptr + m->m_len;
|
|
printf("[");
|
|
for (;;) {
|
|
if (ptr == eptr) {
|
|
m = m->m_next;
|
|
if (m == NULL)
|
|
errx(1, "out of data");
|
|
ptr = mtod(m, unsigned char *);
|
|
eptr = ptr + m->m_len;
|
|
printf("]\n[");
|
|
x = 0;
|
|
}
|
|
printf("%.2x ", *ptr++);
|
|
if (++x % 16 == 0)
|
|
printf("\n");
|
|
if (--len == 0)
|
|
break;
|
|
}
|
|
printf("]\n");
|
|
fflush(stdout);
|
|
}
|
|
#endif
|
|
|
|
static void
|
|
randomise_mbuf_chain(struct mbuf *m)
|
|
{
|
|
int i, data, len;
|
|
|
|
for (i = 0; i < m->m_len; i += sizeof(int)) {
|
|
data = rand();
|
|
if (i + sizeof(int) < (size_t)m->m_len)
|
|
len = sizeof(int);
|
|
else
|
|
len = m->m_len - i;
|
|
memcpy(m->m_data + i, &data, len);
|
|
}
|
|
if (m->m_next)
|
|
randomise_mbuf_chain(m->m_next);
|
|
}
|
|
|
|
static int
|
|
mbuf_len(struct mbuf *m)
|
|
{
|
|
return m == NULL ? 0 : m->m_len + mbuf_len(m->m_next);
|
|
}
|
|
|
|
int in_cksum_portable(struct mbuf *, int);
|
|
int in_cksum(struct mbuf *, int);
|
|
|
|
int
|
|
main(int argc, char **argv)
|
|
{
|
|
struct rusage res;
|
|
struct timeval tv, old_tv;
|
|
int loops, old_sum, off, len;
|
|
#ifdef HAVE_CPU_IN_CKSUM
|
|
int new_sum;
|
|
#endif
|
|
long i, iterations;
|
|
uint32_t init_sum;
|
|
struct mbuf *m;
|
|
bool verbose;
|
|
int c;
|
|
|
|
loops = 16;
|
|
verbose = false;
|
|
random_aligned = 0;
|
|
iterations = 100000;
|
|
|
|
while ((c = getopt(argc, argv, "i:l:u:v")) != -1) {
|
|
switch (c) {
|
|
case 'i':
|
|
iterations = atoi(optarg);
|
|
break;
|
|
case 'l':
|
|
loops = atoi(optarg);
|
|
break;
|
|
case 'u':
|
|
random_aligned = atoi(optarg);
|
|
break;
|
|
case 'v':
|
|
verbose = true;
|
|
break;
|
|
default:
|
|
errx(1, "%s [-l <loops>] [-u <unalign> [-i <iterations> "
|
|
"[<mbuf-size> ...]", getprogname());
|
|
}
|
|
}
|
|
|
|
for (; loops; --loops) {
|
|
if ((m = allocate_mbuf_chain(argv + 4)) == NULL)
|
|
continue;
|
|
randomise_mbuf_chain(m);
|
|
init_sum = rand();
|
|
len = mbuf_len(m);
|
|
|
|
/* force one loop over all data */
|
|
if (loops == 1)
|
|
off = 0;
|
|
else
|
|
off = len ? rand() % len : 0;
|
|
|
|
len -= off;
|
|
old_sum = portable_cpu_in_cksum(m, len, off, init_sum);
|
|
#ifdef HAVE_CPU_IN_CKSUM
|
|
#ifdef MBUFDUMP
|
|
printf("m->m_len=%d len=%d off=%d\n", m->m_len, len, off);
|
|
dump_mbuf(m, len, off);
|
|
#endif
|
|
new_sum = cpu_in_cksum(m, len, off, init_sum);
|
|
if (old_sum != new_sum)
|
|
errx(1, "comparison failed: %x %x", old_sum, new_sum);
|
|
#else
|
|
__USE(old_sum);
|
|
#endif
|
|
|
|
if (iterations == 0)
|
|
continue;
|
|
|
|
getrusage(RUSAGE_SELF, &res);
|
|
tv = res.ru_utime;
|
|
for (i = iterations; i; --i)
|
|
(void)portable_cpu_in_cksum(m, len, off, init_sum);
|
|
getrusage(RUSAGE_SELF, &res);
|
|
timersub(&res.ru_utime, &tv, &old_tv);
|
|
if (verbose)
|
|
printf("portable version: %jd.%06jd\n",
|
|
(intmax_t)old_tv.tv_sec, (intmax_t)old_tv.tv_usec);
|
|
|
|
#ifdef HAVE_CPU_IN_CKSUM
|
|
getrusage(RUSAGE_SELF, &res);
|
|
tv = res.ru_utime;
|
|
for (i = iterations; i; --i)
|
|
(void)cpu_in_cksum(m, len, off, init_sum);
|
|
getrusage(RUSAGE_SELF, &res);
|
|
timersub(&res.ru_utime, &tv, &tv);
|
|
if (verbose) {
|
|
printf("test version: %jd.%06jd\n",
|
|
(intmax_t)tv.tv_sec, (intmax_t)tv.tv_usec);
|
|
printf("relative time: %3.g%%\n",
|
|
100 * ((double)tv.tv_sec * 1e6 + tv.tv_usec) /
|
|
((double)old_tv.tv_sec * 1e6 + old_tv.tv_usec + 1));
|
|
}
|
|
#endif
|
|
free_mbuf_chain(m);
|
|
}
|
|
|
|
return 0;
|
|
}
|