ทำไมฉันถึงต้อง std :: ย้าย std :: shared_ptr?

ฉันได้อ่านซอร์สโค้ดของ Clangแล้วและฉันพบข้อมูลโค้ดนี้:

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

ทำไมฉันจะต้องการที่จะ?std::movestd::shared_ptr

มีจุดใดที่ถ่ายโอนความเป็นเจ้าของในทรัพยากรที่ใช้ร่วมกันหรือไม่

ทำไมฉันจะไม่ทำเช่นนี้แทน?

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

ผมคิดว่าสิ่งหนึ่งคำตอบอื่น ๆ ไม่ได้เน้นพอเป็นจุดของความเร็ว

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

การย้ายshared_ptrแทนที่การคัดลอกทำให้เรา "ขโมย" จำนวนการอ้างอิงอะตอมมิกและเราทำให้โมฆะอีกshared_ptrอัน "ขโมย" จำนวนการอ้างอิงไม่ใช่อะตอมและเร็วกว่าการทำสำเนาเป็นร้อยเท่าshared_ptr(และทำให้การเพิ่มหรือลดการอ้างอิงอะตอมมิก )

โปรดทราบว่าเทคนิคนี้ใช้เพื่อการเพิ่มประสิทธิภาพอย่างแท้จริง การคัดลอก (ตามที่คุณแนะนำ) เป็นเพียงฟังก์ชั่นที่ดี

โดยการใช้moveคุณหลีกเลี่ยงการเพิ่มและลดจำนวนการแบ่งปันทันที ซึ่งอาจช่วยให้คุณประหยัดค่าใช้จ่ายในการดำเนินการปรมาณู

ย้ายการดำเนินงาน (เช่นคอนสตรัคย้าย) ให้std::shared_ptrมีราคาถูกเช่นที่พวกเขาโดยทั่วไปเป็น"ตัวชี้ขโมย" (จากต้นทางไปยังปลายทาง; จะแม่นยำมากขึ้นบล็อกการควบคุมของรัฐทั้งหมดจะถูก "ขโมย" จากต้นทางไปยังปลายทางรวมทั้งข้อมูลจำนวนการอ้างอิง) .

แต่การคัดลอกการดำเนินการในการstd::shared_ptrเรียกใช้การเพิ่มจำนวนการอ้างอิงของอะตอม (เช่นไม่ใช่แค่++RefCountในRefCountสมาชิกข้อมูลจำนวนเต็มแต่เช่นการโทรInterlockedIncrementบน Windows) ซึ่งมีราคาแพงกว่าการขโมยพอยน์เตอร์ / รัฐ

ดังนั้นการวิเคราะห์การเปลี่ยนแปลงการนับการอ้างอิงของกรณีนี้ในรายละเอียด:

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

หากคุณผ่านspค่าจากนั้นคัดลอกภายในCompilerInstance::setInvocationวิธีการคุณมี:

1. เมื่อเข้าสู่วิธีการที่shared_ptrมีพารามิเตอร์คัดลอกสร้าง: โทษนับอะตอม เพิ่มขึ้น
2. ภายในร่างกายของวิธีการที่คุณคัดลอกshared_ptrพารามิเตอร์เข้าไปในข้อมูลสมาชิก: Ref นับอะตอม เพิ่มขึ้น
3. เมื่อออกจากวิธีการ shared_ptrพารามิเตอร์ destructed: โทษนับอะตอม ลดลง

คุณมีการเพิ่มขึ้นสองครั้งของอะตอมและการลดลงของอะตอมหนึ่งครั้งรวมเป็น ดำเนินการปรมาณูสามครั้ง

แต่ถ้าคุณผ่าน shared_ptrพารามิเตอร์ตามค่าและจากนั้นstd::moveภายในเมธอด (ทำอย่างถูกต้องในรหัสของ Clang) คุณมี:

1. เมื่อเข้าสู่วิธีการ shared_ptrมีพารามิเตอร์คัดลอกสร้าง: โทษนับอะตอม เพิ่มขึ้น
2. ภายในร่างกายของวิธีนี้คุณ std::moveshared_ptrพารามิเตอร์เข้าไปในข้อมูลสมาชิก: ref นับไม่ไม่เปลี่ยนแปลง! คุณเป็นเพียงการขโมยพอยน์เตอร์ / รัฐ: ไม่มีการดำเนินการนับอะตอมที่มีราคาแพงที่เกี่ยวข้อง
3. เมื่อออกจากวิธีการshared_ptrพารามิเตอร์จะถูกทำลาย; แต่เนื่องจากคุณย้ายเข้ามาในขั้นตอนที่ 2 ไม่มีสิ่งใดที่จะทำลายได้เนื่องจากshared_ptrพารามิเตอร์ไม่ได้ชี้ไปที่สิ่งใดอีกต่อไป ในกรณีนี้ไม่มีการลดลงของอะตอม

บรรทัดด้านล่าง: ในกรณีนี้คุณจะได้รับเพียงหนึ่งโทษนับเพิ่มอะตอมคือเพียงหนึ่งอะตอมการดำเนินงาน
อย่างที่คุณเห็นนี่เป็นดีกว่าการเพิ่มขึ้นสองครั้งของอะตอมบวกหนึ่งการลดลงของอะตอม (สำหรับการดำเนินการปรมาณูทั้งหมดสามครั้ง ) สำหรับกรณีการคัดลอก

การคัดลอก a shared_ptrเกี่ยวข้องกับการคัดลอกตัวชี้วัตถุสถานะภายในและการเปลี่ยนจำนวนการอ้างอิง การย้ายมันเกี่ยวข้องกับการสลับพอยน์เตอร์ไปยังตัวนับการอ้างอิงภายในและวัตถุที่เป็นเจ้าของเท่านั้นดังนั้นจึงเร็วขึ้น

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

สำหรับ std :: shared_ptr, std :: move อย่างไม่น่าเชื่อหมายถึงการโอนการเป็นเจ้าของของ pointee ในขณะที่การดำเนินการคัดลอกง่ายเพิ่มเจ้าของเพิ่มเติม แน่นอนว่าหากเจ้าของเดิมสละการเป็นเจ้าของ (เช่นโดยอนุญาตให้ std :: shared_ptr ถูกทำลาย) ในภายหลังการโอนการเป็นเจ้าของได้สำเร็จ

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

อย่างน้อยด้วย libstdc ++ คุณควรได้รับประสิทธิภาพเดียวกันกับการย้ายและการกำหนดเพราะการoperator=เรียกstd::moveตัวชี้เข้ามา ดู: https://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/include/bits/shared_ptr.h#L384