The Build LogOften micro-optimizati

The Build Log
Often micro-optimizations like the above are less impactful than structural optimizations where you change the algorithm or approach. This was the case with Ninja’s build log.

One part of the Linux kernel build system tracks the commands used to generate outputs. Consider a motivating example: you compile an input foo.c into an output foo.o, and then change the build file such that it should be rebuilt with different compilation flags. For the build system to know that it needs to rebuild the output, it must either note that foo.o depends on the build files themselves (which, depending on the organization of the project, might mean that a change to the build files would cause the entire project to rebuild), or record the commands used to generate each output and compare them for each build.

The kernel (and consequently the Chrome Makefiles and Ninja) takes the latter approach. While building, Ninja writes out a build log that records the full commands used to generate each output.9 Then for each subsequent build, Ninja loads the previous build log and compares the new build’s commands to the build log’s commands to detect changes. This, like loading build files or path canonicalization, was another hot point in profiles.

After making a few smaller optimizations Nico Weber, a prolific contributor to Ninja, implemented a new format for the build log. Rather than recording commands, which are frequently very long and take a lot of time to parse, Ninja instead records a hash of the command. In subsequent builds, Ninja compares the hash of the command that is about to be run to the logged hash. If the two hashes differ, the output is out of date. This approach was very successful. Using hashes reduced the size of the build log dramatically–from 200 MB to less than 2 MB on Mac OS X–and made it over 20 times faster to load.

ผลลัพธ์ (ไทย) 1:

แฟ้มบันทึกการสร้างมักไมโครเหมาะเหมือนข้างต้นมีประสิทธิภาพน้อยกว่าโครงสร้างเหมาะที่คุณเปลี่ยนอัลกอริทึมหรือวิธีการ นี้เป็นกรณีที่ มีการบันทึกโครงสร้างของนินจาส่วนหนึ่งของ Linux kernel สร้างระบบติดตามคำสั่งที่ใช้ในการสร้างผล พิจารณาตัวอย่างที่สร้างแรงจูงใจ: คุณคอมไพล์ foo.c การป้อนข้อมูลลงใน foo.o การแสดงผล และเปลี่ยนแฟ้มสร้างเช่นที่ควรถูกสร้างใหม่ ด้วยธงต่าง ๆ รวบรวม เพื่อให้ระบบสร้างรู้ว่า จะต้องสร้างผลผลิต มันต้อง เป็น foo.o ขึ้นอยู่กับการสร้างแฟ้มตัวเอง (ซึ่ง ขึ้นอยู่กับองค์กรของโครงการ อาจหมายความ ว่า จะทำให้เกิดการเปลี่ยนแปลงโครงสร้างแฟ้มทั้งโครงการเพื่อสร้าง), หรือใช้คำสั่งบันทึกเพื่อสร้างผลลัพธ์แต่ละ และเปรียบเทียบสำหรับแต่ละรุ่นเคอร์เนล (และดังนั้น Makefiles โครเมี่ยม และนินจา) ใช้วิธีหลัง ในขณะที่อาคาร นินจาเขียนออก สร้างบันทึกที่คำสั่งทั้งหมดที่ใช้ในการสร้างแต่ละ output.9 แล้วสำหรับแต่ละรุ่นตามมา นินจาโหลดแฟ้มบันทึกการสร้างก่อนหน้า และเปรียบเทียบคำสั่งคำสั่งสร้างล็อกการเปลี่ยนแปลงสร้างใหม่ นี้ เช่นการโหลดโครงสร้างไฟล์หรือ canonicalization เส้น เป็นจุดร้อนอื่นในส่วนกำหนดค่าหลังจากทำกี่เล็กเหมาะนิโคเวเบอร์ ผู้สนับสนุนที่อุดมสมบูรณ์ไปนินจา ดำเนินการรูปแบบใหม่สำหรับการสร้างแฟ้มบันทึก แทนการบันทึกสั่งงาน ซึ่งยาวมากบ่อยครั้ง และใช้เวลามากของเวลาที่จะแยกวิเคราะห์ นินจาแทนระเบียนแฮของคำสั่ง ใน builds ในภายหลัง นินจาเปรียบเทียบแฮของคำสั่งที่จะเรียกใช้การบันทึกล็อกแฮ ถ้าเรื่องสองแตกต่างกัน ผลลัพธ์จะล้าสมัย วิธีการนี้ประสบความสำเร็จมาก ใช้เรื่องลดขนาดของแฟ้มบันทึกการสร้างอย่างมาก – จาก 200 MB น้อยกว่า 2 mb บน Mac OS X – เรื่อง 20 ครั้งได้เร็วขึ้นในการโหลด

ผลลัพธ์ (ไทย) 2:

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

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

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

หลังจากทำการเพิ่มประสิทธิภาพขนาดเล็กไม่กี่นิโก้เวเบอร์ผู้บริจาคอุดมสมบูรณ์ให้กับนินจาดำเนินการรูปแบบใหม่สำหรับการสร้างบันทึก มากกว่าคำสั่งซึ่งมักจะยาวมากและใช้เวลามากเวลาที่จะแยกการบันทึกนินจาแทนที่จะบันทึกกัญชาของคำสั่ง ในภายหลังสร้างนินจาเปรียบเทียบกัญชาของคำสั่งที่เป็นเรื่องเกี่ยวกับที่จะทำงานกับกัญชาเข้าสู่ระบบ หากทั้งสอง hashes แตกต่างกันออกเป็นออกจากวันที่ วิธีการนี้จะประสบความสำเร็จมาก โดยใช้แฮชลดขนาดของการสร้างบันทึกอย่างมากจาก 200 ล้านบาทเป็นไม่เกิน 2 MB บน Mac OS X และทำให้มันกว่า 20 ครั้งได้เร็วขึ้นในการโหลด

ผลลัพธ์ (ไทย) 3:

สร้างเข้าสู่ระบบการเพิ่มประสิทธิภาพมักจะไมโครเหมือนข้างต้น มีประสิทธิภาพน้อยกว่าโครงสร้างการเพิ่มประสิทธิภาพที่คุณเปลี่ยนวิธีหรือแนวทาง นี้เป็นกรณีที่มีนินจาสร้างบันทึกส่วนหนึ่งของลินุกซ์สร้างระบบติดตามคำสั่งที่ใช้ในการสร้างผลผลิต พิจารณาการสร้างแรงจูงใจเช่นคุณรวบรวมใส่ฟู C เป็น output ฟู โอ แล้ว เปลี่ยนการสร้างแฟ้มดังกล่าวว่าควรสร้างขึ้นมาใหม่ด้วยการรวบรวมธงที่แตกต่างกัน เพื่อสร้างระบบที่รู้ว่าจะต้องสร้างผลผลิต ก็ต้องทราบว่า ฟู โอ ขึ้นอยู่กับการสร้างไฟล์เอง ( ซึ่งขึ้นอยู่กับองค์กรของโครงการ อาจจะหมายถึงว่า การเปลี่ยนแปลงที่จะสร้างไฟล์จะทำให้โครงการทั้งหมดเพื่อสร้างใหม่ ) หรือบันทึกคำสั่งที่ใช้สร้าง แต่ละผลลัพธ์และเปรียบเทียบพวกเขากับแต่ละสร้างเคอร์เนล ( และจากนั้น Chrome makefiles และนินจา ) ใช้แนวทางหลัง . ในขณะที่อาคาร นินจาเขียนออกสร้าง log ที่บันทึกเต็มรูปแบบคำสั่งที่ใช้สร้างแต่ละผลผลิต ที่ 9 แล้วสำหรับแต่ละที่ตามมาสร้างนินจาโหลดก่อนหน้านี้สร้างเข้าสู่ระบบและเปรียบเทียบใหม่สร้างคำสั่งเพื่อสร้างเข้าสู่ระบบของคำสั่งเพื่อตรวจสอบการเปลี่ยนแปลง นี้ชอบโหลดสร้างไฟล์หรือ canonicalization เส้นทางอีกจุดร้อนในโปรไฟล์หลังจากไม่กี่ขนาดเล็กเพิ่มประสิทธิภาพนิโก้ เวเบอร์ , ผู้สนับสนุน prolific นินจาที่ใช้รูปแบบใหม่เพื่อสร้างบันทึก แทนที่จะสั่งบันทึกซึ่งมักจะยาวมากและใช้เวลามากเวลาที่จะแยกนินจาสับแทนประวัติของคำสั่ง ในที่ตามมาสร้างนินจาเทียบกับ hash ของคำสั่งที่กำลังจะวิ่งไปเข้าแฮก ถ้าทั้งสอง hashes แตกต่าง การแสดงผลเป็นออกจากวันที่ วิธีการนี้ประสบความสำเร็จมาก ใช้ hashes ลดขนาดของสร้างเข้าสู่ระบบอย่างรวดเร็ว– 200 MB ไม่เกิน 2 MB บน Mac OS X ) และทำ 20 กว่าครั้งได้เร็วขึ้นโหลด