เครื่องจำลองระบบคอมพิวเตอร์: เครื่องจำลองแบบเต็มแพลตฟอร์มที่คุ้นเคยและไม่รู้จักตามเข็มนาฬิกาและร่องรอย

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

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

เกมจำลองแพลตฟอร์มเต็มรูปแบบ หรือ “คนเดียวในสนามไม่ใช่นักรบ”

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

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

ด้านล่างนี้เป็นบล็อกไดอะแกรมของชิปเซ็ต x58 จาก Intel เครื่องจำลองคอมพิวเตอร์แพลตฟอร์มเต็มรูปแบบบนชิปเซ็ตนี้จำเป็นต้องมีการใช้งานอุปกรณ์ส่วนใหญ่ที่อยู่ในรายการ รวมถึงอุปกรณ์ที่อยู่ใน IOH (Input/Output Hub) และ ICH (Input/Output Controller Hub) ซึ่งไม่ได้แสดงรายละเอียดไว้ในแผนภาพบล็อก . แม้ว่าตามแนวทางปฏิบัติจะแสดงว่ามีอุปกรณ์ไม่มากนักที่ซอฟต์แวร์ที่เราจะใช้งานไม่ได้ ไม่จำเป็นต้องสร้างรุ่นของอุปกรณ์ดังกล่าว

ส่วนใหญ่แล้ว เครื่องจำลองแบบเต็มแพลตฟอร์มจะถูกนำไปใช้ในระดับคำสั่งของโปรเซสเซอร์ (ISA ดูด้านล่าง) บทความก่อนหน้านี้). สิ่งนี้ช่วยให้คุณสร้างตัวจำลองได้ค่อนข้างรวดเร็วและราคาไม่แพง ระดับ ISA ก็ดีเช่นกัน เนื่องจากยังคงไม่มากก็น้อย ไม่เหมือนเช่น ระดับ API/ABI ซึ่งเปลี่ยนแปลงบ่อยกว่า เป็นต้น นอกจากนี้ การใช้งานในระดับคำสั่งยังช่วยให้คุณสามารถเรียกใช้ซอฟต์แวร์ไบนารี่ที่ไม่มีการแก้ไข ซึ่งก็คือ เรียกใช้โค้ดที่คอมไพล์แล้วโดยไม่มีการเปลี่ยนแปลงใดๆ เหมือนกับที่ใช้กับฮาร์ดแวร์จริง กล่าวอีกนัยหนึ่ง คุณสามารถสร้างสำเนา (“ดัมพ์”) ฮาร์ดไดรฟ์ของคุณ ระบุว่าเป็นรูปภาพสำหรับโมเดลในโปรแกรมจำลองแบบเต็มแพลตฟอร์ม และ voila! – โหลดระบบปฏิบัติการและโปรแกรมอื่นๆ ในเครื่องจำลองโดยไม่มีการดำเนินการใดๆ เพิ่มเติม

ประสิทธิภาพของเครื่องจำลอง

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

ในที่นี้ เป็นการเหมาะสมที่จะกล่าวถึงหัวข้อประสิทธิภาพของเครื่องจำลอง โดยปกติจะวัดเป็น IPS (คำแนะนำต่อวินาที) หรือแม่นยำยิ่งขึ้นใน MIPS (ล้าน IPS) นั่นคือจำนวนคำสั่งโปรเซสเซอร์ที่ดำเนินการโดยเครื่องจำลองในหนึ่งวินาที ในเวลาเดียวกัน ความเร็วของการจำลองยังขึ้นอยู่กับประสิทธิภาพของระบบที่ตัวจำลองทำงานด้วย ดังนั้นจึงอาจถูกต้องกว่าหากพูดถึง "การชะลอตัว" ของเครื่องจำลองเมื่อเปรียบเทียบกับระบบดั้งเดิม

เครื่องจำลองแพลตฟอร์มเต็มรูปแบบที่พบมากที่สุดในตลาด เช่น QEMU, VirtualBox หรือ VmWare Workstation มีประสิทธิภาพที่ดี ผู้ใช้อาจไม่สังเกตเห็นด้วยซ้ำว่างานที่กำลังเกิดขึ้นในเครื่องจำลอง สิ่งนี้เกิดขึ้นได้ด้วยความสามารถพิเศษในการจำลองเสมือนที่ใช้ในโปรเซสเซอร์ อัลกอริธึมการแปลแบบไบนารี่ และสิ่งที่น่าสนใจอื่น ๆ ทั้งหมดนี้เป็นหัวข้อสำหรับบทความแยกต่างหาก แต่โดยสรุป การจำลองเสมือนเป็นคุณลักษณะด้านฮาร์ดแวร์ของโปรเซสเซอร์สมัยใหม่ที่ช่วยให้เครื่องจำลองไม่สามารถจำลองคำสั่งได้ แต่สามารถส่งคำสั่งเหล่านั้นเพื่อดำเนินการโดยตรงไปยังโปรเซสเซอร์จริงได้ ถ้าแน่นอนว่าเป็นสถาปัตยกรรมของ เครื่องจำลองและโปรเซสเซอร์มีความคล้ายคลึงกัน การแปลแบบไบนารีคือการแปลรหัสเครื่องของแขกไปเป็นรหัสโฮสต์และการดำเนินการในภายหลังบนโปรเซสเซอร์จริง เป็นผลให้การจำลองช้าลงเพียงเล็กน้อยเท่านั้น 5-10 เท่า และมักจะทำงานด้วยความเร็วเดียวกันกับระบบจริงด้วยซ้ำ แม้ว่าสิ่งนี้จะได้รับอิทธิพลจากหลายปัจจัยก็ตาม ตัวอย่างเช่น หากเราต้องการจำลองระบบที่มีโปรเซสเซอร์หลายสิบตัว ความเร็วจะลดลงหลายสิบเท่าทันที ในทางกลับกัน เครื่องจำลอง เช่น Simics ในเวอร์ชันล่าสุดรองรับฮาร์ดแวร์โฮสต์ที่มีโปรเซสเซอร์หลายตัว และสร้างขนานแกนประมวลผลจำลองเข้ากับแกนประมวลผลจริงของโปรเซสเซอร์จริงได้อย่างมีประสิทธิภาพ

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

กราฟด้านล่างแสดงความเร็วการจำลองโดยประมาณกับรายละเอียดของโมเดล

การจำลองแบบจังหวะต่อจังหวะ

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

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

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

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

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

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

การจำลองตามรอย

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

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

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

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

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

ที่มา: will.com