Previous chapter
์์คํ
์ ์ฑ๋ฅ์ ์ธก์ ํ๋ ๊ฒ์ ๊ฐ๋จํ ์ผ์ด ์๋๋ค.
ํ๋์ ์ํํธ์จ์ด๋ ๊ท๋ชจ๊ฐ ํฌ๊ณ ๋ณต์กํ๋ฉฐ, ํ๋์จ์ด๋ ์ฑ๋ฅ ๊ฐ์ ์ ์ํ ์ฌ๋ฌ๊ฐ์ง ๊ธฐ๋ฒ์ ์ฌ์ฉํ๊ณ ์์ด ์ฑ๋ฅํ๊ฐ๊ฐ ๋์ฑ ์ด๋ ต๋ค.
Performance
โข
๋ ๋ฐ์คํฌํฑ ์ปดํจํฐ์์ ๊ฐ์ ํ๋ก๊ทธ๋จ์ ์คํ์ํจ๋ค๋ฉด, ๋จผ์ ๋๋๋ ์ชฝ์ด ๋ ๋น ๋ฅธ ์ปดํจํฐ๋ผ๊ณ ํ ์ ์์ ๊ฒ์ด๋ค.
โฆ
๊ฐ์ธ์ ์
์ฅ์์๋ ์๋ต์๊ฐ(response time) : a.k.a. ์คํ์๊ฐ(execution time)์ด ๋ ์ค์ํ ๊ฒ์ด๋ค.
โข
๊ทธ๋ฌ๋ ์ฌ๋ฌ ๋์ ์๋ฒ๋ฅผ ๊ฐ์ง๊ณ ์ฌ๋ฌ ์ฌ์ฉ์์ ์์
์ ์ฒ๋ฆฌํ๋ค๋ฉด, ํ๋ฃจ๋์ ๋ ๋ง์ ์์
์ ์ฒ๋ฆฌํ๋ ์ปดํจํฐ๊ฐ ๋ ๋น ๋ฅธ ์ปดํจํฐ์ผ ๊ฒ์ด๋ค.
โฆ
์ฆ, ์๋ฒ ์
์ฅ์์๋ ์ฒ๋ฆฌ๋(throughput) ๋๋ ๋์ญํญ(bandwidth)์ด ๋ ์ค์ํ๋ค.
ThroughPut
์ด๋ ๋นํ๊ธฐ๊ฐ ๊ฐ์ฅ ์ข์๊ฐ? ๊ฐ ๋นํ๊ธฐ๋ง๋ค์ ์์น๊ฐ ๋ค๋ฅผ ๊ฒ์ด๋ค.
โข
๊ฐ์ฅ ๋น ๋ฅธ ๋นํ๊ธฐ๋?
โข
๊ฐ์ฅ ๋ง์ ์น๊ฐ์ ํ์ฐ๋ ๋นํ๊ธฐ๋?
โข
๊ฐ์ฅ ๊ธด ์ฌํ๋ ์ธ์ง๋?
ํ๋ช
์ด ๋น ๋ฅด๊ฒ ์ด๋ํ๊ธฐ ์ํด์๋ ์ฝฉ์ฝ๋๊ฐ ๋ ๋น ๋ฅด๊ณ ํจ์จ์ ์ผ ๊ฒ์ด๋ค.
๊ทธ๋ ๋ค๋ฉด ๋ง์ ์น๊ฐ์ ๋น ๋ฅด๊ฒ ์ฎ๊ธฐ๊ธฐ ์ํด์๋ ์ด๋ค๊ฒ ๋ ๋น ๋ฅด๊ณ ํจ์จ์ ์ธ๊ฐ?
์ด๋ค ์ผ์ ํ๋๋ฐ ๋จ์ํ ํ๋์ ์ผ๋ง ์ฒ๋ฆฌํ๋ ๊ฒฝ์ฐ๋ ์์ผ๋, ์ฌ๋ฌ ์ผ์ ์ฒ๋ฆฌํ๋ ๊ฒฝ์ฐ๋ ๋ง์ ๊ฒ์ด๋ค.
ThroughPut์ ๋จ์์๊ฐ๋์ ์ผ๋ง๋ ๋ง์ ์ผ์ ์ฒ๋ฆฌํ ์ ์๋๊ฐ๋ฅผ ๋ํ๋ด๋ ๊ฒ์ด๋ค.
๋นํ๊ธฐ๋ ์ปดํจํฐ ํ๋ซํผ์ ๋์๋๊ณ , ์น๊ฐ์ instruction์ ๋์๋ ์ ์์ ๊ฒ์ด๋ค.
ํ๋ก๊ทธ๋จ์ instruction์ผ๋ก ๊ตฌ์ฑ๋์ด์์ผ๋ฉฐ, ์ด๋ค ํ๋ก๊ทธ๋จ์ ๋ฌ๋์ํฌ๋ ์๋ง์ ๋ช
๋ น์ด๊ฐ ์คํ๋์ด์ผ ํ๊ณ , ๋ง์ ๋ช
๋ น์ด๋ฅผ ๋น ๋ฅด๊ฒ ์ฒ๋ฆฌํด์ผํ๋ค.
Relative Performance
์ฆ, ์๋์ ์ผ๋ก ์ฑ๋ฅ์ด ๋ฐ์ด๋๋ค๋ ์ด์ผ๊ธฐ๋ ์๋์ ์ผ๋ก ์คํ์๊ฐ์ด ์ ๋ค๋ ์ด์ผ๊ธฐ์ ๊ฐ๋ค.
ํผ๋์ ํผํ๊ธฐ ์ํด ์ปดํจํฐ ์ฑ๋ฅ์ ์ ๋์ ๋น๊ตํ ๋๋ โโฆ๋ณด๋ค ๋น ๋ฅด๋คโ๋ผ๋ ์ฉ์ด๋ง ์ฌ์ฉํ๊ธฐ๋ก ํ๋ค.
๋ํ ์ฑ๋ฅ์ด ์ฆ๊ฐํ๋ฉด ์คํ์๊ฐ์ด ๊ฐ์ํ๋ค. ๋์ ์ญ๊ด๊ณ์ด๋ฏ๋ก, โ์ฑ๋ฅ์ด ์ฆ๊ฐํ๋ค.โ ๋์ โ์ฑ๋ฅ์ด ๊ฐ์ ๋๋ค.โ์ ๊ฐ์ ํํ์ ์ฌ์ฉํ๋ ๊ฒ์ผ๋ก ํฉ์ํ๋ค.
์ฆ, ๋ ์ปดํจํฐ X์ Y์ ๋ํด X์ ์ฑ๋ฅ์ด Y์ ์ฑ๋ฅ๋ณด๋ค ์ข๋ค๋ฉด
๊ฐ ๋๋ค.
์ด๋ ์ฑ๋ฅ์ ์ ๋์ ์ผ๋ก ๋ํ๋ผ ๊ฒฝ์ฐ ๋ค์๊ณผ ๊ฐ์ด ๋ํ๋ผ ์ ์์ ๊ฒ์ด๋ค.
Measuring Execution Time
์๊ฐ์ ์ฑ๋ฅ์ ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ์ฒ๋์ด๋ค. ๊ฐ์ ์์
์ ๋นจ๋ฆฌ ๋๋ด๋ ์ปดํจํฐ๊ฐ ๊ฐ์ฅ ๋น ๋ฅธ ๋์ด๋ค.
์ฌ๊ธฐ์ ํ๋ก๊ทธ๋จ ์คํ์๊ฐ์ ํ๋ก๊ทธ๋จ์ ์ฒ๋ฆฌํ๋๋ฐ ๊ฑธ๋ฆฐ ์๊ฐ์ ์ด๋จ์๋ก ํ์ํ ๊ฒ์ด๋ค.
๊ทธ๋ฌ๋ ์ฐ๋ฆฌ๊ฐ ์ฌ๋ ๋ฐฉ๋ฒ์ ๋ฐ๋ผ ์๊ฐ์ ์ฌ๋ฌ๊ฐ๋ก ์ ์ํ ์ ์์ ๊ฒ์ด๋ค.
Elapsed time(a.k.a. Response Time (a.k.a. Wall Clock Time)) : ๊ณ์ฐ ์คํ์๊ฐ
ํ ์์
์ ๋๋ด๋๋ฐ ๋๋ ์ ์ฒด ์๊ฐ.
โข
ํ๋ก์ธ์ฑ, I/O, OS ์ค๋ฒํค๋, idle Time๊น์ง ๋ชจ๋ ํฌํจํ๋ค.
CPU Time
์ปดํจํฐ๋ฅผ ๊ณต์ ํ๋ ๊ฒฝ์ฐ, ํ๋ก์ธ์ ํ๋๊ฐ ์ฌ๋ฌ ํ๋ก๊ทธ๋จ์ ๋์์ ์คํํ๋ ๊ฒฝ์ฐ๊ฐ ์๋ค.
์ด๋ฐ ํ๊ฒฝ์์๋ ํ๋ก๊ทธ๋จ์ Elapsed Time์ ์ต์ํํ๋ ๊ฒ ๋ณด๋ค ์ฒ๋ฆฌ๋์ ์ต์ ํ ํ๋ ๊ฒ์ด ๋ ์ค์ํ ์ ์๋ค.
๋ฐ๋ผ์ Elapsed Time๊ณผ ๊ตฌ๋ถํด์ ์์ํ๊ฒ ํ๋ก์ธ์๊ฐ ํ๋ก๊ทธ๋จ์ ์คํํ๊ธฐ ์ํด ์๋นํ ์๊ฐ์ ๊ณ์ฐํ ํ์๊ฐ ์๋ค.
CPU Time์ ์ ์๋ ๋ค์๊ณผ ๊ฐ๋ค.
ํ๋ก์ธ์๊ฐ ์ฃผ์ด์ง Job์ ๋ํด์๋ง ์ฒ๋ฆฌํ๋ ์๊ฐ.
I/O time, ๋ค๋ฅธ job ํ ๋น์๊ฐ์ ์ ์ธํ ๊ฒฝ์ฐ
๋ฌผ๋ก ์ด๋ฅผ ์์ํ๊ฒ ์ถ์ถํด๋ด๋ ๊ฑด ๋ถ๊ฐ๋ฅํ๋ค. (Linux์ CPU Time๋ 100% ์ ํํ์ง๋ ์์)
CPU performance and factors
์ปดํจํฐ์ ์ฑ๋ฅ์ ํ์ํ ๋
์ฌ์ฉ์๊ฐ ์ฌ์ฉํ๋ ์ฒ๋์
์ค๊ณ์๊ฐ ์ฌ์ฉํ๋ ์ฒ๋๊ฐ
์๋ก ๋ค๋ฅธ ๊ฒฝ์ฐ๊ฐ ๋ง์ด ์๋ค.
์ด๋ ์ฒ๋๊ฐ์ ์๊ด๊ด๊ณ๋ฅผ ๊ตฌํ๋ค๋ฉด ์ค๊ณ์์ ๋ณํ๊ฐ ์ฌ์ฉ์๊ฐ ํ๊ฐํ๋ ์ฑ๋ฅ์ ์ผ๋ง๋ ์ํฅ์ ๋ฏธ์น๋์ง ์ ์ ์์ ๊ฒ์ด๋ค.
CPU Time = CPU Clock Cycles ร Clock Cycle Time = CPU CLock Cycles / Clock Rate
โข
ํด๋ฝ์ฌ์ดํด์ ์ค์ด๊ฑฐ๋, ํด๋ก ์ฌ์ดํดํ์์ ์ค์ด๊ฑฐ๋, ํด๋ฝ ๋ ์ดํธ๋ฅผ ๋์ด๋ฉด CPU Time ์ฆ๊ฐ!
๋ค๋ง, ์ด ์์ ์ค ํ๋๋ฅผ ์ค์ด๋ฉด ๋ค๋ฅธ ํ๋๊ฐ ์ฆ๊ฐํ๋ ๊ฒฝ์ฐ๊ฐ ์์ฃผ ๋ฐ์ํ๋ ์ฃผ์ํ์.
Instruction Performance
์์ ์ค๋ช
ํ ์์์ ํ๋ก๊ทธ๋จ ์ํ์ ํ์ํ ๋ช
๋ น์ด ๊ฐ์์ ๊ด๋ จ๋ ์ฌํญ์ด ํฌํจ๋์ด์์ง ์๋ค.
๊ทธ๋ฌ๋ ์ปดํ์ผ๋ฌ๊ฐ ์คํํ ๋ช
๋ น์ด๋ฅผ ์์ฑํ๊ณ ์ปดํจํฐ๋ ์ด ๋ช
๋ น์ด๋ฅผ ์คํํด์ผ ํ๋ ์
์ฅ์ด๋ฏ๋ก, ์คํ์๊ฐ์ ๋ช
๋ น์ด ์์ ๊ด๋ จ์ด ์๋ค.
๊ทธ๋ฌ๋ฏ๋ก ํ๋ก๊ทธ๋จ์ ์คํ์ ํ์ํ ํด๋ญ ์ฌ์ดํด ์๋ ๋ค์๊ณผ ๊ฐ๋ค.
CPU Clock Cycle = Instruction Count ร Cycles per Instruction
Cycles per Instruction(CPI)๋ ํ๋ก๊ทธ๋จ์ด ์คํํ ๋ชจ๋ ๋ช
๋ น์ด์ ๋ํด ํ๊ท ํ ๊ฐ์ ์ฌ์ฉํ๋ค.
Classical CPU Performance Equation
์ด๊ฑธ ์ ์ฉํด์ CPU Time์ ์ฌ์ ์ํ์.
CPU Time = Instruction Count ร CPI ร Clock Cycle Time = Instruction Count ร Cycles per Instruction / Clock Rate
Q : Instruction์ ์คํํ๋๋ฐ 1์ฌ์ดํด๋ง ํ์ํ์ง ์๋์?
A : ํ์ฌ์ ์ปดํจํฐ๋ ๊ทธ๋ ์ง ์์ต๋๋ค. ๋ช
๋ น์ด๋ง๋ค ๊ฑฐ์ณ๊ฐ๋ ํ๋์จ์ด์ ๊ฐ์๊ฐ ๋ค๋ฅด๋ค.
โข
๋ช
๋ น์ด๋ง๋ค ํ์ํ ๋งํผ์ ์ฌ์ดํด์ ํ ๋นํ์.
์ฆ, CPI๋ ๋ฐ๋์ 1์ ์๋๋ค. ์ฌ๋ฌ๊ฐ๊ฐ ๋ ์ ์๋ค.
๋ํ Compiler Optimization Level์ ๋ฐ๋ผ์๋ ์ฑ๋ฅ์ด ๋ฌ๋ผ์ง ์ ์๋ค!!!
CPI Example
CPU TimeA = Instruction Count * CPI(A) * Cycle Time(A) = I * 2.0 * 250ps = I * 500ps
CPU TimeB = Instruction Count * CPI(B) * Cycle Time(B) = I * 1.2 * 600ps = I * 600ps
Speed Up = CPU Time(B)/CPU Time(A) = 1.2
Clock Speed์ ์์ง๋ง๋ผ!
CPI in More Detale
CPI Example
์ผ๋ฐ ํต๋
: ์ฝ๋์ฌ์ด์ฆ๊ฐ ์์ผ๋ฉด ๋นจ๋ฆฌ ๋์๊ฐ ๊ฒ์ด๋ค
โข
Sequence 1 : IC = 5
โฆ
Clock Cycle = 2*1 + 1*2+ 2*3 = 10
โฆ
Avg. CPI = 10/5 = 2.0
โข
Sequence 2 : IC = 6
โฆ
Clock Cycle = 4*1 + 1*2 + 1*3 = 9
โฆ
Avg. CPI = 9/6 = 1.5
Performance Summary
โข
Performance Depends on
โฆ
์๊ณ ๋ฆฌ์ฆ : IC, CPI(์๋ง๋?)์ ์ํฅ
โฆ
ํ๋ก๊ทธ๋๋ฐ ์ธ์ด : IC, CPI์ ์ํฅ
โฆ
Compiler : IC, CPI
โฆ
Instruction Set architecture : IC, CPI, T(c)
Next chapter