Sự khác biệt giữa rdtscp, rdtsc: bộ nhớ và cpuid/rdtsc?

Question

Giả sử chúng tôi đang cố gắng sử dụng tsc để giám sát hiệu suất và chúng tôi muốn ngăn chặn việc sắp xếp lại lệnh.

Đây là những lựa chọn của chúng tôi:

1:rdtscp là lời kêu gọi serializing. Nó ngăn cản sắp xếp lại xung quanh cuộc gọi đến rdtscp.

__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 

Tuy nhiên, rdtscp chỉ khả dụng trên các CPU mới hơn. Vì vậy, trong trường hợp này chúng ta phải sử dụng rdtsc. Nhưng rdtsc không được tuần tự hóa, vì vậy việc sử dụng nó một mình sẽ không ngăn CPU sắp xếp lại nó.

Vì vậy, chúng ta có thể sử dụng một trong hai tùy chọn này để ngăn chặn sắp xếp lại:

2: Đây là một lời kêu gọi cpuid và sau đó rdtsc. cpuid là một cuộc gọi nối tiếp.

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: Đây là một lời kêu gọi rdtsc với memory trong danh sách clobber, mà ngăn sắp xếp lại

__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 

hiểu biết của tôi cho các tùy chọn thứ 3 là như sau:

Lập hãy gọi __volatile__ ngăn trình tối ưu hóa loại bỏ asm hoặc di chuyển nó qua bất kỳ hướng dẫn nào có thể cần kết quả (hoặc thay đổi đầu vào) của asm. Tuy nhiên nó vẫn có thể di chuyển nó đối với các hoạt động không liên quan. Vì vậy, __volatile__ là không đủ.

Thông báo cho bộ nhớ trình biên dịch đang bị ghi đè: : "memory"). Các "memory" clobber có nghĩa là GCC không thể thực hiện bất kỳ giả định về nội dung bộ nhớ còn lại trên cùng một asm, và do đó sẽ không sắp xếp lại xung quanh nó.

Vì vậy, câu hỏi của tôi là:

• 1: Liệu sự hiểu biết của tôi về __volatile__ và "memory" có đúng không?
• 2: Thực hiện hai cuộc gọi thứ hai có thực hiện tương tự không?
• 3: Sử dụng "memory" trông đơn giản hơn nhiều so với sử dụng hướng dẫn tuần tự hóa khác. Tại sao mọi người sử dụng tùy chọn thứ 3 trong tùy chọn thứ 2?

Answer 1

Như đã đề cập trong một chú thích, có sự khác biệt giữa một rào cản biên dịch và một rào cản xử lý. volatile và memory trong tuyên bố asm hoạt động như một rào cản trình biên dịch, nhưng bộ xử lý vẫn miễn phí để sắp xếp lại hướng dẫn.

Rào cản bộ xử lý là các hướng dẫn đặc biệt phải được đưa ra một cách rõ ràng, ví dụ: rdtscp, cpuid, hướng dẫn về hàng rào bộ nhớ (mfence, lfence, ...) v.v.

Là một sang một bên, trong khi sử dụng cpuid như một rào cản trước rdtsc là phổ biến, nó cũng có thể rất xấu từ góc độ hiệu suất, vì các nền tảng máy ảo thường bẫy và bắt chước các hướng dẫn cpuid để áp đặt một tập phổ biến của CPU các tính năng trên nhiều máy trong một cụm (để đảm bảo rằng hoạt động di chuyển trực tiếp hoạt động). Vì vậy, tốt hơn nên sử dụng một trong các hướng dẫn hàng rào bộ nhớ.

Nhân Linux sử dụng mfence;rdtsc trên nền tảng AMD và lfence;rdtsc trên Intel. Nếu bạn không muốn bận tâm với việc phân biệt giữa chúng, mfence;rdtsc hoạt động trên cả hai mặc dù nó hơi chậm hơn khi mfence là một rào cản mạnh hơn lfence.

Answer 2

bạn có thể sử dụng nó như hình dưới đây:

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"); 

Trong đoạn mã trên, các cuộc gọi CPUID đầu tiên thực hiện một rào cản để tránh out-of-trật tự thực hiện các hướng dẫn ở trên và dưới sự hướng dẫn RDTSC. Với phương pháp này, chúng ta tránh gọi lệnh CPUID giữa các lần đọc của thanh ghi thời gian thực

RDTSC đầu tiên sau đó đọc thanh ghi dấu thời gian và giá trị được lưu trữ trong bộ nhớ . Sau đó, mã mà chúng tôi muốn đo được thực hiện. Lệnh RDTSCP đọc thanh ghi thời gian cho lần thứ hai và đảm bảo rằng việc thực hiện tất cả mã mà chúng tôi muốn đo được hoàn thành. Hai lệnh “mov” đến sau đó lưu trữ các giá trị đăng ký edx và eax vào bộ nhớ. Cuối cùng, một cuộc gọi CPUID đảm bảo rằng một rào chắn được thực hiện lại để không thể bất kỳ lệnh nào đến sau được thực thi trước chính CPUID.