สิ่งที่ดีที่สุดสำหรับการเข้ารหัสในสภาพแวดล้อมการรวบรวมช้า

ฉันเคยเขียนโค้ดใน C # ในรูปแบบ TDD - เขียน / หรือเปลี่ยนรหัสเล็ก ๆ ของคอมไพล์อีกครั้งใน 10 วินาทีของการแก้ปัญหาทั้งหมดเรียกใช้การทดสอบอีกครั้งและอีกครั้ง ง่าย...

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

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

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

ด้วย C # และ TDD มันง่ายมากที่จะเขียนโค้ดในรูปแบบของวิวัฒนาการ - หลังจากทำซ้ำหลายสิบครั้งไม่ว่าอะไรก็ตามที่ฉันเริ่มด้วยอึก็จบลงด้วยรหัสที่ดี แต่มันก็ไม่ได้ผลสำหรับฉันอีกต่อไป สภาพแวดล้อม)

มีหลายสิ่งที่อยู่ในใจของฉัน:

1. ทำให้การใช้งานของการรวบรวมการกระจาย คุณสามารถทำสิ่งนี้กับ GCC ("distCC"?) หรือ VC ( Xoreax 'IncrediBuildไม่ได้ราคาถูก แต่คุ้มค่าทุก ๆ ร้อยที่ใช้ไป)

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

3. โปรแกรมต่อต้านโครงการทดสอบขนาดเล็กมากกว่าการสมัครขนาดใหญ่ทั้งหมด

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

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

โซลูชันทางเทคนิคอื่นที่ไม่ได้กล่าวถึงโดยบุคคลอื่นกำลังเปลี่ยนไปใช้โซลิดสเตตไดรฟ์แทนฮาร์ดไดรฟ์ทั่วไป ในโครงการก่อนหน้านี้ที่ฉันทำงานอยู่ SSD ได้ลดเวลาในการสร้างจากช่วง 30 นาทีถึง 3

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

การวางแผนเพิ่มเติมเขียนโค้ดในกลุ่มที่ใหญ่กว่าเขียนการทดสอบการรวมแทนการทดสอบหน่วยและเรียกใช้ชุดการสร้าง + ทดสอบข้ามคืน

เวลาในการรวบรวมที่ยาวนานเป็นปัญหาบางครั้ง แต่การแยกส่วนที่กล่าวมาแล้วสามารถช่วยเอาชนะได้ (ส่วนใหญ่)

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

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

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

ฉันจำได้ง่ายเมื่องานสร้างใช้เวลานาน วิธีการบรรเทาผลกระทบบางอย่าง:

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

10+ นาทีสำหรับการรวบรวม? อย่างจริงจัง?

คุณใช้ IDE ที่สร้างสิ่งปลูกสร้างเพิ่มเติม (เช่น Eclipse) หรือไม่? ถ้าไม่เช่นนั้นคุณควรจะเป็นมันจะทำการคอมไพล์พื้นฐานในไม่กี่วินาทีแทนที่จะเป็นนาที

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

ข้อแรกทำไมใช้เวลารวบรวมนานตั้งแต่แรก

• สภาพแวดล้อมของคุณ (IDE, ทำ, อะไรก็ตาม) สนับสนุนการสร้างที่เพิ่มขึ้นหรือไม่? ตรวจสอบให้แน่ใจว่าคุณกำลังคอมไพล์การเปลี่ยนแปลงใหม่เท่านั้นไม่ใช่ทั้งหมด
• หากคุณมีเครื่องมัลติคอร์ IDE ของคุณอาจรองรับการคอมไพล์แบบขนาน ฉันรู้สำหรับข้อเท็จจริงที่ว่า Visual Studio ทำเช่นนั้น เห็นได้ชัดว่า gcc เพื่อให้ได้เครื่องจักรที่ดีขึ้นและเปิดใช้งานการคอมไพล์แบบขนาน
• พิจารณาใช้ส่วนหัว precompiled
• หากคุณลองทั้งหมดและการรวบรวมยังช้าให้ตรวจสอบรหัสของคุณ มองหาการพึ่งพาที่ไม่จำเป็น คุณรวมส่วนหัวที่มีการประกาศล่วงหน้าเพียงพอหรือไม่ พิจารณาใช้สำนวน PIMPL เพื่อลดการพึ่งพาส่วนหัว

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

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

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

คุณอาจต้องใช้วิธีการหลายง่าม:

1) ระบบสร้างได้เร็วขึ้น แกน / RAM / ดิสก์จำนวนมากเท่าที่คุณสามารถจ่ายได้ สำหรับโครงการ C ++ ที่มีขนาดใหญ่กว่าคุณจะพบว่าดิสก์นั้นมักจะเป็นตัว จำกัด จำนวน

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

3) บิวด์ส่วนเพิ่ม / กระจายบิลด์ / แคชตามความเหมาะสมกับสภาพแวดล้อมของคุณ ในบางระบบ distcc (อาคารแบบกระจาย) และ ccache (การแคชของสิ่งที่สร้างขึ้นบางส่วน) สามารถประหยัดเวลาในการรวบรวมได้มาก

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

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

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

@sbi และ @Michael Kohne พูดว่าอะไร

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

การเปลี่ยนเครื่องมือสร้างทำให้มันลดลงมากขึ้น สำหรับโครงการที่มีหลายส่วน 'scons' สามารถทำคอมไพล์ได้ทั้งหมดก่อนทำการเชื่อมโยงใด ๆ 'make' โดยใช้หลาย makefiles ทำการคอมไพล์ของหนึ่งโครงการก่อนที่ลิงก์ของโครงการนั้นจะย้ายไป

นั่นนำเรามาถึงจุดที่คำสั่งการคอมไพล์แต่ละรายการสามารถทำขนานกันอย่างหนาแน่น 'distcc' บนเครื่องที่ช้าให้สร้าง / scons -j8 บนเครื่องที่มัลติคอร์ สิ่งนี้ทำให้งานสร้างเต็มไปจนถึงไม่กี่นาที

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