จะดีกว่าถ้าใช้ std :: memcpy () หรือ std :: copy () ในแง่ของประสิทธิภาพ?

จะดีกว่าที่จะใช้memcpyตามที่แสดงด้านล่างหรือดีกว่าที่จะใช้std::copy()ในแง่ของประสิทธิภาพ? ทำไม?

char *bits = NULL;
...

bits = new (std::nothrow) char[((int *) copyMe->bits)[0]];
if (bits == NULL)
{
    cout << "ERROR Not enough memory.\n";
    exit(1);
}

memcpy (bits, copyMe->bits, ((int *) copyMe->bits)[0]);

ฉันจะต่อต้านภูมิปัญญาทั่วไปที่นี่ซึ่งstd::copyจะมีการสูญเสียประสิทธิภาพเล็กน้อยที่มองไม่เห็น ฉันเพิ่งทดสอบและพบว่าไม่เป็นความจริง: ฉันสังเกตเห็นความแตกต่างด้านประสิทธิภาพ อย่างไรก็ตามผู้ชนะคือstd::copyอย่างไรก็ตามผู้ชนะคือ

ฉันเขียนการใช้ C ++ SHA-2 ในการทดสอบของฉันฉันแฮช 5 สายโดยใช้ SHA-2 ทั้งสี่รุ่น (224, 256, 384, 512) และฉันวนซ้ำ 300 ครั้ง ฉันวัดเวลาโดยใช้ Boost.timer ตัวนับ 300 วนนั้นเพียงพอที่จะทำให้ผลลัพธ์ของฉันคงที่อย่างสมบูรณ์ ฉันรันการทดสอบ 5 ครั้งแต่ละครั้งสลับกันระหว่างmemcpyรุ่นกับstd::copyรุ่น รหัสของฉันใช้ประโยชน์จากการจับข้อมูลในกลุ่มก้อนใหญ่ที่สุดเท่าที่จะเป็นไปได้ (การใช้งานอื่น ๆ จำนวนมากทำงานด้วยchar/ char *ในขณะที่ฉันทำงานด้วยT/ T *(ซึ่งTเป็นประเภทที่ใหญ่ที่สุดในการใช้งานของผู้ใช้ที่มีพฤติกรรมล้น) ประเภทที่ใหญ่ที่สุดที่ฉันสามารถเป็นศูนย์กลางของประสิทธิภาพของอัลกอริทึมของฉันเหล่านี้คือผลลัพธ์ของฉัน:

เวลา (เป็นวินาที) เพื่อให้การทดสอบ SHA-2 เสร็จสมบูรณ์

std::copy   memcpy  % increase
6.11        6.29    2.86%
6.09        6.28    3.03%
6.10        6.29    3.02%
6.08        6.27    3.03%
6.08        6.27    3.03%

ความเร็วเฉลี่ยที่เพิ่มขึ้นโดยเฉลี่ยของ std :: copy over memcpy: 2.99%

คอมไพเลอร์ของฉันคือ gcc 4.6.3 ใน Fedora 16 x86_64 -Ofast -march=native -funsafe-loop-optimizationsธงเพิ่มประสิทธิภาพของฉัน

รหัสสำหรับการใช้งาน SHA-2 ของฉัน

ฉันตัดสินใจทำการทดสอบการใช้งาน MD5 ของฉันเช่นกัน ผลลัพธ์มีความเสถียรน้อยลงมากฉันเลยตัดสินใจวิ่ง 10 ครั้ง อย่างไรก็ตามหลังจากความพยายามครั้งแรกของฉันฉันได้รับผลลัพธ์ที่แตกต่างกันอย่างมากจากการวิ่งครั้งต่อไปดังนั้นฉันคาดว่าจะมีกิจกรรม OS บางประเภทเกิดขึ้น ฉันตัดสินใจที่จะเริ่มต้นใหม่

การตั้งค่าคอมไพเลอร์และแฟล็กเดียวกัน มี MD5 เพียงเวอร์ชันเดียวเท่านั้นและเร็วกว่า SHA-2 ดังนั้นฉันจึงทดสอบ 3000 ลูปในชุดทดสอบ 5 ชุดที่คล้ายกัน

นี่คือผลลัพธ์ 10 ข้อสุดท้ายของฉัน:

เวลา (เป็นวินาที) เพื่อให้การทดสอบ MD5 เสร็จสมบูรณ์

std::copy   memcpy      % difference
5.52        5.56        +0.72%
5.56        5.55        -0.18%
5.57        5.53        -0.72%
5.57        5.52        -0.91%
5.56        5.57        +0.18%
5.56        5.57        +0.18%
5.56        5.53        -0.54%
5.53        5.57        +0.72%
5.59        5.57        -0.36%
5.57        5.56        -0.18%

ความเร็วเฉลี่ยลดลงโดยเฉลี่ยของ std :: copy over memcpy: 0.11%

รหัสสำหรับการนำ MD5 ไปใช้

ผลลัพธ์เหล่านี้แนะนำว่ามีการเพิ่มประสิทธิภาพบางอย่างที่ std :: copy ใช้ในการทดสอบ SHA-2 ของฉันที่std::copyไม่สามารถใช้ในการทดสอบ MD5 ของฉันได้ ในการทดสอบ SHA-2 อาร์เรย์ทั้งสองถูกสร้างขึ้นในฟังก์ชั่นเดียวกับที่เรียกว่าstd::copy/memcpy /ในการทดสอบ MD5 ของฉันหนึ่งในอาร์เรย์ถูกส่งผ่านไปยังฟังก์ชั่นเป็นพารามิเตอร์ฟังก์ชั่น

ฉันทำการทดสอบอีกเล็กน้อยเพื่อดูว่าฉันสามารถทำอะไรได้บ้างเพื่อทำให้std::copyเร็วขึ้นอีกครั้ง คำตอบกลายเป็นเรื่องง่าย: เปิดการเพิ่มประสิทธิภาพเวลาลิงค์ นี่คือผลลัพธ์ของฉันเมื่อเปิดใช้งาน LTO (ตัวเลือก -flto เป็น gcc):

เวลา (เป็นวินาที) เพื่อให้การทดสอบ MD5 เสร็จสมบูรณ์ด้วย -flto

std::copy   memcpy      % difference
5.54        5.57        +0.54%
5.50        5.53        +0.54%
5.54        5.58        +0.72%
5.50        5.57        +1.26%
5.54        5.58        +0.72%
5.54        5.57        +0.54%
5.54        5.56        +0.36%
5.54        5.58        +0.72%
5.51        5.58        +1.25%
5.54        5.57        +0.54%

การเพิ่มความเร็วเฉลี่ยโดยเฉลี่ยของ std :: คัดลอกไปที่ memcpy: 0.72%

std::copyโดยสรุปมีไม่ปรากฏเป็นโทษประสิทธิภาพสำหรับการใช้ ในความเป็นจริงดูเหมือนว่าจะมีประสิทธิภาพเพิ่มขึ้น

คำอธิบายของผลลัพธ์

เหตุใดจึงอาจstd::copyเพิ่มประสิทธิภาพ

ครั้งแรกฉันจะไม่คาดหวังว่ามันจะช้าลงสำหรับการดำเนินการใด ๆ ตราบใดที่การเพิ่มประสิทธิภาพของการเปิดอินไลน์ คอมไพเลอร์ทั้งหมดอินไลน์อย่างจริงจัง มันอาจเป็นการปรับให้เหมาะสมที่สำคัญที่สุดเพราะช่วยให้การปรับแต่งอื่น ๆ มีประสิทธิภาพมากขึ้น std::copyสามารถ (และฉันสงสัยว่าการใช้งานจริงทั้งหมดทำ) ตรวจพบว่าข้อโต้แย้งนั้นสามารถคัดลอกได้เล็กน้อยและหน่วยความจำนั้นเรียงตามลำดับ ซึ่งหมายความว่าในกรณีที่เลวร้ายที่สุดเมื่อmemcpyถูกกฎหมายstd::copyควรดำเนินการไม่เลว การใช้งานเล็กน้อยของstd::copydefers ที่memcpyควรเป็นไปตามเกณฑ์ของคอมไพเลอร์ของคุณ "เสมอแบบอินไลน์นี้เมื่อเพิ่มประสิทธิภาพสำหรับความเร็วหรือขนาด"

อย่างไรก็ตามstd::copyยังเก็บข้อมูลได้มากขึ้น เมื่อคุณโทรstd::copyฟังก์ชั่นจะรักษาประเภทไว้เหมือนเดิม memcpyทำงานในvoid *ซึ่งจะทิ้งข้อมูลที่เป็นประโยชน์เกือบทั้งหมด ตัวอย่างเช่นถ้าฉันส่งผ่านอาร์เรย์std::uint64_tผู้รวบรวมหรือไลบรารี implementer อาจจะสามารถใช้ประโยชน์จากการจัดตำแหน่ง 64 บิตด้วยstd::copyแต่มันอาจเป็นเรื่องยากที่จะทำเช่นmemcpyนั้น การใช้อัลกอริธึมหลายอย่างเช่นงานนี้โดยการทำงานครั้งแรกในส่วนที่ไม่มีการจัดแนวที่จุดเริ่มต้นของช่วงจากนั้นส่วนที่จัดชิดแล้วส่วนที่ไม่ได้จัดแนวในตอนท้าย หากมีการรับประกันว่าจะจัดแนวทั้งหมดรหัสนั้นจะง่ายขึ้นและเร็วขึ้นและง่ายขึ้นสำหรับตัวพยากรณ์สาขาในโปรเซสเซอร์ของคุณเพื่อให้ถูกต้อง

การเพิ่มประสิทธิภาพก่อนวัย?

std::copyอยู่ในตำแหน่งที่น่าสนใจ ฉันคาดหวังว่ามันจะไม่ช้ากว่าmemcpyและบางครั้งก็เร็วขึ้นด้วยคอมไพเลอร์การเพิ่มประสิทธิภาพที่ทันสมัย นอกจากนี้สิ่งที่คุณสามารถคุณสามารถmemcpy ไม่อนุญาตให้มีการทับซ้อนกันในบัฟเฟอร์ในขณะที่รองรับการทับซ้อนในทิศทางเดียว ( สำหรับทิศทางอื่นของการทับซ้อน) ทำงานเฉพาะในตัวชี้ทำงานบน iterators ใด ๆ ( , , หรือประเภทที่กำหนดเองของตัวเอง) กล่าวอีกนัยหนึ่งคุณควรใช้เมื่อคุณต้องการคัดลอกข้อมูลจำนวนหนึ่งstd::copymemcpystd::copystd::copy_backwardmemcpystd::copystd::mapstd::vectorstd::dequestd::copy

คอมไพเลอร์ทั้งหมดที่ฉันรู้จักจะแทนที่วิstd::copyด้วยตัวอักษร a memcpyเมื่อมันเหมาะสมหรือดีกว่าทำให้ vectorize การคัดลอกเพื่อที่จะเร็วกว่าmemcpyคัดลอกเพื่อที่มันจะได้เร็วกว่า

ไม่ว่าในกรณีใด: โปรไฟล์และค้นหาด้วยตัวคุณเอง คอมไพเลอร์ต่าง ๆ จะทำสิ่งที่แตกต่างและเป็นไปได้มากที่มันจะไม่ทำสิ่งที่คุณถาม

ดู การนำเสนอนี้เกี่ยวกับการเพิ่มประสิทธิภาพของคอมไพเลอร์ (pdf)

นี่คือสิ่งที่ GCC ทำเพื่อง่ายๆstd::copyประเภท POD อย่างง่าย

#include <algorithm>

struct foo
{
  int x, y;    
};

void bar(foo* a, foo* b, size_t n)
{
  std::copy(a, a + n, b);
}

นี่คือการถอดแยกชิ้นส่วน (ที่มี-Oการปรับให้เหมาะสมเท่านั้น) โดยแสดงการเรียกไปที่memmove:

bar(foo*, foo*, unsigned long):
    salq    $3, %rdx
    sarq    $3, %rdx
    testq   %rdx, %rdx
    je  .L5
    subq    $8, %rsp
    movq    %rsi, %rax
    salq    $3, %rdx
    movq    %rdi, %rsi
    movq    %rax, %rdi
    call    memmove
    addq    $8, %rsp
.L5:
    rep
    ret

หากคุณเปลี่ยนฟังก์ชั่นลายเซ็นเป็น

void bar(foo* __restrict a, foo* __restrict b, size_t n)

จากนั้นmemmoveกลายเป็น a memcpyสำหรับการปรับปรุงประสิทธิภาพเล็กน้อย โปรดทราบว่าmemcpyตัวเองจะถูก vectorised อย่างหนัก

ใช้เสมอstd::copyเนื่องจากmemcpyถูก จำกัด เฉพาะโครงสร้าง POD แบบ C เท่านั้นและคอมไพเลอร์อาจแทนที่การโทรstd::copyด้วยmemcpyหากเป้าหมายเป็น POD จริง

นอกจากนี้std::copyยังสามารถใช้กับตัววนซ้ำหลายประเภทไม่เพียงแค่พอยน์เตอร์ std::copyมีความยืดหยุ่นมากขึ้นสำหรับการไม่สูญเสียประสิทธิภาพและเป็นผู้ชนะที่ชัดเจน

ในทางทฤษฎีmemcpyอาจจะมีเล็กน้อย , มองไม่เห็น , เล็กstd::copyได้เปรียบประสิทธิภาพเพียงเพราะมันไม่ได้มีความต้องการเช่นเดียวกับ จากหน้าคนของmemcpy:

เพื่อหลีกเลี่ยงการล้นขนาดของอาร์เรย์ที่ชี้โดยพารามิเตอร์ปลายทางและแหล่งที่มาจะต้องมีอย่างน้อย num ไบต์และไม่ควรทับซ้อนกัน (สำหรับบล็อกหน่วยความจำที่ทับซ้อนกัน memmove เป็นวิธีที่ปลอดภัยกว่า)

ในคำอื่น ๆmemcpyสามารถละเว้นความเป็นไปได้ของข้อมูลที่ทับซ้อนกัน (การผ่านอาร์เรย์ที่ทับซ้อนกันไปmemcpyเป็นพฤติกรรมที่ไม่ได้กำหนด) ดังนั้นmemcpyไม่จำเป็นต้องตรวจสอบเงื่อนไขนี้อย่างชัดเจนในขณะที่std::copyสามารถใช้งานได้ตราบใดที่OutputIteratorพารามิเตอร์ไม่ได้อยู่ในช่วงแหล่งที่มา โปรดทราบว่านี่ไม่เหมือนกับการบอกว่าช่วงต้นทางและช่วงปลายทางไม่สามารถทับซ้อนกันได้

ดังนั้นเนื่องจากstd::copyมีข้อกำหนดที่แตกต่างกันบ้างในทางทฤษฎีมันควรจะช้ากว่าเล็กน้อย (โดยเน้นที่สุด ๆไปเล็กน้อย ) เนื่องจากมันอาจจะตรวจสอบ C-arrays ที่ทับซ้อนกันmemmoveที่ต้องการที่จะดำเนินการ ตรวจสอบ แต่ในทางปฏิบัติคุณ (และโปรไฟล์ส่วนใหญ่) อาจไม่ได้ตรวจพบความแตกต่าง

แน่นอนถ้าคุณไม่ได้ทำงานกับPODคุณก็ไม่สามารถใช้งานmemcpyได้

กฎของฉันเรียบง่าย หากคุณใช้ C ++ ชอบไลบรารี่ C ++ ไม่ใช่ C :)

เพียงเล็กน้อยเพิ่มเติม: ความแตกต่างความเร็วระหว่างmemcpy()และstd::copy()สามารถแตกต่างกันเล็กน้อยขึ้นอยู่กับว่าการเพิ่มประสิทธิภาพจะเปิดใช้งานหรือปิดการใช้งาน ด้วย g ++ 6.2.0 และไม่มีการปรับแต่งให้memcpy()ชนะอย่างชัดเจน:

Benchmark             Time           CPU Iterations
---------------------------------------------------
bm_memcpy            17 ns         17 ns   40867738
bm_stdcopy           62 ns         62 ns   11176219
bm_stdcopy_n         72 ns         72 ns    9481749

เมื่อเปิดใช้งานการปรับให้เหมาะสม ( -O3) ทุกอย่างจะดูเหมือนกันอีกครั้ง:

Benchmark             Time           CPU Iterations
---------------------------------------------------
bm_memcpy             3 ns          3 ns  274527617
bm_stdcopy            3 ns          3 ns  272663990
bm_stdcopy_n          3 ns          3 ns  274732792

อาร์เรย์ยิ่งใหญ่ขึ้นเอฟเฟกต์ที่สังเกตเห็นได้ก็จะน้อยลง แต่ถึงแม้N=1000 memcpy()จะเร็วกว่าถึงสองเท่าเมื่อเปิดใช้งานการปรับให้เหมาะสม

ซอร์สโค้ด (ต้องใช้ Google Benchmark):

#include <string.h>
#include <algorithm>
#include <vector>
#include <benchmark/benchmark.h>

constexpr int N = 10;

void bm_memcpy(benchmark::State& state)
{
  std::vector<int> a(N);
  std::vector<int> r(N);

  while (state.KeepRunning())
  {
    memcpy(r.data(), a.data(), N * sizeof(int));
  }
}

void bm_stdcopy(benchmark::State& state)
{
  std::vector<int> a(N);
  std::vector<int> r(N);

  while (state.KeepRunning())
  {
    std::copy(a.begin(), a.end(), r.begin());
  }
}

void bm_stdcopy_n(benchmark::State& state)
{
  std::vector<int> a(N);
  std::vector<int> r(N);

  while (state.KeepRunning())
  {
    std::copy_n(a.begin(), N, r.begin());
  }
}

BENCHMARK(bm_memcpy);
BENCHMARK(bm_stdcopy);
BENCHMARK(bm_stdcopy_n);

BENCHMARK_MAIN()

/* EOF */

หากคุณต้องการประสิทธิภาพการคัดลอกสูงสุดจริง ๆ (ซึ่งคุณอาจไม่ได้) ให้ใช้ทั้งสองอย่างอย่าง

มีจำนวนมากที่สามารถทำได้เพื่อเพิ่มประสิทธิภาพการคัดลอกหน่วยความจำ - ยิ่งถ้าคุณยินดีที่จะใช้หลายเธรด / แกนสำหรับมัน ดูตัวอย่าง:

มีอะไรหายไป / ย่อยที่ดีที่สุดในการใช้ memcpy นี้?

ทั้งคำถามและคำตอบบางข้อได้แนะนำการใช้งานหรือลิงค์ไปยังการใช้งาน

การทำโปรไฟล์แสดงให้เห็นว่าคำสั่ง: std::copy()รวดเร็วเสมอmemcpy()หรือเร็วกว่าเป็นเท็จ

ระบบของฉัน:

HP-Compaq-dx7500-Microtower 3.13.0-24-generic # 47-Ubuntu SMP ศุกร์ 2 พฤษภาคม 23:30:00 UTC 2014 x86_64 x86_64 x86_64 GNU / Linux

gcc (Ubuntu 4.8.2-19ubuntu1) 4.8.2

รหัส (ภาษา: c ++):

    const uint32_t arr_size = (1080 * 720 * 3); //HD image in rgb24
    const uint32_t iterations = 100000;
    uint8_t arr1[arr_size];
    uint8_t arr2[arr_size];
    std::vector<uint8_t> v;

    main(){
        {
            DPROFILE;
            memcpy(arr1, arr2, sizeof(arr1));
            printf("memcpy()\n");
        }

        v.reserve(sizeof(arr1));
        {
            DPROFILE;
            std::copy(arr1, arr1 + sizeof(arr1), v.begin());
            printf("std::copy()\n");
        }

        {
            time_t t = time(NULL);
            for(uint32_t i = 0; i < iterations; ++i)
                memcpy(arr1, arr2, sizeof(arr1));
            printf("memcpy()    elapsed %d s\n", time(NULL) - t);
        }

        {
            time_t t = time(NULL);
            for(uint32_t i = 0; i < iterations; ++i)
                std::copy(arr1, arr1 + sizeof(arr1), v.begin());
            printf("std::copy() elapsed %d s\n", time(NULL) - t);
        }
    }

g ++ -O0 -o test_stdcopy test_stdcopy.cpp

รายละเอียด memcpy (): main: 21: ตอนนี้: 1422969084: 04859 ที่ผ่านไป: 2650 us
std :: คัดลอก () โปรไฟล์: main: 27: ตอนนี้: 1422969084: 04862 ที่ผ่านไป: 2745 us
memcpy () el 44 44 std :: คัดลอก () ) ผ่านไป 45 วินาที

g ++ -O3 -o test_stdcopy test_stdcopy.cpp

โปรไฟล์ memcpy (): main: 21: ตอนนี้: 1422969601: 04939 ที่ผ่านไป: 2385 us
std :: copy () โปรไฟล์: main: 28: ตอนนี้: 1422969601: 04941 ที่ผ่านไป: 2690 us
memcpy () elapsed 27 s std :: คัดลอก () ) ผ่านไป 43 วินาที

Red Alert ชี้ให้เห็นว่ารหัสใช้ memcpy จาก array ไปยัง array และ std :: copy จาก array ไปยัง vector นั่นเป็นเหตุผลที่ทำให้ memcpy เร็วขึ้น

เนื่องจากมี

v.reserve (sizeof (arr1));

จะไม่มีความแตกต่างในการคัดลอกไปยังเวกเตอร์หรืออาร์เรย์

รหัสได้รับการแก้ไขเพื่อใช้อาร์เรย์สำหรับทั้งสองกรณี memcpy ยังเร็วกว่า:

{
    time_t t = time(NULL);
    for(uint32_t i = 0; i < iterations; ++i)
        memcpy(arr1, arr2, sizeof(arr1));
    printf("memcpy()    elapsed %ld s\n", time(NULL) - t);
}

{
    time_t t = time(NULL);
    for(uint32_t i = 0; i < iterations; ++i)
        std::copy(arr1, arr1 + sizeof(arr1), arr2);
    printf("std::copy() elapsed %ld s\n", time(NULL) - t);
}

memcpy()    elapsed 44 s
std::copy() elapsed 48 s