Performans açısından std :: memcpy () veya std :: copy () kullanmak daha mı iyi?

memcpyAşağıda gösterildiği gibi kullanmak daha iyi mi yoksa std::copy()performans açısından kullanmak daha mı iyi ? Neden?

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

Burada, std::copyhafif, neredeyse algılanamayan bir performans kaybına sahip olacak genel bilgeliğe karşı çıkacağım. Sadece bir test yaptım ve yanlış olduğunu gördüm: Bir performans farkı fark ettim. Ancak kazanan oldu std::copy.

Bir C ++ SHA-2 uygulaması yazdım. Testimde, dört SHA-2 sürümünü (224, 256, 384, 512) kullanarak 5 dize hash alıyorum ve 300 kez döngü yapıyorum. Boost.timer kullanarak zamanı ölçüyorum. Bu 300 loop sayacı sonuçlarımı tamamen stabilize etmek için yeterli. Testi, memcpysürüm ve sürüm arasında dönüşümlü olarak 5 kez çalıştırdım std::copy. Kodum, verileri olabildiğince büyük yığınlardan yakalama avantajından yararlanır (diğer birçok uygulama char/ ile çalışır char *, oysa T/ ile çalışırım T *( Tkullanıcının uygulamasında doğru taşma davranışına sahip en büyük türdür), bu nedenle hızlı bellek erişimi yapabileceğim en büyük tipler algoritmamın performansında çok önemli.

SHA-2 testlerinin tamamlanma süresi (saniye olarak)

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%

Standart hızdaki ortalama ortalama artış :: memcpy üzerinden kopya:% 2.99

Derleyicim Fedora 16 x86_64 üzerinde gcc 4.6.3. Optimizasyon bayraklarım -Ofast -march=native -funsafe-loop-optimizations.

SHA-2 uygulamalarım için kod.

MD5 uygulamam üzerinde de bir test yapmaya karar verdim. Sonuçlar çok daha az kararlıydı, bu yüzden 10 koşu yapmaya karar verdim. Ancak, ilk birkaç denememden sonra, bir koşudan diğerine çılgınca değişen sonuçlar aldım, bu yüzden bir tür işletim sistemi faaliyeti olduğunu tahmin ediyorum. Başlamaya karar verdim.

Aynı derleyici ayarları ve bayrakları. MD5'in yalnızca bir sürümü var ve SHA-2'den daha hızlı, bu yüzden benzer 5 test dizisi üzerinde 3000 döngü yaptım.

Bunlar benim son 10 sonuç:

MD5 testlerinin tamamlanma süresi (saniye olarak)

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%

Standart hızdaki ortalama ortalama azalma :: memcpy üzerinden kopyalama:% 0.11

MD5 uygulamam için kod

Bu sonuçlar, std::copyMD5 testlerimde kullanamadığım SHA-2 testlerimde kullanılan std :: copy'ın bazı optimizasyonları olduğunu göstermektedir . SHA-2 testlerinde, her iki dizi std::copy/ adında aynı işlevle oluşturuldu memcpy. MD5 testlerimde dizilerden biri işleve bir işlev parametresi olarak iletildi.

std::copyTekrar hızlandırmak için neler yapabileceğimi görmek için biraz daha test yaptım . Yanıtın basit olduğu ortaya çıktı: bağlantı süresi optimizasyonunu açın. Bunlar LTO açıkken sonuçlarım (gcc'de -flto seçeneği):

-Flto ile MD5 testlerinin tamamlanma süresi (saniye olarak)

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%

Standart hızdaki ortalama ortalama artış :: Memcpy üzerinden kopyalama:% 0,72

Özetle, kullanım için bir performans cezası yok gibi görünüyor std::copy. Aslında, bir performans kazancı var gibi görünüyor.

Sonuçların açıklaması

Öyleyse neden std::copyperformans artışı sağlayabilir ?

İlk olarak, satır içi optimizasyon açık olduğu sürece herhangi bir uygulama için daha yavaş olmasını beklemezdim. Tüm derleyiciler agresif olarak satır içi; diğer birçok optimizasyonu mümkün kıldığı için muhtemelen en önemli optimizasyondur. std::copyargümanların önemsiz şekilde kopyalandığını ve belleğin sırayla düzenlendiğini tespit edebilir (ve tüm gerçek dünya uygulamalarından şüpheleniyorum). Bu, en kötü durumda, memcpyyasal olduğunda , std::copydaha kötü bir performans göstermemesi gerektiği anlamına gelir . Önemsiz uygulama std::copyolduğunu ertelemektedir için memcpy"her zaman satır içi bu hız veya boyut için optimize ederken" tutarındaki derleyici'nın kriterlerini karşılamalıdır.

Ancak, std::copydaha fazla bilgi tutar. Aradığınızda std::copy, işlev türleri sağlam tutar. memcpyçalışır void *hangi silip mevcut neredeyse tüm yararlı bilgiler. Örneğin, bir diziden std::uint64_tgeçersem, derleyici veya kütüphane uygulayıcısı 64 bit hizalamadan yararlanabilir std::copy, ancak bunu yapmak daha zor olabilir memcpy. Bunun gibi birçok algoritma uygulaması önce aralığın başında hizalanmamış kısım, daha sonra hizalanmış kısım, daha sonra sonda hizalanmamış kısım üzerinde çalışarak çalışır. Tümünün hizalanması garanti edilirse, kod daha basit ve daha hızlı hale gelir ve işlemcinizdeki dal öngörücüsünün doğru olması daha kolay hale gelir.

Erken optimizasyon?

std::copyilginç bir konumda. memcpyHerhangi bir modern optimizasyon derleyici ile asla daha yavaş ve bazen daha hızlı olmasını bekliyorum . Üstelik yapabildiğiniz her şeyi memcpyyapabilirsiniz std::copy. memcpytamponlarda herhangi bir üst üste binmeye izin vermezken, std::copydestekler bir yönde üst üste binmeyi destekler ( std::copy_backwarddiğer üst üste binme yönüyle birlikte). memcpyYalnızca, işaretçiler çalışır std::copyherhangi Yineleyicilerin çalışır ( std::map, std::vector, std::deque, veya kendi özel tip). Başka bir deyişle, sadece std::copyveri yığınlarını kopyalamanız gerektiğinde kullanmalısınız .

Bir basit yerini alacak bildiğim derleyiciler std::copybir ile memcpydaha da iyi uygun ya olduğunda, bu yüzden daha hızlı bir daha olacağını kopya vektörize memcpy.

Her durumda: profil oluşturun ve kendinizi bulun. Farklı derleyiciler farklı şeyler yaparlar ve tam olarak ne istersen yapmazlar.

Derleyici optimizasyonları hakkındaki bu sunuma bakınız (pdf).

İşte PCC'nin basit std::copybir POD tipi için yaptığı şey .

#include <algorithm>

struct foo
{
  int x, y;    
};

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

İşte -Oçağrıyı gösteren sökme (sadece optimizasyon ile) 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

İşlev imzasını

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

sonra hafif bir performans artışı için bir memmoveolur memcpy. O Not memcpykendisi ağır vektörleştirilmiş edilecektir.

Daima kullanmak std::copyçünkü memcpysadece C tarzı POD yapılara sınırlıdır ve derleyici olasılıkla çağrı yerini alacak std::copyolan memcpyhedefler aslında POD ise.

Ayrıca, std::copyyalnızca işaretçilerle değil, birçok yineleyici türüyle kullanılabilir. std::copyhiçbir performans kaybı olmadan daha esnektir ve açık kazanır.

Teoride, ancak aynı gerekliliklere sahip olmadığı memcpyiçin hafif , algılanamayan , sonsuz bir performans avantajına sahip olabilir std::copy. Man sayfasından memcpy:

Taşmaları önlemek için, hem hedef hem de kaynak parametreleri tarafından işaretlenen dizilerin boyutu en az sayı bayt olmalı ve üst üste binmemelidir (çakışan bellek blokları için, memmove daha güvenli bir yaklaşımdır).

Başka bir deyişle, memcpyverilerin çakışması olasılığını göz ardı edebilir. (Üst üste binen dizileri geçmek memcpytanımsız bir davranıştır.) Bu nedenle memcpybu durumu açıkça kontrol etmek gerekmez, ancak parametre kaynak aralığında olmadığı std::copysürece kullanılabilir OutputIterator. Bunun, kaynak aralığının ve hedef aralığının çakışamayacağını söylemekle aynı olmadığını unutmayın .

Yani beri std::copyolması gerektiği teoride, biraz farklı gereksinimleri vardır hafifçe (üzerinde aşırı bir vurgu ile hafifçe muhtemelen C-diziler örtüşen kontrol, ya da başka C-Dizilerin kopyalanmasını temsilci olacağından, daha yavaş) memmovegerçekleştirmek gerekiyor Kontrol. Ancak pratikte, siz (ve çoğu profil sahibi) muhtemelen herhangi bir fark bile tespit etmeyeceksiniz.

Birlikte çalıştığınız değilseniz Tabii ki, PODs , sen olamaz kullanmak memcpyzaten.

Kuralım basit. C ++ kullanıyorsanız C ++ değil C ++ kütüphanelerini tercih edin

Sadece küçük bir ekleme: Optimizasyonların etkin veya devre dışı olmasına bağlı olarak memcpy()ve arasındaki hız farkı std::copy()biraz değişebilir. G ++ 6.2.0 ve optimizasyon olmadan memcpy()açıkça kazanır:

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

Optimizasyonlar etkinleştirildiğinde ( -O3), her şey tekrar aynı görünür:

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

Dizi ne kadar büyük olursa, efekt o kadar az fark edilir, ancak en N=1000 memcpy()iyisi, optimizasyonlar etkinleştirilmediğinde yaklaşık iki kat daha hızlıdır.

Kaynak kodu (Google Benchmark gerektirir):

#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 */

Gerçekten maksimum kopyalama performansına ihtiyacınız varsa (ki olmayabilir de), hiçbirini kullanmayın .

Bir var çok optimize hafıza kopyalama için yapılabilecek - hatta daha bunun için sen istekli birden konuları kullanmak eğer / çekirdekler. Bkz. Örneğin:

Bu memcpy uygulamasında eksik / alt optimal olan nedir?

hem soru hem de cevapların bazıları önerilen uygulamaları veya uygulamalara bağlantıları önerdi.

Profil oluşturma şu ifadeyi gösterir: std::copy()her zaman olduğu kadar hızlı memcpy()veya daha hızlı yanlıştır.

Sistemim:

HP-Compaq-dx7500-Küçük Kasa 3.13.0-24-jenerik # 47-Ubuntu SMP Cum 2 Mayıs 23:30:00 UTC 2014 x86_64 x86_64 x86_64 GNU / Linux.

gcc (Ubuntu 4.8.2-19ubuntu1) 4.8.2

Kod (dil: 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 () profili: main: 21: now: 1422969084: 04859 geçen: 2650 us
std :: copy () profil: main: 27: now: 1422969084: 04862 geçen: 2745 us
memcpy () geçen 44 s std :: copy ( ) geçen 45 s

g ++ -O3 -o test_stdcopy test_stdcopy.cpp

memcpy () profili: main: 21: now: 1422969601: 04939 geçen: 2385 us
std :: copy () profil: main: 28: now: 1422969601: 04941 geçen: 2690 us
memcpy () geçen 27 s std :: copy ( ) geçen süre 43 s

Red Alert, kodun diziden diziye memcpy kullandığını ve diziden vektöre std :: copy olduğunu belirtti. Bu coud daha hızlı memcpy için bir sebep olabilir.

Den beri

v.reserve (sizeof (arr1));

vektör veya diziye kopyalamada hiçbir fark olmayacaktır.

Kod, her iki durumda da dizi kullanmak üzere sabitlenmiştir. memcpy hala daha hızlı:

{
    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