Buộc GCC sử dụng tiền tố lặp lại trong memset() gọi

Question

Tôi đang phát triển một ứng dụng có hiệu suất rất quan trọng. Tôi muốn GCC dịch một số lời gọi cụ thể đến memset() như một lệnh với một tiền tố lặp lại như "rep stos QWORD PTR es: [rdi], rax". GCC thực hiện điều này tự động khi kích thước vừa được biết và nhỏ. Tuy nhiên, GCC ánh xạ các cuộc gọi đến memset() với độ dài ngẫu nhiên thông qua một lời gọi đến memset() thông qua PLT, điều này gây ra sự hiểu sai chi nhánh vì bộ nhớ cache dự đoán nhánh là lạnh.

Có cách nào để buộc GCC phải làm những gì tôi muốn (ngoài lắp ráp nội tuyến) không? Lưu ý rằng tôi không muốn hành vi này cho toàn bộ chương trình, chỉ cho một số cuộc gọi memset cụ thể().

Trên một chủ đề liên quan, tôi cũng quan tâm đến bất cứ hack mà ngăn GCC từ nhánh khi một hướng dẫn cmovcc sẽ thực hiện công việc (Tôi biết về việc sử dụng &, +, vv. Thay vì & &).

Cảm ơn bạn rất nhiều vì đã giúp đỡ.

@FrankH:

Đó là cơ bản những gì tôi đã kết thúc làm. Đây là mã của tôi:

static finline void app_zero(void *dst, uint32_t size, uint32_t count) 
{ 
    // Warning: we tell gcc to use 'dst' both as source and destination here. 
    // This does not cause problems because we don't reuse 'dst'. 
    #ifdef APP_ARCH_X86 
    #define STOS(X,Y) do { \ 
     int c = (size/Y)*count; \ 
     __asm__ __volatile__("cld; xor %%eax, %%eax; rep stos"X"\n\n" \ 
          : "+D"(dst), "+c"(c) :: "rax", "flags"); \ 
     } while (0) 
    if (size % 8 == 0)  STOS("q", 8); 
    else if (size % 4 == 0) STOS("l", 4); 
    else if (size % 2 == 0) STOS("w", 2); 
    else     STOS("b", 1); 
    #undef STOS 
    #else 
    memset(dst, 0, size*count); 
    #endif 
} 

Lưu ý rằng ví dụ của bạn hoạt động trong thiết lập thử nghiệm của bạn, nhưng nó sẽ không làm việc thường. GCC có thể thay đổi cờ hướng, do đó, hướng dẫn cld là cần thiết. Hơn nữa, bạn phải nói với gcc rằng %rdi và %rcx sẽ thay đổi bằng cách hướng dẫn stos, và vì gcc sẽ không cho phép bạn xác định rằng một thanh ghi là cả một đầu vào và clobbered, bạn phải sử dụng vụng "+" cú pháp (mà cũng sẽ làm hỏng giá trị đầu vào của bạn).

Điều này không tối ưu do lệnh 'cld', có độ trễ là 4 chu kỳ trên Nehalem. GCC theo dõi trạng thái đăng ký cờ nội bộ (AFAICT) vì vậy nó không cần phải ban hành lệnh đó mỗi lần.

Answer 1

Tôi không biết về GCC, nhưng theo bản xây dựng mới hơn của MSVC, sử dụng vòng lặp để thực hiện cài đặt/sao chép buộc sử dụng REP STOS (và nó vẫn cho phép tối ưu hóa cho biết kích cỡ và tự động vector) làm việc thử theo GCC.

thay thế để kiểm tra xem GCC có được xây dựng trong tương tự như __stosq, nếu không bạn có thể sẽ cần phải đi xuống để nội tuyến lắp ráp, nhưng thats không xấu cả thuộc GCC (và có lẽ là cách đơn giản nhất và nhanh nhất của nó).

câu hỏi thứ hai của bạn là cách để chung để thực sự có được một câu trả lời tốt, vì nó phụ thuộc vào trường hợp trong tầm tay, tuy nhiên, GCC nên làm cũng đủ trong việc tối ưu hóa ra chi nhánh trừ trường hợp góc cụ thể (sử dụng SETCC/MOVCC/FMOVCC).

Answer 2

Nếu bạn muốn ép buộc điều này, tại sao loại trừ lắp ráp nội tuyến làm tùy chọn?

#define my_forced_inline_memset(dst, c, N) \ 
    __asm__ __volatile__(     \ 
     "rep stosq %%rax, (%%rdi)\n\t" 
     : : "D"((dst)), "a"((c)), "c"((N)) : "memory"); 

Sử dụng này trong một chương trình giới thiệu như:

int main(int argc, char **argv) 
{ 
    my_forced_inline_memset(argv[0], 0, argc); 
    return 0; 
} 

tạo tôi lắp ráp này:

00000000004004b0 <main>: 
    4004b0:  89 f9     mov %edi,%ecx 
    4004b2:  31 c0     xor %eax,%eax 
    4004b4:  48 8b 3e    mov (%rsi),%rdi 
    4004b7:  f3 ab     repz stos %rax,%es:(%rdi) 
    4004b9:  c3      retq 

Đó không phải là một lời giải thích lý do tại sao GCC chọn để làm khác nhau, nhưng như đã nói nếu bạn muốn ép buộc hành vi mà bạn có thể, và nếu bạn biết rõ (các) địa điểm mà bạn cần điều này thì có một chút sai lầm khi gọi một số loại bộ nhớ được xác định đặc biệt của riêng bạn?

Lưu ý:repz stos %rax,(%rdi) (hoặc Intel cú pháp QWORD PTR equiv) là không giống như memset() vì granularity cho memset() là một byte duy nhất. Ở trên là khá giống như memset(..., c, N * 8) vì lý do đó. Giữ nó trong tâm trí.

Edit: Nếu bạn viết mã như:

#include <stdint.h>      // for uintptr_t 
#define my_forced_inline_memset(dst, c, N)       \ 
    __asm__ __volatile__(            \ 
     "rep stos %1, (%0)\n\t"          \ 
     :: "D"((dst)), "a"((uintptr_t)(c)), "c"((N)/sizeof(uintptr_t)) \ 
     : "memory"); 

nó biên dịch cho cả 32bit và 64bit.