The basic idea behind paging is qui

The basic idea behind paging is quite simple: Allocate physical memory to
processes in fixed size chunks (page frames) and keep track of where the various
pages of the process reside by recording information in a page table. Every
process has its own page table that typically resides in main memory, and the
page table stores the physical location of each virtual page of the process. The
page table has N rows, where N is the number of virtual pages in the process. If
there are pages of the process currently not in main memory, the page table indicates
this by setting a valid bit to 0; if the page is in main memory, the valid bit is
set to 1. Therefore, each entry of the page table has two fields: a valid bit and a
frame number.
Additional fields are often added to relay more information. For example, a
dirty bit (or a modify bit) could be added to indicate whether the page has been
changed. This makes returning the page to disk more efficient, because if it is not
modified, it does not need to be rewritten to disk. Another bit (the usage bit) can
be added to indicate the page usage. This bit is set to 1 whenever the page is
accessed. After a certain time period, the usage bit is set to 0. If the page is referenced
again, the usage bit is set to 1. However, if the bit remains 0, this indicates
that the page has not been used for a period of time, and the system might benefit
by sending this page out to disk. By doing so, the system frees up this page’s
location for another page that the process eventually needs (we discuss this in
more detail when we introduce replacement algorithms).
Virtual memory pages are the same size as physical memory page frames.
Process memory is divided into these fixed size pages, resulting in potential internal
fragmentation when the last page is copied into memory. The process may not
actually need the entire page frame, but no other process may use it. Therefore,
the unused memory in this last frame is effectively wasted. It might happen that
the process itself requires less than one page in its entirety, but it must occupy an
entire page frame when copied to memory. Internal fragmentation is unusable
space within a given partition (in this case, a page) of memory.
Now that you understand what paging is, we will discuss how it works. When
a process generates a virtual address, the operating system must dynamically
translate this virtual address into the physical address in memory at which the
data actually resides. (For purposes of simplicity, let’s assume we have no cache
memory for the moment.) For example, from a program viewpoint, we see the
final byte of a 10-byte program as address 9, assuming 1-byte instructions and 1-
byte addresses, and a starting address of 0. However, when actually loaded into
memory, the logical address 9 (perhaps a reference to the label X in an assembly
language program) may actually reside in physical memory location 1239, implying
the program was loaded starting at physical address 1230. There must be an
easy way to convert the logical, or virtual, address 9 to the physical address 1230.
To accomplish this address translation, a virtual address is divided into two
fields: a page field and an offset field, to represent the offset within that page where
the requested data is located. This address translation process is similar to the
process we used when we divided main memory addresses into fields for the cache
mapping algorithms. And similar to cache blocks, page sizes are usually powers of
2; this simplifies the extraction of page numbers and offsets from virtual addresses.
To access data at a given virtual address, the system performs the following steps:
1. Extract the page number from the virtual address.
2. Extract the offset from the virtual address.
3. Translate the page number into a physical page frame number by accessing the
page table.
A. Look up the page number in the page table (using the virtual page number
as an index).
B. Check the valid bit for that page.
1. If the valid bit = 0, the system generates a page fault and the operating
system must intervene to
a. Locate the desired page on disk.
b. Find a free page frame (this may necessitate removing a “victim”
page from memory and copying it back to disk if memory is full).
c. Copy the desired page into the free page frame in main memory.
d. Update the page table. (The virtual page just brought in must have its
frame number and valid bit in the page table modified. If there was a
“victim” page, its valid bit must be set to zero.)
e. Resume execution of the process causing the page fault, continuing
to Step B2.

Results (Thai) 1:

ความคิดพื้นฐานเบื้องหลังเพจจิ้งเป็นค่อนข้างง่าย: จัดสรรหน่วยความจำทางกายภาพกระบวนการในถาวรขนาดก้อน (กรอบหน้า) และเก็บข้อมูลของสถานต่าง ๆหน้าของกระบวนการอยู่ โดยบันทึกข้อมูลในตารางหน้า ทุกกระบวนการมีหน้าตารางที่อยู่โดยทั่วไปในหน่วยความจำหลัก และตารางหน้าเก็บตำแหน่งทางกายภาพของแต่ละหน้าเสมือนการ ที่หน้าตารางมีแถว N โดยที่ N คือ จำนวนหน้าเสมือนในกระบวนการ ถ้าบ่งชี้ว่า ตารางหน้าหน้าของกระบวนการปัจจุบันไม่มีในหลักหน่วยความจำโดยการตั้งค่าบิตที่ถูกต้องให้ 0 หน้าอยู่ในหน่วยความจำหลัก บิตถูกต้องว่าตั้งค่าเป็น 1 ดังนั้น แต่ละรายการของตารางหน้ามีสอง: บิตถูกต้องและหมายเลขเฟรมมักจะมีเพิ่มเขตข้อมูลเพิ่มเติมเพื่อข้อมูลเพิ่มเติม ตัวอย่าง การสามารถเพิ่มบิตสกปรก (หรือบิตแก้ไข) เพื่อบ่งชี้ว่า เพจนั้นได้การเปลี่ยนแปลง ทำให้ความหน้าดิสก์มาก เนื่องจากไม่ปรับเปลี่ยน มันไม่จำเป็นต้องมีจิตไปยังดิสก์ อีกบิต (บิตใช้) สามารถถูกเพิ่มเพื่อบ่งชี้การใช้งานหน้า บิตนี้ถูกตั้งค่าเป็น 1 เมื่อหน้าอยู่เข้าถึง หลังจากช่วงเวลา บิตใช้ถูกตั้งค่าเป็น 0 ถ้ามีการอ้างอิงหน้าอีกครั้ง การใช้บิตการถูกตั้งค่าเป็น 1 อย่างไรก็ตาม ถ้าบิตเหลือ 0 บ่งชี้ไม่มีการใช้หน้าระยะเวลา และระบบอาจได้รับประโยชน์ส่งหน้านี้ออกไปยังดิสก์ โดยการทำเช่นนั้น ระบบช่วยให้หน้านี้ตำแหน่งหน้าที่อื่นในที่สุดต้องการ (เรากล่าวถึงนี้รายละเอียดเพิ่มเติมเมื่อเราแนะนำเปลี่ยนอัลกอริทึม)หน้าหน่วยความจำเสมือนมีขนาดเดียวกันกับเฟรมเพหน่วยความจำกายภาพกระบวนการหน่วยความจำถูกแบ่งออกเป็นขนาดถาวรเพจเหล่านี้ ในศักยภาพภายในกระจายตัวเมื่อหน้าสุดท้ายจะถูกคัดลอกลงในหน่วยความจำ กระบวนการอาจไม่จริง ๆ แล้ว จำเป็นเฟรมของหน้าทั้งหมด แต่ไม่มีกระบวนการอื่นอาจใช้ ดังนั้นมีประสิทธิภาพมีการสิ้นเปลืองหน่วยความจำที่ไม่ได้ใช้ในเฟรมสุดท้ายนี้ มันอาจเกิดขึ้นที่กระบวนการตัวเองต้องการน้อยกว่าหนึ่งหน้าทั้งหมด แต่ต้องการครอบครองการกรอบทั้งหน้าเมื่อคัดลอกหน่วยความจำ กระจายตัวภายในไม่สามารถใช้งานพื้นที่ภายในพาร์ติชันที่กำหนด (ในกรณีนี้ เพ) ของหน่วยความจำหลังจากที่คุณเข้าใจคืออะไรเพจจิ้ง เราจะหารือเกี่ยวกับวิธีการทำงาน เมื่อกระบวนการสร้างที่อยู่เสมือน ระบบปฏิบัติการต้องแบบไดนามิกแปลที่อยู่เสมือนนี้เป็นที่อยู่จริงในหน่วยความจำที่ยังข้อมูลอยู่จริง (สำหรับวัตถุประสงค์ของความเรียบง่าย สมมติเรามีแคไม่หน่วยความจำในขณะนี้) ตัวอย่าง จากวิวที่โปรแกรม เราเห็นตัวไบต์สุดท้ายของโปรแกรมเป็นอยู่ 9 สมมติว่าคำแนะนำ 1 ไบต์และ 1 - 10 ไบต์ไบต์ที่อยู่ และที่อยู่เริ่มต้นของ 0 อย่างไรก็ตาม เมื่อโหลดไปจริงหน่วยความจำ 9 (อาจเป็นการอ้างอิงป้ายชื่อ X ในแอสเซมบลีอยู่แบบลอจิคัลภาษาโปรแกรม) อาจจะอยู่ในตำแหน่งหน่วยความจำกายภาพ 1239 หน้าที่โปรแกรมถูกโหลดราคาเริ่มต้นที่ 1230 กายภาพ ต้องมีการวิธีง่าย ๆ ในการแปลงเชิงตรรกะ การ เสมือน 9 การกายภาพ 1230เพื่อให้บรรลุนี้แปลที่อยู่ ที่อยู่เสมือนถูกแบ่งออกเป็นสองเขตข้อมูล: เขตข้อมูลหน้าและฟิลด์ตรงข้าม ถึงตรงข้ามภายในที่หน้าสถานข้อมูลร้องขออยู่ กระบวนการแปลที่อยู่นี้จะคล้ายกับการกระบวนการที่เราใช้เมื่อเราแบ่งหลักของหน่วยความจำสำหรับแคชอัลกอริทึมของการแม็ป และเช่นเดียวกับแคบล็อก ขนาดหน้ามักจะเป็นอำนาจของ2 นี้ช่วยให้ง่ายสกัดหมายเลขหน้าและปรับค่าจากที่อยู่เสมือนการเข้าถึงข้อมูลที่อยู่เสมือนที่กำหนด ระบบทำตามขั้นตอนต่อไปนี้:1. แยกหมายเลขหน้าจากอยู่เสมือน2. แยกตรงข้ามจากอยู่เสมือน3. แปลหมายเลขหน้าหมายเลขเฟรมของหน้าทางกายภาพ โดยการเข้าถึงตารางหน้าA. หมายเลขหน้าในตารางหน้า (เลขหน้าเสมือนโดยใช้การค้นหาเป็นดัชนี)B. ตรวจสอบบิตถูกต้องสำหรับเพจนั้น1. ถ้าบิตถูกต้อง = 0 ระบบสร้างเพจฟอลต์และทำต้องการแทรกแซงระบบการอ.หาเพจที่ต้องบนดิสก์b. หาเฟรมหน้าฟรี (นี้อาจผนวกเอา "เหยื่อ"หน้าจากหน่วยความจำและการคัดลอกกลับไปยังดิสก์ถ้าหน่วยความจำจะเต็ม)ค.คัดลอกหน้าต้องเป็นกรอบหน้าฟรีในหน่วยความจำหลักd. ปรับปรุงตารางหน้า (เพเสมือนห้องนำในตัวหมายเลขเฟรมและบิตถูกต้องในตารางหน้าปรับเปลี่ยน ถ้ามีการ"เหยื่อ" หน้า บิตถูกต้องต้องตั้งศูนย์)e. ต่อการดำเนินการของกระบวนการก่อให้เกิดข้อบกพร่องหน้า ต่อไปไปยังขั้นตอน B2

Results (Thai) 3:

ความคิดพื้นฐานหลังเพจค่อนข้างง่าย : จัดสรรหน่วยความจำกระบวนการซ่อมชิ้นขนาด

( เฟรมหน้าและติดตามที่หน้าเว็บต่างๆ
ของกระบวนการอยู่ โดยบันทึกข้อมูลในตารางหน้า ทุก
กระบวนการของตัวเองหน้าโต๊ะที่มักจะอยู่ในหน่วยความจำหลัก และหน้าโต๊ะ
ร้านค้าตำแหน่งทางกายภาพของแต่ละหน้าเสมือนจริงของกระบวนการ
หน้าโต๊ะมี N แถวที่ n คือจำนวนของเสมือนหน้าในกระบวนการ ถ้า
มีหน้าของกระบวนการในขณะนี้ไม่ได้อยู่ในหน่วยความจำหลัก หน้าโต๊ะบ่งบอก
นี้โดยการตั้งค่าบิตที่ 0 ; ถ้าหน้าอยู่ในหน่วยความจำหลัก บิตที่ถูกต้อง
ชุด 1 ดังนั้น แต่ละรายการของหน้าโต๊ะมี 2 สาขา : บิตที่ถูกต้องและ

กรอบเลขข้อมูลเพิ่มเติม คือ มักจะเพิ่มรีเลย์ ข้อมูลเพิ่มเติม ตัวอย่างเช่น ,
บิตสกปรก ( หรือแก้ไขบิต ) จะถูกเพิ่มเพื่อบ่งชี้ว่าหน้าได้รับ
เปลี่ยน นี้จะทำให้กลับมาหน้าดิสก์ที่มีประสิทธิภาพมากขึ้น เพราะถ้ามันไม่ได้
แก้ไขก็ไม่ต้องถูกเขียนไปยังดิสก์ บิตอื่น ๆ ( การใช้บิต ) สามารถ
เพิ่มแสดงหน้าการใช้งานบิตนี้จะตั้งค่าเป็น 1 เมื่อหน้า
เข้าถึง หลังจากช่วงระยะเวลาหนึ่ง การใช้บิตถูกตั้งค่าเป็น 0 ถ้าหน้าอ้างอิง
อีกครั้ง การใช้บิตถูกตั้งค่าเป็น 1 แต่ถ้าบิตยังคง 0 นี้บ่งชี้
ที่หน้ายังไม่ได้ใช้สำหรับรอบระยะเวลา และระบบจะส่งหน้านี้ประโยชน์
ออกดิสก์ โดยการทำเช่นนี้ระบบอิสระขึ้นหน้านี้
สถานที่ หน้า อีก ว่า กระบวนการในที่สุดความต้องการ ( เราคุยกัน
รายละเอียดมากขึ้นเมื่อเราแนะนำขั้นตอนวิธีการแทนที่ ) .
เพจหน่วยความจำเสมือนเป็นขนาดเดียวกันเป็นหน่วยความจำทางกายภาพหน้าเฟรม ความทรงจำ
กระบวนการแบ่งเป็นเหล่านี้ขนาดคงที่หน้า ส่งผลให้ศักยภาพของภายใน
เมื่อหน้าสุดท้ายจะถูกคัดลอกลงในหน่วยความจำ ขั้นตอนอาจจะไม่
ต้องการเฟรมทั้งหน้า แต่ไม่มีกระบวนการอื่นอาจใช้ ดังนั้น
ไม่ได้ใช้หน่วยความจำในกรอบรูปนี้สุดท้ายได้อย่างมีประสิทธิภาพเสีย มันอาจจะเกิดขึ้นที่
กระบวนการเองต้องมีน้อยกว่าหนึ่งหน้าอย่างครบถ้วน แต่มันต้องใช้
กรอบทั้งหน้าเมื่อคัดลอกไปยังหน่วยความจำ การแตกแยกภายในพื้นที่ใช้งาน
ภายในให้พาร์ทิชัน ( ในกรณีนี้หน้า ) ของหน่วยความจำ
ตอนนี้คุณเข้าใจสิ่งที่เรียกคือ เราจะหารือถึงวิธีการทํางาน เมื่อ
กระบวนการสร้างที่อยู่เสมือนระบบปฏิบัติการต้องไดนามิก
แปลที่อยู่เสมือนนี้ในที่อยู่ในความทรงจำที่
ข้อมูลจริง ๆอยู่ ( สำหรับวัตถุประสงค์ของความเรียบง่าย สมมติว่าเราไม่มีแคช
ความทรงจำชั่วขณะ ) ตัวอย่างเช่น จากโปรแกรมที่เราเห็น
จุดชมวิวไบต์สุดท้ายของ 10 ไบต์ โปรแกรม ที่อยู่ 9 ทะลึ่ง 1-byte คําแนะนําและ 1 -
ไบต์ที่อยู่และเริ่มต้นที่อยู่ของ 0 อย่างไรก็ตาม เมื่อโหลดลงในหน่วยความจำจริง
, ตรรกะที่อยู่ 9 ( บางทีอาจอ้างอิงจากป้าย X ในการประกอบ
โปรแกรมภาษา ) อาจจะอยู่ในหน่วยความจำตำแหน่ง 859 , implying
โปรแกรมถูกโหลดจากที่อยู่ทางกายภาพ 1230 . ต้องมี
วิธีที่ง่ายในการแปลงเชิงตรรกะหรือเสมือนที่อยู่ 9 ไปยังที่อยู่ทางกายภาพ 1230 .
เพื่อให้บรรลุนี้แปลที่อยู่ที่อยู่เสมือนแบ่งออกเป็นสองเขตข้อมูล :
สนามหน้าและการชดเชยด้าน เป็นตัวแทนชดเชยภายในหน้าเว็บที่ร้องขอข้อมูล
ตั้งอยู่ ที่อยู่นี้กระบวนการแปลคล้ายกับ
กระบวนการที่เราใช้เมื่อเราแบ่งที่อยู่หน่วยความจำหลักในเขตแคช
แผนที่อัลกอริทึม และคล้ายกับแคชบล็อก ขนาด หน้ามักจะมีอำนาจของ
2 ; นี้ช่วยชดเชยตัวเลขและการสกัดหน้า จากที่อยู่เสมือน
เข้าถึงข้อมูลที่ได้รับที่อยู่เสมือนระบบดำเนินการขั้นตอนต่อไปนี้ :
1 สารสกัดจากหน้าหมายเลขจากที่อยู่เสมือน
2สารสกัดจากชดเชยจากที่อยู่เสมือน
3 แปลเป็นเลขหน้าในกรอบหมายเลขโดยการเข้าถึงทางกายภาพหน้า

หน้าโต๊ะ . . ดูหมายเลขหน้าในหน้าโต๊ะ ( ใช้เลขหน้าเสมือน
เป็นดัชนี )
. ตรวจสอบบิตที่ถูกต้องสำหรับหน้าเว็บที่ .
1 ถ้าใช้ได้นะ = 0 , ระบบสร้างหน้าผิดและระบบปฏิบัติการ
ต้องแทรกแซง

aค้นหาต้องการหน้าบนดิสก์ .
B หาเฟรมเพจฟรี ( นี้อาจ necessitate ลบ " เหยื่อ "
หน้าจากหน่วยความจำและดิสก์คัดลอกกลับไปถ้าหน่วยความจำเต็ม )
c . คัดลอกหน้าต้องการในกรอบหน้าฟรีในหน่วยความจำหลัก
d update หน้าโต๊ะ ( หน้าเสมือนเพิ่งเอาต้องมีจำนวนโครง
และถูกต้องบิต ในหน้า ตารางการแก้ไข หากมี
" เหยื่อ " หน้าที่ถูกต้องเป็นบิตต้องตั้งศูนย์ )
e ประวัติการกระบวนการก่อให้เกิดหน้าผิดอย่างต่อเนื่อง
ขั้นตอน 2 .