100년 뒤 개발자 한승규입니다.

2주차에는 파일 입출력에 대해 공부한다.

• File

Unix/Linux에서의 file 타입은 이렇게 있다.

Regular file(일반 파일)

- text or binary data file

Directory

- 윈도우의 폴더이며 Unix/Linux에서는 directory도 하나의 파일로 본다

Special file(특수 파일)

- 파일 형태로 표현된 커널 내 객체

- 데이터 전송, 장치 접근 시 사용하는 파일

Basic commands for file

ls

현재 directory 내의 파일 목록 출력

주요 Option

-l : 상세 파일 정보 출력

-a: 모든 파일(숨겨진 파일 포함 목록 출력)

touch

빈 파일을 생성하거나 해당 파일이 있다면 time stamp를 변경해준다.

rm

파일 삭제

주요 Option

-r: directory 삭제

cat

파일 내용 출력

copy

파일 복사

주요 Option

-r: directory 복사

mv

파일을 이동하거나 이름을 변경

File access permission

Owner, Group, others 사용자에 따라

읽기(r), 쓰기(w), 실행(x) 권한을 가짐

권한은 이렇게 주어지며 권한은 변경할 수도 있다.

chmod

파일 권한 변경

가운데 권한을 비트연산으로 넣어준다.

• Open and Close a file

Low-level file IO vs High-level file IO

Opening files

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int open(const char *pathname, int flags [, mode_t mode]);

- pathname (file path)

열려는 파일의 경로 (파일 이름 포함)

- flags(file state flags)

파일을 여는 방법 설정

-mode (file access permission)

파일을 새로 생성할 때만 유효

return: file descriptor

아래는 flags이며 여러 플래그들을 조합 가능하다 (OR bit operation인 |을 사용)

자주 사용하는 flag들만 소개하겠다.

아래는 mode이다, flag와 마찬가지로 조합이 가능하며 파일 권한 설정 값을 사용한다.

file descriptor

여기서 file descriptor는 열려 있는 파일을 구분하는 정수 값이다.

파일을 열 때 순차적으로 할당이 되며

Default fds

0: stdin

1: stdout

2: stderr

이기 때문에 보통 3번부터 할당이 된다.

File table

열린 파일을 관리 하는 표이다.

kernel이 process 별로 유지하며 열린 파일에 대한 각종 정보를 관리한다.

Access mode, file offset, pointer to files

Closing files

#include <unistd.h>

int close(int fd);

- fd(file descriptor)

닫으려는 file descriptor

return: 0(success), -1(error)

file descriptor를 끊어주는 역할을 한다.

그럼 open과 close를 이용하여 간단하게 파일을 열고 닫는 프로그램을 만들어보자

이렇게 작성을 하고 컴파일을 해본다면

이렇게 새로운 파일이 생성되는 것을 볼 수 있다.

Error handling for System call

System call은 실패 시 -1을 반환

Error code는 errno에 저장 되며

perror를 활용해 error message를 출력 할 수 있다.

#include <stdio.h>

void perror(const char *str);

Reading a file

#include <stdio.h>

ssize_t read(int fd, void *buf, size_t count);

-fd(file descriptor)

읽으려는 파일의 file descriptor

-buf(buffer)

읽은 내용을 저장할 buffer의 시작 주소

-count

읽을 byte의 수

return: 실제로 읽은 byte의 수 (0: 파일의 끝인 EOF에 도달, -1: 에러)

Writing to a file

#include <unistd.h>

ssize_t write(int fd, const void *buf, size_t count);

-fd(file descriptor)

기록하려는 파일의 file descriptor

-buf(buffer)

기록할 내용이 저장된 buffer의 시작 주소

-count

기록할 byte의 수

return: 실제로 기록한 byte의 수 (-1: 에러)

File offset(File position)

File operation을 적용할 위치

파일의 시작점부터 현재 위치까지의 byte 수

Read/Write 수행시, 읽은/기록한 byte 수 만큼 순차적으로 이동

file offset을 이용해 해당 파일을 어디까지 읽었는지, 어디까지 작성했는지 기억한다.

그럼 한 번 Read와 Write까지 활용해서 파일을 작성해보자

#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>

int main(void){
	int rfd, wfd, n;
	char buf[10];

	rfd = open("hello.txt", O_RDONLY);
	if(rfd == -1){
		perror("Open hello.txt");
		exit(1);
	}

	wfd = open("hello.bak", O_CREAT | O_WRONLY | O_TRUNC, 0644);
	if(wfd == -1){
		perror("Open hello.bak");
		exit(1);
	}

	while((n = read(rfd, buf, 6)) > 0)
		if(write(wfd, buf, n) != n) perror("wrote");

	if(n == -1) perror("Read");
	
	close(rfd);
	close(wfd);

	return 0;
}

이렇게 read를 이용하여 offset을 따라 모두 읽고 write하는 것을 볼 수 있다.

우리는 당연히 파일을 처음부터 순차적으로 따라 읽으며 내려왔다.

하지만 파일의 원하는 Block에 직접 접근 하는 방법도 있다.

Moving the file offset

#include <sys/types.h>
#include <unistd.h>

off_t lseek(int fd, off_t offset, int whence);

-fd(file descriptor)

대상 file descriptor

-offset

이동시킬 byte 수 (양수 or 음수)

-whence

기준 위치

return: 이동 후 file offset (-1: 에러)

whence에는

SEEK_SET: 파일의 시작

SEEK_CUR: 현재 위치

SEEK_END: 파일의 끝

이렇게 3가지 종류가 있다.

한 번 사용해보도록 하자

#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>

int main(void){
    int fd, n;
    off_t start, cur;
    char buf[256];

    fd = open("linux.txt", O_RDONLY);
    if(fd == -1){
        perror("Open linux.txt");
        exit(1);
    }

    start = lseek(fd, 0, SEEK_CUR);
    n = read(fd, buf, 255);
    buf[n] = '\0';
    printf("Offset start=%d, Read Str=%s, n=%d\n", (int)start, buf, n);
    cur = lseek(fd, 0, SEEK_CUR);
    printf("Offset cur=%d\n", (int)cur);

    start = lseek(fd, 6, SEEK_SET);
    n = read(fd, buf, 255);
    buf[n] = '\0';
    printf("Offset start=%d, Read Str=%s", (int)start, buf);

    close(fd);

    return 0;
}

실행을 시키면 이렇게 offset이 이동하는 것을 볼 수 있다.

Page cache & write-Back

Page ache

- In-memory store of recenlty accessd dat from an on-disk filesystem

- Disk 접근 시간 절약을 위해 kernel 내부적 기법

page write-back

- Page cache에 변경 된 내용을 disk에 반영하는 것

- 반영 시기는 kernel이 결정

Synchronizing with disks

#include <unistd.h>

int fsync(int fd);

-fd(file descriptor)

대상 file descriptor

return: 0(success), -1(error)

page write-back을 강제로 수행한다.

• File descriptor

Duplicating FD

#include <unistd.h>

int dup(int oldfd);
int dup2(int oldfd, int newfd);

-oldfd(old file descriptor)

복사하려는 file descriptor

-newfd

새로운 fd 지정

dup()의 경우 할당 가능한 fd 중 가장 작은 값으로 할당

return: oldfd를 복사한 새로운 fd (-1: 에러)

한번 실습을 해보자

#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>

int main(void){
    int fd, fd1;

    fd = open("tmp.aaa", O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if(fd == -1){
        perror("Create tmp.aaa");
        exit(1);
    }
    
    close(1);

    fd1 = dup(fd);

    printf("DUP FD = %d\n", fd1);
    printf("Standard Output Redirection\n");
    close(fd);

    return 0;
}

이거를 실행해보면 stdout이 tmp.aaa로 연결이 되어

터미널에 출력이 되지 않고 tmp.aaa에 저장이 되는 것을 볼 수 있다.

어셈블러에서 함수를 어떻게 처리하는지 살펴보자

• Supporting Procedures

함수를 호출하는 절차는 다음과 같다

1. 함수의 매개변수들을 넘긴다.

2. memory space에 필요한 공간을 마련하고 그곳으로 제어를 옮긴다.

3. 함수를 실행한다.

4. return value를 저장하고 돌아갈 위치를 찾는다.

5. 원래 지점으로 돌아간다.

int main(){ //caller
	if(a == 0)
    	b = f1(g, h);
    else
    	b = f1(k, i);
    return 0;
}

int f1(x, y){ //callee, caller
	a = (x + y) * (x + 2) * f2(y);
    return a;
}

int f2(y){ //callee
	return y / 2;
}

여기서 main 함수가 f1을 호출한 caller가 되고

f1은 main 함수에 의해 호출당한 callee이며, f2를 호출한 caller가 된다.

f2는 f1에 의해 호출당한 callee이다.

그러면 RISC-V에서는 매개변수와 return value, return address를 어떻게 주고받을까?

RISC-V는 관습적으로 정해진 레지스터 번호에 해당하는 레지스터를 함수의 호출에 사용한다.

x10~x17: eight parameter registers in which to pass parameters or return values

x10~x17에 해당하는 레지스터를 매개변수를 저장할 때 사용하거나 return value를 저장할 때 사용한다.

x1: one return address register

x1은 함수가 return 할 때 돌아갈 지점을 저장한다.

또 함수를 다루기 위해서 jal이라는 명령어를 사용한다.

jal: "jump-and-link"

jal x1, ProcedureAddress

Branch unconditionally and save the address of the next instruction(return address) to the designated register

무조건 지정해 둔 주소로 분기를 하며, 레지스터에 다음번 실행해야 할 instruction을 저장하고 분기한다.

보통 return address를 저장하는 x1 레지스터를 사용한다.

만약 돌아올 주소를 저장하지 않고 분기하고 싶다면

jal x0, Label

로 주소를 저장하지 않고 분기할 수 있다.

jal에서 더 확장하여 jalr 명령어가 있는데

jalr: "jump and link register" instruction (I-type)

jalr: x0, 0(x1)

x0 주소에 return address를 저장하고 0(x1) 주소로 분기한다는 명령어이다.

주소값을 표현하는 데에 jal에 비해 더 많은 비트를 사용하기 때문에 더 자세한 주소값으로 분기할 수 있다.

• Using More Registers

함수를 실행하기 위해서는 보통 8개의 레지스터보다 더 많은 메모리를 필요로 한다.

그렇기에 컴파일러는 레지스터 이외에 추가로 메모리를 사용한다.(당연히 속도는 더 느려진다)

이렇게 레지스터가 모두 차서 메모리에 저장하는 현상을 spill이라고 한다.

spill이 일어났을 때 저장하기에 이상적인 공간은 stack이다.

x2 레지스터를 stack pointer라고 하는데

이 stack pointer는 데이터가 저장되어 있는 memory의 주소이다.

이 stack은 높은 주소부터 낮은 주소로 데이터를 저장하기 시작한다.

stack pointer를 활용하는 예제이다.

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

//g -> x10
//h -> x11
//i -> x12
//j -> x13
//f -> x20

이 C 코드를

leaf_example:
addi sp, sp, -24 //adjust stack to make room for 3 items
sd x5, 16(sp)    //save register x5 for use afterwards
sd x6, 8(sp)     //save register x6 for use afterwards
sd x20, 0(sp)    //save register x20 for use afterwards
add x5, x10, x11 //register x5 contains g + h
add x6, x12, x12 //register x6 contains i + j
sub x20, x5, x6
addi x10, x20, 0 //move value f to x10
ld x20, 0(sp)    //restore register x20 for caller
ld x6, 8(sp)     //restore register x6 for caller
ld x5, 16(sp)    //restore register x5 for caller
addi sp, sp, 24  //adjust stack to delete 3 items
jalr x0, 0(x1)

x5, x6, x20에 있는 값을 sp를 이동시킨 후 memory에 저장하는 모습이다.

사용 후에는 caller의 데이터를 복원하기 위해 레지스터에 원래 데이터를 두고 sp를 원위치시킨다.

stack을 사용하던 도중 저 sp는 처음 위치보다 더 올라가서 읽으면 안된다.

그렇기에 시작 주소를 fp에 저장하고 그 위로는 데이터를 읽을 수 없도록 한다.

sp는 함수 실행 도중 변할 수 있지만 fp는 그렇지 못하다.

• Register saving convention

하지만 모든 상황에서 caller의 데이터를 복구해 두는 것은 아니다.

저 표에 있듯 x8, x9, x18-x27의 데이터는 복구를 해두어야 하지만 x5-x7, x28-x31의 값은 복구할 필요가 없다.

다시 말해 caller는 callee를 호출 한 후 x5-x7, x28-x31의 값이 원래와 같지 않을 수 있다고 생각을 해야한다는 것이다.

저 표에 sp, fp 등의 레지스터를 추가해보면

다음과 같다.

• Allocating Memory on the Heap

프로그램 실행 중에 데이터를 메모리에 저장하는 방법이다.

Text Segment: instructions, program binaries

Static data segment: constants and static variables

Heap(for dynamic data): place where dynamically allocated(malloc and free in C)

stack은 위에 나왔던 stack 과 같다.

처음 실행 할 때 Text, Static data 영역에 데이터를 저장해두고 프로그램 실행 중에 Heap 영역만 변하게 된다.

• Instructions

lui

immediate에 저장되어 있는 12비트의 수를 64비트로 확장하는 instruction

우선 31~12에 저장되어 있는 20비트의 수를 load한 후

저장하려는 64비트의 왼쪽에 32비트를 sign 비트로 채운다.

그 뒤에 20비트의 수를 넣고 나머지 오른쪽의 12비트를 0으로 채운다.

SB-type

beq, bne등의 instruction이 해당하며 분기하는 instruction이다.

immediate를 이용해서 -4096 ~ 4094 범위로 분기 할 수 있다.

imm[0]은 언제나 0이기 때문에 따로 저장하지 않는다.(항상 짝수이기 때문)

UJ-type

조건에 상관없이 무조건 분기하는 jal 계열의 instruction이다.

조건을 확인하지 않기에 immediate가 더 긴 것을 볼 수 있으며, 여기도 imm[0]이 항상 짝수이기 때문에 따로 저장하지 않는다.

여기서 보면 conditional branch는 13bit, unconditional branch는 21bit의 immediate field를 가진다.

부호를 표현하는 데 1bit, 4byte instruction이기에 2bit가 빠지면

conditional branch는 2의 10제곱 만큼의 위치를

unconditional branch는 2의 18제곱 만큼의 위치로 분기 할 수 있다.

10일 정도 안에 마칠 계획이고

보통은 WSL Ubuntu를 사용하겠지만 MAC을 가지고 있기 때문에 MAC을 이용해서 시스템 프로그래밍을 정리할 예정이다.

• 시스템 프로그래밍의 개요

Systems programming, or system programming, is the activity of programming computer system software. The primary distinguishing characteristic of systems programming when compared to application programming is that application programming aims to produce software which provides services to the user directly (e.g. word processor), whereas systems programming aims to produce software and software platforms which provide services to other software, are performance constrained, or both - from wikipedia

시스템 프로그래밍은 시스템 호출을 이용해서 프로그램을 작성하는 것이다.

시스템 호출은 운영체제에서 제공하는 서비스를 프로그램에서 이용할 수 있도록 지원하는 프로그래밍 인터페이스를 의미한다.

시스템 프로그램은 시스템을 구성하는 자원을 다루는 프로그램이며 응용프로그램에 서비스를 제공하는 프로그램으로 OS, firmware, compiler 등이 있다.

프로그래밍을 하면서 라이브러리는 많이 사용을 해보았을 것이다.

Library function과 System call을 비교해보면

System call: 시스템의 기능을 이용하는 통로, Kernel 내 모듈을 직접 호출

Library function: 미리 컴파일 된 함수, 자주 사용되는 기능을 독립적으로 구현 (내부적으로 System call을 활용)

미리 만들어진 Library를 사용할 수 있지만 굳이 System programming을 배워 사용하는 이유는

직접 System call을 사용한다면 더 많은 것들을 만들 수 있으며 중간 과정을 건너 뛰고 직접 사용한다면 더 높은 성능을 얻을 수 있기 때문이다.

이 시스템 프로그래밍 공부의 목표는

• 시스템을 효율적으로 활용하는 능력 함양

Unix/Linux 기반 시스템 및 새로 만나는 시스템

• 시스템 자원에 대한 이해 향상

- File / Directory

- System information

- Process

- Signal

- Memory

- Communication interface

그냥 프로그램을 만드는 것이 아니라 더 높은 성능의 프로그램을 만들 수 있도록 시스템에 대해 이해하는 것이다.

• Unix/Linux architecture

시스템 프로그래밍 중 사용할 Linux/Unix에 대해 알아보자

현재, 다양한 시스템에서 가장 널리 사용하는 OS이다.

Unix/Linux architecture

- Kernel

OS의 핵심 기능을 모아놓은것

-System call

OS 기능 중 응용프로그램이 사용하도록 허락된 기능들의 집합

-Shell

사용자와 OS 사이의 인터페이스

사용자의 입력을 해석하여 커널의 함수 호출

• Basic Unix/Linux commands

- Login/Logout

telnet: 유닉스 시스템에 접속

이거는 잘 안써서 사용 방법을 모르겠다....

logout: 유닉스 시스템에서 접속해제

ex) logout

exit: 유닉스 시스템에서 접속해제

ex) exit

-Process management

ps: 현재 실생중인 프로세스를 출력

ex) ps -u 사용자ID

kill: process 강제 종료

ex) kill -9 사용자ID

-File/Directory

pwd: 현재 디렉토리 경로 출력

ex) pwd

ls: 디렉토리 내용 출력

ex) ls -l

cd: 현재 디렉토리 변경

ex) cd /tmp

cp: 파일/디렉토리 복사

ex) cp a.txt b.txt

mv: 파일/디렉토리 이름변경과 이동

ex) mv a.txt b.txt

rm: 파일/디렉토리 삭제

ex) rm a.txt

mkdir: 디렉토리 생성

ex) mkdir dir1

rmdir: 빈 디렉토리 삭제

ex) rmdir dir2

cat: 파일 내용 출력

ex) cat a.txt

more: 파일 내용을 쪽 단위로 출력

ex) more a.txt

chmod: 파일 접근권한 변경

ex) chmod 777 a.txt

grep: 패턴 검색

ex)grep abcd a.txt

- Others

su: 사용자 계정 변경

ex) su -seungkyu

tar: 파일/디렉토리 묶기

ex) tar cvf a.tar *

whereis: 파일 위치 검색

Man Page

Unix/Linux 시스템 사용 설명서로 

Shell command, System Call, Standard library에 대한 설명을 제공

man [options][section] page

의 명령어를 입력하여 사용한다.

• VI editor

Linux를 사용하다보면 VI editor를 굉장히 많이 사용할 것이다.

일단 배운 명령어들로 실습을 할 디렉토리를 만들고 들어가준다.

그럼 이 실습 디렉토리에서 vi helloLinux.c 라는 명령어를 입력하여 VI 에디터를 실행해보자

VI 에디터로 helloLinux.c라는 C 소스코드 파일을 작성하겠다는 명령어이다.

그러면

이런 창이 나타나게 된다.

윈도우에서의 메모장이라고 생각하면 된다.

VI Editor의 명령어들이다.

입력모드 전환: i, a, o, O

한글자 수정: r

단어수정: cw

붙이기: p

글자삭제: x

명령취소: u, U

복사: y

행삭제: d

저장하고 종료: wq!

저장하지 않고 종료: :q!

명령어들은 외우려고 하기 보다 쓰다보면 자연스럽게 익혀지기 때문에 많이 사용해보는 것이 좋다.

정리하는 단계이니 일일이 소개하지는 않고

바로 프로그램을 만들어보도록 하겠다.

이렇게 작성을 하고 이 코드를 컴파일해보자

gcc -o helloLinux helloLinux.c

gcc를 이용해서 컴파일을 한다.

이렇게 입력을 하면 컴파일이 되고

./helloLinux를 이용해 컴파일이 된 프로그램을 실행할 수 있다.

• Makefile

GNU C compiler는 Unix/Linux에서 가장 기본이 되는 compiler이다.

위에서 대충 사용해봤겠지만 자세한 사용 방법은 아래와 같다.

gcc [options] filename

options:

-c: object file(.o)만 생성

-o: execution file name 지정(default는 a.out이고 사용자가 이름 지정가능)

이렇게 -c 옵션을 주면 .o 파일을 만들 수도 있다.

Makefile & Make

컴파일을 도와주는 Make에 대해 알아보자

Makefile은 compile 방법을 기술 하는 파일이다.(관련 파일 정보, compile 명령, 실행 파일명 등), 여러 파일로 구성된 프로젝트 설정과 비슷한 개념

Make은 주어진 Makefile에 따라 compile을 수행하고, 실행파일을 생성. 최초 컴파일 이후에는, 변경이 있는 파일만 컴파일 함

Makefile을 사용하면

$ gcc -c -o main.o main.c
$ gcc -c -o foo.o foo.c
$ gcc -c -o bar.o bar.c

$ gcc -o app.out main.o foo.o bar.o

이렇게 항상 하나하나 모두 직접 컴파일을 해줘야 했던 일을

이렇게 미리 Makefile에 작성하여

app.out: main.o foo.o bar.o
	gcc -o app.out main.o foo.o bar.o
    
main.o: foo.h bar.h main.c
	gcc -c -o main.o main.c
    
foo.o: foo.h foo.c
	gcc -c -o foo.o foo.c
    
bar.o: bar.h bar.c
	gcc -c -o bar.o bar.c

$ make 명령어로 한 번에 컴파일 할 수 있다.

이렇게 미리 작성을 해두면 오타날 위험이 적다는 장점도 있다.

그리고 make를 할 때마다 모든 파일들을 컴파일 하는 것이 아니라 수정된 파일들만 찾아서 컴파일을 해주게 된다.

Rule block

Makefile의 Rule block은

<Target>: <Dependencies>
	<Recipe>

Target: Build 대상 이름, 일반적으로 최종 결과 파일명 사용

Dependency: Build 대상이 의존하는 Target이나 파일 목록

Recipe: Build 대상을 생성하는 명령어

Implicit rules

자주 사용되는 규칙을 자동으로 처리해줌(Source를 Compile해서 Object 파일을 생성하는 규칙)

Target에 대한 dependency까지는 명시를 해주어야 한다.

app.out: main.o foo.o bar.o
	gcc -o app.out main.o foo.o bar.o
    
main.o: foo.h bar.h main.c
foo.o: foo.h foo.c
bar.o: bar.h bar.c

이렇게 아래부분을 더 짧게 바꿀 수 있다.

variables

사용하는 명령어들과 파일 명들을 변수로 치환해서 사용할 수 있다.

CC=gcc
CFLAGS=-g pWall
OBJS=main.o foo.o bar.o
TARGET=app.out

$(TARGET): $(OBJS)
	$(CC) -o $@ $(OBJS) // $@: current target name
    
main.o: foo.h bar.h main.c
foo.o: foo.h foo.c
bar.o: bar.h bar.c

Clean rule

Build로 생성된 파일들 삭제하는 규칙

make로 파일을 만든 후에 필요 없어지는 파일들이 생길 수 있다.

그럴 때도 make 파일에 clean을 작성 한 후 한번에 제거할 수 있다.

clean:
    rm -f *.o
    rm -f $(TARGET)

이렇게 작성을 해둔 후

$make clean 명령어를 입력하면 clean에 작성된 명령어들이 한 번에 실행이 된다.

CC=gcc # (built-in variable) compiling C programs
CFLAGS=-g pWall # (built-in variable) extra flags to give to CC
OBJS=main.o foo.o bar.o
TARGET=app.out

all: $(TARGET)

$(TARGET): $(OBJS)
	$(CC) -o $@ $(OBJS) // $@: current target name
    
main.o: foo.h bar.h main.c
foo.o: foo.h foo.c
bar.o: bar.h bar.c

clean:
    rm -f *.o
    rm -f $(TARGET)

이렇게 배워본 makefile을 정리해 보았다.

컴퓨터구조 3주차 정리이다.

전에 다 알아보지 못했던 2의 보수법과 CPU의 기본 명령어들을 알아보도록 하자

• Signed and Unsigned Numbers

컴퓨터는 단순 2진수로만 수를 저장할 수 있지만 양수만이 아닌 음수도 저장할 수 있다.

그렇다면 과연 컴퓨터 내에서는 음수를 어떻게 저장할까?

수를 저장할 때 부호 비트의 자리를 따로 만들고 해당 비트가 0이면 양수, 1이면 음수로 표현한다.

부호 비트를 앞쪽에 저장하는지, 뒤쪽에 저장하는지에 따라서 LSB와 MSB로 나뉘는데

LSB(least significant bit): the right most bit, bit position 0

부호 비트를 0번에 표시하면 LSB

MSB(most significant bit): the left most bit, bit position 63

부호 비트를 63번에 표시하면 MSB

이다.

보통은 MSB를 사용한다.

• signed numbers

음수를 부호 비트 1로 표현하는 것은 알았다.

그렇다면 그냥 단순히 부호비트만 1로 바꾸면 음수가 되는 것일까?

0000 = 0      -> 1000 = -0

0001 = 1       -> 1001 = -1

0010 = 2       -> 1010 = -2... 이런식으로 양수에서 부호비트만 바꾸는 방법을 sign and magnitude(부호-크기)방식이라고 한다.

하지만 해당 방식의 문제는 뺄셈의 계산을 할 때 발생한다.

뺄셈은 음수의 더하기로 계산을 한다.

그렇다면 이 식을 계산해보자

6 - 3 = 0110 + 1011 = ..0001 대충 계산을 해보아도 다른 답이 나오는 것을 볼 수 있다.

뺄셈을 위해 컴퓨터에서는 이 부호-크기 방식을 사용하지 않고 보수법을 사용하게 된다.

1's complement(1의 보수법)

0000 = 0      -> 1111 = -0

0001 = 1       -> 1110 = -1

0010 = 2       -> 1101 = -2 ... 이런식으로 양수와 음수 비트를 역전시키는 방법을 1's complement(1의 보수법)이라고 한다.

이 방법을 사용하면 뺄셈을 수행할 수 있다.

6 - 3 = 0110 + 1100 = 0010 = 2, 비록 3이 나오지는 않지만 이 수에 1을 더해주면 결과가 나오게 된다.

뺄셈 후에는 모두 일관되게 1만 더해주면 되기 때문에 뺄셈 연산이 가능하다.

하지만 이 방법의 단점은 무엇일까?

0을 표현하는 방법이 2가지 이다.(0000, 1111)

이렇게 된다면 표현할 수 있는 수가 하나 줄게 된다.

2's complement(2의 보수법)

0000 = 0      -> 1111 = -1

0001 = 1       -> 1110 = -2

0010 = 2       -> 1101 = -3 ... 이런식으로 1의 보수법에서 아예 미리 1을 더해놓는 방법을 2's complement(2의 보수법)이라고 한다.

이 방법을 사용하면

6 - 3 = 0110 + 1101 = 0011 = 3, 이렇게 바로 원하는 결과를 얻을 수 있으며

0이 중복으로 표현되지 않기 때문에 표현할 수 있는 수가 손실되지 않는다.

양수와 음수를 변환 할 때, 비트를 역전시킨 후에 1만 더해주면 된다.

2 -> -2 는 0010 -> 1101 -> add1 -> 1110으로

-2 -> 2 는 1110 -> 0001 -> add2 -> 0010으로 상호변환이 가능하다.

이렇게 양수와 음수를 표현하는 방법에 대해 알아보았다.

그렇다면 sign extension(부호 확장)에 대해 알아보자

sign extension

이번엔 부호의 확장에 대해 알아보자.

n bit였던 수를 m bit로 확장한다면

해당 수의 부호를 보존하기 위해 MSB 비트를 확장하는 만큼 앞에 채워주면 된다.

그래도 만약 원한다면 0으로 채워줄 수는 있다.

Instructions : lb(load byte), lh(load halfword), lw(load word)

if you don't want to sign extension, use lbu(load byte unsigned).

• Representing instructions

컴퓨터에서 수를 어떻게 저장하는지 살펴보았으니 이제 명령어들을 어떻게 표현하는지 알아보자.

가장 대표적인 명령어 타입으로 R-type, I-type, S-type 이 있다.

R-type

R-type 명령어는 이렇게 이루어져 있다.

opcode: 대략적인 명령어의 종류

rd: destination register(값을 저장할 레지스터)

funct3: additional opcode

rs1: 1st source register

rs2: 2nd source register

funct7: additional opcode 

x20과 x21을 더해서 x9에 저장하는 add x9, x20, x21을 표현한다면

0000000/10101/10100/000/01001/0110011로 표현이 될 것이다.

I-type

i가 붙은 명령어들을 수행하는 I-type instruction이며

이렇게 표현이 된다.

R-type에서 rs2와 funct7 코드가 합쳐져 immediate가 되었으며 immediate는 연산을 수행 할 때 같이 계산이 되는 상수이다.

x2의 레지스터에 있는 주소값에서 8을 더한 주소의 값을 x14에 저장하는 ld x14, 8(x2)를 표현한다면

000000001000/00010/011/01111/0000011로 표현이 된다.

S-type

S-type에는 rd가 없는것이 특징이다. (레지스터에 데이터를 저장하는 과정이 필요하지 않기 때문)

대신 immediate가 rd의 위치까지 차지한 상태로 나뉘어 저장이 된다.

x2의 레지스터에 있는 주소값에서 8을 더한 주소의 값을 x14에 저장되어 있는 주소에 저장하는 sd x14, 8(x2)를 표현한다면

0000000/01110/00010/011/01000/0100011로 표현이 된다.

• logical operations

논리적인 계산을 수행하는 명령어들을 알아보자.

Shift left와 right 부터 살펴보자.

왼쪽으로 이동하는 Shift left는 그냥 0으로 채우지만, 오른쪽으로 이동하는 Shift right는 무슨 수로 채우는지에 따라 부호가 바뀌기 때문에 신중해야 한다.

slli, srli - shift left (right) logical immediate

이 명령어들은 단순히 이동시킨 후 빈자리를 0으로 채워준다.

만약 이 문제를 해결하고 싶다면

sra, srai - shift right arithmetic(immediate): fill with sign-bit

sign bit로 채워주는 sra 계열의 명령어를 사용해야한다.

AND

OR

XOR

해당 명령어들은 컴퓨터를 공부했다면 직관적으로 파악할 수 있을것이다.

여기에 NOT연산은 따로 구현해두지 않고

1111...1111과 xor연산으로 구할 수 있다.

• Instructions for Making Decisions

컴퓨터가 결정을 내리는 과정 코드에 대해 알아보자

쉽게 IF문으로 생각하면 된다.

컴퓨터는 Branch instruction을 이용해 분기를 한다.

Branch instruction

- if statement

• beq rs1, rs2, L1

beq: branch if equal

만약 rs1의 값과 rs2의 값이 같다면 L1으로 분기한다는 조건문이다.

• bne rs1, rs2, L1

bne: branch if not equal

만약 rs1의 값과 rs2의 값이 같지 않다면 L1으로 분기한다는 조건문이다.

bne와 beq를 이용해서 C의 코드를 변환해보자

만약 C의 이런 코드가 있다.

그리고 각각의 변수는 해당 레지스터에 값이 저장되어 있다.

f: x19, g:x20, h:x21, i:x22, j:x23

이렇게 변환이 될 것이다.

While문도 이렇게 조건을 이용해서 만족할 때만 탈출할 수 있도록 만든다.

i: x22, k: x24, base of save: x25

이렇게 계속 만족하는 조건에만 탈출하고 아니면 계속 위로 올라가는 방식으로 조건문을 구현한다.

- Other conditional Branches

• blt: branch is less than

blt rs1, rs2, L1

뜻 그대로 rs1에 저장된 값이 rs2보다 작으면 L1으로 분기한다.

• bge: branch if greater than or equal

bge rs1, rs2, L1

rs1에 저장된 값이 rs2보다 크거나 같으면 분기한다.

bltu, bgeu는 비교하는 값들이 unsigned 수라고 생각하고 비교하는 것이다.

이것들을 이용해 Array의 범위 체크를 구하는 명령어를 만들어보자

우리는 배열을 사용할 때 해당 인덱스가 0 이상 최대 인덱스 미만인지 확인을 해야한다.

당연히 조건문을 두번 사용해야 할 것 같지만

이렇게 bgeu를 한번만 사용한다.

만약 x20에 저장된 수가 음수라면 unsigned 수로는 엄청나게 큰 수로 읽게 되고 그럼 x11보다 클 것이기 때문에

저 식 한번으로도 체크할 수 있다.