1 /*
2  * Copyright (c) 2008-2014 Travis Geiselbrecht
3  *
4  * Permission is hereby granted, free of charge, to any person obtaining
5  * a copy of this software and associated documentation files
6  * (the "Software"), to deal in the Software without restriction,
7  * including without limitation the rights to use, copy, modify, merge,
8  * publish, distribute, sublicense, and/or sell copies of the Software,
9  * and to permit persons to whom the Software is furnished to do so,
10  * subject to the following conditions:
11  *
12  * The above copyright notice and this permission notice shall be
13  * included in all copies or substantial portions of the Software.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
18  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
19  * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
20  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
21  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
22  */
23 #include <stdio.h>
24 #include <string.h>
25 #include <malloc.h>
26 #include <app.h>
27 #include <platform.h>
28 #include <kernel/thread.h>
29 
30 static uint8_t *src;
31 static uint8_t *dst;
32 
33 static uint8_t *src2;
34 static uint8_t *dst2;
35 
36 #define BUFFER_SIZE (2*1024*1024)
37 #define ITERATIONS (256*1024*1024 / BUFFER_SIZE) // enough iterations to have to copy/set 256MB of memory
38 
39 #if 1
mymemcpy(void * dst,const void * src,size_t len)40 static inline void *mymemcpy(void *dst, const void *src, size_t len) { return memcpy(dst, src, len); }
mymemset(void * dst,int c,size_t len)41 static inline void *mymemset(void *dst, int c, size_t len) { return memset(dst, c, len); }
42 #else
43 // if we're testing our own memcpy, use this
44 extern void *mymemcpy(void *dst, const void *src, size_t len);
45 extern void *mymemset(void *dst, int c, size_t len);
46 #endif
47 
48 /* reference implementations of memmove/memcpy */
49 typedef long word;
50 
51 #define lsize sizeof(word)
52 #define lmask (lsize - 1)
53 
c_memmove(void * dest,void const * src,size_t count)54 static void *c_memmove(void *dest, void const *src, size_t count)
55 {
56     char *d = (char *)dest;
57     const char *s = (const char *)src;
58     int len;
59 
60     if (count == 0 || dest == src)
61         return dest;
62 
63     if ((long)d < (long)s) {
64         if (((long)d | (long)s) & lmask) {
65             // src and/or dest do not align on word boundary
66             if ((((long)d ^ (long)s) & lmask) || (count < lsize))
67                 len = count; // copy the rest of the buffer with the byte mover
68             else
69                 len = lsize - ((long)d & lmask); // move the ptrs up to a word boundary
70 
71             count -= len;
72             for (; len > 0; len--)
73                 *d++ = *s++;
74         }
75         for (len = count / lsize; len > 0; len--) {
76             *(word *)d = *(word *)s;
77             d += lsize;
78             s += lsize;
79         }
80         for (len = count & lmask; len > 0; len--)
81             *d++ = *s++;
82     } else {
83         d += count;
84         s += count;
85         if (((long)d | (long)s) & lmask) {
86             // src and/or dest do not align on word boundary
87             if ((((long)d ^ (long)s) & lmask) || (count <= lsize))
88                 len = count;
89             else
90                 len = ((long)d & lmask);
91 
92             count -= len;
93             for (; len > 0; len--)
94                 *--d = *--s;
95         }
96         for (len = count / lsize; len > 0; len--) {
97             d -= lsize;
98             s -= lsize;
99             *(word *)d = *(word *)s;
100         }
101         for (len = count & lmask; len > 0; len--)
102             *--d = *--s;
103     }
104 
105     return dest;
106 }
107 
c_memset(void * s,int c,size_t count)108 static void *c_memset(void *s, int c, size_t count)
109 {
110     char *xs = (char *) s;
111     size_t len = (-(size_t)s) & lmask;
112     word cc = c & 0xff;
113 
114     if ( count > len ) {
115         count -= len;
116         cc |= cc << 8;
117         cc |= cc << 16;
118         if (sizeof(word) == 8)
119             cc |= (uint64_t)cc << 32; // should be optimized out on 32 bit machines
120 
121         // write to non-aligned memory byte-wise
122         for ( ; len > 0; len-- )
123             *xs++ = c;
124 
125         // write to aligned memory dword-wise
126         for ( len = count / lsize; len > 0; len-- ) {
127             *((word *)xs) = (word)cc;
128             xs += lsize;
129         }
130 
131         count &= lmask;
132     }
133 
134     // write remaining bytes
135     for ( ; count > 0; count-- )
136         *xs++ = c;
137 
138     return s;
139 }
140 
null_memcpy(void * dst,const void * src,size_t len)141 static void *null_memcpy(void *dst, const void *src, size_t len)
142 {
143     return dst;
144 }
145 
bench_memcpy_routine(void * memcpy_routine (void *,const void *,size_t),size_t srcalign,size_t dstalign)146 static lk_time_t bench_memcpy_routine(void *memcpy_routine(void *, const void *, size_t), size_t srcalign, size_t dstalign)
147 {
148     int i;
149     lk_time_t t0;
150 
151     t0 = current_time();
152     for (i=0; i < ITERATIONS; i++) {
153         memcpy_routine(dst + dstalign, src + srcalign, BUFFER_SIZE);
154     }
155     return current_time() - t0;
156 }
157 
bench_memcpy(void)158 static void bench_memcpy(void)
159 {
160     lk_time_t null, c, libc, mine;
161     size_t srcalign, dstalign;
162 
163     printf("memcpy speed test\n");
164     thread_sleep(200); // let the debug string clear the serial port
165 
166     for (srcalign = 0; srcalign < 64; ) {
167         for (dstalign = 0; dstalign < 64; ) {
168 
169             null = bench_memcpy_routine(&null_memcpy, srcalign, dstalign);
170             c = bench_memcpy_routine(&c_memmove, srcalign, dstalign);
171             libc = bench_memcpy_routine(&memcpy, srcalign, dstalign);
172             mine = bench_memcpy_routine(&mymemcpy, srcalign, dstalign);
173 
174             printf("srcalign %zu, dstalign %zu: ", srcalign, dstalign);
175             printf("   null memcpy %u msecs\n", null);
176             printf("c memcpy %u msecs, %llu bytes/sec; ", c, (uint64_t)BUFFER_SIZE * ITERATIONS * 1000ULL / c);
177             printf("libc memcpy %u msecs, %llu bytes/sec; ", libc, (uint64_t)BUFFER_SIZE * ITERATIONS * 1000ULL / libc);
178             printf("my memcpy %u msecs, %llu bytes/sec; ", mine, (uint64_t)BUFFER_SIZE * ITERATIONS * 1000ULL / mine);
179             printf("\n");
180 
181             if (dstalign < 8)
182                 dstalign++;
183             else
184                 dstalign <<= 1;
185         }
186         if (srcalign < 8)
187             srcalign++;
188         else
189             srcalign <<= 1;
190     }
191 }
192 
fillbuf(void * ptr,size_t len,uint32_t seed)193 static void fillbuf(void *ptr, size_t len, uint32_t seed)
194 {
195     size_t i;
196 
197     for (i = 0; i < len; i++) {
198         ((char *)ptr)[i] = seed;
199         seed *= 0x1234567;
200     }
201 }
202 
validate_memcpy(void)203 static void validate_memcpy(void)
204 {
205     size_t srcalign, dstalign, size;
206     const size_t maxsize = 256;
207 
208     printf("testing memcpy for correctness\n");
209 
210     /*
211      * do the simple tests to make sure that memcpy doesn't color outside
212      * the lines for all alignment cases
213      */
214     for (srcalign = 0; srcalign < 64; srcalign++) {
215         printf("srcalign %zu\n", srcalign);
216         for (dstalign = 0; dstalign < 64; dstalign++) {
217             //printf("\tdstalign %zu\n", dstalign);
218             for (size = 0; size < maxsize; size++) {
219 
220                 //printf("srcalign %zu, dstalign %zu, size %zu\n", srcalign, dstalign, size);
221 
222                 fillbuf(src, maxsize * 2, 567);
223                 fillbuf(src2, maxsize * 2, 567);
224                 fillbuf(dst, maxsize * 2, 123514);
225                 fillbuf(dst2, maxsize * 2, 123514);
226 
227                 c_memmove(dst + dstalign, src + srcalign, size);
228                 memcpy(dst2 + dstalign, src2 + srcalign, size);
229 
230                 int comp = memcmp(dst, dst2, maxsize * 2);
231                 if (comp != 0) {
232                     printf("error! srcalign %zu, dstalign %zu, size %zu\n", srcalign, dstalign, size);
233                 }
234             }
235         }
236     }
237 }
238 
bench_memset_routine(void * memset_routine (void *,int,size_t),size_t dstalign,size_t len)239 static lk_time_t bench_memset_routine(void *memset_routine(void *, int, size_t), size_t dstalign, size_t len)
240 {
241     int i;
242     lk_time_t t0;
243 
244     t0 = current_time();
245     for (i=0; i < ITERATIONS; i++) {
246         memset_routine(dst + dstalign, 0, len);
247     }
248     return current_time() - t0;
249 }
250 
bench_memset(void)251 static void bench_memset(void)
252 {
253     lk_time_t c, libc, mine;
254     size_t dstalign;
255 
256     printf("memset speed test\n");
257     thread_sleep(200); // let the debug string clear the serial port
258 
259     for (dstalign = 0; dstalign < 64; dstalign++) {
260 
261         c = bench_memset_routine(&c_memset, dstalign, BUFFER_SIZE);
262         libc = bench_memset_routine(&memset, dstalign, BUFFER_SIZE);
263         mine = bench_memset_routine(&mymemset, dstalign, BUFFER_SIZE);
264 
265         printf("dstalign %zu: ", dstalign);
266         printf("c memset %u msecs, %llu bytes/sec; ", c, (uint64_t)BUFFER_SIZE * ITERATIONS * 1000ULL / c);
267         printf("libc memset %u msecs, %llu bytes/sec; ", libc, (uint64_t)BUFFER_SIZE * ITERATIONS * 1000ULL / libc);
268         printf("my memset %u msecs, %llu bytes/sec; ", mine, (uint64_t)BUFFER_SIZE * ITERATIONS * 1000ULL / mine);
269         printf("\n");
270     }
271 }
272 
validate_memset(void)273 static void validate_memset(void)
274 {
275     size_t dstalign, size;
276     int c;
277     const size_t maxsize = 256;
278 
279     printf("testing memset for correctness\n");
280 
281     for (dstalign = 0; dstalign < 64; dstalign++) {
282         printf("align %zd\n", dstalign);
283         for (size = 0; size < maxsize; size++) {
284             for (c = -1; c < 257; c++) {
285 
286                 fillbuf(dst, maxsize * 2, 123514);
287                 fillbuf(dst2, maxsize * 2, 123514);
288 
289                 c_memset(dst + dstalign, c, size);
290                 memset(dst2 + dstalign, c, size);
291 
292                 int comp = memcmp(dst, dst2, maxsize * 2);
293                 if (comp != 0) {
294                     printf("error! align %zu, c 0x%x, size %zu\n", dstalign, c, size);
295                 }
296             }
297         }
298     }
299 }
300 
301 #if defined(WITH_LIB_CONSOLE)
302 #include <lib/console.h>
303 
string_tests(int argc,const cmd_args * argv)304 static int string_tests(int argc, const cmd_args *argv)
305 {
306     src = memalign(64, BUFFER_SIZE + 256);
307     dst = memalign(64, BUFFER_SIZE + 256);
308     src2 = memalign(64, BUFFER_SIZE + 256);
309     dst2 = memalign(64, BUFFER_SIZE + 256);
310 
311     printf("src %p, dst %p\n", src, dst);
312     printf("src2 %p, dst2 %p\n", src2, dst2);
313 
314     if (!src || !dst || !src2 || !dst2) {
315         printf("failed to allocate all the buffers\n");
316         goto out;
317     }
318 
319     if (argc < 3) {
320         printf("not enough arguments:\n");
321 usage:
322         printf("%s validate <routine>\n", argv[0].str);
323         printf("%s bench <routine>\n", argv[0].str);
324         goto out;
325     }
326 
327     if (!strcmp(argv[1].str, "validate")) {
328         if (!strcmp(argv[2].str, "memcpy")) {
329             validate_memcpy();
330         } else if (!strcmp(argv[2].str, "memset")) {
331             validate_memset();
332         }
333     } else if (!strcmp(argv[1].str, "bench")) {
334         if (!strcmp(argv[2].str, "memcpy")) {
335             bench_memcpy();
336         } else if (!strcmp(argv[2].str, "memset")) {
337             bench_memset();
338         }
339     } else {
340         goto usage;
341     }
342 
343 out:
344     free(src);
345     free(dst);
346     free(src2);
347     free(dst2);
348 
349     return 0;
350 }
351 
352 STATIC_COMMAND_START
353 STATIC_COMMAND("string", "memcpy tests", &string_tests)
354 STATIC_COMMAND_END(stringtests);
355 
356 #endif
357 
358 APP_START(stringtests)
359 APP_END
360 
361