Tại sao memcpy () và memmove () nhanh hơn số tăng con trỏ?

Tôi đang sao chép N byte từ pSrcsang pDest. Điều này có thể được thực hiện trong một vòng lặp:

for (int i = 0; i < N; i++)
    *pDest++ = *pSrc++

Tại sao điều này lại chậm hơn memcpyhoặc memmove? Những thủ thuật nào họ sử dụng để tăng tốc độ?

Bởi vì memcpy sử dụng con trỏ từ thay vì con trỏ byte, cũng như việc triển khai memcpy thường được viết với các lệnh SIMD để có thể xáo trộn 128 bit cùng một lúc.

Các lệnh SIMD là các lệnh lắp ráp có thể thực hiện cùng một thao tác trên mỗi phần tử trong một vectơ dài tối đa 16 byte. Điều đó bao gồm hướng dẫn tải và lưu trữ.

Quy trình sao chép bộ nhớ có thể phức tạp hơn và nhanh hơn nhiều so với việc sao chép bộ nhớ đơn giản thông qua các con trỏ như:

void simple_memory_copy(void* dst, void* src, unsigned int bytes)
{
  unsigned char* b_dst = (unsigned char*)dst;
  unsigned char* b_src = (unsigned char*)src;
  for (int i = 0; i < bytes; ++i)
    *b_dst++ = *b_src++;
}

Cải tiến

Cải tiến đầu tiên mà người ta có thể thực hiện là căn chỉnh một trong các con trỏ trên một ranh giới từ (tôi có nghĩa là kích thước số nguyên gốc, thường là 32 bit / 4 byte, nhưng có thể là 64 bit / 8 byte trên các kiến ​​trúc mới hơn) và sử dụng kích thước từ di chuyển / sao chép hướng dẫn. Điều này yêu cầu sử dụng bản sao byte sang byte cho đến khi con trỏ được căn chỉnh.

void aligned_memory_copy(void* dst, void* src, unsigned int bytes)
{
  unsigned char* b_dst = (unsigned char*)dst;
  unsigned char* b_src = (unsigned char*)src;

  // Copy bytes to align source pointer
  while ((b_src & 0x3) != 0)
  {
    *b_dst++ = *b_src++;
    bytes--;
  }

  unsigned int* w_dst = (unsigned int*)b_dst;
  unsigned int* w_src = (unsigned int*)b_src;
  while (bytes >= 4)
  {
    *w_dst++ = *w_src++;
    bytes -= 4;
  }

  // Copy trailing bytes
  if (bytes > 0)
  {
    b_dst = (unsigned char*)w_dst;
    b_src = (unsigned char*)w_src;
    while (bytes > 0)
    {
      *b_dst++ = *b_src++;
      bytes--;
    }
  }
}

Các kiến ​​trúc khác nhau sẽ hoạt động khác nhau dựa trên việc nguồn hoặc con trỏ đích có được căn chỉnh thích hợp hay không. Ví dụ: trên bộ xử lý XScale, tôi có hiệu suất tốt hơn bằng cách căn chỉnh con trỏ đích thay vì con trỏ nguồn.

Để cải thiện hơn nữa hiệu suất, một số thao tác giải nén vòng lặp có thể được thực hiện, để nhiều thanh ghi của bộ xử lý được tải dữ liệu hơn và điều đó có nghĩa là các lệnh tải / lưu trữ có thể được xen kẽ và ẩn độ trễ của chúng bằng các lệnh bổ sung (chẳng hạn như đếm vòng lặp, v.v.). Lợi ích mà điều này mang lại thay đổi khá nhiều bởi bộ xử lý, vì độ trễ của lệnh tải / lưu trữ có thể khá khác nhau.

Ở giai đoạn này, mã kết thúc được viết bằng Assembly thay vì C (hoặc C ++) vì bạn cần phải đặt các lệnh tải và lưu trữ theo cách thủ công để có được lợi ích tối đa của việc ẩn độ trễ và thông lượng.

Nói chung, toàn bộ dòng dữ liệu trong bộ nhớ cache nên được sao chép trong một lần lặp lại của vòng lặp chưa được cuộn.

Điều này đưa tôi đến cải tiến tiếp theo, thêm tính năng tìm nạp trước. Đây là những lệnh đặc biệt yêu cầu hệ thống bộ nhớ đệm của bộ xử lý tải các phần cụ thể của bộ nhớ vào bộ nhớ đệm của nó. Vì có sự chậm trễ giữa việc đưa ra lệnh và điền vào dòng bộ đệm, nên các lệnh cần được đặt theo cách sao cho dữ liệu có sẵn ngay khi nó được sao chép và không sớm / muộn.

Điều này có nghĩa là đặt các hướng dẫn tìm nạp trước khi bắt đầu hàm cũng như bên trong vòng lặp sao chép chính. Với hướng dẫn tìm nạp trước ở giữa vòng lặp sao chép, dữ liệu sẽ được sao chép trong nhiều lần lặp lại.

Tôi không thể nhớ, nhưng cũng có thể có lợi khi tìm nạp trước địa chỉ đích cũng như địa chỉ nguồn.

Các nhân tố

Các yếu tố chính ảnh hưởng đến tốc độ sao chép của bộ nhớ là:

• Độ trễ giữa bộ xử lý, bộ nhớ đệm và bộ nhớ chính.
• Kích thước và cấu trúc của các dòng bộ nhớ đệm của bộ xử lý.
• Hướng dẫn sao chép / di chuyển bộ nhớ của bộ xử lý (độ trễ, thông lượng, kích thước thanh ghi, v.v.).

Vì vậy, nếu bạn muốn viết một quy trình xử lý bộ nhớ hiệu quả và nhanh chóng, bạn sẽ cần phải biết khá nhiều về bộ xử lý và kiến ​​trúc mà bạn đang viết. Chỉ cần nói rằng, trừ khi bạn đang viết trên một nền tảng nhúng nào đó sẽ dễ dàng hơn nhiều nếu chỉ sử dụng các quy trình sao chép bộ nhớ được tích hợp sẵn.

memcpycó thể sao chép nhiều hơn một byte cùng một lúc tùy thuộc vào kiến ​​trúc của máy tính. Hầu hết các máy tính hiện đại có thể hoạt động với 32 bit hoặc hơn trong một lệnh xử lý đơn lẻ.

Từ một ví dụ triển khai :

    00026 * Để sao chép nhanh chóng, hãy tối ưu hóa trường hợp phổ biến trong đó cả hai con trỏ
    00027 * và độ dài được căn chỉnh theo từ và thay vào đó hãy sao chép từng từ một
    00028 * byte-at-a-time. Nếu không, hãy sao chép theo byte.

Bạn có thể triển khai memcpy()bằng bất kỳ kỹ thuật nào sau đây, một số kỹ thuật phụ thuộc vào kiến ​​trúc của bạn để tăng hiệu suất và tất cả chúng sẽ nhanh hơn nhiều so với mã của bạn:

1. Sử dụng các đơn vị lớn hơn, chẳng hạn như các từ 32 bit thay vì byte. Bạn cũng có thể (hoặc có thể phải) đối phó với sự liên kết ở đây. Bạn không thể đọc / ghi một từ 32-bit vào một vị trí bộ nhớ kỳ lạ, ví dụ như trên một số nền tảng và trên các nền tảng khác, bạn phải trả một khoản phạt hiệu suất lớn. Để khắc phục điều này, địa chỉ phải là đơn vị chia hết cho 4. Bạn có thể sử dụng tối đa 64 bit cho CPU 64 bit hoặc thậm chí cao hơn bằng cách sử dụng lệnh SIMD ( Lệnh đơn, nhiều dữ liệu) ( MMX , SSE , v.v.)

2. Bạn có thể sử dụng các lệnh CPU đặc biệt mà trình biên dịch của bạn có thể không tối ưu hóa được từ C. Ví dụ: trên 80386, bạn có thể sử dụng lệnh tiền tố "rep" + lệnh "movsb" để di chuyển N byte được chỉ định bằng cách đặt N vào số Đăng ký. Trình biên dịch tốt sẽ chỉ làm điều này cho bạn, nhưng bạn có thể đang ở trên một nền tảng thiếu trình biên dịch tốt. Lưu ý, ví dụ đó có xu hướng là một minh chứng xấu về tốc độ, nhưng kết hợp với căn chỉnh + hướng dẫn đơn vị lớn hơn, nó có thể nhanh hơn hầu hết mọi thứ khác trên một số CPU nhất định.

3. Bỏ cuộn vòng lặp - các nhánh có thể khá tốn kém trên một số CPU, vì vậy việc hủy cuộn các vòng có thể làm giảm số nhánh. Đây cũng là một kỹ thuật tốt để kết hợp với các lệnh SIMD và các đơn vị có kích thước rất lớn.

Ví dụ: http://www.agner.org/optimize/#asmlib có một memcpytriển khai hoạt động hiệu quả nhất (một lượng rất nhỏ). Nếu bạn đọc mã nguồn, nó sẽ có rất nhiều mã lắp ráp nội tuyến rút ra tất cả ba kỹ thuật trên, chọn kỹ thuật nào trong số những kỹ thuật đó dựa trên CPU bạn đang chạy.

Lưu ý, có những tối ưu hóa tương tự cũng có thể được thực hiện để tìm các byte trong bộ đệm. strchr()và bạn bè thường sẽ nhanh hơn tay bạn cuộn tương đương. Điều này đặc biệt đúng với .NET và Java . Ví dụ, trong .NET, tích hợp sẵn String.IndexOf()nhanh hơn nhiều so với tìm kiếm chuỗi Boyer – Moore , bởi vì nó sử dụng các kỹ thuật tối ưu hóa ở trên.

Câu trả lời ngắn:

• lấp đầy bộ nhớ cache
• chuyển kích thước từ thay vì chuyển byte nếu có thể
• Phép thuật SIMD

Tôi không biết liệu nó có thực sự được sử dụng trong bất kỳ triển khai thế giới thực nào hay không memcpy, nhưng tôi nghĩ Thiết bị của Duff xứng đáng được đề cập ở đây.

Từ Wikipedia :

send(to, from, count)
register short *to, *from;
register count;
{
        register n = (count + 7) / 8;
        switch(count % 8) {
        case 0:      do {     *to = *from++;
        case 7:              *to = *from++;
        case 6:              *to = *from++;
        case 5:              *to = *from++;
        case 4:              *to = *from++;
        case 3:              *to = *from++;
        case 2:              *to = *from++;
        case 1:              *to = *from++;
                } while(--n > 0);
        }
}

Lưu ý rằng điều trên không phải là memcpyvì nó cố tình không tăng tocon trỏ. Nó thực hiện một hoạt động hơi khác: ghi vào một thanh ghi ánh xạ bộ nhớ. Xem bài viết trên Wikipedia để biết chi tiết.

Giống như những người khác nói các bản sao memcpy lớn hơn các khối 1 byte. Sao chép trong các phần có kích thước từ nhanh hơn nhiều. Tuy nhiên, hầu hết các triển khai sẽ tiến thêm một bước nữa và chạy một số hướng dẫn MOV (từ) trước khi lặp lại. Lợi thế của việc sao chép nói, 8 khối từ trên mỗi vòng lặp là bản thân vòng lặp rất tốn kém. Kỹ thuật này làm giảm số lượng các nhánh có điều kiện theo hệ số 8, tối ưu hóa bản sao cho các khối khổng lồ.

Những câu trả lời là rất lớn, nhưng nếu bạn vẫn muốn thực hiện một nhanh memcpycho mình, có một bài viết trên blog thú vị về memcpy nhanh, memcpy nhanh trong C .

void *memcpy(void* dest, const void* src, size_t count)
{
    char* dst8 = (char*)dest;
    char* src8 = (char*)src;

    if (count & 1) {
        dst8[0] = src8[0];
        dst8 += 1;
        src8 += 1;
    }

    count /= 2;
    while (count--) {
        dst8[0] = src8[0];
        dst8[1] = src8[1];

        dst8 += 2;
        src8 += 2;
    }
    return dest;
}

Thậm chí, nó có thể tốt hơn với việc tối ưu hóa truy cập bộ nhớ.

Bởi vì giống như nhiều quy trình thư viện, nó đã được tối ưu hóa cho kiến ​​trúc bạn đang chạy. Những người khác đã đăng các kỹ thuật khác nhau có thể được sử dụng.

Với sự lựa chọn, hãy sử dụng các quy trình thư viện thay vì cuộn của riêng bạn. Đây là một biến thể của DRY mà tôi gọi là DRO (Không lặp lại người khác). Ngoài ra, các quy trình thư viện ít có khả năng bị sai hơn so với việc triển khai của chính bạn.

Tôi đã thấy những người kiểm tra truy cập bộ nhớ phàn nàn về việc đọc vượt quá giới hạn trên bộ nhớ đệm hoặc bộ đệm chuỗi không phải là bội số của kích thước từ. Đây là kết quả của việc tối ưu hóa đang được sử dụng.

Bạn có thể xem việc triển khai MacOS của memset, memcpy và memmove.

Tại thời điểm khởi động, hệ điều hành xác định bộ xử lý mà nó đang chạy. Nó đã tích hợp mã được tối ưu hóa đặc biệt cho từng bộ xử lý được hỗ trợ và tại thời điểm khởi động sẽ lưu trữ một lệnh jmp cho đúng mã ở một vị trí cố định chỉ đọc / chỉ.

Việc triển khai memset C, memcpy và memmove chỉ là một bước nhảy đến vị trí cố định đó.

Việc triển khai sử dụng mã khác nhau tùy thuộc vào sự liên kết của nguồn và đích cho memcpy và memmove. Rõ ràng là chúng sử dụng tất cả các khả năng vectơ có sẵn. Họ cũng sử dụng các biến thể không lưu vào bộ nhớ đệm khi bạn sao chép số lượng lớn dữ liệu và có hướng dẫn để giảm thiểu thời gian chờ đợi cho bảng trang. Nó không chỉ là mã của trình hợp dịch, mà là mã của trình hợp dịch được viết bởi một người có kiến ​​thức cực kỳ tốt về từng kiến ​​trúc bộ xử lý.

Intel cũng bổ sung các hướng dẫn trình hợp dịch có thể làm cho các hoạt động chuỗi nhanh hơn. Ví dụ với một lệnh để hỗ trợ strstr mà 256 byte so sánh trong một chu kỳ.