Os Ch05-Memory Management

บทที่ 5
การจ ัดการหน่วย
ความจำ
(Memory Management)
ระบบปฏิบต
ั ก
ิ าร (Operating Systems) 1
การจ
การจั ดการหน
ั ดการหน่ ว่ วยความจำ
ยความจำ
 การจัดการกับหน่วยความจำ (Memory Management) เป็ น
ปั ญหาที่ยากในการออกแบบระบบปฏิบตั ิการ
 เนื่องจากสมัยก่อนหน่วยความจำมีจำกัด ราคาแพง ความเร็ วไม่
สูงมากนัก
 ถึงแม้ ปัจจุบน
ั ความเร็วและปริ มาณหน่วยความจำมีมากขึ ้นใน
ขณะที่ราคากลับถูกลง
 การจัดการกับหน่วยความจำก็ยงั เป็ นหน้ าที่หนึง
่ ที่สำคัญของ
ระบบปฏิบตั ิการ
ั ก
หน่
หน่ววยความจำหล
ยความจำหลักัก (Main
(Main Memory)
Memory)
 หน่วยความจำหลัก เป็ นศูนย์กลางของการทำงานต่าง ๆ ของระบบ
คอมพิวเตอร์ ในปั จจุบนั
 หน่วยความจำหลัก คือพื ้นที่เก็บข้ อมูลขนาดใหญ่ที่ประกอบไปด้ วย
พื ้นที่เก็บข้ อมูลย่อยที่มีขนาดเป็ นไบต์ (byte) โดยแต่ละไบต์จะมี

แอ็ดเดรส (address) บอกตำแหน่งของตัวเอง
 โปรแกรมเมอร์ ต้องการระบบที่มีหน่วยความจำหลักแบบไม่จำกัด, มี
ความเร็วสูง, และมีความเสถียรสูง หรื อเป็ นแบบไม่ถกู ลบเลือน

(nonvolatile) ถึงแม้ วา่ ระบบไฟฟ้าจะขัดข้ อง ข้ อมูลต่าง ๆ ในหน่วย
ความจำหลักเหล่านันก็ ้ จะไม่สญ ู หายไปด้ วย
ั ก
หน่
(Main Memory)
Memory)
 ระบบคอมพิวเตอร์ ในปั จจุบนั จึงมีการแบ่งหน่วยความจำออกเป็ น
ชัน้ ๆ (memory hierarchy) ได้ ดงั นี ้
 หน่วยความจำขนาดเล็ก, มีความเร็วสูง, ราคาแพงมาก และเป็ น
หน่วยความจำที่เป็ นแบบลบเลือนได้ (volatile cache memory)
 หน่วยความจำขนาดกลาง (ประมาณ 100 กว่าเมกะไบต์ขึ ้นไป), มี
ความเร็วปานกลาง, ราคาปานกลาง และเป็ นหน่วยความจำที่เป็ นแบบ
ลบเลือนได้ (RAM)
 หน่วยความจำขนาดใหญ่ (ประมาณ 10-100 กิกะไบต์) ที่มีความเร็ว
ต่ำ, ราคาถูก, และเป็ นดิสก์เก็บข้ อมูลที่เป็ นแบบไม่ถกู ลบเลือน
ั ก
หน่
(Main Memory)
Memory)
 ส่วนของระบบปฏิบตั ิการที่ใช้ ในการจัดการกับหน่วยความจำของ
ลำดับชันต่
้ าง ๆ จะถูกเรี ยกว่า ตัวจัดการหน่ วยความจำ
(Memory Manager) ซึง่ มีหน้ าที่
 ตรวจสอบว่าส่วนใดของหน่วยความจำที่กำลังถูกใช้ งาน
 ส่วนใดที่วา่ งอยู่
 จัดหน่วยความจำให้ กบั โปรเซสที่ทำงาน
 เก็บหน่วยความจำเหล่านันกลั
้ บคืนสูร่ ะบบเมื่องานเสร็ จ
 จัดการสลับหน่วยความจำหลักกับพื ้นที่ฮาร์ ดดิสก์ เมื่อหน่วยความ
จำหลักมีขนาดเล็กเกินไปที่จะให้ โปรเซสทำงานได้
ั ก
กระบวนการในการจ
กระบวนการในการจั ดการหน
ั ดการหน่ ว่ วยย
ความจำ
ความจำ
 การย้ ายตำแหน่ง (Relocation)
 การป้องกันพื ้นที่ (Protection)
 การใช้ พื ้นที่ร่วมกัน (Sharing)

 การจัดการแบ่งโปรแกรมย่อย (Logical Organization)
 การจัดการแบ่งทางกายภาพ (Physical Organization)
ั ก
การย้
การย้าายตำแหน่
ยตำแหน่งง (Relocation)
(Relocation)
 ในระบบมัลติโปรแกรมมิ่งหรื อระบบที่ทำงานหลาย ๆ โปรแกรม
พร้ อมกันนัน้ โปรเซสต่าง ๆ จะใช้ งานหน่วยความจำหลักร่วมกัน
 ผู้ใช้ งานจะไม่ทราบก่อนว่า ในขณะที่โปรแกรมกำลังทำงานนัน ้ มี
โปรแกรมอื่น ๆ กำลังใช้ งานหน่วยความจำหลักอยูห่ รื อไม่
 เราต้ องการให้ ระบบสามารถสลับโปรแกรมที่ ทำงานเข้ าและออก
(swap in and out) จากหน่วยความจำหลักได้ เพื่อให้ การใช้ งาน

โปรเซสเซอร์ เป็ นไปอย่างมีประสิทธิภาพ
ั ก
การย้
(Relocation)
 เมื่อโปรแกรมถูกดึงออกจากพื ้นที่ไปแล้ ว เป็ นการยากที่จะบอกได้ วา่
ระบบสามารถดึงโปรแกรมนันกลั ้ บเข้ ามาทำงานในพื ้นที่เดิมได้
 เนื่องจากเราไม่ทราบว่าเมื่อโปรแกรมหนึง่ เข้ าไปใช้ หน่วยความจำหลัก
แล้ วจะใช้ พื ้นที่ใด และเราต้ องอนุญาตให้ โปรแกรมสามารถเปลี่ยน
ตำแหน่งภายในหน่วยความจำหลักนี ้ได้ เนื่องจากการสลับที่ (swapin
g)
 เราจึงต้ องสร้ างเทคนิคที่ใช้ ในการจัดการกับปั ญหาดังกล่าวโดยมีการ
กำหนด แอ็ดเดรสของโปรแกรม
ั ก
 จะเห็นว่าระบบปฏิบตั ิการจะต้ องรู้ ตำแหน่งของข้ อมูลตัวควบคุมโปร
เซส (Process Control Information) และตำแหน่งเริ่ มต้ นของ
โปรแกรม ระบบจึงจะสามารถเรี ยกโปรแกรมนันมาทำงานได้
้
ั ก
การย้
(Relocation)
 แต่เนื่องจากระบบปฏิบตั ิการเป็ นตัวจัดการกับหน่วยความจำ และรับ
ผิดชอบในการนำโปรเซสต่าง ๆ เข้ ามาใช้ งานหน่วยความจำ แอ็ดเดรส
ของโปรแกรมจึงสามารถจัดการได้ งา่ ย นอกจากนันหน้ ้ าที่ของ
โปรเซสเซอร์ และโปรแกรมระบบปฏิบตั ิการจะต้ องมีความสามารถใน
การแปลงค่าตำแหน่งในหน่วยความจำที่อ้างถึงในโปรแกรม (referenc
es) ไปเป็ นตำแหน่งจริงในหน่วยความจำหลักได้
ั ก
การย้
(Relocation)
ั ก
การย้
(Relocation)
 แอ็ดเดรสของหน่วยความจำอาจแสดงได้ หลายแบบแตกต่างกัน เช่น
ในโปรแกรมมีตวั แปร a และคอมไพเลอร์ (compiler) แปลตัวแปรนี ้เป็ น
แอ็ดเดรสแบบย้ ายได้ เมื่อทำงาน ตัวโหลดเดอร์ (loader) ก็จะทำ
หน้ าที่แปลงค่าแอ็ดเดรสแบบย้ ายได้ ของตัวแปรนัน้ ไปเป็ นแอ็ดเดรส
จริงทางกายภาพ
 ค่าของแอ็ดเดรสนันจะแบ่
้ งออกเป็ น 2 ค่าคือ
 Absolute Address หรื อแอ็ดเดรสแท้ จริ งของโปรเซสที่อยูใ่ น
พาร์ ติชนั่ ของหน่วยความจำ
 Relative Address หรื อแอ็ดเดรสของคำสัง่ หรื อโปรแกรมของ
โปรเซสหลังจากการคอมไพล์ (โดยมากจะเริ่มต้ นที่ 0)
ั ก
การป
การป้ ้ องกั
องกันนพืพืน้ น้ ทีที่ ่ (Protection)
(Protection)
 ระบบควรมีความสามารถในการป้องกันโปรเซสไม่ให้ ถกู รบกวนจาก
โปรเซสอื่น ๆ
 โปรแกรมในโปรเซสอื่น ๆ ไม่ควรจะเรี ยกใช้ งานในพื ้นที่หน่วยความจำที่
ใช้ โดยโปรเซสหนึง่ ๆ ได้ นอกจากได้ รับอนุญาตโดยโปรเซสนัน้
 เราอาจจะเห็นได้ วา่ การที่ระบบต้ องการความสามารถในการย้ าย
แอ็ดเดรสนันจะทำให้
้ ความสามารถในการป้องกันพื ้นที่ยากขึ ้น
เนื่องจากการหาแอ็ดเดรสของโปรแกรมในหน่วยความจำหลักเมื่อ
ระบบทำการคอมไพล์โปรแกรม (compile-time) นันเป็ ้ นไปได้ ยากมาก
ั ก
การป
(Protection)
 นอกจากนี ้ภาษาของโปรแกรมในปั จจุบนั ส่วนใหญ่จะอนุญาตให้
โปรแกรมสามารถคำนวณหาแอ็ดเดรสในหน่วยความจำได้ เองขณะที่
โปรแกรมกำลังทำงาน (run-time) เช่น การสร้ างตัวแปรอาร์ เรย์แบบมี
ขนาดไม่คงที่
 ดังนันแอ็
้ ดเดรสที่อ้างถึงหน่วยความจำที่ถกู สร้ างโดยโปรเซสใด ๆ จะ
ต้ องถูกตรวจสอบในขณะที่โปรแกรมกำลังทำงาน เพื่อให้ แน่ใจว่า
แอ็ดเดรสที่อ้างถึงนันจะอยู
้ ภ่ ายในพื ้นที่ที่โปรเซสนันได้
้ รับเท่านัน้
ั ก
การป
(Protection)
 โดยปกติแล้ วนัน้ โปรเซสของผู้ใช้ งานนันจะไม่
้ สามารถเข้ าถึงพื ้นที่ของ
ระบบปฏิบตั ิการได้ ทังส่
้ วนที่เป็ นโปรแกรมหรื อข้ อมูล
 โปรแกรมในโปรเซสหนึง่ ๆ ก็ไม่ควรที่จะเรี ยกใช้ คำสัง่ หรื อข้ อมูลที่อยู่
ในโปรเซสอื่น และโปรเซสเซอร์ จะต้ องมีความสามารถในการยกเลิก
คำสัง่ ใดถ้ ามีการละเมิดการป้องกันดังกล่าวในขณะทำงานได้
 จะเห็นได้ วา่ การป้องกันพื ้นที่หน่วยความจำนันจะเป็
้ นหน้ าที่ของ
โปรเซสเซอร์ (ของฮาร์ ดแวร์ ) มากว่าจะเป็ นหน้ าที่ของระบบปฏิบตั ิการ
(ซอฟต์แวร์ )
 เนื่องจากระบบปฏิบต ั ิการไม่สามารถคาดเดาถึงแอ็ดเดรสที่อ้างถึง
ทังหมดของโปรแกรมได้
้
ั ก
การป
(Protection)
 ถึงแม้ วา่ ระบบจะสามารถทำการคาดเดาได้ กระบวนการดังกล่าวก็จะ
กินเวลาในการค้ นหาแอ็ดเดรสที่อ้างถึงของโปรแกรมแต่ละตัวมากเกิน
ไป
 วิธีการที่เป็ นไปได้ ในการตรวจสอบการแอ็กเซสหน่วยความจำของ
แอ็ดเดรสที่อ้างถึงจากโปรแกรม ก็คือเราจะต้ องให้ โปรเซสเซอร์ ที่เป็ น
ส่วนหนึง่ ของฮาร์ ดแวร์ มีความสามารถในการจัดการ
ั ก
การใช้
การใช้พพนื ้ นื ้ ทีที่ ร่ ร่ ว่ วมกั
มกันน (Sharing)
(Sharing)
 กระบวนการในป้องกันพื ้นที่บางครัง้ ต้ องมีการยืดหยุน่ บ้ าง เพื่อให้
โปรเซสหลาย ๆ ตัวมาใช้ พื ้นที่หน่วยความจำเดียวกันได้
 ถ้ ามีโปรเซสกลุม่ หนึง่ กำลังเรี ยกใช้ งานโปรแกรมเดียวกัน จะเป็ นการดี
ถ้ าเราอนุญาตให้ โปรเซสแต่ละตัวได้ เข้ าถึงโปรแกรมส่วนนันได้
้ และดี
กว่าที่จะให้ โปรเซสแต่ละตัวก๊ อบปี แ้ ละเรี ยกใช้ งานโปรแกรมนันแยกกั
้ น
 โปรเซสที่ทำงานร่วมกัน บางงานก็จะต้ องมีการแบ่งปั นข้ อมูลร่วมกันได้

ดังนันระบบการจั
้ ดการหน่วยความจำจะต้ องอนุญาตให้ ตวั ควบคุม
(controller) สามารถเข้ าถึงพื ้นที่สว่ นที่ใช้ งานร่วมกัน้โดยไม่ต้องใช้ วิธี
การป้องกันพื ้นที่
กระบวนการที
ระบบปฏิ บต ิ ่ใช้าร
ั ก ในการย้ ายแอ็Systems)
(Operating ดเดรสนันสนั
้ บสนุนการใช้ พื ้นที่ร่วมกัน 17
การจั
การจัดดการแบ่
การแบ่งงโปรแกรมย่
โปรแกรมย่ออยย
 หน่วยความจำหลักในระบบคอมพิวเตอร์ นนจะถู ั ้ กจัดให้ อยูใ่ นรูปของ
พื ้นที่ 1 มิติ เป็ นเส้ นตรง, มีชอ่ งว่าง และประกอบขึ ้นจากแถวของไบต์
หรื อคำ การจัดการแบบนี ้มีลกั ษณะที่ใกล้ เคียงกับตัวฮาร์ ดแวร์ จริ ง
 สำหรับซอฟต์แวร์ หรื อโปรแกรมนันจะมี ้ การจัดการที่แตกต่างกัน
โปรแกรมโดยส่วนมากจะถูกแบ่งออกเป็ นโมดูล (module) หรื อ
โปรแกรมย่อย ๆ เพื่อให้ สามารถใช้ งานหน่วยความจำได้ อย่างมี
ประสิทธิภาพสูงสุด
 ระบบปฏิบต ั ิการจะไม่นำโปรแกรมย่อยลงสูห่ น่วยความจำพร้ อมกับ
โปรแกรมหลัก แต่จะนำลงเมื่อมีการเรี ยกใช้ เท่านัน้ โดยโปรแกรมย่อย
นันจะถู
้ กบันทึกไว้ ในดิสก์ในรูปแบบที่ย้ายแอ็ดเดรสได้
ั ก
การจั
 เมื่อโปรแกรมต้ องการเรี ยกโปรแกรมย่อยใด ก็จะตรวจดูวา่ โปรแกรม
ย่อยนันอยู
้ ใ่ นหน่วยความจำแล้ วหรื อยัง
 ถ้ ายังก็จะนำโปรแกรมย่อยนันลงสู
้ ห่ น่วยความจำหลัก โดยย้ าย
แอ็ดเดรสไปไว้ ในที่ที่เหมาะสม และย้ ายการควบคุมไปไว้ ที่
โปรแกรมย่อยนัน้
 ถ้ ามีโปรแกรมย่อยนันในหน่
้ วยความจำหลักแล้ ว จะย้ ายการ
ควบคุมไปไว้ ที่โปรแกรมย่อยนันเพื
้ ่อทำงานต่อไป
ั ก
การจั
 ประโยชน์ของวิธีจดั การแบ่งโปรแกรมย่อย
 โปรแกรมย่อยที่ไม่ได้ ใช้ งาน จะไม่ถกู นำลงสูห่ น่วยความจำหลัก ให้ เสียพื ้นที่
เช่น โปรแกรมย่อยที่ไม่คอ่ ยเกิดขึ ้น (โปรแกรมจัดการข้ อผิดพลาดต่าง ๆ)
ทำให้ โปรแกรมหลักที่ใช้ งานจริ งมีขนาดเล็กลงกว่าโปรแกรมทังหมดมาก
้
 โปรแกรมย่อยแต่ละตัวสามารถถูกเขียนและคอมไพล์แยกกันได้ โดยการเชื่อม
โยงโปรแกรมย่อยแต่ละตัวนันเป็ ้ นหน้ าที่ของระบบเมื่อมีการเรี ยกใช้ งาน
 โปรแกรมย่อยแต่ละตัวสามารถมีระดับการป้องกันที่แตกต่างกันได้ เช่น
โปรแกรมย่อยนี ้ อ่านได้ อย่างเดียว ในขณะที่ตวั อื่นสามารถอ่าน/เขียน/และ
เอ็กซิคิวต์ได้
 โปรแกรมหลักสามารถเรี ยกใช้ โปรแกรมย่อย ๆ เหล่านี ้ร่วมกันได้
 เครื่ องมือที่ใช้ ในการจัดการนี ้คือ การแบ่งเป็ นเซ็กเมนต์ (segmentation)
ั ก
การจั
การแบ่งงทางกายภาพ
ทางกายภาพ
 หน่วยความจำของระบบคอมพิวเตอร์ ควรถูกออกแบบเป็ น 2 ระดับ
 หน่วยความจำหลัก (Main Memory) มีความเร็ วในการแอ็กเซส
ข้ อมูลสูงและมีราคาแพง นอกจากนันยั ้ งเป็ นหน่วยความจำแบบลบ
เลือนได้ (ไม่สามารถเก็บข้ อมูลแบบถาวรได้ )
 หน่วยความจำสำรอง (secondary memory) จะมีความเร็ วช้ า
ราคาถูกกว่าหน่วยความจำหลัก แต่เป็ นหน่วยความจำแบบไม่ลบ
เลือน ดังนัน้ หน่วยความจำสำรองที่มีความจุมากสามารถนำมาใช้
เป็ นที่เก็บโปรแกรมหรื อข้ อมูลเป็ นเวลานานได้ ในขณะที่หน่วย
ความจำหลักที่มีความจุขนาดเล็กจะเก็บโปรแกรมหรื อข้ อมูลเมื่อ
โปรแกรมหรื อข้ อมูลทำงานเท่านัน้
ั ก
การจั
การแบ่งงทางกายภาพ
ทางกายภาพ
 ระบบที่มีหน่วยความจำ 2 แบบ ควรคำนึงถึงการจัดการการเคลื่อนย้ าย
ข้ อมูลระหว่างหน่วยความจำทังสอง
้ แต่การทำงานอาจจะเกิดข้ อผิด
พลาดได้ เนื่องจาก
 หน่วยความจำหลักอาจจะมีไม่พอเพียงสำหรับโปรแกรมนัน้ ทำให้ ผ้ เู ขียน
โปรแกรมนันต้้ องใช้ วิธีการแบ่งส่วน (overlay) โดยโปรแกรมและข้ อมูลนันจะ
้
ถูกจัดการแบ่งให้ เป็ นโปรแกรมย่อย ๆ ที่สามารถใช้ งานพื ้นที่ในหน่วยความจำ
เดียวกันได้ โดยมีหน่วยความจำหลักเป็ นตัวสับเปลี่ยนโปรแกรมย่อยเข้ าและ
ออกเมื่อต้ องการ
 ในระบบมัลติโปรแกรมมิ่ง (multiprogramming) โปรแกรมเมอร์ จะไม่
สามารถทราบได้ เลยว่าพื ้นที่หน่วยความจำจะว่างเมื่อใด และอยูท่ ี่ไหน
ั ก
การจั
การจัดดการหน่
การหน่ววยความจำหลั
ยความจำหลักก
 ระบบโปรแกรมเดียว (Monoprogramming)
 กำหนดว่ามีโปรแกรมเพียง 1 โปรแกรมทำงาน ณ เวลาขณะใดขณะหนึง่ ดัง
นันการใช้
้ งานหน่วยความจำจะมีเพียงโปรแกรมกับระบบปฏิบตั ิการเท่านัน้
• ระบบปฏิบตั ิการใช้ พื ้นที่ด้านล่าง

ของหน่วยความจำ RAM
• โปรแกรมใช้ พื ้นที่ด้านบน
• เมนเฟรม และมินิคอมพิวเตอร์
ั ก
การจั
• ระบบปฏิบตั ิการใช้ พื ้นที่ด้านบนของ
หน่วยความจำ ROM
• โปรแกรมใช้ พื ้นที่ด้านล่าง
• ปาล์มและคอมพิวเตอร์ ขนาดเล็ก
• ระบบปฏิบตั ิการใช้ พื ้นที่ด้านล่าง
ของหน่วยความจำ RAM
• โปรแกรมใช้ พื ้นที่ตรงกลาง
• ดีไวซ์ไดร์ เวอร์ ใช้ พื ้นที่ด้านบนที่
เป็ น ROM
ั ก
การจั
 ระบบหลายโปรแกรมที่กำหนดขนาดพาร์ ติชนั คงที่
 ทำงานได้ หลายโปรเซสในเวลาเดียวกัน ทำให้ เพิ่มประสิทธิภาพการทำงาน
ของโปรเซสเซอร์
 แบ่งพื ้นที่หน่วยความจำออกเป็ น n พาร์ ติชนั่ (สามารถทำได้ เมื่อระบบเริ่ มต้ น
ทำงาน)
 เมื่อมีโปรเซสเข้ ามาทำงาน ระบบจะต้ องจัดการนำโปรเซสเหล่านันเข้ ้ าแถว
เพื่อนำไปใส่ในพาร์ ติชนั่ ที่เล็กที่สดุ (ที่มีพื ้นที่เพียงพอให้ โปรเซสนันทำงานได้
้ )
 เนื่องจากเรากำหนดให้ พาร์ ติชนั่ เหล่านี ้มีขนาดตายตัว ระบบก็จะสูญเสียพื ้นที่
ที่ไม่ได้ ใช้ งานที่เหลือในพาร์ ติชนั่ นันไป
้ ซึง่ เราเรี ยกพื ้นที่นนว่
ั ้ า การสูญเปล่ า
ของพื้นทีย่ ่ อยภายใน (Internal fragmentation)
ั ก
ระบบที
ระบบที่ กำ
่ กำหนดขนาดพาร์
หนดขนาดพาร์ตตชิ ชิ ันันคงที
คงที่ ่
ข้ อเสียของการจัดคิวของโปรเซสที่จะเข้ าไปใช้ งาน

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

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

ก่อนนี ้งานขนาด 70 จะถูกเลือกให้ เข้ าไปใส่และที่ไม่เลือกงาน
ขนาด 220 เพราะว่ามีขนาดใหญ่กว่าขนาดของพาร์ ติชนั่ นัน้ วิธี
นี ้ทำงานเร็ว แต่อาจจะทำให้ เกิดการสูญเปล่าของพื ้นที่ยอ่ ยได้
หลังจากใช้ งานไปได้ ระยะหนึง่
ั ก
ระบบที
คงที่ ่
 เนื่องจากการออกแบบแบบนี ้ไม่ต้องการให้ ระบบเปลืองพื ้นที่ขนาดใหญ่
แก่งานที่มีขนาดเล็ก ดังนันวิ
้ ธีการออกแบบระบบสามารถค้ นหา และ
เลือกงานในคิวที่มีขนาดใหญ่ที่สดุ ที่สามารถใช้ งานพื ้นที่นนได้
ั ้ ดังนันใน้
รูปวิธีการนี ้จะเลือกงานขนาด 180 เข้ าไปใส่ในพาร์ ติชนั่
 ทำให้ ระบบได้ ใช้ งานหน่วยความจำได้ อย่างเต็มประสิทธิภาพ
 วิธีการดังกล่าวจะคัดค้ านไม่ให้ งานที่มีขนาดเล็กได้ ใช้ งานพาร์ ติชน
ั่ ที่มีอยู่
 ทำให้ ต้องหาวิธีแก้ ปัญหาดังกล่าว
 ให้ สร้ างพาร์ ติชนั่ ที่มีขนาดเล็กสักกลุม่ หนึง่ ที่ให้ งานีขนาดเล็กทำงานได้ เท่านัน้
 กำหนดกฎว่างานที่เลือกเข้ ามาใช้ งานนันจะถู ้ กมองข้ ามได้ ไม่เกินจำนวนครัง้
ที่กำหนด
ั ก
ระบบที
คงที่ ่
 การจัดการหน่วยความจำแบบนี ้เป็ นวิธีการที่งา่ ยและไม่ซบั ซ้ อนต่อการ
สร้ างโปรแกรมระบบปฏิบตั ิการ แต่มีข้อเสียคือ
 พาร์ ติชนั่ ที่กำหนดให้ มีขนาดและจำนวนที่ตายตัวเมื่อระบบเริ่ ม
ทำงานนัน้ จะเป็ นตัวจำกัดจำนวนของโปรเซสที่สามารถทำงานใน
ระบบ
 เนื่องจากระบบมีการกำหนดขนาดของพาร์ ติชน ั่ คงที่ ดังนันงานที
้ ่มี
ขนาดเล็กจะไม่สามารถใช้ พื ้นที่ของพาร์ ติชนั่ ได้ อย่างเต็ม
ประสิทธิภาพ ถึงแม้ นว่าในบางระบบจะสามารถรู้ จำนวนพื ้นที่
ทังหมดของแต่
้ ละงานที่ต้องการก่อนทำงานก็ตามที
ั ก
การจั
 ระบบที่กำหนดขนาดของพาร์ ติชน
ั่ ให้ เปลี่ยนแปลงได้
 พัฒนาขึ ้นมาเพื่อลดข้ อด้ อยของระบบที่กำหนดขนาดพาร์ ติชนั่ คงที่
 ใช้ เทคนิคการจัดการหน่วยความจำที่ซบ ั ซ้ อนและยุง่ ยากกว่าเดิม
 พาร์ ติชน ั่ สามารถเปลี่ยนแปลงได้ ทงขนาดและจำนวนของพาร์
ั้ ติชนั่
 เมื่อมีโปรเซสเข้ ามาใช้ งาน หน่วยความจำหลักจะถูกแบ่งเป็ นพาร์ ติ
ชัน่ ให้ พอดีกบั ที่โปรเซสนันต้้ องการใช้ งาน
 ระบบปฏิบต ั ิการที่ใช้ ในเครื่ องเมนเฟรม OS/MVT
(Multiprogramming with a Variable Number of Tasks) ของ
บริ ษัท IBM
ั ก
ั ก
ระบบที
หนดขนาดพาร์ตตชิ ชิ ่ ัน่ ันเปลี
เปลี่ ย่ ยนแปลงได้
นแปลงได้
 เมื่อระบบทำงานไปได้ สกั ระยะหนึง่ เราจะพบว่ามีชอ่ งว่างเกิดขึ ้นอย่าง
มากมายในหน่วยความหลัก
 ทำให้ การใช้ งานหน่วยความจำหลักนี ้มีประสิทธิภาพที่น้อยลงไป
 เราเรี ยกช่องว่างเล็ก ๆ เหล่านี ้ว่า การสูญเปล่ าพื้นทีย ่ ่ อยภายนอก
(external fragmentation)
 วิธีการป้องกันปั ญหา การสูญเปล่าพื ้นที่ยอ ่ ยภายนอก คือ การบีบอัด
พืน้ ที่สูญเปล่ า (compact) เหล่านัน้ โดยระบบปฏิบตั ิการสามารถ
เลื่อนพื ้นที่ของโปรเซสต่าง ๆ ที่ใช้ งานให้ มาชิดกัน ซึง่ จะทำให้ พื ้นที่วา่ ง
เปล่าเหลือเพียงแค่ 1 พาร์ ติชนั่ ใหญ่
ั ก
ตัวอยา่ งการบีบอัดขอ
้ มูล
ั ก
ระบบที
หนดขนาดพาร์ตตชิ ชิ ่ ัน่ ันเปลี
เปลี่ ย่ ยนแปลงได้
นแปลงได้
 การบีบอัดนี ้มีความยุง่ ยาก, ใช้ เวลาในการทำงานมาก และเปลืองเวลา
ทำงานของโปรเซสเซอร์ พอสมควร
 การบีบอัดนี ้จำเป็ นต้ องใช้ วิธีการย้ ายตำแหน่งของข้ อมูล (relocation)
ซึง่ จะต้ องมีความสามารถในการย้ ายโปรแกรมจากพื ้นที่หนึง่ ไปอีกพื ้นที่
หนึง่ ในหน่วยความจำหลัก โดยไม่ทำให้ จดุ บอกตำแหน่งการแอ็กเซส
ข้ อมูลนันผิ
้ ดพลาดไปด้ วย
 เครื่ องคอมพิวเตอร์ ที่มีความเร็ วในการก็อบปี ้ 4 ไบต์ตอ
่ 40 นาโนวินาที
จะใช้ เวลาในการบีบอัดหน่วยความจำขนาด 256 MB เท่ากับ 2.7 วินาที
ั ก
การจั
 การจัดการแบบระบบบัดดี ้ (Buddy System)
 ลดข้ อด้ อยของระบบที่กำหนดขนาดพาร์ ติชนั่ คงที่ (ถ้ ากำหนด
จำนวนและขนาดพาร์ ติชนั่ ไม่ดี ก็อาจจะทำให้ ระบบจำกัดจำนวน
ของโปรเซสที่เข้ ามาใช้ งาน หรื ออาจใช้ พื ้นที่ได้ ไม่เต็มประสิทธิภาพ)
 ลดข้ อด้ อยของระบบที่กำหนดขนาดพาร์ ติชน ั่ ให้ เปลี่ยนแปลงได้
(ซับซ้ อน, ยุง่ ยากในการดูแล และใช้ เวลามากในการบีบอัดข้ อมูล)
 หน่วยความจำจะถูกแบ่งออกเป็ นพาร์ ติชน ั่ ที่มีขนาดเท่ากับ 2K โดย
L <= K <= U เพราะการกำหนดแอ็ดเดรสในหน่วยความจำหลัก
มักจะใช้ เลขฐาน 2
ั ก
การจั
การจัดดการแบบระบบบั
การแบบระบบบัดดดีดี้ ้
 2L = ขนาดของพาร์ ติชน
ั่ ที่เล็กที่สดุ ที่สามารถจัดสรรได้
 2U = ขนาดของพาร์ ติชน
ั่ ที่ใหญ่ที่สดุ ที่สามารถจัดสรรได้ ซึง่ โดยปกติ
ขนาด 2U นี ้จะเท่ากับขนาดของหน่วยความจำทังหมดที ้ ่ยงั ว่างอยู่
 ครัง้ แรกแบ่งพาร์ ติชน
ั เท่ากับขนาดหน่วยความจำทังหมด ้
 จากนันพิ้ จารณาว่าโปรเซสต้ องการหน่วยความจำเท่าไร โดยการแบ่ง
หน่วยความจำออกเป็ นครึ่งหนึง่
 ถ้ ายังมีขนาดใหญ่เกินไปก็แบ่งอีก เช่นนี ้เรื่ อยไป จนกว่าขนาดของหน่วย
ความจำมีขนาดเล็กที่สดุ ที่สามารถทำงานโปรเซสนันได้ ้
ั ก
ตัวอย่างการแบ่งพาร์ ติชนั่ แบบระบบบัดดี ้ (ขนาด 1 MB)
ั ก
การใช้ ลงิ ค์ลสิ ต์ควบคุมการทำงานระบบบัดดี ้
ั ก
การตรวจสอบเนื
การตรวจสอบเนือ้ อ้ ทีที่ ข่ ของหน่
องหน่ววยความจำ
 เมื่อหน่วยความจำถูกจัดการแบบเปลี่ยนแปลงขนาดของพาร์ ติชนั่ ได้ นนั ้
ระบบปฏิบตั ิการจะต้ องมีความสามารถในการตรวจสอบได้ วา่ พื ้นที่สว่ น
ใดในหน่วยความจำว่างอยูแ่ ละส่วนไหนที่ถกู ใช้ อยู่
 การตรวจสอบสามารถทำได้ 2 วิธีคือ
 การจัดการแบบบิตแมพ (Memory Management with Bitmaps)
 การจัดการแบบลิงค์ลส ิ ต์ (Memory Management with Linked
Lists)
ั ก
 การจัดการแบบบิตแมพ (Memory Management with Bitmaps)
 หน่วยความจำจะถูกแบบออกเป็ น ยูนิต (unit)
 แต่ละยูนิตจะมีขนาดใหญ่หรื อเล็กก็ได้ เช่น มีขนาด 1 ไบต์ หรื อหลายร้ อยกิโล
ไบต์ก็ได้
 แต่ในแต่ละยูนิตนันจะแทนค่
้ า 1 บิตเสมอ (นัน่ คือ ถ้ าหน่วยความจำมี 1000
ยูนิต ก็จะมี 1000 บิต) และเราเรี ยก บิต เหล่านี ้ว่าระบบบิตแมปนันเอง
้
 มีคา่ 0 หรื อ 1 โดยที่
 ถ้ าบิตแมพ มีคา่ เท่ากับ 1 แสดงว่ายูนิตที่บิตนันเป็
้ นตัวแทนอยู่ ไม่วา่ ง
(มีโปรเซสอยู่)
 ถ้ าบิตแมพ มีคา่ เท่ากับ 0 แสดงว่ายูนิตที่บิตนันเป็
้ นตัวแทนว่างอยู่
(ไม่มีโปรเซสอยู่)
ั ก
การจั
การจัดดการแบบบิ
การแบบบิตตแมพ
แมพ
ั ก
 เมื่อมีโปรเซสต้ องการใช้ พื ้นที่วา่ งในหน่วยความจำ โปรเซสเซอร์ ก็จะ
เข้ าไปอ่านค่าของบิตแมพเพื่อดูวา่ ส่วนใดของหน่วยความจำยังว่างอยู่
 การกำหนดขนาดของ “ยูนิต” เป็ นหัวข้ อที่สำคัญอย่างหนึง่ ของการ
ออกแบบในระบบบิตแมพ
 ถ้ ากำหนดให้ ยน ู ิตมีขนาดเล็ก ระบบก็จะมีบิตแมพที่มีขนาดใหญ่
 ถ้ าเรากำหนดให้ ยน ู ิตมีขนาด 4 ไบต์ จะทำให้ ทกุ ๆ 32 บิตของหน่วย
ความจำต้ องการ 1 บิตในบิตแมพ
 นันหน่
้ วยความจำ 32n บิต จะใช้ n บิต และจะทำให้ บิตแมตใช้ พื ้นที่
ทังหมด
้ 1/33 ของหน่วยความจำทังหมด ้
ั ก
 ถ้ ากำหนดยูนิตให้ มีขนาดใหญ่ บิตแมพก็จะมีขนาดเล็ก แต่อาจจะทำให้
เราสูญเสียหน่วยความจำในยูนิตสุดท้ ายได้
 เป็ นการตรวจสอบพื ้นที่ของหน่วยความจำที่งา่ ย เพราะขนาดของบิตแม
พนันจะคงที
้ ่ และขึ ้นอยูก่ บั ขนาดของยูนิตและขนาดของหน่วยความจำ
ทังหมด
้
 ข้ อเสียของวิธีนี ้คือ
 ทำให้ เกิดการสูญเสียพื ้นที่ภายใน (Internal Fragmentation) ในยูนิตสุดท้ าย
 ทำให้ เกิดการสูญเสียพื ้นที่ภายนอก (External Fragmentation) ตามค่า 0
 การนำโปรเซส k ยูนิตเข้ ามาใช้ งานในหน่วยความจำ ระบบจะต้ องหา 0 เป็ น
จำนวน k บิตติดกันในบิตแมพ และการค้ นหาจะใช้ เวลามาก
ั ก
 การจัดการแบบลิงค์ลสิ ต์ (Memory Management with Linked Lists)
 เป็ นการใช้ ลงิ ค์ลสิ ต์เก็บข้ อมูลของพาร์ ติชนั่ ในหน่วยความจำทังที ้ ่วา่ ง หรื อถูก
ใช้ งานอยู่
 ค่าของสมาชิกตัวแรก (ด้ านซ้ ายมือ) เป็ นตัวบอกว่าพาร์ ติชนั่ ที่โหนด(node)
นันแสดงว่
้ างอยูห่ รื อไม่ ถ้ าพื ้นที่สว่ นนันว่
้ างอยู่ จะถูกแสดงด้ วยตัวอักษร H (
hole) และ ถ้ าพื ้นที่สว่ นนันมี
้ โปรเซสใช้ งานอยูก่ ็จะแสดงเป็ นตัวอักษร P (pro
cess)
 สมาชิกตัวที่สองจะแสดงที่อยูเ่ ริ่ มต้ นของพาร์ ติชนั่
 สมาชิกตัวที่สามจะแสดงความยาวทังหมดของพาร์ ้ ติชนั่ นัน้
 สมาชิกตัวสุดท้ ายจะเป็ นพอยเตอร์ ชี ้ไปยังลิสต์ตวั ต่อไป
ั ก
 ลิสต์ของพาร์ ติชนั่ นันจะถู
้ กจัดเรี ยงตามแอ็ดเดรส (address)
 การจัดเรี ยงตามวิธีดงั กล่าวมีข้อดี คือ
 เมื่อมีโปรเซสใดหยุดทำงาน หรื อถูกดึงออกจากหน่วยความจำ การ
เปลี่ยนแปลงของลิสต์สามารถทำได้ งา่ ย
 โดยปกติแล้ วโปรเซสหนี่ง ๆ จะมีพาร์ ติชน ั่ ด้ านข้ างอยู่ 2 พาร์ ติชนั่ (ยกเว้ น
พาร์ ติชนั่ ที่อยูส่ ว่ นบน/ล่างสุด ของหน่วยความจำ) และพาร์ ติชนั่ ที่อยูโ่ ดย
รอบนี ้จะเป็ นพาร์ ติชนั่ ที่วา่ งหรื อกำลังถูกใช้ งานอยูก่ ็ได้ ซึง่ จะทำให้ เราได้
รูปแบบการทำงาน 4 กรณี
ั ก
ั ก
สมมุติวา่ ก่อนหน้ าที่ โปรเซส X จบการทำงานเรามีลงิ ค์ลสิ ต์ของโปรเซสทังสาม

้
การเปลี่ยนแปลงลิสต์สามารถทำได้ โดยเปลี่ยนตัวอักษร P เป็ น H
ั ก
2 พาร์ ติชนั่ จะถูกรวมเหลือเพียง 1 พาร์ ติชนั่ และทำให้ ลติ ส์มีขนาดสันลง

้
3 พาร์ ติชนั่ ถูกรวมเหลือเพียง 1 พาร์ ติชนั่
ั ก
ั ก
การนำโปรเซสเข้
การนำโปรเซสเข้าามาใช้
มาใช้งงานในหน่
านในหน่ววยความจำ
 First-Fit เป็ นวิธีที่งา่ ยที่สดุ เริ่ มต้ นเนื ้อที่วา่ งจากต้ น ลิสต์ก่อนเสมอ โดยค้ นไปทีละ
โหนดและจะนำโหนดที่วา่ งที่พบและมีขนาดเพียงพอต่อโปรเซสไปใช้ งานก่อน ซึง่
วิธีนี ้จะเร็วแต่ไม่ดี
 Next-Fit เป็ นวิธีที่คล้ ายกับวิธีแรก แต่การหาที่วา่ งจะเริ่ มต้ นจากโหนดที่หยุดลงจาก
การค้ นหาครัง้ ก่อนหน้ านันจนเจอโหนดที
้ ่มีที่วา่ งเพียงพอสำหรับโปรเซส แต่
ประสิทธิภาพของการทำงานนันไม่ ้ ดีไปกว่าแบบแรกเลย
 Best-Fit หาเนื ้อที่วา่ งโดยค้ นทังลิ ้ สต์ เพื่อหาเนื ้อที่วา่ งที่มีขนาดเท่ากันหรื อใกล้
เคียงกับขนาดของโปรเซสจริ ง แต่จะมีข้อเสียคือ ใช้ เวลานาน และทำให้ เกิดช่องว่าง
เล็ก ๆ ภายในหน่วยความจำเป็ นจำนวนมาก วิธีทำให้ การค้ นหาได้ เร็วขึ ้นคือ การ
เรี ยงลิสต์ตามลำดับขนาดจากเล็กไปใหญ่ คือถ้ าเราพบที่วา่ งที่โปรเซสนันลงได้ ้ ก็
ให้ ใช้ ได้ เลยเพราะว่าที่วา่ งหลังจากนันก็ ้ จะมีคา่ ใหญ่กว่าแน่นอน
ั ก
การนำโปรเซสเข้
การนำโปรเซสเข้าามาใช้
มาใช้งงานในหน่
านในหน่ววยความจำ
 Worst-Fit เป็ นวิธีการป้องกันไม่ให้ เกิดปั ญหาการเกิดเนื ้อที่วา่ งเล็ก ๆ เป็ นจำนวน
มากอย่าง Best-Fit เริ่ มต้ นหาเนื ้อที่วา่ งโดยค้ นทังลิ
้ สต์ และหาโหนดที่วา่ งที่มีขนาด
ใหญ่ที่สดุ ในลิสต์ เพื่อใส่โปรเซสใหม่เข้ ามา แต่จะมีข้อเสียเหมือน Best-Fit
 Quick-Fit มีลงิ ค์ลสิ ต์มากกว่า 1 ลิสต์ โดยแต่ละลิงค์ลสิ ต์จะประกอบไปด้ วยโหนด
ที่มีขนาดเท่ากัน ซึง่ พาร์ ติชนั่ ส่วนนันจะว่
้ างหรื อไม่ก็ได้
ั ก
 ถ้ ามีโปรเซสขนาด 8 K เข้ ามาใช้ งาน โปรเซสนันสามารถเข้
้ าไปใช้ ลงิ ค์ลสิ ต์ 8 K ได้
เลย ทำให้ การทำงานและการค้ นหาเร็วขึ ้น
 ข้ อเสีย เมื่อมีโปรเซสใดหยุดทำงาน หรื อถูกสลับออกจากหน่วยความจำ พาร์ ติชนั่ ที่
อยูใ่ กล้ เคียงจะต้ องรวมเป็ น 1 เดียว ซึง่ ค่อนยากซับซ้ อน และถ้ าระบบรวมพาร์ ติชนั่
ไม่สำเร็จจะทำให้ เกิดช่องว่างมากมายที่ไม่สามารถนำโปรเซสใดเข้ าไปใช้ งานได้
ั ก
หน่
หน่ววยความจำเสมื
ยความจำเสมืออนน (Virtual
(Virtual Memory)
Memory)
 หลักการจัดการหน่วยความจำหลักก็เพื่อให้ สามารถนำโปรเซสลงหน่วย
ความจำให้ ได้ มากที่สดุ (ทำให้ ระบบมัลติโปรแกรมมิ่งทำงานย่างมี
ประสิทธิภาพมากที่สดุ )
 หน่วยความจำเสมือน เป็ นวิธีการหนึง่ ที่สามารถทำให้ โปรเซสทำงานได้
ถึงแม้ วา่ โปรเซสนันจะไม่
้ ได้ อยูใ่ นหน่วยความจำหลักทังหมดก็
้ ตาม โดย
ระบบปฏิบตั ิการจะทำหน้ าที่เก็บบางส่วนของโปรแกรมที่กำลังทำงานไว้
ในหน่วยความจำหลัก และเก็บที่สว่ นที่เหลือไว้ ในฮาร์ ดดิสก์
 ข้ อดีหลักของวิธีนี ้ ก็คือ โปรแกรมของผู้ใช้ สามารถมีขนาดใหญ่กว่าหน่วย
ความจำจริ งก็ได้ เพราะวิธีนี ้จะสร้ างหน่วยความจำทางตรรก ให้ ดเู สมือน
ว่ามีหน่วยความจำเป็ นแถวขนาดใหญ่
ั ก
การแบ่
การแบ่งงเป็เป็นหน้
นหน้าา (Paging)
(Paging)
 ระบบที่ใช้ หน่วยความจำเสมือนส่วนใหญ่จะใช้ เทคนิคที่เราเรี ยกว่า การแบ่งเป็ น
หน้ า หรื อ เพจจิ่ง(paging)
 หลักการทำงาน
 เป็ นการแบ่งหน่วยความจำหลักออกเป็ นพาร์ ติชน ั่ ที่มีขนาดเล็กและเท่ากัน
 เราเรี ยกว่า เฟรม (frames) หรื อ เพจเฟรม (page frame)
 การแบ่งโปรแกรมในดิสก์ที่จะเข้ ามาใช้ งานเป็ นชิ ้นเล็ก ๆ เช่นกันเรี ยกว่า หน้ า
(page) โดยที่ทกุ หน้ าจะมีขนาดเท่ากันหมด และมีเงื่อนไขว่า
 ขนาดของ 1 หน้ า จะต้ องเท่ากับขนาดของ 1 เพจเฟรม เสมอ
 ใน 1 เฟรม จะมีการนำเอาแค่ 1 หน้ า มาใส่ได้ เท่านัน้ เช่น หน่วยความ
จำหลัก 1 MB และแบ่งออกเป็ น 4 เพจเฟรม ดังนัน้ ขนาดของเพจเฟรม
คือ 256 KB และ หน้ าในดิสก์เท่ากับ 256 KB เหมือนกัน
ั ก
ั ก
การแบ่
(Paging)
 โหลดโปรเซส A, B และ C ลงหน่วยความจำได้ อย่างต่อเนื่อง จนกระทัง่ นำโปรเซส
B ออกไป แล้ วทำการโหลดโปรเซส D ลงหน่วยความจำ ซึง่ สามารถทำได้ โดยใช้
แนวความคิดของแอ็ดเดรสทางตรรก (logical address)
 โดยให้ ระบบปฏิบตั ิการควบคุมการทำงานของโปรแกรมหรื อโปรเซสในรูปแบบของ
ตารางหน้ า (page table)
ั ก
การแบ่
(Paging)
 การแบ่งเป็ นหน้ าแบบง่าย ๆ นันจะเหมื
้ อนกับการแบ่งพาร์ ติชนั่ แบบมี
ขนาดคงที่ ข้ อแตกต่างอยูท่ ี่วา่ การแบ่งเป็ นหน้ านันจะเป็
้ นการแบ่งพื ้นที่ที่
มีขนาดเล็ก และโปรแกรมหนึง่ ๆ สามารถใช้ งานได้ มากกว่า 1 พาร์ ติชนั่
ได้ และพาร์ ติชนั่ เหล่านี ้ก็ไม่จำเป็ นต้ องต่อเนื่องกัน
 วิธีการที่ทำให้ การจัดการแบบแบ่งเป็ นหน้ าสามารถทำได้ งา่ ยขึ ้นโดย เริ่ ม
จากการแบ่งขนาดของเฟรม และขนาดของหน้ าให้ เป็ นค่ายกกำลังของ
เลขฐาน 2 ซึง่ วิธีนี ้แอ็ดเดรสทางตรรกจะแสดงเป็ นเลขที่หน้ า และระยะ
จากขอบหน้ า (offset)
ั ก
P# +Offset = 000001+0111011110 = 0000010111011110
1 478 1502
ั ก
การแบ่
(Paging)
 การกำหนดขนาดของหน้ าเป็ นค่าของเลขยกกำลัง 2 ทำให้
 โปรแกรมเมอร์ ไม่จำเป็ นต้ องสนใจแอ็ดเดรสทางตรรกเลย เพราะว่า
แอ็ดเดรสทางตรรกของโปรแกรมนันมี ้ คา่ เท่ากับแอ็ดเดรสเปรี ยบ
เทียบอยูแ่ ล้ ว (logical address=relative address)
 การทำงานของฮาร์ ดแวร์ ในการแปลงที่อยูน ่ นจะทำได้
ั้ งา่ ยขึ ้น
เพราะว่าที่อยูจ่ ะถูกเขียนอยูใ่ นรูปของ n + m บิต โดยบิตทางด้ าน
ซ้ ายมือสุดจำนวน n บิต เป็ นเลขที่หน้ า และ บิตทางด้ านขวามือ
จำนวน m บิตเป็ นระยะจากขอบหน้ า ในตัวอย่างก่อนหน้ านี ้ n=6
และ m=10 โดยการแปลงแอ็ดเดรส
ั ก
การแบ่
(Paging)
 การแปลงแอ็ดเดรสทำได้ โดย
 แยกเลขที่หน้ าโดยนำบิตทางด้ านซ้ ายมือจำนวน n บิต ออกมาจาก
ที่อยูท่ างตรรก
 ใช้ เลขที่หน้ าเป็ นตัวตังในตารางหน้
้ าของโปรแกรม เพื่อนำไปใช้
ค้ นหาเลขที่เฟรม k ต่อไป
 ที่อยูท
่ างกายภาพของเฟรมนันคื ้ อ k x 2m และที่อยูท่ างกายภาพ
ของหน่วยความจำหลักที่เทียบ ก็คือตัวเลขที่ได้ บวกกับระยะจาก
ขอบหน้ า (เราไม่จำเป็ นต้ องคำนวณแอ็ดเดรสทางกายภาพอีก
เพราะเราสามารถรวมเลขที่เฟรมกับระยะจากขอบหน้ าได้ เลย)
ั ก
ั ก
ั ก
ตารางหน้
ตารางหน้าา (page
(page table)
table)
 ตารางหน้ า (page table) นันเป็ ้ นการแมพค่าของแอ็ดเดรสทางตรรกไป
หาค่าเลขที่เฟรมที่อยูใ่ นหน่วยความหลัก
 ทางคณิตศาสตร์ อาจจะกล่าวได้ วา่ ตารางหน้ านี ้เป็ นฟั งก์ชน ั่ ที่รับค่าของ
แอ็ดเดรสทางตรรกเป็ นอินพุต (input) และให้ คา่ แอ็ดเดรสทางกายภาพ
ออกมา (output) ซึง่ สิง่ ที่ฟังก์ชนั่ ดังกล่าวทำก็คือ แทนแอ็ดเดรสของเพจ
ที่เป็ นแอ็ดเดรสทางตรรกด้ วยแอ็ดเดรสของเฟรม แต่ถงึ แม้ นการอธิบาย
ข้ างต้ นจะดูเหมือนง่ายแต่ปัญหาที่พบมีอยู่ 2 หัวข้ อคือ
 ตารางหน้ าส่วนใหญ่จะมีขนาดใหญ่
 การแมปค่าแอ็ดเดรสดังกล่าวจะต้ องทำด้ วยความเร็ วสูง
ั ก
(page table)
table)
 ตารางหน้ าส่วนใหญ่จะมีขนาดใหญ่
 ในระบบคอมพิวเตอร์ ปัจจุบนั จะใช้ ที่อยูอ่ ย่างต่ำประมาณ 32 บิต ถ้ าเรา
กำหนดให้ แต่ละหน้ ามีขนาด 4 KB ก็จะทำให้ ระบบมีหน้ าทังหมด
้ 1 ล้ านหน้ า
 ในระบบที่เป็ นแบบ 64 บิต ก็จะทำให้ มีจำนวนหน้ ามากประมาณเกินกว่าที่จะ
นำไปใช้ หมด (1012 หน้ า)
 การแมปค่าแอ็ดเดรสดังกล่าวจะต้ องทำด้ วยความเร็วสูง
 การแมประหว่างแอ็ดเดรสทางตรรกและแอ็ดเดรสทางกายภาพนันจะต้ ้ องทำ
ทุก ๆ ครัง้ เมื่อมีการอ้ างถึงแอ็ดเดรสจริ งในหน่วยความจำหลัก
 ใน 1 คำสัง่ โปรแกรมอาจจะแมปเป็ นจำนวน 1,2 หรื อมากกว่านัน้ และถ้ า
กำหนดให้ แต่ละคำสัง่ ใช้ เวลา 4 nsec ตารางหน้ านันจะต้
้ องมีความสามารถ
ในการสืบค้ นได้ เร็วมากกว่า 1 nsec เพื่อป้องกันปั ญหาคอขวด (bottleneck)
ั ก
ั ก
(page table)
table)
 ตารางหน้ าประกอบไปด้ วยอาร์ เรย์ของรี จิสเตอร์
 เมื่อมีโปรเซสหนึง่ เริ่ มทำงาน ระบบปฏิบต ั ิการจะทำการโหลดรี จิสเตอร์
ด้ วยตารางหน้ าของโปรเซสนัน้ ๆ โดยทำการก็อบปี จ้ ากหน่วยความ
จำหลัก ก็จะทำให้ เราไม่ต้องอ้ างถึงหน่วยความจำอีกในขณะที่โปรเซสกำ
ลังทำงาน
 ข้ อดีของวิธีนี ้ก็คือ เป็ นวิธีที่งา่ ยและไม่ต้องทำการอ้ างถึงหน่วย
ความจำอีกเมื่อทำการแมปแอ็ดเดรส
 ข้ อเสียก็คือถ้ าตารางของหน้ ามีขนาดใหญ่ก็จะทำให้ ระบบมี
ประสิทธิภาพในการทำงานต่ำลง เพราะการโหลดตารางหน้ า
ทังหมดนั
้ นจะใช้
้ เวลานาน
ั ก
4 M บน
4-8M
ตารางลำดับแรก
0-4M
ั ก
(page table)
table)
 โครงสร้ างตารางหน้ า
 Page frame number เป็ นฟิ ลด์ที่มีความสำคัญมากที่สดุ เพราะฟิ ลด์นี ้ใช้ ในการเก็บ
ข้ อมูลว่า หน้ านี ้จะไปอยูใ่ นเฟรมเลขที่อะไรในหน่วยความจำหลัก
 Present/absent มีขนาด 1 บิต ใช้ บอกว่าหน้ านี ้ในปั จจุบนั อยู่ (present) หรื อ ไม่
อยู่ (absent) ในหน่วยความจำหลัก (1=อยู,่ 0=ไม่อยู)่ ถ้ าเป็ นเป็ น 0 แล้ ว จะทำให้
เกิดปั ญหาการผิดหน้ าได้ (page fault)
ั ก
(page table)
table)
 Protection เป็ นบิตที่เก็บข้ อมูลเกี่ยวกับการป้องกันหน้ าว่าหน้ านี ้มีการป้องกันใน
การเรี ยกใช้ งานอย่างไร เช่น ให้ อา่ นได้ อย่างเดียว (Read Only), อ่านและเขียนได้
(Read/Write) หรื อเอ็กซิคิวต์ได้ (Execute) ซึง่ การป้องกันนี ้ใช้ 3 บิตก็พอ เช่น R (re
ad), W (write), E (excute) เป็ น 000,001,010,011}… เป็ นต้ น
 Modified ใช้ ในการเก็บข้ อมูลเกี่ยวกับการใช้ งานของหน้ านัน้ ว่าหน้ าที่เข้ าไปอยูใ่ น
หน่วยความจำหลัก และที่ถกู ใช้ งานแล้ ว หน้ านันถู ้ กบันทึกหรื อปรับเปลี่ยนค่าหรื อ
ไม่ (0=ไม่มีการถูกบันทึกหรื อปรับปรุงเปลี่ยนค่า, 1=มีการถูกบันทึกหรื อปรับปรุง
เปลี่ยนแปลงค่า) บิตนี ้รู้จกั กันในอีกชื่อหนึง่ ว่า เดอร์ ตี ้บิต (dirty bit) เพราะเป็ นบิตที่
ระบบปฏิบตั ิการใช้ ในการตรวจสอบสถานะของหน้ า (ถ้ าหน้ าไหนเปลี่ยนแปลงจะ
เป็ นบอตสกปรกที่ต้องถูกเขียนกลับลงดิสก์
ั ก
(page table)
table)
 Referenced หน้ าที่เข้ าไปอยูใ่ นหน่วยความจำหลักนี ้ ถูกเรี ยกใช้ บ้างหรื อไม่
(0=หน้ านันยั้ งไม่ถกู เรี ยกใช้ งานตังแต่
้ ถกู โหลดเข้ าในหน่วยความจำหลัก, 1=หน้ าที่
ถูกเรี ยกใช้ งานแล้ ว) และบิตนี ้จะเป็ นบิตที่สำคัญสำหรับกระบวนการสับเปลี่ยน
หน้ า (page replacement) ที่เราจะเรี ยนรู้ในหัวข้ อต่อไป
 Caching disabled เป็ นบิตที่ใช้ กำหนดว่าเราไม่ต้องการเก็บค่าแคชสำหรับหน้ านัน้
โดยทัว่ ไปบิตนี ้จะสำคัญสำหรับหน้ าที่ถกู แมปเข้ ากับริ จิสเตอร์ ของอุปกรณ์ เช่นใน
กรณีที่ระบบปฏิบตั ิการจะต้ องรออุปกรณ์ภายนอกตอบสนองคำสัง่ อยูต่ ลอดเวลา
ั ก
(page table)
table)
 เนื่องจากขนาดตารางหน้ านันขึ
้ ้นอยูก่ บั จำนวนหน้ าที่มี กล่าวคือ 1 แถว
ของตารางจะเท่ากับ 1 หน้ าของโปรเซส
 ถ้ าโปรเซสมีขนาดใหญ่มาก ๆ ตารางหน้ าก็จะมีขนาดใหญ่ไปด้ วยซึง่ จะ
ทำให้ การทำงานในการแมปที่อยูน่ นช้
ั ้ าลง
 วิธีการแก้ ก็คือ การทำตารางหน้ าย้ อนกลับ (inverted page table)
โดยในระบบคอมพิวเตอร์ หนึง่ ๆ จะมีตารางหน้ าย้ อนกลับ ได้ แค่ 1
ตาราง เท่านัน้ เพราะแต่ละแถวในตารางหน้ าย้ อนกลับนัน้ จะเป็ น
ตัวแทนของ 1 เฟรม ในหน่วยความจำหลัก
ั ก
(page table)
table)
 เช่น ในระบบที่ใช้ ที่อยูแ่ บบ 64 บิต โดยแต่ละหน้ ามีขนาด 4 KB (212)
และมีขนาดของหน่วยความจำหลักเท่ากับ 256 MB (228) ซึง่ ทำให้ ตาราง
นี ้มีทงหมด
ั้ 65,536 แถว (2 28-12 = 216 = 65536) โดยในแต่ละแถวจะทำ
หน้ าที่เก็บข้ อมูลของ โปรเซส และเลขที่หน้ าที่ใช้ งานอยูใ่ นเฟรมในหน่วย
ความจำหลัก
ั ก
(page table)
table)
 Process id เป็ นหมายเลขโปรเซสที่อยูใ่ นเฟรมนัน้
 Flag Bit จะแสดงถึงสถานะของโปรเซสที่อยูใ่ นเฟรม ซึง่ มี Referenced
Bit, Modified Bit และ Present/Absent Bit อย่างในตารางหน้ า
 Page No จะแสดงหมายเลขหน้ าของโปรเซสนันที ้ ่เข้ ามาอยูใ่ นเฟรมนี ้
 Counter จะเก็บค่าทุกครัง้ ที่โปรเซสเซอร์ หรื อซีพียูทำการเรี ยกใช้ และ
อาจทำการบันทึกว่าถูกเรี ยกใช้ งานครัง้ สุดท้ ายเมื่อไหร่ด้วย
ั ก
(page table)
table)
 ตารางหน้ าแบบย้ อนกลับนี ้จะช่วยให้ เราประหยัดพื ้นที่ได้ เมื่อแอ็ดเดรสหน่วยความ
จำเสมือนนันมี้ จำนวนมากกว่า แอ็ดเดรสในหน่วยความจำหลัก
 วิธีดงั กล่าวมีข้อเสียคือ การแปลงแอ็ดเดรสเสมือนไปหาแอ็ดเดรสจริ งทางกายภาพ
นันทำได้
้ ยากขึ ้น
 เมื่อมี โปรเซส n อ้ างถึง หน้ า p ฮาร์ ดแวร์ จะไม่สามารถทำการค้ นหาแอ็ดเดรสจริ ง
โดยการใช้ p เทียบเป็ นอินเด็กซ์ของตารางได้ อีกต่อไป
 ตรงกันข้ ามวิธีการค้ นหาจะต้ องทำการสืบค้ นทุกแถวในตารางหน้ าย้ อนกลับ ซึง่ การ
ค้ นหาทุกแถวในตารางขนาด 64 K นันทำให้ ้ การทำงานช้ าลงพอสมควร
 วิธีแก้ ปัญหาทำได้ โดยใช้ วิธี TLBs (Translation Lookaside Buffers) ถ้ า TLB
สามารถเก็บหน้ าที่ถกู ใช้ งานบ่อย ๆ การแปลที่อยูก่ ็สามารถทำได้ เร็วเหมือนกับที่
เราทำในตารางหน้ าธรรมดา
ั ก
(page table)
table)
 การใช้ ตารางแบบย้ อนกลับนี ้จำเป็ นต้ องใช้ ซอฟต์แวร์ ช่วยในการสืบค้ น ซึง่ คือการ
ใช้ ตารางแฮช และ ฟั งก์ชนั่ แฮช (hash function เป็ นฟั งก์ชนั่ ที่ใช้ ในการแปลงข้ อมูล
ที่มีความยาวมาก เป็ นบิตที่มีจำนวนน้ อยลงและค่าแฮชของข้ อมูลแต่ละค่าไม่ควรมี
ค่าเหมือนกัน)
 ในการแปลงที่อยูเ่ สมือน ดังรูปและหน้ าที่อยูใ่ นหน่วยความจำที่มีคา่ แฮชเหมือนกัน
ก็จะมีการเชื่อมต่อเข้ าหากัน (chained)
ั ก
ั ก
บับัพพเฟอร์
เฟอร์คค้ น้ นหาที
หาที่ อ่ อยูยู่ ่ (Translation
(Translation Lookaside
Lookaside Buffer)
Buffer)
 โดยทัว่ ไป เมื่อมีการอ้ างถึงหน่วยความจำเสมือนทุก ๆ ครัง้ จะมีการเรี ยก
หาหน่วยความจำหลักถึง 2 ครัง้ คือมีการดึงแถวของตารางหน้ า และการ
ดึงข้ อมูลที่ต้องการออกมาจากหน่วยความจำหลัก
 การทำงานของหน่วยความจำเสมือนใช้ เวลาในการเข้ าถึงหน่วยความ
จำเป็ น 2 เท่า
 วิธีการป้องกันปั ญหาดังกล่าวสามารถทำได้ โดยใช้ แคชหรื อหน่วยความ
จำพิเศษในการเก็บแถวของตารางหน้ า ที่เราเรี ยกกันว่า บัพเฟอร์ ค้นหาที่
อยู่ (TLB) โดยแคชนี ้จะทำหน้ าที่เก็บแถวของตารางหน้ าที่พงึ่ ใช้ เรี ยกใช้
งานเสร็ จ
ั ก
ั ก
Lookaside Buffer)
Buffer)
 เมื่อมีการให้ คา่ แอ็ดเดรสเสมือนกับระบบ โปรเซสเซอร์ จะทำการสืบค้ นใน
ตาราง TLB ก่อน
 ถ้ าพบแถวที่ต้องการในตารางหน้ า (TLB hit) เราก็สามารถเก็บเลข
ที่เฟรมและแปลงเป็ นแอ็ดเดรสจริงได้ เลย
 แต่ถ้าไม่พบแถวที่ต้องการ (TLB miss) โปรเซสเซอร์ หรื อซีพียก ู ็ จะ
ต้ องใช้ เลขที่หน้ าไปเปรี ยบเทียบกับอินเด็กซ์ของตารางหน้ า เพื่อหา
แถวที่ต้องการ และซีพียกู ็จะทำหน้ าที่เพิ่ม TLB ให้ มีแถวของตาราง
หน้ าใหม่นี ้ด้ วย
ั ก
Lookaside Buffer)
Buffer)
 เนื่องจาก TLB จะเก็บข้ อมูลของบางแถวจากตารางหน้ าเท่านัน้ ทำให้ เรา
ไม่สามารถเรี ยงลำดับแถวของ TLB ด้ วยเลขที่หน้ าได้ ดังนัน้ ค่าของ
ฟิ ลด์ในแถวของ TLB จะต้ องมีเลขที่หน้ ากำกับด้ วย
 การค้ นหาเลขที่หน้ าใน TLB ของโปรเซสเซอร์ นนจะเป็
ั้ นแบบการแม
พร่วม(associative mapping) ซึง่ แตกต่างจากการแมพโดยตรงอย่างกัน
ที่ทำในตารางหน้ า
 การออกแบบ TLB จะต้ องพิจารณาถึงวิธีการจัดการกับค่าของแถวที่อยู่
ในตาราง และวิธีการแทนที่คา่ ของแถวใหม่เข้ าไปในตาราง
ั ก
ั ก
การสั
การสับบเปลี
เปลี่ ย่ ยนหน้
นหน้าา (Page
(Page replacement
replacement algorithms)
algorithms)
 การเลือกหน้ าในหน่วยความจำที่จะถูกแทนที่ด้วยหน้ าใหม่ที่เข้ ามา
 คำถามที่น่าสนใจในการสับเปลี่ยนหน้ า
 มีจำนวนเพจเฟรมเท่าไหร่ ที่สามารถให้ กบ ั โปรเซสแต่ละตัวได้
 กลุม่ ของหน้ าถูกพิจารณาให้ สบั เปลี่ยนหน้ านันควรจะถู
้ ก จำกัดหรื อ
ไม่ เพื่อป้องกันไม่ให้ โปรเซสที่ทำให้ เกิดการผิดหน้ า (page fault)
ทำงาน
 ในกลุม ่ ของหน้ าที่เราพิจารณา เราจะเลือกหน้ าใดที่จะนำไปสับ
เปลี่ยน
ั ก
การสั
(Page replacement
algorithms)
 หัวข้ อที่ 1 และ 2 เกี่ยวข้ องกับ การจัดการภายใน (Resident Set
Management) ซึง่ เป็ นการจัดการที่เกี่ยวข้ องกับนโยบายที่เราสามารถ
กำหนดเองได้ เพื่อให้ ระบบปฏิบตั ิการสามารถตัดสินใจว่า “ต้ องการนำ
หน้ าของโปรเซสเข้ ามาเท่าไหร่ในหน่วยความจำ” หรื อว่า “ต้ องการให้
หน่วยความจำหลักกับโปรเซสบางตัวเป็ นจำนวนเท่าไหร่ ” ลองพิจารณา
 ถ้ าขนาดหน้ าของหน่วยความจำน้ อย จะทำให้ มีจำนวนโปรเซสเข้ า
มาใช้ งานหน่วยความจำมากขึ ้น ทำให้ ความน่าจะเป็ นของระบบ
ปฏิบตั ิการสามารถค้ นพบโปรเซสอย่างน้ อยหนึง่ โปรเซสที่พร้ อมที่
จะทำงานมากขึ ้น และทำให้ เสียเวลาในการสลับหน้ าน้ อยลง
ั ก
การสั
(Page replacement
algorithms)
 ถ้ าจำนวนหน้ าของโปรเซสหนึง่ ๆ ที่สามารถอยูใ่ นหน่วยความ
จำหลักน้ อย (จำนวนเฟรมน้ อย) จะทำให้ อตั ราการเกิดการผิดหน้ า
สูงมากขึ ้น เพราะว่าความสัมพันธ์ระหว่างอัตราการผิดหน้ าและ
จำนวนเฟรมในหน่วยความจำเป็ นแบบไฮเพอร์ บอลา (hyperbola)
ดังในรูป
 ถ้ าการกำหนดขนาดของหน้ าคงที่แล้ ว การให้ หน่วยความจำเพิ่ม
กับโปรเซสใดโปรเซสหนึง่ จะไม่มีผลกระทบต่ออัตราการผิดหน้ า
มากนัก
 หัวข้ อที่ 3 เกี่ยวข้ องกับวิธีใช้ และอัลกอริ ทม
ึ่ ของการสับเปลี่ยนหน้ าซึง่ เรา
จะพิจารณารายละเอียดต่อไป
ั ก
ลักษณะการแบ่งหน้ าที่มีความสัมพันธ์กบั อัตราการผิดหน้ า
ั ก
อัอัลลกอริ
กอริทท่มึ ่มึ การสั
นหน้าา
 วิธีสบั เปลี่ยนแบบมาก่อน-ออกก่อน (First-in First-out Algorithm)
 ใช้ เวลาที่หน้ านันถู
้ กนำเข้ ามาในหน่วยความจำเป็ นเกณฑ์ในการตัดสินใจ
 เมื่อต้ องการเลือกหน้ าบางหน้ าออก ก็ให้ เลือกจากหน้ าที่เข้ ามานานที่สดุ
 เราอาจจะไม่ต้องจดเวลาจริ ง ๆ ที่หน้ านันเข้
้ ามาใช้ งานก็ได้ เพียงแต่สร้ างคิว
แบบมาก่อน-ออกก่อน (FIFO queue)
ั ก
นหน้าา
 วิธีสบั เปลี่ยนแบบมาก่อน-ออกก่อน (First-in First-out Algorithm)
 จากตัวอย่าง เกิดการผิดหน้ า 15 ครัง้
 การผิดหน้ าก็จะเกิดขึ ้นเกือบจะทันทีเมื่อนำหน้ าที่กำลังใช้ งานนันกลั
้ บมา
และหน้ าบางหน้ าในหน่วยความจำก็จะถูกสับเปลี่ยนออกไปแทน
 การสับเปลี่ยนที่ไม่ดีจะเพิ่มอัตราการผิดหน้ าได้ และทำให้ การทำงานของโปร
เซสช้ าลง แต่จะไม่ทำให้ ระบบทำงานผิดพลาด
 ปกติกำหนดเฟรมที่มียิ่งมากจะทำให้ เกิดการผิดหน้ าน้ อยลง แต่ปรากฏณ์นี ้ไม่
จริ งเสมอไป จากตัวอย่างที่จะกล่าวต่อไป จะเห็นว่าเมื่อมีจำนวนเฟรมเป็ น 4
จะเกิดการผิดหน้ าน้ อยกว่าเมื่อมีจำนวนเฟรมเป็ น 3 ลักษณะที่เกิดนี ้เรี ยกว่า
ปรากฎการณ์ เบลาดี ้ (Balady’s anomaly)
ั ก
Reference string : 1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5
กราฟการผิดหน้ าของวิธีสบั เปลี่ยนแบบมาก่อน-ออกก่อน

ั ก
นหน้าา
 วิธีสบั เปลี่ยนแบบให้ โอกาสครัง้ ที่สอง (Second Chance Page
Replacement Algorithm)
 ปรับปรุงวิธี FIFO โดยการป้องกันการเปลี่ยนหน้ าที่ถกู เรี ยกใช้ งานบ่อยออกไป
 ทำได้ โดยการเช็คที่บิต Referenced (R) ของหน้ าที่เข้ ามานานที่สดุ
 ถ้ าบิต R มีคา่ เป็ น 0 ก็แสดงว่าหน้ านันเก่
้ าและไม่ได้ ถกู เรี ยกใช้ งานเลย
ระบบก็สามารถทำการสับเปลี่ยนได้ ทนั ที
 ถ้ าบิต R มีคา่ เท่ากับ 1 ก็ให้ กำหนดให้ บิต R นันเป็
้ น 0 และนำหน้ านัน้
กลับไปเข้ าแถวใหม่อีกครัง้
 ทำการเปลี่ยนแปลงเวลาของหน้ านันใหม่ ้ เหมือนดังหน้ านันพึ ้ ง่ เข้ ามาใน
หน่วยความจำ จากนันก็ ้ ทำการค้ นหาหน้ าที่จะถูกสับเปลี่ยนต่อไป
ั ก
วิธีสบั เปลี่ยนแบบให้ โอกาสครัง้ ที่สอง
ั ก
นหน้าา
 วิธีการสับเปลี่ยนแบบวงรอบนาฬิกา (Clock Page Replacement
Algorithm)
 วิธีการให้ โอกาสครัง้ ที่สองจะเป็ นวิธีการที่เป็ นเหตุเป็ นผลพอสมควร
แต่ไม่มีประสิทธิภาพมากนัก
 เพราะการที่ระบบย้ ายหน้ าไปมาในลิสต์นน ั่ ทำให้ ระบบเสียเวลาพอ
สมควร
 วิธีการที่สามารถปรับปรุ งวิธีการดังกล่าวได้ ก็คือ ให้ เราเรี ยงเฟรมทุก
เฟรมเป็ นรูปวงกลมให้ เหมือนรูปนาฬิกา และมีเข็มนาฬิกาชี ้ไปที่
หน้ าที่เก่าที่สดุ
ั ก
นหน้าา
 วิธีการสับเปลี่ยนแบบวงรอบนาฬิกา (Clock Page Replacement
Algorithm)
เมื่อมีการผิดหน้ าเกิดขึ ้น หน้ าที่มีเข็มนาฬิกาชี ้อยูจ่ ะถูกตรวจสอบ
 ถ้ าบิต R มีคา่ เป็ น 0 หน้ านันก็้ จะถูกสับเปลี่ยนออกไป และหน้ าใหม่ก็
จะถูกใส่เข้ ามาในตำแหม่งเดิม พร้ อมกันนัน้ เข็มนาฬิกาก็จะทำการ
เลื่อนไปด้ านหน้ า 1 ตำแหน่ง
 แต่ถ้าบิต R ถูกกำหนดเป็ น 1 ก็ให้ ลบค่าของบิตนันเป็ ้ น 0 และเลื่อนเข็ม
ไปหน้ าถัดไป
 วิธีดงั กล่าวจะถูกทำซ้ำจนกว่าเราจะได้ หน้ าที่มีบิต R เป็ น 0 ซึง่ วิธีการนี ้จะ
เหมือนวิธีการแบบให้ โอกาสครัง้ ที่ 2 เลย เพียงแต่แตกต่างกันไปในวิธีการใช้
งานเท่านัน้
ระบบปฏิบต ั กิ าร (Operating Systems) 93
วิธีสบั เปลี่ยนแบบวงรอบนาฬิกา
ั ก
นหน้าา
 วิธีสบั เปลี่ยนแบบที่ดีที่สดุ (Optimal Page Replacement Algorithm)
 วิธีสบ ั เปลี่ยนหน้ าที่ดีที่สดุ ที่จะทำให้ อตั ราการผิดหน้ าต่ำที่สดุ
 จะต้ องไม่เกิดปรากฏการณ์เบลาดี ้
 วิธีการก็คือ “ให้ เลือกสับเปลี่ยนหน้ าที่จะไม่ถก ู เรี ยกใช้ งาน และมี
ระยะเวลารอการเรี ยกใช้ ที่นานที่สดุ ”
ั ก
 วิธีนี ้จะทำให้ เกิดการผิดหน้ า 9 ครัง้ ซึง่ ดีกว่าวิธีแบบ FIFOมาก (มีการผิด
หน้ า 15 ครัง้ )
 ถ้ าไม่คิดการผิดหน้ า 3 ครัง้ แรก ซึง่ จะต้ องเกิดขึ ้นอย่างแน่นอน จะเห็นได้
ว่าแบบที่ดีที่สดุ นี ้ดีกว่าแบบ FIFO ได้ ถงึ 2 เท่า
 วิธีแบบที่ดีที่สดุ นี ้ยากที่จะสร้ างได้ จริง ๆ เพราะเราต้ องรู้ในอนาคตว่า จะ
มีการเรี ยกหน้ าใดเมื่อไหร่
 วิธีแบบที่ดีที่สด ุ นี ้ จึงมีไว้ เพื่อใช้ ในการเปรี ยบเทียบเท่านัน้
ั ก
นหน้าา
 การสับเปลี่ยนแบบที่ไม่ได้ ใช้ งาน-ออกก่อน (NRU : Not Recently Used)
 นำวิธีการสับเปลี่ยนแบบวงรอบนาฬิกามาเพิ่มประสิทธิภาพ
 โดยพิจารณาบิตสำคัญในตารางหน้ าเพิ่มขึ ้นอีกหนึง่ บิต ซึง่ ก็คือวิธี
แบบที่ไม่ได้ ใช้ งาน-ออกก่อน (NRU)
 เนื่องจากระบบปฏิบต ั ิการสามารถทำการเก็บข้ อมูลสถิติวา่ หน้ าใดที่
กำลังถูกใช้ หรื อ ที่ไม่ได้ ใช้ งาน ได้ จากบิตในแถวของตารางหน้ าที่
แสดงสถานะ การทำงานของแต่ละหน้ า
 บิต Referenced จะถูกกำหนดเป็ น 1 เมื่อหน้ านันถู ้ กเรี ยกใช้ งาน
และบิต Modified จะถูกกำหนดเป็ น 1 เมื่อหน้ านันมี ้ การ
เปลี่ยนแปลง
ั ก
นหน้าา
 บิตทังสองนั
้ นเป็
้ นฟิ ลด์ที่อยูใ่ นแถวของตารางหน้ า และจะถูก
เปลี่ยนแปลงค่าทุกครัง้ เมื่อมีการเรี ยกใช้ งาน
 วิธีการสับเปลี่ยนหน้ าแบบนี ้เป็ นดังนี ้
 เริ่ มทำงาน บิตทังสองในทุ
้ ก ๆ หน้ าจะถูกกำหนดเป็ น 0
 เมื่อครบวงรอบของระยะเวลาหนึง่ ๆ เช่น จากการแทรกของอินเทอร์ รัพต์
(clock interrupt) บิต R ก็จะถูกกำหนดค่าเป็ น 0 เพื่อเป็ นตัวแยกหน้ าที่
ไม่ได้ ถกู เรี ยกใช้ งานออกจากหน้ าอื่น ๆ
 เมื่อมีการผิดหน้ าเกิดขึ ้น ระบบปฏิบตั ิการจะทำการตรวจสอบทุกหน้ า
และแบ่งหน้ าเหล่านันออกเป็
้ น 4 กลุม่ ขึ ้นอยูก่ บั ค่าของบิต R และ บิต M
ั ก
นหน้าา
 กลุม่ ที่ 0: ไม่ถกู เรี ยกใช้ งาน และ ไม่มีการเปลี่ยนแปลงค่า
 กลุม ่ ที่ 1: ไม่ถกู เรี ยกใช้ งาน แต่ มีการเปลี่ยนแปลงค่า
 กลุม ่ ที่ 2: ถูกเรี ยกใช้ งาน แต่ ไม่มีการเปลี่ยนแปลงค่า
 กลุม ่ ที่ 3: ถูกเรี ยกใช้ งาน และ มีการเปลี่ยนแปลงค่า
 ดูเหมือนว่า ไม่มีทางเป็ นไปได้ ที่จะมีหน้ าอยูใ่ นกลุม่ ที่ 1 แต่ มันก็อาจจะเกิดขึ ้น
ได้ ในกรณีที่หน้ าในกลุม่ ที่ 3 นันถู ้ กระบบปฏิบตั ิการทำการกำหนดบิต R เป็ น 0
เมื่อครบวงรอบของระยะเวลาหนึง่ ๆ ซึง่ ระบบปฏิบตั ิการไม่ได้ กำหนดบิต M
เป็ น 0 ด้ วย เพราะเราต้ องการข้ อมูลที่วา่ หน้ านันจะต้้ องถูกเขียนทับกลับลงไป
ในดิสก์ด้วยหรื อไม่ จึงทำการเคลียร์ บิต R แต่ ไม่แตะต้ องบิต M และทำให้ หน้ า
นันอยู
้ ใ่ นกลุม่ ที่ 1
ั ก
นหน้าา
 วิธีนี ้จะสุม
่ เอาหน้ าออกจากกลุม่ ลำดับต่ำสุด (เช่นกลุม่ ที่ 1 มีลำดับ
ต่ำกว่ากลุม่ ที่ 2 และ 3 ตามลำดับ) ที่มีหน้ าของโปรเซสอยู่
 วิธีการนี ้ยังดูเหมือนว่าจะพยายามที่จะนำเอาหน้ าที่ถก ู เปลี่ยนแปลง
แต่ไม่ได้ ถกู เรี ยกใช้ งานหรื ออ้ างอิงถึงออกทุกครัง้ ที่มีการครบวงรอบ
นาฬิกา (ประมาณ 20 msec) มากกว่าหน้ าที่ไม่มีการเปลี่ยนแปลง
แต่ถกู เรี ยกใช้ งานบ่อย
 ข้ อเด่นของวิธี NRU คือ ง่ายที่จะทำความเข้ าใจ, ไม่ยากเกินไปที่จะ
นำมาใช้ งานจริ ง และ มีประสิทธิภาพค่อนข้ างดี
ั ก
การสับเปลี่ยนหน้ าแบบ NRU
ั ก
นหน้าา
 การสับเปลี่ยนแบบใช้ งานน้ อยที่สดุ -ออกก่อน (Least Recently Used)
 วิธีแบบที่ดีที่สดุ (OPT) เป็ นไปไม่ได้ ในทางปฏิบตั ิ
 แบบ FIFO จะดูเวลาที่สบั เปลี่ยนหน้ าเข้ ามาในหน่วยความจำ
 แบบ OPT จะดูเวลาที่หน้ าถูกเรี ยกใช้ งาน
 ถ้ าเราใช้ ข้อมูลในอดีตที่ผา่ นมา ประมาณการณ์อนาคตอันใกล้ เราอาจจะสับ
เปลี่ยนหน้ าที่ไม่ได้ ถกู เรี ยกใช้ งาน เป็ นเวลานานที่สดุ ซึง่ เรี ยกว่า แบบใช้ งาน
น้ อยที่สดุ -ออกก่อน (LRU)
 วิธีนี ้จะบันทึกเวลาที่แต่ละหน้ าถูกอ้ างอิงครัง้ ล่าสุดไว้ เมื่อต้ องการเลือกหน้ า
เพื่อสับเปลี่ยนออก ก็จะเลือกหน้ าที่ไม่ได้ ใช้ มาเป็ นเวลานานสุด (หน้ าที่มีตวั เลข
เวลาน้ อยที่สดุ )
 จะเห็นได้ วา่ วิธีการนี ้ มองย้ อนเวลาไปในอดีต แทนที่จะมองไปในอนาคต
ั ก
การสับเปลี่ยนหน้ าแบบ LRU
ั ก
นหน้าา
 ถึงแม้ วา่ LRU น่าจะใช้ งานได้ ดีในทางทฤษฎี แต่ก็ไม่งา่ ยนักในทางปฏิบตั ิ
 เนื่องจากการใช้ LRU นัน้ ระบบจะต้ องสร้ างลิงค์ลสิ ต์ของทุก ๆ หน้ าในหน่วย
ความจำที่มีหน้ าที่ใช้ งานน้ อยอยูท่ ี่หวั แถวและหน้ าที่ใช้ งานบ่อยอยูท่ ้ ายสุด
 ความยากของวิธีนี ้ก็อยูท่ ี่วา่ ลิสต์จะต้ องทำการปรับเปลี่ยนทุกครัง้ ที่มีการอ้ างอิง
ถึง หรื อมีการเรี ยกใช้ งานในหน่วยความจำ
 การค้ นหาหน้ าในลิสต์, การทำการลบ, หรื อการย้ ายหน้ าไปมานัน้ ล้ วนแต่
เป็ นการทำงานที่ต้องใช้ เวลาของโปรเซสเซอร์ ทงสิ ั ้ ้น
 LRU จะใช้ ฮาร์ ดแวร์ ที่มีตวั นับ หรื อ counter (C) แบบ 64 บิต ที่จะทำการเพิ่ม
ค่าทุกครัง้ ที่มีการเรี ยกใช้ งาน
ั ก
นหน้าา
 ในตารางหน้ าของแต่ละหน้ าจะมีฟิลด์ขนาดใหญ่ที่สามารถใส่คา่ ของตัวนับนี ้ได้
หลังจากที่มีการอ้ างอิงหน่วยความจำในแต่ละครัง้ ค่า C ก็จะถูกบันทึกลงใน

ตารางหน้ าของหน้ านัน้ ๆ
 เมื่อมีการผิดหน้ า ระบบจะต้ องทำการตรวจสอบทุกค่าของ C ในตารางหน้ า
เพื่อค้ นหาหน้ าที่มีคา่ C น้ อยที่สดุ ซึง่ หน้ านันก็
้ คือหน้ าที่ใช้ งานน้ อยที่สดุ นันเอง้
 ถ้ าระบบมี n เพจเฟรม ทำให้ ฮาร์ ดแวร์ นนจะต้ ั ้ องดูแลเมตทริ กซ์ n x n บิต
 ค่าเริ่ มต้ นเป็ น 0 หมด เมื่อใดก็ตามที่เพจเฟรม k ถูกอ้ างอิงถึง ฮาร์ ดแวร์ นนก็ ั ้ จะ
กำหนดให้ ทกุ บิตในแถว k เป็ น 1 และกำหนดให้ ทกุ บิตในคอลัมภ์ k เป็ น 0
 เมื่อมีการตรวจสอบ แถวที่มีค่าของบิตรวมกันน้ อยที่สุดก็คือ แถวที่ถก ู เรี ยก
ใช้ งานน้ อยที่สดุ
ระบบปฏิบต ั ก
0 1 2 3 2 1 0 3 2 3
การสับเปลี่ยนหน้ าแบบ LRU
หน้ าที่อยูใ่ นเฟรมที่ 1 ก็จะถูกเลือกออกเพราะไม่ได้ ถกู เรี ยกใช้ งานนานที่สดุ
ั ก
ผลรวมของเฟรม 0 และ เฟรมที่ 3 มีคา่ เท่ากัน
Frame 0 = (0 1 0 0) = 4 (ฐานสิบ)
Frame 3 = (0 0 1 0) = 2 (ฐานสิบ)
ก็ให้ เลือกหน้ าในเฟรมที่ 3 ออก เพราะมีคา่ น้ อยกว่าเฟรมที่ 0
ั ก
เปรี ยบเทียบการสับเปลี่ยนหน้ าแบบ OPT, LRU, FIFO และ CLOCK
ั ก
การแบ่
การแบ่งงเป็เป็นเซ็
นเซ็กกเมนต์
เมนต์ (Segmentation)
(Segmentation)
 การแบ่งแบบนี ้มีลกั ษณะการทำงานคล้ ายกับการแบ่งเป็ นหน้ าของโปรเซส
 แต่การแบ่งแบบเซ็กเมนต์ หรื อ segmentation นัน้ จะแบ่งโปรเซส หรื อ

โปรแกรมออกเป็ นส่วน ๆ โดยแต่ละส่วนนันไม่ ้ จำเป็ นต้ องมีความยาวเท่า
กัน (แต่ก็อาจจะมีการกำหนดให้ อยูภ่ ายใต้ ขนาดที่ใหญ่ที่สดุ ที่ระบบ
กำหนดได้ )
 การแปลงแอ็ดเดรสทางตรรกเป็ นแอ็ดเดรสจริ งในหน่วยความจำจะต้ องใช้
ข้ อมูล 2 ส่วน คือ เลขที่ของเซ็กเมนต์ และ ระยะเริ่มต้ นจากเซ็กเมนต์นนั ้
(offset)
ั ก
การแบ่งเป็ นเซ็กเมนต์
ั ก
การแบ่
(Segmentation)
 เนื่องจากการแบ่งเป็ นเซ็กเมนต์ทำให้ เกิดชิ ้นส่วนที่ไม่เท่ากัน ซึง่ จะเหมือน
การแบ่งหน่วยความจำแบบเปลี่ยนแปลงขนาดได้ (dynamic partitioning)
 ข้ อแตกต่างคือ โปรแกรมหนึง่ ๆ อาจจะมีหลายส่วน (หรื อหลายเซ็กเมนต์)

ที่สามารถใช้ งานในหลาย ๆ พาร์ ติชนั่ ได้ และพาร์ ติชนั่ เหล่านี ้ก็ไม่ จำเป็ น
ต้ องติดกันด้ วย
 การแบ่งเป็ นเซ็กเมนต์นี ้จะช่วยลดปั ญหาการสูญเสียพื ้นที่ภายใน (internal
fragmentation) แต่จะมีการสูญเสียพื ้นที่ภายนอกอยู่ เหมือนการแบ่งพาร์
ติชนั่ แบบเปลี่ยนแปลงขนาดได้ นนั่ เอง
 อย่างไรก็ตามเนื่องจากโปรเซสถูกแบ่งออกเป็ นชิ ้นเล็ก ๆ การสูญเสียพื ้นที่
ภายนอกก็บควรจะเล็
ระบบปฏิ ต ิ าร ก(Operating
ั ก ลงตามไปด้Systems)
วย 111
การแบ่
(Segmentation)
 การแบ่งเป็ นหน้ านัน้ โปรแกรมเมอร์ จะไม่สามารถมองเห็นและมีสว่ นร่วมได้
 การแบ่งเป็ นเซ็กเมนต์นนั ้ โปรแกรมเมอร์ จะสามารถมองเห็นและมีสว่ นร่วมในการ
จัดการกับโปรแกรมและข้ อมูลของตนได้
 โดยปกติโปรแกรมเมอร์ หรื อคอมไพล์เลอร์ จะทำการแบ่งโปรแกรมและข้ อมูลออกเป็ น
ส่วน ๆ เอง เช่น การใช้ โมดูลในการเขียนโปรแกรม (Module)
 ผลของการแบ่งหน่วยความจำเป็ นส่วน ๆ ที่ไม่เท่ากัน จึงทำให้ ความสัมพันธ์ระหว่าง
แอ็ดเดรสทางตรรกกับแอ็ดเดรสจริ งเป็ นความสัมพันธ์ที่คอ่ นข้ างซับซ้ อน
 โดยใช้ ตารางของเซ็กเมนต์ (segmentation table) เก็บรายละเอียดของแต่ละโปรเซส
และแอ็ดเดรสเริ่ มต้ นของที่วา่ งในหน่วยความจำ
 รวมทังเก็
้ บค่าความยาวของเซ็กเมนต์นนั ้ ๆ ด้ วย เพื่อเป็ นการยืนยันว่าระบบจะไม่ใช้
แอ็ดเดรสที่ไม่ถกู ต้ อง
ั ก
การแบ่
(Segmentation)
 ขันตอนของการแปลงแอ็
้ ดเดรสดังนี ้
 แยกตัวเลขบอกเซ็กเมนต์ทางด้ านซ้ ายมือจำนวน n บิต ออกจากแอ็ดเดรสทาง
ตรรก
 ใช้ ตวั เลขบอกเซ็กเมนต์เป็ นอินเด็กซ์ในตารางของเซ็กเมนต์ เพื่อหาจุดเริ่ มต้ น
แอ็ดเดรสจริ งทางกายภาพของเซ็กเมนต์นนั ้ ๆ
 ทำการเปรี ยบเทียบระยะห่างจากขอบเซ็กเมนต์ (offset: m บิตทางด้ านขวามือ)
กับขนาดความยาวของเซ็กเมนต์นนั ้ ถ้ าระยะห่างนันมากกว่
้ าความยาวของ
เซ็กเมนต์ ก็จะได้ ที่อยูท่ ี่ไม่ถกู ต้ อง
 ถ้ าระยะห่างนันน้
้ อยกว่าความยาวของเซ็กเมนต์ ก็สามารถหาที่อยูข่ อง
เซ็กเมนต์นนได้
ั ้ จาก ผลรวมของจุดเริ่ มต้ นของเซ็กเมนต์ กับ ระยะห่างจากขอบ
ของเซ็กเมนต์
ั ก
0010000000100000
001011110000
= 0010001100010000
การแปลงแอ็ดเดรสทางตรรกเป็ นแอ็ดเดรสจริงของ Segmentation
ั ก
การนำการแบ่
การนำการแบ่งงเป็เป็นเซ็
เมนต์มมาใช้
าใช้ใในหน่
นหน่ววยความจำเสมื
ยความจำเสมืออนน
 การแบ่งเป็ นเซ็กเมนต์ นัน้ จะอนุญาตให้ โปรแกรมเมอร์ สามารถมองเห็นว่าหน่วย
ความจำนันประกอบขึ
้ ้นจากชิ ้นส่วนเล็ก ๆ และชิ ้นส่วนของหน่วยความจำเหล่านี ้
อาจจะมีขนาดไม่เท่ากัน และไม่คงที่ การอ้ างอิงถึงแอ็ดเดรสในหน่วยความจำจะต้ อง
ใช้ เลขที่ของเซ็กเมนต์ และระยะเริ่ มต้ นจากเซ็กเมนต์นนั ้ มีข้อดีหลาย ๆ ข้ อ ดังนี ้
 การจัดการกับการเพิ่มโครงสร้ างของข้ อมูลในโปรแกรมสามารถทำได้ งา่ ย ถ้ า
โปรแกรมเมอร์ ไม่สามารถทราบอนาคตว่าโครงสร้ างของข้ อมูลจะมีขนาดเป็ น
เท่าไหร่ และไม่สามารถแบ่งพื ้นที่แบบที่เปลี่ยนแปลงขนาดได้ ต้ องประมาณ
ขนาดของข้ อมูลก่อน แต่การแบ่งแบบนี ้โครงสร้ างข้ อมูลจะถูกกำหนดให้ อยูใ่ น
ส่วนของตน และระบบจะทำการขยาย หรื อย่อขนาดส่วนนันได้ ้ เมื่อต้ องการ
ถ้ าเซ็กเมนต์นนต้
ั ้ องการขยายในหน่วยความจำหลัก แต่ไม่มีพื ้นที่เพียงพอ
ระบบอาจจะทำการย้ ายส่วนนันไปยั ้ งพื ้นที่ในหน่วยความจำที่มีขนาดใหญ่ขึ ้น
ั ก
 วิธีการนี ้สามารถทำให้ เราเปลี่ยนแปลง หรื อคอมไพล์โปรแกรมแยกออกเป็ น
ส่วน ๆ ได้ โดยไม่จำเป็ นที่จะต้ องให้ โปรแกรมย่อย ๆ เหล่านันถู
้ กโหลดขึ ้นมา
ใหม่ หรื อเชื่อมโยงกัน
 การแบ่งเป็ นเซ็กเมนต์นี ้อนุญาตให้ มีการแชร์ ข้อมูลระหว่างโปรเซสหลาย ๆ โปร
เซส เช่น โปรแกรมเมอร์ สามารถนำโปรแกรมยูทิลติ ี ้ หรื อข้ อมูลที่เป็ นประโยชน์
ใส่ลงในส่วนของเซ็กเมนต์หนึง่ ๆ ที่สามารถถูกอ้ างอิงโดยโปรเซสอื่น ๆ ได้
 การแบ่งแบบนี ้อนุญาตให้ มีการป้องกันข้ อมูลด้ วยตัวเองได้ เพราะส่วนของ
เซ็กเมนต์หนึง่ ๆ นันจะถู
้ กสร้ างขึ ้นมาเพื่อใส่โปรแกรม หรื อข้ อมูลที่ได้ รับการ
นิยามมาอย่างดีแล้ ว ซึง่ โปรแกรมเมอร์ ที่เป็ นผู้ดแู ลระบบสามารถกำหนดสิทธิ
ในการเข้ าถึงข้ อมูลในส่วนนันได้
้
ั ก
 ระบบที่มีการแบ่งเป็ นเซ็กเมนต์นนั ้ โปรเซสแต่ละตัวจะมีตารางของ
เซ็กเมนต์ (segmentation table) เป็ นของตัวเอง
 เมื่อทุกส่วนของเซ็กเมนต์ถก ู โหลดเข้ าไปในหน่วยความจำหลัก ตาราง
เซ็กเมนต์ของโปรเซสก็จะถูกสร้ างขึ ้นมา และถูกโหลดไว้ ในหน่วยความ
จำหลัก
 แต่ละแถวของตารางประกอบด้ วยแอ็ดเดรสเริ่ มต้ นของเซ็กเมนต์นนใน ั้
หน่วยความจำหลัก และความยาวของเซ็กเมนต์นนั ้
 เซ็กเมนต์บางส่วนของโปรเซสอยูใ่ นหน่วยความจำหลักหรื อไม่ก็ได้
 จึงต้ องมี 1 บิต (P) เป็ นฟิ ลด์ของตารางที่จะบอกว่าเซ็กเมนต์ดงั กล่าวอยูใ่ น
หน่วยความจำหลักหรื อไม่
ั ก
 ถ้ าบิตนันแสดงว่
้ าเซ็กเมนต์นนอยู
ั ้ ใ่ นหน่วยความจำหลักแล้ ว แถวดังกล่าว
ก็จะต้ องมีแอ็ดเดรสเริ่ มต้ นและความยาวของเซ็กเมนต์นนั ้
 บิตที่ใช้ ในการเช็คการเปลี่ยนแปลง (Modified bit) จะทำหน้ าที่เหมือนกับ
บิต Modified ในวิธีการแบ่งเป็ นหน้ า (paging)
 ถ้ าเซ็กเมนต์ใดมีการเปลี่ยนแปลง ตังแต่ ้ เมื่อเซ็กเมนต์นนถู
ั ้ กโหลดเข้ าไป
อยูใ่ นหน่วยความจำ ก็ให้ ทำการเขียนเซ็กเมนต์นนกลั ั ้ บลงสูด่ ิสก์เมื่อมีการ
สับเปลี่ยนเซ็กเมนต์ที่อยูใ่ นเฟรม
 ระบบสามารถเพิ่มเติมบิตควบคุมอื่น ๆ ได้ อีก เช่น บิตที่ใช้ สำหรับการ
ป้องกันการเข้ าถึงข้ อมูลในเซ็กเมนต์ที่ต้องการ
ั ก
 วิธีการพื ้นฐานที่ใช้ สำหรับอ่านคำจากหน่วยความจำ จะเกี่ยวข้ องกับการ
แปลงแอ็ดเดรสเสมือน หรื อแอ็ดเดรสทางตรรก ที่ประกอบด้ วย
 ตัวเลขบอกเซ็กเมนต์
 ระยะห่างจากขอบเซ็กเมนต์
 จากค่าทังสองทำให้
้ สามารถหาค่าแอ็ดเดรสจริงทางกายภาพ โดยใช้
ตารางเซ็กเมนต์ชว่ ย
 เนื่องจากตารางเซ็กเมนต์มีขนาดไม่คงที่ และขึ ้นอยูก ่ บั ขนาดของโปรเซส
ดังนัน้ เราจึงไม่สามารถนำตารางนี ้ไปเก็บไว้ ในรี จิสเตอร์ ได้ (จึงต้ องเก็บไว้
ในหน่วยความจำหลัก)
ั ก
แอ็ดเดรสทางตรรก และตาราง Segmentation
ั ก
การรวมวิ
การรวมวิธธีกีการแบ่
ารแบ่งงเป็เป็นหน้
นหน้าากักับบการแบ่
เมนต์เเข้ข้าาด้ด้ววยกั
ยกันน
 ทังวิ
้ ธีการแบ่งเป็ นหน้ า (paging) และวิธีการแบ่งเป็ นเซ็กเมนต์
(segmentation) จะมีข้อดีของแต่ละวิธีที่แตกต่างกัน
 ข้ อดีของการแบ่งเป็ นหน้ า คือ
 การปกปิ ดไม่ให้ โปรแกรมเมอร์ มองเห็นการทำงานของมัน
 การป้องกันการสูญเสียพื ้นที่ภายนอก (external fragmentation)
 จะทำให้ ระบบใช้ หน่วยความจำหลักอย่างมีประสิทธิภาพ
 เนื่องจากหน้ าของโปรเซสที่ถกู สลับเข้ าและออกจากหน่วยความจำนัน้ มีขนาด
คงที่ และเท่ากัน จึงมีความเป็ นไปได้ ที่เราจะพัฒนาอัลกอริ ทมึ่ ที่ซบั ซ้ อนเพื่อนำ
ไปใช้ ในการจัดการกับหน่วยความจำ ดังที่เคยกล่าวมาแล้ วในหัวข้ อเกี่ยวกับ
การสับเปลี่ยนหน้ าในแบบต่าง ๆ
ั ก
ยกันน
 ข้ อดีของการแบ่งเป็ นเซ็กเมนต์ คือ
 โปรแกรมเมอร์ สามารถมองเห็นการทำงาน
 ความสามารถในการจัดการกับโครงสร้ างข้ อมูลที่มีขนาดไม่คงที่
 การทำโปรแกรมเป็ นโมดูล
 การสนับสนุนการแบ่งปั นและการป้องกันเซ็กเมนต์
 ในระบบที่มีการทำงานร่วมกันระหว่างการแบ่งเป็ นหน้ า และการแบ่งเป็ นเซ็กเมนต์
 พื ้นที่ใช้ งานของผู้ใช้ จะถูกแบ่งออกเป็ นเซ็กเมนต์ จำนวนหนึง่ ตามที่
โปรแกรมเมอร์ กำหนด
 ในแต่ละเซ็กเมนต์ก็จะถูกแบ่งออกเป็ นหน้ า ๆ ที่มีขนาดคงที่ และมีความยาว
เท่ากับเฟรมในหน่วยความจำ
 ถ้ าเซ็กเมนต์ใดมีความยาวน้ อยกว่าขนาดของหน้ า เซ็กเมนต์นนก็ ั ้ มีแค่ 1 หน้ า
ั ก
ยกันน
 ในระบบที่มีการทำงานร่วมกันระหว่างการแบ่งเป็ นหน้ า และการแบ่งเป็ นเซ็กเมนต์
 จากมุมมองของโปรแกรมเมอร์ นน ั ้ แอ็ดเดรสทางตรรกจะประกอบไปด้ วยเลขที่
ของเซ็กเมนต์ และระยะห่างจากขอบของเซ็กเมนต์
 ถ้ ามองจากมุมของระบบ ระยะห่างจากขอบของเซ็กเมนต์ก็จะประกอบไปด้ วย
เลขที่หน้ า และระยะห่างจากขอบหน้ าภายในเซ็กเมนต์ นันนั
้ น่ เอง
ั ก
การแปลงแอ็ดเดรสของระบบ Segmetation/Paging
ั ก
ตารางที่เกิดจากการรวม Segmentation/Paging
ั ก

Os Ch05-Memory Management

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Os Ch05-Memory Management

Uploaded by

Copyright:

Available Formats

บทที่ 5

พื ้นที่เก็บข้ อมูลย่อยที่มีขนาดเป็ นไบต์ (byte) โดยแต่ละไบต์จะมี

ความเร็วสูง, และมีความเสถียรสูง หรื อเป็ นแบบไม่ถกู ลบเลือน

 การใช้ พื ้นที่ร่วมกัน (Sharing)

(swap in and out) จากหน่วยความจำหลักได้ เพื่อให้ การใช้ งาน

 โปรเซสที่ทำงานร่วมกัน บางงานก็จะต้ องมีการแบ่งปั นข้ อมูลร่วมกันได้

• ระบบปฏิบตั ิการใช้ พื ้นที่ด้านล่าง

ข้ อเสียของการจัดคิวของโปรเซสที่จะเข้ าไปใช้ งาน

การสร้ างคิวเพียง 1 แถวให้ กบั หน่วย

สมมุติวา่ พาร์ ติชนั่ ที่ 2 ขนาด 200 เกิดช่องว่างอยู่ วิธีมาก่อนได้

สมมุติวา่ ก่อนหน้ าที่ โปรเซส X จบการทำงานเรามีลงิ ค์ลสิ ต์ของโปรเซสทังสาม

การเปลี่ยนแปลงลิสต์สามารถทำได้ โดยเปลี่ยนตัวอักษร P เป็ น H

2 พาร์ ติชนั่ จะถูกรวมเหลือเพียง 1 พาร์ ติชนั่ และทำให้ ลติ ส์มีขนาดสันลง

3 พาร์ ติชนั่ ถูกรวมเหลือเพียง 1 พาร์ ติชนั่

อาจทำการบันทึกว่าถูกเรี ยกใช้ งานครัง้ สุดท้ ายเมื่อไหร่ด้วย

ในตาราง และวิธีการแทนที่คา่ ของแถวใหม่เข้ าไปในตาราง

กราฟการผิดหน้ าของวิธีสบั เปลี่ยนแบบมาก่อน-ออกก่อน

หลังจากที่มีการอ้ างอิงหน่วยความจำในแต่ละครัง้ ค่า C ก็จะถูกบันทึกลงใน

 แต่การแบ่งแบบเซ็กเมนต์ หรื อ segmentation นัน้ จะแบ่งโปรเซส หรื อ

 ข้ อแตกต่างคือ โปรแกรมหนึง่ ๆ อาจจะมีหลายส่วน (หรื อหลายเซ็กเมนต์)

การแปลงแอ็ดเดรสทางตรรกเป็ นแอ็ดเดรสจริงของ Segmentation

You might also like