Neden std :: bir std :: shared_ptr taşıyayım?

Clang kaynak koduna bakıyordum ve şu pasajı buldum:

void CompilerInstance::setInvocation(
    std::shared_ptr<CompilerInvocation> Value) {
  Invocation = std::move(Value);
}

Neden isteyeyim std::movebir std::shared_ptr?

Paylaşılan bir kaynakta sahipliği aktaran herhangi bir nokta var mı?

Neden bunun yerine bunu yapmayayım?

void CompilerInstance::setInvocation(
    std::shared_ptr<CompilerInvocation> Value) {
  Invocation = Value;
}

Bence diğer yanıtların yeterince vurgulamadığı tek şey hız noktasıydı .

std::shared_ptrreferans sayısı atomiktir . referans sayısının artırılması veya azaltılması, atomik artış veya azalma gerektirir . Bu yüz katıdır yavaş daha olmayan atomik saymıyorum, artırma / eksiltme bu süreçte zaman ve kaynak bir ton israf, artırır ve biz tam sayısı ile rüzgar aynı sayaç azaltma eğer.

shared_ptrKopyalamak yerine hareket ettirerek atomik referans sayısını "çalarız" ve diğerini iptal ederiz shared_ptr. Referans sayısını "çalmak" atomik değildir ve kopyalamaktan shared_ptr(ve atomik referans artışına veya azalmasına neden olmaktan) yüz kat daha hızlıdır .

Bu tekniğin yalnızca optimizasyon için kullanıldığını unutmayın. kopyalamak (önerdiğiniz gibi) işlevsellik açısından da iyi.

Kullanarak move, hisse sayısını artırıp hemen düşürmekten kaçınırsınız. Bu, kullanım sayısında bazı pahalı atomik işlemlerden tasarruf etmenizi sağlayabilir.

Taşı (hareket yapıcısı gibi) işlemleri için std::shared_ptrolan ucuz temelde gibi, "çalarak işaretçiler" (kaynaktan bir hedefe, daha kesin konuşmak gerekirse, bütün durumu kontrol bloğu başvuru sayısı bilgileri de dahil olmak üzere, hedef kaynaktan "çalıntı" olduğu) .

Bunun yerine , atomik referans sayısı artışını çağırma üzerindeki kopyalama işlemleri (yani, yalnızca bir tamsayı veri üyesinde değil, örneğin Windows'da arama ), bu sadece işaretçileri / durumu çalmaktan daha pahalıdır .std::shared_ptr++RefCountRefCountInterlockedIncrement

Bu nedenle, bu vakanın ref sayısı dinamiklerini ayrıntılı olarak analiz etmek:

// shared_ptr<CompilerInvocation> sp;
compilerInstance.setInvocation(sp);

Eğer başarılı olursa spdeğeri tarafından ve daha sonra bir almak kopyasını içine CompilerInstance::setInvocationyöntemle, sahip:

1. Yöntemi girerken, shared_ptrparametre kopyalanarak oluşturulur: ref count atomik artış .
2. Yöntemin vücudun İçinde, kopyashared_ptr veri elemanı içerisine parametresini: saymak Ref atom artışı .
3. Yöntemden çıkıldığında, shared_ptrparametre yok edilir: ref count atomik azalma .

Toplam üç atomik işlem için iki atomik artımınız ve bir atomik azalmanız var .

Bunun yerine, shared_ptrparametreyi değere göre geçirirseniz ve daha sonra std::moveyöntemin içinde (Clang kodunda doğru şekilde yapıldığı gibi), şunları elde edersiniz:

1. Yöntemi girerken, shared_ptrparametre kopyalanarak oluşturulur: ref count atomik artış .
2. Yöntemin vücudun İçinde, veri elemanı içerisine parametre: ref sayısı yok değil değiştirin! Sadece işaretçileri / durumu çalıyorsunuz: pahalı atomik referans sayma işlemleri dahil değildir.std::moveshared_ptr
3. Yöntemden çıkılırken shared_ptrparametre yok edilir; ancak 2. adımda hareket ettiğinizden beri, shared_ptrparametre artık hiçbir şeye işaret etmediği için yok edilecek bir şey yok. Yine, bu durumda atomik azalma olmaz.

Alt satır: bu durumda sadece bir referans sayısı atomik artış, yani sadece bir atomik işlem elde edersiniz .
Gördüğünüz gibi, bu, kopya durumu için iki atomik artış artı bir atomik azalmadan (toplam üç atomik işlem için) çok daha iyidir .

Bir shared_ptrkopyalamak, dahili durum nesnesi işaretçisini kopyalamayı ve referans sayısını değiştirmeyi içerir. Onu taşımak yalnızca işaretçileri dahili referans sayacına ve sahip olunan nesneye değiştirmeyi içerir, bu nedenle daha hızlıdır.

Bu durumda std :: move kullanmanın iki nedeni vardır. Yanıtların çoğu hız konusunu ele aldı, ancak kodun amacını daha net gösterme gibi önemli bir konuyu görmezden geldi.

Bir std :: shared_ptr için, std :: move açık bir şekilde noktanın sahipliğinin transferini belirtirken, basit bir kopyalama işlemi ek bir sahip ekler. Elbette, orijinal sahip daha sonra sahipliğini bırakırsa (örneğin, std :: shared_ptr'lerinin yok edilmesine izin vererek), o zaman bir mülkiyet devri gerçekleştirilmiştir.

Sahipliği std :: move ile aktardığınızda, ne olduğu açıktır. Normal bir kopya kullanırsanız, asıl sahibin sahiplikten derhal vazgeçtiğini doğrulayana kadar amaçlanan işlemin bir transfer olduğu açık değildir. Bonus olarak, daha verimli bir uygulama mümkündür, çünkü atomik bir sahiplik devri, sahiplerin sayısının bir arttığı geçici durumu (ve referans sayılarında görevlilerin değişmesini) önleyebilir.

En azından libstdc ++ ile taşıma ve atama ile aynı performansı almalısınız çünkü gelen işaretçi üzerinde operator=çağrılar std::move. Bakınız: https://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/include/bits/shared_ptr.h#L384