1. ์ปดํจํฐ ์์คํ
์ ๋์ํ๋ ์ปดํจํฐ๋ ๊ณต์ ๋ ์ฃผ๊ธฐ์ต์ฅ์น์ ์ ๊ทผ์ ์ ๊ณตํ๋ ๊ณตํต ๋ฒ์ค์ ์ํด ์ฐ๊ฒฐ๋ CPU์ ์ฌ๋ฌ ๊ฐ์ device controller๋ก ๊ตฌ์ฑ๋๋ค.device controller: ๊ฐ ์ฅ์น๋ฅผ ๊ด๋ฆฌํ๋ค.device controller์ CPU๋ ๋ณํ์ผ๋ก ์ํ๋๋ฏ๋ก ์ด๋ค์ ์ฃผ๊ธฐ์ต์ฅ์น ์ ๊ทผ์ ๋ํด ๊ฒฝ์ํ๋ค. Local buffer: CPU์ ์์
๊ณต๊ฐ์ธ ๋ฉ์ธ๋ฉ๋ชจ๋ฆฌ๊ฐ ์กด์ฌํ๋ ๊ฒ ์ฒ๋ผ device controller๋ ์์
๊ณต๊ฐ์ด ํ์ํ๋ค.๋ฉ์ธ CPU์ ์์
๊ณต๊ฐ์ธ ๋ฉ์ธ ๋ฉ๋ชจ๋ฆฌ๊ฐ ์๋ฏ์ด ๋๋ฐ์ด์ค ์ปจํธ๋กค๋ฌ๋ ๋ฐ์ดํฐ๋ฅผ ์์๋ก ์ ์ฅํ๊ธฐ ์ํ ์์
๊ณต๊ฐ์ด ํ์ํ๋ฐ, ์ด๋ฅผ Local Buffer๊ฐ ๊ทธ ์ญํ ์ ํ๋ค.์ปดํจํฐ๊ฐ ์ฒ์ ๊ตฌ๋๋๋ฉด ์ด๊ธฐ์ ์คํ๋ ํ๋ก๊ทธ๋จ์ด ์์ด์ผํ๋ค. ์ด๋ฅผ ๋ถํธ์คํธ๋ฉ ํ๋ก๊ทธ๋จ์ด๋ผ ํ..
๐ปโ๏ธ์ ๊ณต๊ณต๋ถ
1. ์ด์์ฒด์ ๋? ์ปดํจํฐ ํ๋์จ์ด๋ฅผ ๊ด๋ฆฌํ๋ ํ๋ก๊ทธ๋จ์ด์ ์ปดํจํฐ์ ์ฌ์ฉ์์ ์ปดํจํฐ ํ๋์จ์ด ์ฌ์ด์ ์ค๊ฐ ๋งค๊ฐ์ฒด ์ญํ ์ ํด์ฃผ๋ ํ๋ก๊ทธ๋จ์ด๋ค.์ด์์ฒด์ ๋ ์ฌ์ฉ์์๊ฒ ์ธํฐํ์ด์ค๋ฅผ ์ ๊ณตํ๊ณ ์์ฉํ๋ก๊ทธ๋จ์ ์ปดํจํฐ ์์์ ๊ณจ๊ณ ๋ฃจ ๋ฐฐ๋ถํ์ฌ ์์
ํ๊ฒฝ์ ๋ง๋ค์ด ์ค๋ค. ์ ๋นํ ์์ ์ ์์ฉ ํ๋ก๊ทธ๋จ์ผ๋ก๋ถํฐ ์์์ ํ์ํ๊ณ ์
์์ ์ธ ์์ฉ ํ๋ก๊ทธ๋จ์ผ๋ก๋ถํฐ ์ปดํจํฐ๋ฅผ ๋ณดํธํ๋ค. ์ปดํจํฐ ์์คํ
์ ๊ตฌ์ฑ์์: ํ๋์จ์ด, ์ด์์ฒด์ , ์์ฉํ๋ก๊ทธ๋จ, ์ฌ์ฉ์์ปดํจํฐ ์์: ํค๋ณด๋, CPU, ๋ฉ๋ชจ๋ฆฌ ๋ฑ 2. ์ด์์ฒด์ ์ ๋ชฉํ์ฌ์ฉ์์๊ฒ ํธ๋ฆฌ์ฑ์ ์ ๊ณตํ๊ณ , ์ปดํจํฐ ์์คํ
์ ํจ์จ์ ์ผ๋ก ์ด์ํ๊ฒ ํ๋ค.์ปดํจํฐ ์์์ ํ ๋น์ ๊ณต์ ํ๊ณ ํจ์จ์ ์ผ๋ก ์ด๋ฃจ์ด์ ธ์ผ ํ๋ค. 3. ์ด์์ฒด์ ์ ๋ฐ์ ์์
๋ฐฉ์ ๋ฐ์ ํ๋์์ด์ด๋ง ์์คํ
→ ์ผ๊ด ์์
์์คํ
: batch(ํ ๋ฒ์ ..
Fake Simple ์ปดํจํฐ ๋ช
๋ น์ด ์งํฉ - ์ดํด๋ฅผ ์ํ ๋จ์ํ ๊ฐ์ ,์์์ด๋ค. ๋ช
๋ น์ด ํ์ (๊ฐ์ ) 16bits๋ก ๊ตฌ์ฑ ์ฐ์ฐ๋ถํธ๊ฐ 4bits ํน์ 16bits 1) 15๋ฒ bits๊ฐ 0์ด๋ฉด 12~15๋ฒ bit๊ฐ ์ฐ์ฐ๋ถํธ์ด๊ณ , 2) 15๋ฒ bits๊ฐ 1์ด๋ฉด 0~15๋ฒ bit๊ฐ ์ฐ์ฐ๋ถํธ์ด๋ค. ๋ช
๋ น์ด LDA~CAL์ ์ฐ์ฐ๋ถํธ๊ฐ 1~6์ธ๋ฐ ๊ฐ์๊ธฐ HLT๋ถํฐ๋ 8000์ด ๋๋ค. ์ด์ ๋ 15๋ฒ ๋นํธ์ ์๋ค. ์์์ 15๋ฒ ๋นํธ๊ฐ 0์ด๋ฉด 12~15๋ฒ ๋นํธ๊ฐ ์ฐ์ฐ๋ถํธ์ด๊ณ , 15๋ฒ ๋นํธ๊ฐ 1์ด๋ฉด 0~15๋ฒ ๋นํธ๊ฐ ์ฐ์ฐ๋ถํธ๋ผ๊ณ ํ์๋ค. 1(16)์์ 1์ 0001(2) ์ฆ 15๋ฒ ๋นํธ๊ฐ 0์ด๊ณ , 8000(16)์์ 8์ 1000(2) ์ฆ, 15๋ฒ ๋นํธ๊ฐ 1์ด๋ค. 1(16) = 0000/0000/0000/0001(2) 8..
์ต์์ ํ๋กํผํฐ ํด๋์ค์ ์์๋์ง ์์ ํ๋กํผํฐ๋ ์ ์ญ ๋ณ์/์์์ ์ญํ public/internal/private ๋ฑ์ ๊ฐ์์ฑ ์ง์ ์ด ๊ฐ๋ฅ private val prefix = "Hello, " fun main() { val name = readLine() ?: return println("$prefix$name") } ๋ฆ์ ์ด๊ธฐํ ์์ฑ์์์ ์ด๊ธฐํ ๋์ง๋ ์์ง๋ง, ํ๋ก๊ทธ๋จ ํ๋ฆ ์ ์ค์ฌ์ฉ ์๋ ์ด๊ธฐํ ๋๋ ๊ฒ์ด ๋ช
๋ฐฑํ ๋ณ์์๋ lateinit์ด๋ผ๋ ์์ฝ์ด๋ก ํ๊ธฐํ์ฌ null ๊ฐ์ด ๋ถ๊ฐํจ์ ํ๊ธฐํ ์ ์๋ค. ์ค์ ์ด๊ธฐํ๊ฐ ์๋ ๊ฒฝ์ฐ UninitializedPropertyAccessException์ด ๋ฐ์ํ๋ฏ๋ก !!๋ฅผ ์ฌ์ฉํ ๊ฒ๊ณผ ๋น์ทํ ํน์ฑ์ ๊ฐ์ง๋ค. (๊ฐ๋ฅํ๋ฉด by lazy ์ฌ์ฉ์ ๊ถ์ฅ) class ..
1. ๋ช
๋ น์ด ์งํฉ ๊ตฌ์กฐ(ISA) ๋ช
๋ น์ด ์งํฉ๊ตฌ์กฐ = ์ปดํจํฐ๊ตฌ์กฐ ์ด๋ค ํ๋ก๊ทธ๋จ๊ณผ ๊ทธ ํ๋ก๊ทธ๋จ์ ์ํํ ์ปดํจํฐ ํ๋์จ์ด ์ฌ์ด์ ์ธํฐํ์ด์ค์ ๋ํ ์ ์ ๋ช
๋ น์ด๋ ์ปดํจํฐ ํ๋์จ์ด์์ ์ธ์&์คํ๋๋ ๊ธฐ๊ณ์ด Machine Code, Assembly Code ๋ช
๋ น์ด ์งํฉ ๊ตฌ์กฐ๋ "ํน์ CPU๋ฅผ ์ํด ์ ์๋ ๋ช
๋ น์ด๋ค์ ๋ชจ์" S/W์ H/W์ฌ์ด์ ISA Cํ๋ก๊ทธ๋จ์ ๋ณํ๊ณผ์ C program -> Asm program -> Object program ->Executable program text text binary binary ADT data value์ ์งํฉ์ด ์ธก์ Object๋ฅผ ๊ฐ๋ฆฌํค๋ state๊ฐ ๋๋ค. 2. ๋ช
๋ น์ด ํน์ฑ ๋ช
๋ น์ด์ ํน์ฑ: ํํ๋ฅผ ๊ฒฐ์ ํ๋ ์์ธ CPU๋ ์ฃผ๋ฉ๋ชจ๋ฆฌ์์ ๋ช
๋ น์ด๋ฅผ ๋ฐ์์์ ๊ทธ ๋ช
๋ น์ ์ค..
์ปดํจํฐ์ ์ฑ๋ฅ = ์๋ต์๊ฐ์ผ๋ก ์ ์ํ๋ค. ๊ทธ๋ฌ๋, ์๋ต์๊ฐ๊ณผ ์ฒ๋ฆฌ์จ์ ์ํธ์ฐ๊ด๊ด๊ณ์!! ์๋ต์๊ฐ์ด๋? ํ๋์ ํ๋ก๊ทธ๋จ์ ์ฒ๋ฆฌํ๋๋ฐ ์์๋๋ ์๊ฐ ์
๋ ฅ์ด ์ฃผ์ด์ง๊ณ ์์คํ
์ด ๋ฐ์ํ๊ธฐ๊น์ง ๊ฑธ๋ฆฐ ์๊ฐ ์ ํํ!!! ์ปดํจํฐ ์ฑ๋ฅ = CPU ์คํ์๊ฐ ์ผ๋ก ์ ์ CPU์คํ์๊ฐ: CPU๊ฐ ํ๋์ ํ๋ก๊ทธ๋จ์ ์ํํ๋๋ฐ ์์ํ๊ฒ ์ฌ์ฉ๋ ์๊ฐ(์
์ถ๋ ฅ๊ฐ์ ๋ค๋ฅธ ํ๋ก๊ทธ๋จ ์คํ ์๊ฐ์ ํฌํจํ์ง ์๋๋ค.) ์ปดํจํฐ์ ์ฑ๋ฅ์ด ์ข๋ค = CPU ์คํ์๊ฐ์ด ์งง๋ค ์ฑ๋ฅ =1 / CPU ์คํ ์๊ฐ ๋ ์ปดํจํฐ X, Y๋ก ๋น๊ตํด๋ณด์ ์ฑ๋ฅ ๋น๊ต ์ ๋ํ M2๋ M1๋ณด๋ค ์ฑ๋ฅ์ด n๋ฐฐ ํฅ์. M1์ด ๊ธฐ์ค์ด๋ฏ๋ก ๋ถ๋ชจ! ์๋ฌ์ ๋ฒ์น 1) ์์คํ
์ ์ผ๋ถ๋ถ์ ๊ฐ์ ํ๋ ๊ฒฝ์ฐ, ์ ์ฒด ์์คํ
์์ ์ป์ ์ ์๋ ์ต๋ ์ฑ๋ฅ ํฅ์์ ๊ตฌํ ๋ ์ฌ์ฉ 2) ์์คํ
์ฑ๋ฅ ํฅ์์ ..
์ง๋ฌธ ๊ฐ์ฒด์ ๊ตฌ์กฐ์ฒด์ ์ฐจ์ด์ ์? ํด๋์ค๋ ์์์ง์&์ฐธ์กฐ ํ์, ๊ตฌ์กฐ์ฒด๋ ๊ฐ ํ์, ์์ ๋ฐ ๋ฉ์๋ ์ง์ ํ์ง ์์. ํจ์๊ฐ ์๋ฃ๊ตฌ์กฐ ์์ผ๋ก ๋ค์ด์ค๋ฉด ์ด๋ค ์ฅ์ ์ด ์๊ธฐ๋๊ฐ? ์ ์ ๋ณด ์๋์ ๊ฐ์ฒด ๊ธฐ๋ฐ์์๋ง ๊ฐ๋ฅํ๊ฐ? ๋ฐ์์ ์ฌ์ฉ ํ ์ ์๊ฒ ์ ์ธ var time:Double private Set 4ํด๋์ค๋? ๋ณ์์ ๋ฉ์๋๋ฅผ ๊ฐ์ง๋ ํ์
์ ์ ์ํ๋ ๋จ์ ํด๋์ค ์ ์ธ class Person{ //ํ๋กํผํฐ var firstName: String = "" var familyName: String = "" var age: Int = 0 //๋ฉ์๋ fun fullName() = "$firstName $familyName" fun showMe() { println("${fullName()}: $age") } } ๊ฐ์ฒด์..
์ ํจ์ ๋ด ํจ์ ์ฌ์ฉ ์ด์ ํ๋ผ๋ฏธํฐ? ์ ํจํค์ง ์ด์ ๋ชจ๋๋ณ๋ก ๊ตฌ๋ถ, ํ์
์ ์ฉ์ด ์ ์๋ฐ์๋ ์๋ ์ฝํ๋ฆฐ์ ๊ธฐ๋ฅ(๋ฒ์: '..' 'unitl' ',') (์์: 'in') Kotlin ํจ์์ ์ import kotlin.math.PI // kotlin.math ํจํค์ง์์ PI ์์๋ฅผ ๊ฐ์ ธ์ด fun circleArea(radius: Double): Double { //ํจ์์ ์ ์ return PI*radius*radius } fun main() { print("Enter radius: ") val radius = readLine()!!.toDouble() println("Circle area: ${circleArea(radius)}") } fun circleArea(radius: Double): Dou..