การเขียนโปรแกรมแบบแยกส่วนมีผลต่อเวลาคำนวณหรือไม่

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

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

ใช่มันไม่เกี่ยวข้อง

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

ในระยะสั้นการสงสารซีพียูได้อย่างสมบูรณ์เข้าใจผิดที่สุด 99.99% ของเวลา สำหรับกรณีที่เหลืออยู่ที่หายากใช้ profilers อย่าได้คิดว่าคุณสามารถมองเห็นกรณีดังกล่าว - คุณไม่สามารถ

มันขึ้นอยู่กับ.

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

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

หลายปีที่ผ่านมาฉันกำลังทำสีการเชื่อมต่อแบบ 8 ทิศทางที่ไม่ซ้ำบนภาพ FLIR แบบเรียลไทม์กับสิ่งที่ในเวลานั้นเป็นโปรเซสเซอร์ที่เหมาะสม ความพยายามครั้งแรกใช้การเรียกรูทีนย่อยและการเรียกรูทีนย่อยค่าใช้จ่ายกินโปรเซสเซอร์ที่ยังมีชีวิตอยู่ (4 สายต่อ PIXEL x 64K พิกเซลต่อเฟรม x 30 เฟรมต่อวินาที = คุณเข้าใจ) ความพยายามครั้งที่สองเปลี่ยนรูทีนย่อยเป็นแมโคร C โดยไม่สูญเสียความสามารถในการอ่านและทุกอย่างก็เป็นดอกกุหลาบ

คุณต้องดูอย่างหนักในสิ่งที่คุณกำลังทำและสภาพแวดล้อมที่คุณจะทำ

ประการแรก: โปรแกรมในภาษาที่สูงกว่าสำหรับการอ่านโดยมนุษย์ไม่ใช่โดยเครื่อง

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

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

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

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

อาจไม่มีค่าใช้จ่ายในการคำนวณ โดยปกติแล้วคอมไพเลอร์ / JITs สำหรับ 10-20 ปีที่ผ่านมาหรือดังนั้นข้อตกลงกับฟังก์ชั่น inline ที่ดีอย่างสมบูรณ์แบบ สำหรับ C / C ++ โดยปกติจะ จำกัด ฟังก์ชั่น 'inlinable' (เช่นคำจำกัดความของฟังก์ชั่นนั้นมีให้สำหรับคอมไพเลอร์ระหว่างการคอมไพล์ - นั่นคือมันอยู่ในส่วนหัวของไฟล์เดียวกัน) แต่เทคนิคปัจจุบันของ LTO เอาชนะสิ่งนี้

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

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

• ปัญหาอยู่ที่ไหน โดยปกติแล้วคนเราจะหาฮอตสปอตได้ยากในขณะที่เราอ่านซอร์สโค้ดต่างกัน เรามีอัตราส่วนเวลาในการทำงานที่แตกต่างกันและเราดำเนินการตามลำดับในขณะที่ โปรเซสเซอร์ สมัยใหม่ไม่ต้องการ
• ต้องทำการคำนวณบางอย่างทุกครั้งหรือไม่? ตัวอย่างเช่นหากคุณเปลี่ยนพารามิเตอร์เดียวจากหลายพันคุณอาจต้องการคำนวณเพียงส่วนหนึ่งที่ได้รับผลกระทบแทนที่จะเป็นแบบจำลองทั้งหมด
• คุณใช้อัลกอริธึมที่เหมาะสมที่สุดหรือไม่? เปลี่ยนจากO(n)เป็นO(log n)อาจมีผลกระทบมากขึ้นแล้วอะไรก็ตามที่คุณสามารถทำได้ด้วยการปรับให้เหมาะสมแบบไมโคร
• คุณใช้โครงสร้างที่เหมาะสมหรือไม่ สมมติว่าคุณกำลังใช้Listเมื่อคุณต้องการHashSetเพื่อให้คุณมีการค้นหาเมื่อคุณสามารถมีO(n)O(1)
• คุณใช้การขนานอย่างมีประสิทธิภาพหรือไม่ ในปัจจุบันแม้กระทั่งโทรศัพท์มือถือสามารถมี 4 คอร์หรือมากกว่านั้นก็อาจจะดึงดูดให้ใช้เธรด อย่างไรก็ตามพวกเขาไม่ใช่ bullet เงินเนื่องจากพวกเขามีค่าใช้จ่ายในการซิงโครไนซ์ (ไม่ได้กล่าวถึงว่าหากปัญหาคือหน่วยความจำที่ถูกผูกไว้

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

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

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

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

คำตอบของฉันอาจจะไม่ขยายตัวมากเกินไปกับคำตอบที่มีอยู่ แต่ฉันรู้สึกว่าทั้งสองเซ็นต์ของฉันอาจมีประโยชน์

ก่อนอื่น; ใช่สำหรับแบบแยกส่วนคุณมักจะสละเวลาในการประมวลผลในระดับหนึ่ง การเขียนทุกอย่างในรหัสแอสเซมบลีจะทำให้คุณได้ความเร็วที่ดีที่สุด ที่กล่าวว่า ...

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

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

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

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

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

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

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