2022. 12. 14. 23:14ใ_Study/OperationSystem
Paging ๐¸.•*¨*•¸.•*¨*•¸.•*¨*•¸.•*¨*•
ํด๋น ์๋ฃ๋ ๊ฐ์ ํ์ต์๋ฃ์ ๋๋ค.
static partion / dynamic partition : ์์ ์ฌ์ด์ฆ์๋ ๋จํธํ๊ฐ ์๊ธด๋ค.
ํ๋ก์ธ์ค๋ฅผ ๋งค์ฐ ์์ ๊ณ ์ ๋ ์ฌ์ด์ฆ๋ก ๋๋ ๊ฒ์ page ๋ผ๊ณ ํ๊ณ
๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋งค์ฐ ์์ ๊ณ ์ ๋ ์ฌ์ด์ฆ์ ๋ฉ๋ชจ๋ฆฌ์กฐ๊ฐ์ผ๋ก ๋๋์๋๋ฐ ์ด๋ฅผ page frame์ด๋ผ๊ณ ํ๋ค. page๋ฅผ ๋ฃ์ ์ ์๋ ํ์ด๋ผ๊ณ ์๊ฐํ๋ฉด ๋๋ค.
Memory is partitioned into equal fixed-size chunks
- Frames or page Frames
- that are relativley small
Process is also divided into small fixed-size chunks (pages) of the same size
frame(page frame) : memory ์ชฝ์ ๋๋
page : process ์ชฝ์์ ๊ฐ์ ์ฌ์ด์ฆ๋ก ๋๋ ์กฐ๊ฐ
์ด๋ ๊ฒ page๋ฅผ ์ฌ์ฉํ๋ฉด ์ธ๋ถ ๋จํธํ๊ฐ ํด๊ฒฐ ๋๋ค: (ํ ๋นํ๊ณ ๋ฐ๊นฅ์ชฝ์ ๋จ์ ๋ฉ๋ชจ๋ฆฌ), ๊ทธ๋ ์ง๋ง ์๋ page์กฐ๊ฐ ๋ณด๋ค ์์ผ๋ฉด internal fragmentation ์ ์๊ธด๋ค. ์ ์ด์ ํฌ๊ธฐ๊ฐ ๋งค์ฐ ์๊ธฐ ๋๋ฌธ์ ๋ด๋ถ ๋จํธํ๋ก ์๊ธฐ๋๋ผ๋ ์๊ฒ ์๊ธด๋ค.
ํ๋ก์ธ์ค๋ฅผ ์ชผ๊ฐ์ด ์ฌ๋ฌ ๊ฐ์ frame์ ์ ์ฅ์ด ๊ฐ๋ฅํ๋ค ์ด๋ฅผ paging ๊ธฐ๋ฒ์ด๋ผ๊ณ ํ๋ฉฐ partition์ ๊ตณ์ด ์ฐ์๋ ํ์๊ฐ ์๊ณ ์ฌ๊ธฐ์ ๊ธฐ ๋ฃ์ด๋ ๋๋ค.
OS maintain page table for each process : ํ์ด์ง ํ ์ด๋ธ์ ๋ง๋ค์ด ๊ด๋ฆฌํ๋ค.
which contains the frame location forf each page in the process
logical address๋ ํ์ด์ง ๋๋ฒ๋ก ๊ตฌ์ฑ๋์ด ์๋ค.
ํ์ด์ง ์์์๋ ๊ทธ์์ ์ฐธ์กฐํ ์ฃผ์๋ฅผ offset ๋ฒํธ๋ก ๊ฐ์ง๊ณ ์๊ณ ์ด๋ฅผ ์ด์ฉํ์ฌ Page table์ ์ค์ ์ฃผ์๋ฅผ ์ฐธ์กฐํ๋๋ฐ ์ฌ์ฉํ๋ค. (์ด๋ฏธ size๋ฅผ ์๊ณ ์๋ค)
logical address = page number + offset
paging์ page table์ number index์์ framelocation์ ์ฐพ์์ผํ๋ค.
relative address ๊ฐ์๊ฒฝ์ฐ ์์๊ฐ 1502 ์ธ๋ฐ ์ด๋ฅผ ์ด์ง์๋ก ๋ํ๋ด๋ฉด 000001 0111011110 ์ด๋ค.
์ด๋ 1(1024) + 0111011110(478) ์ด๋ค.
์ฆ, 1KB ์ ๊ฐ์ ์ฌ์ด์ฆ๋ก ํ์ด์ง๋ฅผ ๋๋๋ฉด ํ ๋จ์๊ฐ 2์ 10์น์ด๋ผ offset์ด 10๊ฐ(10๋นํธ) ์ธ ๊ฑฐ ๊ฐ๋ค.
๋ค์ page number์ด 000010 ์ด ๋๋ฉด offset์ 2์ 10์น์ด ์ง๋์ผํ๋ค. ๋ฐ๋ผ์ Page๋ฌถ์์ด 1KB์ธ ๊ฒ์ ๋ง์กฑํ๋ค.
๋ฐ๋ผ์ page number ์ bit๋ฅผ ์กฐ์ ํ๋ฉด page ์ ๋จ์๋ฅผ ์กฐ์ ํ ์ ์์๊ฑฐ ๊ฐ๋ค.
segmentation๐¸.•*¨*•¸.•*¨*•¸.•*¨*•¸.•*¨*•
A program can be subdivided into segements : ํ๋ก๊ทธ๋จ์ ์ฌ๋ฌ segments๋ก ๋๋ ์ ์๋ค.
- Not required that all segments of all programs be of the same length : ๊ฐ์ ํฌ๊ธฐ๋ก ๊ตณ์ด ๋๋์ง ์์๋ ๋๋ค.
- there is a maximum length : ์ต๋ ๊ธธ์ด๊ฐ ์ ํด์ ธ ์๋ค.
Logical address consists of two parts:
- segment number + offset
similar to dynamic partitioning (unequal size)
- but, a program may occupy more than one patition;
- these partitions need not be contiguous
No internal fragmentation : ๋ด๋ถ ๋จํธํ๊ฐ ํด๊ฒฐ๋๋ค.
Relatively smaller external fragmentation : ์ธ๋ถ ๋จํธํ๊ฐ ๋ฐ์ํ๋ค.
Segmentation is visible to ther programmer or compiler
Provded as a convenience to organize logically programs
No simple relationship between logical addresses and physical addresses
OS maintains a segment table for each process and a list of free blocks of main memory
Each segment table entry contains:
- the starting physical addresses of that segment
- the length of that segment
to assure that invalid addresses are not used.
ํ์ํ segment ํฌ๊ธฐ๋งํผ ํ ๋น๋ฐ์ ์ฌ์ฉํ๋ค.
page๋ ์ฌ์ด์ฆ๋ฅผ ์๊ณ ์๋๋ฐ ์ฌ๊ธฐ๋ ๋๊ณผ ๋์ ์ฃผ์๋ก ์ฌ์ด์ฆ๋ฅผ ๊ณ์ฐํ๋ค.
limit : ์์ ์์น
base : ๋๋๋ ์์น
๋จ์ : physical address์ ์ ํ ๊ด๊ณ๊ฐ ์๋ logical address, ๋น์ด์๋ block list ๊ฐ ํ์๋ก ํ๋ค.
์ ๋ฆฌ
Paging | Segment | |
์ ์ | ํ๋ก์ธ์ค๋ฅผ ์ชผ๊ฐ์ด ์ฌ๋ฌ ๊ฐ์ frame์ ์ ์ฅ์ด ๊ฐ๋ฅํ๋ค | ํ๋ก๊ทธ๋จ์ ์ฌ๋ฌ ๊ฐ์ segment ๋ก ๋๋์ด ์ ์ฅ์ด ๊ฐ๋ฅํ๋ค. |
์ฌ์ฉ | page : ํ๋ก์ธ์ค์์ ๋๋ ๊ฐ์ ์ฌ์ด์ฆ์์์ ์กฐ๊ฐ | segment : ์ฌ๋ฌ ํฌ๊ธฐ๋ก ๋๋์ด์ง ํ๋ก๊ทธ๋จ |
๋ฐ์ํ๋ ๋จํธํ | ๋ด๋ถ ๋จํธํ | ์ธ๋ถ ๋จํธํ |
์ฃผ์ ์ฐธ์กฐ | page table + offset | segment table + offset |
visible ์ฌ๋ถ | ์์คํ ์์ ์ฒ๋ฆฌ | ๊ฐ๋ฐ์๊ฐ ํ์ธ ๊ฐ๋ฅ |