인프런 워밍업 클럽 스터디 3기 - CS 전공지식 <3주차 발자국>

섹션8

가상 메모리가 나오게 된 이유?

물리 메모리(RAM)의 한계를 극복하기 위해 가상 메모리(Virtual Memory)가 등장함

초창기 컴퓨터에서는 실행 가능한 프로그램의 크기가 물리 메모리(RAM) 크기보다 작거나 같아야 했음
하지만 프로그램이 커지면서 RAM 용량을 초과하는 프로그램 실행이 필요해짐
이를 해결하기 위해 디스크(하드 디스크 등)를 이용하여 RAM처럼 사용할 수 있도록 만든 개념이 가상 메모리

가상 메모리란?

물리 메모리보다 더 큰 주소 공간을 제공하기 위해 디스크를 활용하는 기술

프로세스가 실행될 때, 필요한 데이터만 RAM에 적재하고, 나머지는 하드디스크의 가상 메모리 영역(스왑 영역)에 저장
프로세스가 참조하는 데이터가 RAM에 없으면 페이지 폴트(Page Fault) 발생 → 디스크에서 해당 데이터를 RAM으로 불러옴

쉽게 말하면
→ RAM이 부족할 때, 하드 디스크를 추가적인 메모리처럼 활용하는 기술

가상 메모리 크기는 어떻게 결정될까?

가상 메모리의 크기는 주로 운영체제(OS)와 CPU 아키텍처에 의해 결정됨.

CPU의 주소 지정 방식
- 32비트 시스템: 최대 4GB (2³²)
- 64비트 시스템: 이론적으로 최대 16EB (2⁶⁴) (실제 OS마다 제한 다름)
운영체제의 정책
- OS 설정에 따라 가상 메모리 크기 조절 가능 (ex. Windows에서는 "가상 메모리 크기 변경" 설정 가능)
하드 디스크 용량
- 가상 메모리는 RAM 일부 + 하드 디스크의 스왑 공간으로 구성됨
- 하드 디스크 용량이 작으면 가상 메모리 크기도 제한됨

일반적인 가상 메모리 크기 설정:

Windows: RAM의 1.5배 ~ 2배 정도가 기본 설정
Linux: 스왑 영역(Swap Partition) 크기를 RAM 크기의 2배로 설정하는 경우 많음

가상 메모리를 사용하는 과정

프로세스가 주소(가상 주소)를 요청
CPU는 MMU(메모리 관리 장치, Memory Management Unit)를 통해 가상 주소를 물리 주소로 변환
변환된 주소가 RAM에 존재하면 그대로 사용
만약 RAM에 없으면?
- 페이지 폴트(Page Fault) 발생
- 디스크에서 해당 페이지를 RAM으로 가져옴 (스왑)
- 필요 없어진 페이지는 디스크로 내보냄 (페이징 기법 활용)

가상 메모리 시스템이란?

운영체제가 가상 메모리를 관리하는 시스템

페이지 테이블을 이용하여 가상 주소 → 물리 주소 변환
페이지 교체 알고리즘(LRU, FIFO 등)을 사용하여 필요한 데이터만 RAM에 유지
스왑 영역을 활용하여 필요 없는 페이지는 디스크로 이동

하드 디스크의 스왑 영역(Swap Area)이란?

RAM이 부족할 때, 데이터를 저장하는 하드 디스크의 공간

Linux에서는 Swap Partition, Windows에서는 Pagefile.sys라고 함
RAM이 꽉 차면 덜 중요한 데이터를 Swap 영역으로 이동
하지만 하드 디스크는 RAM보다 속도가 훨씬 느리므로 성능 저하가 발생할 수 있음

즉, RAM의 부족을 보완하지만 속도가 느려서 주의해야 함!

메모리 관리자란?

운영체제(OS)에서 메모리를 효율적으로 관리하는 역할을 하는 모듈

메모리 관리자의 역할?

프로세스가 사용할 메모리를 할당 및 해제
가상 주소를 물리 주소로 변환
페이지 교체 및 스왑 관리
외부 단편화와 내부 단편화 해결

동적 주소 변환이란?

프로세스가 실행 중일 때, 논리 주소(가상 주소)를 물리 주소로 변환하는 과정

CPU의 MMU(메모리 관리 장치)가 논리 주소 → 물리 주소 변환 수행
페이지 테이블을 이용하여 매핑
실행 중인 프로그램이 직접 물리 주소를 알 필요 없음 (OS가 관리)

즉, 프로그램이 실제 메모리 주소를 신경 쓰지 않아도 실행 가능하도록 하는 기술!

가상 메모리 시스템에서 가변 분할 방식과 고정 분할 방식

가변 분할 방식(Variable Partitioning) - 세그멘테이션(Segmentation)

프로세스 크기에 맞춰 메모리를 동적으로 할당하는 방식

장점
메모리를 효율적으로 사용할 수 있음 (공간 낭비 최소화)
단점
외부 단편화(External Fragmentation) 발생

고정 분할 방식(Fixed Partitioning) - 페이징(Paging)

고정된 크기의 페이지 단위로 메모리를 나누어 할당

장점
외부 단편화 없음 (고정된 크기의 페이지 사용)
단점
내부 단편화(Internal Fragmentation) 발생 가능

운영체제에서는 보통 "세그멘테이션 + 페이징"을 혼합하여 사용

페이징(Paging)이란?

가상 메모리를 일정한 크기(페이지)로 나누어, 물리 메모리에 적재하는 메모리 관리 기법
고정된 크기의 블록(페이지) 단위로 메모리를 할당하여 단편화를 줄이고, 효율적인 메모리 사용을 가능하게 함

쉽게 말하면:

프로세스가 사용하는 메모리를 일정한 크기의 페이지(Page)로 나누고, 이를 물리 메모리의 프레임(Frame)에 매핑하는 방식

페이징의 장단점

장점

외부 단편화(External Fragmentation) 없음
- 페이지 크기가 고정되어 있어 메모리의 작은 빈 공간을 효율적으로 활용 가능
메모리 할당이 쉽고 빠름
- 모든 페이지 크기가 동일하므로 메모리 할당 및 해제가 간단
가상 메모리를 효율적으로 관리 가능
- 프로세스의 전체 메모리를 한 번에 로드할 필요 없이, 필요한 페이지만 로드 가능
- → 요구 페이징(Demand Paging) 가능

단점

내부 단편화(Internal Fragmentation) 발생 가능
- 프로세스가 페이지 크기보다 작은 메모리를 필요로 할 경우 남는 공간이 낭비됨
페이지 테이블의 오버헤드(Overhead) 발생
- 페이지 테이블이 클수록 메모리를 많이 차지하고, 주소 변환 속도가 느려질 수 있음
주소 변환 시간이 증가할 수 있음
- TLB(변환 색인 버퍼, Translation Lookaside Buffer)를 사용하여 속도 향상 가능

페이지(Page)란?

프로세스의 가상 메모리를 일정한 크기로 나눈 블록
각 페이지는 동일한 크기를 가짐 (ex. 4KB, 8KB 등)
운영체제가 메모리를 관리하기 쉽게 만들어줌

프레임(Frame)이란?

물리 메모리(RAM)를 페이지와 동일한 크기의 블록으로 나눈 단위
하나의 페이지는 하나의 프레임에 매핑됨

즉, "페이지(Page)는 가상 메모리 단위", "프레임(Frame)은 물리 메모리 단위"

페이징의 주소 변환 과정

프로세스가 가상 주소(논리 주소)를 요청
가상 주소를 페이지 번호(Page Number)와 오프셋(Offset)으로 분리
페이지 번호를 페이지 테이블(Page Table)에서 찾아서 물리 메모리의 프레임 번호(Frame Number)로 변환
프레임 번호 + 오프셋을 조합하여 물리 주소(Physical Address)를 계산
변환된 물리 주소를 이용해 메모리에 접근

즉, 페이지 테이블을 통해 가상 주소 → 물리 주소로 변환됨!

페이지 테이블(Page Table)이란?

각 페이지 번호(Page Number)와 해당하는 물리 메모리의 프레임 번호(Frame Number)를 매핑하는 데이터 구조
운영체제가 프로세스의 메모리를 관리하는 데 사용됨

메모리 관리자가 페이지 테이블을 사용하는 방법

페이지 테이블을 참조하여 가상 주소를 물리 주소로 변환
각 프로세스마다 개별적인 페이지 테이블을 가짐
변환 색인 버퍼(TLB, Translation Lookaside Buffer)를 이용해 주소 변환 속도 향상 가능

페이지 넘버(Page Number)란?

가상 주소를 페이지 크기로 나눈 몫
페이지 테이블에서 참조할 때 사용하는 값

페이지 넘버 구하는 공식

페이지 크기가 4KB(4096B)일 경우, 가상 주소 8192라면

8192÷4096=2

→ 페이지 번호 = 2번 페이지

오프셋(Offset)이란?

해당 페이지 내에서의 위치(몇 번째 바이트인지)
페이지 내부에서 데이터를 찾을 때 사용

오프셋 구하는 공식

Offset=가상 주소mod 페이지 크기\text{Offset} = \text{가상 주소} \mod \text{페이지 크기}Offset=가상 주소mod페이지 크기

페이지 크기가 4KB(4096B)일 경우, 가상 주소 8192라면

8192mod 4096=08192 \mod 4096 = 08192mod4096=0

→ 0번째 위치 (페이지의 첫 번째 바이트)

세그멘테이션(Segmentation)과 페이징(Paging)의 차이점

운영체제는 보통 "세그멘테이션 + 페이징"을 함께 사용하여 단점 보완

페이지 크기의 중요성

작은 페이지 크기 (ex. 4KB)
- 장점: 내부 단편화 줄어듦
- 단점: 페이지 테이블 크기 증가 → 관리 오버헤드 증가
큰 페이지 크기 (ex. 64KB, 2MB)
- 장점: 페이지 테이블 크기 감소 → 주소 변환 속도 빨라짐
- 단점: 내부 단편화 증가

페이지 크기는 내부 단편화와 페이지 테이블 크기 사이에서 균형을 맞춰야 함

내부 단편화(Internal Fragmentation)란?

페이지 크기보다 작은 메모리를 할당할 때, 남는 공간이 낭비되는 문제
예: 4KB 페이지에 3.8KB 데이터 저장 → 0.2KB 낭비

외부 단편화(External Fragmentation)란?

메모리가 사용 가능한 공간으로 남아 있지만, 필요한 크기의 연속된 공간이 부족하여 할당할 수 없는 문제
페이징 기법을 사용하면 외부 단편화를 방지할 수 있음!

페이지 테이블 크기에 따른 장단점

페이지 테이블이 작을 경우

장점: 메모리 공간 절약
단점: 페이지 크기가 커서 내부 단편화 증가

페이지 테이블이 클 경우

장점: 페이지 크기가 작아져 내부 단편화 감소
단점: 페이지 테이블이 너무 크면 메모리 관리 오버헤드 증가

결론적으로, 페이지 크기와 페이지 테이블 크기 사이에서 최적의 균형을 찾는 것이 중요함!

1. 페이지 교체 정책(Page Replacement Policy)

페이지 교체 정책은 메모리가 꽉 찼을 때 어떤 페이지를 스왑 영역으로 보낼지 결정하는 방식이다.
가상 메모리 시스템에서 페이지 폴트가 발생하여 새로운 페이지를 로드해야 하지만, 물리 메모리에 빈 공간이 없는 경우 기존 페이지를 제거해야 하는데, 이때 어떤 페이지를 선택할지를 결정하는 알고리즘이다.

2. 페이지 폴트(Page Fault)란?

프로그램이 가상 메모리의 페이지를 요청했으나, 해당 페이지가 물리 메모리에 없는 경우 발생하는 인터럽트이다.
이때 운영체제(OS)는 페이지 폴트를 처리하기 위해 디스크에서 해당 페이지를 읽어와 물리 메모리에 로드한다.

3. 페이지 폴트가 발생하는 이유

실행 중인 프로그램이 처음으로 특정 페이지를 참조할 때
실행 중인 프로그램이 스왑 영역에 저장된 페이지를 다시 참조할 때
메모리가 부족하여 페이지를 교체해야 하는 상황

4. 페이지 교체 정책 종류

1) 무작위(Random) 페이지 교체 알고리즘

교체할 페이지를 랜덤하게 선택하여 제거하는 방법.
구현이 단순하지만 성능이 좋지 않음.

장점: 구현이 쉬움.
단점: 성능이 낮고, 비효율적인 교체가 발생할 수 있음.

2) FIFO(First-In, First-Out) - 가장 오래된 페이지 교체

메모리에 가장 먼저 들어온 페이지를 제거하는 방식.
큐(Queue)를 이용하여 가장 앞쪽에 있는 페이지를 제거함.

장점: 구현이 간단함.
단점: 오래된 페이지가 자주 사용되는 경우에도 교체될 수 있음. (Belady’s anomaly 발생 가능)

FIFO 과정

페이지 요청이 들어오면, 메모리에 없으면 페이지 폴트 발생.
물리 메모리에 빈 공간이 없으면, 가장 먼저 들어온 페이지를 제거.
새로운 페이지를 해당 공간에 삽입.

3) OPT(Optimal) - 앞으로 가장 오랫동안 사용되지 않을 페이지 교체

앞으로 가장 오랫동안 사용되지 않을 페이지를 제거하는 방식.
이론적으로 가장 효율적인 방법이지만, 미래의 메모리 접근 패턴을 알아야 하므로 현실적으로 구현이 불가능함.

장점: 이론적으로 페이지 폴트 발생 횟수가 가장 적음.
단점: 실제로 구현이 불가능함.

4) LRU(Least Recently Used) - 최근 가장 적게 사용된 페이지 교체

최근 가장 오랫동안 사용되지 않은 페이지를 제거하는 방식.
과거의 페이지 참조 기록을 기반으로 가장 오랫동안 사용되지 않은 페이지를 선택함.

장점: 자주 사용하는 페이지는 유지할 가능성이 높음.
단점: 구현이 다소 복잡하고, 최근 사용 정보를 저장하는데 추가적인 메모리 비용이 발생.

LRU 과정

페이지 요청이 들어오면, 메모리에 없으면 페이지 폴트 발생.
메모리에 빈 공간이 없으면, 가장 오랫동안 사용되지 않은 페이지를 제거.
새로운 페이지를 해당 공간에 삽입.

5. 페이지 테이블 엔트리(Page Table Entry, PTE)

페이지 테이블의 각 항목(엔트리)으로, 가상 주소와 물리 주소의 매핑 정보를 저장하는 데이터 구조.

포함되는 주요 정보

페이지 프레임 번호 (어떤 물리적 주소에 해당하는지)
유효(Valid) 비트 (페이지가 물리 메모리에 존재하는지 여부)
읽기/쓰기 권한 정보
페이지가 수정되었는지(Dirty 비트)

페이지 테이블 엔트리에 데이터를 저장할 때 발생하는 단점

페이지 테이블 크기가 커질 수 있음 → 메모리 낭비 발생.
페이지 테이블 검색 시간이 증가 → 성능 저하 발생.
추가적인 TLB(Translation Lookaside Buffer) 캐시 필요 → 성능 향상을 위한 추가 하드웨어 비용 발생.

P4 방식이란?

P4 방식은 4단계 페이지 테이블 구조를 사용하는 메모리 관리 방식으로, 주로 64비트 운영체제에서 사용됨.

P4 페이지 테이블 구조

P4 Directory → P3 Directory → P2 Directory → P1 Table → 물리 메모리
가상 주소를 4단계에 걸쳐 변환하여 물리 메모리를 찾음.

장점

큰 메모리 공간(64비트 주소 공간)을 효율적으로 관리 가능.
페이지 테이블을 계층적으로 나누어 메모리 낭비를 줄임.

단점

주소 변환 과정이 4단계로 늘어나므로 속도가 느릴 수 있음.
TLB 캐시 미스가 발생할 경우 성능 저하 가능성.

정리

페이지 교체 정책: 메모리가 꽉 찼을 때 교체할 페이지를 선택하는 방법.
FIFO: 가장 먼저 들어온 페이지 제거 (단순하지만 성능 낮음).
OPT: 앞으로 가장 오랫동안 사용되지 않을 페이지 제거 (이론적 최적, 실제 구현 불가능).
LRU: 최근 가장 사용이 적은 페이지 제거 (성능 좋지만 구현 복잡).
P4 방식: 4단계 페이지 테이블 구조를 사용하는 메모리 관리 기법 (64비트 운영체제에서 사용).

스레싱(Thrashing)이란?

스레싱(Thrashing)은 운영체제가 대부분의 시간을 페이지 교체 작업에 소비하여 실제 작업 수행이 거의 이루어지지 않는 현상을 의미한다.

즉, 페이지 폴트가 너무 자주 발생하여 CPU가 계속해서 페이지 교체만 수행하고, 유효한 작업을 처리하지 못하는 상태를 말한다.

스레싱이 일어나는 과정

프로세스가 증가하면서 메모리 사용량이 많아짐
물리 메모리가 부족하여 페이지 폴트가 빈번하게 발생
운영체제가 페이지 교체를 계속 수행하면서 CPU가 대부분의 시간을 페이지 교체 작업에 소모
실제 프로그램 실행 속도가 크게 저하됨
CPU 이용률이 낮아지고, 전체 시스템 성능이 급격히 저하됨

스레싱이 발생하는 이유

프로세스의 워킹 셋(Working Set) 크기가 물리 메모리보다 클 때
과도한 멀티태스킹으로 인해 메모리가 부족할 때
운영체제가 너무 많은 프로세스를 동시에 실행할 때
잘못된 페이지 교체 정책이 사용될 때 (ex. FIFO가 Belady's anomaly를 유발하는 경우)
지역성(Locality) 특성이 약한 경우 (즉, 프로그램이 너무 많은 서로 다른 페이지를 반복적으로 참조하는 경우)

운영체제가 스레싱을 해결하기 위한 방법

1) 워킹 셋(Working Set) 알고리즘 적용

각 프로세스가 일정 시간 동안 참조하는 페이지 집합(워킹 셋)을 유지하도록 제한
필요 이상의 페이지 교체를 방지하여 스레싱을 감소

2) 페이지 부하 조절(Page Load Control) - 다중 프로그래밍 수준 조정

실행 중인 프로세스 수를 줄여서 각 프로세스에 할당되는 메모리를 증가시킴
즉, 프로세스의 개수를 줄이면 남은 프로세스가 더 많은 메모리를 사용 가능

3) 프레임 할당 정책 개선

최소한의 페이지 프레임을 보장하는 페이지 할당 정책을 개선하여 스레싱을 예방
예: LRU(Least Recently Used) 알고리즘 사용하여 효율적인 페이지 교체 수행

4) 페이지 폴트 빈도(Page Fault Frequency, PFF) 제어

페이지 폴트가 너무 자주 발생하면, 프로세스에게 더 많은 페이지를 할당
페이지 폴트가 너무 적으면, 불필요한 페이지를 회수하여 다른 프로세스에 할당

5. 워킹 셋(Working Set)이란?

워킹 셋(Working Set)이란, 프로세스가 일정 시간 동안 자주 참조하는 페이지들의 집합이다.

워킹 셋 개념의 핵심

프로그램은 지역성(Locality) 원칙을 따르므로, 일정 시간 동안 특정한 페이지들만 집중적으로 참조함
따라서 해당 페이지들을 메모리에 유지하면 페이지 폴트를 줄일 수 있음
워킹 셋을 기준으로 메모리 할당을 조절하면 스레싱을 방지할 수 있음

정리

스레싱(Thrashing): CPU가 대부분의 시간을 페이지 교체에 소비하여 실제 작업이 거의 수행되지 않는 현상
발생 원인: 프로세스 증가, 메모리 부족, 잘못된 페이지 교체 정책, 지역성 부족
해결 방법:

워킹 셋 알고리즘 적용
프로세스 개수 조절(다중 프로그래밍 수준 조정)
효율적인 페이지 교체 정책 적용
페이지 폴트 빈도(Page Fault Frequency) 조절
섹션 09

주변 장치(Peripheral Device) 내부 구조
주변 장치는 컴퓨터 시스템의 입출력(I/O) 작업을 수행하는 장치이며, 내부적으로 다음과 같은 구조를 가진다.

주변 장치의 기본 내부 구조
1. 제어(Control) 회로
  - CPU나 메모리와 신호를 주고받으며 입출력 요청을 처리
  - I/O 작업을 수행하는 동안 상태를 유지
2. 데이터 버퍼(Data Buffer)
  - 데이터를 임시 저장하여 CPU와의 통신을 원활하게 함
  - 블록 단위 또는 스트림 단위로 데이터 처리
3. 입출력 인터페이스
  - CPU와 주변 장치 간 데이터 전송을 담당하는 인터페이스
  - 예: USB, PCIe, SATA, I2C 등
주변 장치 종류
(1) 입력 장치 (Input Devices)
- 컴퓨터에 데이터를 입력하는 장치
- 예: 키보드, 마우스, 스캐너, 터치스크린, 조이스틱
(2) 출력 장치 (Output Devices)
- 컴퓨터의 처리 결과를 사용자에게 보여주는 장치
- 예: 모니터, 프린터, 스피커
(3) 저장 장치 (Storage Devices)
- 데이터를 저장하고 읽는 장치
- 예: HDD, SSD, USB, SD 카드
(4) 네트워크 장치 (Network Devices)
- 네트워크 통신을 담당하는 장치
- 예: LAN 카드, Wi-Fi 모듈, 블루투스 장치
캐릭터 디바이스(Character Device)와 블록 디바이스(Block Device)
(1) 캐릭터 디바이스(Character Device)
- 바이트 단위로 데이터를 읽고 쓰는 장치
- 스트림 기반으로 동작하며, 데이터가 순차적으로 처리됨
- 예: 키보드, 마우스, 시리얼 포트, 터미널
(2) 블록 디바이스(Block Device)
- 데이터를 블록 단위(예: 512B, 4KB 등)로 읽고 쓰는 장치
- 랜덤 액세스 가능, 즉 특정 블록을 바로 읽고 쓸 수 있음
- 예: HDD, SSD, USB, CD/DVD
고속 입출력 버스와 저속 입출력 버스
(1) 고속 입출력 버스(High-Speed I/O Bus)
- 대용량 데이터 전송이 필요한 장치에 사용
- CPU와 직접 연결되어 빠른 속도로 데이터를 주고받음
- 예: PCIe, SATA, NVMe
(2) 저속 입출력 버스(Low-Speed I/O Bus)
- 상대적으로 낮은 대역폭을 요구하는 장치에 사용
- 주로 센서, 키보드, 마우스 등 저속 장치에 사용
- 예: I2C, SPI, UART, USB(2.0 이하)
Direct Memory Access (DMA)란?
DMA(Direct Memory Access, 직접 메모리 접근)는 CPU의 개입 없이 주변 장치가 메모리와 직접 데이터를 주고받을 수 있도록 하는 기술이다.

DMA의 동작 과정
1. CPU가 DMA 컨트롤러(DMAC)에게 메모리 주소와 데이터 크기를 설정
2. DMA 컨트롤러가 직접 I/O 장치 ↔ 메모리 간 데이터 전송 수행
3. 데이터 전송이 완료되면 DMA 컨트롤러가 CPU에게 인터럽트(Interrupt) 발생
DMA의 장점
- CPU 부하 감소 → CPU가 데이터 이동 작업에서 해방됨
- 빠른 데이터 전송 → CPU 개입 없이 고속 데이터 처리 가능
- 효율적인 입출력 성능 향상
DMA를 사용하는 대표적인 장치
- HDD, SSD, 그래픽 카드(GPU), 네트워크 카드(NIC)
- 대용량 데이터를 빠르게 전송하는 장치에 주로 사용됨

DSP(Digital Signal Processor)란?

DSP(Digital Signal Processor, 디지털 신호 처리기)는 디지털 신호를 빠르게 처리하는 특수 목적의 마이크로프로세서이다.

DSP의 역할

아날로그 신호(소리, 영상, 센서 데이터 등)를 디지털 신호로 변환하여 연산
빠른 실시간 신호 처리가 가능하여 오디오, 영상, 통신, 의료 장비 등에 사용됨
일반 CPU보다 병렬 연산(동시 연산)에 특화됨

DSP의 활용 분야

오디오/영상 처리 → MP3 플레이어, 스마트폰 음성 인식, 영상 코덱
통신 시스템 → 5G, Wi-Fi 신호 처리, 모뎀
의료 장비 → MRI, 초음파 영상 처리
자동차 → 차량 내 음성 인식, 레이더 신호 처리

DSP vs 일반 CPU 차이점

키보드와 마우스를 통한 애플리케이션 동작 과정

입력 장치(Keyboard & Mouse)의 동작 과정
사용자가 키보드/마우스 입력

키보드의 키를 누르거나 마우스를 이동/클릭

입력 장치의 컨트롤러가 신호 처리

키보드: 스캔코드(Scan Code) 생성
마우스: 위치 정보(x, y) 및 버튼 클릭 이벤트 생성

입력 신호가 운영체제(OS)로 전달됨

키보드/마우스 입력은 인터럽트(Interrupt) 방식으로 OS에 전달됨

OS가 입력을 애플리케이션에 전달

운영체제(Windows, Linux, macOS 등)가 이벤트를 감지
적절한 애플리케이션에 입력 이벤트 전달(이벤트 큐 활용)

애플리케이션이 입력을 처리하여 동작 수행

키보드 입력 → 텍스트 입력, 단축키 실행
마우스 입력 → 버튼 클릭, 드래그, UI 조작

예시: 웹 브라우저에서 키보드와 마우스를 통한 동작 과정

사용자가 Google 검색창에 "DSP란?" 입력
키보드 이벤트 → 웹 브라우저가 입력을 감지하여 텍스트 표시
엔터 키 입력 → 웹 브라우저가 검색 요청을 서버에 전달
마우스 클릭 → 검색 버튼을 클릭하면 검색 결과 페이지 로드

하드 디스크 구조

하드 디스크(HDD, Hard Disk Drive)는 데이터를 저장하는 자기 저장 장치로, 내부적으로 여러 개의 플래터(Platter)가 회전하며 데이터를 저장하고 읽는다.

하드 디스크 주요 구성 요소

플래터(Platter): 데이터를 저장하는 원형 디스크
스핀들(Spindle): 플래터를 회전시키는 중심축
헤드(Head): 데이터를 읽고 쓰는 장치
암(Arm): 헤드를 이동시키는 기구
액추에이터(Actuator): 헤드의 움직임을 제어하는 장치

플래터(Platter)란?

플래터(Platter)는 HDD 내부에서 데이터를 저장하는 원형 디스크이다.
특징

자성을 띤 표면을 갖고 있어 데이터를 저장
여러 개의 플래터가 수직으로 겹쳐진 형태로 배치
고속 회전(RPM 단위, 보통 5,400~7,200 RPM)

플래터 구조

트랙(Track): 플래터의 원형 경로
섹터(Sector): 트랙을 나눈 최소 저장 단위
클러스터(Cluster): 여러 섹터가 모인 데이터 저장 단위
실린더(Cylinder): 여러 플래터의 같은 위치에 있는 트랙들의 집합

시크 타임(Seek Time)이란?

시크 타임(Seek Time)은 헤드가 원하는 트랙으로 이동하는 데 걸리는 시간을 의미한다.

하드 디스크의 속도를 결정하는 중요한 요소
보통 밀리초(ms) 단위로 측정됨
짧을수록 HDD 속도가 빠름

시크 타임 최적화 방법

파일 조각 모음(Defragmentation): 파일을 연속된 클러스터에 배치하여 헤드 이동 최소화
캐시(Buffer) 사용: 자주 사용하는 데이터를 미리 로드

플래시 메모리(Flash Memory)란?

플래시 메모리(Flash Memory)는 전원이 없어도 데이터가 유지되는 반도체 저장 장치

비휘발성(Non-volatile) 메모리로, 전원이 꺼져도 데이터 유지
기계적 움직임이 없는 반도체 기반 저장 장치
HDD보다 빠르고, SSD(솔리드 스테이트 드라이브)에 사용됨

플래시 메모리의 종류

플래시 메모리 구조

플래시 메모리는 '셀(Cell)'이라는 단위로 구성됨

페이지(Page): NAND 플래시의 최소 저장 단위
블록(Block): 여러 개의 페이지로 구성됨
플래시 컨트롤러: 데이터 읽기/쓰기 및 관리 담당

플래시 메모리의 동작 방식
쓰기(Program): 전압을 가해 데이터를 저장
읽기(Read): 저장된 데이터를 읽음
삭제(Erase): 데이터를 삭제할 때 블록 단위로 초기화

플래시 메모리의 특징

기계적 움직임이 없어 내구성이 뛰어남
빠른 데이터 액세스 속도
수명이 제한됨(특정 횟수 이상 덮어쓰기하면 성능 저하)

HDD vs SSD (플래터 기반 vs 플래시 메모리 기반)

섹션 10

파일 시스템(File System)이란?

파일 시스템은 운영체제가 데이터를 저장하고 관리하는 방식이다.
하드디스크, SSD, USB 등 저장 장치에서 파일을 생성, 삭제, 수정, 검색하는 기능을 담당한다.

파일 시스템의 기능

파일과 디렉토리 관리: 생성, 수정, 삭제
접근 권한 관리: 읽기/쓰기/실행 권한 설정
무결성 보장: 데이터 손상 방지
백업과 복구: 데이터 보호 및 복원
파일 암호화: 보안 강화

블록 디바이스(Block Device)

하드디스크(HDD)와 플래시 메모리(SSD)는 블록 디바이스이다.
블록 단위로 데이터를 저장하고 처리하는 저장 장치.
블록 단위로 접근하여 데이터를 읽고 쓰므로 빠른 속도와 효율적인 관리 가능.

윈도우 파일 확장자(예시)

파일 확장자는 파일의 형식과 실행 프로그램을 결정한다.

파일 디스크립터(File Descriptor)란?

운영체제가 파일을 관리하는 식별자(정수형 값)
파일이 열리면, 운영체제는 파일 디스크립터(파일 번호)를 할당함
프로세스는 이 디스크립터를 이용해 파일을 읽고, 쓰고, 닫음

시스템 콜(System Call)이란?

운영체제의 서비스(파일 조작, 프로세스 관리 등)를 요청하는 인터페이스
유저 모드 → 커널 모드 전환을 통해 하드웨어 접근 가능
파일 시스템 관련 시스템 콜 예시
open() → 파일 열기
read() → 파일 읽기
write() → 파일 쓰기
close() → 파일 닫기

7. 파일의 데이터 집합 종류

파일 시스템에서 데이터를 저장하는 방식(파일 구조)에 따라 3가지로 분류됨

(1) 순차 파일 구조 (Sequential File Organization)

데이터를 순차적으로 저장하는 방식
테이프(Tape) 저장 방식과 유사

과정

데이터를 순서대로 저장
읽거나 검색할 때 처음부터 순서대로 접근
수정 시 새로운 파일을 만들어 다시 저장

장점
저장 방식이 간단하고 구현이 쉬움
연속적으로 데이터 처리 시 속도가 빠름

단점
특정 데이터 검색 시 시간이 오래 걸림
삽입/삭제 작업이 비효율적

(2) 직접 파일 구조 (Direct File Organization)

키 값(해시 함수 등)을 이용해 직접 접근하는 방식
HDD, SSD 같은 랜덤 액세스가 가능한 저장 장치에 적합

과정

키 값(해시 함수 등)을 통해 특정 위치에 바로 저장
데이터를 검색할 때 키 값을 이용해 즉시 접근

장점
데이터 검색 속도가 빠름
대량의 데이터 관리에 적합

단점
키 값 충돌(Hash Collision) 문제가 발생할 수 있음
데이터 저장 공간이 비효율적으로 사용될 수 있음

(3) 인덱스 파일 구조 (Indexed File Organization)

데이터 위치를 저장하는 인덱스를 별도로 관리하는 방식
데이터와 별도로 인덱스 파일을 유지하여 빠른 검색 가능

과정

데이터의 위치 정보를 인덱스 테이블에 저장
검색 시 인덱스를 먼저 조회하여 해당 데이터를 빠르게 찾음

장점
검색 속도가 빠름 (특히 대량의 데이터에서 효과적)
삽입/삭제가 비교적 효율적

단점
인덱스를 추가로 저장해야 하므로 메모리 공간이 필요함
데이터 변경이 많으면 인덱스 유지 비용이 발생

'그림으로 쉽게 배우는 자료구조와 알고리즘(기본편)' 3주차

알고리즘

삽입 정렬 (Insertion Sort)

삽입정렬이란?

삽입정렬은 정렬되지 않은 데이터를 하나씩 골라, 이미 정렬된 부분에 적절한 위치에 삽입하는 방식입니다.
작은 데이터에서 효율적이지만, 데이터가 많아질수록 비효율적입니다.

시간복잡도, 장단점

시간복잡도: 평균 및 최악 시간 복잡도는 O(n²) (최악의 경우는 모든 원소를 하나씩 비교해야 함)
장점:
- 간단하고 구현이 용이
- 정렬이 거의 되어 있는 배열에서는 빠른 속도
- 추가 메모리 필요 없음 (In-place 정렬)
단점:
- 데이터가 많아질수록 비효율적
- 최악의 경우 O(n²)의 시간 복잡도

C++ 예시 구현 코드

#include <iostream>
using namespace std;

void insertionSort(int arr[], int n) {
    for (int i = 1; i < n; i++) {
        int key = arr[i];
        int j = i - 1;

        // key보다 큰 원소들을 오른쪽으로 한 칸씩 이동
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
}

int main() {
    int arr[] = {12, 11, 13, 5, 6};
    int n = sizeof(arr) / sizeof(arr[0]);

    insertionSort(arr, n);

    cout << "Sorted array: ";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }

    return 0;
}

병합 정렬 (Merge Sort)

병합정렬이란?

병합정렬은 분할 정복 알고리즘을 사용하여 배열을 반으로 나누고, 나눈 배열을 재귀적으로 정렬한 후, 두 배열을 병합하는 방식입니다.

시간복잡도, 장단점

시간복잡도: 항상 O(n log n) (배열을 계속 반으로 나누고 합치는 과정에서 시간이 걸림)
장점:
- 항상 O(n log n)의 성능을 보장
- 안정적 정렬 (같은 값이 있으면 원래의 순서를 유지)
단점:
- 추가 메모리가 필요 (O(n))
- 복잡한 구현

C++ 예시 구현 코드

#include <iostream>
using namespace std;

void merge(int arr[], int left, int right) {
    if (left < right) {
        int mid = left + (right - left) / 2;
        merge(arr, left, mid); // 왼쪽 절반 정렬
        merge(arr, mid + 1, right); // 오른쪽 절반 정렬

        // 병합
        int n1 = mid - left + 1;
        int n2 = right - mid;

        int L[n1], R[n2];

        for (int i = 0; i < n1; i++)
            L[i] = arr[left + i];
        for (int i = 0; i < n2; i++)
            R[i] = arr[mid + 1 + i];

        int i = 0, j = 0, k = left;
        while (i < n1 && j < n2) {
            if (L[i] <= R[j]) {
                arr[k] = L[i];
                i++;
            } else {
                arr[k] = R[j];
                j++;
            }
            k++;
        }

        while (i < n1) {
            arr[k] = L[i];
            i++;
            k++;
        }

        while (j < n2) {
            arr[k] = R[j];
            j++;
            k++;
        }
    }
}

int main() {
    int arr[] = {12, 11, 13, 5, 6, 7};
    int n = sizeof(arr) / sizeof(arr[0]);

    merge(arr, 0, n - 1);

    cout << "Sorted array: ";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }

    return 0;
}

퀵 정렬 (Quick Sort)

퀵정렬이란?

퀵정렬은 분할 정복 알고리즘을 사용하며, 기준값(pivot)을 정해 배열을 두 부분으로 분할한 후, 각 부분에 대해 재귀적으로 정렬하는 방식입니다.

시간복잡도, 장단점

시간복잡도: 평균 시간 복잡도는 O(n log n), 최악의 경우는 O(n²) (배열이 이미 정렬된 경우)
장점:
- 빠른 정렬 속도 (평균 O(n log n))
- 메모리 사용 효율적 (In-place 정렬)
단점:
- 최악의 경우 O(n²) 시간이 걸릴 수 있음 (피벗 선택에 따라)
- 불안정한 정렬 (같은 값이 있으면 순서가 달라질 수 있음)

C++ 예시 구현 코드

#include <iostream>
using namespace std;

int partition(int arr[], int low, int high) {
    int pivot = arr[high];
    int i = low - 1;

    for (int j = low; j < high; j++) {
        if (arr[j] <= pivot) {
            i++;
            swap(arr[i], arr[j]);
        }
    }

    swap(arr[i + 1], arr[high]);
    return i + 1;
}

void quickSort(int arr[], int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high);
        quickSort(arr, low, pi - 1); // 왼쪽 부분 정렬
        quickSort(arr, pi + 1, high); // 오른쪽 부분 정렬
    }
}

int main() {
    int arr[] = {10, 7, 8, 9, 1, 5};
    int n = sizeof(arr) / sizeof(arr[0]);

    quickSort(arr, 0, n - 1);

    cout << "Sorted array: ";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }

    return 0;
}

동적 프로그래밍 - 메모이제이션 (Memoization)

메모이제이션이란?

메모이제이션은 이미 계산된 값을 캐시하여 재사용하는 방법입니다. 주로 재귀 함수에서 많이 사용됩니다.

시간복잡도, 장단점

시간복잡도: 중복 계산을 방지하여 시간 복잡도를 O(n)으로 줄일 수 있음
장점:
- 재귀적 문제 해결 시 성능 향상
- 중복 계산 방지
단점:
- 메모리 사용량 증가 (캐시를 저장해야 하므로)

C++ 예시 구현 코드 (피보나치 수열)

#include <iostream>
#include <unordered_map>
using namespace std;

unordered_map<int, int> memo;

int fib(int n) {
    if (n <= 1) return n;
    if (memo.find(n) != memo.end()) return memo[n];
    memo[n] = fib(n - 1) + fib(n - 2);
    return memo[n];
}

int main() {
    int n = 10;
    cout << "Fibonacci of " << n << " is " << fib(n) << endl;
    return 0;
}

동적 프로그래밍 - 타뷸레이션 (Tabulation)

타뷸레이션이란?

타뷸레이션은 하향식 문제 해결 방식입니다. 하위 문제를 먼저 계산하고, 이를 기반으로 상위 문제를 해결합니다.

시간복잡도, 장단점

시간복잡도: 보통 O(n) (배열을 채우는 과정에서)
장점:
- 메모리 사용 효율적
- 중복 계산을 제거
단점:
- 재귀적 사고가 아닌 반복적 방법 (문제를 재귀적으로 풀고 싶을 때 불편)

C++ 예시 구현 코드 (피보나치 수열)

#include <iostream>
using namespace std;

int fib(int n) {
    int dp[n + 1];
    dp[0] = 0;
    dp[1] = 1;

    for (int i = 2; i <= n; i++) {
        dp[i] = dp[i - 1] + dp[i - 2];
    }

    return dp[n];
}

int main() {
    int n = 10;
    cout << "Fibonacci of " << n << " is " << fib(n) << endl;
    return 0;
}

완주 후기:

혼자서 강의를 듣기 시작했다면 두 강의를 완주하지 못했을 것 같다. 커리큘럼 따라서 완주를 하고, 감자님이 내주신 문제들에 대한 답변들을 풀이하면서 더 찾아보게 되는 것 같았습니다.

3주차에 수강한 강의 내용들은 너무 어려워서 다시 한번 돌려보고 후에, 전체적으로 모든 강의를 다시 볼 생각입니다.

좋은 강의 제공해주셔서 감사합니다.