C ++ 11'deki normal işaretçilerle karşılaştırıldığında akıllı işaretçilerin ek yükü ne kadar? Başka bir deyişle, akıllı işaretçiler kullanırsam kodum daha yavaş mı olacak ve eğer öyleyse ne kadar yavaş olacak?

Özellikle, C ++ 11 std::shared_ptrve std::unique_ptr.

Açıkçası, yığından aşağı itilen şeyler daha büyük olacak (en azından öyle düşünüyorum), çünkü akıllı bir işaretçinin aynı zamanda iç durumunu da saklaması gerekiyor (referans sayısı, vb.), Asıl soru şu: performansımı etkiler mi?

Örneğin, normal bir işaretçi yerine bir işlevden akıllı bir işaretçi döndürüyorum:

std::shared_ptr<const Value> getValue();
// versus
const Value *getValue();

Veya, örneğin, işlevlerimden biri normal bir işaretçi yerine parametre olarak bir akıllı işaretçiyi kabul ettiğinde:

void setValue(std::shared_ptr<const Value> val);
// versus
void setValue(const Value *val);

std::unique_ptr yalnızca, önemsiz olmayan bir silici sağlarsanız bellek ek yüküne sahiptir.

std::shared_ptr çok küçük olmasına rağmen her zaman referans sayacı için bellek ek yükü vardır.

std::unique_ptr yalnızca kurucu sırasında (sağlanan siliciyi kopyalamak ve / veya işaretçiyi sıfırlamak zorunda ise) ve yıkıcı sırasında (sahip olunan nesneyi yok etmek için) zaman ek yüküne sahiptir.

std::shared_ptryapıcıda (referans sayacını oluşturmak için), yıkıcıda (referans sayacını azaltmak ve muhtemelen nesneyi yok etmek için) ve atama operatöründe (referans sayacını artırmak için) zaman ek yükü vardır. İplik güvenliği garantileri nedeniyle std::shared_ptr, bu artışlar / azalmalar atomiktir, dolayısıyla biraz daha fazla ek yük ekler.

Bu işlemin işaretçiler için en yaygın olanı gibi görünürken, bunların hiçbirinin başvurudan uzaklaşmada (sahip olunan nesneye başvuruda bulunmada) zaman ek yükü olmadığını unutmayın.

Özetlemek gerekirse, bazı ek yükler vardır, ancak sürekli olarak akıllı işaretçiler oluşturup yok etmediğiniz sürece kodu yavaşlatmamalıdır.

Cevabım diğerlerinden farklı ve gerçekten kodun profilini çıkarıp çıkarmadıklarını merak ediyorum.

shared_ptr, kontrol bloğu için bellek ayırması nedeniyle (ref sayacını ve tüm zayıf referanslara bir işaretçi listesini tutan) oluşturma için önemli bir ek yüke sahiptir. Ayrıca bu nedenle ve std :: shared_ptr her zaman 2 işaretli bir tuple (biri nesneye, biri kontrol bloğuna) olduğu için büyük bir bellek ek yüküne sahiptir.

Bir paylaşımlı_ işaretleyiciyi bir değer parametresi olarak bir işleve iletirseniz, normal bir çağrıdan en az 10 kat daha yavaş olacaktır ve yığın çözülmesi için kod segmentinde çok sayıda kod yaratacaktır. Referans olarak geçerseniz, performans açısından da oldukça kötü olabilecek ek bir yönlendirme elde edersiniz.

Bu nedenle, işlev gerçekten sahiplik yönetimine dahil olmadıkça bunu yapmamalısınız. Aksi takdirde "shared_ptr.get ()" kullanın. Normal bir işlev çağrısı sırasında nesnenizin öldürülmediğinden emin olmak için tasarlanmamıştır.

Eğer delirirseniz ve bir derleyicideki soyut sözdizimi ağacı gibi küçük nesnelerde veya başka herhangi bir grafik yapısındaki küçük düğümlerde shared_ptr kullanırsanız, büyük bir performans düşüşü ve büyük bir hafıza artışı göreceksiniz. C ++ 14 piyasaya çıktıktan kısa bir süre sonra ve programcı akıllı işaretçileri doğru kullanmayı öğrenmeden önce yeniden yazılmış bir ayrıştırıcı sistemi gördüm. Yeniden yazma, eski koddan çok daha yavaştı.

Bu bir sihirli değnek değildir ve ham işaretçiler de tanım gereği kötü değildir. Kötü programcılar kötüdür ve kötü tasarım kötüdür. Dikkatli tasarlayın, sahipliği net bir şekilde göz önünde bulundurarak tasarlayın ve shared_ptr'yi çoğunlukla alt sistem API sınırında kullanmaya çalışın.

Daha fazlasını öğrenmek istiyorsanız, Nicolai M. Josuttis'in "C ++ 'da Paylaşılan İşaretçilerin Gerçek Fiyatı" hakkındaki güzel konuşmasını izleyebilirsiniz https://vimeo.com/131189627
Yazma engelleri, atomik için uygulama ayrıntılarının ve CPU mimarisinin derinliklerine iner. kilitler vb. bir kez dinledikten sonra bu özelliğin ucuz olduğundan asla bahsetmeyeceksiniz. Daha yavaş bir büyüklük ispatı istiyorsanız, ilk 48 dakikayı atlayın ve her yerde paylaşılan işaretçi kullanırken 180 kata kadar daha yavaş çalışan (-O3 ile derlenmiş) örnek kod çalıştırmasını izleyin.

Tüm kod performanslarında olduğu gibi, zor bilgiler elde etmenin gerçekten güvenilir tek yolu, makine kodunu ölçmek ve / veya incelemektir .

Bununla birlikte, basit mantık şunu söylüyor:

• Hata ayıklama yapılarında bazı ek yükler bekleyebilirsiniz, çünkü örneğin operator->, ona adım atabilmeniz için bir işlev çağrısı olarak yürütülmesi gerekir (bu, sınıfları ve işlevleri hata ayıklama dışı olarak işaretlemek için genel destek eksikliğinden kaynaklanır).

• İçin shared_ptrbir kontrol bloğunun dinamik ayırma gerektirir ve dinamik ayırma çok daha yavaş C ++ başka temel işleminden daha olduğundan size (kullanımını yapmak, ilk yaratılış bazı yükü bekleyebilirsiniz make_sharedzaman pratik olarak mümkün olduğu yükü en aza indirmek için).

• Ayrıca shared_ptr, örneğin bir shared_ptrdeğere göre geçerken bir referans sayımını sürdürmenin bazı minimum ek yükleri vardır, ancak bunun için böyle bir ek yük yoktur unique_ptr.

Yukarıdaki ilk noktayı aklınızda tutarak, ölçüm yaparken bunu hem hata ayıklama hem de sürüm sürümleri için yapın.

Uluslararası C ++ standardizasyon komitesi bir yayınlamıştır performansına teknik rapor öncesinde, ancak bu 2006 yılında oldu unique_ptrve shared_ptrstandart kütüphanesine eklenmiştir. Yine de, akıllı işaretçiler o noktada eski hataydı, bu nedenle rapor bunu da değerlendirdi. İlgili bölümden alıntı yapmak:

"Önemsiz bir akıllı işaretçi aracılığıyla bir değere erişmek, sıradan bir işaretçi aracılığıyla erişmekten önemli ölçüde daha yavaşsa, derleyici soyutlamayı verimsiz bir şekilde ele alıyor demektir. Geçmişte, çoğu derleyicinin önemli soyutlama cezaları vardı ve mevcut birkaç derleyicide hala var. Bununla birlikte, en az iki derleyicinin% 1'in altında soyutlama cezası ve% 3'ün altında bir cezaya sahip olduğu bildirildi, bu nedenle bu tür genel giderlerin ortadan kaldırılması son teknolojiye uygundur "

Bilinçli bir tahmin olarak, 2014'ün başlarından itibaren bugün en popüler derleyicilerle "en son teknolojinin içinde kuyu" elde edildi.

Başka bir deyişle, akıllı işaretçiler kullanırsam kodum daha yavaş mı olacak ve eğer öyleyse ne kadar yavaş olacak?

Yavaş? Büyük olasılıkla, eğer shared_ptrs kullanarak büyük bir dizin oluşturmuyorsanız ve uzaklardan dayanılmaz bir kuvvet tarafından yere düşen yaşlı bir bayan gibi bilgisayarınızın kırışmaya başladığı noktaya kadar yeterli belleğiniz yoksa.

Kodunuzu yavaşlatan şey, yavaş aramalar, gereksiz döngü işlemleri, büyük veri kopyaları ve diske çok sayıda yazma işlemi (yüzlerce gibi).

Akıllı bir işaretçinin avantajlarının tümü yönetimle ilgilidir. Ancak genel gider gerekli mi? Bu, uygulamanıza bağlıdır. Diyelim ki 3 aşamalı bir dizi üzerinde yineliyorsunuz, her aşama 1024 öğe dizisine sahip. smart_ptrBu işlem için bir tane oluşturmak aşırı olabilir, çünkü yineleme tamamlandığında onu silmeniz gerektiğini bileceksiniz. Böylece, bir smart_ptr...

Tek bir bellek sızıntısı, ürününüzün zamanında bir arıza noktasına sahip olmasına neden olabilir (diyelim ki programınız her saat 4 megabayt sızdırıyor, bir bilgisayarı kırmak aylar alır, yine de kırılır, biliyorsunuz çünkü sızıntı var) .

"Yazılımınız 3 ay garantilidir, o zaman beni servis için arayın" demek gibidir.

Yani sonunda gerçekten mesele şu ki ... bu riski kaldırabilir misin? Yüzlerce farklı nesne üzerinde indekslemenizi işlemek için ham bir işaretçi kullanmak, belleğin kontrolünü kaybetmeye değer.

Cevap evet ise, ham bir işaretçi kullanın.

Düşünmek bile istemiyorsanız smart_ptr, a iyi, uygulanabilir ve harika bir çözümdür.

Sadece bir bakış için ve sadece []operatör için, aşağıdaki kodda gösterildiği gibi ham işaretçiden ~ 5 kat daha yavaştır gcc -lstdc++ -std=c++14 -O0ve bu sonuç kullanılarak derlenmiş ve çıktısı alınmıştır:

malloc []:     414252610                                                 
unique []  is: 2062494135                                                
uq get []  is: 238801500                                                 
uq.get()[] is: 1505169542
new is:        241049490 

C ++ 'ı öğrenmeye başlıyorum, aklımda şu var: her zaman ne yaptığınızı bilmeniz ve başkalarının c ++' nızda ne yaptığını bilmek için daha fazla zaman ayırmanız gerekir.

DÜZENLE

@Mohan Kumar'ın söylediği gibi, daha fazla ayrıntı verdim. Gcc sürümü, 7.4.0 (Ubuntu 7.4.0-1ubuntu1~14.04~ppa1)yukarıdaki sonuç -O0kullanıldığında elde edildi , ancak '-O2' bayrağını kullandığımda şunu aldım:

malloc []:     223
unique []  is: 105586217
uq get []  is: 71129461
uq.get()[] is: 69246502
new is:        9683

Sonra kaydırılır clang version 3.9.0, -O0oldu:

malloc []:     409765889
unique []  is: 1351714189
uq get []  is: 256090843
uq.get()[] is: 1026846852
new is:        255421307

-O2 şuydu:

malloc []:     150
unique []  is: 124
uq get []  is: 83
uq.get()[] is: 83
new is:        54

Clang'ın sonucu -O2inanılmaz.

#include <memory>
#include <iostream>
#include <chrono>
#include <thread>

uint32_t n = 100000000;
void t_m(void){
    auto a  = (char*) malloc(n*sizeof(char));
    for(uint32_t i=0; i<n; i++) a[i] = 'A';
}
void t_u(void){
    auto a = std::unique_ptr<char[]>(new char[n]);
    for(uint32_t i=0; i<n; i++) a[i] = 'A';
}

void t_u2(void){
    auto a = std::unique_ptr<char[]>(new char[n]);
    auto tmp = a.get();
    for(uint32_t i=0; i<n; i++) tmp[i] = 'A';
}
void t_u3(void){
    auto a = std::unique_ptr<char[]>(new char[n]);
    for(uint32_t i=0; i<n; i++) a.get()[i] = 'A';
}
void t_new(void){
    auto a = new char[n];
    for(uint32_t i=0; i<n; i++) a[i] = 'A';
}

int main(){
    auto start = std::chrono::high_resolution_clock::now();
    t_m();
    auto end1 = std::chrono::high_resolution_clock::now();
    t_u();
    auto end2 = std::chrono::high_resolution_clock::now();
    t_u2();
    auto end3 = std::chrono::high_resolution_clock::now();
    t_u3();
    auto end4 = std::chrono::high_resolution_clock::now();
    t_new();
    auto end5 = std::chrono::high_resolution_clock::now();
    std::cout << "malloc []:     " <<  (end1 - start).count() << std::endl;
    std::cout << "unique []  is: " << (end2 - end1).count() << std::endl;
    std::cout << "uq get []  is: " << (end3 - end2).count() << std::endl;
    std::cout << "uq.get()[] is: " << (end4 - end3).count() << std::endl;
    std::cout << "new is:        " << (end5 - end4).count() << std::endl;
}