중간고사

1

컴퓨터는 본질적으로 모두 같은 기능을 한다. 차이점은 용도와 특성화에서 온다.

퍼포먼스에 영향을 주는 요인 : 알고리즘, 언어/컴파일러/아키텍쳐, 프로세서/메모리, OS를 비롯한 IO

공학에서 가장 중요한 가치는 공통적인 문제를 빠르게 만드는 것. 중요한 건 아닌거 같긴 한데 아무튼

우리가 사용하는 ApplicationSoftware는 Hardware에게 일을 시킨다. 그 일을 시킬 때 여러가지 문제가 발생하지 않도록 중간에서 매개 해주는 역할을 하는 것이 SystemSoftware이다. ← shell

AssemblyLanguage 와 machine Instruction은 1대1 대응관계이다. 표현이 다를 뿐.

컴퓨터의 모든 정보는 2진수로 표현된다.

ISA = Instruction Set Architecture (ABI : Application Binary Interface, Microarchitecture)

퍼포먼스의 비교는 단순 덧셈으로 계산할 수 없다. 상호 연관이 있기 때문. 모두 곱하거나 가중치를 통해 계산해줘야함.

응답시간 : 처리하는데 몇초 걸림?

처리율 : 단위 시간당 몇번 처리함?

1초에 10번 처리했다 → 응답시간 0.1초, 처리율 10회 프로세서를 빠른것으로 교체한다 → 처리율은 오르고 응답시간은 줄어든다 프로세서의 개수를 늘린다 → 처리율은 오른다(적은시간에 동일한양 처리, 나눠서하니까), CPU의 응답속도는 그대로다. 같은 CPU를 그냥 대수를 늘린거니까.

성능은 시간의 역이다. 시간이 적게걸려야 성능이 좋은 것!

경과시간 : cputime을 포함해 모든 걸린시간을 다 더한것 IO랑 OS의 오버헤드, idle time까지 전부

CPU time : 순수하게 CPU안에서만 걸린 시간을 계산 한 것. (User + System)CPU time

클락 : 논리회로때 배운 그 클락 맞다. 클락이랑 진동수는 역수다.

pico = 10^-12 → tera = 10^12 nano = 10^-9 → giga = 10^9

CPU Time = 몇번의 사이클? (CC) * 사이클당 얼마의시간?(CCT) ← 너무나 자명하다

단 여기서 CC랑 CCT는 독립변수가 아님. CC가 줄면 CCT가 오르고 CCT가 줄면 CC가 오르고 그런다. 따라서 그 둘의 적절한 타협점을 찾는것이 CPU설계에서 중요함

CC(몇번의 싸이클?) = sum(인스트럭션 몇개? (IC) * 인스트럭션당 사이클 몇개? (CPI))

인스트럭션이 실행될 때 사이클이 필요하니까 모든 인스트럭션에 대해 그 인스트럭션 몇개가 필요하고 그 인스트럭션이 사이클 몇개를 소모한느지 계산해서 다 더해버리면 그게 총 필요한 사이클의 개수 즉 CC가 될것.

평균 CPI = 전체 필요한 사이클 수를 모든 인스트럭션의 개수로 나누면 되겠지? 위에서 구한 CC를 IC로나눈다.

CPI 1, 2, 3 IC1 2, 1, 2 IC2 4, 1, 1 1→ CC = 12 + 21 + 32 = 10, avgCPI = 10 / (2 + 1 + 2) = 2 2→ CC = 14 + 21 + 31 = 9, avgCPI = 9 / (4 + 1 + 1) = 1.5

같은 ISA를 가진것을 생각 A : CCT = 250ps, CPI = 2.0 B : CCT = 500ps, CPI = 1.2 A CPUT = IC * CPI * CCT = IC * 2.0 * 250ps = 500ICps B CPUT = IC * CPI * CCT = IC * 1.2 * 500ps = 600ICps 시간은 성능의 반비례한다. B의 성능이 1.2배 좋다.

2GHz의 clock을 가진 A는 10초가 걸렸고 조금 더 빠른 clock을 가진 B에서는 같은 프로그램이 6초가 걸렸다. B가 clock이 빨라진 대신 clock cycle의 개수가 1.2배가 되었다면 B의 clock 은 얼마일까? CPUTA = CC * CCTA = CC / 2GHz = 10sec → CC = 20GHzsec CPUTB = 1.2CC * CCTB = 1.2CC / CCTB = 6sec → 20GHzsec * 1.2 / CCTB = 6sec =20GHz / CCTB = 5 →20GHz = 5CCTB →CCTB = 4GHz

멀티프로세서 : 싱글 프로세서의 속도 개선의 한계를 돌파하기위해 여러 싱글 프로세서를 하나로 묶어서 이용한다. 그치만 하나의 프로그램에서 여러개의 코어를 동시에 사용하도록 하는건 생각보다 쉽지 않다.

기하 평균 : 산술평균이 덧셈 값들의 평균이듯, 기하 평균은 곱셈값들의 평균을 나타낸다. 모든 곱셈값들을 곱하고 개수만큼으로 제곱근을 해서 구한다. 성능 비교에서 사용됨 성능은 단순히 더해서 얻을수 있는게 아니다.

2

인스트럭션 : 로우레벨. 흐름구문이 없음. 다른 컴퓨터는 다른 ISA를 갖는다.

CISC VS RISC : Complex vs Reduced인데 말그대로 complex가 ISA가 방대하다. 근데 그만큼 다 사용하는건 아님. 따라서 무조건 크다고 좋은건 아님. 최적화에도 문제가있고..

RISC-V : 32개의 레지스터 x0~31을 사용한다. (각 레지스터의 길이는 64비트임) 64비트 체계이므로 메모리는 2^64를 사용할 수 있는데, word의 길이는 32bit, 즉 2^3바이트이다. 따라서 2^61 word를 사용할 수 있다. 더블워드는 word * 2 즉 2^4, 64비트이다.

디자인 원칙 : 간단하고 규칙적이어야 한다. add dst, src, src 처럼 dst랑 src의 위치가 일정한방식으로 디자인되어있다.

레지스터 컨벤션 :

x0 = constant 0 x1 = return address x2 = stack pointer x5~7 = temp x8~9 = saved x10~17 = args, returns x18~27 = saved x28~31 = temp

디자인 원칙 : 작을수록 빠르다. → 레지스터 클 필요도 없다 무조건 작은거 32개 레지스터

레지스터가 커지면 통과할 게이트가 많아지고 결국엔 시간이 많이필요하게되는거

byte address : 메모리를 바이트 어드레스로 나타낸다. 한 블럭이 한 바이트를 나타냄. word는 4바이트이다 ⇒ 32비트. 메모리 체계에서 2^62개 word가 표현될 수 있음.

엔디안 : big endian 하위주소 → 상위주소로 MSB부터 LSB까지, small endian 하위주소 → 상위주소로 LSB부터 MSB까지

줄맞춤 : align, RISC-V에서는 align을 지원하지 않는다. 메모리를 공간의 배수에 맞춰서저장하도록 하는것인데 공간의 낭비가 발생한다. 대신 짝수 주소를 사용하기는 한다..

offset

    A[12] = h + A[8];             //adrs of A = x22, h = x21
    -----------------------------------------------------------------
    ld x9, 64(x22)                //x22즉 A의 주소로부터 64, 즉 8칸 떨어진곳의 요소를 x9에 저장
    add x9, x21, x9               //x9에는 A[8]값이 저장되어있다. 이거랑 h를 더해서 x9에 저장
    sd x9, 96(x22)                //x9에는 계산값이 저장되어있다. A로부터 96, 12칸 떨어진곳에 x9을 저장

레지스터 vs 메모리 : 레지스터는 빠르다. CPU에 박혀있으니까 당연히 더 빠르다. 반면 메모리는 사용하려면 ld해야하고 sd해야하니 instruction이 더 많이 들어가고 결국엔 속도가 느려진다. C언어같은 하이레벨 랭기지에서 register를 굳이 붙여주지 않아도 컴파일러가 알아서 레지스터를 쓴다. 그리고 레지스터는 연속적인 주소체계를 가진것이 아니기때문에 배열처럼 사용한다거나 그런건 불가능함.

immediate : 상수값을 다루는경우 변수를 선언할 필요 없이 바로 가져다 쓸 수 있도록 해줌. 그러나 instruction의 길이가 word단위이기때문에, word단위 내에서 알맞은 상수만 사용할 수 있기 때문에 길이에 제한이 생긴다.

부호 확장 : 2진수 체계에서 음수는 MSB가 1이냐 0이냐로 결정이 난다. shift instruction을 이용해 우리는 2진수를 왼쪽 오른쪽으로 밀 수 있는데, 이런 일을 할 때 MSB를 어떻게 다뤄주느냐에 따라서 부호 자체가 바껴버린다. 일반적으론 logical shift를 해서 빈자리를 0으로 채우고 우측 shift시에만 arithmetic shift를 고려해주면 된다. MSB를 살리면서 움직이는거. 다시말해서 MSB 0 이었으면 0으로, 1이었으면 1로 채우는것. 각종 instruction에서 자릿수에 안맞는 immediate이들어오면 extension해서 자리를 맞춰줘야겠지. 그럴때 사용된다.

instruction format : 연산자에 따라서 instruction의 포맷을 나눌 수 있다. 모두 바이너리 코드로 구현되어있지만, 일종의 포맷을 정해서 그 binary를 어떻게 해석할 것인가 여지를 주는것. 배치가 굉장히 중요하다는 사실. RISC-V는 간단함을 최고로 여기기 때문에 instruction의 길이는 무조건 32비트로 고정되어있다. 포맷은 가능한 간단하고 동일하게 유지하려고 하자

stored program : instruction도 데이터와 다름없이 2진수로 메모리에 표현됨

Logical instruction :

« slli : shift left logical immediate

srli : shift right logical immediate ~ xor : xor 자기자신을 통해서 구해진다.

a = 1, b = 2일 때 a&b = 1 (둘 다 true) a&&b = 0 (같지 않다) logical 과 arithmetic의 차이

and or xor은 r포맷 andi ori xori는 i포맷

프로시져 : 함수랑 같다고 보면된다 코드의 재활용성을 늘려 코드의 양을 줄이고 flow를 꼬아준다. 수행시간은 늘어나지만 사용하는 공간을 줄일 수 있고, 이미 구현되어있는걸 가져다 쓰기만 할 수 있기 때문에 여러모로 장점이 많다. 근데 프로시저는 제어의 흐름이 옮겨가는거니까 흐름인 PC와 데이터가들어있는 x10~17레지스터 등 신경써줘야하는 부분이 많다.

1. 파라미터들을 x10~x17에 배치해준다.
2. 컨트롤을 프로시져로 옮긴다. 이말은 즉 프로그램 카운터에 프로시저의 주소가 오도록 해야한다는 것. jal x1 procedure 로 할 수 있다.
3. 프로시저에서 공간을 사용할 수도 있다. 따라서 백업이 필요한 데이터들은 stack 에 push 해줘야한다. x8~x9, x18~27까지 save되어야하는 레지스터들, 혹은 현시점에서 돌아가야하는 리턴주소 등.
4. 프로시저가 영향을 끼칠 수 있는 공간을 정리해서 영향 받지 않도록 하였고, 파라미터들은 x10~17레지스터를 통해 접근이 가능하니, 이제 프로시저에서 의도한 행위가 이뤄지면 된다.
5. 행위의 결과를 caller가 접근할 수 있는 x10~17에 저장해준다
6. 무조건적으로 돌아간다.

jalr : 보통 sd에 x0를 넣어서 무조건 이동으로 쓰지만 사실은 다른걸 넣어서 switch문으로도 쓸 수 있다.

끝단 프로시져

    long long leaf_example(long long g, h, i, j){
    	long long f;
    	f = (g + h) - (i + j);
    	return f;
    }

    laef_example :
    	addi sp, sp, -8  <- sp 공간확보
    	sd x20, 0(sp)    <- 확보된 sp에 x20을 저장. x18~27은 saved되어야한다
    	add x5, x10, x11 <- g + h를 x5에 저장.
    	add x6, x12, x13 <- i + j를 x6에 저장.
    	sub x20, x5, x6  <- 두 결과를 뺀걸 x20에 저장. 그냥 한번 해보는듯?
    	addi x10, x20, 0 <- caller가 접근 가능한 x10~17에 return value저장
    	ld x20, 0(sp)    <- stack에 백업했던 x20값 복원
    	addi sp, sp, 8   <- garbage collect. 스택 공간 release
    	jalr x0, 0(x1)   <- 다음 instruction으로 무조건 분기

    leaf_example : 
    	addi sp, sp, -8
    	sd x1, 0(sp)
    	add x5, x10, x11
    	add x6, x12, x13
    	sub x10, x5, x6
    	ld x1, 0(sp)
    	addi sp, sp, 8
    	jalr x0, 0(x1)

스택메모리 : 스택은 높은곳에서 낮은곳으로 찬다. 새로운 요소를 넣고싶으면 sp를 빼라

끝단이 아닌 프로시져

    long long fact(long long n){
    	if(n < 1) return 1;
    	else return n * fact(n - 1);
    }

    fact : 
    	addi sp, sp, -16  <- 프로시져가 반복되면 리턴주소나 인자값은 저장되어야
    	sd x1, 8(sp)      <- 스택 16자리 늘려서 8자리 8자리 리턴주소랑 인자가 먹는다.
    	sd x10, 0(sp)
    	addi x5, x10, -1  <- x10 - 1 0보다 크거나 같으면 else로 아니면 그대로
    	bge x5, x0, else
    	addi x10, x0, 1   <- 1을 리턴해준다.
    	addi sp, sp, 16   <- 끝났으니 잡아먹었던 스택은 걍 날려도됨.
    	jalr x0, 0(x1)    <- 끝나면 가야되는곳으로 돌아간다.
    else :
    	addi x10, x10, -1 <- 기존 x10은 sp에 저장되어있으니 ㄱㅊ
    	jal x1, fact      <- x10 - 1로 fact 를 다시 실행 실행시 sp에 값을 저장하니 ㄱㅊ
    	addi x6, x10, 0   <- 기존 x10을 복귀시켜야하니 x6으로 옮겨준다.
    	ld x10, 0(sp)
    	ld x1, 8(sp)
    	addi sp, sp, 16   <- 이번 라이프사이클은 끝남. sp에 필요없는 16비트 제거
    	mul x10, x10, x6  <- 결과를 caller가 접근할 수 있는 x10~17에 배치하고
    	jalr x0, 0(x1)    <- 끝나면 돌아가야하는 곳으로 돌아간다. 

    fact : 
    4	  addi sp, sp, -16
    8	  sd x1, 8(sp)
    12	sd x10, 0(sp)
    16	addi x5, x10, -1
    20	bge x5, x0, Else     //offset 12
    24	addi sp, sp, 16
    28	jalr x0, 0(x1)
    Else :
    32	addi x10, x10, -1
    36	jal x1, fact         //offset -32
    40	addi x6, x10, 0
    44	ld x10, 0(sp)
    48	ld x1, 8(sp)
    52	addi sp, sp, 16
    56	mul x10, x10, x6
    60	jalr x0, 0(x1)

스택에 쌓이는건 인자, 리턴주소, 저장된 레지스터주소, 배열구조 등등 존나다양함

전역변수는 static data영역에, 지역변수는 stack영역에, 동적할당된것은 dynamic data영역에 저장된다. 지역변수랑 동적할당은 런타임중에 동적으로 할당이될 수 있어서 크기가 정해져있지 않다. stack은 위에서 dynamic은 아래에서 올라오며 서로 필요한 공간을 나눠먹는다.

wide immediate : 대부분의 immediate 상수는 클 필요가 없지만 가끔 존나큰게 필요하다. I format에서 지원하는 최대 immediate 크기는 12비트니까 커봐야 -2^11~2^11 -1 임. 가끔씩 32비트 상수를 써야하는 일이 발생할 수 있는데 그럴때를 위해서 상위 20비트 (load upper immeidate)를 사용할 수 있도록해준다.

0x003d0500 ⇒ 상위 20 = 0x003d0(000) 하위 12 = 0x500 lui x19, 0x003d0 ← 이렇게 하면 알아서 하위 12비트는 0으로, 상위 비트는 MSB맞춰서 확장해서 더해줌 addi x19, 0x500 ← lui에서 다 처리하지 못한 하위 12비트도 처리

대부분의 가지치기는 12비트 안쪽에서 끝낼 수 있는 가까운 가지치기이다.

immediate * 2만큼의 주소를 더해서 보낸다. ← RISC-V가 짝수 주소체계를 지원하기 때문?

조건부 가지치기 : 옵코드와 레지스터 두개, 12비트의 이미디엇을 사용. 0번째 비트는 생략 가능. 짝수 주소를 사용하기 때문. 따라서 표현에 동원되는 비트는 13자리 → -2^12-1 ~ 2^12 -2 로 -4096 ~ 4094바이트의 범위(메모리가 기본적으로 바이트 어드레싱)를 이동할 수 있음 이걸 +-2^10 word (4바이트가 32비트 32비트가 word)(+-4Kib)로 대략적으로 표현할 수 있다.

무조건 가지치기 : 옵코드와 레지스터 하나, 20비트의 이미디엇 사용. 따라서 +-2^18word 범위 (+- 1Mib)

20비트의 이미디엇 사용 → 0번째 비트는 무료 → 21개의 가용비트 ⇒ -2^21-1 ~ 2^21-2

둘 다 짝수주소체계라 1비트가 남는다 따라서 각각 13비트와 21비트의 범위를 갖지만 음수를 고려해야함 → 12, 20 워드 길이는 바이트임

U-format을 이용하면 더 멀리 jump할 수 있다.

맞으면 L1으로 바로 보내(beq)는 대신 맞으면 L2로 보내고 틀리면 U-format으로 L1을 보내는식으로 논리와 코드를 바꾸어주면 L1은 uformat을 타고 더 멀리 갈 수 있다. (20비트 이미디엇)

jal은 i포맷이다 → register로부터 immediate 12비트 범위까지 보낼 수 있다.

jalr이 uj포맷 → 현위치로부터 로부터 immediate 20비트 범위까지 보낼 수 있다. SB처럼 짝수체계 이용

lui는 u포맷 → upper immediate을 이용하는데 사용한다.

jal x1 label : jal의 주소로부터 label(immediate)만큼 떨어진 곳으로 jump함과 동시에 x1에는 현재의 다음 실행 예정 주소 즉 PC +4가 저장된다 그래서 x1대신 x0을 주면 리턴주소를 남기지 않고 jump를 할 수 있는거고 원한다면 다른 레지스터를 줘서 다른 레지스터에 리턴 주소를 남길 수 도 있다.

jalr도 동일하다. 애초에 jump라는건 flow가 옮겨가는거임. jal은 jal의 위치에서 20자리 immediate만큼 jump했지만, jalr에서는 register+ 12자리 immediate만큼 jump를 한다. 둘다 rd자리엔 돌아올 주소를 집어넣는데 jalr같은경우는 보통 돌아올떄, 즉 기준점 PC를 통해 돌아오는경우, 다시 이쪽으로 올 필요가 없기때문에 constant인 x0을 넣어서 주소 저장없이 돌아오는것이다. 만약에 다른 레지스터를 넣고자 한다면 그 레지스터에는 돌아올 주소가 들어갈거고, 그건 switch문 같은데서 쓰인다.

MIPS = Million Instructions Per Second = IC / (CPUT * 10^6)

ISA = Instruction Set Architecture 명령어 집합으로 Intel CPU와 AMD CPU의 경우 ISA는 같지만 마이크로 아키텍쳐가 다르다고 볼 수 있다. 동일한 ISA를 갖는다는것은 그 밑단인 마이크로 아키텍쳐가 어떻게 구현됐는지는 몰라도, 같은 명령어 셋으로 동작한다는 의미이므로 binary compatible하다고 볼 수 있다.

addressing mode

• immediate addressing : operand 하나는 reg, 하나는 imm ⇒ immediate으로부터 정보를 가져옴
• register addressing : operand 둘 다 reg ⇒ 레지스터로부터 정보를 가져옴
• base addressing : 하나는 reg, 하나는 메모리 (reg + imm) ⇒ 메모리로부터 정보를 가져옴 immediate이 offset
• pc relative addressing : 하나는 reg, 하나는 PC (reg + imm) ⇒ PC로부터 분기함 immediate이 offset

RISC-V는 byte ordering이다 → 한 메모리 블럭이 한 바이트를 갖는다 align을 지원한다 → 메모리 할당을 word 사이즈에 맞춰서 한다 (RISC-V는 align을 지원하지 않는다. 대신 짝수주소를 이용. 참고로 RISC-V의 word사이즈는 4바이트 32비트)

3

REVIEW 강한 instruction은 그 하드웨어 구현이 더 복잡해지고 그로인해 속도를 느리게만든다 Assembly코딩은 컴파일러가 더 잘하고 오류도 더 잘잡는다. binary compatibility를 지원하려면 ISA가 같거나 포함하고있어야한다. word는 메모리 4블럭씩 차이난다. 메모리 한블럭은 1바이트(8비트), word는 4바이트(32비트)

arithmetic 연산에서 우리는 signed와 unsigned를 구분해 HW를 설계하지 않아도 된다. 그렇게도 물론 할 수 있지만 앞서 말했듯 하드웨어의 복잡함은 속도를 저하시킨다. 따라서 둘 다 계산이 되게 하고 발생하는 문제, 예를들어 오버플로우 같은 문제들은 SW단에서 해결할 수 있도록 해준다. HW와 SW사이의 균형을 맞춰서 해결하는것

덧셈 연산에서의 overflow는 양+양 = 음 음+음 = 양 이 두가지를 말한다. unsigned에서 carry비트로인해 범위를 벗어나는것은 overflow라고 하지 않는다.

양수를 빼는 것과 음수를 더하는것은 동일한 효과를 낸다. 사실상 뺄셈도 덧셈과 같은것. 따라서 뺄셈에서의 overflow는 덧셈으로 바꿔서 생각해주면 간단하게 해결된다.

곱셈 알고리즘 : 곱셈은 multiplier의 각자리와 multiplicand를 곱한 부분 곱들을 모두 더해서 해결할 수 있다. 이를 HW적으로 해결하기 위해서는 multiplier는 매 반복마다 오른쪽으로, multiplicand는 왼쪽으로 shift해주면 해결된다.

multiplier의 LSB와 multiplicand를 곱해서 부분곱을 얻어내는데, 각 연산이 반복될수록 연산의 결과값은 2배가되어야한다 (연산의 결과값이 2배가된다 ⇒ 연산의 결과를 왼쪽으로 shift해줘야한다) ⇒ multiplicand를 left shift 매번 곱해지는 multiplier의 LSB를 위해서 multiplier를 right shift한다. ⇒ multiplier 를 right shift

곱셈의 결과의 길이는 operand length의 합과 같다. 64비트 수 두개를 곱했을 때 최대 길이는 128이된다. 근데 완벽히그런건 아니고 carry 발생 안하면 127에서 멈출수도있다. 최악의 경우가 128비트인데 최악의 경우에 맞춰줘야한다.

multiply flow chart multiplier의 LSB가 0이면 그냥 지나가고 1이면 multiplicand를 결과값이랑 더해준다. multiplicand는 왼쪽으로 1비트, multiplier는 오른쪽으로 1비트씩 shift 해준다. 반복을 64 번 했다면 연산이 완료된것. 그렇지 않다면 반복한다.

초기 덧셈 회로 : multiplicand, multiplier, product 레지스터를 사용하는데, multiplicand는 왼쪽으로 64번 shift 해야하고 product는 64비트 수 두개의 곱셈값을 저장해야하므로 128비트의 크기를 가져야한다. multiplier는 오른쪽으로 shift하기만하니까 128일필요는 없다. 덧셈기는 최대 128비트까지 더해야하므로 128비트여야함.

ex) 0010(multiplicand) * 0011(multiplier) 부분곱 : 0011, 0000 0010 = 1 * 0000 0010 = 0000 0010 시프트 : 0001, 0000 0100 ————————————————————————- 부분곱 : 0001, 0000 0100 = 1 * 0000 0100 = 0000 0010 + 0000 0100 = 0000 0110 시프트 : 0000, 0000 1000 ————————————————————————- 부분곱 : 0000, 0000 1000 = 0 * 0000 1000 = 0000 0110 + 0000 0000 = 0000 0110 시프트 : 0000, 0001 0000 ————————————————————————- 부분곱 : 0000, 0001 0000 = 0 * 0001 0000 = 0000 0110 + 0000 0000 = 0000 0110 시프트 : 0000, 0010 0000 ————————————————————————- 4번 반복 : multiplier 의 bit 수 만큼 연산 후 종료

개선된 버전의 덧셈 회로 : multiplicand는 어짜피 움직여봐야 뒤에 0만 주렁주렁 달고나오는데, 큰 의미 없으니까 그러지말고 걍 합할때 product를 오른쪽으로 shift시켜서 더하는 위치를 바꿔주자. multiplicand는 고정시키고 연산할때마다 결과인 product를 오른쪽으로 밀어준다. multiplier는 어짜피 오른쪽으로 밀려야하니까 product의 최종 크기인 128비트에 multiplier 초기크기 64비트, 결과도 초기엔 64비트만 나오니까 타당하다 한자리씩 밀어주면서 하자

더 빠른 버전 : ALU를 존나많이써서 한번에 계산을때린다면? 뒤에서 앞에서 모두 계산하면서 뒷비트 앞비트 빼내고 최종적으로 중간 비트까지 빼내면 그게 결국엔 곱셈연산 수행한거랑 같다. 32 + 16 + 8 + … + 1개 해서 총 63개의 ALU를 동원해서 128비트를 계산해낼 수 있고, 6의 깊이를 갖기 때문에, 시간은 적게먹는다. 여기에 파이프라인을 통해서 더 빨라질 수도 있다.

곱셈 instruction : 64비트의 곱셈은 128비트의 결과를 도출한다. 4가지의 instruction이 있는데, 보통 우리가 계산하는건 64비트만해도 존나게 큰 숫자기때문에 하위 64비트만 생각을 해줘도 된다. 그래서 다른 ISA들과 달리 RICS-V에서는 곱셈도 R포맷으로 나타낼수있다 굉장히 예외적인것.

mul : 곱셈연산 결과 128비트의 하위 64비트만을 반환해준다 mulh : 곱셈연산 결과 상위 64비트를 반환해주는데, 이는 둘 다 signed 연산했을 경우, mulhu : mulh랑 같은데 둘 다 unsigned였을경우 mulhsu : mulh랑 같은데 하나는 signed, 하나는 unsigned였을 경우다

mul만으로 값을 표현하고싶은데 혹시라도 범위를 벗어났다면? ← 만약 mul로 표현할 수 있는 범위를 넘어갔다면 mulh값이 있을것이다. 넘기지 않았다면 mul의 MSB값으로 sign extension된 값이 mulh에 들어가겠지만, 혹시라도 그렇지 않다는건 mul로 표현을 다 하지 못하는(overflow)값이 계산되었다는 의미임. SW적으로 이를 알아서 처리해준다. 걱정할 필요는 없

---

---

DIVISOR 안나옵니다!~~

C → RISC-V Instruction Session

PDF 예제 1

    long long leaf_example(long long g, h, i, j){
    	long long f;
    	f = (g + h) - (i + j);
    	result f;
    }

    leaf_example :
    	add x5, x10, x11
    	add x6, x12, x13
    	sub x10, x5, x6
    	jalr x0, 0(x1)

return value가 저장될 x10에 그냥 직빵으로 값을 저장하는 방식으로 하면 이렇게 간단하게 될 것.

    leaf_example : 
    	addi sp, sp, -8
    	sd x20, 0(sp)
    	add x5, x10, x11
    	add x6, x12, x13
    	addi x10, x20, 0
    	ld x20, 0(sp)
    	addi sp, sp, 8
    	jalr x0, 0(x1)

굳이 x20처럼 save되어야하는 register를 사용한다면 대략 이런 꼴이 된다.

PDF 예제 2

    long long fact (long long n){
    	if(n < 1) return 1;
    	else return n * fact(n - 1);
    }

    fact : 
    	addi sp, sp, -16
    	sd x1, 8(sp)
    	sd x10, 0(sp)
    	addi x5, x10, -1
    	bge x5, x0, L1
    	addi x10, x0, 1
    	addi sp, sp, 16
    	jalr x0, 0(x1)
    L1 : 
    	addi x10, x10, -1     //recursive call을 위한 새 argument n-1
    	jal x1, fact          //recursive call
    	addi x6, x10, 0       //x10에 원래 값 돌려놓기 전에 반환값 백업
    	ld x10 0(sp)          //재귀가 끝나야 반환되니까 이시점에선 이번째 백업된 값 복구되는거 
    	ld x1 8(sp)           
    	addi sp, sp, 16       
    	mul x10, x10, x6      
    	jalr x0, 0(x1)

과제 1

    for ( i = 1; i <= 100; i++){
    	sum += i;
    }

    Loop : 
    	addi x7, x6, -100     //x7에 i - 100을 저장해둔다.
    	blt x0, x7, Exit      //(i <= 100) => (i-100 <= 0) => !(i-100 > 0) => ! (0 < i-100)
    	add x5, x5, x6      
      addi x6, x6, 1
    	beq x0, x0, Loop   
    Exit : 

내 정답

    Loop : 
    	addi x7, x0, 100      //x7에 100을 저장해둔다. 
    	blt x7, x6, Exit      //(i <= 100) => !(i > 100) => !(100 < i)
    	add x5, x5, x6
      addi x6, x6, 1
    	beq x0, x0, Loop
    Exit :

재용

과제 2

    int fib(int n){
    	if(n == 0) return 0;
    	if(n == 1) return 1;
    	return fib(n - 1) * fib(n - 2);
    }

내 정답

    fib : 
    	addi sp, sp, -32     //현재 반복이 n번째라면 n-1번째의 정보 백업
    	sd x1, 24(sp)
    	sd x10, 16(sp)
    	sd x18, 8(sp)
    	sd x19, 0(sp)
    	bne x10, x0, L1
    	addi sp, sp, 32
    	jalr x0, 0(x1)
    L1 :                 
    	addi x5, x10, -1
    	bne x5, x0, L2
    	addi sp, sp, 32
    	jalr x0, 0(x1)
    L2 : 
    	addi x10, x10, -1    //x10에서 1 뺀 값을 인자로 줘 재귀
    	jal x1, fib              
    	addi x18, x10, 0     //결과를 saved 레지스터에 저장
    	ld x10, 16(sp)       //x10이 변경되었으므로 스택에서 load
    	addi x10, x10, -2    //x10에서 2 뺀 값을 인자로 줘 재귀
    	jal x1, fib            
    	addi x19, x10, 0     //결과를 saved 레지스터에 저장
    	add x10, x18, x19    //리턴을 위해 x10에 saved에 저장한 두 결과를 더해서 caller에게 전달
    	ld x19, 0(sp)        //recursion이 끝나면 이전에 저장한 값들을 되돌린다.
    	ld x18, 8(sp)
    	ld x1, 24(sp)        
    	addi sp, sp, 32      //stack해제
    	jalr x0, 0(x1)       //jump