0. The first step of this tutorial is to read the following documents (either in the tutorial or at home):

Transcription

1 0. The first step of this tutorial is to read the following documents (either in the tutorial or at home):! ia-32-architectures-software-developer-system-programming-manual pdf! It is important to understand how the performance mechanism works before basing your measurements on it. 1. Execute the following command to make sure that your chipset is compatible with RDTSC: $ cat /proc/cpuinfo Your CPU chipset should be Intel and both tsc and rtscp should be enabled as flag. Intel CPUs have a timestamp counter to keep track of every cycle that occurs on the CPU. Starting with the Intel Pentium processor, the devices have included a per-core timestamp register that stores the value of the timestamp counter and that can be accessed by the RDTSC and RDTSCP assembly instructions. When running a Linux OS, the developer can check if his CPU supports the RDTSCP instruction by looking at the flags field of /proc/cpuinfo ; if rdtscp is one of the flags, then it is supported. How it works: Using the "RDTSC" instruction loads the high-order 32 bits of the timestamp register into EDX, and the low-order 32 bits into EAX 2. As we did in last tutorial, write a 1 MB file into /dev/tutorial:! $ dd if=/dev/random of=/dev/tutorial bs= count=1 3. Using the "RDTSC" instruction loads the high order 32 bits of the timestamp register into EDX, and the low order 32 bits into EAX. The following is used to obtain the current time stamp in C programs:

2 asm volatile ("RDTSC\n\t"!!! "mov %%eax, %1\n\t": "=r" (cycles_high),!! "=r" (cycles_low):: "%eax", "%edx"); To access the complete value, we use uint64_t num_of_cycles = (((uint64_t)cycles_high << 32) cycles_low); 4. Modify the mycat.c (from the previous tutorial) as follows: #include<stdio.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <unistd.h> #include <inttypes.h> int main() {! int fd, ret, mainloop=0;! char f[]="/dev/tutorial";! char buf[1024];! struct timeval startread, endread, startwrite, endwrite;! uint64_t start, end, read_cycles, write_cycles, minread, minwrite;! unsigned cycles_low, cycles_high, cycles_low1, cycles_high1;! while(mainloop < 1000) // Number of trials! fd = open(f,o_rdonly);! if( fd < 0)!! printf("unable to open file\n");!! return 0;! }! ret = read(fd, buf, 1024);! while (ret > 0 ) "RDTSC\n\t" "mov %%edx, %0\n\t" "mov %%eax, %1\n\t": "=r" (cycles_high), "=r" (cycles_low)::"%eax", "%ebx", "%ecx", "%edx");!! write(1, buf, 1024);! "mov %%eax, %1\n\t": "=r" (cycles_high1)!,"=r" (cycles_low1)::"%eax", "%ebx", "%ecx", "%edx");!! start = ( ((uint64_t)cycles_high << 32) cycles_low );

3 !! end = ( ((uint64_t)cycles_high1 << 32) cycles_low1 );!! write_cycles += (end - start);! "mov %%eax, %1\n\t": "=r" (cycles_high)!, "=r" (cycles_low)::"%eax", "%ebx", "%ecx", "%edx");!! ret = read(fd, buf, 1024);! "mov %%eax, %1\n\t": "=r" (cycles_high1)!, "=r" (cycles_low1)::"%eax", "%ebx", "%ecx", "%edx");!! start = ( ((uint64_t)cycles_high << 32) cycles_low );!! end = ( ((uint64_t)cycles_high1 << 32) cycles_low1 );!! read_cycles += (end - start);!! }!! mainloop = mainloop + 1;! }! sleep(1);! printf("\nread cycles: %llu\n", read_cycles);! printf("write cycles: %llu\n", write_cycles);! return 0; } 5. What is this program doing? This program is measuring the total time it takes to read and write to stdout from the /dev/tutorial device. 6. How would you calculate the average time for both read and write? You can divide the total number of cycles between the number of iterations of the loop. NOTE: Remember that even a measurement operation increases the number of CPU cycles and real time execution of the program! Next tutorial we will try to measure both RDTSC and gettimeofday() to see what s this overhead. 7. Finally, let s consider all of these points for future measurements: Fixing CPUID issues: This is a good start: cpuid followed by rdtsc; since the variance in cpuid does not affect the start of the measurement. This is a bad end: a single rdtsc; compiler might reorder rdtsc to somewhere that we do not want.

4 This is bad fix for this problem: cpuid then rdtsc; same issue, rdtsc might still move to other positions. This is a better fix for the end: cpuid followed by rdtsc, followed by cpuid - The problem is that we are now counting cpuid's time "inside" our measurement. - Since cpuid has a high variance the result would not be reliable. The solution: - The preferred way is using RDTSCP if supported by CPU. Using RDTSCP ensures that all the instructions that before it in the source code are executed, before itself.! asm volatile ("CPUID\n\t" // this is outside!!!!! : "=r" (cycles_high), "=r" (cycles_low)!!! :: "%rax", "%rbx", "%rcx", "%rdx"); /*call the function to measure here*/! asm volatile("rdtscp\n\t" // notice that CPUID is no longer inside the measuring range!!! "CPUID\n\t"!!! : "=r" (cycles_high1), "=r" (cycles_low1)!!! :: "%rax", "%rbx", "%rcx", "%rdx"); The not-so-optimal way:! asm volatile ("CPUID\n\t"::: "%rax", "%rbx", "%rcx", "%rdx"); // this is outside! asm volatile ("RDTSC\n\t"!!! : "=r" (cycles_high), "=r" (cycles_low)!!! :: "%rax", "%rdx");

5 /*call the function to measure here*/! asm volatile("mov %%cr0, %%eax\n\t"!! "mov %%eax, %%cr0\n\t" // this causes the serialization!!!!! : "=r" (cycles_high1), "=r" (cycles_low1)!!! :: "%rax", "%rdx");