깜지로 쓰려는 블로그

지난 글에서 컴퓨터 HACK을 만들기 위해서

1. CPU

2. ROM 32K

3. Screen

4. Keyboard

5. RAM

6. Computer

이렇게 6가지로 나누어서 설명했다.

1. CPU 구현하기

CPU는 ALU와 세 레지스터 - 어드레스 레지스터, 데이터 레지스터, 프로그램 카운터로 만들면 된다. 각각이 뭐하는건지는 직접 만들기도 하고 수차례 시뮬레이션도 돌렸으니 넘어가고 고맙게도 아래의 그림처럼 연결하면 된다고 알려준다. 동작 과정은 다음과 같다.

 1) 명령어 해독 : CPU 입력 - 명령어 instruction은 A 명령어(MSB가 0, op-code라고도 했던거같은데), C 명령어(MSB가 1일때) 올수 있고, C 명령인 경우 111accccccccdddjjj 6개의 제어 비트 ccccccc와 a로 선택된 연산을 수행하고, ddd로 지정한 곳에 연산 결과를 저장한다. jjj가 000이 아닌 경우 연산 결과에 따라서 jjj의 조건(0과같거나, 크거나, 작거나 등)에 따라 어드레스 레지스터에 입력된 명령어 주소로 점프한다.

 2) 명령어 실행 : 들어온 명령어가 A 명령어인 경우 A 레지스터에 담는다. C 명령어의 경우 해독된 명령어의 연산을 수행한다.

 3) 명령어 가져오기 : 명령어가 실행되면 프로그램 카운터는 다음에 실행할 명령어의 주소를 준비하고, 현재 명령어가 끝나면 PC에 지정된 주소의 명령어가 실행된다. 하지만 앞서 보았듯이 "@LOOP\n 0;JMP" 처럼 라벨 심볼로 점프할때는  어드레스 레지스터 A에 담겨진 라벨 심볼 (LOOP)의 주소로 점프하여 명령어를 수행하게 되고, PC도 이를 따라가 다음 실행할 주소를 담아서 수행한다. 

이제 CPU 구현에 필요한 내용은 대강 정리했는데

어디부터 시작하는게 좋을지가 고민이다.

프로그램 카운터나 각 먹스, 레지스터에는 제어 비트를 어떻게 넣어야 하는건지

 위 그림을 보고 사용해야할 회로들의 인터페이스를 정리해보자

CPU = ALU + D/A registor + PC +(Mux 16 2개)

1. ALU

- 입력 : 16비트 x(D), y(M/A),   제어 비트 6개

- 출력 : 상태 출력 비트 2개 zr ng, alu 연산 출력 16비트 outM

2. PC

- 입력 : 16비트 입력(다음 실행 주소 A-점프시),  제어 비트 3개(reset, load, inc-이 순서대로 조건에따라 수행) 

- 출력 : 제어 비트에 따라 리셋시 0, 로드시 점프할 주소, 증산시 다음 명령어, 이도저도 아닐땐 상태 유지

3. Regsitor

- 입력 : 16비트 입력 in, 로드 제어비트 load

- 출력 : 현재 값 out, 입력 로드시 out[t+1] = in[t]가 된다.

4. MUX 16

- 입력 ; 16비트 a, b

- 출력 : sel이 0인경우 a, sel == 1일때 b

CPU

- 입력 : inM(데이터 메모리에서 읽어온 값), instruction(현재 실행할 명령어)

- 출력

 outM : RAM[addressM]에 쓰여진 결과

 addressM : 값이 쓰여질 주소, A 레지스터의 출력

 writeM : 메모리에 쓸지 읽을지 여부

 pc : 다음 명령의 주소

1.1 PC 구현하기

1. reset 입력 : PC의 제어비트 같은 경우에는 reset을 바로 연결시켜주면 될거같기는 한데 ..  

2: inc 입력 : inc는 reset이 0이 아니면 1이니까 Not(in=reset, out=resetNotOut) 해서 넣어주면 될거같다.

3. load 입력 : load 의 경우에는 명령어의 j 비트가 000인 경우에만 점프하는게 아니니까 3bit or한 결과가 0이면 load는 0, 1이면 1로해야겠다. 일단 instruction의 LSB 3비트만 받아서 or 연산 후 jmp123or을 출력하여 load 자리에 넣는다고 생각하고 이 이름을 입력받도록 하자.

4. in 입력 : A 레지스터의 출력을 써야하니 일단 A 레지스터를 어떻게 할지 생각하지는 않았지만 aRegistorOut이란 이름으로 해놓자.

5. 출력 : PC의 출력은 pc란 이름으로 출력되어야한다.

일단 프로그램 카운터 쪽 파트는 이렇게 정리했다.

    //PC PARTS
    Or(a=instruction[0], b=instruction[1], out=jmp12or);
    Or(a=jmp12or, b=instruction[2], out=jmp123or)
    Not(in=reset, out=resetNotOut)
    PC(in=aRegistorOut, load=jmp123or, inc=resetNotOut, reset=reset, out=pc);

1.2 A registor 구현하기

가장 먼저 PC를 만들면서 A의 입력을 받도록 했었으니까 이번에는 A 레지스터를 한번 보자

A Registor는 일단 좌측의 Mux16의 결과를 받아 우측의 Mux16과 PC로 보내고 있으며, 제어비트 c가 0인지 1인지에 따라 값을 읽기만 하거나 저장을 한다.

1. in 입력 : in의 경우 좌측 먹스의 출력을 받으니 일단 leftMuxOut 정도로 해놓자

2. 출력 : A 레지스터의 출력은 우측 먹스의 입력으로, PC의 입력으로도 사용하는데 일단 aRegistorOut 정도로 해놓자.

3. c 입력 : A 레지스터에 값을 쓸지 말지 여부는 명령어가 A 명령어인지 C 명령어인지에 따라 결정되었었다. 라벨 심볼이든, 변수든, 상수가 오던간에 A 명령어 이므로 instruction의 MSB를 보고 0이면 c에는 1, MSB가 1이면 c에는 0을 놓도록 Not 게이트(출력명은 opcodeOut)를 추가하여 연결해보자.

    //A registor PARRTS
    Not(in=instruction[15], out=opcodeOut);
    //if opcode is 0 (== A instruction) -> opcodeOut = 1 -> load = 1
    Register(in=leftMuxOut, load=opcodeOut, out=aRegistorOut);

+ 오류 발견1 ) D registor 구현 중 A에 로드해야하는 경우 추가 발견

A 레지스터에는 A 명령어가 들어올때 외에도 C 명령어일 때, 첫번째 d비트의 값이 1인 경우 instruction[5]==1, 연산 결과를 A 레지스터에 담는다. 명령어가 C 명령어고 첫번째 d비트가 1인지 여부 ((instruction[15] && instruction[5]) 한 결과를 loadA라 하면, opcodeOut과 loadA 둘중 하나가 1이면 1이되도록 or 연산을 한 후 aRegistorLoad 라는 이름으로 전달해주자.

    //A registor PARRTS
    Not(in=instruction[15], out=opcodeOut); // A instruction == store to A registor
    And(a=instruction[15], b=instruction[5], out=loadA); //if instruction is C, store outM to A registor
    Or(a=opcodeOut, b=loadA, out=aRegistorLoad);
    //if opcode is 0 (== A instruction) -> opcodeOut = 1 -> load = 1
    Register(in=leftMuxOut, load=aRegistorLoad, out=aRegistorOut);

1.3 D registor

이번에는 D registor를 구현해보자. D 레지스터는 A명령어로 입력하지는 못하고, C 명령어의 ddd 값에 따라서 대입하도록 되어있었다. 그러면 D 레지스터에 입력하는 경우는 어떤 경우가 있었나?

 위 표를 보면 2번째 d비트가 1일때만 D 레지스터에 입력하도록 되어있었다. 그러니까 A D M 순서니까 instruction[5], instruction[4], instruction[3] 순이 되겠다. 근데 지금보니까 d의 첫번째 비트가 1인 경우에도 A 레지스터에 값을 저장하도록 하고 있다. 그러니까 A 명령어인 경우 외에도 instruction[5] == 1일때도 A 레지스터의 load = 1이 되도록 해줘야 하는거같다. 일단 처음에 쓴 부분 뒤에다가 추가로 표기해놔야겠다.

1. in 입력 : D Registor는 ALU의 연산 결과를 담을수 있으므로 outM을 연결해주면 될거같은데, outM은 외부로 나가므로 루프할수 없으니 outMLoop 라는 루프 출력을 만들어서 in에다가 넣자.

2. c 입력 : 앞서 설명한것 처럼 명령어가 C 명령어이고 5번째 비트가 1일때 c에 넣도록 구현하자.

3. 출력 : A 레지스터때 처럼 dRegistorOut 정도로만 하자.

    //D registor PARTS
    And(a=instruction[15], b=instruction[4], out=loadD); //if instruction is C and dest is d, store outM to A registor
    Register(in=outMLoop, load=loadD, out=dRegistorOut);

이제 PC, A, D, 레지스터는 전부 구현했고, ALU 하기전에 먹스부터 정리해보자.

1.4 좌측 MUX16(한참 삽질하여 뒤에 다시 정리함)

 일단 좌측 먹스부터 생해보자. 왼쪽 먹스의 경우에는 a 자리에 ALU의 출력 outM, 이건 루프가 안되니 D 레지스터의 입력으로한 outMLoop를 사용하고, b 자리에는 instruction을 그대로 넣어주면 될거같다. MUX16은 sel이 0일때 a, 1 일때 b를 내보냈었는데 평소에는 A 레지스터에 A 명령어를 넣고, 아니다 C instruction[5]가 1일때만 outM을 A 레지스터에 넣었으니 이걸 sel 기준으로 잡으면 될거같다.

 먹스는 sel이 0일때 a를 출력으로 하지만, C instruction[5] == 1일때 A레지스터에 저장해야하니 Not(C instruction[5]) 한것을 sel에 넣어야 alu의 출력이 A 레지스터로 넣어지고, C instruction[5]가 0이라면 not 연산으로 sel에 들어가는 값이 1이되고 instruction이 A 레지스터로 전달 되겠다.

 잠깐 A 레지스터는 값과 주소를 저장한다 했는데, 값은 지금까지 한걸보면 A 명령어와 C 명령어의 목적지에 따라 ALU의 결과를 값으로 넣어주도록 했다. 하지만 C 명령어인데 instruction[5]가 아닌 경우는 A registor에 넣어도 되는건지 햇갈리기 시작했다. 

 지난번에 ALU, PC 구현할때는 완벽하게 동작을 이해하지 않더라도 표만 보고, 동작 조건만 따라서 연결만 해줬어도 어떤 흐름인지 따라가지는 못하지만 원하는 동작을 하기는 했었다. 지금도 A 레지스터에 먹스 a를 넣는 조건을 찾았으니 전처럼  해야할까? 그냥 그랬다가는 나중에 놓친 부분이 있으면 엄청 해맬거같은데 고민된다.

 C 명령어가 (A=)가 아닐때 잠깐 곱셈 어셈블리어로 CPU 에뮬레이터를 보니

@1     //이때 A에는 1이 들어가고,    현재 1번지의 값은 20이다.

D=M   //그러면 M에는 20이 들어갈 것이고, A 레지스터는 명령어를 저장하는게 아니라 기존의 1을 유지해야한다.

D=M 연산한 결과 A 레지스터는 1로 그대로 유지되고 있고,

D의 값이 RAM[1]의 값으로 덮어씌워졌다.

아 지금 보니까 생각난게 이래서 A 레지스터의 load를 조절해줘야 되구나.

아까 수정한 A 레지스터에는 C 명령어이고, instruction[5]가 1인 경우에만 load=1이 되도록 했으니

어셈블리어에서 A=이 아닐때는 load에 0이들어가 기존 값을 유지하는게 된다.

그리고 위에 사진에는 @22에 노란줄이 되어있는데 이 명령어는 A 명령어이고, A 레지스터는 순차 논리 회로이므로 다음 클럭때 A는 22로 반영이 될거같다.

실제로 A 레지스터의 값이 22로 변했다. 

그런데 아직 ALU아 하단 입력 M/A가 20 그대로 유지되고 있다.

현재 22이니까 22이여야 하는데 안바뀐건 시간이 안지나서 그런걸까?

아니면 우측 먹스에서 inM이 들어와 아직까지는 아래에 20이 들어가는거같다.

8번 명령어는 값을 저장하는 A 명령어라 M이 반영이 안된건지

아 다시 처음부터 보니까 이해가 되는게

내가 그동안 노란줄을 현재 실행한 명령어로 오해하고 있었다. 실제로는 프로그램 카운터가 가리키는 주소라

다음에 실행하는 명령어인데도

다시 이 코드를 한번씩 실행하면

PC가 0일때 모두 0이지만, 0번 명령어를 실행하는 즉시 PC는 1, A에는 A 명령어를 통해 2가 저장된다. 

registor(load=1) out(t+1) = in(t) 이었으므로 아직 ALU의 M/A 입력이 0이고,

다음 클럭때(PC가 2를 가리킬때) 2를 출력하게 된다.

일단 오케이 아까보다는 PC니 A 레지스터 값 저장이니 더 이해된거같네

아까 햇갈렷던 A 레지스터의 값이 22인데 ALU에 반영안된 이유는

현재 실행한 명령어는 8번 명령어라 A에는 즉시 저장되었지만 출력이 아직 안되었기 때문이고

8번 시점에 M/A 입력이 20인건, 7번 시점에서는 A가 1이지만 우측 먹스에 의해서 inM이 전달되서 그런거같다.

좌측 먹스를 정리하면서 좀 많이 해매버렸는데, A에 A 명령어든 C 명령어 연산 결과를 저장하든 말든간에 우측 먹스에 의해서 alu 아래 단자 값이 정해지니 이게 중요한거같다.

먹스 하나가 내용 정리하는데 어쩌다 보니 다른 회로 합친거보다 길어졌다.

잠깐만 다시 정리하자

outMLoop와 instruction을 A 레지스터로 저장 조건과 전달 조건

A 레지스터 저장 조건

1. 명령어가 A레지스터인 경우 - instruction을 저장한다.

2. 명령어가 C 명령어이고, instruction[5] = 1인 경우 - outMLoop를 저장한다.

A 레지스터 전달 조건

1. 명령어가 A레지스터인 경우 - instruction을 저장한다.

 -> 좌측 먹스로 명령어를 전달한다.

2. 명령어가 C 명령어이고, instruction[5] = 1인 경우 - outMLoop를 저장한다.

 -> 좌측 먹스로 outMLoop를 전달한다.

3. 그외 경우 : C 명령어이나 instruction[5] = 0인 경우

 -> 저장 하지 않아 기존의 저장된 값을 출력하므로 무관하다.

 그러므로 ((instruction[5] == 1) && (instruction[15] == 1)) ==1일때만 outMLoop를 A 레지스터로 전달하도록 하고

그외는 명령어를 전달하자.

그러면 이제 좌측 먹스 구현 조건을 다 정리된거같다.

    //left Mux16
    And(a=instruction[5], b=instruction[15], out=isOutMLoop)
    Mux16(a=instruction, b=outMLoop, sel=isOutMLoop);

하.. 오늘 안에 다 구현할수 있을줄 알았는데

밤에 좀 자고 너무 놀아서 결국에 5장도 마무리 못했다.

매 챕터가 다 금방 끝낼거같아보이긴 한데 막상 하면 막히는 부분에서 한참 해매니까 하루에는 못끝내고 못해도 이틀은 걸린다 ㅜㅜ 내일은 마무리해야지

오늘 새벽에 4장 어샘블리어 구현 마무리하고

잠을 너무 늦게자서 피곤하긴한데

오늘 안에 5장을 끝낼수 있을지는 모르겠다.

범용 목적 컴퓨터와 단일 목적 컴퓨터 

일단 이번 장에서는 

1-3장에서 만든 렘, 프로그램 카운터, ALU, 레지스터 등을 가지고

CPU와 컴퓨터를 만드는게 목표이다.

책에서 말하기를 여기서 만드는게 범용 목적 컴퓨터라 하는데,

초등학생 때 컴활 준비했을때였던가

정처기 준비할때였던가. 

그때 범용 목적 컴퓨터가 무엇인지에 대해 잘 몰랐는데,

뒤에 또 말할거지만

범용 목적 컴퓨터는 우리가 사용하는 PC나 휴대폰처럼 게임이든, 인터넷이든, 음악이든 하나의 목적이 아닌 다양한 용도로 사용할수 있는 컴퓨터를 말하며,

 범용 목적 컴퓨터 외 다른 분류로 특수 목적/단일 목적 컴퓨터가 있다.

단일 목적 컴퓨터의 경우 처음 이 단어를 보는 사람에게는 막연할거같은데 나도 그랬었고,

 우리 주위를 보면 신호등, 엘리베이터, 밥솥, 냉장고 등 다양한 기계, 전자장치들이 존재한다.

아직 시퀀스에 대해서 잘 아는건 아니지만 이런 기계 중에서는 엘리베이터나 자동 수양장치, 자기 유지 회로 등 프로세서없이 만들어서 사용할 수 있는 시퀀스 시스템도 있고, 

 아날로그 시퀀스 만으로는 구현하기는 어려워 프로세서를 이용한 디지털 시스템이 있는데 우리가 사용하는 PC나 휴대폰 외에도 TV나 밥솥, 냉장고도 내부에 프로세서가 들어가 있고 프로그래밍을 하여 사람이 쉽게 사용할수 있고, 원하는 동작을 하도록 되어있다.

 이런 냉장고, 식기세척기, 밥솥 등과 같이 아날로그 회로만으로는 구현하기 어려워 사용한 프로세서를 특수 목적/단일 목적 컴퓨터라 하며, 단일 목적 컴퓨터는 PC같은 범용 목적 컴퓨터와는 다르게 밥솥은 밥솥역활만 하도록, 냉장고는 냉장고 역활만 하도록 특정 용도에 한정한 컴퓨터를 의미한다.

 범용 목적 컴퓨터와 차이점이라면 다양한 작업을 할 필요가 없으니 계산 성능이나 메모리 공간, 주변 장치등이 범용 목적 컴퓨터에 비해 적이며 저렴하다는 점이다.

 정도로 이해하고 있는데, 당장은 이 정도만 이해해도 답답하거나 막히는 일은 없었다.

외장 프로그램 방식과 내장 프로그램 방식

 컴퓨터 구조를 공부하다 나오면 자주 보는 폰 노이만 구조니 하버드 구조랑 더불어 내장 프로그램 방식이란 단어를 종종 보곤 했었다. 그런데 처음 컴퓨터를 공부 할때는 당연히 프로그램은 컴퓨터 안에 있으니까 원래 내장된거 아닌가? 왜 내장 프로그램이라는 용어가 나온건지 잘 이해가 되지를 않았었다.

 전기랑 디지털 논리 회로를 배우면서 동기 카운터를 만들고, 난드투 태트리스에서 ALU, 램 만들면서 이전보다는 좀 더 와닿았는게, 특히 직접 만든 ALU를 시뮬레이터로 테스트를 할때/기계어 어셈블리어 작성한걸 돌리면서 상태 비트 레지스터/C명령어에 따라 +1 연산하기도 -1 연산하기도하고 D+A M+D 든 연산을 하는걸 봤었다.

 지난 장에서는 어셈블리어로 곱셈기 프로그램을 짜서 CPU 에뮬레이터로 돌렸었는데, 그 때는 직접 만든 바이너리 코드를 ROM에다가 저장해서 돌린덕에 PC로 지정한 명령어 실행하고, 그다음 명령어 가져와서 ALU에 넣어 실행하고를 반복했었다.

 하지만 이런식으로 프로그램을 기억장치에 넣어서 사용하기 전에는 직접 프로세서가 원하는 동작을 하도록, 원하는 값을 넣을 수 있도록 하드웨어를 조작(선을 뺏다 꽂앗다)하여 만들었으며 이를 하드웨어로 프로그래밍 하는 방식을 외장 프로그램 방식이라 하더라.

 잠깐 찾아보니 최초의 전자식 컴퓨터인 애니악이 이런 외장 프로그래밍 방식이라 한다. 디지털 논리회로를 지금 만큼 모르고 애니악이 최초의 컴퓨터니 에드박이니 하는걸 들을때는 그냥 연도 외우는 문젠갑다 싶어 억지로 외웠었는데 애니악과 우리가 현재 쓰는 컴퓨터가 이런 차이가 있다더라. 

 당장에 FPGA로 앞서 만든 ALU를 구현한다 하더라도 입력 두개나 상태 입력 비트에다가 +1, -1, +M, 0, not 연산을 하도록 전선을 일일이 연결해서 전원을 줬다면 얼마나 어려웠을까?

하드웨어를 이용한 동작 구현과 소프트웨어를 이용한 동작 구현

 그리고 내장 프로그래밍 방식의 장점은 간단한 명령어들을 합쳐서 복잡한 명령어를 구현할 수 있다는 점이다. 가장 최근에 본 예시로 곱셈 연산일거같은데, 위의 ALU 제어 테이블이나 HACK의 어셈블리어 명령어 테이블을 봐도 하드웨어적으로는 곱셈 연산을 만든 적이 없고, 덧셈 뺄샘 그리고 논리 현산 몇개 뿐이다. 

 그런데 어떻게 곱셈 연산을 해냈던가? sum = D+M 연산을 D 횟수 만큼 하도록 루프를 돌면서 곱셈한것과 동일한 결과가 나오도록 어셈블리어를 만들었다. 거기다가 명령어 테이블에도 없던 입출력 제어도 ROM에다가 넣어둔 어셈블리어로 할수 있었다. 명령어 테이블에 없는 동작을 어셈블리어, 그러니까 소프트웨어 적으로 구현했는데 하드웨어로 구현할수 없을까?

 잠깐 찾아보면 곱셈이나 나눗셈도 논리 곱셈기, 논리 나눗셈기가 나오는데 직접 하드웨어로 구현할수가 있다. 그런데도 사용하고자 하는 모든 연산을 하드웨어적으로 구현안하는 이유가 ALU로 원하는 모든 연산을 할수 있도록 각 연산들을 하드웨어로 구현해 짚어넣으면 하드웨어로 구현하기 힘든 연산도 있을 것이고, 그 만큼 비용도 비싸지고, 크기도 커진다.

 하지만 곱샘 연산 구현때와 같이 ALU에서 제공하는 단순한 연산들로 소프트웨어 적으로 구현하는 것이 하드웨어로 구현하는것 보다 쉽고, 프로세서가 커질 필요도 없으며 소모하는 비용도 늘진 않는다. 지금 당장은 이정도로 이해하고 있고, 이게 RISC와 CISC의 차이인거 같은데 뒤에 또 보자

컴퓨터 구조 : 튜링 머신과 폰 노이만 구조

아 내장 프로그램 생각 정리하다가

외장 프로그램으로 넘어가고, RISC CISC 얘기까지 가버렸는데,

결국에는 이 내장 프로그램 방식이 대표적인 컴퓨터 모델인 튜링 머신이나 폰 노이만 구조같은 컴퓨터 구조의 핵심이 된다.

 튜링 머신은 컴퓨터 공부하면서 몇번 들어봤지만 자주 까먹던 개념인데, 실제 물리적인 컴퓨터는 아니고 어떻게 프로그램을 읽고 처리할지 판단하는 추상적인 개념의 컴퓨터라 한다(만든 것도 있긴한데).

 잠깐 나무 위키를 봤는데 (위 그림과는 조금 다르지만) 튜링머신은 테이프, 헤드, 상태 기록기, 행동표 등으로 구성되어있다고 한다. 지금 하는거와 빗댄다면 테이프는 기억 장치, 메모리 역활, 헤드는 어드레스 레지스터 역할, 상태 기록기는 상태 레지스터 쯤 되는거 같고, 행동표는 행동을 지시한다니까 프로그램 카운터쯤? 비슷한게 아닌가 싶기도 하다.

 결국에는 헤드를 통해 테이프의 값을 읽거나 쓸수 있다는 점에서 튜링 머신도 내장 프로그램 방식이라고 하는거같다.

 폰노이만 구조는 지난번에 하버드 구조와 같이 정리했던거 같은데, 내장 프로그램 방식인 만큼 메모리가 내장 되어있으며, 하버드 구조(데이터 메모리와 명령어 메모리가 다른 버스를 이용)와는 다르게 데이터 메모리와 명령어 메모리가 같은 버스를 통해서 CPU에서 읽고 썻었던게 특징이었다.

메모리

 아무튼 우리가 만든 컴퓨터 HACK은 계속 봤지만 데이터 메모리 RAM과 명령어 메모리 ROM 두개로 나눠져 있으며 어드레스 레지스터 A를 이용하여 데이터 메모리의 값 M == RAM[A] 에 접근하기도 했었다. 근데 아직도 잘 이해안가는 건 어드레스 레지스터 A가 명령어 메모리의 현재 명령을 가리키고 있다고 하는데,

12: @23

13: D=A

위 연산에서 어드레스 레지스터 A는 23이란 값을 저장하고 있지, D=A란 연산의 주소를 가지고 있지는 않았던거같다.

다음에 실행할 거긴 하지만 명령어의 주소를 가지고 있는건 프로그램 카운터가 아니었나?

어드레스 레지스터 A가 어떻게 명령어 메모리의 명령어 주소를 가리키는가?

아 어셈블리어 천천히 돌리고 나서야 이해가 된다.

위 사진을 보면 지금 ROM의 16번지에서 A레지스터에다가 0을 담고

17번 명령어에는 RAM[0]의 값을 데이터 레지스터에 넣도록 하고 있다.

그런데 그 다음 줄을 보면 A 명령어와 C명령어로

@22

D; JEQ

가 있는데,

이 명령어를 진행하면 @22라는 A 명령어에 의해 A 레지스터에 22가 담기게 되고,

D에 있는 값에 따라 ROM의 22번지로 점프하게 된다.

그러니까 여기서 어드레스 레지스터 A는 점프해서 갈 명령어의 주소를 가리키고 있다.

해당 부분의 실제 어셈블리 코드는

@R0
D=M
@END
D;JEQ

인데 어셈블리어에서 작성한 @END가 어셈블리로인해 @22가 된후 기계어로 되어 롬에 올라갔고,

어드레스 레지스터에 담겨져 주소 역활을 한게 되었다.

이제야 이해된다!

그래서 어드레스 레지스터 A가

데이터의 주소, 명령어의 주소, 임시 데이터 보관 역활을 하는건가보다.

CPU

앞에서 메모리니, 어셈블리어니, 명령어니 계속 정리해왔는데, 이제 CPU를 다룰 차례가 되었다. 계속 공부해왔지만 구현했던 ALU, 레지스터, 제어기 등으로 구성되어 있다.

ALU : 이름 그대로 산술 논리 연산하는 장치이며, 구현되지 않은 기능은 하드웨어로 구현해도되고 소프트웨어로 구현해도되며 비용이나 성능, 효율성을 고려해서 설계된다.

레지스터 : 레지스터는 CPU 안에 있는 작지만 고속의 기억 장치인데 CPU가 아주 빠르게 동작하다보니, 기억 장치 CPU 밖에 있는 메모리라 한다면 메모리에 값을 잠깐 저장한다거나 원하는 값이든 명령어든 가져 오려고 하면 CPU의 작업 속도에 비해 오랜 시간이 걸려 일을 못하고 지연되는데 이를 stavation 기아 상태라고 한다. 이런 기아 상태를 방지하고, 계산 속도를 늘리기 위해 CPU 내부에 작지만 고속으로 읽고 쓰기가 가능한 기억 장치를 둔 걸 레지스터라고 한다. 일반 컴퓨터에서는 레지스터가 많이 존재하지만 우리가 만들 HACK에는 어드레스 레지스터, 데이터 레지스터 그리고 프로그램 카운터 3개 뿐이다.

제어 : 어셈블리어를 보면 알수 있지만 명령어들은 ALU에 입력으로 쓰거나, 메모리에서 가져오거나, 레지스터에 잠깐 저장하는 등 각 하드웨어 장치에 읽고/쓰기 등의 동작들 중에서 어떤 동작을 프로그램 실행중에 할지를 의미한다.

가져오기 및 실행 : fetch-execute를 가져오기 및 실행이라 적었는데, 대강 의미는 맞으니까 CPU의 과정은 명령어를 가져오고 실행하기의 반복이라 할수 있을거 같다. 에뮬레이터에서 봤지만 CPU는 프로그램이 실행되는 동안 각 사이클(클럭 마다) 명령어 메모리 ROM에서 실행할 명령어(에뮬레이터상에서는 어셈블리어지만 실제로는 이진 기계어)를 가져오게 되고 C 명령어의 c 비트에 따라 어떤 동작을 할지 해석(판단)하여 그 동작을 실행/수행 execute한다. 그래서 이 과정을 fetch-execute 사이클이라고 부르나보다.

입출력 장치

 지난 장에서 설명한거지만 컴퓨터 주변장치인 키보드와 화면을 memory mapped i/o 방식으로 ram 상에 화면과 키보드의 메모리맵에 접근해서 값을 읽거나 써왔다. 이런식으로 입출력 장치를 제어하는 이유는 실제 컴퓨터 주변 장치로 키보드, 화면 뿐만 아니라 마우스, 카메라도 있을 것이고, 프린트나 다른 센서 등 수 많은 장치들이 있다. 하지만 이런 장치들 각각을 어떻게 컴퓨터와 연결해서 사용할까 각 장치가 어떤지 다 알아야할까?

 그런 번거로움을 줄이기 위해서 각 장치들의 메모리 맵을 RAM의 영역에 배당하여 해당 매모리맵 영역에 접근함으로서 주변장치들을 사용가능하도록 약속한게 memory mapped i/o 방식이고 이덕분에 지난 과제에서 간편하게 스크린과 화면을 제어할수가 있었다.

 오늘 새벽에 그 과제를 하면서 너무 피곤하기도 하고 시간이 늦어서 제대로 설명하지는 않았지만, 클럭 사이클마다 각 주변장치의 매모리맵을 보고 (ex. 키보드 입력이 들어오면 화면에 검은칠을 하라)원하는 동작을 하도록 처리하다보니 사람이 보기에는 알아차릴수 없을 만큼 빠르게 반영된다.

 그리고 화면은 2차원 배열 형태로 되어있는데, 메모리는 1차원 주소로 접근 했었다. 그런데도 입출력 메모리 맵핑 방식으로 스크린에 접근할수 있었던건 스크린의 2차원 주소를 1차원으로 직렬화를 했기 때문이다. 일일히 적기는 번거로워서 안했지만 1차원으로 변형한 주소를 이용해서 스크린의 모든 픽셀에(정확히는 각 픽셀들을 담은 레지스터에) 접근할수 있었다.

 입출력 매모리 맵핑 방식을 사용하기로 약속/표준화 하여 컴퓨터든 주변장치든 서로 상관없이 만들더라도 이런 약속을 지킨 덕분에 주변 장치의 매모리 맵을 할당하고 사용할수 있게 되었다고 이해하면 될거같다.

 주변장치 인스톨러 : 그래서인가 예전에 카메라든 프린터든 새로사서 컴퓨터에서 쓰려면 그런 장치를 쓸수 있도록 설치 프로그램을 돌렸는데, 이런 설치 프로그램을 설치하면서 컴퓨터가 새 장치의  메모리 맵과 베이스 주소를 가져서 사용할수 있게 되는거고

 디바이스 드라이버 : 리눅스를 공부하면서 보게되는 디바이스 드라이버도 이것도 인스톨러와 해당 입출력 장치의 메모리맵을 설정하고 물리적인 주변장치에서 값을 어떻게 가져올지를 정리하는 프로그램이라고 한다.

이제 이번장 이론 마지막으로 HACK 컴퓨터의 구성 요소들을 간단하게 보고 과제를 좀 해야겠다.

그래도 이번 장은 생각보다 빨리 정리 끝낼거같네.. 과제가 얼마나 걸릴지는 모르겠지만 ㅋㅋㅋㅋㅋㅋㅋㅋ

HACK 컴퓨터

 HACK 컴퓨터는 확장자명을 hack으로 하는 기계어 프로그램을 동작시키는 16비트의 폰 노이만 구조의 컴퓨터다. 데이터 메모리인 RAM과 명령여 메모리인 ROM이 컴퓨터에 내장되며 같은 버스, 어드레스 레지스터 A로 접근해서 값 혹은 주소를 읽고 썻었다.

CPU

1) 입력

- inM은 이름 그대로 데이터 메모리에서 가져오는 값

- instruction인 A 명령어 혹인 C명령어로 A 명령어일때는 A=값,  C명령어일땐 명령을 수행 or A/D/M 레지스터 중 지정된 곳에 저장(C 명령어의 목적지가 M이면 writeM은 쓰기 명령을 위해 1이되고, 그렇지 않으면 0이된다. 결과는 outM)

- reset이 0이면 다음 명령을 하지만 1이되면 프로그램 카운터가 0을 가리킨다.

* 주의사항 : 출력 outM과 writeM은 조합 논리회로로 구현되서 명령어 실행 즉시 반영된다!

                출력 addressM과 pc은 순차 논리회로로 구현되어 다음 타임 스탭, 클럭에서 반영된다.

명령어 메모리

 ROM32K이기도 하며, 0000 0000 0000 0000 ~ 0111 1111 1111 1111 2^15(32K)만큼 접근할수 있고, 한 레지스터가 16비트로 이뤄지다보니 출력은 16비트 크기를 갖는다. ROM이다 보니 어드레스로 접근은 해도 쓰기 작업은 없어 in이나 load 단자는 없다.

입출력 장치

 화면과 키보드는 데이터 메모리 RAM에 매핑되어 사용되고, 클럭마다 반영되는데 이 장치들의 매모리 맵을 별도의 빌트인 칩인 Screen과 Keyboard으로 다룬다고 한다. 이것들이 따로 있다는건지 아니면, 램 상에 들어있는걸 칩이라고 부르는지는 잘 이해는 안되지만 일단은 좀 더보자

 화면 메모리 맵 : 쓰기 작업을 하다보니 전에 구현한 RAM과 비슷하게 address와 load 입력을 받는다. 차이라면 스크린 공간이 8K다보니 주소가 13비트 입력으로 되어있다.

 키보드 메모리 맵 : 키보드 베이스 어드레스의 위치에 있는 레지스터 하나의 값으로 키보드 입력을 나타내다보니, 입력 값이나 주소가 필요없고, 16비트 출력만 내보낸다.

데이터 메모리 RAM

 앞서서 스크린과 키보드를 칩으로 나타내고 있으니까 순간 혼동했는데 RAM4K, RAM16K를 구현할 떄 처럼 저만 스크린, 키보드 칩은 그냥 저 크기를 가지는 주변장치의 입출력을 저장하는 기억장치였다. 이 주변장치들이 RAM 안에 포함되어 있어서 16K와 합친다고 별도의 칩으로 표현해놓은 것이고, 결국에는 RAM = RAM16K + 스크린(RAM8K) + 키보드(레지스터, 읽기전용) 하여 데이터 메모리를 구현하나보다.

컴퓨터

드디여 난드 투 테트리스의 마지막 하드웨어인 컴퓨터를 구현할 차례다. 프로그램을 어떻게 집어 넣는지는 아직 잘은 모르겠지만 앞서 만든 CPU와 RAM, ROM을 잘 조합한게 컴퓨터이고, 이 컴퓨터는 reset 입력만 받는다. 0일때는 그대로 프로그램 카운터 진행되는데로 연산하지만 reset 1이 되었다가 0이되면 프로그램 카운터가 0이되어 다시 시작한다. 

와 벌써 하드웨어 마지막 과제라니 내가 이걸 주말부터만들기 시작해서 이제서야 5장까지 왔다.

책 페이지로는 1/3 조금 넘게 밖에 못온게 너무 충격이긴한데,

디지털 논리회로만 넘기면 나머지는 쉬울줄 알앗지만 장난아니었다.

2년전에 ALU하다가 포기하기도 했었고

이번에 다시하면서 처음에 논리회로 만들때만 해도 포기하고 싶었는데 계속 하다보니까 컴퓨터 구현까지

생각보다 많이 왔다.

근데 이속도로 어셈블러, 가상머신, 컴파일러, 고급언어, 운영체제까지 하려면 다음주까지는 걸릴것같네 ...

되게 유익하기는 한데 시간 엄청 잡아먹고 있긴하다.

아무튼 이론 글은 여기까지 하고

과제 하는거보고 다음 글을 써야겠다.

아아 진짜 오늘 너무 바보짓했다 ㅠㅜ

기계어/어셈블리어 파트 이론 마무리하고 과제하는데

이번 장의 과제가 어셈블리어로 곱셈 연산과

키보드, 화면 입출력 어셈블리어로 구현하는 예제인데

곱샘 연산 구현하는데만 4~5시간은 낭비해버리고 말았다.

// This file is part of www.nand2tetris.org
// and the book "The Elements of Computing Systems"
// by Nisan and Schocken, MIT Press.
// File name: projects/04/mult/Mult.tst

load Mult.asm,
output-file Mult.out,
compare-to Mult.cmp,
output-list RAM[0]%D2.6.2 RAM[1]%D2.6.2 RAM[2]%D2.6.2;

set RAM[0] 0,   // Set test arguments
set RAM[1] 0,
set RAM[2] -1;  // Test that program initialized product to 0
repeat 20 {
  ticktock;
}
set RAM[0] 0,   // Restore arguments in case program used them as loop counter
set RAM[1] 0,
output;

set PC 0,
set RAM[0] 1,   // Set test arguments
set RAM[1] 0,
set RAM[2] -1;  // Ensure that program initialized product to 0
repeat 50 {
  ticktock;
}
set RAM[0] 1,   // Restore arguments in case program used them as loop counter
set RAM[1] 0,
output;

set PC 0,
set RAM[0] 0,   // Set test arguments
set RAM[1] 2,
set RAM[2] -1;  // Ensure that program initialized product to 0
repeat 80 {
  ticktock;
}
set RAM[0] 0,   // Restore arguments in case program used them as loop counter
set RAM[1] 2,
output;

set PC 0,
set RAM[0] 3,   // Set test arguments
set RAM[1] 1,
set RAM[2] -1;  // Ensure that program initialized product to 0
repeat 120 {
  ticktock;
}
set RAM[0] 3,   // Restore arguments in case program used them as loop counter
set RAM[1] 1,
output;

set PC 0,
set RAM[0] 2,   // Set test arguments
set RAM[1] 4,
set RAM[2] -1;  // Ensure that program initialized product to 0
repeat 150 {
  ticktock;
}
set RAM[0] 2,   // Restore arguments in case program used them as loop counter
set RAM[1] 4,
output;

set PC 0,
set RAM[0] 6,   // Set test arguments
set RAM[1] 7,
set RAM[2] -1;  // Ensure that program initialized product to 0
repeat 210 {
  ticktock;
}
set RAM[0] 6,   // Restore arguments in case program used them as loop counter
set RAM[1] 7,
output;

사용한 테스트 스크립트는 이건데

ALU로 M=M+D 연산이 가능한걸 잊어버리고,

+1연산으로 이중루프를 만들어 곱셈 연산을 구현하느라

클럭 루프를 너무 많이 돌아버렸고, 

앞에 작은 수를 다루는 경우는 문제 없었지만

마지막 6 * 7 예제에서 210회 클럭안에 수행해야하는데

M=M+D 연산으로 하면 금방할걸

+1연산으로 구현해 놓으니 210회 클럭안에 연산을 마치지 못해서 자꾸 에러뜨길래

이게 라인 수가 너무 많아서 그런갑다 싶어 라인 수를 줄이느라 시간낭비했다.

그러다가 갑자기 +1 안해도 되는게 생각나서 했더니 20분도 안걸리고 해결했다 ㅜㅜ

아아아아아ㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏㅏ

이거에서 해매지만 않았어도 진작에 입출력 제어 끝내고 다음 장으로 넘어갈텐데

곱셈 연산 해결한게 밤 11시 30분이라

입출력 헨들링까지 하고 글 정리하고 가면 좀 더 지나야 갈수있을거같다.

삽질하면서  HACK 어셈블리어 구현 연습한건 좋긴한데

이렇게 간단하게 할수있는걸 하루/4 시간을 낭비한게 너무 아깝긴하다 ㅜㅜ

마지막 Mult.asm이 마지막 구현 결과

gif 용량이 너무 커져서 0 곱셈 부분은 좀 자르고

활용한 CPU 에뮬레이터로 앞서 구현한 ALU와 메모리, 프로그램 카운터가 어떻게 동작하는지 알수 있다.

위에껀 너무 빠르니까

천천히 볼수있게 6 * 7부분만 캡처

두번째 과제로는

입출력 처리 어셈블리어 작성

1. 무한 루프를 돌며 키보드 입력을 받고, 입력되면 화면 전체를 꺼멓캐 한다.

2. 키를 놓으면 허옇게 하면된다.

이걸 어떻게 하냐

지난 글에 키보드, 스크린에 대해서 제대로 설명안했는데

각 입출력장치 메모리맵에다가 값을 읽고 써주면 될거같다.

키보드와 스크린은 어디있나 싶었는데

CPU 에뮬레이터에 상에 같이 있었다.

키보드 버튼을 누르면 키보드가 사용가능해져서

실제 키입력을 누르면 가상 머신에 반영되는거같다.

HACK 스크린

아무튼 HACK 컴퓨터의 스크린은

1. 256 x 512 = 2^8 * 2^9 = 2^17 = 131,072개의 픽셀을 가지고 있고

-> 레지스터가 16비트이고, 한비트가 한픽셀 값을 저장하니까 전체 픽셀을 16으로 나누면 8K의 RAM 공간이 사용된다.

ex) 131,072 / 16 = 2^17/2^4 = 2 ^ 13 = 8192 = 8K

 -> 전체 메모리 32K 중에 RAM이 16K니까, RAM 절반을 얘가 사용하네?

2. RAM의 16384번지에 있고, 이 베이스 주소는 SCREEN 이란 이름으로 미리 정의되어있다.

3. 보통 이미지 다룰때 처럼 베이스 번지가 0, 0을 나타낸다.

4. 이 화면은 그레이스케일이나 컬러가아닌 단순 흑백 화면으로 해당 픽셀에 1을 넣으면 검정, 0을 넣으면 흰색이된다.

5. RAM[SCREEN + row * 32 + col/16] : 1에서 말했듯이 레지스터에서 16개의 픽셀을 보관하고 있다보니, 픽셀 하나하나에 접근할수 없고, 접근하고자 하는 레지스터의 해당 픽셀 부분을 바꿔주면 될거같다.

스크린 예시1 ) 스크린 좌표 0,0 픽셀에다가 검정 표시하기

대강 스크린 베이스 레지스터에다가 1000 0000 0000 0000을 넣으면 될거같은데

A 명령어는 0부터 시작하고 값은 15비트밖에 못넣지 않았던가? 

아 다시 생각해보니까

A 명령어는 @SCREEN이니까 상관이 없네

그럼 1000 0000 0000 0000은 어떻게 만들어야 할지가 막막하다.

C명령어 테이블을 보면 C비트에다가 111010을 넣으면 -1이 나온다고 한다.

10진수 -1은   0000 0000 0000 0001에다가 2의 보수를 취해 구하면

-1 (10) = 1111 1111 1111 1111(2)이 된다.

우리가 구하고자 하는 값은 1000 0000 0000 0000이니

1. 어드레스 레지스터의 값은 2^15승이 최대이므로, A 명령어의 값에 2^16을 넣지 않고

2. 0111 1111 1111 1111를 컨트롤 비트로 -A든 -D든 해서

3. 목적지를 데이터 레지스터로 설정하여 담은 뒤

4. 스크린의 베이스 레지스터에다가 데이터 레지스터 값을 넣어보자

진짜 될진 모르겟네

0111 1111 1111 1111은

   1000 0000 0000 0000

-  0000 0000 0000 0001

2^16 - 1이므로 65,535가 된다.

@65535

D=-A

이걸 하려고 했지만 위 표를 보니 A 레지스터 최대값이 32767이라고 안돌아간다..

@32767
D=-A

으로 에뮬레이터에 돌려봤는데

데이터레지스터의 값을 2진수로 보니 내가 원했던 값이랑 거의 비슷하다?

그리고 왜 32767이 2^15 = 32768(10) = 0100 0000 0000 0000 이니까

32767의 1의보수 = 1011 1111 1111 1111이고

-32767 = 1100 0000 0000 0000 라 생각했지만

2진법 변환기에서 32767은 

0111 1111 1111 1111

32768이

1000 0000 0000 0000 이라고 한다.

오늘 곱샘연산에서 1/4나절 헛짓하고, 시간이 시간이라 그런가 잘 이해가 안된다

1 = 2^0

0000 0000 0000 0001

2 = 2^1

0000 0000 0000 0010

4 = 2^2

0000 0000 0000 0100

8 = 2^3

0000 0000 0000 1000

...

2^15

1000 0000 0000 000

하 이렇게 2진법을 쓰니까 이해가간다

2^0 = 1이 LSM이니 0에서 부터 시작해서 16비트의 MSB가 2^15 위치인데

2^15=32,768이고

A 명령어의 맨 앞비트만 사용 불가하니

최대 가능한 값은 0111 1111 1111 1111 = 32,768 -1 = 32,767이니까

위의 코드가 동작해서

-A 연산한 결과가

-32,767이 1000 0000 0000 0001이 나왔다!

내가 원하는 건 0, 0픽셀만 출력하면 되니

1000 0000 0000 0000으로 만들어주기 위해

-A 한 결과에다가 -1을 해주면 된다.

@32767
D=-A
@SCREEN
M=D-1

픽셀 하나만 찍다보니 뭐가 바뀌었나 싶긴한데 잘보면

화면 좌측 상단 쪽에 M=D-1 연산한 뒤에 아주 작은 검은점 하나 생겼다.

스크린 예시2 ) 첫째 행만 검은줄로 채우기

첫째 행만 검은줄을 채우기 위해 네 가지를 기억하면 될거같다.

1.  메모리 레지스터 하나당 16비트를 가지고 있어 16개의 픽셀 값을 표현한다.

2. 1111 1111 1111 1111은 -1이다.

3. 스크린의 열 길이가 512픽셀이니 512/16 = 32개의 픽셀에다가 -1을 채우면 된다.

4. @SCREEN 그러니까 스크린 베이스 어드레스는 16384이므로 16416번지까지 -1을 넣어주자

금방 할줄 알았는데 생각보다 머릴 좀 써야된다.

앞에서 어셈블리어 연습 많이 했다고 생각했는데 값을 넣었다 뺏다만 했지

값 + 1은 몰라도 주소 + 1은 안해서 어떻게 하나 고민했는데

ㅋㅋㅋ 진짜 이것도 결국에 검색해서 알았는데

꼭 A명령어 1번, C 명령어 1번 같은 식으로 할 필요가 없고,

A명령어 1번, C명령어 2번이든 여러번 하는게 가능했다.

A명령어

C명령어 각각 한번씩만 하면

도저히 RAM[A+1]에 접근할 방법이 생각이 안났는데

A=100일때, A=A+1을 시켜놔도

@3

M=D를 하려고하면 A의 값이 3으로 바뀌어져

아무리 생각해도 101번 번지에 담을수가 없었기 때문이다.

잠깐 찾아봤더니 이게 가능한거더라 .

@x
A=M+D
M=-1

이러면 나머지 문제도 금방 풀수 있을거같다.

@16416
D=A
@dest
M=D
@SCREEN
D=A
@cur_addr
M=D
    (LOOP)
@cur_addr
A=M
M=-1
@cur_addr
M=M+1
D=M
@dest
D=D-M
@LOOP
D;JLT
     (END)
@END

벌써 시간이 2시 넘었네 ;;

나머지는 얼른 대충 구현하고 가야겠다.

하도 앞에서 삽질을 많이 하는 바람에 

실제 과제는 금방 끝냈다.

두 번째 과제 : 어셈블리어로 키보드 스크린 입출력 제어 

1. 키보드 입력 받으면 화면 꺼멓게

2. 키보드 입력이 없으면 화면 허옇게

@INIT
0;JMP
     (INIT)
@SCREEN  //start screen addr
D=A
@cur_addr //cur screen addr
M=D
@8192      //total screen register num
D=A
@SCREEN
D=M+D
@end_addr // end screen addr
M=D
     (LOOP)
@KBD
D=M
@BLACK     // when key is pressed, val is greater than 0 
D;JGT
@WHITE
0;JMP
     (WHITE)
@cur_addr
D=M
@SCREEN
D=D-M
@LOOP
D;JEQ        // cur_addr ==screen  dont ram[cur_addr]=1 and  cur_addr -= -1
@cur_addr
A=M
M=0
@cur_addr
M=M-1
@LOOP
0;JMP
     (BLACK)
@cur_addr
D=M
@end_addr
D=D-M
@LOOP
D;JEQ         // cur_addr == end__addr dont ran[cur_addr]=-1 and cur_addr+1
@cur_addr
A=M
M=-1         // ram[cur_addr] = -1
@cur_addr
M=M+1      // cur_addr += 1
@LOOP
0;JMP

캡처한 gif는 너무 느려서 커지는 바람에 용량 줄인다고 반토막 냈다

동작은 잘되는데

하드웨어 시뮬레이션이라 그런가 클럭 속도 제한때문에 그런건지

아니면 내가 한번에 모든 픽셀을 바꿀줄 몰라서 그런걸까 

생각보다 반영되는게 좀 많이 느리다

새벽까지 하긴 해버렸지만 거의 이틀만에

난드투 테트리스 기계/어셈블리어 파트를 마무리했다 

대충 책보는거랑 정리하는거랑 걸리는 시간 차이가..

내일 5장 얼마나 진행할수 있을까 ㅋㅋㅋㅋㅋㅋ