Lines Matching full:size
132 int validate_memcpy(char* s, char* d, size_t size);
133 int validate_memset(char* s, char c, size_t size);
160 struct result_t { int size; float res; };
163 int size = 0;
166 if (size<128) size += 8;
167 else if (size<1024) size += 128;
168 else if (size<16384) size += 1024;
169 else size <<= 1;
173 size = FAST_SIZES[i];
175 if (size > MAX_SIZE) {
179 const int REPEAT = (((size < DCACHE_SIZE) ?
180 (CACHED_SPEED_EST) : (UNCACHED_SPEED_EST)) / size) / 2;
190 memcpy(dst, src, size); // just make sure to load the caches I/D
194 MEMCPY(ddd, sss+offset, size);
197 const float throughput = (size*1000000000.0f*REPEAT) / (1024*1024*t);
198 results[nbr].size = size;
204 printf("%9s %9s %9s\n", "size", "MB/s", "MB/s (nc)");
206 printf("%9d %9ld %9ld\n", results[i].size, (long)results[i].res, (long)results[i+1].res);
219 for (int size=0 ; size<4096 && !nb ; size++) {
220 nb += validate_memcpy(s, d, size);
222 nb += validate_memcpy(s+o, d, size);
223 nb += validate_memcpy(s, d+o, size);
224 nb += validate_memcpy(s+o, d+o, size);
236 int validate_memcpy(char* s, char* d, size_t size)
239 memset(d-4, 0x55, size+8);
240 MEMCPY(s, d, size);
241 if (memcmp(s,d,size)) {
242 printf("*** memcpy(%p,%p,%lu) destination != source\n",s,d,size);
245 bool r = (d[size]==0x55)&&(d[size+1]==0x55)&&(d[size+2]==0x55)&&(d[size+3]==0x55);
247 printf("*** memcpy(%p,%p,%lu) clobbered past end of destination!\n",s,d,size);
252 printf("*** memcpy(%p,%p,%lu) clobbered before start of destination!\n",s,d,size);
286 struct result_t { int size; float res; };
289 int size = 0;
293 size = FAST_SIZES[i];
294 if (size > MAX_SIZE) {
297 const int REPEAT = (((size < DCACHE_SIZE) ?
298 (CACHED_SPEED_EST) : (UNCACHED_SPEED_EST)) / size);
305 else preload(dst, size); // load D
309 memset(dst, 0, size);
313 const float throughput = (size*1000000000.0f*REPEAT) / (1024*1024*t);
314 results[nbr].size = size;
320 printf("%9s %9s %9s\n", "size", "MB/s", "MB/s (cached)");
322 printf("%9d %9ld %9ld\n", results[i].size, (long)results[i].res, (long)results[i+1].res);
330 for (int size=0 ; size<4096 && !nb ; size++) {
331 nb += validate_memset(d, char(o), size);
332 nb += validate_memset(d+o, char(o), size);
343 int validate_memset(char* d, char c, size_t size)
346 for (size_t i=0; i<size ; d[i++]=0xaa) ;
348 d[size+1] = 0x55;
349 memset(d, c, size);
350 if (d[size+1]!=0x55) {
351 printf("*** memset(%p,%02x,%lu) clobbered past end of destination!\n",d,(int)c,size);
355 printf("*** memset(%p,%02x,%lu) clobbered before start of destination!\n",d,(int)c,size);
358 for (size_t i=0 ; i<size ; i++) {
360 printf("*** memset(%p,%02x,%lu) failed at offset %lu\n",d,(int)c,size, i);
387 int validate_memcmp(const char* s, const char* d, size_t size)
390 int a = ref_memcmp(s, d, size);
391 int b = memcmp(s, d, size);
395 printf("*** memcmp(%p,%p,%lu) failed %d should be %d\n",s,d,size,b,a);
424 struct result_t { int size; float res; };
427 int size = 0;
431 size = FAST_SIZES[i];
432 if (size > MAX_SIZE) {
436 const int REPEAT = (((size < DCACHE_SIZE) ?
437 (CACHED_SPEED_EST) : (UNCACHED_SPEED_EST)) / size) / 2;
447 memcpy(ddd, sss+offset, size); // just make sure to load the caches I/D
451 c = memcmp(ddd, sss+offset, size);
452 //printf("size %d, memcmp -> %d\n", size, (int)c);
454 c = memcmp(ddd, sss+offset, size);
458 const float throughput = (size*1000000000.0f*REPEAT) / (1024*1024*t);
459 results[nbr].size = size;
465 printf("%9s %9s %9s\n", "size", "MB/s", "MB/s (nc)");
467 printf("%9d %9ld %9ld\n", results[i].size, (long)results[i].res, (long)results[i+1].res);
490 for (int size=0 ; size<32 && !nb ; size++) {
492 nb += validate_memcmp(s+o, d+o, size);
494 // memmove((char*)d+1, d, size);
496 nb += validate_memcmp(s, d+o, size);
536 struct result_t { int size; float res; };
539 int size = 0;
543 size = FAST_SIZES[i];
544 if (size > MAX_SIZE) {
547 const int REPEAT = (((size < DCACHE_SIZE) ?
548 (CACHED_SPEED_EST) : (UNCACHED_SPEED_EST)) / size);
554 memset(str, 'A', size-1);
556 else preload(str, size); // load D
567 const float throughput = (size*1000000000.0f*REPEAT) / (1024*1024*t);
568 results[nbr].size = size;
574 printf("%9s %9s %9s\n", "size", "MB/s", "MB/s (cached)");
576 printf("%9d %9ld %9ld\n", results[i].size, (long)results[i].res, (long)results[i+1].res);
595 size_t size = 0x40000000;
596 while (size) {
597 void* addr = malloc(size);
599 printf("size = %9lu failed\n", size);
600 size >>= 1;
602 total += size;
603 printf("size = %9lu, addr = %p (total = %9lu (%lu MB))\n",
604 size, addr, total, total / (1024*1024));
608 memset(addr, 0, size);
610 size = size + size>>1;
625 size_t size = i==0 ? 4096 : 48*1024*1024; // 48 MB
626 printf("Allocating %lu MB... ", size/(1024*1024)); fflush(stdout);
627 void* addr1 = mmap(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
631 memset(addr1, 0x55, size);
634 madvise(addr1, size, MADV_DONTNEED);
645 printf("Allocating %lu MB... ", size/(1024*1024)); fflush(stdout);
646 void* addr2 = mmap(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
650 memset(addr2, 0xAA, size);
653 munmap(addr2, size);
656 memset(addr1, 0x55, size);
659 munmap(addr1, size);
