Garbage Collection: ํ๊ณต๊ฐ์ ํ ๋น๋ ๊ณต๊ฐ์ ์๋์ ์ผ๋ก ๋ฐํํด์ฃผ๋ ๊ฒ
- application์ด freeํด์ค ํ์๊ฐ ์ ๋ ์์
- Functional, scripting, ํ๋ Object oriented ์ธ์ด์์ ํํ ์์: Lisp, ML, Java, Perl, Mathematica...
- C์ C++์์๋ ๋ณด์์ ์ธ ํํ์ gc ์กด์ฌ :๋ชจ๋ garbage collect(์์ง)๋ถ๊ฐ:
- ์ธ์ ๋ฉ๋ชจ๋ฆฌ free์์ผ์ค ์ง memory manager๊ฐ ์๊น?
- ์ผ๋ฐ์ ์ผ๋ก ๋ฏธ๋์ ๋ญ๊ฐ ์ด๋ป๊ฒ ์ฐ์ผ ์ง ์ ์ ์๋ ๋ฐฉ๋ฒ์ด ์์ (์กฐ๊ฑด์ ๋ฐ๋ผ ๋ค๋ฅด๋ฏ๋ก)
- ํ์ง๋ง ํน์ ๋ธ๋ก๋ค์ ๊ฐ๋ฅดํค๋ ํฌ์ธํฐ๊ฐ ์๋ค๋ฉด ๊ทธ ๋ธ๋ก๋ค์ ์ฌ์ฉ(์ ๊ทผ)ํ ์ ์๋ค๋ ๊ฑด ์ ์ ์์.
compact
ํ์ง ์์ ์ด์ ๋ธ๋ก์ ์ฎ๊ธฐ์ง ์์CS์์ reference counting์ ์ฐธ์กฐ์ ๊ฐ์,ํฌ์ธํฐ์ ๊ฐ์ ๋ฑ์ ์ ์ฅํ๋ ํ๋ก๊ทธ๋๋ฐ ๊ธฐ์ ๋๋ ์์(object, ๋ฉ๋ชจ๋ฆฌ ๋ธ๋ก, ๋์คํฌ ๊ณต๊ฐ ๋ฑ๋ฑ)์ ๋ค๋ฃจ๋ ๋ฐฉ์์ด๋ค.
GC์๊ณ ๋ฆฌ์ฆ์์ reference counting์ ๋์ด์ ์ฌ์ฉ๋์ง ์๋ object๋ค์ deallocateํ๊ธฐ ์ํด ์ฌ์ฉ๋๋ค.
๊ฐ object์ ๊ดํด counting track๋ฅผ ์ฐธ์กฐํ๋ฉด์, ์ฐธ์กฐ์ ๊ฐ์๊ฐ 0์ด ๋๋ฉด object๊ฐ ์ ๊ทผ ๋ถ๊ฐ๋ฅํ๋ค๊ณ ํ๋จํ๊ณ destroy(์ ๊ฑฐ)ํ ์ ์๋ค๊ณ ํ๋จ.
object๋ฅผ ์ ๊ฑฐํ๋ฉด ์ด object์ ์ํด ์ฐธ์กฐ๋๊ณ ์๋ ์ฐธ์กฐ ์นด์ดํธ๋ ๊ฐ์ํ๋ค. ๋ฐ๋ผ์ ํ๋์ ์ฐธ์กฐ๋ฅผ ์ ๊ฑฐํ๋ฉด free๋๋ object์ ๊ฐ์๊ฐ ๋ฌด์ง ์ปค์ง ์ ์๋ค.
์ด๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด reference count๊ฐ 0์ด ๋๋ฉด ๋ฐ๋ก ์ ๊ฑฐํ๊ธฐ๋ณด๋ค๋ ์ฐธ์กฐ๋์ง ์์ object๋ฆฌ์คํธ
์ ๋ฃ์ด ์ฃผ๊ธฐ์ ์ผ๋ก ์ด ๋ฆฌ์คํธ์์ ์ ๊ฑฐํ๋ ๋ฐฉ์์ ์ทจํจ.
Simple reference count๋ ์ฆ์ ์ ๋ฐ์ดํธ๊ฐ ํ์ํ๋ค.
์ฐธ์กฐ๊ด๊ณ๊ฐ ์์ ๋๊ฑฐ๋ ์ญ์ ๋๊ฑฐ๋, object์ reference count๊ฐ ๊ฐ์ํ๊ฑฐ๋, object๊ฐ ์์ฑ๋๊ฑฐ๋ ๋ณต์ฌ๋์ด reference count๊ฐ ์ฆ๊ฐํ๋ค ๋ฑ๋ฑ์ ๊ฒฝ์ฐ.
์ฐ์
Mark-compact
์ ๋น์ทํ๊ฒ Copying collection
์ garbage๋ฅผ Collect
ํ์ง๋ ์๋๋ค.live
object๋ค์ ํ๊ณณ์ ๋ชฐ์์ฃผ๊ณ , ๋๋จธ์ง ํ ์์ญ๋ค์ ์ค๋ก์ง garbage ๋ฐ์ ์๊ธฐ ๋๋ฌธ์ ์ฌ์ฉ๊ฐ๋ฅํ๋ค๋ ๊ฑธ ์ ์ ์๋ค. Like markcompact but unlike marksweep copying
garbage collection does not really collect garbage
Rather it moves all of the live objects into one area
and the rest of the heap is then known to be available
because it contains only garbage Garbage collec
tion in these systems is thus only implicit and some
researchers avoid applying that term to the process
Copying collectors like markingandcompacting
collectors move the objects that are reached by the
traversal to a contiguous area While markcompact
collectors use a separate marking phase that traverses
the live data copying collectors integrate the traversal
of the data and the copying process so that most ob
jects need only be traversed once Objects are moved
to the contiguous destination area as they are reached
by the traversal The work needed is proportional to
the amount of live data all of which must be copied
The term scavenging is applied to the copying
traversal because it consists of picking out the worth
while objects amid the garbage and taking them away.
node
๋ค.edge
๋ค.root node
๋ค์ด๋ค. node(==๋ธ๋ก)
๋ฅผ ํฅํ edge(pointer)๊ฐ ์๋ค๋ฉด reachable(์ ๊ทผ๊ฐ๋ฅ)
ํ๋ค.Non-reachable(์ ๊ทผ๋ถ๊ฐ๋ฅํ)
๋
ธ๋๋ค์ garbage๋ค. ์ ์
- Application
โ new(n): ๋ชจ๋ ์์ญ์ด clear๋ ์๋ก์ด ๋ธ๋ก์ ๊ฐ๋ฅดํค๋ ํฌ์ธํฐ return
โ read(b,i): registerํํ b์์ญ์ ์๋ i ์์น read
โ write(b,i,v): b ๋ธ๋ก์ i ์์น์ v write- ๊ฐ ๋ธ๋ก์ header word๋ฅผ ๊ฐ์ง
โ addressed as b[-1], for a block b
โ collector์ ๋ฐ๋ผ ๋ค๋ฅด๊ฒ ์ฌ์ฉ๋จ- GC๊ฐ ์ฌ์ฉํ๋ Instructions
โ is_ptr(p): p๊ฐ ํฌ์ธํฐ์ธ์ง ์๋์ ๊ฒฐ์
โ length(b): header ๋ถํฌํจ, b ๋ธ๋ก return
โ get_roots(): ๋ชจ๋ root returns
mark bit
๋ฅผ ์ฌ์ฉํ๊ธฐMark
(ํ์ํ๊ธฐ) : root
์์ ์์ํด์ ์ ๊ทผ๊ฐ๋ฅํ ๋ชจ๋ ๋ฉ๋ชจ๋ฆฌ์ bit set mark
ํด์ฃผ๊ธฐSweep
(๋น์๋ฃจ๋ก ์ธ์ด์ฃผ๊ธฐ): ๋ชจ๋ ๋ธ๋ก ์ค์บํ๊ธฐ
โก๏ธ ํ ๋น์ ๋์ง๋ง mark์ ํ์ง์์ ๋ธ๋ก๋ค freeํด์ฃผ๊ธฐIs_ptr()
: ํ ๋น๋ ๋ฉ๋ชจ๋ฆฌ ๋ธ๋ก์ ๊ฐ๋ฅดํค๋ ์ง์ ๋ฐ๋ผ word๊ฐ ํฌ์ธํฐ์ธ์ง ๊ฒฐ์ ๊ท ํํธ๋ฆฌ
๋ฅผ ํ์ฉํด์ ํ ๋น๋ ๋ชจ๋ ๋ธ๋ก track โก๏ธ key ์์น ํ์