วิธีการกำหนดจำนวนสูงสุดที่จะผ่านไปยังตัวเลือก -j?

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

เอาต์พุตของnprocเทียบเท่ากับจำนวนเธรดที่ฉันมีให้คอมไพล์ด้วยหรือไม่?

make -j1 make -j16

nprocให้จำนวนคอร์ / เธรด CPU ที่พร้อมใช้งานเช่น 8 บน CPU แบบ quad-core ที่รองรับ SMT แบบสองทาง

จำนวนงานที่คุณสามารถรันพร้อมกันmakeโดยใช้-jตัวเลือกขึ้นอยู่กับปัจจัยหลายประการ:

• จำนวนหน่วยความจำที่มีอยู่
• จำนวนหน่วยความจำที่ใช้โดยแต่ละmakeงาน
• ขอบเขตของmakeงานที่เป็น I / O- หรือ CPU-bound

make -j$(nproc) เป็นจุดเริ่มต้นที่ดี แต่โดยปกติคุณสามารถใช้ค่าที่สูงขึ้นได้ตราบใดที่คุณไม่ได้ใช้หน่วยความจำที่เหลืออยู่

สำหรับการสร้างที่รวดเร็วจริง ๆ ถ้าคุณมีหน่วยความจำเพียงพอฉันขอแนะนำให้ใช้ a tmpfsวิธีที่งานส่วนใหญ่จะทำงานกับ CPU และmake -j$(nproc)จะทำงานเร็วที่สุด

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

การคอมไพล์ไฟล์เล็ก ๆ 100 ไฟล์อาจเร็วกว่าการคอมไพล์ไฟล์ขนาดใหญ่เพียงไฟล์เดียวหรือ viceversa การสร้างรหัสที่มีความซับซ้อนสูงขนาดเล็กอาจช้ากว่าการสร้างรหัสตรง / เส้นตรงจำนวนมาก

แม้แต่บริบทของการสร้าง - การใช้ปัจจัย aj ที่ปรับให้เหมาะกับการสร้างบนเซิร์ฟเวอร์เฉพาะที่ปรับการปรับแต่งสำหรับงานสร้างที่ไม่ซ้ำซ้อนอาจให้ผลลัพธ์ที่น่าผิดหวังมากเมื่อใช้งานโดยนักพัฒนาที่สร้างแบบขนานบนเซิร์ฟเวอร์ที่ใช้ร่วมกันเดียวกัน เวลากว่าทั้งหมดรวมกันหากต่อเนื่อง) หรือบนเซิร์ฟเวอร์ที่มีการกำหนดค่าฮาร์ดแวร์ที่แตกต่างกันหรือเสมือนจริง

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

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

อาจเป็นความคิดที่ดีที่จะวัดการสร้างที่เหมือนกันหลาย ๆ อย่างในบริบทที่เหมือนกันที่คาดคะเนเพียงเพื่อให้ได้แนวคิดเกี่ยวกับความแปรปรวนของการวัดของคุณ - หากสูงเกินไปอาจทำให้เกิดความพยายามเพิ่มประสิทธิภาพทั้งหมด (ความแปรปรวน 20% การอ่านค่าเสื่อมในการค้นหาตัวประกอบ j)

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

วิธีที่ตรงไปตรงมาที่สุดคือการใช้nprocเช่น:

make -j`nproc`

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

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

หากต้องการทำเช่นนี้nproc+1ให้ลอง:

make -j$((`nproc`+1))

หากคุณต้องการเขียนmakeคำสั่งเพื่อใช้ตัวทำงานแบบขนานมากเท่าที่คุณมี CPU เสมือนฉันขอแนะนำให้ใช้:

nproc | xargs -I % make -j%

ซึ่งสามารถเขียนเป็นคำสั่งแบบสแตนด์อโลนหรือเป็นRUNคำสั่งภายในDockerfile(เนื่องจากนักเทียบท่าไม่รองรับคำสั่งแบบซ้อน)