๐ง ์์ฌ ๊ฒฐ์ ๋ช ๋ น์ด
์ปดํจํฐ๋ ๋จ์ํ ์ฐ์ ์ฐ์ฐ๋ง์ ์งํํ์ง ์์ต๋๋ค.
์ ๋ ฅ ๋ฐ์ดํฐ๋ ์ฐ์ฐ ๊ฒฐ๊ณผ์ ๋ฐ๋ผ ๋ค๋ฅธ ๋ช ๋ น์ด๋ฅผ ์คํํ ์ ์์ต๋๋ค.
ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์์๋ ๋ณดํต if ๋ฌธ์ฅ์ ํตํด์ ํ๋จ ๊ธฐ๋ฅ์ ํํํฉ๋๋ค.
RISC-V ์ด์ ๋ธ๋ฆฌ์ด์์๋ go to ๊ฐ ์๋ if ๋ฌธ๊ณผ ๋น์ทํ ํ๋จ ๋ช ๋ น์ด๋ฅผ ๊ฐ์ง๋๋ค.
๋๊ฐ์ ๋ช ๋ น์ด๋ฅผ ๋ณธ ํ ๋์ด๊ฐ๋๋ก ํ๊ฒ ์ต๋๋ค.
โญ๏ธ beq - ๊ฐ์ผ๋ฉด ๋ถ๊ธฐํ๋ค.
beq rs1, rs2, L1
์ ๋ช ๋ น์ด๋ rs1์ ๊ฐ์ด rs2์ ๊ฐ๊ณผ ๊ฐ์ ๊ฒฝ์ฐ L1์ผ๋ก ์ด๋ํ๋ผ๋ ๋ป์ ๋๋ค.
โญ๏ธ bne - ๊ฐ์ง ์์ผ๋ฉด ๋ถ๊ธฐํ๋ค.
bne rs1, rs2, L1
์ ๋ช ๋ น์ด๋ rs1์ ๊ฐ์ด rs2์ ๊ฐ๊ณผ ๊ฐ์ง ์์ ๊ฒฝ์ฐ L1์ผ๋ก ์ด๋ํ๋ผ๋ ๋ป์ ๋๋ค.
๐ง ์กฐ๊ฑด๋ถ ๋ถ๊ธฐ (Conditional branch)
์กฐ๊ฑด๋ถ ๋ถ๊ธฐ ๋ช ๋ น์ด์ Format์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
โญ๏ธ SB - format
imm[12] | imm[10:5] | rs2 | rs1 | funct3 | imm[4:1] | imm[11] | opcode |
1 bit | 6 bit | 5 bit | 5 bit | 3 bit | 4 bit | 1 bit | 7 bit |
SB - Format์ B๋ Branch๋ฅผ ์๋ฏธํฉ๋๋ค.
์ ํ์์ S-Format๊ณผ ๋น์ทํ์ง๋ง, ์ฐจ์ด์ ์ด ์์ต๋๋ค.
S-format๊ณผ ํจ๊ป ๋ด๋ณด๋๋ก ํ๊ฒ ์ต๋๋ค.
SB - | imm[12] | imm[10:5] | rs2 | rs1 | funct3 | imm[4:1] | imm[11] | opcode |
1 bit | 6 bit | 5 bit | 5 bit | 3 bit | 4 bit | 1 bit | 7 bit | |
S - | imm[11:5] |
rs2 | rs1 | funct3 | imm[4:0] | opcode | ||
7 bit | 5 bit | 5 bit | 3 bit | 5 bit | 7 bit |
โญ๏ธ SB - format์ด ๊ฐ์ง๋ ํํ์ ๋ํ์ฌ
์์ ๊ฐ์ ํํ๋ฅผ ๋๋ ์ด์ ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
์กฐ๊ฑด๋ถ ๋ถ๊ธฐ ๋ช ๋ น์ด์ ๊ฒฝ์ฐ immediate ํ๋์๋ PC(Program counter)์ ๋ํด์ง offset(๋ค์ instruction๊ณผ์ ์ฃผ์ ์ฐจ์ด)์ด ๋ค์ด๊ฐ๋๋ค.
instruction์ ํญ์ 32๋นํธ(4๋ฐ์ดํธ)๋ก ๊ณ ์ ๋์ด ์์ต๋๋ค.
RISC-V๋ Byte Address๋ฅผ ์ฌ์ฉํ๋ฏ๋ก, instruction ์ฌ์ด์ ๊ฐ๊ฒฉ์ ํญ์ 4(byte)์ ๋ฐฐ์์ ๋๋ค.
4์ ๋ฐฐ์๋ผ๋ ๊ฒ์, instruction์ ์ฃผ์๊ฐ ํญ์ 00์ผ๋ก ๋๋๋ค๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค. (4๊ฐ 100 ์ด๋ฏ๋ก)
์ฆ ๋ท์๋ฆฌ๊ฐ ํญ์ 00์ผ๋ก ๊ณ ์ ์ด๋ฏ๋ก 00์ ๊ตณ์ด ํ์ํ ํ์๊ฐ ์์ด์ง๋๋ค.
๋ฐ๋ผ์ 00์ ํํํ๊ธฐ ์ํ 2๋นํธ๋ฅผ ์๋ ์ ์์ด์ immediate๋ [13 : 2]์ ๋ฒ์๋ฅผ ๊ฐ์ง ์ ์์ต๋๋ค.
๊ทธ๋ฐ๋ฐ ์๋ฅผ ์ดํด๋ณด๋ฉด immediate์ ๋ฒ์๋ [13 : 2] ๊ฐ ์๋ [12 : 1] ์ธ ๊ฒ์ ์ ์ ์์ต๋๋ค.
(์ฌ๊ธฐ๋ถํฐ๋ ๊ธฐ์ต์ด ์ ์๋์.. ใ ใ ์ง์ก์ง์ก ๋ค์์ ์ ๋ฆฌํด์ ๋ค์ ํ ๊ฒ์, ์ผ๋จ ๊ทธ๋ฅ ๊ทธ๋ฐ๊ฐ๋ค ํ๊ณ ๋๊ธฐ์ธ์ ใ ใ )
์ด๋ RISC-V์ ๋ช ๋ น์ด๊ฐ ์ ์ ๋ ฌ๋์ด ์๊ธฐ์ 2๋ฐ์ดํธ๋ก ์์ถํ์ฌ ํํ์ด ๊ฐ๋ฅํด์ง๊ธฐ ๋๋ฌธ์ ๋๋ค.
๋ช ๋ น์ด๋ฅผ ์์ถํ์ฌ ๊ธธ์ด๋ฅผ ์ค์์ง๋ง, ๊ทธ๋งํผ ๊ฐ๊ฒฉ์ด ์ค์ด๋ค์ด ์๋ ์ ์๋ ๋นํธ๋ 00์์ 0์ผ๋ก ๋ฐ๋๋๋ค.
์ฆ 1๋นํธ๋ฅผ ์๋ ์ ์๊ธฐ์ immediate์ ๋ฒ์๋ [12 : 1]๊ฐ ๋๋ ๊ฒ์ ๋๋ค.
(๋ํผ์ ๋)
๊ทธ๋ผ ๋๋ฒ์งธ ์๋ฌธ์ผ๋ก๋ ์ [12 : 6] [5 : 1] ์ด ์๋๋ผ [12] [10 : 5] [4 : 1] [11] ์ด๋ ์ ๋๋ค.
๊ธฐ์กด S- format์์๋ [11 : 5] [4 : 0]์ ์ฌ์ฉํ์์ต๋๋ค.
์ด๋ฅผ [12 : 6] [5 : 1]๋ก ํํํ๋ฉด ๋ชจ๋ ์๋ฆฌ์์ ๋ํ์ฌ ์๋ฏธ๊ฐ ๋ฐ๋๋๋ค.
์๋ฏธ๋ฅผ ๋ฐ๊พธ์ง ์๊ณ ๊ธฐ์กด S-format๊ณผ ์ต๋ํ ์ ์ฌํ๊ฒ ๋ง์ถ๊ธฐ ์ํด [10 : 5] [4 : 1] ์ ์ฌ์ฉํ ๊ฒ์ ๋๋ค.
๊ทธ๋ผ [11 : 5] [4 : 1] [12] ๊ฐ ์ ์ผ ์ ์ฌํ๊ฑฐ ์๋๋? ํ์ค ์ ์๋๋ฐ, ์ ์ฌ๋๋ก๋ง ๋ฐ์ง๋ฉด ๋ง์ต๋๋ค๋ง, [12]๋ MSB๋ผ๋ ๊ฒ์ ์ง์คํ ํ์๊ฐ ์์ต๋๋ค.
์์์ธ์ง ์์์ธ์ง๋ฅผ ํ๋จํ๋ ๋ฑ์ ์ฌ๋ฌ ํ๋จ์์, MSB ํ๋๋ง ๋ณด๊ณ ๋ ํ๋จ ๊ฐ๋ฅํ ์กฐ๊ฑด๋ค์ด ๋ง์ต๋๋ค.
์ด๋ฌํ ๊ฒฝ์ฐ MSB๊ฐ ๋ค์ ์์นํ๋ ๊ฒ ๋ณด๋ค๋, ๋งจ ์์ ์์นํ์ฌ ๊ณง๋ฐ๋ก ํ์ธํ ์ ์๋๋ก ํ๋ ๊ฒ์ด ๋ ๊ฐํธํฉ๋๋ค.
๋ฐ๋ผ์ MSB๋ฅผ ๋งจ ์์ผ๋ก ์ค๊ฒ๋ ํ๋ฉฐ, S- format๊ณผ ์ต๋ํ ์ ์ฌํ๋๋ก ๋ช ๋ น์ด๋ฅผ ํํํ๊ธฐ ์ํด ์์ ํํ๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ ๋๋ค.
๐ง ์กฐ๊ฑด๋ถ ๋ถ๊ธฐ ๋ฒ์ญ
if (i == j) f = g + h;
else f = g - h;
์์ C ์ฝ๋๋ฅผ ์ด์ ๋ธ๋ฆฌ์ด๋ก ๋ฒ์ญํด ๋ณด๋๋ก ํ๊ฒ ์ต๋๋ค.
f๋ x19, g๋ x20, h๋ x21, i๋ x22, j๋ x23์ด ํ ๋น๋ฉ๋๋ค.
bne x22, x23, Eles // i(x22)๋ j(x23)๋ ๊ฐ์ง ์์ผ๋ฉด Else๋ก ์ด๋ํด๋ผ
add x19, x20, x21 // f(x19) = g(x20) + h(x21)
beq x0, x0, Exit // ๋ฌด์กฐ๊ฑด Exit (๋ฌด์กฐ๊ฑด ๋ถ๊ธฐ - unconditional branch)
Else: sub x19, x20, x21 // f(x19) = g(x20) - h(x21)
Exit: ...
์ค์ํ ์ ์ ์กฐ๊ฑด์ผ๋ก๋ i == j ์๋ ๊ฒ์ด ์ด์ ๋ธ๋ฆฌ์ด๋ก๋ ๊ฐ์ง ์์(bne)๋ก ๋ฒ์ญ๋์๋ค๋ ๊ฒ๊ณผ,
Else๋ฌธ ์์์ beq x0, x0 Exit์ ํตํด ํญ์ Exit์ผ๋ก ์ด๋ํ๋๋ก ๋ฒ์ญ๋ ์ ์ ๋๋ค.
add ๋ช ๋ น์ ํ ๋ค์๋ Else : sub ... ๊ฐ ์คํ๋๋ฉด ์๋๊ธฐ ๋๋ฌธ์ beq x0, x0, Exit๋ฅผ ์จ์ if ๋ฌธ์ฅ์ ๋๋ถ๋ถ์ผ๋ก ์ด๋ํ๊ฒ ํด์ฃผ์์ต๋๋ค.
์ด๋ ์ฌ์ฉ๋ ๋ช ๋ น์ ๋ฌด์กฐ๊ฑด ๋ถ๊ธฐ(unconditional branch)๋ผ๊ณ ํฉ๋๋ค.
RISC-V์์๋ ์์ ๊ฐ์ ๋ฌด์กฐ๊ฑด ๋ถ๊ธฐ๋ฅผ ํํํ๊ธฐ ์ํ ํ๊ฐ์ง ๋ฐฉ๋ฒ์ผ๋ก ์กฐ๊ฑด์ด ํญ์ ์ฐธ์ธ ์กฐ๊ฑด๋ถ ๋ถ๊ธฐ ๋ช ๋ น์ด๋ฅผ ์ฌ์ฉํฉ๋๋ค.
๐ง ์ํ๋ฌธ
ํ๋จ ๊ธฐ๋ฅ์ ๋ ์ค ํ๋๋ฅผ ์ ํ(if๋ฌธ์ฅ)ํ๋ ๋ฐ์๋ ์ค์ํ์ง๋ง,
๊ณ์ฐ์ ๋ฐ๋ณต์๋ ์ค์ํฉ๋๋ค.
๋ ๊ฒฝ์ฐ์ ๋ชจ๋ ๊ฐ์ ์ด์ ๋ธ๋ฆฌ ๋ช ๋ น์ด๊ฐ ์ฌ์ฉ๋ฉ๋๋ค.
์์๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
while (save[i] == k) i += 1;
i๋ x22, k๋ x24์ ํ ๋น๋์์ผ๋ฉฐ,
๋ฐฐ์ด save์ ์์ ์ฃผ์๋ x25์ ์ ์ฅ๋์ด ์๋ค๊ณ ํ ๋, ์ C ๋ฌธ์ฅ์ ํด๋นํ๋ RISC-V ์ด์ ๋ธ๋ฆฌ ์ฝ๋๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
Loop: slli x10, x22, 3 // ์์ ๋ ์ง์คํฐ x10์ i * 8์ ๊ฒฐ๊ณผ ์ ์ฅ (8๋ฐ์ดํธ)
add x10, x10, x25 // save(x25)์ ์์ ์ฃผ์์ x10์ด ๊ฐ์ง ๊ฐ(i * 8)๋ฅผ ๋ํ๋ค.
ld x9, 0(x10) // save[i] ๊ฐ์ ์์ ๋ ์ง์คํฐ x9์ ์ ์ฅ
bne x9, x24, Exit // save[i]์ k(x24)๊ฐ ๋ค๋ฅด๋ฉด Exit๋ก ์ด๋
addi x22, x22, 1 // i = i + 1;
beq x0, x0, Loop //Loop๋ก ๋ฌด์กฐ๊ฑด ๋ถ๊ธฐ
Exit: ...
์ด๋ฅผ ์ข ๋ ๋น ๋ฅด๊ฒ ์ต์ ํํ๋ฉด ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
slli x10, x22, 3 // ์์ ๋ ์ง์คํฐ x10์ i * 8์ ๊ฒฐ๊ณผ ์ ์ฅ (8๋ฐ์ดํธ)
add x10, x10, x25 // save(x25)์ ์์ ์ฃผ์์ x10์ด ๊ฐ์ง ๊ฐ(i * 8)๋ฅผ ๋ํ๋ค.
ld x9, 0(x10) // save[i] ๊ฐ์ ์์ ๋ ์ง์คํฐ x9์ ์ ์ฅ
bne x9, x24, Exit // save[i]์ k(x24)๊ฐ ๋ค๋ฅด๋ฉด Exit๋ก ์ด๋
Loop: addi x22, x22, 1 // i = i + 1;
slli x10, x22, 3 // ์์ ๋ ์ง์คํฐ x10์ i * 8์ ๊ฒฐ๊ณผ ์ ์ฅ (8๋ฐ์ดํธ)
add x10, x10, x25 // save(x25)์ ์์ ์ฃผ์์ x10์ด ๊ฐ์ง ๊ฐ(i * 8)๋ฅผ ๋ํ๋ค.
ld x9, 0(x10) // save[i] ๊ฐ์ ์์ ๋ ์ง์คํฐ x9์ ์ ์ฅ
beq x9, x24, Loop
Exit: ...
๐ง ๋ค๋ฅธ ์กฐ๊ฑด๋ถ ๋ช ๋ น์ด
๊ฐ์์ง ๋ค๋ฅธ์ง๋ฅผ ๋น๊ตํ๋ ๋ช ๋ น์ด(beq, bne) ์ด์ธ์๋, ๋ ๋ณ์ ๊ฐ์ ๋์ ๋น๊ต๊ฐ ํ์ํ ๊ฒฝ์ฐ๋ ์ข ์ข ์กด์ฌํฉ๋๋ค.
ํ์ํ ๋น๊ต๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
less than ( $<$ )
less than or equal ( $\leq$ )
greater than ( $>$ )
greater than orr equal ( $\geq$ )
equal ( $=$ )
not equal ( $\neq$ )
๋น๊ต ๋ช ๋ น์ ๋ถํธ์๋ ์์ ๋ถํธ์๋ ์๋ฅผ ๋ชจ๋ ๋ค๋ฃฐ ์ ์์ด์ผ ํฉ๋๋ค.
์ด๋ค ๋์๋ MSB๊ฐ 1์ธ ์๊ฐ ์์๋ฅผ ๋ํ๋ด๋๋ฐ, ์ด๋๋ ๋น์ฐํ MSB๊ฐ 0์ธ ์ด๋ค ์์๋ณด๋ค๋ ์์ต๋๋ค.
ํ์ง๋ง ๋ถํธ์๋ ์ ์์ ๊ฒฝ์ฐ์๋ MSB๊ฐ 1์ธ ์๊ฐ MSB๊ฐ 0์ธ ์ด๋ค ์๋ณด๋ค๋ ๋ ํฝ๋๋ค.
์ด๋ฌํ MSB์ ์ด์ค์ ์๋ฏธ๋ฅผ ์ด์ฉํ์ฌ, ๋ฐฐ์ด ๊ฒฝ๊ณ ๊ฒ์ฌ ๋น์ฉ์ ์ค์ด๋ ๋ฐฉ๋ฒ์ ๊ณง ์ดํด๋ณด๊ฒ ์ต๋๋ค.
RISC-V ์์ ์ ๊ณต๋๋ ๋ช ๋ น์ด๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
blt - branch if less than
bltu - branch if less than, unsigned
bge - branch if greter than or equal
begu - branch if greter than or equal, unsigned
๋๋จธ์ง ๋น๊ต๋ $<$ ๊ณผ $\geq$, $=$, $\neq$ ๋ฅผ ํตํด์ ํํํ ์ ์์ผ๋ฏ๋ก ๋ฐ๋ก ์ ๊ณตํ์ง ์์ต๋๋ค.
์๋ฅผ ๋ค์ด $a \; > \; b$ ๋ $a\; \leq \;b$ ๊ฐ ์๋ ๊ฒฝ์ฐ๋ก ํํ์ด ๊ฐ๋ฅํ๋ฐ, ์์๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
if ( a > b ) a += 1;
a๋ x22, b๋ x23์ด ํ ๋น๋์์ ๋, ๋ค์๊ณผ ๊ฐ์ด ๋ฒ์ญ๋ฉ๋๋ค.
bge x23, x22, Exit // b(x23) >= a(x22) ์ธ ๊ฒฝ์ฐ Exit
addi x22, x22, 1 // b >= a ๊ฐ ์๋ ๊ฒฝ์ฐ์ ์คํ๋๋ค.
๋ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ ๋ช ๋ น์ด ์คํ ๊ฒฐ๊ณผ๋ฅผ ์์ฝํ์ฌ ํ์ํ๋ ๋ณ๋์ ๋นํธ๋ค์ ๋๋ ๋ฐฉ๋ฒ์ผ๋ก, Intel x86-64์ ๊ฒฝ์ฐ ํด๋น ๋ฐฉ์์ ์ฌ์ฉํฉ๋๋ค.
์ด ๋ณ๋์ ๋นํธ๋ค์ ์กฐ๊ฑด ์ฝ๋(condition code) ๋๋ ํ๋๊ทธ(flag)๋ผ ๋ถ๋ฆฝ๋๋ค.
โญ๏ธ ๋น ๋ฅธ ๊ฒฝ๊ณ ๊ฒ์ฌ ๋ฐฉ๋ฒ
๋ถํธ์๋ ์ ์๋ฅผ ๋ถํธ์๋ ์ ์์ฒ๋ผ ๋ค๋ฃจ๋ฉด $0 \leq x < y$ ๊ฒ์ฌ ๋น์ฉ์ ๋ฎ์ถ ์ ์์ต๋๋ค.
์ด ๊ฒ์ฌ๋ ์ธ๋ฑ์ค๊ฐ ๋ฐฐ์ด์ ํ๊ณ๋ฅผ ๋ฒ์ด๋ฌ๋์ง ํ์ธํ๋ ๊ฒ์ฌ์ ์ ์ฉํฉ๋๋ค.
2์ ๋ณด์๋ก ํํ๋ ์์๊ฐ ๋ถํธ์๋ ์ ์์์์ ํฐ ์์ฒ๋ผ ๋ณด์ด๋ ๊ฒ์ด ํต์ฌ์ธ๋ฐ,
์ฆ 2์ ๋ณด์ ํํ์์๋ MSB๊ฐ ๋ถํธ ๋นํธ์ด์ง๋ง, ๋ถํธ์๋ ์ ์์์๋ ํฐ ๊ฐ์ ์๋ฏธํฉ๋๋ค.
๋ฐ๋ผ์ ๋ถํธ์๋ ๋น๊ต x < y๋ฅผ ํ๋ฉด, x๊ฐ y๋ณด๋ค ์์์ง ๋ฟ๋ง ์๋๋ผ, x๊ฐ ์์์ธ์ง๋ ๊ฒ์ฌํ ์ ์์ต๋๋ค.
์ถ๊ฐ์ ์ผ๋ก ์ค๋ช ํ๋ฉด ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
$0 \leq x < y$ ๋ฅผ ๋ณด๋ฉด, y๋ ํญ์ 0๋ณด๋ค ํฐ ์, ์ฆ ์์์์ ์ ์ ์์ต๋๋ค.
๋ฐ๋ผ์ y์ MSB๋ 0์ธ ๊ฒ์ด ์๋ช ํฉ๋๋ค.
์ด์ ๋ถํธ์๋ ๋น๊ต x < y๋ฅผ ํ๊ฒ ๋๋ค๋ฉด ๋ค์ ์ํฉ์ด ๋์ฌ ์ ์์ต๋๋ค.
1. x๊ฐ ์์์ธ ๊ฒฝ์ฐ
-> x์ MSB๊ฐ 1์ด๋ฏ๋ก, ๋ถํธ์๋ ๋น๊ต์์๋ x < y์ ๊ฒฐ๊ณผ๊ฐ false์ ๋๋ค.
2. x๊ฐ y์ ๊ฐ๊ฑฐ๋ ํฐ ์์์ธ ๊ฒฝ์ฐ
-> ๋ง์ฐฌ๊ฐ์ง๋ก x $\geq$ y์ด๋ฏ๋ก x < y์ ๊ฒฐ๊ณผ๊ฐ false ์ ๋๋ค.
3. x๊ฐ y๋ณด๋ค ์์ ๊ฒฝ์ฐ
-> x < y์ธ ๊ฒฝ์ฐ์ด๋ฏ๋ก ๊ฒฐ๊ณผ๊ฐ true์ ๋๋ค.
์ฆ x๊ฐ ์์์ด๊ฑฐ๋ x $\geq$ y ์ธ ๊ฒฝ์ฐ๋ฅผ ํ๋ฒ์ ๊ฒ์ฌ๋ก ์งํํ ์ ์์ต๋๋ค.