Assume we&#39;re trying to use the tsc for performance monitoring and we we want to prevent instruction reordering.

These are our options: 

**1:** `rdtscp` is a serializing call. It prevents reordering around the call to rdtscp.

    __asm__ __volatile__(&quot;rdtscp; &quot;         // serializing read of tsc
                         &quot;shl $32,%%rdx; &quot;  // shift higher 32 bits stored in rdx up
                         &quot;or %%rdx,%%rax&quot;   // and or onto rax
                         : &quot;=a&quot;(tsc)        // output to tsc variable
                         :
                         : &quot;%rcx&quot;, &quot;%rdx&quot;); // rcx and rdx are clobbered

However, `rdtscp` is only available on newer CPUs. So in this case we have to use `rdtsc`. But `rdtsc` is non-serializing, so using it alone will not prevent the CPU from reordering it.

So we can use either of these two options to prevent reordering:

**2:** This is a call to `cpuid` and then `rdtsc`. `cpuid` is a serializing call.

    volatile int dont_remove __attribute__((unused)); // volatile to stop optimizing
    unsigned tmp;
    __cpuid(0, tmp, tmp, tmp, tmp);                   // cpuid is a serialising call
    dont_remove = tmp;                                // prevent optimizing out cpuid

    __asm__ __volatile__(&quot;rdtsc; &quot;          // read of tsc
                         &quot;shl $32,%%rdx; &quot;  // shift higher 32 bits stored in rdx up
                         &quot;or %%rdx,%%rax&quot;   // and or onto rax
                         : &quot;=a&quot;(tsc)        // output to tsc
                         :
                         : &quot;%rcx&quot;, &quot;%rdx&quot;); // rcx and rdx are clobbered

**3:** This is a call to `rdtsc` with `memory` in the clobber list, which prevents reordering

    __asm__ __volatile__(&quot;rdtsc; &quot;          // read of tsc
                         &quot;shl $32,%%rdx; &quot;  // shift higher 32 bits stored in rdx up
                         &quot;or %%rdx,%%rax&quot;   // and or onto rax
                         : &quot;=a&quot;(tsc)        // output to tsc
                         :
                         : &quot;%rcx&quot;, &quot;%rdx&quot;, &quot;memory&quot;); // rcx and rdx are clobbered
                                                      // memory to prevent reordering

My understanding for the 3rd option is as follows:

Making the call `__volatile__` prevents the optimizer from removing the asm or moving it across any instructions that could need the results (or change the inputs) of the asm. However it could still move it with respect to unrelated operations. So `__volatile__` is not enough.

Tell the compiler memory is being clobbered: ` : &quot;memory&quot;)`. The `&quot;memory&quot;` clobber means that GCC cannot make any assumptions about memory contents remaining the same across the asm, and thus will not reorder around it.

So my questions are:

 - 1: Is my understanding of `__volatile__` and `&quot;memory&quot;` correct?
 - 2: Do the second two calls do the same thing?
 - 3: Using `&quot;memory&quot;` looks much simpler than using another serializing instruction. Why would anyone use the 3rd option over the 2nd option?

All Rdtsc Solutions on Gang of Coders

Total of 1 Rdtsc Solutions

Difference between rdtscp, rdtsc : memory and cpuid / rdtsc?