ฉันจะทำให้ Windows ทำงานเร็วเท่ากับ Linux สำหรับการคอมไพล์ C ++ ได้อย่างไร

ฉันรู้ว่านี่ไม่ใช่คำถามการเขียนโปรแกรม แต่มีความเกี่ยวข้อง

ผมทำงานในธรรมโครงการแพลตฟอร์มขนาดใหญ่ข้าม ใน Windows ฉันใช้ VC ++ 2008 บน Linux ฉันใช้ gcc มีไฟล์ประมาณ 40k ในโครงการ Windows ช้ากว่า Linux 10 เท่าถึง 10 เท่าในการคอมไพล์และเชื่อมโยงโครงการเดียวกัน ฉันจะแก้ไขได้อย่างไร

การเปลี่ยนแปลงที่เพิ่มขึ้นครั้งเดียวสร้าง 20 วินาทีบน Linux และ> 3 นาทีบน Windows ทำไม? ฉันยังสามารถติดตั้งตัวเชื่อมโยง 'gold' ใน Linux และลดเวลาลงเหลือ 7 วินาที

git ในทำนองเดียวกันนั้นเร็วกว่า 10x ถึง 40x บน Linux มากกว่า Windows

ในกรณี git เป็นไปได้ที่ git ไม่ได้ใช้ Windows อย่างเหมาะสม แต่เป็น VC ++? คุณคิดว่า Microsoft ต้องการทำให้นักพัฒนาซอฟต์แวร์ของตัวเองมีประสิทธิภาพมากที่สุดเท่าที่จะเป็นไปได้และการคอมไพล์ที่เร็วขึ้นจะไปไกลกว่านั้น บางทีพวกเขากำลังพยายามกระตุ้นให้นักพัฒนาเข้าสู่ C #?

ในการทดสอบอย่างง่ายค้นหาโฟลเดอร์ที่มีโฟลเดอร์ย่อยมากมายและทำแบบง่าย

dir /s > c:\list.txt

บน Windows ทำสองครั้งและเวลาครั้งที่สองเพื่อเรียกใช้จากแคช คัดลอกไฟล์ไปยัง Linux และดำเนินการเทียบเท่า 2 และเวลาที่เรียกใช้ครั้งที่สอง

ls -R > /tmp/list.txt

ฉันมีเวิร์คสเตชั่ 2 เครื่องพร้อมสเปคเดียวกัน HP Z600s พร้อม ram 12gig, 8 cores ที่ 3.0ghz ในโฟลเดอร์ที่มีไฟล์ ~ 400k Windows ใช้เวลา 40 วินาทีลินุกซ์ใช้เวลา <1 วินาที

มีการตั้งค่ารีจิสทรีที่ฉันสามารถตั้งค่าให้เร่งความเร็ว Windows ได้หรือไม่ สิ่งที่ช่วยให้?

ลิงก์ที่เกี่ยวข้องเพียงเล็กน้อยเล็กน้อยซึ่งเกี่ยวข้องกับการรวบรวมเวลาไม่จำเป็นต้องเป็น i / o

• เห็นได้ชัดว่ามีปัญหาใน Windows 10 (ไม่อยู่ใน Windows 7) ที่ปิดกระบวนการที่ถือล็อคทั่วโลก เมื่อทำการคอมไพล์ด้วยหลายคอร์ดังนั้นจึงมีหลายขั้นตอนที่ทำให้เกิดปัญหานี้

• /analyseตัวเลือกที่สามารถส่งผลกระทบ perf เพราะมันโหลดเว็บเบราเซอร์ (ไม่เกี่ยวข้องที่นี่ แต่รู้ดี)

ถ้าแฮ็กเกอร์ระบบ Windows ไม่ยอมใครง่ายๆเข้ามาคุณจะไม่ได้รับมากกว่าความเห็นที่เข้าข้าง (ซึ่งฉันจะไม่ทำ) และการเก็งกำไร (ซึ่งเป็นสิ่งที่ฉันจะลอง)

1. ระบบไฟล์ - คุณควรลองการทำงานแบบเดียวกัน (รวมถึงdir) บนระบบไฟล์เดียวกัน ฉันเจอสิ่งนี้ซึ่งเปรียบเทียบระบบไฟล์ไม่กี่ตัวสำหรับพารามิเตอร์ต่างๆ

2. เก็บเอาไว้. ฉันเคยพยายามคอมไพล์บน Linux บน RAM disk และพบว่ามันช้ากว่าการรันบนดิสก์ด้วยวิธีที่เคอร์เนลดูแลการแคช นี่เป็นจุดขายที่มั่นคงสำหรับ Linux และอาจเป็นสาเหตุที่ทำให้ประสิทธิภาพแตกต่างกันมาก

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

ความคิดบางอย่าง:

1. ปิดใช้งาน 8.3 ชื่อ นี่อาจเป็นปัจจัยใหญ่ในไดรฟ์ที่มีไฟล์จำนวนมากและมีโฟลเดอร์จำนวนน้อย:fsutil behavior set disable8dot3 1
2. ใช้โฟลเดอร์เพิ่มเติม จากประสบการณ์ของฉัน NTFS เริ่มทำงานช้าลงด้วยไฟล์มากกว่า 1,000 ไฟล์ต่อโฟลเดอร์
3. เปิดใช้งานบิลด์ขนานด้วย MSBuild เพียงเพิ่มสวิตช์ "/ m" และจะเริ่มต้นหนึ่งสำเนาของ MSBuild ต่อซีพียูคอร์โดยอัตโนมัติ
4. วางไฟล์ของคุณไว้ใน SSD - ช่วยสุ่ม I / O อย่างมหาศาล
5. หากขนาดไฟล์เฉลี่ยของคุณมากกว่า 4KB ให้ลองสร้างระบบไฟล์ใหม่ด้วยขนาดคลัสเตอร์ที่ใหญ่กว่าซึ่งสอดคล้องกับขนาดไฟล์โดยเฉลี่ยของคุณ
6. ตรวจสอบให้แน่ใจว่าไฟล์ถูกจัดระเบียบแล้ว ไฟล์ที่กระจัดกระจายทำให้เกิดการค้นหาดิสก์จำนวนมากซึ่งอาจทำให้คุณมีค่าใช้จ่ายมากกว่า 40+ ในการรับส่งข้อมูล ใช้ยูทิลิตี "contig" จาก sysinternals หรือตัวจัดเรียงข้อมูล Windows ในตัว
7. หากขนาดไฟล์เฉลี่ยของคุณมีขนาดเล็กและพาร์ติชันที่คุณใช้อยู่เต็มค่อนข้างเป็นไปได้ว่าคุณกำลังเรียกใช้ด้วย MFT ที่กระจัดกระจายซึ่งไม่ดีต่อประสิทธิภาพ นอกจากนี้ไฟล์ที่มีขนาดเล็กกว่า 1K จะถูกจัดเก็บโดยตรงใน MFT ยูทิลิตี้ "contig" ที่กล่าวถึงข้างต้นสามารถช่วยได้หรือคุณอาจต้องเพิ่มขนาด MFT คำสั่งต่อไปนี้จะเพิ่มเป็นสองเท่าเป็น 25% ของโวลุ่ม: fsutil behavior set mftzone 2เปลี่ยนหมายเลขสุดท้ายเป็น 3 หรือ 4 เพื่อเพิ่มขนาดโดยการเพิ่มทีละ 12.5% ​​เพิ่มเติม หลังจากรันคำสั่งแล้วให้รีบู๊ตแล้วสร้างระบบไฟล์
8. ปิดการใช้งานเวลาเข้าถึงล่าสุด: fsutil behavior set disablelastaccess 1
9. ปิดใช้งานบริการจัดทำดัชนี
10. ปิดใช้งานซอฟต์แวร์ป้องกันไวรัสและป้องกันสปายแวร์หรืออย่างน้อยให้ตั้งค่าโฟลเดอร์ที่เกี่ยวข้องที่จะถูกละเว้น
11. วางไฟล์ของคุณในฟิสิคัลไดรฟ์อื่นจากระบบปฏิบัติการและไฟล์เพจจิ้ง การใช้ฟิสิคัลไดรฟ์แยกต่างหากช่วยให้ Windows ใช้ I / O แบบขนานกับไดรฟ์ทั้งสอง
12. ดูธงคอมไพเลอร์ของคุณ คอมไพเลอร์ Windows C ++ มีตัวเลือกมากมาย ตรวจสอบให้แน่ใจว่าคุณใช้สิ่งที่คุณต้องการจริงๆเท่านั้น
13. ลองเพิ่มจำนวนหน่วยความจำที่ระบบปฏิบัติการใช้สำหรับบัฟเฟอร์เพจพูล (ตรวจสอบว่าคุณมี RAM เพียงพอก่อน): fsutil behavior set memoryusage 2
14. ตรวจสอบบันทึกข้อผิดพลาดของ Windows เพื่อให้แน่ใจว่าคุณไม่ได้พบข้อผิดพลาดของดิสก์เป็นครั้งคราว
15. ดูเคาน์เตอร์ผลการทำงานที่เกี่ยวข้องกับดิสก์ทางกายภาพเพื่อดูว่าดิสก์ของคุณยุ่งแค่ไหน ความยาวคิวสูงหรือนานต่อการถ่ายโอนเป็นสัญญาณที่ไม่ดี
16. 30% แรกของพาร์ติชั่นดิสก์นั้นเร็วกว่าดิสก์อื่นในแง่ของเวลาในการถ่ายโอนข้อมูลดิบ พาร์ติชันที่แคบลงยังช่วยลดเวลาในการค้นหา
17. คุณใช้ RAID หรือไม่ ถ้าเป็นเช่นนั้นคุณอาจต้องปรับแต่งประเภท RAID ของคุณให้เหมาะสม (RAID-5 ไม่ดีต่อการเขียนที่หนักหน่วงเช่นการคอมไพล์)
18. ปิดใช้งานบริการใด ๆ ที่คุณไม่ต้องการ
19. จัดเรียงข้อมูลโฟลเดอร์: คัดลอกไฟล์ทั้งหมดไปยังไดรฟ์อื่น (เพียงแค่ไฟล์) ลบไฟล์ต้นฉบับคัดลอกโฟลเดอร์ทั้งหมดไปยังไดรฟ์อื่น (เพียงแค่โฟลเดอร์ว่าง) จากนั้นลบโฟลเดอร์เดิมจัดเรียงไดรฟ์เดิมคัดลอกโครงสร้างโฟลเดอร์ก่อน จากนั้นคัดลอกไฟล์ เมื่อ Windows สร้างโฟลเดอร์ขนาดใหญ่ทีละไฟล์โฟลเดอร์จะถูกแยกส่วนและช้า ("contig" ควรช่วยที่นี่ด้วย)
20. หากคุณเป็น I / O ที่ถูกผูกไว้และมีรอบการทำงานของ CPU ว่างให้ลองเปิดการบีบอัดดิสก์ มันสามารถให้การเร่งความเร็วที่สำคัญสำหรับไฟล์ที่บีบอัดได้สูง (เช่นซอร์สโค้ด) โดยมีค่าใช้จ่ายใน CPU

NTFS ช่วยประหยัดเวลาในการเข้าถึงไฟล์ทุกครั้ง คุณสามารถลองปิดการใช้งาน: "ชุดพฤติกรรม fsutil disablelastaccess 1" (รีสตาร์ท)

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

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

โดยส่วนตัวแล้วฉันพบว่าการใช้งานเครื่องเสมือน windows บน linux นั้นจัดการเพื่อลบความเชื่องช้าของ IO ใน windows ได้อย่างมากน่าจะเป็นเพราะ linux vm ทำการแคชจำนวนมากซึ่ง Windows เองไม่ได้ใช้

การทำเช่นนั้นฉันสามารถเร่งความเร็วเวลาในการรวบรวมโครงการ C ++ ขนาดใหญ่ (250Kloc) ที่ฉันทำงานจาก 15 นาทีถึง 6 นาที

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

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

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

1. เข้าถึงซอร์สโค้ด

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

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

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

2. ระบบปฏิบัติการยูนิกซ์มีแนวโน้มไปสู่ไฟล์ขนาดเล็กจำนวนมาก Windows มักจะมีไฟล์ขนาดใหญ่จำนวนน้อย (หรือไฟล์เดียว)

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

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

   แอปพลิเคชัน Windows มักจะเปิดไฟล์ขนาดใหญ่หนึ่งไฟล์ค้างไว้เปิดเป็นเวลานานปิดเมื่อดำเนินการเสร็จ คิดถึง MS-Word msword.exe (หรืออะไรก็ตาม) จะเปิดไฟล์หนึ่งครั้งและผนวกเป็นชั่วโมงปรับปรุงบล็อกภายในและอื่น ๆ ค่าของการเพิ่มประสิทธิภาพการเปิดไฟล์จะเสียเวลา

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

   การพัฒนาซอฟต์แวร์น่าเศร้ามีแนวโน้มต่อสถานการณ์แรก Heck ระบบประมวลผลคำที่ดีที่สุดสำหรับ Unix (TeX / LaTeX) สนับสนุนให้คุณใส่แต่ละบทในไฟล์ที่แตกต่างกันและ # รวมพวกเขาทั้งหมดเข้าด้วยกัน

3. Unix มุ่งเน้นไปที่ประสิทธิภาพสูง Windows เน้นประสบการณ์ของผู้ใช้

   Unix เริ่มทำงานในห้องเซิร์ฟเวอร์: ไม่มีส่วนต่อประสานผู้ใช้ สิ่งเดียวที่ผู้ใช้เห็นคือความเร็ว ดังนั้นความเร็วจึงมีความสำคัญ

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

4. ระบบนิเวศของ Windows ขึ้นอยู่กับความล้าสมัยตามแผน ทำไมจึงต้องปรับซอฟต์แวร์ให้เหมาะสมเมื่อฮาร์ดแวร์ใหม่เพิ่งออกไปปีหรือสองปี?

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

   นอกจากนี้เนื่องจาก Unix เป็นโอเพ่นซอร์ส (แม้ว่าจะไม่ใช่ก็ตามทุกคนสามารถเข้าถึงแหล่งข้อมูลได้) นักศึกษาปริญญาเอกที่เบื่อหน่ายทุกคนสามารถอ่านรหัสและมีชื่อเสียงได้ด้วยการทำให้ดีขึ้น สิ่งนั้นไม่ได้เกิดขึ้นใน Windows (MS มีโปรแกรมที่ให้นักวิชาการสามารถเข้าถึงซอร์สโค้ดของ Windows ได้ซึ่งไม่ค่อยได้รับประโยชน์จาก) ดูเอกสารด้านประสิทธิภาพที่เกี่ยวข้องกับ Unix ตัวเลือกนี้: http://www.eecs.harvard.edu/margo/papers/หรือค้นหาประวัติของเอกสารโดย Osterhaus, Henry Spencer หรืออื่น ๆ Heck หนึ่งในการโต้วาทีที่ใหญ่ที่สุด (และสนุกที่สุดในการดู) ในประวัติศาสตร์ Unix คือการกลับไปกลับมาระหว่าง Osterhaus และ Selzer http://www.eecs.harvard.edu/margo/papers/usenix95-lfs/supplement/rebuttal HTML คุณไม่เห็นสิ่งนั้นเกิดขึ้นในโลกของ Windows คุณอาจเห็นผู้ขายที่รวมกันเป็นหนึ่งเดียว แต่ดูเหมือนว่าจะหายากมากขึ้นเมื่อเร็ว ๆ นี้เนื่องจากนวัตกรรมดูเหมือนว่าจะอยู่ในระดับมาตรฐานของร่างกาย

นั่นคือวิธีที่ฉันเห็น

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

การเชื่อมโยงที่เพิ่มขึ้น

หากโซลูชัน VC 2008 ถูกตั้งค่าเป็นหลายโครงการที่มีเอาต์พุต. lib คุณจะต้องตั้งค่า "ใช้อินพุตไลบรารีพึ่งพา"; สิ่งนี้ทำให้ linker เชื่อมโยงโดยตรงกับไฟล์. obj แทนที่จะเป็น. lib (และทำให้ลิงก์เพิ่มขึ้นจริง ๆ )

ประสิทธิภาพการสำรวจเส้นทางของไดเรกทอรี

ค่อนข้างไม่ยุติธรรมเลยที่จะเปรียบเทียบการรวบรวมข้อมูลไดเรกทอรีในเครื่องเดิมด้วยการรวบรวมข้อมูลไดเรกทอรีที่สร้างขึ้นใหม่ด้วยไฟล์เดียวกันในเครื่องอื่น หากคุณต้องการการทดสอบที่เทียบเท่าคุณควรทำสำเนาของไดเรกทอรีบนเครื่องต้นทางอีกครั้ง (อาจยังช้า แต่อาจเกิดจากหลายสิ่งหลายอย่าง: การแตกแฟรกเมนต์, ชื่อไฟล์แบบสั้น, บริการพื้นหลังและอื่น ๆ ) แม้ว่าฉันคิดว่าประเด็นที่สมบูรณ์แบบสำหรับdir /sมีส่วนเกี่ยวข้องกับการเขียนเอาต์พุตมากกว่าการวัดไฟล์จริง ประสิทธิภาพการสำรวจเส้นทาง แม้dir /s /b > nulในเครื่องของฉันจะช้าด้วยไดเรกทอรีขนาดใหญ่

ฉันค่อนข้างแน่ใจว่ามันเกี่ยวข้องกับระบบไฟล์ ฉันทำงานในโครงการข้ามแพลตฟอร์มสำหรับ Linux และ Windows ที่รหัสทั้งหมดเป็นเรื่องธรรมดายกเว้นที่รหัสขึ้นอยู่กับแพลตฟอร์มเป็นสิ่งจำเป็นอย่างยิ่ง เราใช้ Mercurial ไม่ใช่ git ดังนั้น "Linuxness" ของ git จึงไม่มีผล การดึงการเปลี่ยนแปลงจากพื้นที่เก็บข้อมูลส่วนกลางใช้เวลาตลอดไปบน Windows เมื่อเทียบกับ Linux แต่ฉันต้องบอกว่าเครื่อง Windows 7 ของเราทำได้ดีกว่า Windows XP มาก การคอมไพล์โค้ดหลังจากนั้นแย่ยิ่งกว่า VS 2008 ไม่ใช่แค่ hg; CMake ทำงานช้าลงมากบน Windows เช่นกันและเครื่องมือทั้งสองนี้ใช้ระบบไฟล์มากกว่าสิ่งอื่นใด

ปัญหาแย่มากที่นักพัฒนาส่วนใหญ่ของเราที่ทำงานในสภาพแวดล้อม Windows ไม่ต้องกังวลกับการสร้างที่เพิ่มขึ้นอีกต่อไป - พวกเขาพบว่าการสร้างสามัคคีสร้างขึ้นมาเร็วกว่า

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

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

ฉันเพิ่งแก้ไข makefiles ของโครงการข้ามแพลตฟอร์มโดยใช้ makefiles ทั่วไป (GNU) สำหรับ Linux และ Windows Make กำลังเริ่มต้นsh.exeกระบวนการสำหรับแต่ละสูตรที่ทำให้เกิดความแตกต่างระหว่าง Windows และ Linux!

ตามที่ GNU ทำเอกสาร

.ONESHELL:

ควรแก้ปัญหา แต่คุณลักษณะนี้ (ปัจจุบัน) ไม่รองรับ Windows ทำ ดังนั้นการเขียนสูตรใหม่ให้อยู่บนบรรทัดตรรกะเดี่ยว (เช่นโดยการเพิ่ม; \ หรือ \ ที่ส่วนท้ายของบรรทัดการแก้ไขปัจจุบัน) ทำงานได้ดีมาก!

IMHO นี่คือทั้งหมดที่เกี่ยวกับประสิทธิภาพของดิสก์ I / O ลำดับความสำคัญแสดงให้เห็นการดำเนินการจำนวนมากไปที่ดิสก์ใน Windows ในขณะที่พวกเขาจัดการในหน่วยความจำภายใต้ Linux เช่น Linux จะดีกว่าแคช ตัวเลือกที่ดีที่สุดของคุณภายใต้ windows คือการย้ายไฟล์ของคุณไปยังดิสก์เซิร์ฟเวอร์หรือระบบไฟล์ที่รวดเร็ว พิจารณาซื้อโซลิดสเตตไดรฟ์หรือย้ายไฟล์ของคุณไปยังเซิร์ฟเวอร์ ramdisk หรือ NFS ที่รวดเร็ว

ฉันรันการทดสอบการสำรวจเส้นทางไดเรกทอรีและผลลัพธ์นั้นใกล้เคียงกับเวลารวบรวมที่รายงานซึ่งบอกว่าสิ่งนี้ไม่เกี่ยวกับเวลาประมวลผล CPU หรืออัลกอริธึมคอมไพเลอร์ / ลิงเกอร์เลย

เวลาที่วัดได้ตามที่แนะนำข้างต้นภายในทรีของไดเรกทอรีโครเมียม:

• Windows Home Premium 7 (8GB Ram) ใน NTFS: 32 วินาที
• Ubuntu 11.04 Linux (2GB Ram) บน NTFS: 10 วินาที
• Ubuntu 11.04 Linux (2GB Ram) บน ext4: 0.6 วินาที

สำหรับการทดสอบฉันดึงแหล่งโครเมียม (ทั้งคู่ภายใต้ win / linux)

git clone http://github.com/chromium/chromium.git 
cd chromium
git checkout remotes/origin/trunk 

เพื่อวัดเวลาที่ฉันวิ่ง

ls -lR > ../list.txt ; time ls -lR > ../list.txt # bash
dir -Recurse > ../list.txt ; (measure-command { dir -Recurse > ../list.txt }).TotalSeconds  #Powershell

ฉันปิดการเข้าถึงเครื่องบันทึกเวลาเครื่องสแกนไวรัสของฉันและเพิ่มการตั้งค่าตัวจัดการแคชภายใต้ windows (> RAM 2Gb) โดยไม่ต้องปรับปรุงใด ๆ ความจริงก็คือ Linux ออกประสิทธิภาพได้ดีกว่า Windows ถึง 50 เท่าเมื่อเทียบกับ RAM หนึ่งในสี่

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

ลองใช้ jom แทน nmake

รับได้ที่นี่: https://github.com/qt-labs/jom

ความจริงก็คือว่า nmake ใช้เพียงแกนเดียวของคุณเท่านั้น jom เป็นโคลนของ nmake ที่ใช้ประโยชน์จากตัวประมวลผลแบบมัลติคอร์

GNU ทำสิ่งนั้นออกนอกกรอบด้วยตัวเลือก -j ซึ่งอาจเป็นสาเหตุของความเร็วเทียบกับ Microsoft nmake

jom ทำงานโดยการรันคำสั่ง make ต่างกันแบบขนานบนโปรเซสเซอร์ / คอร์ที่ต่างกัน ลองด้วยตัวเองรู้สึกถึงความแตกต่าง!

ฉันต้องการเพิ่มการสังเกตเพียงครั้งเดียวโดยใช้ Gnu make และเครื่องมืออื่น ๆ จากเครื่องมือ MinGW บน Windows: พวกเขาดูเหมือนจะแก้ไขชื่อโฮสต์ได้แม้ว่าเครื่องมือไม่สามารถสื่อสารผ่าน IP ได้ ฉันเดาว่านี่เกิดจากรูทีนเริ่มต้นบางส่วนของรันไทม์ MinGW การใช้พรอกซี DNS ท้องถิ่นช่วยให้ฉันปรับปรุงความเร็วในการรวบรวมด้วยเครื่องมือเหล่านี้

ก่อนที่ฉันจะปวดหัวขนาดใหญ่เพราะความเร็วในการสร้างลดลง 10 เท่าเมื่อเปิดการเชื่อมต่อ VPN ในแบบคู่ขนาน ในกรณีนี้การค้นหา DNS ทั้งหมดเหล่านี้ผ่าน VPN

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

ฉันเพิ่งจะสามารถเก็บถาวรวิธีอื่นเพื่อเร่งความเร็วในการรวบรวมประมาณ 10% บน Windows โดยใช้ Gnu โดยการแทนที่ mingw bash.exe ด้วยเวอร์ชันจากwin-bash

(win-bash ไม่สะดวกสบายมากเกี่ยวกับการแก้ไขแบบโต้ตอบ)