title
stringlengths 1
544
โ | parent
stringlengths 0
57
โ | created
stringlengths 11
12
โ | editor
stringclasses 1
value | creator
stringclasses 4
values | edited
stringlengths 11
12
โ | refs
stringlengths 0
536
โ | text
stringlengths 1
26k
| id
stringlengths 32
32
|
---|---|---|---|---|---|---|---|---|
**Claude Shannon**
|
Computer Scientists
|
May 9, 2023
|
Alan Jo
|
Alan Jo
|
Jun 25, 2023
|
[Alan Turing](https://texonom.com/alan-turing-df61b5084e544ac58577d289983e0d28)
|
๊ตฌ๊ธ ํ์ ๊ฒ์ ๊ธฐ์ค์ผ๋ก ์ธ์์์ 4๋ฒ์งธ๋ก ๋ง์ด ์ธ์ฉ๋ ๋
ผ๋ฌธ์ธ <์ ๋ณดํต์ ์ ์ํ์ ์ด๋ก >์ด๋ผ๋ ๋
ผ๋ฌธ์ ๋ฐํ
[Entropy](https://texonom.com/entropy-35fdf9bb7fdd42edbd4277147ca0ec38)
1950~1986 ์ฐ ํ๊ท ๋ณต๋ฆฌ์์ต์จ์ด 28% ๋ก ์ธ๊ณ์ต๊ณ ์์ค
[N gram Language Model](https://texonom.com/n-gram-language-model-e600ddf01e2645e1b1d76604454bc3c9) [One Time Pad](https://texonom.com/one-time-pad-0fd4b702a7854dca8263035014fa3914)
|
bc27d0c33de4438cb326957a169ed36a
|
Edsger Dijkstra
|
Computer Scientists
|
Aug 9, 2023
|
Alan Jo
|
Alan Jo
|
Aug 9, 2023
|
> [Edsger Dijkstra's One-Day Workweek - Cal Newport](https://calnewport.com/edsger-dijkstras-one-day-workweek)
|
569bf90716e64b468e888f51099c8beb
|
|
Grace Hopper
|
Computer Scientists
|
Sep 7, 2020
|
Alan Jo
|
Alan Jo
|
Jun 25, 2023
|
์ต์ด๋ก ์ปดํ์ผ๋ฌ๋ฅผ ๋ง๋ค๊ณ ์ฒ์์ผ๋ก ๋๋ฒ๊น
(?)์ ํ ๊ทธ๋ ์ด์ค ํธํผ๋ ์ฌ์ฑ
1947๋
ํธํผ๋ ๋งํฌ2์์ ํ๋ก๊ทธ๋๋ฐ ์์
์ ํ๊ณ ์์๋๋ฐ, ๊ทธ ๋ ๋ฐ๋ผ ์ฒ๊ณต์นด๋ ์
๋ ฅ์ด ์ ์๋์๋ค.
๊ฒฐ๊ตญ, ๋ฆด๋ ์ด ์์ ์ฃฝ์ด์๋ ๋๋ฐฉ ๋๋ฌธ์ ์ปดํจํฐ๊ฐ ์ ๋๋ก ๋์ํ์ง ์๋๋ค๋ ์ฌ์ค์ ์๊ฒ ๋
๊ทธ๋ฆฌ๊ณ ๊ทธ ๋๋ฐฉ์ ์์
๋
ธํธ์ ๋ถ์ด๋ฉด์ ์ต์ด์ ์ปดํจํฐ ๋ฒ๊ทธ๋ผ๊ณ ๋ฉ๋ชจ๋ฅผ ๋จ๊ธด๋ค.
|
1b108f44e96a4899b18c1a6821869f48
|
|
Margaret ***Hamilton***
|
Computer Scientists
|
Sep 7, 2020
|
Alan Jo
|
Alan Jo
|
Jun 25, 2023
|
### software engineering ์ด๋ผ๋ ์ฉ์ด๋ฅผ ์ฒ์ ์ฌ์ฉํ๋ค
๋ํ์์ ์ํ์ ๊ณต๋ถํ ๊ทธ๋
๋ ๋จํธ์ ๋ฐ์ฌ ํ์ ๊ณต๋ถ๋ฅผ ์ง์ํ๊ธฐ ์ํด MIT์์ ํ๋ก๊ทธ๋๋จธ๋ก ์ผ์ ์์ํ๋ค. ๋น์ ๊ทธ๋
๋ ์ ๋๋ก๋ ํ๋ก๊ทธ๋๋ฐ ๊ต์ก๋ ๋ฐ์ง ๋ชปํ๊ณ ๋ฐ๋ก ๋ ์จ๋ฅผ ์์ธกํ๋ ํ๋ก๊ทธ๋จ ๊ฐ๋ฐ์ ์ฐธ์ฌ
๊ทธ ํ, ์์คํ
ํ๋ก๊ทธ๋๋ฐ ์ ๋ฌธ๊ฐ๊ฐ ๋์ด ์ํด๋ก11 ํ๋ก์ ํธ์ ์ฐธ๊ฐํ๊ฒ ๋๋ค. ๋น์ ์ํด๋ก11 ํ๋ก์ ํธ์๋ SW๊ฐ๋ฐ์ ์ํ ์์ฐ๊ณผ ์ผ์ ์ด ํฌํจ๋์ด ์์ง ์์๊ณ , ์๊ตฌ ์ฌํญ์๋ ์ํํธ์จ์ด ๋ํ ์ธ๊ธ์ ์์๋ค
> [F/OSS Story - ํ์ด์ง 5 - ๋งํ๋ก ๋๋๋ ์์ /์คํ์์ค ์ํํธ์จ์ด ์ด์ผ๊ธฐ](https://joonecomics.wordpress.com/category/foss-story/page/5/)
|
ea62b054dc0a47d291b80dc976b5f8d8
|
|
Shumuel Winograd
|
Computer Scientists
|
Jun 25, 2023
|
Alan Jo
|
Alan Jo
|
Jun 25, 2023
|
5f38451bbad04b6da44260f93ca4eb43
|
||
Von Neumann
|
Computer Scientists
|
Apr 15, 2023
|
Alan Jo
|
Alan Jo
|
Jun 25, 2023
|
ef79cb1b1e9045d28caced75663e14f7
|
||
Alan Turing History
|
Alan Turing Notion
|
May 9, 2023
|
Alan Jo
|
Alan Jo
|
May 9, 2023
|
์ผ์๋ธ๋ฆฟ์ง ๋ํ๊ต ์
ํ
ํ๋ฆฐ์คํด ์์์ญํ ๋
ผ๋ฌธ์ ์๊ฐ์ ๋ฐ์
๊ทธ ๋
ผ๋ฌธ์ด ์กด ํฐ ๋
ธ์ด๋ง์ด ์ด ๊ฒ
ํ๋ฒ ๋ฅดํธ๊ฐ ๊ธฐ๊ณ๊ฐ ๋ง๋ฅ์ด๋ค๋ผ๋ ์ฃผ์ฅ์ ํ๊ณ ์ธ๊ณ์ํํ๊ณ๊ฐ ์์ธํ๋๋ฐ
ํ๊ต์์ ๊ธฐ๊ณ๊ฐ ๋ง๋ฅ์ด ์๋๋ค๋ผ๋ ์๋ฏธ๋ฅผ ๊ฐ์ง๋ [๋ถ์์ ์ฑ ์ ๋ฆฌ](https://texonom.com/e158a278de5b4a7fa97b509cbd2dc0bd) ๋ฅผ ์ฝ๊ณ
์ฐ์ฐ์ ์ํํ๋ ์๋ํ๋ ๊ธฐ๊ณ๋ผ๋ ๋ถ์ผ์ ํฅ๋ฏธ๋ฅผ ๊ฐ์ง๊ณ ๊ณต๋ถํ๊ฒ ๋๋ค
๊ดด๋ธ์ ๋ถ์์ ์ฑ ์๋ฆฌ์ ๊ฐ๋จํจ์ ์๋ก ์์ ๋ง์ ๋ฐฉ์์ผ๋ก ์ฆ๋ช
๊ทธ ๊ณผ์ ์์ universial machine์ด๋ผ๋ ๋จ์ด ๋์ด
์ด๋ฐ ๋ฐฉ์์ผ๋ก ๋๋ค๋์๋ฅผ ๋ง๋ค์ด์ ๋ถ์์ ์ฑ ์๋ฆฌ ์ฆ๋ช
ํ ์๋ก ์ ์ฒ์น๋ฅผ ๋ฐ๋ผ ํ๋ฆฐ์คํด์ผ๋ก ๋ ๋จ
๋ง๋ค์ด๋
22์ด์ ์ํ๋ฐ์ฌ๋๊ณ ๋
ผ๋ฌธ ์์ฒญ ์ด ์กด ํฐ ๋
ธ์ด๋ง๊ณผ ๊ต๋ฅ
๋งจํํ ํ๋ก์ ํธ์ ์กด ํฐ ๋
ธ์ด๋ง์ด ์ฐธ์ฌ
์จ๋ฐ ํ๋ง์ ์ํธ ์๊ทธ์ ์๋๋ฐ ์ฐธ์ฌ
๋
ผ๋ฌธ ์ ์ ๋๋๊ณ ๋
๊ทผ๋ฐ ์ค๋จ๋จ ๋ชป์์๋ด์
์ดํ์ ๋ช๋
๋ค ๊ตฌํ๋์๋๋ฐ ๋น์ ์ธ๊ณ์ ค๋น ๋ฅธ ์ปดํจํฐ
ํฐ๋
ธ์ด๋ง์ด edvac ๋ณด๊ณ ์ ๋ฏธ๊ตญ์ ์ป๋๋ฐ ํ๋ง๋จธ์ ์์ด๋์ด ์ฐธ๊ณ ํ๋์ง ํ์คํ์ง ์๋ค
์ดํ ์๊ตญ ํ์ค์ ๋งํ
๋งจ์ฒด์คํฐ ๋ํ์ ๊ฐ์ ์ธ๊ณต์ง๋ฅ ๊ณต๋ถ
์ํ๊ณผ ์๋ฌผํ ๊ณต๋ถํ๋ฉฐ ๋
ผ๋ฌธ ์ด๋ค
๊ณผ์ฐ ๊ธฐ๊ณ๋ ์๊ฐ์ ํ ์ ์์๊น๋ผ๋ ์ง๋ฌธ์ผ๋ก ๋
ผ๋ฌธ ์์
์ฒ ํ์ ๋
ผ๋ฌธcan machine think? Imitation Game
์ฌ๊ธฐ์ ๋์ค๋ ๋ง , ๊ฐํํ์ต ๊ฐ๋
์๊ฐ
๋ชจ๋ ์ง์ฑ์ ์์ญ์์ ์ธ๊ฐ๊ณผ ๊ธฐ๊ณ์ ๊ฒฝ์์ ์์ธก
์ดํ ์์ฐ์์ ๋ฐ์ํ๋ ํจํด์ด ์๊ธฐ๋ ๊ณผ์ ์ ์ํ์ ์ผ๋ก ์์
ํธ๋ฅด๋ชฌ ํํ์น๋ฃ์ค ์ฌ๊ณผ๋จน๊ณ ์์ด
ํฐ ์ด๋ง ๊ตฌ์กฐ ์ด๋ก ์ ์ฐฝ์์ AI์ ์ ๋์์ด์ ํ๋ง ํ
์คํธ์ ์ด์ ์ ๋๊ทธ๋ง ๊ฐ๋ฐ์
์ด๋ฆฐ์์ ํ๋ง์ ์น๊ตฌ๋ฅผ ๋์ด๋ฆฌ๊ณ ์ถ์ ๋ง์์ ์์์ญํ๊ณผ ์ํ์ ์ฌ์ทจํ๋ค
์๋ฐ ํ๋ง์ ๊ธฐ๊ณ์ ๋ํ ์ฆ๋ช
์ ๊ดด๋ธ์ ๋ถํ์ ์ฑ ์๋ฆฌ์ ๊ธฐ๋ฐํ๋ค
2์ฐจ๋์ ์๋๊ทธ๋ง ๋
์ผ ์ด uboat (undersea)์์ ์ฌ์ฉํ ์ํธํ๊ธฐ์ - 1943 - ์จ๋ฐ ํ๋ง
์๋์
๋ ์์ํญํ ์๋ฎฌ๋ ์ด์
์ํด ๋ง๋ค์ด์ง ๊ฒ - 1946 - ๋ฏธ๊ตญ
ํฐ ๋
ธ์ด๋ง์ด edvac ๋ณด๊ณ ์๋ก ํฐ ๋
ธ์ด๋ง ๊ตฌ์กฐ ์ ๋ฆฝ (1936 ์จ๋ฐํ๋ง์ด ์ ์ํ ๋
ผ๋ฌธ๊ณผ ๊ฑฐ์ ๋น์ท - ํ์ง๋ง ํ๋ง ์ธ๊ธ ์๋ค)
์๋ ํ๋ง์ด ๋ณด๋ ๋ถ์์ ํด๋ณด์ด๋ ๋ณด๊ณ ์ โ ์๊ตญ์์ ๋ง๋ค์ด์ฃผ์ธ์ ํด์ ๋ ๋๋จํ Proposed Electronic Calculator๋ผ๋ ๋
ผ๋ฌธ์ ๋ธ๋ค
Automatic Computing Engine ์ผ๋ก ์ด๋ฆ์ง๋๋ค
edvac์ ๋์ด ์๋ธ๋ฃจํด ๊ฐ๋ฅํ๊ฒ ๊ตฌ์กฐ ์ค๊ณํ์ง๋ง ๋๋ฌด ๋ณต์กํ๋ค๊ณ ์๊ตญ์์ ๋ถ๊ฐ๋ฅํ๊ฑฐ ์๋๋๊ณ ๋ชป์์๋จน์
aceํ๋ก์ ํธ ์ค๋จ๋จ
3๋
๋ค pilot ace๋ผ๋ ๊ณ์๊ธฐ๋ก ์ ์๋์ ์ธ๊ณ์์ ๊ฐ์ฅ ๋น ๋ฅธ ์ปดํจํฐ๋ก ๊ธฐ๋ก๋๋ค
๊ทธ ํ ๊ถค๋ธ ์๊ฐํด์ค ๋งฅ์ค๋ด๋จผ ๋ฐ๋ผ ๋งจ์ฒด์คํฐ ๋ํ ๊ฐ์ ์ฐ๊ตฌ
๋ชจ๋ ์ด์ํ ์ธ๊ณต์ง๋ฅ์ ๋ง๋ค์ด์ผ๊ฒ ๋ค ํด์ ์ํ์ ์๋ฌผํ ๊ณต๋ถ ์์
1950๋
์ - computing machinery and intelligence๋ฅผ ๋ง๋ ๋ค
The imitation game์ด๋ผ๋ ์ ๋ช
ํ ๋จ์ด๊ฐ ๋์จ๋ค โ turing test ๋ผ๊ณ ๋ถ๋ฆฌ๋ฉฐ ๋งค๋
์ธ๊ณ์์ ์ด๋ฆฌ๊ณ ์๋ค
2014๋
์ ์ ์ง ๊ตฌ์คํธ๋ง์ด ์ต์ด๋ก ํ๋ง ํ
์คํธ๋ฅผ ํต๊ณผํ๋ค
์ด ๋
ผ๋ฌธ ๋ง์ง๋ง์ผ๋ก ํ๋ฌธ์ฅ์ผ๋ก ์ ๋ฆฌ - ์ฒ ํ์ ๋
ผ๋ฌธ
์ดํ์ ์ง์ turochamp๋ฅผ ๊ฐ๋ฐํ๊ฒ ๋์ง๋ง ์ง์ง ์คํ์๋ ์คํจ - ์๊ณ ๋ฆฌ์ฆ ๋ณต์ก
2012๋
๋๊ฐ ๋์์ผ ๋ง๋ ๋ค - ๊ฒฐ๊ณผ๋ ์ข์ง ๋ชปํ์ง๋ง
morphogenesis๋ผ๋ ๊ฐ๋
์์ฐ์์ ๋ฐ์ํ๋ ํจํด์ด ์์ฑ๋๋ ๊ณผ์ ์ ์ํ์ ์ผ๋ก ์ค๋ช
ํ๋ ๋
ผ๋ฌธ๋ ๋ด๊ฒ ๋๋ค - ์๋ฌผํ ๋
ผ๋ฌธ
์๋๋ ๋จธ๋ ์ด๋ผ๋ ๋จ์์ ์ฐ์ธ๊ด๊ณํ์ง๋ง
๋์ฑ์ ์๊ตญ ๋ถ๋ฒ์ด๋ผ์ ๊ตฌ๊ธ๋๋ค
2013๋
์ ์๊ตญ์ ๋์ฑ์ ๊ฒฐํผ์ด ํฉ๋ฒํ๋๋ค
ํธ๋ฅด๋ชฌ์น๋ฃ๋ฅผ ๋ฐ์ผ๋ฉฐ ์ฌํ์ ๋ชป์ด๊ฒจ ์ฒญ์ฐ๊ฐ๋ฆฌ๋ฅผ ๋ง๋ค์ด ์ฌ๊ณผ์ ๋ฃ๊ณ ์์ดํ๋ค
์ดํ ์๊ตญ์ ์๋๊ทธ๋ง๋ฅผ ๋ค๋ฅธ ๊ตญ๊ฐ์ ๋ณด์ ํ์คํ๋ค๊ณ ํ๊ณ ์๊ธฐ๋ค๋ง ํด๋
ํด์ ๊ทธ ์ ๋ณด ์ฌ์ฉํ๋ค
์๊ตญ์ ์ด๋ฅผ ๊ฐ์ถ๊ธฐ ์ํด, ๋์ฑ์ ์ ์จ๋ฐ ํ๋ง์ ๊ฐ์ถ๋ค
the ultra secret์์ ํ๋ง์ ์
์ ์ด ๋ฐํ์ง๋ค ์๊ตญ๊ณผ ์ ๋๊ทธ๋ง
2009๋
์ ์จ๋ฐํ๋ง ์ฌ๋ฉด์ด๋์ด ์ผ์ด๋๋ค - 2010๋
์ ์คํฐ๋ธ ํธํน์ด ๊ฐ์ธํ๊ณ 10๋ ์ธ๋ฌผ์ ์๋ฐ ํ๋ง์ด ๋ค์ด๊ฐ๊ณ ์๋ฆฌ์๋ฒ ์ค 2์ธ ์ฌ์์ ํน๋ณ์ฌ๋ฉด๊ถ์ผ๋ก ๊ณต์ ์ฌ๋ฉด๋๋ค
์ปดํจํฐ๊ณ์ ๋
ธ๋ฒจ์์ธ ํ๋ง์์ด ์๊ธด๋ค
> [์จ๋ฐ ํ๋ง - ํ๋ ์ปดํจํฐ ๊ณผํ์ ์๋ฒ์ง (feat. ์ธ๊ณ 2์ฐจ ๋์ ) [์]](https://www.youtube.com/watch?v=QasRpCP8qsI)
> [2. ์จ๋ฐ ํ๋ง๊ณผ ํฐ๋
ธ์ด๋ง](https://joone.net/2016/11/15/%ec%95%a8%eb%9f%b0-%ed%8a%9c%eb%a7%81%ea%b3%bc-%ed%8f%b0%eb%85%b8%ec%9d%b4%eb%a7%8c/)
|
b394066bcd2a49fb9e048836bbf1a212
|
|
Automatic Computing Engine
|
Alan Turing Notion
|
Mar 2, 2021
|
Alan Jo
|
Alan Jo
|
May 9, 2023
|
์ฒ์์ผ๋ก ๋ฉ๋ชจ๋ฆฌ ๋ด์ฅ ์ด์ฉ
cpu
memory
์
๋ ฅ์ฅ์น
์ถ๋ ฅ์ฅ์น
์ค๊ณ
|
a61d7bc038fe4e58a80989d1c3e6facf
|
|
OS Function
|
OS Notion
|
May 19, 2021
|
Alan Jo
|
Alan Jo
|
Jan 18, 2023
|
### OS Functions
|Title|
|:-:|
|[Processor Scheduling](https://texonom.com/processor-scheduling-924d2fa78737494d82e74595de81219f)|
|[Memory Management](https://texonom.com/memory-management-dbf37c509eaf46deb2df8ccd086e386c)|
|[Disk Management](https://texonom.com/disk-management-f82047a4bc5a4bfb9960448cd13ac476)|
|
cc6a2b8fffb94340b51bc3f4a9c38862
|
|
OS History
|
OS Notion
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
Jun 21, 2022
|
์ด๊ธฐ ์ปดํจํฐ๋ค์ [Punch Card](https://texonom.com/punch-card-dcb71893cc074afb9ec6865b43eaaa61) ๋ฅผ ์
,์ถ๋ ฅ์ ์ฌ์ฉ
๋ฌผ๋ฆฌ์ ์ผ๋ก ์ปดํจํฐ ๋ฉ๋ชจ๋ฆฌ์ ๋ก๋ํด์ ์คํ์ํค๊ณ ์คํ์ด ์๋ฃ๋๋ฉด ๋ฉ๋ชจ๋ฆฌ ๋คํ๋ฅผ ํด์ ์ถ๋ ฅ์ ์ป์
[TTY](https://texonom.com/tty-d3c35ff3460343359b453c88a3bb896f)
[Punch Card](https://texonom.com/punch-card-dcb71893cc074afb9ec6865b43eaaa61)

์ด ๊ณผ์ ์ ์ฌ๋์ด ์ง์ ๋ฐ๋ณตํ๋ค๊ฐ ํ๋ก๊ทธ๋จ์ ์ํด ์๋ํ ํ๊ธฐ ์์ํ๊ฒ์ด Operating System ์ ์์
> unix: bsd (now free bsd), system V: bsd: for ํ๋ฌธ: system V: ex. ์๋ผ๋ฆฌ์ค
>> init in bsd: getty
>> init in system V: inittab
>> those are psd 1
>
> UNIX โ GNU โ Linux
> โ POSIX โ BSD โ MACOS
> 
> [Introduction](https://mug896.github.io/bash-shell/tty.html)
|
0f04c35c56144da9a9646d935a4a69fd
|
|
OS Structure
|
OS Notion
|
May 19, 2021
|
Alan Jo
|
Alan Jo
|
Apr 3, 2023
|
[Software Architecture](https://texonom.com/software-architecture-5d3c80f6ffe44d60b10c870903c2b703)
|
### OS Structures
|Title|
|:-:|
|[CLI](https://texonom.com/cli-3b46069e77904f7b8ce85faff6252cfc)|
|[OS Kernel](https://texonom.com/os-kernel-631bce6131a64accb3a482df622ff957)|
|[Disk System](https://texonom.com/disk-system-104aed644fd54c31a9938e4f7b3bae6f)|
|[File System](https://texonom.com/file-system-7a340052fcaf48169a5c6da2610aa5cf)|
|[I/O Systems](https://texonom.com/io-systems-1fe831bd09ae43909cccb33056a1dfc7)|
### OS Components
|Title|
|:-:|
|[GUI](https://texonom.com/gui-936270e7b4af43e3929f69fcb6e1e2e4)|
|
a66cf2a9ea8f4841b64ca65fbec8b743
|
UNIX
|
OS Notion
|
Mar 18, 2021
|
Alan Jo
|
Alan Jo
|
Apr 25, 2023
|
## **UNiplexed Information Computing System**
### Unix Notion
|Title|
|:-:|
|[POSIX](https://texonom.com/posix-6fd6ba0425f145fca4dea48a6dee1ce7)|
|[Unix Philosophy](https://texonom.com/unix-philosophy-8f96f33ed93b4ea5a533303869abfa92)|
|[UNIX Structure](https://texonom.com/unix-structure-f892f7c631854084a7a93cf8db918cc3)|
|[Unix-like](https://texonom.com/unix-like-578ba7dbb07b44b3a2d3895ca103c5ec)|
|[UNIX History](https://texonom.com/unix-history-34c9169587714b508aad541945d7571d)|
|
233213b96425492f925a8277650c5b28
|
|
Disk Management
|
OS Functions
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
Jan 18, 2023
|
[File System](https://texonom.com/file-system-7a340052fcaf48169a5c6da2610aa5cf)
|
### Need
- Ram and disk price difference is still 10^2
- Memory is volatile
- Disks as swap space for virtual memory system
### Disk Management Notion
|Title|
|:-:|
|[Disk layout](https://texonom.com/disk-layout-5091a147a01a4ff2986c9d80e6aad326)|
|[Disk Allocation methods](https://texonom.com/disk-allocation-methods-4a49727bed65460cb4db6426038b97b4)|
|[Disk caching](https://texonom.com/disk-caching-f0d66b9112c24fbd9b6bb7f115da6af0)|
|[Anatomy of hard-disk](https://texonom.com/anatomy-of-hard-disk-e4eca2717d6145a189df99f477adf720)|
|[Disk Head Scheduling](https://texonom.com/disk-head-scheduling-e6e60cca761147059a1bf7717616c398)|
|[Disk management](https://texonom.com/disk-management-2db57b8f7837407088208b308e51bbec)|
|[RAID](https://texonom.com/raid-4b50ffdd255d430ca76f393e8d1ebe25)|
|[Tertiary storage devices](https://texonom.com/tertiary-storage-devices-def6411e9adf4220811b65706895e6e3)|
|[Disk Performance](https://texonom.com/disk-performance-28e569d80cbe4c3b9e68857ac92550ea)|
> primary - secondary - tertiary
|
f82047a4bc5a4bfb9960448cd13ac476
|
Memory Management
|
OS Functions
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
Jan 18, 2023
|
### Memory Management Notion
|Title|
|:-:|
|[Memory Management History](https://texonom.com/memory-management-history-baac71af6c7c4281894e15349bde6777)|
|[Memory Management Method](https://texonom.com/memory-management-method-040223391bea4c148bcfee4f4064572f)|
|[Memory Address Changing](https://texonom.com/memory-address-changing-53916e26496843d6bf5a26e6185ebe8d)|
### Memory Management Usage
|Title|
|:-:|
|[Garbage Collector](https://texonom.com/garbage-collector-8af9f92e3ca842ee8ddd638e25647cd7)|
|[Memory Leak](https://texonom.com/memory-leak-16c4f840b59e4d45a04770b03e582229)|
### reference bit
> [Untitled](https://asfirstalways.tistory.com/140)
### associative register
> [์ฐ๊ด๊ธฐ์ต์ฅ์น, ๋ณต์ ๋ชจ๋ ๊ธฐ์ต์ฅ์น](https://devkim93.tistory.com/entry/%EC%97%B0%EA%B4%80%EA%B8%B0%EC%96%B5%EC%9E%A5%EC%B9%98-%EB%B3%B5%EC%88%98-%EB%AA%A8%EB%93%88-%EA%B8%B0%EC%96%B5%EC%9E%A5%EC%B9%98)
|
dbf37c509eaf46deb2df8ccd086e386c
|
|
Processor Scheduling
|
OS Functions
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
Aug 10, 2023
|
### Scheduling is small issue in OS but hard to optimize
### Processor Scheduling Notion
|Title|
|:-:|
|[Processor Scheduler](https://texonom.com/processor-scheduler-8c124741c1e84d26b0b0a8ad599337f4)|
|[Process](https://texonom.com/process-ffd68f9e2b2648759b96047d48d17778)|
|[Interrupt](https://texonom.com/interrupt-d26d34c54d5447a6888ad85089184fb3)|
|[Thread](https://texonom.com/thread-d704a229d3b94619963c61bb742b822b)|
### Processor Scheduling Usages
|Title|
|:-:|
|[Processor Scheduling Algorithm](https://texonom.com/processor-scheduling-algorithm-305e26d3aca84cdd9e5c980e91642a8f)|
|[Processor Scheduling Method](https://texonom.com/processor-scheduling-method-c5c243a128b74b2183508330aec1090c)|
|[Processor Scheduling Evaluation](https://texonom.com/processor-scheduling-evaluation-b897d00ffba948e6922c062d95693455)|
> [[OS] 5-2. CPU Scheduling II](https://asfirstalways.tistory.com/124)
|
924d2fa78737494d82e74595de81219f
|
|
Anatomy of hard-disk
|
Disk Management Notion
|
May 19, 2021
|
Alan Jo
|
Alan Jo
|
May 19, 2021
|
# Anatomy of hard-disk
- **platters **and **double of heads of platters**
- since we can use upper and lower of platter
- usually **sector **is 512 bytes
- head need physical take off and landing - slow
- **Disk address = (driver, surface, track, sector)**
- Cylinder-based mapping
- Seek time : The head is moved to the target track
- latency : Rotational latency
- Transfer time: Read/write the sector


### Mapping algorithm or disk addressing
<details><summary>
Mapping from sector address to logical block address</summary>
(surface j, track i, sector k) = k + s * (j + i*p)
- Assuming p surfaces in the disk and s sectors per track.
</details>
|
e4eca2717d6145a189df99f477adf720
|
|
Disk Allocation methods
|
Disk Management Notion
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
May 19, 2021
|
### where should we allocate(save) in disk
- contiguous allocation - has hole waste to cleanblock also has same sizesimple but
- linked allocation (dynamic) - pointerif bad sector broken easily occur
- indexed allocation - Has index blockhas pointer
> do not trust memory - especially secondary memory
> contiguous : ์ธ์ ํ
|
4a49727bed65460cb4db6426038b97b4
|
|
Disk caching
|
Disk Management Notion
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
May 19, 2021
|
for slow disk performance
**Buffer cache (in memory)** : cache file blocks in memory to capture locality in buffer cache or buffer cache - Idea: cache file blocks in memory to capture locality in buffer cache (or buffer cache)
- this cache is system wide, shared by all processes
- cache consistency issues can be occur
**Page cache** - โ Caches pages rather than disk blocks using virtual memory techniques. โ Memory-mapped I/O uses a page cache.
**Unified Buffer cache** -โ A unified buffer cache uses the same page cache to cache both memory-mapped pages and ordinary file system I/O. โ Avoids double caching and the possibility of inconsistencies between page caches and buffer caches.
|
f0d66b9112c24fbd9b6bb7f115da6af0
|
|
Disk Head Scheduling
|
Disk Management Notion
|
May 19, 2021
|
Alan Jo
|
Alan Jo
|
May 19, 2021
|
More than one request in the disk queue - read or write
### Algorithms
- FCFS - fair but ineffcient - fifo
- SSTF - starvation possible - select minimum seek time - **usual algorithm**
- SCAN - elevator algorithm - possibility of double time - double direction
- C-SCAN - one direction since disk is round - **usual algorithm **- provide uniform wait time
- LOOK - one direction until services all requests โ reverse
- C-LOOK - variant of C-SCAN - only goes as far as the last request in each direction
|
e6e60cca761147059a1bf7717616c398
|
|
Disk layout
|
Disk Management Notion
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
May 19, 2021
|
cpu can't directly control disk
so kernel has in-memory sturcture




|
5091a147a01a4ff2986c9d80e6aad326
|
|
Disk management
|
Disk Management Notion
|
May 19, 2021
|
Alan Jo
|
Alan Jo
|
May 19, 2021
|
[Disk partitioning](https://texonom.com/disk-partitioning-129115f572724f5cbc570c7517151187)
[Disk bad sector](https://texonom.com/disk-bad-sector-5cc7aac350854f0885cfa60f62bee9ce)
[Disk Swap Space](https://texonom.com/disk-swap-space-5bf2726b42c14bf1abeeb90018408163)
|
2db57b8f7837407088208b308e51bbec
|
|
Disk Performance
|
Disk Management Notion
|
May 19, 2021
|
Alan Jo
|
Alan Jo
|
May 19, 2021
|
### Performance - 1. cost, 2. speed & bandwidth, 3. reliability
optical disk - permanent data storage โ cloud in temporary


|
28e569d80cbe4c3b9e68857ac92550ea
|
|
RAID
|
Disk Management Notion
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
Jun 7, 2021
|
## redundant array of inexpensive disks
[Hardware RAID](https://texonom.com/hardware-raid-861083a0395649d18fa43e8b5dec9f51)
### RAID level - originally 5 level
[RAID 0](https://texonom.com/raid-0-5b52502a6406464689c2bf557f5d3b47)
[RAID 1](https://texonom.com/raid-1-b4b2a03a0193424e8fa40b4ee7488be7)
[RAID 2](https://texonom.com/raid-2-1b24579f29674f05a13c00b5075f2739)
[RAID 3 ](https://texonom.com/raid-3-4cc5f5d7b3c84145825a3f9bc4975ec9)
[RAID 4](https://texonom.com/raid-4-f4db629dc21d4e58a8ad908a83be049f)
[RAID 5](https://texonom.com/raid-5-afdf3a4add0a4374958c915fea1f83ef)
Usual tech of server and NAS and data center
### Two design goals of various RAIDs
1. increased data reliabilitymirroring data
2. increased input/output performance
trade-off between reliability and performance
> even parity, odd parity for detect block failure
> Striping : Disk striping - look at the diagrams which are like stripes
|
4b50ffdd255d430ca76f393e8d1ebe25
|
|
Tertiary storage devices
|
Disk Management Notion
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
May 19, 2021
|
ex. usb, sd card, external disk
[HSM](https://texonom.com/hsm-95b2b5fc37ca4982aed9c39ffe45ecb2)
|
def6411e9adf4220811b65706895e6e3
|
|
Disk bad sector
|
Disk management
| null | null | null | null | null |
[Disk bad sector remapping](https://texonom.com/disk-bad-sector-remapping-f18741071ab949c29a01c238403a0630)
|
5cc7aac350854f0885cfa60f62bee9ce
|
Disk partitioning
|
Disk management
| null | null | null | null | null |
129115f572724f5cbc570c7517151187
|
|
Disk Swap Space
|
Disk management
| null | null | null | null | null |
temporal image space of main memory
### Swap File approach
### Swap partition Approach
- Swapping By File system read but slow because of using VFS but do not need partition
- or do not need file system just image dump to this sector
> rule of the thumb - twice of main memory
|
5bf2726b42c14bf1abeeb90018408163
|
Disk bad sector remapping
|
Disk bad sector
| null | null | null | null | null |
f18741071ab949c29a01c238403a0630
|
|
Hardware RAID
|
RAID
| null | null | null | null | null |
ํ๋์จ์ด ๋๋ฐ์ด์ค๋ฅผ ํตํด RAID๋ฅผ ์ํํ๋ ๊ฒฝ์ฐ ์ด์์ฒด์ ์ ํ์ผ์์คํ
์ RAID ๋ฉ์ปค๋์ฆ์ ์ธ์ํ์ง ๋ชปํจ
์ ์ฉ ํ๋์จ์ด์ธ RAID card ์์ฒด์์ ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ ๊ฒฝ์ฐ ์ ์ฒด ๋์คํฌ array๊ฐ ๋ฌด์ฉ์ง๋ฌผ์ด ๋๋ ๊ฒฝ์ฐ๋
> [๋ค์ด๋ฒ ํด๋ผ์ฐ๋ ํ๋ซํผ (NAVER Cloud Platform) : ๋ค์ด๋ฒ ๋ธ๋ก๊ทธ](https://blog.naver.com/n_cloudplatform/222384170516)
|
861083a0395649d18fa43e8b5dec9f51
|
RAID 0
|
RAID
| null | null | null | null | null |

- RAID 0 - striped disks
|
5b52502a6406464689c2bf557f5d3b47
|
RAID 1
|
RAID
| null | null | null | null | null |

- RAID 1 - disk mirroring
|
b4b2a03a0193424e8fa40b4ee7488be7
|
RAID 2
|
RAID
| null | null | null | null | null |
1b24579f29674f05a13c00b5075f2739
|
|
RAID 3
|
RAID
| null | null | null | null | null |

- RAID 3 - Striped set with dedicated parityidea of redundant disk to increase reliability - many disk decrease reliabilitybut update parity block overhead and bottle neck to parity disk
|
4cc5f5d7b3c84145825a3f9bc4975ec9
|
RAID 4
|
RAID
| null | null | null | null | null |
f4db629dc21d4e58a8ad908a83be049f
|
|
RAID 5
|
RAID
| null | null | null | null | null |

- RAID 5 - Striped set with distributed parity
|
afdf3a4add0a4374958c915fea1f83ef
|
HSM
|
Tertiary storage devices
| null | null | null | null | null |
95b2b5fc37ca4982aed9c39ffe45ecb2
|
|
Memory Address Changing
|
Memory Management Notion
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
May 19, 2021
|
- **Physical address space** - Starting at address 0, going to address MAXsys
- **Logical address space** - Starting at address 0, going to address MAXprog
**CPU(code) execute instructions by logical address**
> **relative address** is an example of logical addres**s**
### Address Generation

until linking, code has relative address and after loading to memory, it has physical address
โ Hardware for Address Translation (For adequate performance) โ dynamically โrelocatedโ
- **Base (also called Relocation) Register **- used for validation in CPU (either limit R)
- **Limit Register -** size of program
## Linking
combining various pieces of code and data into a single file that can be loaded into memory
<details><summary>
Linkerโs tasks</summary>
1. **Symbol resolution** : each **global symbol** in an object file is bound to a **unique definition**
2. **Relocation** : the physical **memory address for each symbol is determined **and where **references **to those objects are modified **either**
</details>
<details><summary>
kind of linker</summary>
1. static linker(`linkage editorโ) - Object modules combine while Compile time
2. dynamic linker - Useful with language libraries (no duplicated copies) - done in Load time or Run time
</details>
### Shared library
- Static libraries disadvantages - Potential for duplicating- **ex. libc.a**
- automatically occur when executable - also occur by user code dlopen() - routines can be shared by multiple processes **ex. ****[libc.so](http://libc.so)**
|
53916e26496843d6bf5a26e6185ebe8d
|
|
Memory Management History
|
Memory Management Notion
|
May 19, 2021
|
Alan Jo
|
Alan Jo
|
May 19, 2021
|
# Backgrounds
Multi programming by time sharing Need multiple processes in memory at once (number of I/O + CPU) **So we need protected updating**
**Memory management = **The task that is carried out by the โ**OS and hardware(MMU)**โ to accommodate multiple processes and **fully use memory resources **to maximize performance
**Requirement - **Each process should have a logically contiguous space โ virtual memory, make user do not consider memory while make program
### **Goal - protect, performance(fully use) and sharing**
|
baac71af6c7c4281894e15349bde6777
|
|
Memory Management Method
|
Memory Management Notion
|
May 19, 2021
|
Alan Jo
|
Alan Jo
|
May 19, 2021
|
### Memory Management Methods
|Title|
|:-:|
|[Virtual Memory](https://texonom.com/virtual-memory-07bf10ba636b42e9818c009b17f893f0)|
|[Paging](https://texonom.com/paging-0571138c29914318a5f6a717cc2b36c0)|
|[Dynamic Partitioning](https://texonom.com/dynamic-partitioning-ec4c829bbfec46d28f441044264eb5a7)|
|[Fixed partitioning](https://texonom.com/fixed-partitioning-068a5eb6e57b4146926dc02fc828b649)|
|[Segmentation](https://texonom.com/segmentation-9927cad8b8bf4366abdc591e533e1060)|
|
040223391bea4c148bcfee4f4064572f
|
|
Dynamic Partitioning
|
Memory Management Methods
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
May 19, 2021
|
- make partition when process input come
- Each process is allocated exactly as much memory as it requires
- Has external fragment (hole is external with no internal)
- Use compaction to shift processes to free memory by external (less use by i/o problem)
> **Compaction is possible only if relocation is dynamic, and is done at execution time**
> I/O problem - Do I/O only into Operating System buffers
<details><summary>
Possible algorithms of placement</summary>
1. Best-fit - The fragment as small as possible
2. First-fit
3. Next-fit: choose first hole from last placement
4. Worst-fit: allocate the largest hole
</details>
> **Overlays** - choose memory layout by program call graph to efficient memory distribute by function module code
|
ec4c829bbfec46d28f441044264eb5a7
|
|
Fixed partitioning
|
Memory Management Methods
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
May 19, 2021
|
Partitions can be of equal or unequal sizes set by hardware - has internal fragmentation (Unequal-size partitions lessens these)
- A program may be too large โ design the program with overlays
### queue(s) fixed partitioning
Placement algorithm with โunequal sizeโ partitions use of multiple queues(minimize internal fragmentation) โ some queue will empty โ use of single queue (increase internal fragmentation)
> internal means internal of partition
|
068a5eb6e57b4146926dc02fc828b649
|
|
Paging
|
Memory Management Methods
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
May 19, 2021
|
### Physical address space of a process can be non-contiguous (Pages are contiguous)
- Keep track of all free frames - internal fragment
- Set up a page table to translate logical to physical addresses
- A virtual (logical) address is a pair (p, o)
- Physical memory address is a pair (f, o)
- Not all pages are mapped to frames
**๋ด๋ถ ๋จํธํ O, ์ธ๋ถ ๋จํธํ X**
**๊ณ ์ ๋ ์์ญ์ธ ํ์ด์ง(page)๋ก ๋ถํ **
### Paging Notion
|Title|
|:-:|
|[Page Replacement Algorithm](https://texonom.com/page-replacement-algorithm-3721241bd6b84fd9b55960f82ecf1fbe)|
|[Paging Table](https://texonom.com/paging-table-b368ef8543cf4628b837232f4fd7fe7c)|
|[Associative Register](https://texonom.com/associative-register-538b0ad40e84419795da36b76959786f)|
|[Paging Protection ](https://texonom.com/paging-protection-b0940a815ff94260bcae736355499b4b)|
|[Hierarchical paging](https://texonom.com/hierarchical-paging-2b45d0a7145b4ae98735812f9f771786)|
|[Segmentation Paging](https://texonom.com/segmentation-paging-dfb1e2f233f1401daf3f8dc74466a57e)|
|[Buddy System](https://texonom.com/buddy-system-b83b6f21d398442a84ff9c4fcd2ce295)|
### Paging Usage
|Title|
|:-:|
|[Paging Example](https://texonom.com/paging-example-35326cf37c694b23ab5bab18de683b9f)|
> [์ธ๊ทธ๋จผํ
์ด์
(segmentation) VS ํ์ด์ง(paging)](https://blog.naver.com/PostView.nhn?blogId=qbxlvnf11&logNo=221368476938&parentCategoryNo=&categoryNo=&viewDate=&isShowPopularPosts=false&from=postView)
|
0571138c29914318a5f6a717cc2b36c0
|
|
Segmentation
|
Memory Management Methods
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
May 19, 2021
|
### more classical method before paging but used in virtual address image
**๊ฐ๋ณ์ ์ธ ์์ญ์ธ ์ธ๊ทธ๋จผํธ(segment)๋ก**
**๋ด๋ถ ๋จํธํ X, ์ธ๋ถ ๋จํธํ O**
- like paging - it has segment table also in each process
Logical address consists of a two tuple - <segment-number, offset>
Segment-table base register (STBR), Segment-table length register (STLR) exist
- **has segment number s(identify segment) and d index(of process entry)- Maps two-dimensional physical addresses**each entry has base and limit

Has also relocation, sharing, allocation issue for fragmentation

> [์ธ๊ทธ๋จผํ
์ด์
(segmentation) VS ํ์ด์ง(paging)](https://blog.naver.com/PostView.nhn?blogId=qbxlvnf11&logNo=221368476938&parentCategoryNo=&categoryNo=&viewDate=&isShowPopularPosts=false&from=postView)
|
9927cad8b8bf4366abdc591e533e1060
|
|
Virtual Memory
|
Memory Management Methods
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
Jan 18, 2023
|
## Demand paging = virtual memory
### Motive : In any hardware, same code(address) should have same data (memory management by maintaining logical semantic)
virtual address: logical address
**Concept : separating of user logical memory from physical memory**
> - Symbolic Address : access variable by name
> - address binding : variable mapping to address and physical memory when compile
**Insight : program do not need all of their code and data at once, so we can separate (but of course have overhead)**
> - Implementation : demand paging
**effect : VM enables program to execute without requiring their entire address space to be resident in physical memory. isolate each process's memory, enable share files and address spaces.**
### Virtual Memory Notion
|Title|
|:-:|
|[Page Table](https://texonom.com/page-table-ffbce6c10d9a4a8993bd0d809f4a4249)|
|[Segmentation Fault](https://texonom.com/segmentation-fault-b1008afd3e3a4117a92c978ba3dc0c14)|
|[Page Replacement](https://texonom.com/page-replacement-936ec615a0554950bc1ab233fb67434f)|
|[page size](https://texonom.com/page-size-c50803e5e52b492c847de02404f0be36)|
|[TLB reach](https://texonom.com/tlb-reach-afd1dceecb9542c086eab1d89b938824)|
|[Swapping](https://texonom.com/swapping-98903f7a115e48808b17fc418468c8e3)|
|[Page fault handler](https://texonom.com/page-fault-handler-b4d166a24a7740a9bc153f80701a03bc)|
|[Virtual Memory Thrashing](https://texonom.com/virtual-memory-thrashing-f57fa2a2a76244278cca8ad66badd63f)|
|[i/o interlock](https://texonom.com/io-interlock-458727109a584d01b1087036dd6922bc)|
|[Pages Arguments](https://texonom.com/pages-arguments-287308a9ec104a0eb0c4e01b157c8831)|
|[TLB (Translation Lookaside Buffer)](https://texonom.com/tlb-translation-lookaside-buffer-fd5ffc7e77c44f57a744915cc426c27e)|
### Virtual Memory Notion Usages
|Title|
|:-:|
|[Linux Paging](https://texonom.com/linux-paging-dddeb1bb20e64c67bf7d38ae744e625c)|
|[COW(copy-on-write)](https://texonom.com/cowcopy-on-write-b41107af21f04feb923f02eeaf677017)|
|[Memory-Mapped Files](https://texonom.com/memory-mapped-files-09442c8a229e475083829ddf52eca697)|
> [8๊ฐ. ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ](https://marlinbar.tistory.com/68?category=300896)
|
07bf10ba636b42e9818c009b17f893f0
|
|
Associative Register
|
Paging Notion
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
May 19, 2021
|
parallel search - if associative register exist
<details><summary>
Address translation (Aยด, Aยดยด) </summary>
โ If Aยด is in associative register, get frame number out
โ Otherwise, get frame number from page table in memory
</details>
### Effective Access time
Associative lookup = `math: \epsilon `time unit - related to hardware performanc
Assume memory cycle time is 1 microsecond
Hit ratio (`math: \alpha`) - related to algorithm
$$EAT = (1 + \epsilon)\alpha + (2 + \epsilon)(1 - \epsilon) \\ = 2 + \epsilon - \alpha$$
|
538b0ad40e84419795da36b76959786f
|
|
Buddy System
|
Paging Notion
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
May 19, 2021
|
- used with virtual memory system either
- combination of fixed and dynamic
Compromise to overcome disadvantages of both fixed and dynamic partitioning schemes
<details><summary>
**Alogorithm**</summary>
1. Start with entire block
2. When request of size S is made
> 
3. this process is repeated until the smallest block greater or equal to S is generated.
4. Two buddies are coalesced whenever both of them become de-allocated.
> Given the address and size of a block, the address of buddy is automatically determined. The address of a block and its buddy differ in exactly one bit position
> **binary branch framework and buddy(share one parent) is has different bit of final address**
</details>

> modified form is used in UNIX SVR4 (and also in Linux) for kernel memory allocation (KMA)
> Smallest size of block is page

|
b83b6f21d398442a84ff9c4fcd2ce295
|
|
Hierarchical paging
|
Paging Notion
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
May 19, 2021
|
โ A simple technique is a two-level page table
โ Break up the logical address space into multiple page table
Has page offset either but **has multi page number in logical address**

last page number indicate page of page table,other is root or outer page table
|
2b45d0a7145b4ae98735812f9f771786
|
|
Page Replacement Algorithm
|
Paging Notion
|
May 19, 2021
|
Alan Jo
|
Alan Jo
|
May 19, 2021
|
### Page Replacement Algorithms
|Title|
|:-:|
|[LRU Algorithm](https://texonom.com/lru-algorithm-1f181112165f4df8b5a5cdea967d65c1)|
|[Clock Algorithm](https://texonom.com/clock-algorithm-80f852e82a0548f5856f09baf11f6cf1)|
|[Second Chance Algorithm](https://texonom.com/second-chance-algorithm-afdfb27ecaac4854902ba38eec679e41)|
|[FIFO Algorithm](https://texonom.com/fifo-algorithm-80eb13636a8f4edc8861c04033c9d637)|
|[LFU Algorithm](https://texonom.com/lfu-algorithm-db665029bdb84a42a98099c471ec744b)|
> [์ฐ์ฃผ๋ฅผ ์ํด : ๋ค์ด๋ฒ ๋ธ๋ก๊ทธ](https://blog.naver.com/oidoman/90097323379)
> [LRU ์๊ณ ๋ฆฌ์ฆ (Least Recently Used Algorithm)](https://j2wooooo.tistory.com/121)
|
3721241bd6b84fd9b55960f82ecf1fbe
|
|
Paging Protection
|
Paging Notion
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
May 19, 2021
|
**Memory protection bits** - Implemented by associating protection bit with each page - e.g. read-only, read-write, in page table
**valid/invalid bit** - changed by other page in same frame
### Sharing is easy - just indicate same frame and make it both valid
|
b0940a815ff94260bcae736355499b4b
|
|
Paging Table
|
Paging Notion
|
May 19, 2021
|
Alan Jo
|
Alan Jo
|
May 19, 2021
|
### Paging Tables
|Title|
|:-:|
|[Hashed page table](https://texonom.com/hashed-page-table-5503e136b5d94731911edb2a21ccd4c9)|
|[Inverted page table](https://texonom.com/inverted-page-table-25d3365925cf4aea9b9eb834c1c6bbad)|
### One table (mean one image) for each process: part of processโs state
<details><summary>
Contents</summary>
1. Flags: valid/invalid (also called resident) bit, dirty bit, reference (also called clock or used) bit used for clock page change algorithm
2. Page frame number
</details>
Page table is kept in main memory
- Page-table base register (PTBR) points to the page table of each process
- Page-table length register (PTLR) indicates size of the page table of each process
> use tlb to lessen memory access overhead to find page
page table size is pretty big โ โ** Only need to map the portion of the address space actually being used** (tiny fraction of entire address space)
Approach Methods
> โ Multi-level(Hierarchical) paging, Hashed page table, Inverted page table
|
b368ef8543cf4628b837232f4fd7fe7c
|
|
Segmentation Paging
|
Paging Notion
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
May 19, 2021
|
- **Use segments to manage logically related units**
- **Use pages to partition segments into fixed size chunks **- first go to segment table (protection easy)
> Need to allocate page table entries only for those pieces of the segments that have themselves been allocated.
> 
> 
**Logical (virtual) address โ Linear address โ Physical address (intel 32 architecture)**

Segmentation: logical partition of memory - Segment Selector bits exist (segmentation register store segment selector bits usually)

> Offset means relative address
|
dfb1e2f233f1401daf3f8dc74466a57e
|
|
Clock Algorithm
|
Page Replacement Algorithms
|
May 19, 2021
|
Alan Jo
|
Alan Jo
|
May 19, 2021
|
second-chance๋ณด๋ค ๋ย ํจ์จ์ ์ธ FIFO๋ฒ์ ์ ์๊ณ ๋ฆฌ์ฆ
queue์ ํ์ด์ง๋ฅผ ์ด๋์ํค์ง ์๋๋ค. clock ์๊ณ ๋ฆฌ์ฆ์ ์ํํ ๋ฆฌ์คํธ๋ฅผ ์ ์งํ๊ณ , ๊ฐ์ฅ ์ค๋๋ ํ์ด์ง๋ฅผ ๊ฐ๋ฆฌํค๋ hand(iterator)๋ฅผ ๊ฐ์ง๊ณ ์๋ค
ํ์ด์ง ํดํธ๊ฐ ๋ฐ์ํ๊ณ ๋น ํ๋ ์์ด ์๋ค๋ฉด, hand๊ฐ ๊ฐ๋ฆฌํค๊ณ ์๋ ํ์ด์ง์ ์ฐธ์กฐ๋นํธ๋ฅผ ๊ฒ์ฌ
๋ง์ฝ ์ฐธ์กฐ๋นํธ๊ฐ ํด๋ฆฌ์ด ์ํ๋ผ๋ฉด hand๊ฐ ๊ฐ๋ฆฌํค๊ณ ์๋ ํ์ด์ง๊ฐ ์๋ก์ด ํ์ด์ง๋ก ์ฌ์ฉ
๊ทธ๋ ์ง ์์ผ๋ฉด ์ฐธ์กฐ๋นํธ๋ฅผ ํด๋ฆฌ์ด์ํจ๋ค. ๊ทธ ๋ค์ hand๋ ์ฆ๊ฐํ๊ณ , ํ์ด์ง๊ฐ ๊ต์ฒด๋ ๋๊น์ง ์ด ๊ณผ์ ์ด ๋ฐ๋ณต
> [์ฐ์ฃผ๋ฅผ ์ํด : ๋ค์ด๋ฒ ๋ธ๋ก๊ทธ](https://blog.naver.com/oidoman/90097323379)
|
80f852e82a0548f5856f09baf11f6cf1
|
|
FIFO Algorithm
|
Page Replacement Algorithms
|
May 19, 2021
|
Alan Jo
|
Alan Jo
|
May 19, 2021
|
**FIFO**ย : ํ์ด์ง๊ฐ ์ฃผ๊ธฐ์ต์ฅ์น์ย ์ ์ฌ๋ ์๊ฐ์ ๊ธฐ์ค์ผ๋ก ๊ต์ฒด๋ ํ์ด์ง๋ฅผ ์ ์ ํ๋ ๊ธฐ๋ฒ
๋จ์ : ์ค์ํ ํ์ด์ง๊ฐ ์ค๋ ์์๋ค๋ ์ด์ ๋ง์ผ๋ก ๊ต์ฒด๋๋ ๋ถํฉ๋ฆฌ. ๊ฐ์ฅ ์ค๋ ์์๋ ํ์ด์ง๋ ์์ผ๋ก ๊ณ์ ์ฌ์ฉ๋ ๊ฐ๋ฅ์ฑ์ด ์์.
[Belady's Anomaly](https://texonom.com/beladys-anomaly-d5dfd0e9467f4aa1a7ba5d584c4c6d0c)
|
80eb13636a8f4edc8861c04033c9d637
|
|
LFU Algorithm
|
Page Replacement Algorithms
|
May 19, 2021
|
Alan Jo
|
Alan Jo
|
May 19, 2021
|
**LFU**ย : ๊ฐ์ฅย ์ ์ ํ์๋ฅผ ์ฐธ์กฐํ๋ ํ์ด์ง๋ฅผ ๊ต์ฒด
๋จ์ : ์ฐธ์กฐ๋ ๊ฐ๋ฅ์ฑ์ด ๋ง์์๋ ๋ถ๊ตฌํ๊ณ ํ์์ ์ํ ๋ฐฉ๋ฒ์ด๋ฏ๋ก ์ต๊ทผ์ ์ฌ์ฉ๋ ํ๋ก๊ทธ๋จ์ย ๊ต์ฒด์ํฌ ๊ฐ๋ฅ์ฑ์ด ์๊ณ , ํด๋น ํ์๋ฅผ ์ฆ๊ฐ์ํค๋ฏ๋ก ์ค๋ฒํค๋ ๋ฐ์
|
db665029bdb84a42a98099c471ec744b
|
|
LRU Algorithm
|
Page Replacement Algorithms
|
May 19, 2021
|
Alan Jo
|
Alan Jo
|
May 19, 2021
|
## Least Recently Used Algorithm
๊ฐ์ฅ ์ค๋ซ๋์ ์ฐธ์กฐ๋์ง ์์ ํ์ด์ง๋ฅผ ๊ต์ฒด
|
1f181112165f4df8b5a5cdea967d65c1
|
|
Second Chance Algorithm
|
Page Replacement Algorithms
|
May 19, 2021
|
Alan Jo
|
Alan Jo
|
May 19, 2021
|
FIFO์ ๋ณํ๋ ํํ์ ์๊ณ ๋ฆฌ์ฆ
FIFO์ ๊ฐ์ด ์ ๊ฑฐ๋ ํ์ด์ง๋ฅผ queue์ ์ฒซ๋ฒ์งธ ์์๋ก๋ถํฐ ์ฐพ๋๋ค
๊ทธ๋ฌ๋ ์ฆ์ ํ์ด์ง๋ฅผ ์ ๊ฑฐํ๋ ๊ฒ์ด ์๋๋ผ, ๊ทธ ํ์ด์ง์ ์ฐธ์กฐ๋นํธ๊ฐ ์ธํ
๋์ด ์๋์ง๋ฅผ ์ฒดํฌํ๋ค
์ธํ
๋์ด ์์ง ์์ผ๋ฉด ์ ๊ฑฐํ๋ ๊ฒ์ด๊ณ , ๊ทธ๋ ์ง ์์ผ๋ฉดย ์ฐธ์กฐ๋นํธ๋ฅผ ํด๋ฆฌ์ดํด์ queue์ ๋งจ ๋ค๋ก ์ด๋์
> [์ฐ์ฃผ๋ฅผ ์ํด : ๋ค์ด๋ฒ ๋ธ๋ก๊ทธ](https://blog.naver.com/oidoman/90097323379)
|
afdfb27ecaac4854902ba38eec679e41
|
|
Belady's Anomaly
|
FIFO Algorithm
| null | null | null | null | null |
FIFO(First In First Out)์์, ์๋ ํ์ด์ง ํ๋ ์์ ๊ฐ์๋ฅผ ๋๋ฆฌ๋ฉด page fault๋ฐ์์ด ๊ฐ์ ํด์ผ ํ๋, ์คํ๋ ค ๋์ด๋๋ ๊ฒฝ์ฐ๊ฐ ๋ฐ์
> [๋ฒจ๋ ์ด๋์ ๋ชจ์ (Belady's Anomaly)](https://m.blog.naver.com/cookatrice/50037414550)
|
d5dfd0e9467f4aa1a7ba5d584c4c6d0c
|
Hashed page table
|
Paging Tables
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
May 19, 2021
|
- The virtual page number is hashed into a page table
- This page table contains a chain of elements hashing to the same location
- need hash function and page table like hash table

Virtual page numbers are compared in this chain searching for a match. If a match is found, the corresponding physical frame is extracted (fast)
|
5503e136b5d94731911edb2a21ccd4c9
|
|
Inverted page table
|
Paging Tables
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
May 19, 2021
|
### ์ญ ํ์ด์ง ํ
์ด๋ธ
One entry for each real page of memory (frame) - Only one page table in the system
- Entry consists of the virtual address of the page stored in that real memory location, with information about the process that owns that page
- by pid, p โ get i by hash table for limit one either

> [์ญ ํ์ด์ง ํ
์ด๋ธ (Inverted Page Table) > ๋๋ฆฌ์ ๋์งํธ๋ผ์ดํ](http://blog.skby.net/%EC%97%AD-%ED%8E%98%EC%9D%B4%EC%A7%80-%ED%85%8C%EC%9D%B4%EB%B8%94-inverted-page-table/)
|
25d3365925cf4aea9b9eb834c1c6bbad
|
|
Paging Example
|
Paging Usage
|
May 19, 2021
|
Alan Jo
|
Alan Jo
|
May 19, 2021
|
# Paging in Hardware (Intel x86)
โ **physical addresses of page tables (CR3 register store) - two level in intel (+ page directory)**

Enable by setting PG bit in CR0 register
4kb so 20 upper bits to find page table



> Linux support Four-level paging for future



|
35326cf37c694b23ab5bab18de683b9f
|
|
i/o interlock
|
Virtual Memory Notion
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
Jan 18, 2023
|
- ์ปค๋๋ก ๋ฌธ์ ํด๊ฒฐ - Lock pages in physical memory using lock bits.
|
458727109a584d01b1087036dd6922bc
|
|
Page fault handler
|
Virtual Memory Notion
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
Jan 18, 2023
|
### It is kind of interrupt
if required PTE (entry) has invalid bit in page table than cause an exception to throw so go to OS(kernel mode), bring in missing page into physical frame, update PTE and restart instruction.
-**Page fault service time: **service the page-fault interrupt + Read in the page + Restart the process
- **Effective access time: **memory access time * (1 - p) + disk access time * p (p = probability of page fault)
**degradation: **effective access time / memory access time (low p than low degradation)
> **Locality**: dependent on page replacement policy
> page change occur by not only by PFH, since predict page usage by machine learning
|
b4d166a24a7740a9bc153f80701a03bc
|
|
Page Replacement
|
Virtual Memory Notion
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
Jan 18, 2023
|
> **Belady's Proof (Oracle solution: ideal)**: Evicting the page that will not be used for the longest period of time minimizes the number of page faults
# Counting Algorithms
- LFU(Least frequently used)but do not reflect time variable*recent used victim
- MFU(Most Frequently Used)consider recent used
# Timing algorithms
- FIFOSimple: single pointer sufficesBelady's Anomaly: more frame do not improve fifo algorithm performance
- LRU (Least recently used)by counters or stack
### but lru is complicate
### LRU Approximation (real use)
- Sampled LRU (hardware support)reference bit - can be cleared when full
- Second-Chance AlgorithmLRU clock(Secondd chance) - clock bitclock hand - PTE reference - often use modified bit(dirty bit) either
> Evaluate algorithm usually by running it on a particular string of memory references (reference string) and computing the number of page faults on that string
**Evict picked victim page**
Page fault service time โ Service the page-fault interrupt + Read in the page + Restart the process
### Allocation of Frames
each process need minimum number of pages - Must provide enough frames to hold all the different pages that any single instruction can reference
- local replacement - can not steal other process's frame - Fixed(Equal) allocation - each algorithm to process
- global replacement - can steal other process's frame - Priority allocation
> Proportional allocation : related to process size set frame number
> Priority allocation : set process priority
# Page replacement Examples
1. windows NTdemand paging with clustering(gist)process has working-set min, working-set maximum and if exceed then automatic working-set trimming process perform to restore free memory
2. solaris 2
> 
|
936ec615a0554950bc1ab233fb67434f
|
|
page size
|
Virtual Memory Notion
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
Jan 18, 2023
|
- Provide Multiple Page Sizeshardware page size various so we can choose by softwarelarge: small page table, small page faultsmall: less handling overhead, small internal fragment
|
c50803e5e52b492c847de02404f0be36
|
|
Page Table
|
Virtual Memory Notion
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
Jan 18, 2023
|
Each Process has Page Table, Page table entry(PTE) has valid, access bit
### Page Table Arguments
1. V = {0 ,1 , ..., N-1}: virtual address space
2. P = {0, 1, ..., M-1}: physical address space
3. N > M: difference that not comparable
4. MAP: V โ P U {null} address mapping function
5. null if in Disk (if valid is 0): page fault
### Page Table Parameters
log upper = lower
6. P = Page size (bytes): typically KBs
7. N = Virtual Address limit
8. M = Physical address limit
<details><summary>
virtual address = virtual page number(VPN) bit + page offset</summary>
VPN acts page index in page table
</details>
physical address = physical page number bit + page offset
address translation change previous one only (32 bit to other)
> compare start by page table base register
page table need protection and cache do not need because of address translation
|
ffbce6c10d9a4a8993bd0d809f4a4249
|
|
Pages Arguments
|
Virtual Memory Notion
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
Jan 18, 2023
|
Virtual page and Physical page both exists, Page Table connect VP to PP
- P = total number of virtual pages
- N = total number of Physical pages
1. PP can be placed in Disk (Storage)
2. Different VP can point out same PP (ex. library)
> if disk read occur than DMA(direct memory access) transfer and then by I/O controller there will be interrupt processor
|
287308a9ec104a0eb0c4e01b157c8831
|
|
Segmentation Fault
|
Virtual Memory Notion
|
Jun 1, 2021
|
Alan Jo
|
Alan Jo
|
Jan 18, 2023
|
[Segmentation](https://texonom.com/segmentation-9927cad8b8bf4366abdc591e533e1060)
|
## Segfault
OS์ ๋ฉ๋ชจ๋ฆฌ ์ก์ธ์ค ์๋ฐ์ ์๋ฆฌ๊ธฐ ์ํด ๋ฉ๋ชจ๋ฆฌ ๋ณดํธ ๊ธฐ๋ฅ์ด์๋ ํ๋์จ์ด์์ ๋ฐ์ํ๋ ์ค๋ฅ
customer handler๋ฅผ ์ค์นํ์ฌ ์ฌ์ฉํ์ง ์์ผ๋ฉด Linux์ ์ปค๋์์ ๋์ํ๊ณ ์๋ process signal ์ฒ๋ฆฌ
segfault๋ ์ผ๋ฐ์ ์ผ๋ก ํ๋ก์ธ์ค๋ฅผ ์ข
๋ฃํ๊ณ ์ ์ ํ ulimit ์ค์ ์ ๊ฐ์ถ ์ฝ์ด ๋คํ๋ฅผ ์์ฑ
[Segfault RSP](https://texonom.com/segfault-rsp-9fa0f64a2de94e26906b7689c0590fd4)
[Segfault RIP](https://texonom.com/segfault-rip-364a0188edf74a3e9f535a5f733bc996)
์ค๋ฅ ๊ฐ์ ํ์ด์ง ์ค๋ฅ ์ค๋ฅ ์ฝ๋ ๋นํธ์ ๋นํธ ๋ง์คํฌ from `arch/x86/mm/fault.c`
> [What is Segfault Message?](https://hslee77.github.io/linux,cloud/2021/05/07/LinuxSegfault-Event.html)
|
b1008afd3e3a4117a92c978ba3dc0c14
|
Swapping
|
Virtual Memory Notion
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
Jan 18, 2023
|
A process can be swapped temporarily out of memory to a **backing store - **and then brought back into memory for continued execution
Backing store - Fast disk that must provide direct access to these memory images
bring a page into memory only when it is needed (page-level **swapping**)
- OS do movement of pages between memory/disks
- evicted pages go to disk if page is dirty to a swap file
|
98903f7a115e48808b17fc418468c8e3
|
|
TLB reach
|
Virtual Memory Notion
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
Jan 18, 2023
|
- TLB Reach = (RLB Size) * (Page Size)๊ฐ๋ณ ํ์ด์ง ์ฌ์ด์ฆ ์ด์ฉํด์ ์ปค๋ํํ
๋ ํฐ ํ์ด์ง
|
afd1dceecb9542c086eab1d89b938824
|
|
TLB (Translation Lookaside Buffer)
|
Virtual Memory Notion
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
Jan 18, 2023
|
usually fully associative cache since page table is in memory
### bits: valid + dirty(since it is cache and if write back) + tag(process ID + virtual page number) + physical page number + page offset
|
fd5ffc7e77c44f57a744915cc426c27e
|
|
Virtual Memory Thrashing
|
Virtual Memory Notion
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
Jan 18, 2023
|
<details><summary>
Since lack of free frame(low RAM), process > physical memory then page fault rate will be very high</summary>

</details>
โ os use all time to swapping
Solution Method two - working set, ppf
>
### 1. Working set,
locality set + others for continity = working set
***Working Set***: set of actively used pages
`math: \Delta` : working-set window : fixed number of page references (ex. 10,000 instruction)
> ex. WS(t1) = {1,2,3,4,5} ,ํ๊บผ๋ฒ์ ๋ฐ๋ฉ, ๋์ฌ
$$\Sigma WSSi = total demand frames$$
OS monitor direct D, and if D > total number of frames in physical them swap process
***then how to direct?: ***like sampled lru use ***reference bit*** and ***interval time***
increasing bit will make performance better 2^bit per interrupt
### 2. Page-fault Frequency Allocation
Window's method
directly measure and control page-fault rate
establish acceptable page fault frequency
- too high rate โ increase number of frames
- too low rate โ decrease number of frames
|
f57fa2a2a76244278cca8ad66badd63f
|
|
Segfault RIP
|
Segmentation Fault
| null | null | null | null | null |
๋ช
๋ น ํฌ์ธํฐ ๋ ์ง์คํฐ ๊ฐ
|
364a0188edf74a3e9f535a5f733bc996
|
Segfault RSP
|
Segmentation Fault
| null | null | null | null | null |
์คํ ํฌ์ธํฐ ๋ ์ง์คํฐ ๊ฐ
|
9fa0f64a2de94e26906b7689c0590fd4
|
COW(copy-on-write)
|
Virtual Memory Notion Usages
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
Jan 18, 2023
|
like fork(do not need to copy code and data) we do resource sharing efficiently
image copy on write time, parent and child processes to initially share the same
If either process modifies a shared page, only then is the page copied.

|
b41107af21f04feb923f02eeaf677017
|
|
Linux Paging
|
Virtual Memory Notion Usages
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
Jan 18, 2023
|
### four-level paging for future hardware which has many three level to mapping to hardware
each process has its own Page Global Directory and its own set of page (upper, middle, null)tables


task struct data sturucture has mm pointer, mm is pointer which has image mm_struct data sturcture. that has mmap pointer. process's meta data sturcture vm araa struct
pgd is page first table base address directory
1. read then page fault (segmentation fault) start end area
2. write code is fault so OS read commision
3. also fault because because r/w no physical in frame then replacement
> 

**KMA: **dynamic memory allocation in head (3gb) by malloc. in kernel (1gb) memory allocationbecause kernel cannot use malloc
- contiguous page frame allocator : alooc_pages()
- noncontiguous page fram allocator : vmalloc()
- memory object allocators : the slab alloctor- kmem_cache_alloc : congifuous allocation of kernel objects- kmalloc() : contiguous allocation of arbitrary length up to 128kb
## Page replacemnet in linux
- **two LRU listsinactive_list - pages not known to be importantactive_list - pages known to be referenced frequently**
- kernel swap daemon (a kernel thread)
- more on page replacemnet mechanism
> 64bit usually use 3 level paging
|
dddeb1bb20e64c67bf7d38ae744e625c
|
|
Memory-Mapped Files
|
Virtual Memory Notion Usages
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
Jan 18, 2023
|
Memory-mapped file I/O allows file I/O to be treated as routine memory access by mapping a disk block to a page in memory
- Uniform access for files and memory โ less copying

|
09442c8a229e475083829ddf52eca697
|
|
Garbage Collector
|
Memory Management Usage
|
Oct 29, 2020
|
Alan Jo
|
Alan Jo
|
May 19, 2021
|
### Garbage Collector Notion
|Title|
|:-:|
|[GC Compaction](https://texonom.com/gc-compaction-9179519ad2ec4ba48377ad941be50edf)|
|[Generational GC](https://texonom.com/generational-gc-9e88cd3b020e417dbe4d0a231884d0c7)|
|[Generational Theory](https://texonom.com/generational-theory-307b210f9661421580b4b22b331014c1)|
### Garbage Collectors
|Title|
|:-:|
|[Static Garbage Collector](https://texonom.com/static-garbage-collector-eaac7f4e278741fe97fa212dd9037eba)|
|[Dynamic Garbage Collector](https://texonom.com/dynamic-garbage-collector-7d88c0e0170b4c1c8a890b6e65932088)|
|
8af9f92e3ca842ee8ddd638e25647cd7
|
|
Memory Leak
|
Memory Management Usage
|
Oct 29, 2020
|
Alan Jo
|
Alan Jo
|
May 19, 2021
|
1. Global Variable
2. Timer, Callback
3. Closer
4. Multi Reference
> [์๋ฐ์คํฌ๋ฆฝํธ์ V8 ์์ง์ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ ํ๋ก์ธ์ค](https://medium.com/naver-place-dev/%EC%9E%90%EB%B0%94%EC%8A%A4%ED%81%AC%EB%A6%BD%ED%8A%B8%EC%99%80-v8-%EC%97%94%EC%A7%84%EC%9D%98-%EB%A9%94%EB%AA%A8%EB%A6%AC-%EA%B4%80%EB%A6%AC-%ED%94%84%EB%A1%9C%EC%84%B8%EC%8A%A4-f45091e696e1)
|
16c4f840b59e4d45a04770b03e582229
|
|
GC Compaction
|
Garbage Collector Notion
|
Apr 30, 2021
|
Alan Jo
|
Alan Jo
|
Apr 30, 2021
|
[Dynamic Garbage Collector](https://texonom.com/dynamic-garbage-collector-7d88c0e0170b4c1c8a890b6e65932088)
|

> [Go ์ธ์ด์ GC์ ๋ํด - LINE ENGINEERING](https://engineering.linecorp.com/ko/blog/go-gc/)
|
9179519ad2ec4ba48377ad941be50edf
|
Generational GC
|
Garbage Collector Notion
|
Apr 30, 2021
|
Alan Jo
|
Alan Jo
|
Apr 30, 2021
|
[Generational Theory](https://texonom.com/generational-theory-307b210f9661421580b4b22b331014c1) [V8 GC](https://texonom.com/v8-gc-2630948f867a46069a56ccae5271f574) [JVM GC](https://texonom.com/jvm-gc-0023b0c7ffe644ed94a45f2a69fde1ea)
|
์ธ๋๋ณ GC์ ๋ชฉ์ ์ heap ๋ด ๊ฐ์ฒด๋ฅผ ์๋ช
(GC์์ ์ด์ ๋จ์ ํ์ ๋ฑ์ผ๋ก ๋ํ๋)์ ๋ฐ๋ผ ๋ถ๋ฅํ์ฌ GC ํจ์จ์ ํฅ์์ํค๋ ๊ฒ
- ๊ฐ์ฒด ์ ๊ท ํ ๋น ์์ญ์์ GC๋ฅผ ์์ฃผ ์ํ(Minor GC)
- ํด๋น ์์ญ GC์์ ์ฌ๋ฌ ๋ฒ ์ด์ ๋จ์(๊ฐ์ฅ ์ค๋๋) ๊ฐ์ฒด๋ ์น๊ฒฉ(promote)์์ผ GC ๋น๋๊ฐ ๋ฎ์(Major GC) ์์ญ์ผ๋ก ์ด๋
Java8 HotSpot VM์์๋ ๋ชจ๋ ์ปฌ๋ ํฐ๊ฐ ์ธ๋๋ณ GC๋ฅผ ์ ๊ณต
[write barrier](https://texonom.com/write-barrier-73c82a9b955346429fee7fc504ab3172)
> [Go ์ธ์ด์ GC์ ๋ํด - LINE ENGINEERING](https://engineering.linecorp.com/ko/blog/go-gc/)
|
9e88cd3b020e417dbe4d0a231884d0c7
|
Generational Theory
|
Garbage Collector Notion
|
Apr 30, 2021
|
Alan Jo
|
Alan Jo
|
Apr 30, 2021
|
์๋ก ํ ๋น๋ ๊ฐ์ฒด๋ ๋๋ถ๋ถ ์ผ์ฐ ์ฃฝ๋๋ค๋ ๊ฐ์ค
|
307b210f9661421580b4b22b331014c1
|
|
write barrier
|
Generational GC
| null | null | null | null | null |
์ธ๋๋ณ GC๋ GC๋ฅผ ์ํํ์ง ์์ ๋๋ ์ ํ๋ฆฌ์ผ์ด์
์ ์ค๋ฒํค๋๊ฐ ๋ฐ์ํ๋ค๋ ๋จ์
root์์ ์ ๊ท ์ธ๋๋ฅผ ์ฐธ์กฐํ๋ ๊ฒฝ๋ก๋ง ์กฐ์ฌํ ๋ค ๊ทธ ์ค ์ ๊ทผ ๋ถ๊ฐ๋ฅํ ์ํ์ธ ๊ฒ์ ํ์ํ๋ฉด
๊ทธ๋ ๋ค๊ณ ์ค๋๋ ๊ฐ์ฒด๋ฅผ ํฌํจํ์ฌ heap ์ ์ฒด๋ฅผ ๊ฒ์ฌํด ๋ฒ๋ฆฌ๋ฉด ์ธ๋๋ณ GC๋ฅผ ํ๋ ์๋ฏธ๊ฐ ์๋ค
๊ทธ๋์ ์ ํ๋ฆฌ์ผ์ด์
์์ ์ฐธ์กฐ๋ฅผ ๋์
ํ๊ฑฐ๋ rewriteํ ๋, ์ค๋๋ ์ธ๋์์ ์ ๊ท ์ธ๋๋ฅผ ์ฐธ์กฐํ๋ ๊ฒฝ์ฐ ํด๋น ์ฐธ์กฐ๋ฅผ ๋ณ๋๋ก ๊ธฐ๋กํ๋ ์ฒ๋ฆฌ๊ฐ ์ถ๊ฐ
์ด์ ๊ฐ์ ์ฐธ์กฐ์ โmutateโ์ ํจ๊ป ๋ถ์์ ์ผ๋ก ์งํํด์ผ ํ๋ ์ฒ๋ฆฌ๋ฅผ โwrite barrierโ๋ผ๊ณ

์ธ๋๋ณ GC๋ฅผ ์ฌ์ฉํ๋ฉด write barrier ์ค๋ฒํค๋์ ๋นํด ์ป์ ์ ์๋ ์ด์ ์ด ๋ ํด ๊ฒ์ผ๋ก ๊ธฐ๋
> [Go ์ธ์ด์ GC์ ๋ํด - LINE ENGINEERING](https://engineering.linecorp.com/ko/blog/go-gc/)
|
73c82a9b955346429fee7fc504ab3172
|
Dynamic Garbage Collector
|
Garbage Collectors
|
Apr 30, 2021
|
Alan Jo
|
Alan Jo
|
Apr 30, 2021
|
GC ์ํ ์ alive ์ํ์ ๊ฐ์ฒด๋ฅผ heap ๋์ผ๋ก ์ฌ๋ฐฐ์นํด์ heap์ ์์ถ
- ๋จํธํ ํํผ
- bump allocation์ ํตํด ๊ณ ์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น ๊ตฌํ ๊ฐ๋ฅ
> - ๊ฐ์ฒด๊ฐ heap ๋์ ์์นํ๋ฏ๋ก ๋ฉ๋ชจ๋ฆฌ ์ ๊ท ํ ๋น ์ ๋์์ ๋ฐ๋ก increment

### Dynamic Garbage Collectors
|Title|
|:-:|
> [Go ์ธ์ด์ GC์ ๋ํด - LINE ENGINEERING](https://engineering.linecorp.com/ko/blog/go-gc/)
|
7d88c0e0170b4c1c8a890b6e65932088
|
|
Static Garbage Collector
|
Garbage Collectors
|
Apr 30, 2021
|
Alan Jo
|
Alan Jo
|
Apr 30, 2021
|
์ ์ ์ ํ์ GC๋ GC๋ณ๋ก heap ๋ด ๊ฐ์ฒด๋ฅผ ์ฌ๋ฐฐ์นํ์ง ์์ต๋๋ค
์ ์ ์ ํ GC์์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น๊ณผ ํด์ ๋ฅผ ๋ฐ๋ณตํ๋ฉด heap ๋จํธํ๊ฐ ๋ฐ์ํด ํ ๋น ์ฑ๋ฅ์ด ์
ํ๋๋ ๋ฌธ์ ๊ฐ ์๋ค
๋จ, ์ด๋ ๋ฉ๋ชจ๋ฆฌ ํ ๋น์๋ฅผ ์ด๋ป๊ฒ ๊ตฌํํ๋๋์ ๋ฐ๋ผ ๋ฌ๋ผ์ง
### Static Garbage Collectors
|Title|
|:-:|
|[Tracing garbage collection](https://texonom.com/tracing-garbage-collection-19e036fe4c964d12be25ea3a974b69fd)|
> [Go ์ธ์ด์ GC์ ๋ํด - LINE ENGINEERING](https://engineering.linecorp.com/ko/blog/go-gc/)
|
eaac7f4e278741fe97fa212dd9037eba
|
|
Tracing garbage collection
|
Static Garbage Collectors
|
Nov 9, 2020
|
Alan Jo
|
Alan Jo
|
Apr 30, 2021
|
[Stop the world GC](https://texonom.com/stop-the-world-gc-5b16f1ca6ac3450bbf63e3bf56397538)
[Mark & Sweep GC](https://texonom.com/mark-sweep-gc-b7bb682c52bc4be98043c847381fe483)
[Reference Counting](https://texonom.com/reference-counting-a780282e427c436f8e12ca7f95173926)
[Strong and weak references](https://texonom.com/strong-and-weak-references-7c3454cf4f1843d991bdc68439ec0091)
> [Tracing garbage collection](https://en.wikipedia.org/wiki/Tracing_garbage_collection#Stop-the-world_vs._incremental_vs._concurrent)
|
19e036fe4c964d12be25ea3a974b69fd
|
|
Mark & Sweep GC
|
Tracing garbage collection
| null | null | null | null | null |
### ๋ฃจํธ์์ ์ ๊ทผ ๊ฐ๋ฅํ ๋ฉ๋ชจ๋ฆฌ๋ active, ๋๋จธ์ง๋ ๊ธฐ๋น์ง
[CMS Collector](https://texonom.com/cms-collector-5893234d493d4a9a8e14b4a392d44827)
**active root ์ ์์น ์๋ ์ฐธ์กฐ๊ฐ ํฌํจ๋์ด์๋ค๋ฉด, ํ์ ์๋ ๋ฉ๋ชจ๋ฆฌ๊ฐ ํ ๋น๋ ๋งํผ ๋ฉ๋ชจ๋ฆฌ ๋์๊ฐ ๋ฐ์**
2๋จ๊ณ ๊ฐ๋น์ง ์ปฌ๋ ์
์๊ณ ๋ฆฌ์ฆ
1. Mark: GC ๋ฃจํธ ๋ชฉ๋ก์ ์์ฑํฉ๋๋ค. ์๋ฐ์คํฌ๋ฆฝํธ์ ๊ฒฝ์ฐย `window`๊ฐ์ฒด๊ฐ ๋ฃจํธ๋ก ์๋ํ๋๋ฐ, ๋ฃจํธ๋ ์ฝ๋์์ ์ฐธ์กฐ๋๋ ์ ์ญ ๋ณ์๋ฅผ ๋ปํฉ๋๋ค. ๋ชจ๋ ๋ฃจํธ๋ค์ย `acitve`ย ํน์ย `alive`(๊ฐ๋น์ง๊ฐ ์๋)๋ก ํ์๋๋ฉฐ, ์ด๋ค์ ์์๋ค ๋ํ ์ฌ๊ท์ (recursively)์ผ๋ก ๋์ผํ๊ฒ ์ฒ๋ฆฌ๋ฉ๋๋ค. ์ฆ, ๋ฃจํธ์์ ์ ๊ทผ ๊ฐ๋ฅํ๋ค๋ฉด ๊ฐ๋น์ง๊ฐ ์๋๋ผ๊ณ ํ๋จ๋ฉ๋๋ค.
2. Sweep:ย `active`๋ก ํ๊ธฐ๋์ง ์์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋ชจ๋ ๊ฐ๋น์ง๋ก ๊ฐ์ฃผํ์ฌ ๋ฐํํฉ๋๋ค.
> [์๋ฐ์คํฌ๋ฆฝํธ์ V8 ์์ง์ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ ํ๋ก์ธ์ค](https://medium.com/naver-place-dev/%EC%9E%90%EB%B0%94%EC%8A%A4%ED%81%AC%EB%A6%BD%ED%8A%B8%EC%99%80-v8-%EC%97%94%EC%A7%84%EC%9D%98-%EB%A9%94%EB%AA%A8%EB%A6%AC-%EA%B4%80%EB%A6%AC-%ED%94%84%EB%A1%9C%EC%84%B8%EC%8A%A4-f45091e696e1)
|
b7bb682c52bc4be98043c847381fe483
|
Reference Counting
|
Tracing garbage collection
| null | null | null | null | null |
๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ๋ ๋ณ์์ ์๋ฅผ ์ถ์ ํ๋ ๋ฐฉ๋ฒ
๋ ํผ๋ฐ์ค๊ฐ ํ๋ ์ฆ๊ฐ/๋ณต์ฌ ๋ ๋๋ง๋ค ์นด์ดํธ๊ฐ 1๋งํผ ์ฆ๊ฐ
๋ ํผ๋ฐ์ค ์นด์ดํ
์ ๋งค์ฐ ์ฌํํ๊ณ ๋น ๋ฅธ ๊ฐ๋น์ง ์ปฌ๋ ์
๋ฐฉ์์ด์ง๋ง, cyclic/circular reference ๋ฅผ ์ฒ๋ฆฌํ์ง ๋ชปํ๋ ๋ฑ์ ๋จ์
์ค๋งํธ ํฌ์ธํฐ cpp
|
a780282e427c436f8e12ca7f95173926
|
Stop the world GC
|
Tracing garbage collection
| null | null | null | null | null |
5b16f1ca6ac3450bbf63e3bf56397538
|
|
Strong and weak references
|
Tracing garbage collection
| null | null | null | null | null |
7c3454cf4f1843d991bdc68439ec0091
|
|
CMS Collector
|
Mark & Sweep GC
| null | null | null | null | null |
## Concurrent Mark & Sweep
|
5893234d493d4a9a8e14b4a392d44827
|
Interrupt
|
Processor Scheduling Notion
|
May 19, 2021
|
Alan Jo
|
Alan Jo
|
Mar 28, 2023
|
[reverie](https://github.com/facebookexperimental/reverie)
|
### interception
### Interrupt Notion
|Title|
|:-:|
|[Mode Switching](https://texonom.com/mode-switching-b7f85582f0474555a8c08da922b33610)|
|[OS Mode](https://texonom.com/os-mode-b0375e3351064cbd9d220d1c9d44e0e8)|
|[Syscall](https://texonom.com/syscall-74f2aa4e9d7141dbad05bae5c88a07e0)|
|[Context Switching](https://texonom.com/context-switching-132451f1c9fe4324a1a2bd84e11e7696)|
|[Preemptive Scheduling](https://texonom.com/preemptive-scheduling-c4b6e46752f14d69bb769e987ae1c21b)|
|[Cooperative Scheduling](https://texonom.com/cooperative-scheduling-93d38df64c4843e68d71e5db4e0f5752)|
> [๋ฐฑ์๋ ๊ฐ๋ฐ์๋ค์ด ์์์ผํ ๋์์ฑ 4โโโ์ค์ผ์ค๋ง](https://choi-geonu.medium.com/๋ฐฑ์๋-๊ฐ๋ฐ์๋ค์ด-์์์ผํ -๋์์ฑ-4-์ค์ผ์ค๋ง-e684331afc77)
|
d26d34c54d5447a6888ad85089184fb3
|
Process
|
Processor Scheduling Notion
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
May 19, 2023
|
[Memory Management](https://texonom.com/memory-management-dbf37c509eaf46deb2df8ccd086e386c)
|
### process - program in execution
### Process Notion
|Title|
|:-:|
|[Process Sync](https://texonom.com/process-sync-45211a317f4f442cbab6b374fdaed630)|
|[Process switching ](https://texonom.com/process-switching-7f2486a6184241fba896860610a4d5f1)|
|[Process Memory](https://texonom.com/process-memory-53285d27582d49058052939d739e8623)|
|[Process Function Call](https://texonom.com/process-function-call-ab41c2af3a5743599fca591ce08b535f)|
|[Process State](https://texonom.com/process-state-bbe0f9abe7b240c7a1d2a2d1c3478afd)|
|[Process control block](https://texonom.com/process-control-block-f62e2db348e442c580ea6d2084973973)|
|[Process descriptor](https://texonom.com/process-descriptor-81614898a94d48058419b80e9e971fae)|
|[Process image ](https://texonom.com/process-image-c6384d00d1af41a6bcaa1b238165be17)|
|[Process context](https://texonom.com/process-context-e76d70c66cd840b4a247de3310e85416)|
|[Process Exit](https://texonom.com/process-exit-2d82b561fba64541bde82c478297a22c)|
|[Critical Section](https://texonom.com/critical-section-8469b236528b41efb4088ea3a69a4cc4)|
|[Semaphore](https://texonom.com/semaphore-46b11416972249d2a40e6c3e5060304a)|
|[Monitor Sync](https://texonom.com/monitor-sync-54b03a3282964bdb88207ec60dfeb1b2)|
|[IPC](https://texonom.com/ipc-98010a1077fd45968ce78ae98505b2e5)|
|[massage passing](https://texonom.com/massage-passing-ab22575af94b441caad37d2e1697cd59)|
|[Mutex](https://texonom.com/mutex-cbfff707d2fe484ea20344f1104b7141)|
> memory, device, files, process has each table
> **process image **is get by pid
> [์๋ฒ์ ๊ฑธ๋ฆฌ๋ ๋ถํ, ์ถ์ธกํ์ง ๋ง๊ณ ๊ณ์ธกํ์](https://injae-kim.github.io/dev/2020/07/09/how-to-check-single-server-load-average.html)
|
ffd68f9e2b2648759b96047d48d17778
|
Processor Scheduler
|
Processor Scheduling Notion
|
May 19, 2021
|
Alan Jo
|
Alan Jo
|
Feb 21, 2023
|
### Processor Schedulers
|Title|
|:-:|
|[Long-term scheduler](https://texonom.com/long-term-scheduler-5f0783472fa94c478b10b7a1bfbf0192)|
|[Short-term scheduler](https://texonom.com/short-term-scheduler-f95f24cbd78d490c8a216dcabb04e4cb)|
|[Medium-term scheduler](https://texonom.com/medium-term-scheduler-15b70c90c2f641e696fcc6c90cbd04d9)|
### Processor Scheduler Notion
|Title|
|:-:|
|[Processor Dispatcher](https://texonom.com/processor-dispatcher-dac6ca05f13c4ddc82906bd73f6080df)|
### Processor Queues
|Title|
|:-:|
|[Job Queueย ](https://texonom.com/job-queue-92bccac0db114b5c83a0f3ac0d9de17e)|
|[Ready Queue](https://texonom.com/ready-queue-c8546adf7d604a73a15b292808bef5b7)|
|[Device Queue](https://texonom.com/device-queue-453d40088668423c96d51003b27f9a2e)|
- selection function (which) in ready Q
- decision mode (when) - end time
> - non preem
> - preem
> [[O/S] CPU Scheduler์ Dispatcher](https://velog.io/@ss-won/OS-CPU-Scheduler%EC%99%80-Dispatcher)
|
8c124741c1e84d26b0b0a8ad599337f4
|
|
Thread
|
Processor Scheduling Notion
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
Feb 21, 2023
|
### Thread Notion
|Title|
|:-:|
|[Thread Safe](https://texonom.com/thread-safe-a6b8ab6ec6e146deafa86b428e5ecfbe)|
|[Threads model](https://texonom.com/threads-model-800491618af24626b02f701d43578b66)|
|[kernel level thead](https://texonom.com/kernel-level-thead-498f95b4e748492b8e2ed535bf987b0b)|
|[Lock convoy](https://texonom.com/lock-convoy-a904af475dcb4bb8a0d99ea8e095de39)|
|[Two-Step Dance](https://texonom.com/two-step-dance-b328c6d4bef8483a97e076bbc91b0be8)|
|[Priority Inversion](https://texonom.com/priority-inversion-beb6115d6154481db836a5677f877581)|
|[Threads Scheduling](https://texonom.com/threads-scheduling-e1315fdaa06740c6ab54f097edeba1d7)|
|[Deadlock](https://texonom.com/deadlock-8c118f296cc1477aac5c59c75cec8235)|
|[CAS](https://texonom.com/cas-b3541e0665b74cf7aa4f91a7b202fde2)|
### Thread Types
|Title|
|:-:|
|[user level thread](https://texonom.com/user-level-thread-6f68e5d2dff240359b9b494534598b29)|
> [์ข ์์ํ ์ค๋ ๋ ๊ด๋ จ ๋ฌธ์ ](https://m.blog.naver.com/PostView.nhn?blogId=jjoommnn&logNo=130036504092&proxyReferer=https:%2F%2Fwww.google.com%2F)
|
d704a229d3b94619963c61bb742b822b
|
|
****Context Switching****
|
Interrupt Notion
|
Mar 28, 2023
|
Alan Jo
|
Alan Jo
|
Mar 28, 2023
|
### ****Context Switching Notion****
|Title|
|:-:|
|
132451f1c9fe4324a1a2bd84e11e7696
|
|
****Cooperative Scheduling****
|
Interrupt Notion
|
Mar 28, 2023
|
Alan Jo
|
Alan Jo
|
Mar 28, 2023
|
ํ์กฐ์ ์ค์ผ์ค๋ง
|
93d38df64c4843e68d71e5db4e0f5752
|
|
Mode Switching
|
Interrupt Notion
|
May 19, 2021
|
Alan Jo
|
Alan Jo
|
Feb 21, 2023
|
b7f85582f0474555a8c08da922b33610
|
||
OS Mode
|
Interrupt Notion
|
Nov 5, 2019
|
Alan Jo
|
Seong-lae Cho
|
Feb 21, 2023
|
# hardware protection
1. dual mode - user mode / kernel mode - need hardware support
2. hardware protect
protected processor register in intel **CPL(current), RPL(request), DPL(descriptor)**
> supervisor = system = monitor = kernel
> before mode
> intel real mode, protected mode
# Mode change
### 1. hardware(external) interrupt - i/O interrupt - device interrupt
โ timer intterupt
### 2. software(internal) interrupt - exception
โ exception handler
### 3. system call
# system call
โ system call handler (by system call interface - inplement of wapper funct in libc.a)
### Method
> int 0x80(vector) or sysenter
> 1. same reg to KM stack
> 2. invoke system call service routine
> 3. exit handler
> syscall_exit or sysexit
> <details><summary>
>
> example</summary>
> 1. fork ()
> 2. fork{} in libc.a
> 3. movl 2, %eax - 2 means fork, eax is register
> 4. int 0x80(system call)
> 5. go to IDT(interrupt desciptor table)
> 6. go to kernel mode function
> 7. save all in stack
> 8. check eax to function
> 9. find sys call table that (2, fork)
> 10. do ref_from_sys_call in entry.S
>
> </details>
>
> ### kind
>
> [System call](https://texonom.com/system-call-f36194e943f3498593520460b36c55aa)
>
- process management system call
- file management system call
- file system management system call
> &system_call - handler address
# Bridge
there is breidge like north and south to control traffic
> no bridge in embedded
# VM
- hosted - up on host OS
- stand alone - up on hardware
[dual booting](https://texonom.com/dual-booting-24656ee018014e6388b841b9f579c30c)
|
b0375e3351064cbd9d220d1c9d44e0e8
|
|
Preemptive Scheduling
|
Interrupt Notion
|
Mar 28, 2023
|
Alan Jo
|
Alan Jo
|
Mar 28, 2023
|
์ ์ ํ ์ค์ผ์ฅด๋ง
|
c4b6e46752f14d69bb769e987ae1c21b
|
|
Syscall
|
Interrupt Notion
|
Feb 21, 2023
|
Alan Jo
|
Alan Jo
|
Feb 21, 2023
|
74f2aa4e9d7141dbad05bae5c88a07e0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.