286 lines
7.4 KiB
C
286 lines
7.4 KiB
C
|
/*
|
||
|
|
* Copyright (c) 2008 Travis Geiselbrecht
|
||
|
|
*
|
||
|
|
* Permission is hereby granted, free of charge, to any person obtaining
|
||
|
|
* a copy of this software and associated documentation files
|
||
|
|
* (the "Software"), to deal in the Software without restriction,
|
||
|
|
* including without limitation the rights to use, copy, modify, merge,
|
||
|
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||
|
|
* and to permit persons to whom the Software is furnished to do so,
|
||
|
|
* subject to the following conditions:
|
||
|
|
*
|
||
|
|
* The above copyright notice and this permission notice shall be
|
||
|
|
* included in all copies or substantial portions of the Software.
|
||
|
|
*
|
||
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||
|
|
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
||
|
|
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||
|
|
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
||
|
|
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||
|
|
*/
|
||
|
|
#include <debug.h>
|
||
|
|
#include <string.h>
|
||
|
|
#include <malloc.h>
|
||
|
|
#include <app.h>
|
||
|
|
#include <platform.h>
|
||
|
|
#include <kernel/thread.h>
|
||
|
|
|
||
|
|
static uint8_t *src;
|
||
|
|
static uint8_t *dst;
|
||
|
|
|
||
|
|
static uint8_t *src2;
|
||
|
|
static uint8_t *dst2;
|
||
|
|
|
||
|
|
#define BUFFER_SIZE (1024*1024)
|
||
|
|
#define ITERATIONS 16
|
||
|
|
|
||
|
|
extern void *mymemcpy(void *dst, const void *src, size_t len);
|
||
|
|
extern void *mymemset(void *dst, int c, size_t len);
|
||
|
|
|
||
|
|
static void *null_memcpy(void *dst, const void *src, size_t len)
|
||
|
|
{
|
||
|
|
return dst;
|
||
|
|
}
|
||
|
|
|
||
|
|
static time_t bench_memcpy_routine(void *memcpy_routine(void *, const void *, size_t), size_t srcalign, size_t dstalign)
|
||
|
|
{
|
||
|
|
int i;
|
||
|
|
time_t t0;
|
||
|
|
|
||
|
|
t0 = current_time();
|
||
|
|
for (i=0; i < ITERATIONS; i++) {
|
||
|
|
memcpy_routine(dst + dstalign, src + srcalign, BUFFER_SIZE);
|
||
|
|
}
|
||
|
|
return current_time() - t0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void bench_memcpy(void)
|
||
|
|
{
|
||
|
|
time_t null, libc, mine;
|
||
|
|
size_t srcalign, dstalign;
|
||
|
|
|
||
|
|
printf("memcpy speed test\n");
|
||
|
|
thread_sleep(200); // let the debug string clear the serial port
|
||
|
|
|
||
|
|
for (srcalign = 0; srcalign < 64; ) {
|
||
|
|
for (dstalign = 0; dstalign < 64; ) {
|
||
|
|
|
||
|
|
null = bench_memcpy_routine(&null_memcpy, srcalign, dstalign);
|
||
|
|
libc = bench_memcpy_routine(&memcpy, srcalign, dstalign);
|
||
|
|
mine = bench_memcpy_routine(&mymemcpy, srcalign, dstalign);
|
||
|
|
|
||
|
|
printf("srcalign %lu, dstalign %lu\n", srcalign, dstalign);
|
||
|
|
printf(" null memcpy %u msecs\n", null);
|
||
|
|
printf(" libc memcpy %u msecs, %llu bytes/sec\n", libc, BUFFER_SIZE * ITERATIONS * 1000ULL / libc);
|
||
|
|
printf(" my memcpy %u msecs, %llu bytes/sec\n", mine, BUFFER_SIZE * ITERATIONS * 1000ULL / mine);
|
||
|
|
|
||
|
|
if (dstalign == 0)
|
||
|
|
dstalign = 1;
|
||
|
|
else
|
||
|
|
dstalign <<= 1;
|
||
|
|
}
|
||
|
|
if (srcalign == 0)
|
||
|
|
srcalign = 1;
|
||
|
|
else
|
||
|
|
srcalign <<= 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static void fillbuf(void *ptr, size_t len, uint32_t seed)
|
||
|
|
{
|
||
|
|
size_t i;
|
||
|
|
|
||
|
|
for (i = 0; i < len; i++) {
|
||
|
|
((char *)ptr)[i] = seed;
|
||
|
|
seed *= 0x1234567;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static void validate_memcpy(void)
|
||
|
|
{
|
||
|
|
size_t srcalign, dstalign, size;
|
||
|
|
const size_t maxsize = 256;
|
||
|
|
|
||
|
|
printf("testing memcpy for correctness\n");
|
||
|
|
|
||
|
|
/*
|
||
|
|
* do the simple tests to make sure that memcpy doesn't color outside
|
||
|
|
* the lines for all alignment cases
|
||
|
|
*/
|
||
|
|
for (srcalign = 0; srcalign < 64; srcalign++) {
|
||
|
|
for (dstalign = 0; dstalign < 64; dstalign++) {
|
||
|
|
// printf("srcalign %zu, dstalign %zu\n", srcalign, dstalign);
|
||
|
|
for (size = 0; size < maxsize; size++) {
|
||
|
|
|
||
|
|
// printf("srcalign %zu, dstalign %zu, size %zu\n", srcalign, dstalign, size);
|
||
|
|
|
||
|
|
fillbuf(src, maxsize * 2, 567);
|
||
|
|
fillbuf(src2, maxsize * 2, 567);
|
||
|
|
fillbuf(dst, maxsize * 2, 123514);
|
||
|
|
fillbuf(dst2, maxsize * 2, 123514);
|
||
|
|
|
||
|
|
memcpy(dst + dstalign, src + srcalign, size);
|
||
|
|
mymemcpy(dst2 + dstalign, src2 + srcalign, size);
|
||
|
|
|
||
|
|
int comp = memcmp(dst, dst2, maxsize * 2);
|
||
|
|
if (comp != 0) {
|
||
|
|
printf("error! srcalign %zu, dstalign %zu, size %zu\n", srcalign, dstalign, size);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static void validate_memcpy_overlap(void)
|
||
|
|
{
|
||
|
|
size_t srcalign, dstalign, size;
|
||
|
|
const size_t maxsize = 256;
|
||
|
|
int comp;
|
||
|
|
|
||
|
|
printf("testing memcpy for correctness in overlap cases\n");
|
||
|
|
|
||
|
|
for (dstalign = 0; dstalign < 64; dstalign++) {
|
||
|
|
for (size = 0; size < maxsize; size++) {
|
||
|
|
|
||
|
|
fillbuf(src, maxsize * 2, 567);
|
||
|
|
fillbuf(src2, maxsize * 2, 567);
|
||
|
|
|
||
|
|
/* Case one will check cpy memory is the same - fwd*/
|
||
|
|
memcpy(src + dstalign, src, size);
|
||
|
|
comp = memcmp(src + dstalign, src2, size);
|
||
|
|
if (comp != 0) {
|
||
|
|
printf("ERROR (Case1): dstalign %zu, size %zu, ret %d\n", dstalign, size, comp);
|
||
|
|
}
|
||
|
|
|
||
|
|
fillbuf(src, maxsize * 2, 8588485);
|
||
|
|
fillbuf(src2, maxsize * 2, 8588485);
|
||
|
|
|
||
|
|
/* Case two will check cpy memory is the same - bkwd*/
|
||
|
|
memcpy(src, src + dstalign, size);
|
||
|
|
comp = memcmp(src, src2 + dstalign, size);
|
||
|
|
if (comp != 0) {
|
||
|
|
printf("ERROR (Case2): dstalign %zu, size %zu, ret %d\n", dstalign, size, comp);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static time_t bench_memset_routine(void *memset_routine(void *, int, size_t), size_t dstalign)
|
||
|
|
{
|
||
|
|
int i;
|
||
|
|
time_t t0;
|
||
|
|
|
||
|
|
t0 = current_time();
|
||
|
|
for (i=0; i < ITERATIONS; i++) {
|
||
|
|
memset_routine(dst + dstalign, 0, BUFFER_SIZE);
|
||
|
|
}
|
||
|
|
return current_time() - t0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void bench_memset(void)
|
||
|
|
{
|
||
|
|
time_t libc, mine;
|
||
|
|
size_t dstalign;
|
||
|
|
|
||
|
|
printf("memset speed test\n");
|
||
|
|
thread_sleep(200); // let the debug string clear the serial port
|
||
|
|
|
||
|
|
for (dstalign = 0; dstalign < 64; dstalign++) {
|
||
|
|
|
||
|
|
libc = bench_memset_routine(&memset, dstalign);
|
||
|
|
mine = bench_memset_routine(&mymemset, dstalign);
|
||
|
|
|
||
|
|
printf("dstalign %lu\n", dstalign);
|
||
|
|
printf(" libc memset %u msecs, %llu bytes/sec\n", libc, BUFFER_SIZE * ITERATIONS * 1000ULL / libc);
|
||
|
|
printf(" my memset %u msecs, %llu bytes/sec\n", mine, BUFFER_SIZE * ITERATIONS * 1000ULL / mine);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static void validate_memset(void)
|
||
|
|
{
|
||
|
|
size_t dstalign, size;
|
||
|
|
int c;
|
||
|
|
const size_t maxsize = 256;
|
||
|
|
|
||
|
|
printf("testing memset for correctness\n");
|
||
|
|
|
||
|
|
for (dstalign = 0; dstalign < 64; dstalign++) {
|
||
|
|
printf("align %zd\n", dstalign);
|
||
|
|
for (size = 0; size < maxsize; size++) {
|
||
|
|
for (c = 0; c < 256; c++) {
|
||
|
|
|
||
|
|
fillbuf(dst, maxsize * 2, 123514);
|
||
|
|
fillbuf(dst2, maxsize * 2, 123514);
|
||
|
|
|
||
|
|
memset(dst + dstalign, c, size);
|
||
|
|
mymemset(dst2 + dstalign, c, size);
|
||
|
|
|
||
|
|
int comp = memcmp(dst, dst2, maxsize * 2);
|
||
|
|
if (comp != 0) {
|
||
|
|
printf("error! align %zu, c %d, size %zu\n", dstalign, c, size);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
#if defined(WITH_LIB_CONSOLE)
|
||
|
|
#include <lib/console.h>
|
||
|
|
|
||
|
|
static int string_tests(int argc, cmd_args *argv)
|
||
|
|
{
|
||
|
|
src = memalign(64, BUFFER_SIZE + 256);
|
||
|
|
dst = memalign(64, BUFFER_SIZE + 256);
|
||
|
|
src2 = memalign(64, BUFFER_SIZE + 256);
|
||
|
|
dst2 = memalign(64, BUFFER_SIZE + 256);
|
||
|
|
|
||
|
|
printf("src %p, dst %p\n", src, dst);
|
||
|
|
printf("src2 %p, dst2 %p\n", src2, dst2);
|
||
|
|
|
||
|
|
if (argc < 3) {
|
||
|
|
printf("not enough arguments:\n");
|
||
|
|
usage:
|
||
|
|
printf("%s validate <routine>\n", argv[0].str);
|
||
|
|
printf("%s bench <routine>\n", argv[0].str);
|
||
|
|
goto out;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!strcmp(argv[1].str, "validate")) {
|
||
|
|
if (!strcmp(argv[2].str, "memcpy")) {
|
||
|
|
validate_memcpy();
|
||
|
|
} else if (!strcmp(argv[2].str, "memset")) {
|
||
|
|
validate_memset();
|
||
|
|
} else if (!strcmp(argv[2].str, "memcpy_overlap")) {
|
||
|
|
validate_memcpy_overlap();
|
||
|
|
}
|
||
|
|
} else if (!strcmp(argv[1].str, "bench")) {
|
||
|
|
if (!strcmp(argv[2].str, "memcpy")) {
|
||
|
|
bench_memcpy();
|
||
|
|
} else if (!strcmp(argv[2].str, "memset")) {
|
||
|
|
bench_memset();
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
goto usage;
|
||
|
|
}
|
||
|
|
|
||
|
|
out:
|
||
|
|
free(src);
|
||
|
|
free(dst);
|
||
|
|
free(src2);
|
||
|
|
free(dst2);
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
STATIC_COMMAND_START
|
||
|
|
{ "string", NULL, &string_tests },
|
||
|
|
STATIC_COMMAND_END(stringtests);
|
||
|
|
|
||
|
|
#endif
|
||
|
|
|
||
|
|
APP_START(stringtests)
|
||
|
|
APP_END
|
||
|
|
|