rdtscp, rdtsc: memory ve cpuid/rdtsc arasındaki fark nedir?

Question

Performans izleme için tsc'yi kullanmaya çalıştığımızı ve talimatların yeniden sıralanmasını önlemek istediğimizi varsayalım.

1:rdtscp bir Serileştirme çağrıdır

Bu

bizim seçeneklerdir. Rdtscp'ye çağrı etrafında yeniden sıralamayı engeller.

__asm__ __volatile__("rdtscp; "   // serializing read of tsc 
        "shl $32,%%rdx; " // shift higher 32 bits stored in rdx up 
        "or %%rdx,%%rax" // and or onto rax 
        : "=a"(tsc)  // output to tsc variable 
        : 
        : "%rcx", "%rdx"); // rcx and rdx are clobbered 

Ancak rdtscp yeni işlemci üzerinde kullanılabilir. Bu durumda rdtsc kullanmamız gerekiyor. Ancak rdtsc seri hale getirilmiyor, dolayısıyla tek başına kullanmak CPU'nun yeniden sıralanmasını engelleyemez.

2:

yüzden yeniden sıralama önlemek için bu iki seçenekten birini kullanabilirsiniz Bu da cpuid ve rdtsc için bir çağrıdır. cpuid seri hale getirme çağrısıdır.

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__("rdtsc; "   // read of tsc 
        "shl $32,%%rdx; " // shift higher 32 bits stored in rdx up 
        "or %%rdx,%%rax" // and or onto rax 
        : "=a"(tsc)  // output to tsc 
        : 
        : "%rcx", "%rdx"); // rcx and rdx are clobbered 

3: Bu yeniden sıralama önler clobber listesinde memory ile rdtsc çağrısı olduğunu

__asm__ __volatile__("rdtsc; "   // read of tsc 
        "shl $32,%%rdx; " // shift higher 32 bits stored in rdx up 
        "or %%rdx,%%rax" // and or onto rax 
        : "=a"(tsc)  // output to tsc 
        : 
        : "%rcx", "%rdx", "memory"); // rcx and rdx are clobbered 
                // memory to prevent reordering 

aşağıdaki gibi 3 seçenek için My anlayış:

Yapımı __volatile__ numaralı çağrı, eniyileyicinin asm'ı kaldırmasını veya asm'ın sonuçlarına (veya girdilerin değiştirilmesine) gerek duyabilecek herhangi bir yönerge üzerinde hareket etmesini engeller. Ancak ilgisiz operasyonlara göre hareket edebilir. Yani __volatile__ yeterli değil.

Derleyici belleğinin yakalandığını söyle: : "memory"). "memory" clobber, GCC'nin, bellek içeriği ile ilgili olarak asm'da aynı kalan tüm varsayımları yapamayacağı anlamına gelir ve bu nedenle, etrafında yeniden sıralama yapmayacaktır.

Yani benim sorular şunlardır:

• 1: __volatile__ ve "memory" doğru benim anlayış var mı?
• 2: İkinci iki çağrı da aynı şeyi yapıyor mu?
• 3: "memory"'u kullanmak, başka bir serileştirme komutunu kullanmaktan çok daha basit görünüyor. Neden 3. seçenekte 3. seçeneği kullanan kimse var?
bir yorumda belirtildiği gibi

Answer 1

, bir derleyici bariyer ve işlemci bariyer arasında bir fark vardır. Asm deyiminde volatile ve memory derleyici bariyeri olarak işlev görür, ancak işlemci yönergeleri yeniden düzenlemek için hala ücretsizdir.

İşlemci bariyeri, açıkça belirtilmesi gereken özel talimatlardır, örn. rdtscp, cpuid, hafıza kilidi talimatları (mfence, lfence, ...) vb.Olarak bir kenara

, rdtsc yaygındır önce bariyer olarak cpuid kullanırken, aynı zamanda sanal makine platformları genellikle tuzak beri bir performans açısından çok kötü olabilir ve CPU ortak bir dizi empoze etmek amacıyla cpuid talimat taklit Bir kümedeki birden fazla makinede bulunan özellikler (canlı geçişin çalışmasını sağlamak için). Böylece bellek çit talimatlarından birini kullanmak daha iyidir.

Linux çekirdeği AMD platformlarında mfence;rdtsc ve Intel lfence;rdtsc kullanır. Üzerinde mfence;rdtsc eserler bunlar arasında ayrım ile rahatsız etmek istemiyorsanız hem de mfencelfence daha güçlü bir engeldir yavaş olarak biraz olsa.

Answer 2

bunu aşağıda gösterildiği sever kullanabilirsiniz:

Yukarıdaki kodda

asm volatile (
"CPUID\n\t"/*serialize*/ 
"RDTSC\n\t"/*read the clock*/ 
"mov %%edx, %0\n\t" 
"mov %%eax, %1\n\t": "=r" (cycles_high), "=r" 
(cycles_low):: "%rax", "%rbx", "%rcx", "%rdx"); 
/* 
Call the function to benchmark 
*/ 
asm volatile (
"RDTSCP\n\t"/*read the clock*/ 
"mov %%edx, %0\n\t" 
"mov %%eax, %1\n\t" 
"CPUID\n\t": "=r" (cycles_high1), "=r" 
(cycles_low1):: "%rax", "%rbx", "%rcx", "%rdx"); 

, ilk CPUID çağrı RDTSC talimatı altında ve üstünde talimatların dışı bir yürütme önlemek için bir bariyer uygular. Bu yöntemle, gerçek zamanlı kayıtlar

arasındaki bir CPUID komutunu çağırmaktan kaçınırız. İlk RDTSC sonra zaman damgası yazıcısını okur ve değer belleğinde saklanır. Sonra ölçmek istediğimiz kod yürütülür. RDTSCP komutu, zaman damgası kaydını ikinci kez okur ve ölçmek istediğimiz tüm kodların yürütülmesinin tamamlanmasını garanti eder. Daha sonra gelen iki “mov” komutu edx ve eax kayıtlarını hafızaya kaydeder. Son olarak, bir CPUID çağrısı, bir engelin tekrar uygulanmasını garanti eder, böylece daha sonra gelen herhangi bir komutun, CPUID'den önce yürütülmesi imkansızdır.