diff --git a/string/Makefile b/string/Makefile index f76758f..459b2a7 100644 --- a/string/Makefile +++ b/string/Makefile @@ -46,7 +46,7 @@ routines := strcat strchr strcmp strcoll strcpy strcspn \ # for -fbounded-pointer compiles. Glibc uses memchr for explicit checks. o-objects.ob := memcpy.o memset.o memchr.o -strop-tests := memchr memcmp memcpy memmove mempcpy memset memccpy \ +strop-tests := wcscmp memchr memcmp memcpy memmove mempcpy memset memccpy \ stpcpy stpncpy strcat strchr strcmp strcpy strcspn \ strlen strncmp strncpy strpbrk strrchr strspn memmem \ strstr strcasestr strnlen strcasecmp strncasecmp \ diff --git a/string/test-wcscmp.c b/string/test-wcscmp.c new file mode 100644 index 0000000..2b9baed --- /dev/null +++ b/string/test-wcscmp.c @@ -0,0 +1,386 @@ +#include +#include + +#define TEST_MAIN +#include "test-string.h" +#define MAXSAMPLESTPT 1000 + + +int relative_timing; + +typedef int (*proto_t) (const uint32_t *, const uint32_t *); + +static int repeat_one_test = 32; + +int simple_wstrcmp (const uint32_t *, const uint32_t *); +IMPL (simple_wstrcmp, 1) +IMPL (wcscmp, 1) + + +int +simple_wstrcmp (const uint32_t *s1, const uint32_t *s2) +{ + uint32_t ret; + + while ((ret = *s1 - *s2++) == 0 && *s1++); + return ret; +} + + +static int +check_result (impl_t *impl, const uint32_t *s1, const uint32_t *s2, + int exp_result) +{ + int result = CALL (impl, s1, s2); + if ((exp_result == 0 && result != 0) + || (exp_result < 0 && result >= 0) + || (exp_result > 0 && result <= 0)) + { + error (0, 0, "Wrong result in function %s %d %d", impl->name, + result, exp_result); + ret = 1; + return -1; + } + + return 0; +} + +static void +do_one_test (impl_t *impl, const uint32_t *s1, const uint32_t *s2, + size_t len, int exp_result) +{ + if (check_result (impl, s1, s2, exp_result) < 0) + return; + + if (HP_TIMING_AVAIL) + { + hp_timing_t start __attribute ((unused)); + hp_timing_t stop __attribute ((unused)); + hp_timing_t best_time = ~ (hp_timing_t) 0; + size_t i; + + for (i = 0; i < repeat_one_test; ++i) + { + __asm__ ("cpuid" : : : "eax", "ebx", "ecx", "edx"); + HP_TIMING_NOW (start); + CALL (impl, s1, s2); + HP_TIMING_NOW (stop); + HP_TIMING_BEST (best_time, start, stop); + } + + if (relative_timing) + { + hp_timing_t t = (best_time == 0) ? 1 : best_time; + + printf ("\t%zd/%zd", (size_t) (best_time/len), + (size_t) (len / t)); + } + else + printf ("\t%zd", (size_t) best_time); + } +} + +static void +do_one_throughput(impl_t *impl, const uint32_t *s1, const uint32_t *s2) +{ + if (HP_TIMING_AVAIL) + { + __asm__ ("cpuid" : : : "eax", "ebx", "ecx", "edx"); + hp_timing_t start __attribute ((unused)); + hp_timing_t stop __attribute ((unused)); + hp_timing_t best_time = ~ (hp_timing_t) 0; + size_t i; + __asm__ ("cpuid" : : : "eax", "ebx", "ecx", "edx"); + HP_TIMING_NOW (start); + for (i = 0; i < MAXSAMPLESTPT; ++i) + CALL (impl, s1, s2); + HP_TIMING_NOW (stop); + HP_TIMING_DIFF (best_time, start, stop); + + printf ("\t%zd", (size_t) best_time/MAXSAMPLESTPT); + } +} + +static void +do_tpt_test (size_t align1, size_t align2, size_t len, uint32_t max_char, + uint32_t lresidual, int exp_result) +{ + size_t i, a; + uint32_t *s1, *s2; + + if (len == 0) + return; + /* Test up to 32byte alignment. */ + align1 &= 31; + if (align1 + 4 * len + 4 >= page_size) + return; + + /* Test up to 32byte alignment. */ + align2 &= 31; + if (align2 + 4 * len + 4 >= page_size) + return; + /* Put them close to the end of page. */ + i = align1 + 4 * len + 8; + s1 = (uint32_t *) (buf1 + ((page_size - i) / 16 * 16) + align1); + i = align2 + 4 * len + 8; + s2 = (uint32_t *) (buf2 + ((page_size - i) / 16 * 16) + align2); + + for (i = 0; i < len; i++) + s1[i] = s2[i] = 1 + 1023 * i % max_char; + + /* allow asymmetry in string lengths, if string lengths are not equal, + the short one may end before 4KB boundary + */ + s1[len] = lresidual; + s2[len] = 0; + s1[len + 1] = 1023; + s2[len + 1] = 1024 + exp_result; + s2[len - 1] -= exp_result; + + /* Make sure that all strings are terminated with 0. */ + *( (uint32_t *) (buf1 + BUF1PAGES * page_size - 4)) = 0; + *( (uint32_t *) (buf2 + page_size - 4)) = 0; + + if (HP_TIMING_AVAIL) + printf ("TPT: Len2 %4zd, alignment %2zd/%2zd, residual %2zd, exp_result %2d:", len, align1, align2, lresidual, exp_result); + + FOR_EACH_IMPL (impl, relative_timing) + do_one_throughput (impl, s1, s2); + if (HP_TIMING_AVAIL) + { + putchar ('\n'); + } + +} + + +static void +do_test (size_t align1, size_t align2, size_t len, uint32_t max_char, + uint32_t lresidual, int exp_result, int page_start) +{ + size_t i, a; + uint32_t *s1, *s2; + + if (len == 0) + return; + + /* Test up to 16byte alignment. */ + + if (align1 + len * 4 + 4 >= page_size) + return; + + /* Test up to 16byte alignment. */ + + if (align2 + len * 4 + 4 >= page_size) + return; + + if (page_start) + { + s1 = (uint32_t *) (buf1 + align1); + s2 = (uint32_t *) (buf2 + align2); + } + else + { + /* Put them close to the end of page. */ + i = align1 + 4 * len + 8; + s1 = (uint32_t *) (buf1 + ((page_size - i) / 16 * 16) + align1); + i = align2 + 4 * len + 8; + s2 = (uint32_t *) (buf2 + ((page_size - i) / 16 * 16) + align2); + } + + for (i = 0; i < len; i++) + s1[i] = s2[i] = 1 + 1023 * i % max_char; + + s1[len] = lresidual; + s2[len] = 0; + s1[len + 1] = 1023; + s2[len + 1] = 1024 + exp_result; + s2[len - 1] -= exp_result; + + /* Make sure that all strings are terminated with 0. */ + *( (uint32_t *) (buf1 + BUF1PAGES * page_size - 4)) = 0; + *( (uint32_t *) (buf2 + page_size - 4)) = 0; + + if (HP_TIMING_AVAIL) + printf ("LAT: Len2 %4zd, alignment %2zd/%2zd, residual %2zd, exp_result %2d:", len, align1, align2, lresidual, exp_result); + + FOR_EACH_IMPL (impl, relative_timing) + do_one_test (impl, s1, s2, len, exp_result); + + if (HP_TIMING_AVAIL) + putchar ('\n'); +} + +static void +do_random_tests (void) +{ + size_t i, j, n, align1, align2, pos, len1, len2; + int result; + int r; + for (size_t a = 0; a < 4; a++) + for (size_t b = 0; b < 4; b++) + { + uint32_t *p1 = (uint32_t *) (buf1 + page_size - 512 * 4 - a); + uint32_t *p2 = (uint32_t *) (buf2 + page_size - 512 * 4 - b); + + for (n = 0; n < ITERATIONS / 2; n++) + { + align1 = random () & 31; + if (random () & 1) + align2 = random () & 31; + else + align2 = align1 + (random () & 24); + pos = random () & 511; + j = align1 > align2 ? align1 : align2; + if (pos + j >= 511) + pos = 510 - j - (random () & 7); + len1 = random () & 511; + if (pos >= len1 && (random () & 1)) + len1 = pos + (random () & 7); + if (len1 + j >= 512) + len1 = 511 - j - (random () & 7); + if (pos >= len1) + len2 = len1; + else + len2 = len1 + (len1 != 511 - j ? random () % (511 - j - len1) : 0); + j = (pos > len2 ? pos : len2) + align1 + 64; + if (j > 512) + j = 512; + for (i = 0; i < j; ++i) + { + p2[i] = random () & 255; + if (i < len1 + align1 && !p1[i]) + { + p1[i] = random () & 255; + if (!p1[i]) + p1[i] = 1 + (random () & 127); + } + } + for (i = 0; i < j; ++i) + { + p2[i] = random () & 255; + if (i < len2 + align2 && !p2[i]) + { + p2[i] = random () & 255; + if (!p2[i]) + p2[i] = 1 + (random () & 127); + } + } + + result = 0; + memcpy (p2 + align2, p1 + align1, 4 * pos); + if (pos < len1) + { + if (p2[align2 + pos] == p1[align1 + pos]) + { + p2[align2 + pos] = random () & 255; + if (p2[align2 + pos] == p1[align1 + pos]) + p2[align2 + pos] = p1[align1 + pos] + 3 + (random () & 127); + } + + if (p1[align1 + pos] < p2[align2 + pos]) + result = -1; + else + result = 1; + } + p1[len1 + align1] = 0; + p2[len2 + align2] = 0; + + FOR_EACH_IMPL (impl, 1) + { + r = CALL (impl, p1 + align1, p2 + align2); + if ((r == 0 && result) + || (r < 0 && result >= 0) + || (r > 0 && result <= 0)) + { + error (0, 0, "Iteration %zd - wrong result in function %s (%zd, %zd, %zd) %d != %d, p1 %p p2 %p", + n, impl->name, len1, len2, pos, result, r, p1, p2); + ret = 1; + } + } + } + } +} + +static void +check1 (void) +{ + uint32_t *s1 = (uint32_t *)(buf1 + 0xb2c); + uint32_t *s2 = (uint32_t *)(buf1 + 0xfd8); + size_t i1, i2, l1, l2; + int exp_result; + + wcscpy(s1, L"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrs"); + wcscpy(s2, L"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijkLMNOPQRSTUV"); + + l1 = wcslen (s1); + l2 = wcslen (s2); + for (i1 = 0; i1 < l1; i1++) + for (i2 = 0; i2 < l2; i2++) + { + exp_result = simple_wstrcmp (s1 + i1, s2 + i2); + FOR_EACH_IMPL (impl, 0) + check_result (impl, s1 + i1, s2 + i2, exp_result); + } +} + +int +main (int argc, char **argv) +{ + size_t i; + + test_init (); + + check1 (); + + printf ("%23s", ""); + FOR_EACH_IMPL (impl, relative_timing) + printf ("\t%s", impl->name); + putchar ('\n'); + + for (i = 1; i < 32; ++i) + { + do_test (i, i, i, 127, 0, 0, 0); + do_test (i, i, i, 127, 0, 0, 1); + do_test (i, i, i, 127, 0, 1, 1); + do_test (i, i, i, 127, 0, -1, 0); + do_test (i, i, i, 127, 0, -1, 1); + do_test (i, i, i, 127, 1, 1, 1); + } + + for (i = 1; i < 12; ++i) + { + do_test (0, 0, 2 << i, 127, 0, 0, 0); + do_test (0, 0, 2 << i, 254, 0, 0, 0); + do_test (0, 0, 2 << i, 127, 0, 1, 0); + do_test (0, 0, 2 << i, 254, 0, 1, 0); + do_test (0, 0, 2 << i, 127, 0, -1, 0); + do_test (0, 0, 2 << i, 254, 0, -1, 0); + do_test (0, 4 * i, 2 << i, 127, 1, 1, 0); + do_test (4 * i, 4 * i + 4, 2 << i, 254, 1, 1, 0); + } + + for (i = 1; i < 9; ++i) + { + do_test (i, 2 * i, 8 << i, 10000, 0, 0, 0); + do_test (8 * i, 4 * i, 8 << i, 20000, 0, 0, 0); + do_test (i, 2 * i, 8 << i, 30000, 0, 1, 0); + do_test (2 * i, i, 8 << i, 10000, 0, 1, 0); + do_test (4 * i, 4 * i + 4, 8 << i, 20000, 0, -1, 0); + do_test (2 * i, i, 8 << i, 30000, 0, -1, 0); + do_test (4 * i + 4, 4 * i, 8 << i, 10000, 1, 1, 0); + } + + do_random_tests (); + + for (i = 1; i < 5; ++i) + { + do_tpt_test (0, 0, 4 << (i*2), 127, 0, 0); + do_tpt_test (0, 4, 4 << (i*2), 127, 0, 0); + do_tpt_test (12, 0, 4 << (i*2), 127, 0, 0); + do_tpt_test (12, 4, (16 << (i*2)) - i, 127, 0, 0); + do_tpt_test (3, 1, (16 << (i*2)) - i, 127, 1, 1); + } + + return ret; +}