Lines Matching refs:size
134 int validate_memcpy(char* s, char* d, size_t size);
135 int validate_memset(char* s, char c, size_t size);
162 struct result_t { int size; float res; };
165 int size = 0;
168 if (size<128) size += 8;
169 else if (size<1024) size += 128;
170 else if (size<16384) size += 1024;
171 else size <<= 1;
175 size = FAST_SIZES[i];
177 if (size > MAX_SIZE) {
181 const int REPEAT = (((size < DCACHE_SIZE) ?
182 (CACHED_SPEED_EST) : (UNCACHED_SPEED_EST)) / size) / 2;
192 memcpy(dst, src, size); // just make sure to load the caches I/D
196 MEMCPY(ddd, sss+offset, size);
199 const float throughput = (size*1000000000.0f*REPEAT) / (1024*1024*t);
200 results[nbr].size = size;
206 printf("%9s %9s %9s\n", "size", "MB/s", "MB/s (nc)");
208 printf("%9d %9ld %9ld\n", results[i].size, (long)results[i].res, (long)results[i+1].res);
221 for (int size=0 ; size<4096 && !nb ; size++) {
222 nb += validate_memcpy(s, d, size);
224 nb += validate_memcpy(s+o, d, size);
225 nb += validate_memcpy(s, d+o, size);
226 nb += validate_memcpy(s+o, d+o, size);
238 int validate_memcpy(char* s, char* d, size_t size)
241 memset(d-4, 0x55, size+8);
242 MEMCPY(s, d, size);
243 if (memcmp(s,d,size)) {
244 printf("*** memcpy(%p,%p,%zd) destination != source\n",s,d,size);
247 bool r = (d[size]==0x55)&&(d[size+1]==0x55)&&(d[size+2]==0x55)&&(d[size+3]==0x55);
249 printf("*** memcpy(%p,%p,%zd) clobbered past end of destination!\n",s,d,size);
254 printf("*** memcpy(%p,%p,%zd) clobbered before start of destination!\n",s,d,size);
288 struct result_t { int size; float res; };
291 int size = 0;
295 size = FAST_SIZES[i];
296 if (size > MAX_SIZE) {
299 const int REPEAT = (((size < DCACHE_SIZE) ?
300 (CACHED_SPEED_EST) : (UNCACHED_SPEED_EST)) / size);
307 else preload(dst, size); // load D
311 memset(dst, 0, size);
315 const float throughput = (size*1000000000.0f*REPEAT) / (1024*1024*t);
316 results[nbr].size = size;
322 printf("%9s %9s %9s\n", "size", "MB/s", "MB/s (cached)");
324 printf("%9d %9ld %9ld\n", results[i].size, (long)results[i].res, (long)results[i+1].res);
332 for (int size=0 ; size<4096 && !nb ; size++) {
333 nb += validate_memset(d, char(o), size);
334 nb += validate_memset(d+o, char(o), size);
345 int validate_memset(char* d, char c, size_t size)
348 for (size_t i=0; i<size ; d[i++]=0xaa) ;
350 d[size+1] = 0x55;
351 memset(d, c, size);
352 if (d[size+1]!=0x55) {
353 printf("*** memset(%p,%02x,%zd) clobbered past end of destination!\n",d,(int)c,size);
357 printf("*** memset(%p,%02x,%zd) clobbered before start of destination!\n",d,(int)c,size);
360 for (size_t i=0 ; i<size ; i++) {
362 printf("*** memset(%p,%02x,%zd) failed at offset %zd\n",d,(int)c,size, i);
389 int validate_memcmp(const char* s, const char* d, size_t size)
392 int a = ref_memcmp(s, d, size);
393 int b = memcmp(s, d, size);
397 printf("*** memcmp(%p,%p,%zd) failed %d should be %d\n",s,d,size,b,a);
426 struct result_t { int size; float res; };
429 int size = 0;
433 size = FAST_SIZES[i];
434 if (size > MAX_SIZE) {
438 const int REPEAT = (((size < DCACHE_SIZE) ?
439 (CACHED_SPEED_EST) : (UNCACHED_SPEED_EST)) / size) / 2;
449 memcpy(ddd, sss+offset, size); // just make sure to load the caches I/D
453 c = memcmp(ddd, sss+offset, size);
454 //printf("size %d, memcmp -> %d\n", size, (int)c);
456 c = memcmp(ddd, sss+offset, size);
460 const float throughput = (size*1000000000.0f*REPEAT) / (1024*1024*t);
461 results[nbr].size = size;
467 printf("%9s %9s %9s\n", "size", "MB/s", "MB/s (nc)");
469 printf("%9d %9ld %9ld\n", results[i].size, (long)results[i].res, (long)results[i+1].res);
492 for (int size=0 ; size<32 && !nb ; size++) {
494 nb += validate_memcmp(s+o, d+o, size);
496 // memmove((char*)d+1, d, size);
498 nb += validate_memcmp(s, d+o, size);
538 struct result_t { int size; float res; };
541 int size = 0;
545 size = FAST_SIZES[i];
546 if (size > MAX_SIZE) {
549 const int REPEAT = (((size < DCACHE_SIZE) ?
550 (CACHED_SPEED_EST) : (UNCACHED_SPEED_EST)) / size);
556 memset(str, 'A', size-1);
558 else preload(str, size); // load D
569 const float throughput = (size*1000000000.0f*REPEAT) / (1024*1024*t);
570 results[nbr].size = size;
576 printf("%9s %9s %9s\n", "size", "MB/s", "MB/s (cached)");
578 printf("%9d %9ld %9ld\n", results[i].size, (long)results[i].res, (long)results[i+1].res);
597 size_t size = 0x40000000;
598 while (size) {
599 void* addr = malloc(size);
601 printf("size = %9zd failed\n", size);
602 size >>= 1;
604 total += size;
605 printf("size = %9zd, addr = %p (total = %9zd (%zd MB))\n",
606 size, addr, total, total / (1024*1024));
610 memset(addr, 0, size);
612 size = size + (size>>1);
627 size_t size = i==0 ? 4096 : 48*1024*1024; // 48 MB
628 printf("Allocating %zd MB... ", size/(1024*1024)); fflush(stdout);
629 void* addr1 = mmap(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
633 memset(addr1, 0x55, size);
636 madvise(addr1, size, MADV_DONTNEED);
647 printf("Allocating %zd MB... ", size/(1024*1024)); fflush(stdout);
648 void* addr2 = mmap(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
652 memset(addr2, 0xAA, size);
655 munmap(addr2, size);
658 memset(addr1, 0x55, size);
661 munmap(addr1, size);