ค่าใช้จ่ายในการเรียกใช้ฟังก์ชันเมื่อใดยังคงมีความสำคัญในคอมไพเลอร์สมัยใหม่?

ฉันเป็นคนเคร่งศาสนาและพยายามไม่ทำบาป นั่นคือเหตุผลที่ฉันมักจะเขียนเล็ก ( น้อยกว่านั้นเพื่อ reword โรเบิร์ตซีมาร์ติน) ฟังก์ชั่นเพื่อให้สอดคล้องกับบัญญัติหลายประการที่สั่งโดยพระคัมภีร์รหัสสะอาด แต่ในขณะที่ตรวจสอบบางสิ่งฉันลงจอดที่โพสต์นี้ด้านล่างซึ่งฉันได้อ่านความคิดเห็นนี้:

โปรดจำไว้ว่าค่าใช้จ่ายของการเรียกใช้วิธีการอาจมีความสำคัญขึ้นอยู่กับภาษา มักจะมีข้อเสียระหว่างการเขียนรหัสที่สามารถอ่านได้และการเขียนรหัสนักแสดง

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

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

ขึ้นอยู่กับโดเมนของคุณ

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

และยังมีคำถามของคอมไพเลอร์ inlining วิธีการสำหรับคุณ คอมไพเลอร์ส่วนใหญ่ฉลาดพอที่จะอินไลน์ฟังก์ชั่นที่เป็นไปได้

และสุดท้ายมีกฎทองของประสิทธิภาพ: เสมอประวัติส่วนตัว อย่าเขียนรหัส "ปรับให้เหมาะสม" ตามข้อสมมติ หากคุณไม่ปกติให้เขียนทั้งสองกรณีและดูว่าแบบไหนดีกว่ากัน

ค่าใช้จ่ายในการเรียกใช้ฟังก์ชั่นขึ้นอยู่กับภาษาทั้งหมดและในระดับที่คุณปรับให้เหมาะสม

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

ในระดับสูงภาษาอย่าง Perl, Python และ Ruby มีการทำบัญชีจำนวนมากต่อการเรียกใช้ฟังก์ชันทำให้มีราคาค่อนข้างสูง สิ่งนี้ทำให้แย่ลงโดยการเขียนโปรแกรมเมตา ฉันเคยเร่งความเร็วซอฟต์แวร์ Python 3x เพียงแค่ยกฟังก์ชั่นการโทรออกจากลูปที่ร้อนแรงมาก ในรหัสประสิทธิภาพที่สำคัญฟังก์ชันของตัวช่วยอินไลน์สามารถมีผลที่เห็นได้ชัดเจน

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

• หากรหัสของคุณไม่สำคัญกับประสิทธิภาพการทำงานทำให้การบำรุงรักษาง่ายขึ้น แม้ในซอฟต์แวร์ที่มีประสิทธิภาพที่สำคัญรหัสส่วนใหญ่จะไม่เป็น "ฮอตสปอต"

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

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

เกือบทั้งหมด adages เกี่ยวกับรหัสสำหรับการปรับแต่งประสิทธิภาพการทำงานเป็นกรณีพิเศษของกฎหมายของดาห์ล คำแถลงสั้น ๆ ที่ตลกขำขันของกฎของอัมดาห์คือ

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

(การเพิ่มประสิทธิภาพของสิ่งต่าง ๆ ให้เป็นศูนย์เปอร์เซ็นต์ของ runtime เป็นไปได้ทั้งหมด: เมื่อคุณนั่งลงเพื่อเพิ่มประสิทธิภาพของโปรแกรมขนาดใหญ่และซับซ้อนคุณมีแนวโน้มที่จะพบว่ามันใช้เวลาอย่างน้อยบางอย่างของ runtime ในสิ่งที่มันไม่จำเป็นต้องทำเลย .)

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

แต่ถ้ามีกลอุบายที่คุณสามารถดึงได้ทำให้การเรียกใช้ฟังก์ชันทั้งหมดเร็วขึ้นเคล็ดลับนั้นน่าจะคุ้มค่า นักพัฒนาคอมไพเลอร์ใช้เวลามากมายในการปรับฟังก์ชั่น "คำนำ" และ "epilogues" เพราะนั่นเป็นประโยชน์ต่อโปรแกรมทั้งหมดที่คอมไพล์ด้วยคอมไพเลอร์นั้นแม้ว่ามันจะเป็นเพียงเล็กน้อยสำหรับแต่ละโปรแกรม

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

• หากรันไทม์ต่อการร้องขอของฟังก์ชันน้อยกว่ามิลลิวินาที แต่ฟังก์ชันนั้นเรียกว่าหลายร้อยหลายพันครั้งก็น่าจะมีการแทรกไว้

• หากโปรไฟล์ของโปรแกรมแสดงฟังก์ชั่นหลายพันฟังก์ชั่นและไม่มีฟังก์ชั่นใดเลยที่ใช้งานได้มากกว่า 0.1% ของเวลารันไทม์ดังนั้นโอเวอร์เฮดของการเรียกใช้ฟังก์ชันอาจมีความสำคัญในภาพรวม

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

ฉันจะท้าทายคำพูดนี้:

มักจะมีข้อเสียระหว่างการเขียนรหัสที่สามารถอ่านได้และการเขียนรหัสนักแสดง

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

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

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

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

หลักการส่วนใหญ่สำหรับโค้ดที่อ่านได้ - การจัดรูปแบบที่สอดคล้องกันชื่อตัวระบุที่มีความหมายความคิดเห็นที่เหมาะสมและเป็นประโยชน์และอื่น ๆ จะไม่มีผลต่อประสิทธิภาพ และบางอย่างเช่นการใช้ enums แทนที่จะเป็นสายก็มีประโยชน์ต่อประสิทธิภาพ

ค่าใช้จ่ายในการเรียกใช้ฟังก์ชันไม่สำคัญในกรณีส่วนใหญ่

อย่างไรก็ตามกำไรที่ใหญ่กว่าจากโค้ดอินไลน์คือการเพิ่มประสิทธิภาพรหัสใหม่หลังจากอินไลน์

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

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

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

หากฟังก์ชันที่เรียกใช้มีขนาดเล็กและคอมไพเลอร์สามารถอินไลน์ได้ค่าใช้จ่ายจะเป็นศูนย์ การใช้งานคอมไพเลอร์ / ภาษาสมัยใหม่มี JIT, การเพิ่มประสิทธิภาพการเชื่อมโยงเวลาและ / หรือระบบโมดูลที่ออกแบบมาเพื่อเพิ่มความสามารถในการทำงานแบบอินไลน์เมื่อมันเป็นประโยชน์

OTOH มีค่าใช้จ่ายที่ไม่ชัดเจนในการเรียกใช้ฟังก์ชัน: การมีอยู่ของพวกเขาอาจยับยั้งการปรับให้เหมาะสมของคอมไพเลอร์ก่อนและหลังการโทร

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

ตัวอย่างเช่นถ้าคุณไม่จำเป็นต้องเรียกใช้ฟังก์ชันในการวนซ้ำแต่ละครั้ง:

for(int i=0; i < /* gasp! */ strlen(s); i++) x ^= s[i];

คอมไพเลอร์อาจรู้ว่ามันเป็นฟังก์ชั่นที่บริสุทธิ์และย้ายออกจากลูป (ในกรณีที่แย่มากเช่นตัวอย่างนี้ยังแก้ไขอัลกอริทึม O (n ^ 2) โดยไม่ตั้งใจให้เป็น O (n)):

for(int i=0, end=strlen(s); i < end; i++) x ^= s[i];

จากนั้นอาจจะเขียนวนซ้ำเพื่อประมวลผลองค์ประกอบ 4/8/16 ต่อครั้งโดยใช้คำแนะนำแบบกว้าง / SIMD

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

for(int i=0; i < strlen(s); i++) {
    x ^= s[i];
    do_nothing();
}

เอกสารเก่านี้อาจตอบคำถามของคุณ:

Guy Lewis Steele, Jr .. "การเปิดโปงตำนาน 'การเรียกขั้นตอนราคาแพง' หรือการดำเนินการตามขั้นตอนการโทรถือว่าเป็นอันตรายหรือแลมบ์ดา: The Ultimate GOTO" MIT AI Lab AI Lab Memo AIM-443 ต.ค. 2520

บทคัดย่อ:

ชาวบ้านกล่าวว่างบ GOTO เป็น "ถูก" ในขณะที่การเรียกขั้นตอนเป็น "แพง" ตำนานนี้ส่วนใหญ่เป็นผลมาจากการใช้งานภาษาที่ออกแบบมาไม่ดี การเติบโตทางประวัติศาสตร์ของตำนานนี้ได้รับการพิจารณา ทั้งแนวคิดทางทฤษฎีและการนำไปปฏิบัติที่มีอยู่ถูกกล่าวถึงซึ่งทำให้ debunk myth นี้ มันแสดงให้เห็นว่าการใช้การโทรแบบไม่ จำกัด ขั้นตอนช่วยให้มีสไตล์ที่ยอดเยี่ยม โดยเฉพาะอย่างยิ่งผังงานใด ๆ ที่สามารถเขียนเป็นโปรแกรม "โครงสร้าง" โดยไม่ต้องแนะนำตัวแปรเพิ่มเติม ความยากลำบากในการใช้คำสั่ง GOTO และการเรียกโพรซีเดอร์นั้นเป็นลักษณะที่ขัดแย้งกันระหว่างแนวคิดการเขียนโปรแกรมเชิงนามธรรมและการสร้างภาษาที่เป็นรูปธรรม

• ใน C ++ ระวังการออกแบบฟังก์ชั่นการโทรที่คัดลอกอาร์กิวเมนต์ค่าเริ่มต้นคือ "pass by value" ค่าใช้จ่ายในการเรียกใช้ฟังก์ชันเนื่องจากการบันทึกการลงทะเบียนและสิ่งอื่น ๆ ที่เกี่ยวข้องกับสแต็กเฟรมสามารถถูกครอบงำโดยสำเนาของวัตถุที่ไม่ได้ตั้งใจ (และอาจมีราคาแพงมาก)

• มีการเพิ่มประสิทธิภาพที่เกี่ยวข้องกับสแต็กเฟรมที่คุณควรตรวจสอบก่อนที่จะยอมแพ้กับรหัสที่มีการแยกตัวประกอบสูง

• ส่วนใหญ่เวลาที่ฉันต้องจัดการกับโปรแกรมที่ช้าฉันพบว่าการเปลี่ยนแปลงอัลกอริทึมให้ความเร็วที่สูงกว่าการเรียกฟังก์ชั่นอินไลน์ ตัวอย่างเช่น: วิศวกรคนอื่นแยก parser ที่เติมโครงสร้าง map-of-maps ส่วนหนึ่งของสิ่งนั้นคือเขาลบดัชนีแคชออกจากแผนที่หนึ่งไปยังแผนที่ที่มีเหตุผล นั่นเป็นการย้ายรหัสที่ดีอย่างไรก็ตามมันทำให้โปรแกรมไม่สามารถใช้งานได้เนื่องจากปัจจัยการชะลอตัว 100 ครั้งเนื่องจากการค้นหาแฮชสำหรับการเข้าถึงในอนาคตทั้งหมดเมื่อเทียบกับการใช้ดัชนีที่เก็บไว้ การทำโปรไฟล์แสดงให้เห็นว่าส่วนใหญ่ใช้เวลาในฟังก์ชั่นการแฮช

อย่างที่คนอื่นพูดคุณควรวัดประสิทธิภาพโปรแกรมของคุณก่อนและอาจไม่พบความแตกต่างในทางปฏิบัติ

ถึงกระนั้นจากระดับแนวความคิดฉันคิดว่าฉันจะอธิบายบางสิ่งที่ทำให้สับสนในคำถามของคุณ ประการแรกคุณถาม:

ค่าใช้จ่ายในการใช้งานฟังก์ชั่นยังคงมีความสำคัญในคอมไพเลอร์สมัยใหม่หรือไม่?

สังเกตคำสำคัญ "ฟังก์ชั่น" และ "คอมไพเลอร์" คำพูดของคุณแตกต่างกันเล็กน้อย:

โปรดจำไว้ว่าค่าใช้จ่ายของการเรียกใช้วิธีการอาจมีความสำคัญขึ้นอยู่กับภาษา

นี่คือวิธีการพูดคุยในแง่ของวัตถุ

ในขณะที่ "ฟังก์ชั่น" และ "วิธีการ" มักจะใช้แทนกันได้มีความแตกต่างเมื่อมันมาถึงค่าใช้จ่ายของพวกเขา (ซึ่งคุณถามเกี่ยวกับ) และเมื่อมันมาถึงการรวบรวม (ซึ่งเป็นบริบทที่คุณให้)

โดยเฉพาะอย่างยิ่งที่เราต้องรู้เกี่ยวกับการจัดส่งแบบคงที่เทียบกับการจัดส่งแบบไดนามิก ฉันจะเพิกเฉยต่อการเพิ่มประสิทธิภาพในขณะนี้

ในภาษาเช่น C ที่เรามักจะเรียกฟังก์ชั่นที่มีการจัดส่งแบบคงที่ ตัวอย่างเช่น:

int foo(int x) {
  return x + 1;
}

int bar(int y) {
  return foo(y);
}

int main() {
  return bar(42);
}

เมื่อคอมไพเลอร์เห็นการเรียกfoo(y)มันจะรู้ว่าฟังก์ชั่นfooชื่อนั้นหมายถึงอะไรดังนั้นโปรแกรมเอาต์พุตสามารถข้ามไปยังfooฟังก์ชั่นได้ซึ่งค่อนข้างถูก นั่นคือความหมายของการส่งแบบคงที่

อีกทางเลือกหนึ่งคือการจัดส่งแบบไดนามิกที่คอมไพเลอร์ไม่ทราบว่าจะเรียกใช้ฟังก์ชันใด ตัวอย่างเช่นนี่คือรหัส Haskell บางส่วน (เนื่องจากค่าเทียบเท่า C จะยุ่ง!):

foo x = x + 1

bar f x = f x

main = print (bar foo 42)

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

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

class A:
  def __init__(self, x):
    self.x = x

  def foo(self):
    return self.x + 1

def bar(y):
  return y.foo()

z = A(42)
bar(z)

การy.foo()เรียกใช้การจัดส่งแบบไดนามิกเนื่องจากเป็นการค้นหาค่าของfooคุณสมบัติในyวัตถุและเรียกสิ่งที่พบ ไม่รู้ว่าyจะมีคลาสAหรือAคลาสมีfooเมธอดดังนั้นเราจึงไม่สามารถกระโดดข้ามไปที่มันได้

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

แล้วสิ่งนี้จะส่งผลกระทบต่อคอมไพเลอร์ที่ทันสมัยและปรับให้เหมาะสมได้อย่างไร

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

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

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

หากภาษาของเราทำให้เรามีข้อ จำกัด มากขึ้นตัวอย่างเช่นโดยการ จำกัดyชั้นเรียนAโดยใช้คำอธิบายประกอบดังนั้นเราสามารถใช้ข้อมูลนั้นเพื่อสรุปฟังก์ชั่นเป้าหมาย ในภาษาที่มีคลาสย่อย (ซึ่งเกือบทั้งหมดเป็นภาษาที่มีคลาส!) ที่จริงแล้วไม่เพียงพอเนื่องจากyจริง ๆ แล้วอาจมีคลาส (ย่อย) ที่แตกต่างกันดังนั้นเราจึงต้องการข้อมูลเพิ่มเติมเช่นfinalคำอธิบายประกอบของ Java เพื่อทราบว่าจะเรียกฟังก์ชันใด

Haskell ไม่ได้เป็นภาษา OO แต่เราสามารถอนุมานค่าของfโดย inlining bar(ซึ่งคงส่ง) ลงmainแทนสำหรับfoo yเนื่องจากเป้าหมายของfooin in mainเป็นที่รู้จักกันในแบบคงที่การเรียกจะถูกส่งแบบสแตติกและอาจได้รับการอินไลน์และปรับให้เหมาะสมอย่างสมบูรณ์ (เนื่องจากฟังก์ชั่นเหล่านี้มีขนาดเล็กคอมไพเลอร์มีแนวโน้มที่จะอินไลน์พวกมัน )

ดังนั้นราคาลดลงมาที่:

• ภาษาส่งการโทรของคุณแบบคงที่หรือแบบไดนามิกหรือไม่?
• หากเป็นภาษาหลังให้ใช้งานเพื่ออนุมานเป้าหมายโดยใช้ข้อมูลอื่น ๆ (เช่นประเภทคลาสคำอธิบายประกอบอินไลน์ ฯลฯ ) หรือไม่
• การจัดส่งแบบสแตติก (เชิงอนุมานหรืออย่างอื่น) จะเพิ่มประสิทธิภาพได้อย่างไร

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

ใช่การคาดคะเนของสาขาที่ไม่ได้รับนั้นมีราคาแพงกว่าฮาร์ดแวร์ที่ทันสมัยกว่าเมื่อหลายสิบปีก่อน แต่คอมไพเลอร์มีความฉลาดในการปรับแต่งสิ่งนี้ให้ดีขึ้น

ยกตัวอย่างเช่นพิจารณา Java เมื่อแรกเห็นแล้วค่าใช้จ่ายในการเรียกใช้ฟังก์ชันควรโดดเด่นเป็นพิเศษในภาษานี้:

• ฟังก์ชั่นเล็ก ๆ เป็นที่แพร่หลายเนื่องจากการประชุม JavaBean
• ฟังก์ชั่นเริ่มต้นที่เสมือนจริงและมักจะ
• หน่วยการคอมไพล์เป็นคลาส รันไทม์รองรับการโหลดคลาสใหม่ได้ตลอดเวลารวมถึงคลาสย่อยที่แทนที่วิธี monomorphic ก่อนหน้านี้

ด้วยความหวาดกลัวจากการปฏิบัติเหล่านี้โปรแกรมเมอร์ C โดยเฉลี่ยจะทำนายว่า Java จะต้องมีขนาดอย่างน้อยหนึ่งลำดับที่ช้ากว่า C และ 20 ปีที่แล้วเขาก็จะถูกต้อง มาตรฐานที่ทันสมัย ​​แต่วางรหัส Java สำนวนภายในไม่กี่เปอร์เซ็นต์ของรหัส C เทียบเท่า เป็นไปได้อย่างไร?

เหตุผลหนึ่งก็คือฟังก์ชั่นอินไลน์ JVMs ที่ทันสมัยเรียกว่าเป็นเรื่องของหลักสูตร มันใช้อินไลน์การเก็งกำไร:

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

นั่นคือรหัส:

int x = point.getX();

ได้รับการเขียนใหม่ถึง

if (point.class != Point) GOTO interpreter;
x = point.x;

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

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

โปรดจำไว้ว่าค่าใช้จ่ายของการเรียกใช้วิธีการอาจมีความสำคัญขึ้นอยู่กับภาษา มักจะมีข้อเสียระหว่างการเขียนรหัสที่สามารถอ่านได้และการเขียนรหัสนักแสดง

นี่คือโชคไม่ดีขึ้นอยู่กับ:

• toolchain ของคอมไพเลอร์รวมถึง JIT ถ้ามี
• โดเมน

แรกของทุกกฎข้อที่หนึ่งของการเพิ่มประสิทธิภาพการปฏิบัติงานเป็นรายแรก มีหลายโดเมนที่ประสิทธิภาพของส่วนซอฟต์แวร์ไม่เกี่ยวข้องกับประสิทธิภาพของสแต็กทั้งหมด: การเรียกฐานข้อมูล, การทำงานของเครือข่าย, การปฏิบัติการของ OS, ...

นี่หมายความว่าประสิทธิภาพของซอฟต์แวร์นั้นไม่เกี่ยวข้องอย่างสมบูรณ์แม้ว่าจะไม่ได้ปรับปรุงความหน่วงแฝงการปรับซอฟต์แวร์ให้เหมาะสมอาจส่งผลให้ประหยัดพลังงานและประหยัดฮาร์ดแวร์ (หรือประหยัดแบตเตอรี่สำหรับแอพมือถือ) ซึ่งอาจสำคัญ

อย่างไรก็ตามโดยทั่วไปแล้วสิ่งเหล่านี้ไม่สามารถมองด้วยตาและบ่อยครั้งที่การปรับปรุงอัลกอริทึมทรัมป์การเพิ่มประสิทธิภาพขนาดเล็กโดยขอบขนาดใหญ่

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

ตอนนี้เกี่ยวกับประสิทธิภาพของซอฟต์แวร์ล้วน ๆ มันแตกต่างกันมากระหว่าง toolchains

การเรียกใช้ฟังก์ชันมีสองค่าใช้จ่าย:

• ค่าใช้จ่ายเวลาทำงาน
• ต้นทุนเวลารวบรวม

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

การรั่วไหล / การรีจิสเตอร์รีจิสเตอร์นี้ใช้เวลาน้อยมาก (รอบ CPU หลายสิบ)

โดยทั่วไปแล้วคาดว่าค่าใช้จ่ายนี้จะเล็กน้อยเมื่อเทียบกับค่าใช้จ่ายจริงของการใช้งานฟังก์ชั่นอย่างไรก็ตามรูปแบบบางอย่างมีประสิทธิภาพที่นี่: getters, ฟังก์ชั่นที่ได้รับการปกป้องโดยเงื่อนไขง่าย ๆ ...

นอกเหนือจากล่ามผู้เขียนโปรแกรมจะหวังว่าคอมไพเลอร์หรือJITจะเพิ่มประสิทธิภาพการเรียกฟังก์ชั่นที่ไม่จำเป็น แม้ว่าความหวังนี้บางครั้งอาจไม่เกิดผล เพราะเครื่องมือเพิ่มประสิทธิภาพไม่ใช่เวทมนต์

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

ตัวอย่างทั่วไปคือ:

void func(condition: boolean) {
    if (condition) {
        doLotsOfWork();
    }
}

void call() { func(false); }

หากfuncมีการ inlined แล้วเพิ่มประสิทธิภาพจะตระหนักว่าสาขาจะไม่ดำเนินการและเพิ่มประสิทธิภาพในการcallvoid call() {}

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

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

"โปรดจำไว้ว่าค่าใช้จ่ายในการเรียกใช้วิธีการอาจมีความสำคัญขึ้นอยู่กับภาษาซึ่งมักจะมีข้อเสียระหว่างการเขียนรหัสที่อ่านได้และการเขียนรหัสนักแสดง"

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

ฉันแค่จะบอกว่าไม่มีทางแบน ฉันเชื่อว่าคำพูดจะไม่ประมาทเพียงแค่โยนออกไปที่นั่น

แน่นอนว่าฉันไม่ได้พูดความจริงทั้งหมด แต่ฉันไม่สนใจที่จะพูดความจริงอย่างมาก มันเหมือนในภาพยนตร์เรื่อง Matrix ที่ฉันลืมไปว่ามันเป็น 1 หรือ 2 หรือ 3 - ฉันคิดว่ามันเป็นภาพยนตร์ที่มีนักแสดงหญิงชาวอิตาลีเซ็กซี่ที่มีแตงโมขนาดใหญ่ (ฉันไม่ชอบ แต่อย่างใดอย่างแรก) เมื่อ oracle lady บอกกับ Keanu Reeves ว่า"ฉันแค่บอกคุณว่าคุณต้องการได้ยินอะไร"หรืออะไรทำนองนี้นั่นคือสิ่งที่ฉันต้องการจะทำตอนนี้

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

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

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

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