devbelly

블로그 이사합니다.

devbelly — Thu, 30 Dec 2021 15:25:58 +0900

https://devbelly.github.io/

컴퓨터구조 ANSWER1

devbelly — Sat, 30 Oct 2021 22:53:54 +0900

answer: mflo $t0
answer: 000000 01000 01001 00000 00000 011000
answer: 000000 00000 00000 01010 00000 010010
answer: 3
answer: 1
answer:000000 10001 10010 01000 00000 100000
answer: sub $6 $4 $5
answer: 000000 00000 10000 01010 00100 000000
answer: 001101 01001 01011 1000 0000 0000 0000
answer: 001100 00000 01100 1111 1111 1111 1111 1111
answer: 001000 00000 01101 1111 1111 1111 1111
answer: True
answer: ori $t1, $0, -32768, (상수 field를 10진수로 표현해야한다)
answer: True
answer: lui $t1, -1,ori $t1, $0, -32768
answer: True
answer: 0x56780000 / answer: 001111 00000 01000 1111 1111 1111 1111
answer: 101011 00101 00100 0000 0000 0000 1000
answer: 100011 00101 00110 0000 0000 0000 1000, lw $6, 8($5)

answer:

lw $t0, 32($s3) #base register로부터 32비트 떨어져있으므로(4 byte x 8) 32라고 적어야 한다.
add $s1, $s2, $t0

answer: 000000 01001 00000 00000 00000 001000
answer: 000010 0000 0100 0000 0000 0000 0010 01 (상위 4비트는 PC의 4비트로 채우고 하위 2비트는 0으로 채운다)
answer: 000101 00011 00100 0000 0000 0000 0011

rs, rt의 위치가 assemble후에 바뀌지 않음을 유의하자.
answer: false, (-131071~131071)

answer:

Loop:    
    sll $t1, $s3, 2
    add $t1, $s6, $t1
    lw $t1, 0($t1)
    bne $t1, $s5, Exit
    addi $s3, $s3, 1
    j Loop
Exit: 
    jr $ra

answer:

addi $a0, $0, 10
addi $v0, $0, 1
syscall

28.

29.

30.

31.

32.

33.

34.

컴퓨터구조 TEST1

devbelly — Sat, 30 Oct 2021 22:53:47 +0900

1. 연산의 결과 (6)를 확인하기 위해 수행해야하는 명령어는?

2. mult $t0 t1를 2진수로 표현하라(단, fucnt 값은 24)

3. mflo $t2을 2진수로 표현하라(단, funct 값은 18)

Example

.text
.globl main
main:
    addi $t0, $0, 7
    addi $t1, $0, 2
    div $t0, $t1
    mflo $t2
    mfhi $t3

4. $t2에 저장된 값은?

5. $t3에 저장된 값은?

6. add $t0, $s1, $s2를 2진수로 표현하시오. (단, funct값은 32)

7. 다음 2진수를 어셈블리로 바꾸시오. 000000 00100 00101 00110 00000 100010(sub)

8. sll $10, $16, 4를 2진수로 표현하시오.(단, funct 값은 0)

9. ori $11, $9, 0x8000을 2진수로 표현하시오. (단, op 값은 13)

10. andi $12, $0, 0xffff를 2진수로 표현하시오.(단, op값은 12)

11. addi $13, $0, -1을 2진수로 표현하시오.(단, op값은 8)

addi $t1, $0, 0x8000

12. out-of-range error가 발생하는가 True/False로 대답하시오.

13. SPIM에 load되는 명령어를 쓰시오

ori $t1, $0, -32768

14. out-of-range error가 발생하는지 True/False로 대답하시오

15. SPIM에 load되는 명령어를 쓰시오.

addiu $t1, $0, 32768

16. out-of-range error가 발생하는지 True/False로 대답하시오

17. $t1 레지스터의 값이 0x12345678일 때, lui $t1 0x5678을 수행한 결과를 쓰시오.

17-2) lui $t0 0xffff를 2진수로 표현하시오. (op 값은 15)❌

18. sw $4, 8($5)을 2진수로 변환하라.(단 op 값은 43) ❌

19. 0x8ca60008을 disassemble 한 명령어를 적어라.

int g,h,A[100];
g = h + A[8];

g in $s1, h in $s2, base address of A in $s3

20. 위 코드를 어셈블리로 나타내라

21. jr $t1을 2진수로 나타내라.(단, funct 값은 8이다) ❌

.text 0x00400024
.globl main
main:
    nop
    j main

22. j main을 2진수로 변환하라. (단, op 값은 2)

    bne $3, $4, Else # 0x00400038
    add $s0, $s1, $s2
    j Exit
Else: sub $s0, $s1, $s2
Exit: add $s0, $s0, $s0

23. bne $3, $4, Else를 2진수로 변환하라.(단, op값은 5이다)

24. beq, bne명령어의 offset필드를 계산할 때 표현가능한 범위는 -32768~32767이다.

25. 다음의 코드를 assembly로 변환하라.(단, i in $s3, k in $s5, address of arr in $s6, arr is int array)

i = 1;
while (arr[i]==k) ++i;

26. Syscall을 이용하여 10을 출력하시오.

27. 다음 표를 완성하시오

Signal name	deasserted	asserted
RegDst
RegWrite
ALUSrc
PCSrc
MemRead
MemWrite
MemtoReg

28. 다음 표를 완성하시오

opcdoe	ALUOp
lw
sw
beq
R-type

29. 다음 표를 완성하시오

ALU function	ALU control
add
sub
and
or
slt

30. 빈 칸을 채우시오

31. 빈 칸을 채우시오

* 32. 빈 칸을 채우시오.*

33. 철수가 clock cycle을 정하기 위해 기준으로 해야하는 명령어는?

34. 다음 표를 완성하시오

컴퓨터구조 중간고사범위

devbelly — Sat, 30 Oct 2021 22:53:35 +0900

mult rs, rt / multu rs, rt / mfhi rd / mflo rd

rs 레지스터와 rt 레지스터의 곱셈을 수행한다. 연산의 결과 64비트를 저장하기 위해 hi, lo 레지스터를 사용하여 저장한다. hi와 lo의 값을 확인하기 위해 mfhi rd, mflo rd명령어를 사용한다.

곱셈의 결과는 오버플로우 체크를 하지 않는다. (프로그램에서 확인 가능)

div rs,rt / divu rs, rt

rs레지스터를 rt레지스터와 나눈다.

overflow와 divide-by-zero checking을 자체적으로 수행하지 않는다.
hi에는 remainder lo에는 quotient가 저장된다.

nor rd, rs, rt

rs 레지스터와 rt 레지스터를 or 한 후 not을 하여 rd 레지스터에 저장한다.

Example

.text
.globl main
main:
    addi $t1, $0, 0x3C00
    addi $t2, $0, 0x0DC0

    nor $t6, $t1, $t2
    nor $t7, $t1, $t1

0x3c00	0000 0000 0000 0000 0011 1100 0000 0000
0x0dc0	0000 0000 0000 0000 0000 1101 1100 0000
$t6	1111 1111 1111 1111 1100 0010 0011 1111

이러한 성질로 인하여 어셈블리에서는 not 연산을 필요로 하지 않는다. 예를 들어 $t1에 대해 not 연산이 필요하다면 아래와 같이 하면 된다.

1) nor $t6, $t1, $t1
2) nor $t6, $t1, $0

R-format

add rd, rs, rt / addu rd, rs, rt

rs 레지스터와 rt 레지스터를 더해 rd 레지스터에 해당 값을 저장한다. 어셈블리에서는 destination 레지스터를 먼저 적었지만 기계어에서는 0p rs rt rd shamt 32의 순서로 표현된다.

sll / srl

rt 레지스터의 값을 shamt만큼 shift를 하여 rd 레지스터에 저장한다. rs 레지스터는 0임을 주의하자.

I-format

ori

I-format
R[rt] = R[rs] | ZeroExtImm

andi

I-format
R[rt] = R[rs] & ZeroExtImm

addi

I-format
R[rt] = R[rs] + SignExtImm

ori, andi VS addi

프로세서의 ALU는 2개의 32비트를 입력받아 1개의 32비트 출력을 만들어 내는 장치입니다. I-format의 공간적인 한계로 인해 Imm필드는 16비트로 밖에 표현되지 못하여 ALU연산을 위해 Extension을 해야합니다. ori, andi와 같은 logical instruction은 ZeroExtension을 수행하고 addi와 같은 arithmetic instruction은 SignExtension을 하게 됩니다.

out-of-range error

어셈블리를 기계어로 바꾸는 과정에서 out-of-range error가 발생할 수 있습니다. 이때 아래의 두 원칙이 적용됩니다.

1. out-of-range error는 명령어의 종류에 따라 결정된다.

명령어의 종류가 arithmetic instruction(addi,addiu)일 때, 상수 operand에 signed number가 올것을 기대하여 -32768~32767범위를 벗어나게 되면 out-of-range error가 발생
명령어의 종류가 logical instruction(andi, ori)일 때, 상수 operand에 unsigned number가 올 것을 기대하여 0~65535범위를 벗어나게 되면 out-of-range error가 발생

2. 상수 operand는 10진수인지 16진수인지에 따라 signed, unsigned를 결정한다.

operand에 10진수를 적으면 signed number로 해석되고
operand에 16진수를 적으면 unsigned로 해석된다.

lui rt, imm

rt레지스터의 상위 16비트를 imm로 초기화한다
rt레지스터의 하위 16비트를 0으로 초기화한다

Pseudoinstruction , li

load immediate instruction, 기계어 명령은 아니지만 프로그래머의 편의를 위해 존재한다

li $10, 1 : 10번 레지스터에 1을 저장한다
위 명령어는 ori $10, $0, 1로 SPIM에 load 된다.

sw rt, offset(rs) / lw rt, offset(rs)

rt: destination (lw) or source (sw) register number
rs: base register number

Initializing Data Segment

Example 1

.data
.byte 1
.byte -2
.space 3
.byte 's'

Address	value
0x1001000	0x01
0x1001001	0xfe
0x1001002	0x00
0x1001003	0x00
0x1001004	0x00
0x1001005	0x73

**in c **

char arr[]={1,-2,0,0,0,'s'};

Example 2

.data 0x10020000
w1: .word 1
    .word -1
    .word 0xabcdef12
    .word 0xffff

.text
main: lui $5, 0x1002
      lui $4, 0x789a
      sw  $4, 8($5)

in c

int w1[4]={1,-1,0xabcdef12,0xffff};
int main(){
    w1[2]=0x789a0000;
}

.ascii VS .asciiz

.ascii와는 다르게 .asciiz는 추가적으로 맨 끝에 0을 저장한다.

str: .ascii "star"
str2: .asciiz "star"

in c

char str[]={'s','t','a','r'};
char str2[]={'s','t','a','r','\0'};

Big Endian vs Little Endian

Big Endian: 주소가 큰(big)쪽에 수의 마지막 부분을 적는다
Little Endian:주소가 작은(little)쪽에 수의 마지막 부분을 적는다.

Example

.data 0x10010000
.byte 1
.byte -2
.space 1
.byte 's'

Big Endian? 0x01fe0073

Little Endian? 0x7300fe01

word alignment

데이터를 저장하다가 4바이트에 해당하는 데이터를 저장할 때, 현재 비어있는 공간부터 데이터를 저장하는 것이 아니라 4의 배수에 해당하는 주소부터 새로이 데이터를 저장한다.

Example

.data 0x10010000
a:
    .byte 1
    .byte -2
w:
    .word 1

.text
.globl main
main:
    la $5, a
    la $6, w

결과는 다음과 같이 .word 1을 저장할 때 0x10000002,0x10000003 주소를 건너뛰고 0x10000004부터 저장함을 알 수 있습니다.

$5: 0x10000000
$6: 0x10000004

Memory Operand

Example

int g,h,A[100];
g = h + A[8];

g in $s1, h in $s2, base address of A in $s3

jr r

rs 레지스터에 적힌 주소로 branch를 한다. 다른 unconditional branch은 J-format인 반면 jr은 R-format이다.

Example

.text 0x00400024
.globl main
main:
    nop
    la $t1, main
    jr $t1

j L1 / jal L2

L1에 해당하는 Label로 branch를 한다. J-format을 사용. j와 jal의 차이점은 jal은 branch를 할 때, 추가적으로 현재 PC값의 다음 값을 $31레지스터에 저장한다.

target은 assemble과정에서 branch할 주소를 적어야하는데 26비트 밖에 할당할 수가 없다. 따라서 BTA를 계산하기 위한 특별한 방법을 적용해 32비트로 변환을 해야한다.

Example

.text 0x00400024
.globl main
main:
    nop
    j main

beq rs, rt, L1 / bne rs, rt, L1

rs레지스터와 rt레지스터를 비교하여 같거나(beq) 다르다면(bne) L1에 해당하는 Label로 branch를 한다. 두 개의 레지스터와 branch를 위한 immediate field를 사용하므로 L-format이다.

Example

    bne $3, $4, Else # 0x00400038
    add $s0, $s1, $s2
    j Exit
Else: sub $s0, $s1, $s2
Exit: add $s0, $s0, $s0

branch할 주소를 16비트로 밖에 표현을 못하므로 BTA를 계산을 따로 해야한다. 16비트에 B가 적힌다면 BTA는 B x 4 + PC가 된다. B x 4를 한 후 32비트인 PC와 덧셈을 하기 위해 Sign Extension을 하게 된다. Example에서 현재 PC값이 0x00400038일 때, 현재 PC와 Else 명령어 사이는 3칸의 차이가 있으므로 3 x 4 + PC를 하면 Else의 주소를 얻을 수 있다. 이러한 계산이 가능한 이유는 PC와 BTA가 서로 local하기 때문이다.

slt rd, rs, rt / slti rd, rs, constant

slt rd, rs, rt : if(R[rs]<R[rt]) R[rd]=1 else R[rd]=0;
slti rd, rs, constant: if(R[rs]<constant) R[rd]=1 else R[rd]=0;

slt 는 bne, beq와 함께 사용하기 위해서 존재한다. if (R[$s3]<R[$s4])와 같은 명령어는 아래와 같이 표현할 수 있다.

slt $1, $s3, $S4
bne $1, $0, Target

프로그래머의 편의를 위해 pseudo instruction인 blt를 제공하기도 한다. 즉, blt $s3, $s4, Target으로 표현 가능.

Addressing Mode Summary

1. Immediate addressing

instruction의 operand가 instruction에 직접 적혀 있는 것을 의미합니다. 예를 들어 addi $t0, $t1, 1에서 1은 Immediate addressing을 사용하고 있습니다.

2. Register addressing

operand가 register에 적혀 있는 것을 의미합니다. 예를 들어 addi $t0, $t1, 1에서 $t0은 register addressing을 사용하고 있습니다.

3. Base addressing

Target address가 Memory에 적혀 있는 것을 의미합니다. 해당 Memory의 주소를 계산하기 위해 base register이 가리키는 주소와 offset을 더해 Memory address를 구합니다. 예를 들어 sw $t1, 0($t2)은 operand에 t1값을 저장하기 위해 주소를 구해야 하는데, base register와 offset을 통해 해당 주소에 접근을 합니다.

4. PC-relative addressing

Target address가 Memory에 적혀 있는 것을 의미합니다. Base register을 직접 지정해준 base addressing 와는 달리 PC값을 통해 Target address에 접근합니다. beq, bne instruction이 이에 해당합니다.

5. Pseudodirect addressing

Target address가 거의 instruction에 적혀 있는 것을 의미합니다. 32비트의 주소를 완성하기 위해 address에 x4를 한 후, 상위 4비트를 PC값의 상위 4비트로 초기화합니다. J-format instruction에서 주로 사용합니다.

Procedure and Stack

Procedure은 함수를 의미합니다. 함수의 호출은 다음 단계를 따릅니다.

1) Register에 Parameter을 세팅한다. 주로 $a0-$a3 사용 (부족하면 Stack 사용)
2) Procedure로 Branch한다
3) Procedure을 위한 저장공간을 확보합니다.
4) Procedure 수행
5) 결과를 Register에 저장합니다. 주로 $v0-$v1 사용
6) Caller로 Branch합니다

System Call

OS에 구현된 function을 호출하는 것을 의미합니다. 인자 전달을 위해 $a0-$a3을 사용하고 함수의 행동을 정의하기 위해 $v0 레지스터를 사용합니다. 아래는 $v0에 따른 Syscall의 행동들을 정의한 것입니다.

Memory Layout

1. Reserved

0~0x0040 0000에 해당하는 영역. 비어있는 채로 둔다.

2. Text

Text Segment에 해당하는 부분을 의미한다. 프로그램 수행 코드가 담겨 있다

3. Static data

Data Segment중 하나. global 변수들을 저장한다. 이를 위해 $gp를 사용

4. Dynamic data

Data Segment중 하나. Heap이라고 부르며 새로 할당한 변수들을 저장하는 공간이다.

5. Stack

Data Segment 중 하나. local variable을 저장한다. 이를 위해 $sp 사용.

❗️ recursive procedure은 PDF 참고

https://www.youtube.com/watch?v=OL3qD2c0Db4

Translation and Startup

프로그램이 메모리에 로드되기 위해서는 아래의 과정을 따른다.

1) compiler가 user code를 assembly로 바꾼다
2) assembler가 assembly를 object module로 바꾼다. machine language에 해당한다.
3) 여러 object module과 미리 컴파일된 library를 Linker을 통해 Executable로 바꾼다. 이때 Executable은 secondary storage에 저장된다.
4) secondary storage에 저장된 executable을 Loader을 통해 memory에 load하여 프로그램을 수행한다.

Object Module

Object Module이 제공하는 정보는 다음과 같다.

Object file header: Object file의 다른 부분에 대한 정보(size, position)을 저장
Text segment: user가 작성한 code에 대한 부분
Static data segment: 프로그램이 수행되면서 계속 access 할수 있는 global variable을 저장한다.
Relocation information: executable이 메모리에 로드되어 수행될 때, 실제로 어디에 로드 되는지 알 수 없으므로 해당 위치에 따라 달라지는 정보를 저장
Symbol table: label의 주소를 저장

Object file Example

빨간색 네모는 object file header로 object file에 대한 정보들을 저장하고 있다.
Relocation information은 Text Segment중 Relocation이 필요한 주소를 저장하게 된다. lw은 0($gp)가 실제로 가리키는 주소를 Link 과정에는 알 수 없으므로 Relocation information에 저장을 하고, jal 또한 Text Segment의 B 레이블로 branch를 해야하지만 실제로 가리키는 주소를 Link 과정에는 알 수 없으므로 Relocation information에 저장하게 된다.

Executable file Example

Relocation information을 통해 주소들이 계산 되었음을 알 수 있습니다. (lw, jal)

Load Program

Executable file에는 memory address가 적혀있지만 실제 Loader가 메모리에 어느 부분에 로드할지는 알 수가 없다. 하지만 virtual memory를 사용하면 processor마다 각자의 address를 갖기 때문에 Executable에서 사용한 address를 그대로 사용할 수 있습니다. 즉 Relocation이 필요하지 않게 됩니다.

Static Link vs Dynamic Link

Static Link는 Executable에 Library Routine을 포함하는 것을 의미합니다. 이에 따라 단점이 존재하게 됩니다.

Executable의 size가 커질 수 있다.
Library가 업데이트 되면 다시 Link하는 과정이 필요하다.

Dynamic Link를 사용하면 위 문제점들을 해결할 수 있습니다.

Combinational Elements

현재의 입력만으로 출력을 만들어 낸다.

ALU는 다양한 연산을 사용할 수 있다. 연산의 종류를 결정하기 위해 control input을 사용한다.

이와 비슷하게 MUX 또한 출력을 결정하기 위해 control input을 사용한다.

State(Sequential) elements

현재의 입력과 이전의 입력으로 출력을 만들어 낸다

Register

clock signal에서 rising edge일때 input 데이터를 output에 저장한다. 걸리는 시간을 gate delay라고 한다. input이 변하더라도 clock signal이 rising edge가 아니라면 출력에 기록하지 않는다. write control이 표시되어 있지 않으면 항상 1이다.

Register with write control

clock signal이 rising edge일때 write control을 확인하여 input 데이터를 output에 저장한다. write control이 1일때 데이터를 저장한다.

이를 확장해 32bit register을 만들 수 있다.

Instruction memory

32비트의 주소를 읽어와 해당 주소에 적힌 instruction을 출력으로 보낸다. 매 cycle마다 출력으로 instruction을 보낸다. rising edge마다 값을 보내는 것이 아님에 유의하자. Control signal은 생략되어있다.

Data memory

Memwrite, Memread 에 따라 메모리에 데이터를 쓰거나 출력을 하게 된다. 둘 다 동시에 1이 될 수 는 없으나 0은 가능하다.

Memwrite가 1이라면 주소를 읽어와서 해당 주소에 Write data를 쓰게 된다.
Memread가 1이라면 읽어온 주소에 저장된 값을 출력으로 보낸다.

Register File

32비트 register가 32개 모여있는 것을 Register file이라고 한다.

Regwrite의 값이 1일 때만 레지스터에 값을 기록한다.
Regread는 항상 1이여서 clock cycle마다 값을 읽어 출력한다.

Control signal

Control signal은 조합회로로 만들 수 있다. instruction의 특정 필드를 input으로 하면 output을 얻을 수 있다. i-format, j-format은 opcode만 전달하고 r-format은 추가적으로 funct 값도 input으로 전달한다.

Example 1

1) instruction memory에서 instruction을 읽어온다.
2) $8, $9가 Read register에 쓰인다.
3) add 이므로 rd에 값이 쓰여야한다. RegDst가 1이 된다.
4) add이므로 두 개의 레지스터를 ALU에 전달해야한다. ALU의 두 번째 operand는 register의 두번째 read data이므로 ALUSrc는 0이 된다.
5) Register file의 Write data에 ALU result가 쓰여야 하므로 RegtoMem의 값이 0이된다.

Example 2

Read register에 rs필드를 읽어온다.
rt필드에 저장이 되어야하므로 RegDst 값은 0이 된다.
주소를 계산해야하므로 ALU의 두 번째 operand는 imm 필드가 되어야한다. ALUSrc는 1이 된다.
Memory에서 읽어온 값을 Register file의 Write data에 기록해야하므로 MemtoReg는 1이 된다.
주소계산을 위해 add를 사용해야므로 ALU control는 add를 의미하는 0010을 출력해야한다.
lw에서 ALUop값으로 00을 전달하고 이를 통해 0010을 만들어 낸다.

Example 3

두 개의 레지스터 값을 비교해야하므로 Read register 1,2 값을 읽는다.
ALU의 두 번째 operand는 레지스터로부터 오기 때문에 ALUSrc의 값은 0이 된다.
출력되는 Zero control signal에 따라 PC값을 결정한다.
branch instruction을 보고 적절한 ALUop값을 전달한다.

[디자인패턴] 인터페이스 분리 원칙(ISP)

devbelly — Wed, 27 Oct 2021 14:36:24 +0900

인터페이스 분리 원칙(ISP)

클라이언트는 자신이 이용하지 않는 메서드에 의존하지 않아야 한다는 원칙이다.

클라이언트는 자신이 사용하지 않는 메소드에 의존하도록 강제될 때, 인터페이스가 변경되면 클라이언트 또한 영향을 받기 마련이다. 이러한 결합을 낮추기 위해 거대한 인터페이스를 분리해서 사용할 수 있다.

세 개의 클라이언트에서 employee 를 사용하고 있는 모습입니다. 앞선 원칙들에 따라 employee에서의 변경이 모든 클라이언트들에게 영향을 미치므로 DIP원칙에 따라 인터페이스를 생성합니다. 즉 컴파일 의존성은 클라이언트들은 인터페이스로 이동하지만 런타임 의존성은 여전히 employee에 있습니다.

employee 의 변경이 클라이언트에 영향을 미치지 않지만 인터페이스가 변경이 된다면 클라이언트들은 여전히 영향을 받게 됩니다. 만일 methodForA() 에서 파라미터를 변경했다면 해당 메서드를 사용하지 않는 B와 C 또한 영향을 받게 됩니다. 이러한 상황에서 ISP를 통해 문제를 해결합니다.

클래스가 모든 클라이언트 고유의 인터페이스를 상속하고 그것을 구현함으로써 클라이언트간의 불필요한 의존성을 끊고 독립적으로 만들 수 있다. 인터페이스가 불가피하게 변경되어야한다면 직접 인터페이스를 변경하는 대신 새로운 인터페이스를 생성하도록 해 재컴파일과 재배포를 피할 수도 있다.

[디자인패턴] 의존 관계 역전 원칙(DIP)

devbelly — Wed, 27 Oct 2021 14:35:33 +0900

의존 관계 역전 원칙(DIP)

상위 수준의 모듈은 하위 수준의 모듈에 의존해서는 안된다. 둘 모두 추상화에 의존해야한다.

기존 절차지향적 프로그래밍에서는 상위수준의 모듈이 하위수준의 모듈에 의존하는 경향이 있었다. 이러한 의존성을 역전시켜 상위수준의 모듈이 하위수준의 모듈에 의존하지 않도록 하는 원칙이다. 의존성을 역전시키는 방법은 상위 모듈과 하위 모듈 둘 다 추상화에 의존하게 하는 것이다.

Abstraction vs Encapsulation

Abstraction과 Encapsulation의 관계는 상호보완적이라 볼 수 있다. Abstraction은 객체의 행동에 초점을 맞추어 공통적인 부분을 묶어낸 것이라면 Encapsulation은 이러한 행동을 뒷받침해주는 Implementation에 초점을 맞춘 것이다.

이에 따라 클래스를 구현할 때는 아래의 원칙을 지켜야 한다.

어떤 변수도 구체 클래스에 대한 포인터나 참조값을 가져선 안 된다.
어떤 클래스도 구체 클래스에서 파생되어서는 안 된다.
어떤 메소드도 그 기반 클래스에서 구현된 메소드를 오버라이드해서는 안된다.

Example

class Switch{
	private Light light;
    void activate(){
		light.turnOn();
    }
}

Switch 클래스를 통해 Light 클래스를 켜는 코드입니다. Switch와 Light 클래스만을 사용하는 경우를 한정하여서 코드의 재사용이 가능합니다. 결국 재사용이 불가능한 상태입니다. 문제가 발생한 원인은 상위 클래스가 직접적으로 Light라는 타입을 변수로 갖기 때문입니다. 이를 해결하기 위해 turnOn()이 가능한 것들을 추상화하여 사용해야합니다.

class Switch{
	Lightable light;
	void activate(){
		light.turnOn();
	}
}

직접적인 Light클래스에 의존하는 대신 Lightable이라는 추상화된 인터페이스에 의존하도록 변경했습니다. 상위 모듈이 하위모듈에 직접 의존하지 않으므로 DIP가 실현되었습니다.

[디자인패턴] 리스코프 치환 원칙(LSP)

devbelly — Wed, 27 Oct 2021 14:12:10 +0900

리스코프 치환 원칙(LSP)

서브타입은 그것의 기반타입으로 치환가능해야한다.

타입 S의 객체 o1과 타입 T의 객체 o2가 있을 때, T로 프로그램 P를 정의했음에도 불구하고 o2를 o1으로 치환할 때 P의 행위가 변하지 않으면, S는 T의 서브타입이다.

리스코프 치환 원칙(LSP)는 개발자가 서브 클래스를 작성하기 위한 원칙을 제공합니다. 아래 LSP를 위반한 원칙들을 통해 자세히 알아봅시다.

Example 1.

DrawShape() 함수를 살펴보면 OCP를 위반하고 있다는 것을 알 수 있다. DrawShape()는 메서드에서 사용할 모든 Shape의 서브 타입에 대해 알고 있어야 하기 때문이다. 만일 Triangle 타입을 추가하고 싶다면 소스코드의 변경없이는 확장이 불가능하다.

이는 Circle와 Square이 Shape를 상속하기는 하지만 Draw()함수를 오버라이드하지 않아 발생한 문제이다. 즉, Shape의 서브 타입을 일일이 검사하여 각 클래스가 무엇인지 파악한 후 그에 맞는 함수를 호출한다.

Example 2.

정사각형과 직사각형은 is-a관계로 표현될 수 있다. 정사각형은 직사각형이기 때문이다. 그래서 Rectangle 클래스를 상속하여 Square 클래스를 만드는 것은 문제가 되지 않을 것이라고 생각이 된다.

문제점 1

상속을 하고 보니 Square클래스에서는 사용하지 않는 함수들이 존재함을 알 수 있다. 예를 들어 SetHeight()나 SetWidth()를 둘 다 사용할 필요는 없다. 즉 퇴화함수가 발생하는데 이는 잠정적인 LSP 위반이다. 일단 이 문제를 메서드 오버라이딩을 사용하여 해결했다고 치자.

void Square :: setWidth(double w){
	Rectangle :: SetWidth(w);
	Rectangle :: SetHeight(w);
}

문제점 2

이제 프로그래머는 상속의 장점중 하나인 다형성을 활용하기 위해 다음의 함수를 작성했다.

void f(Rectangle& r){
	r.setWidth(32);
}

setWidth()가 virtual로 선언이 되어있지 않아 함수가 정적 바인딩이 된 상태이다. 이 상태에서는 Rectangle :: setWidth() 가 호출이 되므로 다형성을 제대로 실현하지 못하게 된다. 결국 부모 클래스의 코드를 직접 수정하는 상황이 발생하므로 OCP를 위반하는 상황이다. 이 문제 또한 코드를 수정하여 해결했다고 치자.

문제점 3

이제 Rectangle 클래스를 클라이언트에서 사용을 해보자. 해당 클래스를 가져와 다음 함수를 작성했다고 해보자.

void g(Rectangle& r){
	r.setWidth(10);
	r.setHeight(5);
}

클라이언트는 r의 넓이가 50이 될 것을 기대하지만 이는 r이 Square이라면 제대로 작동하지 않을 것이다. 왜 이러한 문제가 발생한걸까?

계약에 의한 설계

Design by Contract은 메소드의 사전조건과 사후조건을 선언하는 것으로 구체화된다. 사전조건과 사후조건에 대한 규칙은 다음과 같다.

하위형에서 선행조건은 강화될 수 없다.
하위형에서 후행조건은 약화될 수 없다.

위 사례에서는 후행조건이 약화되었다고 볼 수 있다. Rectangle :: setWidth(input)에서의 후행조건은 itsWidth==input && itsHeight==prevHeight 이지만 Square :: setWidth(input)에서는 itsHeight==prevHeight의 조건을 충족하지못하므로 후행조건이 약화되었다.

[디자인패턴] 개방 폐쇄 원칙(OCP)

devbelly — Wed, 27 Oct 2021 14:08:44 +0900

개방 폐쇄 원칙(OCP)

소프트웨어 개체(클래스, 모듈, 함수)는 확장에 대해 열려 있어야 하고, 수정에 대해서는 닫혀 있어야한다.

개방 폐쇄 원칙을 따르는 모듈은 다음과 같은 두 가지 속성을 갖는다.

1. 확장에 대해 열려 있다.

이것은 모듈의 행위가 확장될 수 있음을 의미한다. 요구사항이 변경될 때, 이 변경에 맞춰 새로운 행위를 추가해 모듈을 확장할 수 있다. 새로운 타입을 추가함으로써 새로운 기능을 추가하는 것과 같다.

2. 수정에 대해 닫혀 있다.

어떤 모듈을 확장하는 것은 소스코드나 바이너리 코드의 변경을 초래하지 않는다. 이는 확장이 일어날 때 상위 레벨이 영향을 받지 말아야 한다는 것이다.

HOW?

이는 모순된 것처럼 보인다. 어떻게 소스 코드를 변경하지 않고도 그 모듈의 행위를 바꾸는 일이 가능한걸까? 정답은 Abstraction을 통한 inversion에 있다.

Abstraction?

Abstraction is the process by which data and programs are defined with a representation similar in form to its meaning, while hiding away the implementation details.

추상화는 추상 기반 클래스이자, 모든 가능한 파생 클래스를 대표하는 가능한 행위의 묶음이기도 하다.상위 모듈을 고정된 추상화에 의존하면 상위 모듈은 수정에 대해 닫혀 있는 것이 가능하게 된다. 그리고 그 모듈의 행위는 추상화의 새 파생 클래스를 만듦으로써 확장에 대해서는 열려 있게 된다.

위 그림은 OCP를 위반한 예시이다. 만일 Client객체가 새로운 Server객체를 사용하도록 바꾸고 싶다면 Client 클래스를 수정하여 다른 Server클래스를 사용하도록 바꿔야하므로 수정에 대해 닫혀있지 않게 된다. 즉 OCP를 위반하게 된다.

위에서 제시된 문제점을 스트레티지 패턴을 사용함으로써 해결했다. 확장이 필요한 부분에 Abstraction을 적용하여 상위모듈이 고정된 추상화에 의존하도록 했다. 만일 새로운 server객체를 사용하고 싶다면 Client Interface를 구현한 새로운 클래스를 추가하도록 하면 된다.

장점?

이렇게 수정하면 경직성의 문제가 사라진다. 경직성이란 단순한 방법으로도 소프트웨어를 변경하기 어려운 것을 의미한다. 한 군데의 변경이 다른 의존적인 모듈의 변경을 일으킬 때 경직성의 문제가 있다고 한다. Client가 고정된 추상화에 의존하므로 하위 모듈의 변경이 상위 모듈에 영향을 미치지 않는다.

또한 부동성이 없다. 부동성이란 원하는 부분을 모듈로부터 분리해내어 다른 곳에서 사용할수 있는 것을 의미한다. 추상화를 구현한 서브 클래스는 재활용이 가능하므로 부동성 문제도 해결할 수 있다.

단점?

그렇다면 우리는 변경될 부분을 미리 예측하여 추상화를 해놓아야 하는걸까? 변경될 부분이 무엇인지 미리 안다면 우리는 해당 부분을 추상화 하면 되지만 실제로 서비스하기 전까지는 어느 부분에 변경이 필요한지 예측하기 어렵다. 또한 미리 추상화를 다 했다 하더라도 이는 불필요한 복잡성만 증가할 뿐이다.

Solution

Agile Design에서는 아래와 같은 해결책을 제시한다.

아주 짧은 주기로 개발한다.
소프트웨어를 빨리 그리고 자주 릴리즈한다.

지레 겁 먹고 모든 부분을 추상화하는 대신, 빠르게 개발하여 변화가 필요한 부분을 체감한 뒤 해당 부분을 추상화하도록 하면 필요한 부분에 대해 추상화를 할 수 있다.

[백준 1028] 다이아몬드 광산

devbelly — Sat, 2 Oct 2021 11:45:34 +0900

문제

https://www.acmicpc.net/problem/1028

알고리즘

풀이

2차원 광산이 주어질 때, 광산의 최대 크기를 구하는 문제입니다.

단순하게 브루트포스로 접근한다면 임의의 점을 광산의 최상단으로 잡은 후 네 변이 만들어 질 수 있나 검사를 해보면 됩니다. 모든 점을 최상단으로 검사하기 위해서는 $O(RC)$ 의 시간복잡도가 필요하고 추가적으로 네 변을 검사하기 위해서 선형시간만큼의 복잡도가 더 필요합니다.

위 계산법에서 낭비되는 부분을 줄여야합니다. 최상단 점 (i, j)에서 len 길이를 만들 때 오른쪽 상단변을 계산하는 과정은 (i+1,j+1)에서 len-1 길이를 만들 때 오른쪽 상단변을 계산하는 과정과 겹치게 됩니다. 즉 DP를 이용합시다.

$lcache[i][j]$ : i, j에서 왼쪽으로 만들 수 있는 최대 길이

$rcache[i][j]$: i, j에서 오른쪽으로 만들 수 있는 최대 길이

이 배열을 선언하면 광산의 만들어지는 네 점을 빠르게 검사할 수 있습니다.

코드

#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; ++i)
#define REP(i, n) for (int i = 1; i <= n; ++i)
using namespace std;

const int MAXR = 750 + 5;

int R, C, ans, arr[MAXR][MAXR], rcache[MAXR][MAXR], lcache[MAXR][MAXR];

int main() {
#ifndef ONLINE_JUDGE
    freopen("in", "r", stdin);
    freopen("out", "w", stdout);
#endif
    cin.tie(NULL);
    cout.tie(NULL);
    ios::sync_with_stdio(false);

    cin >> R >> C;
    REP(i, R)
    REP(j, C) {
        char x;
        cin >> x;
        arr[i][j] = (x == '1' ? 1 : 0);
    }
    for (int i = R; i >= 1; --i)
        for (int j = C; j >= 1; --j) {
            if (!arr[i][j]) continue;
            rcache[i][j] = rcache[i + 1][j + 1] + arr[i][j];
        }

    for (int i = R; i >= 1; --i)
        for (int j = C; j >= 1; --j) {
            if (!arr[i][j]) continue;
            lcache[i][j] = lcache[i + 1][j - 1] + arr[i][j];
        }

    for (int len = 375; ~len; --len) {
        REP(i, R) {
            if (i + 2 * len - 2 <= R) {
                REP(j, C) {
                    if (j - len + 1 >= 1 && j + len - 1 <= C) {
                        if (rcache[i][j] >= len && lcache[i + len - 1][j + len - 1] >= len && lcache[i][j] >= len && rcache[i + len - 1][j - len + 1] >= len) {
                            cout << len;
                            return 0;
                        }
                    }
                }
            }
        }
    }
    cout << ans;
    return 0;
}

[백준 3078] 좋은 친구

devbelly — Thu, 30 Sep 2021 15:45:44 +0900

문제

https://www.acmicpc.net/problem/3078

알고리즘

구현

풀이

위치가 K+1이상 벗어나지 않으면서 이름의 길이가 같은 쌍의 갯수를 찾는 문제입니다.

$N$제한이 30만이므로 $O(N^2)$을 사용해서 순서쌍을 찾기는 어렵습니다. 스택과 비슷한 느낌으로 현재 자신과 같은 길이가 이전에 몇개 있었는지를 기록하여 $O(N)$에 풀도록 합시다. 단 이것을 기록한 배열은 유효한(서로 친구)값만을 유지하기 위해서 위치 차이가 K가 넘어가면 해당 정보를 지우는 업데이트를 하면 됩니다.

코드

#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; ++i)
#define REP(i, n) for (int i = 1; i <= n; ++i)
using namespace std;

const int MAXN = 3e5 + 5;

int N, K;
int c[21], nm[MAXN];
long long ans;
int main() {
#ifndef ONLINE_JUDGE
    freopen("in", "r", stdin);
    freopen("out", "w", stdout);
#endif
    cin.tie(NULL);
    cout.tie(NULL);
    ios::sync_with_stdio(false);

    cin >> N >> K;
    rep(i, N) {
        string s;
        cin >> s;
        nm[i] = s.length();
    }
    rep(i, N) {
        if (i >= K + 1) c[nm[i - K - 1]] -= 1;
        ans += c[nm[i]];
        c[nm[i]] += 1;
    }
    cout << ans;
    return 0;
}