์ด๋ฒ ๊ณผ์ ๋ malloc
์ ์ง์ ๊ตฌํํ๋ ๊ฒ.
์ข ๋ ๋ช
ํํ๋ malloc
, free
, realloc
์ ํฌํจํ๋ ๋์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น๊ธฐ๋ฅผ ๋ง๋๋ ๊ฒ.
์ฒ์์ ์ฑ ์ ์๋ ์ฝ๋๋ฅผ ๊ทธ๋๋ก ํ์ดํ ํด๋ณด๋ฉด์ ์ดํดํ์ผ๋, ๊ณ์ ์ด๋ฐ ์๊ฐ์ด ๋ค์๋ค.
๊ทธ๋์ ์ด๊ฒ ์ง๊ธ ๋ญ ํ๊ณ ์๋๊ฑฐ์ง?
์๊ฐํด๋ณด๋ malloc
์ด ์์์ ์ด๋ป๊ฒ ๋์ํ๋ ์ง๋ ๋ชจ๋ฅด๊ณ malloc
์ ๋ฐ๋ผ ๋ง๋ค๋ ค๊ณ ํ๋ ๊ฒ.
๊ทธ๋ ๋ด malloc
์ด ๋ฌด์ด๋. memory allocation.
C dynamic memory allocation refers to performing manual memory management for dynamic memory allocation in the C programming language via a group of functions in the C standard library, namely malloc, realloc, calloc and free.
- ์ถ์ฒ : https://en.wikipedia.org/wiki/C_dynamic_memory_allocation
malloc
์ ํฌํจํด realloc
, calloc
, free
๋ C์์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋์ ํ ๋น ๋ฐ์ ์ ์๊ฒ ํด์ฃผ๋ ํจ์์ ๋ชจ์์ธ ๊ฒ.
๊ตฌ์ฒด์ ์ธ malloc
์ ๋ด๋ถ ๋ก์ง.
๋ค์ด๊ฐ๊ธฐ์ ์์, malloc
์ด heap ์์ญ์ ์ก๊ณ ์ ์งํ๋ค๋ ์ฐจ์์์ ์ดํด๋ฅผ ๋๊ธฐ์ํด pool์ด๋ผ๋ ๋จ์ด๋ฅผ ์ฌ์ฉํ์์ ์๋ฆฐ๋ค. ๊ฒฐ๊ตญ ๊ฐ์ ๋ง์ด๋ค.
malloc
์ ํฌ๊ธฐ๊ฐ ์์ ํ ๋น์์ฒญ์ ๋ํด์๋ ์์ ์ด ๊ฐ์ง pool(i.e. heap segment)์์ ํ ๋นํด์ฃผ๊ณ , ํฌ๊ธฐ๊ฐ ํฐ ํ ๋น์์ฒญ์ ๋ํด์๋ pool์ด ์๋ memory mapping segment์์ ํ ๋นํด์ค๋ค.
malloc
๋ด์์๋ ๋๊ฐ์ง syscall์ด ํ์ฉ๋๋๋ฐ, mmap
๊ณผ sbrk
๊ฐ ๊ทธ๊ฒ์ด๋ค.
sbrk
๋ malloc
์ด ์ ์งํ๊ณ ์๋(์ข ๋ ์ ํํ๋ ์์์ ์ธ๊ธ๋ ํจ์๋ค๋ก ์ด๋ฃจ์ด์ง ๋ช
์์ ํ ๋น๊ธฐ์์ ์ ์งํ๊ณ ์๋) pool์์์ ํ์ฌ ํ ๋น์์ฒญ์ ๋ํ ํ ๋น์ ํด์ค ์ ์๋ ์ํฉ์ด ์์ ๋, pool์ size๋ฅผ ๋๋ฆฌ๊ธฐ์ํด ์ฌ์ฉ๋๋ค.
sbrk
์ ์ํ๋ incr๋ฅผ ์ ๋ฌํด ํธ์ถํ๊ฒ ๋๋ฉด ๊ฐ์๋ฉ๋ชจ๋ฆฌ ์์์ heap segment์ ๋ ์ง์ ์ ๊ฐ๋ฆฌํค๋ program brk๊ฐ incr๋งํผ ์ฆ๊ฐํ๊ณ , ์ด๋ ๊ณง heap segment์ ํฌ๊ธฐ๊ฐ ์ฆ๊ฐํจ์ ์๋ฏธํ๋ค. ๋ ์ด๋ ๊ณง malloc
์ด ์ ์งํ๋ pool์ ํฌ๊ธฐ๊ฐ ์ฆ๊ฐํจ์ ์๋ฏธํ๋ค.
mmap
์ ํฌํค๊ฐ ํฐ ํ ๋น์์ฒญ์ ๋ํด memory mapping segment์ ์์ญ์ ํ ๋นํด ์ค ๋ ์ฌ์ฉ๋๋ค. ์๋ mmap
์ '๋ฉ๋ชจ๋ฆฌ ๋งคํ'์ ์ํด ์ฌ์ฉ๋๋ ์์คํ
ํธ์ถ.
๋ฉ๋ชจ๋ฆฌ ๋งคํ์ด๋, ์ด๋ค ๊ฐ์๋ฉ๋ชจ๋ฆฌ ์์ญ์ ๋์คํฌ์ ํ์ผ ๋ด์ฉ์ผ๋ก ์ด๊ธฐํํ ๋ ์ฌ์ฉํ๋ ์์คํ ํธ์ถ.
๋จ, ์ง๊ธ ์ํฉ์์๋ ๊ทธ์ ํ ๋น ์์ฒญ ํฌ๊ธฐ์ ๋ง๋ ๊ฐ์๋ฉ๋ชจ๋ฆฌ ์์ญ์ ์ป์ผ๋ฉด ๋๋ ๊ฒ์ด๋ฏ๋ก, ํน์ ํ์ผ ๋ด์ฉ์ด ๋ค์ด๊ฐ ์์ง ์์, ์ด ํ๋ก์ธ์ค๋ง์ด ์ฌ์ฉ ๊ฐ๋ฅํ ์์ญ์ ๋ฐ์ผ๋ฉด ๋๊ฒ ๋ค. ๊ตฌ์ฒด์ ์ธ ๋ด๋ถ ๊ตฌํ์ ๋ชจ๋ฅด๊ฒ ์ง๋ง, mmap
์ manual๋ก ํธ์ถํ ๋ MAP_ANONYMOUS
flag ์, MAP_PRIVATE
flag๋ฅผ ์ฃผ๋ฉด, ๋ฉ๋ชจ๋ฆฌ ์์ญ ๋ด๋ถ๊ฐ 0์ผ๋ก ์ด๊ธฐํ ๋, ์ด ํ๋ก์ธ์ค๋ง ์ฌ์ฉ ํ ์ ์๋ ์์ญ์ ์ป์ ์ ์๊ธฐ์ ์ด๋ฌํ ๋ฐฉ๋ฒ์ ์ฌ์ฉํ์ผ๋ฆฌ๋ผ ์ถ์ธก๋๋ค.
๊ทธ๋ ๋ด ์ ํฌ๊ธฐ๊ฐ ํฐ ํ ๋น ์์ฒญ์ ๋ํด์๋ heap์ ์์ญ์ด ์๋ memory mapping segment์ ์์ญ์ ํ ๋นํด์ค๊น?
๋จผ์ , free
๋ฅผ ํตํด์๋ ์ค์ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ๋ฐํ์ด ์ด๋ฃจ์ด์ง์ง ์์ ์๋ ์์์ ์์์ผ ํ๋ค. ์์ ๋งํ๋ฏ malloc
์ ์์ฒด์ ์ธ pool์ ์ ์งํ๋ฉด์ ํ ๋น๊ณผ ๋ฐํ์ ์ํํด์ฃผ๊ธฐ ๋๋ฌธ์, ์ผ๋จ pool์ ํฌ๊ธฐ๊ฐ ์ ํด์ง๋ฉด ๊ทธ ํฌ๊ธฐ ๋งํผ์ ํด๋น ํ๋ก์ธ์ค๊ฐ ๊ณ์ํด์ ์ ์ ํ๋ ๊ณต๊ฐ์ด ๋ ๊ฒ์ด๋ค.
์ด๋ฌํ ์ํฉ์์, ํฌ๊ธฐ๊ฐ ์ ๋ฒ ํฐ ์์ญ์ pool์์ ํ ๋นํ๊ณ ๋ฐํํ๋ค๋ฉด, ๊ทธ๋ฆฌ๊ณ ๊ตฌํ๋ ์๊ณ ๋ฆฌ์ฆ์ ํน์ฑ์ ๊ทธ ์์ญ์ ํ์ฉํ์ง ์๊ฒ ๋๋ค๋ฉด, ๋ฉ๋ชจ๋ฆฌ์ ๋ญ๋น๊ฐ ์๊ธธ ๊ฒ์ด๋ค.
์ด๋ฅผ ๋ฐฉ์งํ๊ณ ์, ํน์ threshold๋ฅผ (glibc์ malloc ๊ธฐ์ค 128KB) ๋๋ ํ ๋น ์์ฒญ์ ๋ํด์๋ mmap
์ ํตํด pool(heap segment) ๋ฐ๊นฅ์ ๊ฐ์ ๋ฉ๋ชจ๋ฆฌ ์์ญ์ ๊ณต๊ฐ์ ํ ๋นํด์ฃผ๊ณ , free
๋ฅผ ์์ฒญ์ munmap
์ ํตํด ์์คํ
์ ์ค์ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ด ๋ฐํ๋ ์ ์๋๋ก ํ๋ ๊ฒ์ด๋ค.
์ด์จ๋ ์ด ๋ชจ๋ ์ดํด๋ฅผ ํตํด ์ฐ๋ฆฌ๊ฐ ์ํํด์ผํ ๊ณผ์ ๋,
๋๋ง์ ๋ช
์์ ํ ๋น๊ธฐ(malloc
, free
, realloc
์ ํฌํจํ๋)๋ฅผ ๋ง๋๋ ๊ฒ. ๊ตฌ์ฒด์ ์ผ๋ก๋ ํ ๋น๊ธฐ๊ฐ ๊ฐ๊ณ ์๋ pool์ ๊ด๋ฆฌํ๋ ๋ฐฉ๋ฒ์ ๊ตฌํํ๋ ๊ฒ์ด ๋๊ฒ ๋ค.
ํ ๋น๊ธฐ๊ฐ ํด์ผํ๋ ์ฃผ๋ ์ ๋ฌด๋ ์์ฒญ ์ฌ์ด์ฆ์ ํด๋นํ๋ ๋ธ๋ก์ ์ฐพ์์ ์ดํ๋ฆฌ์ผ์ด์ ์๊ฒ ์ ๋ฌํด์ฃผ๊ณ , ์ดํ๋ฆฌ์ผ์ด์ ์ด ํด๋น ๋ธ๋ก์ ๋ฐํํ๋ฉด ๊ทธ ๊ณต๊ฐ์ ๋ค์ ์ฌํ์ฉ ํ๋ ๊ฒ.
๋ธ๋ก์ ์ฐพ๋ ๋ฐฉ๋ฒ์ ๋จ์ํ๊ฒ ํด์ ์๊ฐ์ ๋น ๋ฅด๊ฒ ํ๋ฉด,
์ฒ๋ฆฌ๋(throughput)์ ๋์ง๋ง, ๊ณต๊ฐ ํ์ฉ๋(space utilization)๋ ์ค์ด๋ ๋ค.
๋ฐ๋๋ก ๋ธ๋ก์ ์ ๊ตํ๊ฒ ์ฐพ์์ ๊ณต๊ฐ์ ํจ์จ์ ์ผ๋ก ์ ์ฐ๋ฉด,
๊ณต๊ฐ ํ์ฉ๋(space utilization)๋ ๋์ด๋์ง๋ง, ์ฒ๋ฆฌ๋(throughput)์ด ์ค์ด๋ค ๊ฒ์ด๋ค.
pool์ ๊ด๋ฆฌํ๋ ๋ฐฉ๋ฒ์ด๋ผ ํจ์,
๊ตฌ์ฒด์ ์ผ๋ก ๋ณด์๋ฉด ์๋์ ๊ฐ๋ค.
์ด๋ป๊ฒ free block๋ค์ ์ง์์ ์ผ๋ก ์ถ์ ํ๋๊ฐ?
free block list์๋ implicit, explicit, segment list, buddy system์ด ์๋ค.
implicit list : ๊ฐ ๋ธ๋ก์ ํค๋(์ ํธํฐ)์ ๊ทธ ๋ธ๋ก์ ํ ๋น์ฌ๋ถ๊ฐ ์ ์ฅ๋์ด ์์ ๋ฟ์ด๋ค. ๊ทธ๋์ ๊ฐ์ฉ ๋ธ๋ก๋ค์ ํ๋์ฉ ๋ณด๋ ค๋ฉด, ๋ฌด์กฐ๊ฑด ๋งจ ์ฒ์ ๋ธ๋ก๋ถํฐ ํ๋นํ๋น ํ๋์ฉ ๋ณด๋ฉด์ ๊ทธ ๋ธ๋ก์ด free์ธ์ง allocated์ธ์ง ํ์ธํด์ผ ํ๋ค.
์ด ๊ด์ ์์ ๋ณด๋ฉด 'free block list'๋ผ๋๊ฑด ์กด์ฌํ์ง ์๋๋ค(ํ๋ฉด์ผ๋ก ๋๋ฌ๋์ง ์๋๋ค). ๋จ์ง ํ ์์ '๋ฌต์์ ์ผ๋ก' ์จ์ด์๋ ๊ฒ์ด๋ค. ์ด๋ฐ ์์ผ๋ก free ๋ธ๋ก์ ์ฐพ์์ผ ํ๊ธฐ ๋๋ฌธ์ implicit list๋ผ๊ณ ๋ถ๋ฅธ๋ค.
explicit list : implicit๊ณผ ๋ค๋ฅด๊ฒ, free block ๋ค์ด ์๋ก ํฌ์ธํฐ๋ฅผ ํตํด ์ฐ๊ฒฐ๋จ์ผ๋ก์จ free block list๊ฐ ๋ช
์์ ์ผ๋ก ์กด์ฌํ๊ฒ ๋๋ค. ์ด์ค ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ก ๊ตฌํํ ์ ์๋ค.
๋ช
์์ ์ผ๋ก ๋ฆฌ์คํธ๊ฐ ์กด์ฌํ๊ธฐ ๋๋ฌธ์, ์๋กญ๊ฒ ๋ฐ์๋ free block์ list์ ์ด๋ค ๋ฐฉ์์ผ๋ก ์ฝ์
ํ ์ง ๋ฐฉ๋ฒ์ด ๋๋ ์ ์๋ค : LIFO(ํ์
์ ์ถ) ๋๋ free block์ address order. ์ ์๋ ๋ฐํ์ด ๋น ๋ฅด๊ณ ํ์์ ๋ฐํ์ ๋ง๋ ์์น(์ฃผ์์์ผ๋ก)๋ฅผ ํ์ธํด์ผ ํ๊ธฐ ๋๋ฌธ์ ์๊ฐ์ด ๊ฑธ๋ฆฐ๋ค. ๋ค์์ ์ค๋ช
๋ first-fit์ ๋ฐฉ๋ฒ์ ์ฌ์ฉํ๋ค๊ณ ํ๋ฉด, LIFO๋ณด๋ค๋ address order์ first-fit์ด best-fit์ ๊ทผ์ ํ๋ ์ข์ ๋ฉ๋ชจ๋ฆฌ ์ด์ฉ๋๋ฅผ ๊ฐ์ง. (best-fit์ด ๊ฐ์ฅ ์ข์ํ
์ง๋ง, ํ์ค์ ์ผ๋ก ์๊ฐ์ด ๋๋ฌด ์ค๋ ๊ฑธ๋ฆผ. ๋ฐ๋ผ์ first-fit์ ์ฌ์ฉํ๋ฉด์ list์ ๊ตฌ์ฑ์ ํตํด best-fit์ ๊ทผ์ ํด์ง๋ ค๋ ์๋๊ฐ ๋ง์)
Segregated Lists (Segregated Fit) : ๋ค์์ free block list๋ฅผ ํฌ๊ธฐ ํด๋์ค๋ก ๋๋์ด ์ ์งํ๋๋ฐ, ๊ฐ list์ blcok ํฌ๊ธฐ๋ ๊ทธ list์ ํด๋นํ๋ ํฌ๊ธฐ ๋ฒ์ ์์ ์ํ๋ค. ๋ถํ ์ด๋ ์ฐ๊ฒฐ๋ ํ์ง ์์ผ๋ฉด์ ๋จ์ง free block์ ํฌ๊ธฐ๋ณ๋ก ๋ชจ์๋ ์ผ๋ก์จ ๊ด๋ฆฌ์ ํ์์ ์ฉ์ดํ๊ฒ ํจ.
๋น ๋ฅด๊ณ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ๊ฐ ํจ์จ์ ์ธ ๋ฐฉ์. ์ด๋ ํ ์์ฒญ ํฌ๊ธฐ์ ๋ํด ์ ์ฒด ํ์ด ์๋ ํด๋น ํฌ๊ธฐ์ ํด๋์ค ์(ํ์ ํน์ ๋ถ๋ถ)์์๋ง ๊ฒ์์ ์ํํ๊ธฐ ๋๋ฌธ์ ๋น ๋ฅธ ๊ฒ์์๊ฐ.
๋ํ 'ํด๋น ํด๋์ค'๋ผ๋ ๋ง์ ์ต๋ํ ์์ฒญ ํฌ๊ธฐ์ ๋น์ทํ ํฌ๊ธฐ์ ๋ธ๋ก๋ค ์ค์์ ๊ฒ์ํ๋ ๊ฒ์ด๋ฏ๋ก ๋ฉ๋ชจ๋ฆฌ ์ด์ฉ๋๋ ๋์์ง ์์.
buddy system : segregated fit ๋ฐฉ๋ฒ์ ํน๋ณ ์ผ์ด์ค. ๊ฐ ํฌ๊ธฐ ํฌ๋์ค์ ํฌ๊ธฐ๊ฐ 2์ ์ ๊ณฑ์์ด๋ค. ๋ง์ฝ ์ ์ฒด heap size๊ฐ ์ด๋ผ๋ฉด, ํฌ๊ธฐ ํด๋์ค๋ค์ ํฌ๊ธฐ๋ ,where
์ด๋ค. ๋งจ ์ฒ์์๋ ํฌ๊ธฐ์ ๋ธ๋ก ํ๋๊ฐ ์๊ณ , ์์ฒญ์ ๋ฐ๋ผ ํด๋น ๋ธ๋ก์ ๋ฐ์ผ๋ก ๊ณ์ ์ชผ๊ฐ๋ฉด์ ๋๋๊ฒ๋๋ค. fitํ size์ ๋ธ๋ก์ด ์์ฑ๋๋ฉด ๊ทธ ๋ธ๋ก์ ํ ๋นํ๊ณ , ๊ณผ์ ์ค์ ์ชผ๊ฐ์ง ๋ธ๋ก(buddy: ์ด๋ค ๋ธ๋ก๊ณผ ํฌ๊ธฐ๊ฐ ๊ฐ์ ์ง๊ฟ ๋ธ๋ก)๋ค์ ๋ค์ ๊ฐ๊ฐ์ ํด๋์ค๋ก ๋ค์ด๊ฐ๊ฒ ๋๋ค. ๋ธ๋ก์ freeํ ๋๋ buddy๊ฐ free์ํ์ด๋ฉด ์ฐ๊ฒฐํ๊ณ , allocated buddy๊ฐ ๋์ฌ ๋ ๊น์ง ํฌ๊ธฐ๋ฅผ ํค์๊ฐ๋ฉฐ ์ด๋ฅผ ๋ฐ๋ณตํ๋ค.
(Memory Partitioning 3: Buddy System).
ํ ๋น ์์ฒญ์ ์ ํฉํ free block์ ์ด๋ค ๋ฐฉ์์ผ๋ก ์ ํํ ๊ฒ์ธ๊ฐ?
free block์์ ์์ฒญ๋ size๋งํผ์ ๋บ ๋๋จธ์ง์ ๋ธ๋ก ์์ญ์ ๋ค์ free block์ผ๋ก ๋ง๋ค ๊ฒ์ธ๊ฐ?
๋ฐฉ๊ธ ๋ฐํ๋ free block์ ์ธ์ ํ free block๋ค๊ณผ ํฉ์ณ ํ๋์ ๋ ํฐ free blcok์ผ๋ก ๋ง๋ค ๊ฒ์ธ๊ฐ?
์ฌ์ค ์ด๋ฐ ๋ชจ๋ ๋
ธ๋ ฅ๋ค์ ํด์ผํ๋ ์ด์ ๋ ์ดํ๋ฆฌ์ผ์ด์
์ด ๋ช
์์ ์ผ๋ก free๋ฅผ ์์ฒญํ๊ธฐ ๋๋ฌธ (๋ช
์์ ํ ๋น๊ธฐ). ๊ฐ ์์ฒญ์ ์ ํฉํ ๋น ๊ณต๊ฐ์ ํ์ํ๊ณ ํ ๋นํ๋ ๊ณผ์ ๊ณผ ๊ทธ ๊ตฌ์กฐ๋ฅผ ๊ตฌํํ๋ ๊ฒ์ด ๋ณต์กํ ๊ฒ.
free๋ฅผ ๋ฌต์์ ์ผ๋ก ํ๊ธฐ๋ก ์ฝ์ ํ๋ค๋ฉด, ์ฆ ์ดํ๋ฆฌ์ผ์ด์
์ ๋ฌด์กฐ๊ฑด ํ ๋น๋ง ๋ฐ๊ณ , ํ ๋น ๋ฐ์ ๊ณต๊ฐ ์ค ๋์ด์ ์ฐ์ด์ง ์์ ๊ณต๊ฐ๋ค์ ํ ๋น๊ธฐ ์ธก์์ ํ๋จํด ์์๋ก freeํด์ค ์ ์๋ค๋ฉด ๊ณต๊ฐ ๊ด๋ฆฌ๊ฐ ๋งค์ฐ ์ ์ฉํด์ง ๊ฒ. ๋จ ์ด ๊ฒฝ์ฐ์๋ ํ ๋นํด์ค ๊ณต๊ฐ ์ค ๋ ์ด์ ์ฐ์ด์ง ์์ ํ ๋น ๊ณต๊ฐ์ ํ๋จํ๋ ๊ธฐ์ค๊ณผ ๊ทธ ๊ตฌํ์ด ๋ณต์กํด์ง ๊ฒ์ด๋ค.
ํ๋ก์ธ์ค๋ค์ ์๋ก cpu์ ๋ฉ์ธ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋ค๋ฅธ ํ๋ก์ธ์ค๋ค๊ณผ ๊ณต์ ํ๋ค.
์ด๋ฌํ ์ํฉ์์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋ณด๋ค ํจ์จ์ ์ด๊ณ ๋ ์ ์ ์๋ฌ๋ฅผ ๊ฐ๋๋ก ๊ด๋ฆฌํ๊ธฐ ์ํด ๊ฐ์๋ฉ๋ชจ๋ฆฌ(Virtual Memory)๋ผ๋ ๋ฉ์ธ๋ฉ๋ชจ๋ฆฌ์ ๋ํ ์ถ์ํ๋ฅผ ์ด์ฉํ๋ค. ์ด๋ฌํ ์ถ์ํ๋ฅผ ํตํด ํ๋ก์ธ์ค ํ๋๋ ์์ ์ด ๋ฉ์ธ๋ฉ๋ชจ๋ฆฌ ์ ์ฒด๋ฅผ ์ฌ์ฉํ๋ค๊ณ ๊ฐ์ ํ๋ฉด์ ์คํ๋ ์ ์๋ค.
๊ฐ์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํตํด ๋ค์์ ์ธ๊ฐ์ง ๊ธฐ๋ฅ์ ์ป์ ์ ์๋ค.
๋ฉ์ธ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋์คํฌ์ ๋ํ ์บ์๋ก ์ทจ๊ธํด, ๋ฉ์ธ ๋ฉ๋ชจ๋ฆฌ ๋ด ํ์ฑํ ์์ญ๋ง ์ ์งํ๋ฉด์ ํ์ํ ๋๋ง ๋์คํฌ์ ๋ฉ๋ชจ๋ฆฌ ๊ฐ์ ๋ฐ์ดํฐ ์ ์ก์ด ์ด๋ฃจ์ด์ง๋๋ก ํ๋ค.
๊ฐ ํ๋ก์ธ์ค์ ํต์ผ๋ ์ฃผ์๊ณต๊ฐ์ ์ ๊ณตํจ์ผ๋ก์จ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ๋ฅผ ๋จ์ํํ๋ค.
๊ฐ ํ๋ก์ธ์ค์ ์ฃผ์๊ณต๊ฐ์ ๋ค๋ฅธ ํ๋ก์ธ์ค์ ์ํ ์์์ผ๋ก๋ถํฐ ๋ณดํธํ๋ค.
ํ๋ก๊ทธ๋จ์ด ์ฌ์ฉํ๋(์๊ธฐ ์์ ์ด ๋ฉ๋ชจ๋ฆฌ์ ์ฌ๋ ค์ง๋ ๊ฒ ํฌํจ) ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ๊ฐ ์ฉ๋์ ๋ง๊ฒ ์ธ๊ทธ๋จผํธ(์์ญ)์ผ๋ก ๋๋ ์ ๊ตฌ์กฐํ ํ ๊ฒ.
code segment (text segment)
์คํ๊ฐ๋ฅํ ๋ช
๋ น์ด(executable code)๊ฐ ์ ์ฅ๋๋ค. ๋ณดํต read-only์ด๊ณ , ์ฌ์ด์ฆ๊ฐ ์ ํด์ ธ์๋ค.
data segment (initialized)
์ด๊ธฐํ๋ static ๋ณ์๋ค(e.g. global variables, local static variables)์ ํฌํจํ๋ค.
BSS segment (Block Started by Symbol)
์ด๊ธฐํ๋์ง ์์ static ๋ณ์๋ค์ ํฌํจํ๋ค.
์ด ์ธ๊ทธ๋จผํธ์ ๋ฐ์ดํฐ๋ค์ ํ๋ก๊ทธ๋จ์ ์คํ๊ณผ ํจ๊ป ์ปค๋์ ์ํด 0์ผ๋ก ์ด๊ธฐํ๋๋ค.
Stack
์คํ ์์ญ์ LIFO ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง๋ ํ๋ก๊ทธ๋จ ์คํ์ ํฌํจํ๋ค.
ํธ์ถ๋ ํจ์์ ์ง์ญ๋ณ์, ํจ์ ์ํ ์ดํ์ ๋ฆฌํดํ ์ฃผ์์ ๋ ์ง์คํฐ ์ํ ๊ฐ ๋ฑ์ ์ ๋ณด๊ฐ ์ ์ฅ๋๋ค.
Heap
๋์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น์ด ์ํ๋๋ ์ธ๊ทธ๋จผํธ ๊ณต๊ฐ.
์ดํ๋ฆฌ์ผ์ด์
์ ์์คํ
์ฝ์ ์ฌ์ฉํด์ ์ด์์ฒด์ ๋ก๋ถํฐ ์๋น์ค(e.g. I/O)๋ฅผ ์์ฒญํจ.
์ปค๋์ด ์์ ์ ๋ณดํธํ๊ธฐ ์ํด ๋ง๋ ์ธํฐํ์ด์ค๋ผ๊ณ ์ดํดํ ์๋ ์์.
LGTM