เมื่อใดถ้าเคยการคลายการวนซ้ำยังคงมีประโยชน์อยู่หรือไม่?

ฉันพยายามเพิ่มประสิทธิภาพโค้ดที่มีความสำคัญอย่างยิ่ง (อัลกอริธึมการเรียงลำดับอย่างรวดเร็วที่ถูกเรียกเป็นล้าน ๆ ล้านครั้งในการจำลองมอนติคาร์โล) โดยการคลายการวนซ้ำ นี่คือวงในที่ฉันพยายามเร่งความเร็ว:

// Search for elements to swap.
while(myArray[++index1] < pivot) {}
while(pivot < myArray[--index2]) {}

ฉันพยายามยกเลิกการเล่นบางอย่างเช่น:

while(true) {
    if(myArray[++index1] < pivot) break;
    if(myArray[++index1] < pivot) break;
    // More unrolling
}


while(true) {
    if(pivot < myArray[--index2]) break;
    if(pivot < myArray[--index2]) break;
    // More unrolling
}

สิ่งนี้ไม่แตกต่างอย่างแน่นอนดังนั้นฉันจึงเปลี่ยนกลับเป็นรูปแบบที่อ่านได้มากขึ้น ฉันเคยมีประสบการณ์คล้าย ๆ กันในครั้งอื่น ๆ ฉันได้ลองคลายการวนซ้ำ เมื่อพิจารณาถึงคุณภาพของตัวทำนายสาขาบนฮาร์ดแวร์สมัยใหม่เมื่อใดถ้าเคยการคลายการวนซ้ำยังคงเป็นการเพิ่มประสิทธิภาพที่มีประโยชน์หรือไม่?

การคลายการวนซ้ำนั้นสมเหตุสมผลหากคุณสามารถทำลายห่วงโซ่การพึ่งพาได้ สิ่งนี้ทำให้ CPU ที่ไม่เป็นระเบียบหรือ super-scalar มีความเป็นไปได้ในการกำหนดเวลาสิ่งต่าง ๆ ได้ดีขึ้นและทำงานได้เร็วขึ้น

ตัวอย่างง่ายๆ:

for (int i=0; i<n; i++)
{
  sum += data[i];
}

ที่นี่ห่วงโซ่การพึ่งพาของอาร์กิวเมนต์สั้นมาก หากคุณได้รับการหยุดชะงักเนื่องจากคุณมีแคชในอาร์เรย์ข้อมูล cpu ไม่สามารถทำอะไรได้นอกจากรอ

ในทางกลับกันรหัสนี้:

for (int i=0; i<n; i+=4)
{
  sum1 += data[i+0];
  sum2 += data[i+1];
  sum3 += data[i+2];
  sum4 += data[i+3];
}
sum = sum1 + sum2 + sum3 + sum4;

สามารถทำงานได้เร็วขึ้น หากคุณได้รับแคชพลาดหรือแผงลอยอื่น ๆ ในการคำนวณหนึ่งยังมีห่วงโซ่การพึ่งพาอื่น ๆ อีกสามห่วงที่ไม่ได้ขึ้นอยู่กับแผงลอย CPU ที่ไม่เป็นระเบียบสามารถดำเนินการได้

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

for (int i=0; i<200; i++) {
  doStuff();
}

เขียน:

for (int i=0; i<50; i++) {
  doStuff();
  doStuff();
  doStuff();
  doStuff();
}

ถึงแม้ว่ามันจะไม่สำคัญ แต่ตอนนี้คุณกำลังทำการเปรียบเทียบ 50 ครั้งแทนที่จะเป็น 200 (ลองนึกภาพการเปรียบเทียบนั้นซับซ้อนกว่า)

การคลายลูปแบบแมนนวลโดยทั่วไปส่วนใหญ่เป็นสิ่งประดิษฐ์ของประวัติศาสตร์อย่างไรก็ตาม เป็นอีกหนึ่งรายการที่เพิ่มขึ้นเรื่อย ๆ ซึ่งคอมไพเลอร์ที่ดีจะทำเพื่อคุณเมื่อมันสำคัญ ตัวอย่างเช่นคนส่วนใหญ่ไม่ได้รำคาญที่จะเขียนx <<= 1หรือแทนx += x x *= 2คุณเพียงแค่เขียนx *= 2และคอมไพเลอร์จะปรับให้เหมาะสมกับสิ่งที่ดีที่สุด

โดยทั่วไปแล้วความจำเป็นในการคาดเดาคอมไพเลอร์ของคุณจะน้อยลงมากขึ้น

โดยไม่คำนึงถึงการทำนายสาขาบนฮาร์ดแวร์สมัยใหม่คอมไพเลอร์ส่วนใหญ่จะคลายการวนซ้ำให้คุณอยู่ดี

มันจะคุ้มค่าที่จะค้นหาว่าการเพิ่มประสิทธิภาพคอมไพเลอร์ของคุณให้ประโยชน์กับคุณมากเพียงใด

ฉันพบว่าการนำเสนอของ Felix von Leitner ให้ความกระจ่างในเรื่องนี้มาก ฉันขอแนะนำให้คุณอ่านมัน สรุป: คอมไพเลอร์สมัยใหม่ฉลาดมากดังนั้นการเพิ่มประสิทธิภาพด้วยมือจึงแทบจะไม่มีประสิทธิภาพ

เท่าที่ฉันเข้าใจคอมไพเลอร์สมัยใหม่ได้คลายการวนลูปตามความเหมาะสมแล้วตัวอย่างเช่น gcc หากผ่านแฟล็กการปรับให้เหมาะสมตามที่คู่มือระบุว่าจะ:

คลายลูปซึ่งสามารถกำหนดจำนวนการวนซ้ำได้ในเวลาคอมไพล์หรือเมื่อเข้าสู่ลูป

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

การคลายการวนซ้ำไม่ว่าจะเป็นการคลายด้วยมือหรือการคลายการรวบรวมคอมไพเลอร์มักจะต่อต้านการทำงานโดยเฉพาะอย่างยิ่งกับซีพียู x86 รุ่นล่าสุด (Core 2, Core i7) บรรทัดล่าง: เปรียบเทียบโค้ดของคุณโดยมีและไม่มีลูปคลายการเล่นซีพียูใด ๆ ที่คุณวางแผนจะปรับใช้โค้ดนี้

การพยายามโดยไม่รู้ตัวไม่ใช่หนทางที่จะทำได้
การเรียงลำดับนี้ใช้เวลาโดยรวมสูงหรือไม่

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

นี่คือตัวอย่างวิธีการรับประสิทธิภาพสูงสุด

การคลายการวนซ้ำอาจเป็นประโยชน์ในบางกรณี การได้รับเพียงอย่างเดียวไม่ได้ข้ามการทดสอบบางอย่าง!

ตัวอย่างเช่นสามารถอนุญาตการเปลี่ยนสเกลาร์การแทรกการดึงข้อมูลซอฟต์แวร์ล่วงหน้าอย่างมีประสิทธิภาพ ... คุณจะแปลกใจจริง ๆ ว่ามันมีประโยชน์แค่ไหน (คุณสามารถเพิ่มความเร็ว 10% ในลูปส่วนใหญ่ได้อย่างง่ายดายแม้จะมี -O3) โดยการคลายอย่างจริงจัง

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

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

สถานการณ์ที่ดีสำหรับการคลายลูปจะเป็นการหมุนภาพ เนื่องจากคุณสามารถหมุนเวียนกลุ่มงานแยกกันได้ เพื่อให้ได้ผลคุณจะต้องลดจำนวนการทำซ้ำลง

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

ในตัวอย่างของคุณคุณใช้ตัวแปรโลคัลจำนวนเล็กน้อยโดยไม่ใช้รีจิสเตอร์มากเกินไป

การเปรียบเทียบ (ไปยังจุดสิ้นสุดของลูป) ก็เป็นข้อเสียเปรียบที่สำคัญเช่นกันหากการเปรียบเทียบมีน้ำหนักมาก (เช่นไม่ใช่testคำสั่ง) โดยเฉพาะอย่างยิ่งหากขึ้นอยู่กับฟังก์ชันภายนอก

การคลายการวนซ้ำช่วยเพิ่มการรับรู้ของ CPU สำหรับการทำนายสาขาเช่นกัน แต่สิ่งเหล่านี้ก็เกิดขึ้นอยู่ดี