1. 💡 컴퓨터, 어떻게 똑똑해졌을까? – 계산기에서 멀티태스커로

1) 🧠 단순했던 컴퓨터, 점점 복잡해진 설계

4장까지는 CPU가 메모리와 I/O 장치와 어떻게 소통하는지 간단한 구조를 살펴봤어요.
하지만 현실 속 컴퓨터는 그렇게 단순하지 않아요. 빠르고, 효율적이며, 전력도 덜 먹고, 동시에 여러 프로그램을 실행해야 하죠.

그래서 컴퓨터 설계는 점점 더 복잡한 기술과 구조를 요구하게 됐습니다.

컴퓨터가 단순히 계산만 하던 시절은 오래전에 지나갔습니다. 이제 컴퓨터는 우리가 사용하는 수많은 프로그램을 동시에 실행하고, 그 과정에서 메모리도 효율적으로 잘 배분합니다.

그렇다면 이런 복잡한 기능들이 어떻게 가능한 걸까요?

그 핵심에는 '컴퓨터 아키텍처'와 '운영체제'라는 두 주인공이 있습니다. 아키텍처는 하드웨어의 설계 철학, 운영체제는 그것을 효율적으로 사용하는 소프트웨어의 관리자입니다. 이 둘은 마치 대규모 주방의 설비(아키텍처)와 요리사장(운영체제)처럼 협력합니다.

2) 🏛️ 컴퓨터 아키텍처는 설계도이지 양식이 아니다

'컴퓨터 아키텍처'는 마치 고대 건축 양식처럼 들릴 수 있지만, 실제로는 CPU, 메모리, I/O 등의 구성요소를 어떻게 배치할지에 대한 설계 철학입니다.

“도리스식이나 이오니아식 말고, 진짜 속 내용물 이야기!”

성공적인 아키텍처도 있었고, 실험적으로 끝난 구조도 있었어요. 다양한 시도가 있었기에 지금의 컴퓨터가 존재하는 거죠.

3) 🧩 이번 장의 초점: 메모리와 프로그램 실행

5장은 메모리 구조와 실행 장치의 설계, 그리고 여러 프로그램을 동시에 실행하기 위한 멀티태스킹을 집중적으로 다룹니다.

• 최신 CPU 안에서 가장 큰 영역은 ‘메모리 처리 회로’예요.
• 멀티코어, 전력 관리, 실행 최적화 장치 등도 함께 등장합니다.
• 동시에 여러 프로그램을 돌리려면 ‘운영체제’라는 관리자가 꼭 필요합니다.

✍️ 한 줄 요약!

컴퓨터 아키텍처는 뼈대, 운영체제는 감독, 메모리는 전략의 핵심!
우리가 프로그램을 ‘똑똑하게’ 실행할 수 있는 비결은 여기에 있어요.

2. 🛣️ 폰 노이만 vs 하버드: 메모리 고속도로 전쟁

💡 두 개의 뇌: 컴퓨터 구조의 선택지와 진화

1) 📚 폰 노이만 vs 하버드 구조 – "한길을 갈 것인가, 두 갈래로 나눌 것인가"

컴퓨터 설계에는 두 가지 대표적인 길이 있어요.

• 폰 노이만 구조는 명령어와 데이터를 같은 메모리에서 읽는 구조예요. 도로가 하나라서 데이터를 실어 나르거나 명령을 받을 때 줄을 서야 하는 상황이 발생하죠. 그래서 약간 느릴 수 있어요.
• 하버드 구조는 명령어와 데이터가 각기 다른 메모리에 있어요. 명령도 가져오고, 데이터도 동시에 받을 수 있어서 더 빠르고 효율적이지만, 하드웨어 설계가 복잡해집니다. 두 번째 메모리를 처리하기 위한 버스가 더 필요해요

📌 정리:

• 폰 노이만: 단순하지만 느릴 수 있음
• 하버드: 복잡하지만 병렬성이 좋음

이 두 구조의 유일한 차이는 메모리 배열뿐입니다.

2) 🧠 코어 이야기 – 하나의 뇌보다 여럿이 낫다?

처음엔 CPU 하나면 충분하다고 생각했어요. 위 사진의 두 구조 모두 cpu가 하나뿐이었죠. 하지만 성능의 한계에 부딪혔습니다.

🔌 회로는 작아지는데, 발열은 커진다? 전력 장벽 이야기

기술 발전으로 CPU 회로는 점점 더 작아지고 빨라졌습니다. 하지만 작아지면서 생긴 문제도 있죠.

바로 전력 장벽(Power Wall) 때문이에요.

• CPU 속도는 빨라졌지만, 전력 소비와 발열도 같이 증가했어요.
• 회로를 작게 만들수록 열은 더 많이 나고, 결국 회로가 녹는 수준에 이를 수도 있었죠.

속도는 빨라졌지만 그만큼 전력 소모와 발열이 커졌습니다.

이를 해결하기 위해 우리는 하나의 CPU에 여러 개의 코어를 넣는 '멀티코어 프로세서'를 만들었습니다.

이 코어들은 각자 다른 작업을 병렬로 처리할 수 있어서 효율이 훨씬 높아졌습니다.

• 하나의 CPU 안에 여러 개의 코어(뇌)를 넣어, 병렬로 작업을 나눠 처리합니다.
• 이제 CPU는 "단일한 두뇌"가 아니라 "작은 팀"으로 움직여요!

그래서 요즘 CPU를 보면 'i5-1235U (10코어)' 같은 표현을 자주 보게 되죠.

3) 멀티 코어 프로세스, 멀티 코어가 뭘까

출처 : https://imjeongwoo.tistory.com/152?category=943671

멀티코어(Multi-core)

• 하나의 CPU 내부에 두 개 이상의 독립적인 core가 있는 기술.
• 하나의 core 처리하는 작업을 여러 개의 core가 분담하여 처리 가능.

멀티 프로세서

• 여러 개의 Processor(=CPU)를 사용하는 것.
• 여러 개의 CPU가 각각 독립적으로 작업을 처리.

멀티 코어 프로세서란?

멀티 코어 또는 멀티 코어 프로세서(multi-core processor) CPU는 두 개 이상의 독립 코어를 단일 집적 회로로 이루어진 하나의 패키지로 통합한 것을 말합니다.

• 멀티코어 + 멀티프로세스
• 하나의 CPU 내부에 두개 이상의 core가 있고, 이러한 멀티코어 CPU가 여러 개 존재.

4) 🖥️ 칩 하나에 우주가! 마이크로컴퓨터와 SoC

하드웨어의 구성 방식도 다양합니다. 여기서 혼동하기 쉬운 세 가지를 구분해볼게요.

구분	구성 요소	특징
마이크로프로세서	CPU만 있음	메모리, I/O는 외부에 따로
마이크로컴퓨터	CPU + 메모리 + I/O	하나의 칩에 통합, 아두이노 등이 예
SoC (System on a Chip)	마이크로컴퓨터 + WiFi, GPU 등	스마트폰에 들어가는 복잡한 컴퓨터 시스템

• 아두이노는 하버드 구조를 따르는 마이크로컴퓨터예요. 센서나 간단한 제어에 아주 유용하죠. 번쩍이는 장난감부터 센서 제어까지 다양하게 사용됩니다.
• SoC는 말 그대로 칩 하나에 모든 걸 담은 작은 도시예요. 스마트폰, IoT 기기 등에 탑재됩니다.

🎯 요약하면,

• 마이크로프로세서는 큰 시스템의 부품
• 마이크로컴퓨터는 작지만 독립적인 시스템
• SoC는 고기능, 고집적, 멀티기능 칩!

5) 실제 사용 cpu

✅ 멀티코어 (Multi-core) CPU 예시

하나의 CPU(하나의 패키지) 내부에 여러 개의 코어가 있는 구조

CPU 이름	코어 수	주요 용도	비고
Intel Core i5-12400	6코어 12스레드	일반 PC, 게임	P코어 6개
AMD Ryzen 5 5600G	6코어 12스레드	사무용, 내장그래픽 포함	멀티코어 설계
Apple M1	8코어 (4P+4E)	맥북, 맥미니	ARM 기반 SoC
Snapdragon 8 Gen 2	8코어 (1+4+3)	플래그십 스마트폰	고성능 모바일 칩

💡 대부분의 노트북, 데스크탑, 스마트폰에 들어있는 CPU들은 멀티코어입니다.

✅ 멀티코어 프로세서 (Multi-core Processor) 예시

여러 개의 코어를 가진 CPU가 여러 개 있는 구성
즉, 멀티코어 + 멀티프로세서 조합입니다.

시스템 구성 예시	사용 CPU	총 코어 수	사용 예
듀얼 Intel Xeon Silver 4310	12코어 × 2	24코어	서버, 클러스터
듀얼 AMD EPYC 7313	16코어 × 2	32코어	가상화 서버
Apple M2 Ultra	24코어 단일 패키지	24코어 (16P+8E)	워크스테이션용 SoC
GPU 병렬 처리 연산	CUDA Core 수천 개	수천 스레드	병렬 과학 연산 (비유적 멀티코어)

💡 고성능 서버나 워크스테이션에서는 2개 이상의 멀티코어 CPU를 장착해 처리 능력을 높입니다.

멀티프로세서 시스템 (Multi-processor System) 예시

완전히 독립된 CPU(=Processor) 들이 하나의 시스템에 연결되어 있는 구조

시스템 유형	사용 프로세서	특징
대형 서버 시스템 (예: IBM Power System)	여러 개의 Power9 CPU	SMP 또는 NUMA 구조
HPC(고성능 컴퓨팅) 클러스터	각 노드에 별도 CPU	병렬 컴퓨팅, 분산 처리
이중화 시스템 (Failover Server)	두 CPU가 각각 실행	안정성, 백업 목적
엔터프라이즈 메인프레임	수십 개의 프로세서	금융, 통신 대형 시스템

💡 멀티프로세서는 하드웨어적으로 완전히 분리된 CPU를 여러 개 연결하는 구조예요. 성능보다 안정성과 병렬처리에 강점이 있죠.

🔍 정리 비교

항목	정의	예시
멀티코어	하나의 CPU 안에 여러 코어	Intel i7, M1, Ryzen 등
멀티코어 프로세서	멀티코어 CPU 여러 개	듀얼 Xeon 서버 등
멀티프로세서	독립된 CPU 여러 개	HPC, 메인프레임

3. 📦 프로그래머의 게으름이 낳은 발명: 함수, 프로시저, 서브루틴 이야기

1) 왜 함수가 생겼을까?

프로그래머들은 종종 "게으르다"는 소리를 들어요. 근데 이건 사실 비하가 아니라 창의력의 원천이기도 해요.
똑같은 코드를 두 번 이상 쓰는 걸 진심으로 싫어하거든요.

“왜 같은 코드를 또 쓰지? 한 번만 써놓고 다시 부르면 되잖아?”

이런 생각에서 함수(function)라는 개념이 등장했어요.
어떤 작업을 미리 정해놓고, 필요할 때마다 그걸 "호출"해서 쓰는 방식이죠.

함수는 실제로 프로시저(procedure), 서브루틴(subroutine) 같은 이름으로도 불려요.
쓰는 언어나 맥락에 따라 다르지만, 우리가 생각하는 기능은 거의 같아요.

함수를 프로시저나 서브루틴으로 부르는 이유는?

📌 함수, 프로시저, 서브루틴… 왜 이름이 다를까?

용어	의미	왜 그렇게 불렸을까?
함수 (Function)	어떤 값을 입력받아, 계산하고, 결과를 반환하는 코드 묶음	수학적 함수 개념에서 유래. 수학처럼 입력 → 출력이 있는 계산 단위
프로시저 (Procedure)	일련의 명령을 순서대로 실행하는 코드 묶음. 반환값이 없을 수도 있음	"절차적 절차(procedure)"라는 뜻에서, 결과를 만들기보단 작업 흐름 자체에 초점
서브루틴 (Subroutine)	메인 루틴(메인 프로그램)에서 호출되는 작은 코드 블록	옛날 어셈블리 언어나 초기 언어에서 "루틴의 하위 개념"으로 사용. 기능적 분할을 위한 용어

💡 한마디로 요약하면?

• Function은 "값을 계산해서 돌려주는 느낌"
• Procedure는 "작업을 순서대로 처리하는 절차"
• Subroutine은 "메인 작업을 도와주는 작은 기능"

서로 미묘하게 다른 느낌이 있지만, 현대의 많은 언어에서는 거의 동의어처럼 쓰이기도 해요.

예를 들어:

• C 언어에서는 void printHello() 같은 반환값 없는 것도 함수라고 부르고
• Pascal에서는 반환값이 있으면 Function, 없으면 Procedure
• 어셈블리나 옛 언어에서는 서브루틴이란 말을 더 자주 썼죠

🎯 지금은 그냥 "함수(Function)"라고 부르면 거의 다 통합니다.

하지만 이런 다양한 이름을 알고 있으면, 옛 문서나 다른 언어를 읽을 때 도움이 돼요!

"다른 이름을 가졌지만, 결국 다 같은 '게으른 프로그래머의 친구'예요." 😄

2) 함수의 모습 – 자바스크립트 예제로 보자

예를 들어, 아래처럼 자바스크립트에서는 cube(x)라는 함수를 만들 수 있어요:

function cube(x) {
  return (x * x * x);
}

이 함수는 간단하게 말해서, 어떤 숫자를 받아서 세제곱한 값을 반환합니다.

그럼 실제로 함수를 호출해서 써볼까요?

y = cube(3);      // y에는 27이 저장됨
z = cube(4) + cube(6);  // z는 64 + 216 = 280

함수 하나만 잘 정의해두면, 복붙 없이도 어디서든 쓸 수 있게 되는 거예요.

3) 근데 이게 어떻게 작동하는 걸까?

우리가 함수 cube()를 호출하면, 컴퓨터는 이런 식으로 생각합니다:

1. "좋아, 지금 작업은 잠깐 멈추고 cube 함수로 가자!"
2. "근데 나중에 어디서 돌아와야 하지? … 아, 현재 명령어 다음 주소를 기억하자!"
3. "cube 함수 실행 완료!"
4. "이제 저장해둔 그 주소로 돌아가서 다음 명령 실행하자!"

즉, "함수 호출 지점의 주소"를 저장하고, 함수 실행이 끝나면 그 주소로 점프해서 돌아오는 거예요.

4) 진짜 컴퓨터는 어떻게 기억하고 이동할까?

이건 컴퓨터 내부 구조와 관련된 일이에요. 예전 기계에서는 이렇게 처리했어요:

🧠 가상의 메모리 주소 예시 (표 5-1 방식)

주소	명령어	의미
100	pca	프로그램 카운터를 누산기로 옮김
101	add 5	5를 더해서 반환 주소 계산 (105)
102	store 200	반환 주소를 메모리 200번지에 저장
103	load 3	세제곱할 값(x)을 누산기에
104	bra 300	cube 함수로 분기 (jump)
105	함수 끝나고 여기부터 계속 실행

함수의 시작 주소는 300이고, 함수가 끝난 후엔 bra 200 (간접) 명령을 통해
200번지에 저장된 값(=105)으로 다시 분기하는 거예요.

즉,

• 함수 호출 전에는 ‘돌아갈 주소’를 따로 저장해둬야 하고,
• 함수 끝에는 ‘그 주소로 점프’해야 합니다.

이런 점프 방식은 ‘간접 분기(indirect branch)’라고도 불러요.

5) 흐름을 도식으로 보면 이렇게!

이게 바로 우리가 cube(3)을 호출했을 때 백그라운드에서 일어나는 일이에요.

6) 복잡하니까, 명령어도 진화했어요!

이렇게 함수 호출을 구현하려면 생각보다 명령어가 많이 필요해요.
그래서 CPU 설계자들은 "이거 좀 자동으로 처리해주는 명령 없을까?" 하고 고민했죠.

그 결과 나온 명령어가 바로:

✅ ARM의 BL (Branch with Link) 명령어

• BL은 함수로 점프하는 동시에 “돌아올 주소”를 링크 레지스터에 자동 저장해줘요.
• 함수에서 돌아올 땐, 링크 레지스터 값을 다시 프로그램 카운터에 넣으면 OK!

이런 식으로 프로세서들은 점점 더 똑똑하게 진화해왔어요.

📌 한눈에 요약하면?

개념	설명
함수 (Function)	코드 재사용 단위, 호출하고 반환
반환 주소 저장	함수 호출 직전에 현재 위치 저장
간접 분기	저장된 주소로 다시 이동
ARM의 BL	분기 + 반환 주소 저장을 한 번에 처리하는 명령
장점	코드 재사용, 메모리 절약, 유지보수 용이

4. 부가적인 이야기 : 🚀 ARM, 어떻게 세계를 정복했을까? - M1

앞에 나온 것 같은데 기억이 안나... 이번주에 다시 정리해야겠다.

1) ARM은 CPU를 직접 만들지 않는 CPU 회사

ARM은 CPU를 직접 만들지 않아요. 대신, 가볍고 효율적인 CPU 설계도를 만들어서 다른 반도체 회사들에게 라이선스(설계 사용권) 형태로 팔죠.

• 회사 이름은 ARM (Advanced RISC Machine)
• RISC란? Reduced Instruction Set Computer
  → 적은 수의 단순한 명령어로 효율을 높이는 구조!

이런 단순하고 가벼운 설계는 전력 소모를 줄이면서도 빠른 연산이 가능하게 만들어줘요. 그래서 스마트폰, IoT 기기, 디지털카메라 등 저전력이 중요한 기기들에 딱이에요!

2) ARM의 탄생은 BBC 교육 방송에서부터

1980년대, 영국은 '국민에게 컴퓨터를 알리자!'라는 BBC 컴퓨터 리터러시 프로젝트를 시작해요.
BBC는 교육 방송에 쓸 컴퓨터를 만들어달라고 에이콘(Acorn) 컴퓨터사에 요청했죠.

그 결과 만들어진 게 바로 BBC 마이크로(BBC Micro).
당시로선 고성능이었고, 영국 교육 시장을 평정했어요!

하지만 에이콘은 더 강력한 CPU가 필요하다고 판단, 인텔에 협조를 요청했지만 거절당하고…

결국 “그럼 우리가 만들자!” 하고 자체 CPU 개발에 뛰어듭니다.

이렇게 탄생한 게 바로 ARM = Acorn RISC Machine이에요!

3) ARM의 첫 작품: ARM2 → 인텔을 압도하다

• 첫 ARM CPU인 ARM2 (1987) 는 단 2만 7천 개의 트랜지스터로 구성됐지만,
  인텔의 80286보다 빠른 성능을 보여줘요!

• 이 기술력 덕분에 애플도 주목하게 되고,
  에이콘은 ARM 부서를 분사시켜 지금의 ARM Holdings가 됩니다.

4) 애플, 닌텐도, 스마트폰까지 – ARM의 확장

• 애플 뉴튼에 ARM CPU를 사용했고,
• 이후 아이팟, 닌텐도 DS, 초대 아이폰까지 ARM이 들어가게 돼요!

전력 소모가 적고, 발열도 낮으면서도 충분히 빠르기 때문에
모바일 기기에서는 ARM을 따라올 수 있는 아키텍처가 없었죠.

5) ARM 아키텍처, 이제는 노트북(Mac)도 접수!

2020년, 애플이 발표한 M1 칩은 ARM 기반 CPU에요.

• 이전까지는 맥북에 인텔 CPU를 썼지만,
  M1부터는 애플이 직접 설계한 ARM 기반 SoC를 사용!

• 저전력임에도 불구하고 성능이 엄청나서,
  데스크탑 분야에서도 ARM이 경쟁력을 입증했어요.

🧠 요약 정리

구분	내용
ARM이란?	저전력 RISC 기반 CPU 설계 회사 (직접 생산 X)
설계 철학	단순한 명령어 세트 → 빠르고 전력 효율 높음
시작은?	1980년대 영국, BBC 교육용 컴퓨터에서 탄생
유명 제품	애플 M1, 아이폰, 닌텐도 DS, 스마트폰 대부분
장점	전력 효율, 저발열, 모바일/IoT에 최적화
현재	노트북(Mac), 서버, 슈퍼컴퓨터까지 확장 중!

---

“단순한 설계로, 세상을 바꾼 CPU”
이게 바로 ARM의 이야기입니다 😎

🎯 스택의 등장은 다음 이야기!

지금까지는 반환 주소를 ‘200번지’ 같은 고정된 곳에 저장했어요.
그런데 재귀 함수나 여러 개의 함수가 연달아 호출될 땐 어떻게 될까요?

이때 필요한 게 바로 "스택(Stack)"입니다.
다음 장에서는, 함수를 안전하게 반복 호출할 수 있게 해주는 스택과 LIFO 구조의 등장을 이야기해볼게요.

함수 호출은 단순히 코드 분할이 아니라, 주소 기억과 점프의 미학이었습니다.

5. 🍜 스택과 재귀 함수의 마법 – 함수 호출의 진짜 원리

1) 🧠 함수는 단순하지 않다! (재귀의 세계)

프로그래밍에서 함수는 단순히 계산만 하는 도구가 아니에요.
함수가 다른 함수를 호출하거나, 심지어 자기 자신을 다시 호출할 수도 있죠!
이걸 재귀(recursion)라고 부릅니다.

예: 이미지를 재귀적으로 쪼개는 subdivide() 함수

function subdivide(x, y, size):
  if size ≠ 1 and 색이 모두 같지 않다면:
    half = size / 2
    subdivide(x, y, half)         // 왼쪽 아래
    subdivide(x, y+half, half)    // 왼쪽 위
    subdivide(x+half, y+half, half) // 오른쪽 위
    subdivide(x+half, y, half)    // 오른쪽 아래
  else:
    색 정보 저장

2) 🌳 재귀 함수와 쿼드트리 – 함수가 자기 자신을 부른다고?

“함수가 자기 자신을 부르는 건 너무 위험한 거 아냐?”
아니요! 오히려 재귀(recursion)는 많은 분야에서 아주 유용하게 사용됩니다.

예시: 이미지를 압축하는 subdivide 함수

function subdivide(x, y, size):
  if size ≠ 1 and 색이 모두 같지 않다면:
    half = size / 2
    subdivide(x, y, half)         // 왼쪽 아래
    subdivide(x, y+half, half)    // 왼쪽 위
    subdivide(x+half, y+half, half) // 오른쪽 위
    subdivide(x+half, y, half)    // 오른쪽 아래
  else:
    색 정보 저장

subdivide 함수는 이미지를 네 등분하며 재귀적으로 분할해요.
모든 픽셀이 같은 색이 아니면 계속 쪼갭니다.

모든 색이 같을 때까지 나누는 방식이에요.

이 구조는 쿼드트리(Quad Tree)라고 부르며, 트리 구조로 데이터를 표현해요.

각각의 블록이 나눌 필요가 없다면, 잎 노드(leaf node)로 남아요.

• 나뭇가지처럼 뻗어나가는 구조
• 최종 결과는 40개의 조각만 저장하면 됨
• 모든 색이 같지 않으면 → 4개의 하위 정사각형으로 분할
• 같은 색이면 더 이상 분할 X → 저장 공간 절약!

✅ 이 구조는 ‘압축’에도 유리해요. 64개의 픽셀을 40개만 저장해도 되니까요!

3) 🔁 재귀는 어떻게 돌아올 위치를 기억할까?

함수를 호출하는 순간, 컴퓨터는 두 가지 일을 해야 해요:

1. 함수로 점프해서 새로운 작업을 처리
2. 작업이 끝나면 원래 자리로 정확히 복귀

함수를 호출하면, 그 자리에서 어디로 다시 돌아와야 할지를 기억해야 해요.
이걸 “반환 주소”라고 해요.

그래서 프로그램 카운터(PC) 값, 즉 현재 위치를 어딘가에 저장해둡니다.
이게 바로 “반환 주소(Return Address)”예요.

예전에는 이 주소를 특정 메모리 위치(예: 200번지)에 저장했는데요,
만약 함수 안에서 또 다른 함수를 호출한다면…?

😨 반환 주소가 덮어쓰기 되어버리겠죠!

이 반환 주소와 함수의 지역 변수들을 저장해 두는 공간이 '스택'입니다.

4) 🍽️ 접시를 쌓는 방식 – 스택(Stack)!

✅ “접시처럼 위에 쌓고, 위에서부터 꺼낸다!”

컴퓨터는 함수를 호출할 때마다 ‘스택’에 정보를 쌓습니다.
그리고 함수가 끝나면 가장 마지막에 쌓은 정보부터 꺼내서 실행을 이어가죠.

이 방식은 LIFO 구조 (Last In, First Out)
즉, "나중에 넣은 게 먼저 나간다"는 규칙을 따릅니다.

🔧 함수 호출 시, 스택에는 어떤 정보가 쌓일까?

함수를 호출할 때, 컴퓨터는 다음 정보를 스택 프레임(stack frame)이라는 단위로 저장해요:

구성 요소	설명
반환 주소	함수 실행이 끝난 뒤 돌아가야 할 코드 위치
매개변수	함수가 처리해야 할 입력 값들
지역 변수	함수 안에서만 사용되는 변수들
상태 정보	레지스터, 조건 코드 등 특정 하드웨어 상태

이렇게 스택 프레임 하나가 함수 호출의 모든 맥락(Context)을 담고 있습니다.

🔄 호출될 때마다 쌓이고, 끝나면 빠진다

함수가 다른 함수를 호출하면?

• 새로운 스택 프레임이 위에 또 쌓이고
• 그 함수가 끝나면 스택에서 해당 프레임만 pop!

이렇게 하면 각 함수의 실행 상태가 서로 완전히 독립적으로 유지됩니다.
그래서 함수가 자기 자신을 호출하는 재귀(Recursion)도 가능한 거죠!

🎯 왜 하필 ‘스택’ 구조일까?

스택은 다음과 같은 이유로 함수 호출에 딱 맞아요:

1. 복잡한 함수 호출 구조에서도 실행 흐름을 정확하게 복원할 수 있음
2. 재귀 호출도 문제없이 처리 가능 (반환 주소가 계속 분리되어 저장되니까요)
3. 중첩된 함수 실행이 가능 (예: A → B → C 호출 후, C → B → A 복귀)

❗ 만약 반환 주소를 한 군데에만 저장하면?
→ A가 B를 호출하고 B가 C를 호출할 때,
마지막 C만 기억되고 A나 B로 돌아갈 수 없게 됩니다!

🧠 하드웨어도 스택을 특별히 지원한다!

스택이 너무 중요해서, 컴퓨터 아키텍처에는 다음과 같은 하드웨어 지원도 있어요:

• 스택 포인터(Stack Pointer) 레지스터:
  현재 스택의 꼭대기(Top)를 가리킴
• 프레임 포인터(Frame Pointer):
  현재 스택 프레임의 시작 위치
• 스택 한계(limit) 레지스터:
  스택이 넘치는 걸 방지하는 안전장치

이 덕분에 함수 호출과 반환은 빠르고 안정적으로 처리될 수 있어요.

📦 스택을 사용하는 또 다른 예들

• 인터럽트 처리: 외부 이벤트가 발생했을 때, 현재 작업을 스택에 저장
• 예외 처리 (try/catch): 예외 발생 시 호출 스택을 추적해 오류 위치를 찾아냄
• 멀티스레딩: 각 스레드는 자신만의 스택 공간을 가짐 (독립적인 함수 실행을 위해)

“스택은 함수 호출의 은밀한 조력자입니다.
프로그램이 복잡해질수록, 스택은 더 바쁘게 움직이고 있어요!” 😎

5) 🧠 함수 호출의 숨은 비밀 – 스택이 없다면 아무 것도 돌아가지 않는다!

✅ 왜 스택이 필요할까?

함수를 호출하면 컴퓨터는 그 함수 안에서 무엇을 해야 할지 여러 정보를 기억해야 합니다:

1. 어디서 왔는지? → 반환 주소
2. 무엇을 처리해야 하는지? → 인자(argument)
3. 처리 중 필요한 변수는? → 지역 변수(local variable)

이 모든 정보를 한 곳에 담아두지 않으면,
함수가 끝났을 때 원래 자리로 돌아갈 수 없고, 처리 흐름도 엉망이 돼버립니다.

🧱 각 호출마다 ‘스택 프레임(Stack Frame)’이 생성된다

함수를 호출할 때마다 생기는 작은 저장 공간이 바로 스택 프레임입니다!

스택 프레임에는 다음과 같은 정보들이 들어 있어요:

구성 요소	설명
반환 주소	함수 실행이 끝난 뒤 돌아갈 위치
매개변수 (인자)	호출 시 전달된 입력 값
지역 변수	함수 내에서만 사용하는 임시 값
이전 스택 포인터	함수 종료 후 스택 복구를 위한 포인터 저장

이 프레임은 스택(Stack)이라는 자료구조에 위에서부터 쌓이고,
함수가 끝나면 해당 프레임이 제거(pop)되며 실행이 이어져요.

📌 스택이 없다면 이런 문제가 생겨요!

int add(int a, int b) {
    return a + b;
}

int doubleAdd(int x) {
    return add(x, x) + add(x, x);
}

위 코드는 add(x, x)를 두 번 호출하죠.
스택이 없으면 두 번째 add() 호출 시 첫 번째 호출의 반환 주소와 변수들이 덮어쓰기되기 때문에
정상적인 결과를 기대할 수 없습니다.

🧠 스택이 있기 때문에 두 호출의 정보가 서로 분리되어 안전하게 처리됩니다!

🔁 재귀 호출의 대표 사례: 팩토리얼

int factorial(int n) {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

이 함수가 factorial(5)를 호출하면, 내부적으로 이런 호출이 연쇄적으로 일어나요:

factorial(5)
 ↳ factorial(4)
   ↳ factorial(3)
     ↳ factorial(2)
       ↳ factorial(1)

각 호출마다:

• n의 값이 달라야 하고
• 각각 다른 반환 주소로 돌아가야 해요

이 모든 걸 기억하는 공간이 스택이며,
factorial(1)이 종료되면 스택 프레임이 하나씩 pop되며
n * factorial(n-1)이 계산됩니다.

🌟 요약하면!

개념	설명
스택(Stack)	함수 호출 시 컨텍스트 정보를 저장하는 공간
스택 프레임	하나의 함수 호출에 대한 정보 묶음
반환 주소	어디로 돌아가야 할지 저장
함수 인자, 지역 변수	호출 시 필요한 데이터 저장
재귀 호출	스택이 있어야만 가능
스택 오버플로	너무 많은 호출 → 메모리 초과

함수가 함수 안에서 또 다른 함수를 호출하는 구조(또는 자기 자신을 재귀 호출)는
각 호출마다 ‘고유한 반환 주소와 변수’를 기억해야 합니다.

✅ 이 모든 것을 담는 저장소가 바로 스택(Stack)이에요!

• 반환 주소도
• 지역 변수도
• 함수 인자도

모두 스택에 저장됩니다.

→ 함수가 끝나면, 그에 해당하는 스택 프레임이 제거되고
→ 다시 원래 함수의 실행이 이어집니다.

“스택은 함수가 호출되는 순간부터, 끝날 때까지의 모든 여정을 책임지는 비서 같은 존재입니다.”
🧠 함수를 이해하려면, 그 뒤에 있는 스택의 원리를 꼭 알아야 해요!

6) 🌐 깊이 우선 탐색 vs 너비 우선 탐색

• 깊이 우선 탐색(DFS):
  가능한 한 한 방향으로 깊이 들어가다가, 막히면 돌아오는 방식

• 너비 우선 탐색(BFS):
  수평적으로 옆으로 먼저 이동한 뒤, 아래로 내려가는 방식

재귀 함수의 호출 방식은 DFS와 매우 유사합니다.
트리 구조를 순회할 때마다, 깊게 파고들고, 돌아오는 과정에서 스택이 사용돼요!

7) 📦 스택의 위험 – Stack Overflow & Underflow

⚠️ Stack Overflow가 발생하는 이유

재귀 호출이 너무 깊어지거나, 스택을 너무 많이 쓰면 어떻게 될까요?

✅ 스택 오버플로(Stack Overflow) 발생!
→ 스택 메모리 영역을 초과하면서 프로그램이 강제 종료돼요.

예:

def infinite_rec():
    infinite_rec()

infinite_rec()  # 💥 StackOverflowError 발생!

이건 마치 식당에서 접시가 천장까지 쌓여서 무너지는 상황과 같아요.

• 스택 오버플로(Stack Overflow)
  → 스택 공간이 꽉 찼는데 또 push 하려 하면 발생! 😱
  → 재귀가 너무 깊으면 이 문제가 발생할 수 있어요.

• 스택 언더플로(Stack Underflow)
  → 비어있는 스택에서 pop 하려고 하면 발생! ❌

✅ 그래서 스택은 하드웨어에서도 엄청 중요하게 다뤄요.
MMU는 스택 한계(overflow)를 감지할 수 있는 장치도 갖고 있어요.

8) 📏 중위 / 전위 / 후위 표기법과 스택 언어

• 중위 표기법 (Infix): 1 + 2
• 전위 표기법 (Prefix): + 1 2
• 후위 표기법 (RPN): 1 2 +

후위 표기법은 스택으로 쉽게 구현 가능해요!

예: 1 2 + 3 4 + ×

→ 스택에 1, 2 push → + 연산
→ 스택에 3, 4 push → + 연산
→ 두 결과를 ×

이런 방식은 PostScript, Forth, RPN 계산기 등에서 사용됩니다.

📌 한눈에 보는 요약표

개념	설명
재귀 함수	자기 자신을 호출하는 함수
subdivide	이미지를 쪼개서 압축하는 재귀 함수
쿼드트리	사분할 기반 트리 구조
깊이 우선 탐색	깊게 파고든 뒤 돌아오는 구조 (재귀와 비슷)
스택	함수 호출 시 반환 주소와 변수 저장
스택 프레임	스택에 저장되는 단위 (주소, 지역변수 등 포함)
스택 오버플로	스택이 가득 찼을 때 발생하는 오류
수식 표기법	중위 / 전위 / 후위 (RPN) 등 다양한 표현법

"재귀 호출과 스택이 없다면, 함수는 단 한 번밖에 돌아갈 수 없을 거예요."
→ 컴퓨터는 기억하는 법도, 되돌아가는 법도 알고 있답니다!

6. 🛎️ 쿠키 굽는 중 초인종이 울리면? – 컴퓨터 인터럽트 시스템 완전 정복

1) 🍪 쿠키 반죽하다가 생긴 문제: 컴퓨터에도 벌어지는 일

자, 상상해봅시다. 오늘은 집에 혼자 있는 날이고, 당신은 주방에서 맛있는 초콜릿 칩 쿠키를 만들고 있어요. 반죽기에서 버터를 녹이고, 설탕을 넣고, 재료를 하나하나 섞으며 레시피를 따라가죠. 그런데 이때…

🛎️ “딩동!”

문 앞에서 누군가 초인종을 눌렀습니다. 중요한 소포일 수도 있고, 그냥 지나가던 세일즈맨일 수도 있어요. 그런데 문제는—쿠키 반죽 중간에 누가 왔는지 알 방법이 없다는 것입니다. 쿠키를 태우지 않으면서도 누가 왔는지 확인하려면 어떻게 해야 할까요?

바로 이 상황, 컴퓨터에서도 그대로 일어납니다.
컴퓨터는 "한 번에 한 가지 작업"을 순서대로 착실히 처리하지만, 갑자기 중요한 외부 이벤트(입력, 도착한 네트워크 패킷, 알람 등)가 발생할 수도 있죠.

그럼 컴퓨터는 어떻게 초인종에 반응할까요?

답은 바로 인터럽트(Interrupt) 시스템입니다.

2) 📜 순서도 이야기: 폴링(polling)과 그 한계

처음엔 이렇게 할 수 있습니다:

쿠키 굽기 → 초인종이 울렸는지 확인 → 아니면 계속 → 또 확인 → 또 확인

이런 방식은 실제로 존재해요. 이름하여 폴링(polling). 컴퓨터가 일정 주기마다 외부 입력이 있는지 계속 검사하는 방식이죠. 초인종이 울렸는지 반복적으로 확인하는 거예요.

하지만 이 방식은 문제가 많아요:

• 초인종이 안 울렸다면? 👉 확인하는 데 불필요한 시간 낭비
• 초인종이 울렸지만 확인 전에 지나쳤다면? 👉 기회를 놓침

👎 “계속 쳐다봐야 반응할 수 있는 시스템, 비효율적이죠.”

그래서 더 똑똑한 시스템이 필요했습니다.

3) 🧠 컴퓨터의 똑똑한 반응 – 인터럽트 시스템의 등장

이제 컴퓨터는 마치 초인종이 울릴 때만 반응하는 초인종 시스템을 갖게 됩니다.

이게 바로 인터럽트 시스템입니다.

• Interrupt (인터럽트): 현재 작업을 잠시 중단하고, 더 중요한 일에 즉시 반응할 수 있게 해주는 시스템
• 즉, 초인종이 울리면 쿠키 반죽을 잠깐 멈추고 문 앞을 확인한 뒤, 다시 돌아오는 방식

✔️ 인터럽트가 필요한 이유

상황	설명
키보드 입력	사용자가 키를 누르면 즉시 반응해야 함
타이머 알람	프로그램을 일정 시간 후 멈추거나 재시작해야 함
네트워크 수신	데이터가 도착했을 때 즉시 읽어야 함
예외 처리	오류 상황이 발생하면 즉시 중단하고 조치 필요

🔌인터럽트란?

컴퓨터는 순서대로 명령어를 착실하게 실행합니다.
하지만 현실 세계는 예측 불가능하죠.

• 키보드를 눌렀을 때
• 마우스를 클릭했을 때
• 타이머가 종료됐을 때
• 0으로 나누는 연산이 발생했을 때

이런 상황에서 CPU는 현재 작업을 잠깐 멈추고,
더 중요한 작업(초인종 응대 등)을 처리한 뒤,
다시 돌아와 원래 작업을 계속합니다.

그 중심에 있는 것이 바로 인터럽트 시스템입니다.

4) 🏛️ 인터럽트의 구성 요소: 쿠키로 이해하는 컴퓨터 구조

컴퓨터 구성 요소	쿠키 비유
프로그램	쿠키 레시피
CPU	요리사
메모리	재료 창고
인터럽트 신호	초인종 벨
인터럽트 핸들러	문 열고 응대하는 행동

요즘 쓰이는 프로세서 대부분은 인터럽트 시스템이 들어갑니다.

인터럽트 시스템은 적절한 신호가 들어오면 CPU 실행을 잠깐 중단시킬 수 있는 핀이나 전기 연결을 포함한다. 핀pin은 칩에 연결된 전기적 접점을 뜻하는 말이다.

칩에는 핀처럼 보이는 부품이 있는 경우가 많았지만, 장치 크기가 줄어듦에 따라 다른 방식도 쓰이기 시작했다. 많은 프로세서 칩(특히 마이크로컴퓨터)에는 통합 주변장치가 들어 있고(이런 장치를 온칩on-chip I/O 장치라고도 한다),

이런 장치들은 내부적으로 인터럽트 시스템에 연결되어 있다.

5) ⚙️ 인터럽트의 작동 흐름

자, 인터럽트가 어떻게 작동하는지 실제 컴퓨터 관점에서 살펴볼까요?

1단계: 인터럽트 발생

• 키보드, 네트워크, 타이머 등에서 "지금 봐야 해!"라는 신호가 도착

2단계: 현재 CPU 상태 저장 - 직압 장ㄹ;

• CPU는 지금 진행하던 작업을 잠깐 멈추고
• 프로그램 카운터(PC) 값과 레지스터 상태를 스택에 저장함
• PC(Program Counter)
• 레지스터 값
• 실행 중인 코드의 정보 (→ PCB 또는 스택에 저장)

3단계: 인터럽트 핸들러 실행

• 미리 정해진 인터럽트 벡터를 따라
• 해당 인터럽트 핸들러 함수로 점프
• 핸들러가 그 상황을 처리

4단계: 원래 작업 복귀

• 스택에 저장해둔 PC와 레지스터 정보 복구
• 중단한 지점부터 다시 프로그램 실행 재개!

✅ 즉, 인터럽트는 함수 호출과 유사하지만, 외부 이벤트가 발생해야 작동해요.

6) 🧰 인터럽트의 내부 구성: 어떤 구조로 되어 있나?

🔸 인터럽트 벡터 테이블 (Interrupt Vector Table, IVT)

• 인터럽트가 발생하면, CPU는 어디로 점프할지 알아야 하죠?
• 각 인터럽트에 해당하는 핸들러 주소가 저장된 테이블입니다.
• 0x0000~0x00FF 같은 고정된 메모리 주소에 위치하는 경우가 많아요.

인터럽트 번호	의미	핸들러 주소
0	나눗셈 오류	0x0010
1	키보드 입력	0x0020
2	타이머 알림	0x0030
3	외부 장치 신호	0x0040

인터럽트 구성 요소

구성 요소	설명
인터럽트 라인	하드웨어 신호선 (CPU로 요청 전달)
인터럽트 벡터	인터럽트 종류별 처리 루틴의 주소 테이블
인터럽트 핸들러	실제 인터럽트를 처리하는 함수
PCB / 스택	작업 상태 저장소 (복귀를 위해 필수!)

7) 📦 인터럽트는 스택을 활용한다

인터럽트도 결국은 일종의 함수 호출입니다.
그래서 컴퓨터는 인터럽트를 처리할 때 현재 상태를 스택에 저장합니다.

• PC 값 (어디까지 실행했는지)
• 주요 레지스터 (중간 계산값들)
• 인터럽트 핸들러에서 사용하는 지역 변수

이 모든 걸 저장한 뒤, 작업이 끝나면 스택에서 pop해서 원래대로 돌아옵니다.

📌 그래서 스택이 없다면 함수 호출도, 인터럽트도 제대로 작동할 수 없어요!

8) ⏱️ 인터럽트의 핵심 이슈 – 응답 시간과 복귀

1. 반응 시간 (Response Time)

• 인터럽트가 발생했을 때, 얼마나 빨리 반응할 수 있느냐?
• 너무 느리면? → 쿠키는 타버리고, 데이터는 사라져요.

2. 상태 복귀 (State Restoration)

• 인터럽트가 끝난 뒤, 원래 프로그램이 정확히 이어서 돌아가야 해요.
• 실행 중인 레지스터 값, 프로그램 흐름 등 모든 걸 복구해야 함

9) 🔀 인터럽트에도 우선순위가 있다

모든 인터럽트가 동등하게 중요한 건 아니에요.

예를 들어,

• 초인종보다 화재 경보기가 더 중요하겠죠?

그래서 컴퓨터는 각 인터럽트에 대해 우선순위(priority)를 설정합니다.

• 우선순위가 더 높은 인터럽트가 발생하면, 낮은 인터럽트 핸들러도 중단되고 새로운 핸들러로 진입할 수 있어요. (Nested Interrupts)

10) 🛡️ 인터럽트를 잠시 막는 기술 – 마스킹(Masking)

일부 상황에서는 인터럽트를 아예 무시하거나 차단할 필요도 있어요.

• 예: 데이터를 복사하는 아주 민감한 시점엔 방해받고 싶지 않음
• 이럴 때는 인터럽트 마스크를 설정해 특정 인터럽트를 비활성화할 수 있어요.

"지금 바쁘니 초인종 소리 무시해주세요" – 이 느낌입니다.

11) 🔥 예외 처리도 인터럽트다?

인터럽트는 꼭 외부에서만 발생하지 않아요. 컴퓨터 내부에서도 예외(Exception)라는 형태로 발생할 수 있어요.

예외 상황	설명
0으로 나누기	수학적 오류
메모리 초과	스택 오버플로
접근 금지	보호된 영역 침범

이때도 인터럽트 벡터를 따라 예외 핸들러로 점프하여 문제를 처리합니다.
예외 상황에 대한 복구, 로깅, 사용자 메시지 출력 등이 이때 실행되죠.

12) 🎛️ 인터럽트를 만드는 주체들

인터럽트는 다음과 같은 장치나 요소들에 의해 생성될 수 있어요.

발생 주체	예시
하드웨어	키보드, 마우스, 네트워크, 타이머
소프트웨어	시스템 콜, 유닉스 시그널, 소프트웨어 인터럽트
내부 이벤트	예외, 디버깅, 불법 명령 실행 등

13) 🧵 운영체제와 인터럽트: 멀티태스킹의 기반

운영체제는 인터럽트를 멀티태스킹의 기반으로 사용해요.

• 일정 시간마다 타이머 인터럽트가 발생하면
• 현재 실행 중인 프로그램을 중단
• 문맥 교환(Context Switch)를 수행
• 다음 프로그램으로 전환!

즉, 여러분이 윈도우에서 크롬과 카카오톡을 동시에 실행할 수 있는 건 인터럽트 시스템 덕분이에요.

14) 📱 현실의 예시 – 인터럽트는 여기저기서 쓰인다

• 📷 카메라 앱: 버튼 누르자마자 반응
• 🧠 IoT 기기: 센서 값 변화 즉시 처리
• 🕹️ 게임: 키 입력이나 충돌 이벤트 감지
• 🖥️ 서버: 클라이언트 요청 도착 시 즉시 대응

⚙️ 15) 인터럽트의 종류

✅ 하드웨어 인터럽트

• 외부 장치(키보드, 마우스, 타이머, 네트워크 등)가 요청
• CPU가 외부의 신호에 반응

✅ 소프트웨어 인터럽트 (Trap)

• 프로그램 내부에서 발생
  • 예외(Exception): 0으로 나누기, 잘못된 메모리 접근 등
  • 시스템 콜(System Call): 사용자 → OS 요청

📌 Trap도 인터럽트다! 단지 “소프트웨어가 발생”시켰다는 점만 다름.

출처 : https://velog.io/@woo00oo/%EC%9D%B8%ED%84%B0%EB%9F%BD%ED%8A%B8Interrupt

15) 🧠 한 장으로 보는 인터럽트 요약

항목	설명
인터럽트	외부 이벤트에 대응하기 위해 프로그램 실행을 잠시 멈추는 메커니즘
핸들러	인터럽트 발생 시 실행되는 특별한 함수
스택	현재 상태를 저장하고 복구하는 데 사용
벡터 테이블	각 인터럽트 번호에 대한 핸들러 주소를 저장
우선순위	더 중요한 인터럽트를 먼저 처리 가능
마스킹	특정 인터럽트를 잠시 비활성화 가능
예외	내부 오류도 인터럽트처럼 처리
응답 시간	빠른 반응이 중요! (실시간 시스템에서 핵심)

🧁 마무리 – 쿠키를 태우지 않으려면?

쿠키 반죽을 하면서도 초인종에 반응할 수 있는 방법.
그게 바로 컴퓨터의 인터럽트 시스템입니다.

이 시스템 덕분에 우리는:

• 여러 프로그램을 동시에 돌릴 수 있고
• 사용자 입력에 즉시 반응하고
• 갑작스러운 상황에도 적절히 대응할 수 있어요.

“컴퓨터가 똑똑한 이유?
쿠키를 태우지 않고, 소포도 놓치지 않는 인터럽트 시스템 덕분이에요!”

7. ⏱️ CPU는 어떻게 시간을 나눌까? – 시분할과 주소 지정

1) 🎬 멀티태스킹은 어떻게 가능한가요?

우리는 평소에 컴퓨터에서 여러 프로그램을 동시에 실행합니다.
하지만 CPU는 한 번에 하나의 명령어만 처리할 수 있어요.

그렇다면, 어떻게 유튜브와 카카오톡을 동시에 실행할 수 있을까요?

✅ 해답은 바로 운영체제(OS)가

• 시간(Time)을 쪼개고 ⏱️
• 공간(Memory)을 나눠서 🧱
  각 프로그램에 조금씩 번갈아가며 CPU를 할당하는 데 있습니다.

2) 🧠 운영체제의 역할: 프로그램들의 관리자

운영체제는 컴퓨터 자원을 관리하는 시스템 프로그램입니다.

관리자 프로그램을 운영체제 또는 운영체제 커널이라고 하고 OS와 OS가 관리하는 프로그램을 구분하기 위해 OS를 시스템 프로그램이라고 부르고 다른 모든 프로그램을 사용자 프로그램이나 프로세스라고 부릅니다.

용어	설명
운영체제(OS)	시스템 자원을 총괄 관리하는 관리자
커널(Kernel)	운영체제의 핵심 기능 집합
사용자 프로그램	일반 사용자가 실행하는 앱
프로세스(Process)	실행 중인 사용자 프로그램

운영체제는 CPU, 메모리, 저장장치, 입출력 장치 등을 관리하며
여러 프로그램이 동시에 돌아가는 환경을 만들어줍니다.

커널 관련 정리 : 리눅스 개요 : 커널이 뭐에요? 왜 필요해?

3) ⏲️ 시간 분할: 시분할 스케줄링(Time Slicing)

운영체제는 타이머 인터럽트를 통해
각 프로그램이 얼마나 CPU를 썼는지 파악하고,
일정 시간이 지나면 다른 프로그램으로 전환시킵니다.

시분할 스케줄링 흐름
A 프로그램 실행 시작
→ 타이머 인터럽트 발생
→ A 상태 저장
→ B 프로그램 실행
→ 다시 타이머 인터럽트
→ B 상태 저장
→ A 복귀

⏳ 사용자 프로그램의 실행 시간을 조절하는 스케줄링scheduling 기법을 이를 "시분할(Time Slicing)"이라 부르며,
컴퓨터는 마치 빠른 줄넘기 교대처럼 프로그램을 번갈아 실행합니다.

4) 📦 상태 저장과 문맥 교환(Context Switch)

각 프로그램의 현재 상태를 저장하고 복원하는 과정이 필요합니다.
이걸 문맥(Context)이라고 부르고, 교환 과정은 문맥 교환(Context Switch)이라 해요.

✅ 문맥 교환은 시간이 드는 작업이지만, 멀티태스킹의 핵심입니다!

5) 🏠 공간 분할: 여러 프로그램을 메모리에 올리는 방법

운영체제는 메모리를 아래처럼 나눠서 프로그램을 올립니다.

사용자 프로그램은 하나씩 차례로 메모리에 올라갑니다.

하지만 이때 절대 주소 방식으로 작성된 프로그램은 문제가 생길 수 있어요.

우리가 예로 든 컴퓨터는 절대 주소 지정absolute addressing을 사용했어요. 절대 주소 지정은 명령어 주소가 특정 메모리 주소를 가리킨다는 뜻입니다.

예를 들어, 1000번지에서 실행되도록 만든 프로그램을 2000번지에 올리면… 오류 발생!

6) 🧭 주소 문제 해결법: 인덱스 레지스터와 상대 주소 지정

(1) 인덱스 레지스터 (Index Register)

컴퓨터 CPU 의 인덱스 레지스터 는 프로그램 실행 중 피연산자 주소를 가리키는 데 사용되는 프로세서 레지스터 (또는 할당된 메모리 위치) 입니다.

문자열 과 배열을 단계별로 실행하는 데 유용합니다. 루프 반복 및 카운터를 보관하는 데에도 사용할 수 있습니다.

절대 주소 지정 문제의 해결법으로 나타났어요!!

• 컴퓨터는 명령어에 ‘직접 주소’를 넣지 않고, 간접적으로 계산해서 유효 주소(Effective Address)를 만들어내는 방식
• 이건 어떤 명령어가 어디의 데이터를 참조해야 할지를 결정하는 과정이에요.

출처 : https://blog.naver.com/k97b1114/140157844146

좀 더 자세히 설명하자면,

🧾 명령어 주소 (Instruction Address)

• 명령어 안에 들어 있는 주소 부분입니다.
• 즉, 기준이 되는 상대적인 주소, 또는 오프셋(offset)이라고 생각하면 돼요.
• 예: LOAD 100 → “100번지의 데이터를 불러와줘!”

하지만 이건 어디까지나 기준 주소에 더해져야 하는 상대 주소예요. 실제 위치는 아직 아니에요!

🧮 인덱스 레지스터 (Index Register)

• 이건 OS나 CPU가 “현재 이 프로그램은 어디서부터 실행 중이다”를 알려주는 기준 시작점이에요.
• 즉, “기준이 되는 주소(=베이스)”라고 생각하면 됩니다.

예를 들어, 어떤 프로그램이 3000번지부터 실행 중이라면, 인덱스 레지스터는 3000으로 설정됩니다.

➕ 유효 주소 (Effective Address)

• 실제로 메모리에서 접근해야 할 주소예요.
• 계산 방식은 단순해요!

유효 주소 = 인덱스 레지스터 값 + 명령어 주소 (오프셋)

이 말은,

• 이 명령어는 원래는 100번지의 데이터를 보려는 명령이었지만,
• 지금 이 프로그램이 2000번지부터 시작했기 때문에
• 실제로는 2000 + 100 = 2100번지의 데이터를 참조해야 한다는 뜻이에요!

용어	의미
명령어 주소 (offset)	명령어 안에 있는 상대 주소. “이만큼 떨어진 곳”
인덱스 레지스터	현재 프로그램이 시작된 기준 주소
유효 주소	실제로 접근하는 메모리 주소 = 기준 + 상대값

(2) 상대 주소 지정 (Relative Addressing)

✅ 왜 상대 주소 지정이 필요할까?

• 우리가 작성한 프로그램은 언제나 메모리의 같은 위치에서 실행되지 않아요.
  운영체제가 그때그때 프로그램을 다른 위치에 로딩할 수 있기 때문이에요.
• 하지만 프로그램 코드 안에 절대 주소가 박혀 있으면 이식성이 떨어지겠죠.
• 그래서 명령어 주소를 기준으로 상대적인 거리만 기억하도록 하면,
  어디에 프로그램이 위치하든지 유효 주소는 정확하게 계산됩니다.

📦 예시

• 현재 명령어가 메모리 주소 4000에 위치해 있고,
• +20 떨어진 곳에 점프하려는 명령이 있다면,
  → 유효 주소는 4000 + 20 = 4020

이처럼 상대 주소 지정은 다음과 같은 장점이 있어요:

장점	설명
위치 독립성	프로그램이 메모리의 어느 위치에 로드되든 정상적으로 동작 가능
코드 재사용성	다른 위치에서도 동일 코드 사용 가능 (특히 공유 라이브러리 등에서 유리)
컴파일러 최적화	컴파일러가 오프셋(상대 거리)만 계산하면 되므로 구현 간결

🔧 요즘 대부분의 컴파일러와 어셈블러는 이 상대 주소 계산을 자동으로 처리해 줍니다.
우리는 jump +4 같은 코드만 쓰면, 실제 메모리 주소 계산은 기계가 해주죠!

📌 추가 팁: 상대 주소는 보통 분기(branch) 명령어에서 많이 쓰여요

4000:  CMP A, 10       ; 비교
4001:  JE +4            ; 조건이 참이면 4005번지로 점프
4002:  ...              ; 다른 명령어
4005:  PRINT "OK"       ; 점프 대상

이처럼 현재 위치를 기준으로 점프 대상을 지정하면,
프로그램이 어느 위치에 올라가더라도 정확히 원하는 명령으로 이동할 수 있습니다.

🔧 요즘 컴파일러는 이런 상대 주소 계산을 자동으로 해줍니다.

주소 지정 방식 더 알아보기 : https://blog.naver.com/k97b1114/140157844146

7) 🔄 프로그램의 재배치(Relocation)

이런 주소 지정 기술을 활용하면,
운영체제는 프로그램을 메모리의 어떤 위치든 자유롭게 올려서 실행할 수 있어요.

• 절대 주소를 쓰지 않아도 되니까 메모리 충돌 없음
• 여러 프로그램이 한꺼번에 올라가도 문제 없이 동작 가능

8) 🧠 요약 정리: 운영체제가 멀티태스킹을 해내는 방법

항목	설명
운영체제(OS)	시스템 자원 관리자
시분할(Time Slicing)	CPU 시간을 잘게 나눠 여러 프로그램에 할당
타이머 인터럽트	일정 시간마다 스위칭을 알림
문맥 교환(Context Switch)	프로그램 상태를 저장하고 복원
인덱스 레지스터	명령어 주소에 기준값을 더해 유효 주소 계산
상대 주소 지정	명령어 기준으로 주소를 계산
재배치(Relocation)	프로그램을 메모리의 어디든 옮겨 실행 가능

🎬 마무리 – 운영체제는 모든 것을 조율하는 무대 감독

• CPU는 빠르게 실행만 하고
• 메모리는 그냥 저장소고
• 진짜 조율자는? 👉 운영체제!

“멀티태스킹이 가능한 이유?
운영체제가 시간과 공간을 잘 쪼개서 프로그램들을 조화롭게 조율하기 때문입니다.” 🎵

8. 🧠 내 컴퓨터 메모리는 ‘진짜’가 아닐 수도 있다? – MMU와 가상 메모리 이야기(프로그램은 어떻게 메모리 안에서 안전하게 실행될까?)

MMU(Memory Management Unit)는 컴퓨터 메모리를 훨씬 더 유연하게 만들어주는 마법 같은 장치입니다. 주기억장치관리의 핵심은 '메인 메모리를 어떻게 잘 관리할 수 있을까'에 있습니다.

메모리를 좀 더 자세히

1) 🚨 멀티태스킹의 시대, 안전은 필수다!

과거에는 컴퓨터가 한 번에 하나의 프로그램만 실행해도 충분했지만,
요즘은 백그라운드에서 여러 프로그램이 동시에 실행되는 멀티태스킹이 당연한 시대예요.

하지만 문제가 있습니다.

• 여러 프로그램이 한 메모리를 공유할 경우
• 버그가 난 프로그램이 다른 프로그램의 메모리를 침범할 수 있음
• 심하면 운영체제(OS) 자체의 메모리를 덮어쓸 수도 있음

🧨 보안 위협뿐만 아니라, 시스템 전체가 뻗을 수 있어요!

그래서 필요한 것이 바로 MMU (Memory Management Unit)입니다.

2) 🧰 MMU란 무엇인가요?

MMU는 컴퓨터에 들어 있는 하드웨어 장치로,

✅ 프로그램이 사용하는 "가상 주소"를 실제 "물리 주소"로 변환해주는 장치입니다.

출처 : https://velog.io/@tycode4/%EA%B0%80%EC%83%81-%EB%A9%94%EB%AA%A8%EB%A6%AC

우리가 보통 알고 있는 가상 메모리는:

"MMU가 프로그램이 사용하는 가상 주소를 물리 주소로 바꿔주는 시스템"

...이 정도로 알고 있지만, 사실 그 기능은 시작일 뿐이고, 진짜 강력한 기능은 훨씬 더 대담한 착각(!)을 만들어내요.

🧠 프로그램은 "메모리 부족"을 모른다?
운영체제는 이렇게 속입니다:

“그래, 네가 필요한 만큼 메모리가 있는 것처럼 써도 돼~ 내가 뒤에서 알아서 해줄게!”

실제로는 메모리가 부족해도 프로그램이 느끼지 않도록, 페이지 폴트(page fault)와 함께 요구불 페이징(demand paging) 기법이 작동합니다.

즉, 프로그램은 자신이 마치 독립적인 메모리를 갖고 있는 것처럼 느끼게 만들어 주는 장치죠.

용어	설명
가상 주소	프로그램이 사용하는 주소. 겉보기용
물리 주소	실제 메모리(RAM) 상의 위치
MMU	가상 주소 → 물리 주소로 바꿔주는 장치

📌 이 과정 덕분에 여러 프로그램이 서로 독립된 공간에서 실행되는 것처럼 동작할 수 있어요!

3) 🧭 가상 주소의 동작 원리: 페이지와 페이지 테이블

MMU는 가상 주소를 물리 주소로 단순히 1:1 매핑하지 않습니다.
대신, 페이지(Page)라는 단위로 메모리를 관리하죠.

📦 Demand Paging(요구불 페이징)이란?

프로그램이 진짜로 필요한 페이지만 물리 메모리에 올려요.

나머지는 아직 메모리에 없어요. 필요할 때 그때그때 불러옵니다.

마치 넷플릭스에서 보고 싶은 장면만 스트리밍하는 것과 같아요.

📦 페이지란?

• 메모리를 일정한 크기로 쪼갠 단위 (예: 256B, 4KB 등)
• 프로그램은 페이지 단위로 메모리를 할당받고 사용

📑 페이지 테이블(Page Table)

• 각 프로그램마다 자신의 가상 페이지가 어느 물리 페이지에 매핑되는지 저장하는 테이블
• . 페이지 테이블에는 각 페이지가 물리 메모리상에서 차지하는 실제 위치 정보가 들어 있어 있습니다.
• 프로그램마다 다르고, 운영체제가 관리함

🔁 MMU 주소 변환 흐름

CPU는 무조건 가상메모리만을 참조해달라고 요청하고, 그 가상메모리 주소가 실제 어느 물리 주소에 있는지 MMU가 변환 시켜주고, 그 해당 물리 메모리에 접근을 하여 그 해당 데이터를 CPU에 전달합니다.

1. 프로그램은 가상 주소를 사용해 메모리에 접근
2. MMU가 가상 주소의 페이지 번호를 읽고
3. 해당 페이지 번호를 페이지 테이블에서 검색하여
4. 매핑된 물리 페이지의 주소로 접근!

가상 주소는 연속적이지만, 물리 주소는 불연속일 수 있음 → 메모리 조각 문제 방지!

이로 인해 페이징 기법이 생겨남 더 읽어보기

페이지 테이블은 그냥 메모리의 일부분

프로그램 입장에서는 가상 메모리가 연속적인 것처럼 보이지만, 실제 물리 메모리상의 위치는 굳이 연속적일 필요가 없습니다.

심지어 프로그램이 실행되는 도중에 프로그램이 위치한 물리적 메모리 주소가 바뀔 수도 있어요.

그리고 프로그램들이 서로 협력하는 경우에는 여러 프로그램의 가상 메모리 중 일부가 같은 물리 메모리를 함께 사용하는 공유 메모리 기능을 제공할 수도 있어요.

이제 페이지 테이블의 내용이 프로그램 문맥의 일부분이 된다는 사실에 유의하고 보면, 페이지 테이블은 그냥 메모리의 일부분이 됩니다.

4) 💡 예시: 16비트 주소와 페이지 테이블

가상 주소: A15~A0 (총 16비트)

• 상위 비트(A15~A8) → 페이지 번호 (256개 페이지)
• 하위 비트(A7~A0) → 페이지 안의 오프셋

페이지 테이블:

가상 페이지 번호	매핑된 물리 페이지 번호
0	8
1	5
...	...

→ 예를 들어, 가상 주소 0x01A2는:

• 페이지 번호: 0x01
• 오프셋: 0xA2
• 페이지 테이블을 통해 → 물리 페이지 5번 → 0x05A2로 변환됨

5) 🧷 프로그램 분리를 통한 보안성 강화

MMU가 없다면?

• 프로그램 1이 프로그램 2의 메모리를 침범할 수 있음
• 악성 코드가 운영체제를 덮어쓸 수 있음

MMU가 있다면?

• 각 프로그램은 자기만의 가상 메모리 공간을 가짐
• 서로의 메모리에 접근할 수 없음
• 운영체제의 메모리 영역도 보호됨 (커널 모드 전용)

6) 📛 예외 처리와 페이지 폴트와 스왑

📍 페이지 폴트(Page Fault)

• 프로그램이 존재하지 않는 가상 주소에 접근하면 발생하는 예외
• OS는 이 예외를 받아 새 메모리 페이지를 할당하거나, 프로그램을 중단함

📌 활용 예시: 스택 오버플로

• 스택이 범위를 초과하면 → 페이지 폴트 발생
• OS가 스택을 위한 메모리를 확장해줄 수 있음 (동적 증가)

💿 스왑 아웃(Swap Out) / 스왑 인(Swap In)

운영체제는 물리 메모리가 꽉 찼을 때 이렇게 처리해요:

동작	설명
💤 스왑 아웃	사용하지 않는 페이지를 디스크로 옮김 (속도 느림)
⚡ 스왑 인	프로그램이 그 페이지를 다시 필요로 할 때, 디스크에서 다시 불러옴

이 과정을 통해 물리 메모리가 실제보다 더 커 보이게 만들 수 있어요. 이것이 바로 가상 메모리의 핵심 마법입니다.

🔁 동작 흐름 예시

1. 프로그램이 0x2000 주소에 접근하려 함
2. 해당 페이지가 물리 메모리에 없음 → 페이지 폴트 발생
3. OS는 필요 없는 다른 페이지를 스왑 아웃해서 공간 확보
4. 디스크에서 0x2000이 포함된 페이지를 스왑 인
5. MMU가 가상 주소 → 물리 주소 매핑 다시 설정
6. 프로그램은 아무 일도 없었던 것처럼 실행 계속

요구불 페이징은 “필요한 메모리만 즉시 가져오고, 안 쓰는 메모리는 디스크로 보내는” 스마트한 가상 메모리 운영 방식입니다.

이 과정을 '요구 페이징(Demand Paging)'이라고 합니다. OS는 페이지 접근 패턴을 추적해 어떤 페이지를 스왑할지 결정합니다. 대표적으로 LRU(Least Recently Used) 알고리즘이 사용됩니다.

"자주 쓰는 건 냉장고에, 덜 쓰는 건 창고에. 그런데 창고에서 꺼낼 땐 시간이 걸린다!"

9) 🔄 MMU vs 인덱스 레지스터

항목	MMU	인덱스 레지스터
기능	가상 → 물리 주소 변환	동적 주소 계산 (오프셋 계산용)
범위	모든 메모리	제한적 (일부 주소에만 적용)
보호 기능	있음 (보안, 권한 등)	없음
프로그램 분리	가능	불가능

MMU는 단순한 주소 계산기가 아니라, 보안·안정성·다중 프로그램 실행의 핵심 장치입니다.

10) 스와핑에 두 가지 의미

1. 교과서에서는 이렇게 말해요

"메모리가 부족한 상황에서는 스와핑을 통해서라도 프로그램을 실행시키는 게 낫다."

• 운영체제는 가상 메모리를 통해 메모리보다 많은 프로그램을 실행하게 도와줘요.
• 이때 물리 메모리가 부족하면 디스크에 데이터를 잠시 옮겨두는 스와핑을 사용합니다.
• 성능은 좀 떨어져도 시스템이 멈추지 않고 돌아가는 것이 더 중요하다고 보는 거예요.
• 그래서 OS는 LRU(Least Recently Used) 같은 페이지 교체 알고리즘을 써서 덜 쓰는 페이지부터 스왑 아웃해요.

요약: 성능보다 가용성(Availability)이 중요한 상황에서는 스와핑이 합리적이에요.

2. 실무에서는 왜 다르게 말할까요?

"Kafka 같은 고처리량 시스템에서는 (거의) 무조건 스와핑을 막아야 한다."
– 카프카 핵심 가이드 p.40

고성능 시스템에서는 상황이 완전히 달라요. 성능이 떨어지면 비즈니스 자체가 타격을 입을 수 있기 때문이에요.

실무에서 스와핑이 문제 되는 이유

이유	설명
💥 성능 저하	스왑은 디스크 I/O를 유발해요. RAM보다 수천 배 느려요.
🌀 레이턴시 증가	Kafka, DB, 게임 서버처럼 실시간성이 중요한 시스템에선 치명적이에요.
🧠 예측 불가	커널이 어떤 페이지를 스왑할지 결정하기 때문에, 예측이 어려워요.
📉 처리량 감소	CPU는 한가한데 메모리 I/O 때문에 전체 속도가 늦춰져요.

3. ✋ 예를 들면 이런 상황이 생겨요

• Kafka의 Page Cache가 스왑되면 디스크 접근 속도가 심각하게 느려져요.
• JVM 기반 시스템은 GC 타이밍이 중요한데, 스왑이 끼면 GC가 언제 작동할지 예측 불가해져요.

4. 📌 그래서 실무에서는 이렇게 막아요

• vm.swappiness 값을 10 이하로 줄이거나 아예 0으로 설정

  sudo sysctl -w vm.swappiness=10

• Kafka, Elasticsearch, Redis 등은 스왑 비활성화가 권장

• 컨테이너에서는 --memory-swappiness=0 옵션 사용

🧩 쉽게 비교하면?

항목	일반 PC (교과서 관점)	Kafka 같은 고성능 서버 (실무 관점)
목표	실행 가능한 시스템 유지	지연 최소화, 처리량 극대화
스와핑 허용	허용 (필요악)	❌ 최대한 방지
페이지 교체	LRU 등 사용	스와핑 자체를 안 하도록 세팅
리소스 부족 시	느려져도 동작 유지	성능 저하는 SLA 위반으로 치명적

💡 한 줄 정리

교과서에서 말하는 스와핑은 ‘최후의 안전장치’지만, 실무에서는 ‘절대 피해야 할 성능 지옥’입니다.

✅ 마무리 요약

키워드	설명
MMU	가상 주소 ↔ 물리 주소 변환 하드웨어
페이지	일정 단위로 쪼갠 메모리 블록
페이지 테이블	가상 → 물리 주소 매핑 정보 저장 테이블
페이지 폴트	없는 가상 주소 접근 시 발생하는 예외
제어 비트	실행불가, 읽기전용 등 접근 권한 제어
프로그램 분리	가상 메모리 공간으로 서로 격리

"현대 컴퓨터에서 MMU 없는 시스템은 상상할 수 없습니다.
프로그램이 안전하게, 그리고 서로 간섭 없이 실행될 수 있도록 돕는 조력자.
그게 바로 MMU입니다!"

"가상 메모리는 마치 각 가정이 자기 집 주소 체계를 쓰는 것처럼, 다른 집 주소와 겹치지 않게 만들어주는 장치입니다."

9. 🛡️ 사용자 모드 vs 시스템 모드 – 누구에게 권한이 있을까?

✅ 사용자에게 주는 ‘환상’과 그 이면의 시스템 보호

1) 운영체제는 착각을 심어준다?

멀티태스킹 시스템에서 여러 프로그램이 동시에 실행되고 있어도,

각 프로그램은 ‘내가 유일하게 실행 중인 프로그램’이라고 착각합니다.

이건 MMU(메모리 관리 장치) 덕분이에요.

• MMU는 각 프로세스마다 독립적인 가상 주소 공간을 만들어줘요.
• 덕분에 프로세스들은 서로의 메모리에 접근할 수 없고, 마치 자신만 컴퓨터를 쓰는 것처럼 보이죠.

2) 그런데, I/O 장치가 끼면 문제가 생긴다?

맞아요.
타이머나 디스크 같은 I/O 장치는 시스템 전체에 영향을 주는 하드웨어라서 함부로 건드리면 곤란해져요.

예를 들어:

• 운영체제는 타이머 인터럽트를 이용해 프로세스를 주기적으로 전환해요.
• 그런데 어떤 사용자 프로그램이 타이머를 “1시간에 한 번만 인터럽트해줘~”라고 바꿔버리면?
  • 😱 → 다른 프로그램은 영원히 실행되지 못할 수도 있어요.

3) 그래서 운영체제는 ‘특권 계층’을 둡니다

CPU는 두 가지 모드를 구분해요:

모드	설명
🧍‍♂️ 사용자 모드(User Mode)	일반 앱이나 사용자 코드가 실행되는 공간
🛡️ 시스템 모드(System/Kernal Mode)	운영체제 커널, I/O, MMU 설정 등 중요한 코드가 실행되는 공간

일반 프로그램은 사용자 모드에서만 실행돼요.
중요한 명령어(예: I/O 제어, MMU 설정 등)는 “특권 명령어(Privileged Instructions)”라서
👉 시스템 모드에서만 실행이 가능해요!

👉 CPU의 모드 전환(User Mode ↔ System Mode), 그리고 특권 명령어 실행 여부 판단은 모두 운영체제 커널(Kernel)이 주도적으로 관리하고 통제

리눅스 커널 정리

4) 사용자 → 운영체제와 대화하는 방법은?

사용자 프로그램이 시스템 기능이 필요할 때는 직접 실행 못 해요.
대신 다음 중 하나를 사용해요:

• 트랩(trap) : 예외 상황이나 오류 발생 시, 자동으로 OS에 제어권을 넘김
• 시스템 콜(system call) : 사용자 프로그램이 명시적으로 운영체제에게 요청하는 메커니즘

예: read(), write(), fork() 등이 모두 시스템 콜!

5) 이 구조의 장점은?

1. ✅ 운영체제를 보호: 일반 프로그램이 시스템 자원을 함부로 만지지 못함
2. ✅ 프로세스 간 보호: 사용자 프로그램이 서로의 메모리나 자원을 침범할 수 없음
3. ✅ 운영체제 자원 제어: 자원 할당을 운영체제가 전적으로 통제 가능

6) 동작 간단하게

✅ 사용자 모드 → 시스템 모드 전환 흐름도 설명

이 그림은 사용자 모드(User Mode)에서 실행 중인 프로그램이 어떻게 운영체제 커널이 실행되는 시스템 모드(System Mode)로 전환되는지를 보여주는 흐름도예요.

🔄 전체 흐름 요약

1. 사용자 프로그램 실행 중

   • 이때 CPU는 사용자 모드(User Mode)로 설정됨
   • read(), write() 같은 시스템 콜은 직접 실행할 수 없음

2. 시스템 콜 요청

   • 사용자 프로그램이 시스템 리소스를 요청하면, int 0x80 같은 시스템 콜 인터럽트 발생
   • 이 순간 트랩(trap)이 발생하면서 CPU는 모드를 전환

3. Mode Bit가 0 → 1로 전환

   • Mode Bit는 CPU 내부의 한 비트로, 현재 CPU가 User Mode(0)인지, System Mode(1)인지 나타냄
   • 이 비트를 바꾸는 건 오직 운영체제(커널 코드)만 가능

4. 커널 모드로 진입 (System Mode)

   • 이제 커널이 제어권을 잡고, I/O 명령이나 메모리 할당 같은 특권 명령어(Privileged Instructions)를 안전하게 수행
   • 일반 프로그램은 이 명령어를 직접 실행할 수 없음

5. 작업 완료 후 사용자 모드 복귀

   • 작업이 끝나면 CPU의 Mode Bit를 다시 0(사용자 모드)로 바꾸고, 사용자 프로그램으로 돌아감

🧠 주요 개념 요약

개념	설명
🟦 Mode Bit	CPU 안의 한 비트로, 현재 모드가 사용자(0)인지 시스템(1)인지 나타냄
🛑 트랩(Trap)	예외 상황이나 시스템 콜 시 커널로 제어권이 넘어가는 동작
🧭 시스템 콜(System Call)	사용자 프로그램이 OS 기능을 요청하는 인터페이스 (ex. 파일 읽기)
🛡️ 특권 명령어(Privileged Instructions)	MMU 설정, I/O 제어 등 시스템 모드에서만 실행 가능한 명령어

운영체제는 Mode Bit와 Trap 메커니즘을 활용해 사용자 프로그램과 커널 기능을 확실하게 격리하고 보호합니다.

💡 한 마디로 정리하면?

“운영체제는 사용자에게 착각을 심어주는 동시에, 철저한 보호 장치를 두어 시스템을 지킨다.”

📱 그래서 우리 프로그램은 어디서 실행되나요?

• 여러분이 만드는 앱, 웹 브라우저, 게임 등은 모두 사용자 공간(user space)에서 실행됩니다.
• 운영체제 커널은 시스템 공간(kernel space)에서 실행되며, 일반 사용자가 직접 접근할 수 없어요.

시스템 공간을 다룰 수 있는 사람은 ‘커널 해커’ 같은 아주 숙련된 프로그래머입니다.

"이건 마치 은행 창구에서 직접 금고를 만지지 못하고, 요청서를 써서 창구 직원에게 전달하는 것과 비슷합니다."

“CPU 모드를 관리하는 건 하드웨어지만, 그 모드를 전환하고 제어하는 건 오직 운영체제 커널만 할 수 있다.”

10. 🧊 냉장고, 마트, 창고 – 메모리의 식량 저장 전략

• 레지스터: 가장 빠르고 가장 작음 (CPU 안)
• L1, L2, L3 캐시: 속도와 크기 중간 단계 (CPU와 RAM 사이)
• RAM: 주 메모리, CPU보다 느림
• 디스크/SSD: 가장 느리지만 가장 큼

✅ 컴퓨터는 왜 '메모리 계층 구조'를 만들었을까?

1) 과거에는 CPU와 메모리 속도가 비슷했다

옛날에는 CPU와 메모리가 같은 속도로 동작했어요.
컴퓨터의 모든 부품이 한 템포로 움직이던 평화로운 시절이었죠.

그런데 시간이 흐르며 CPU는 무섭게 빨라졌고, 메모리는 그만큼 따라오지 못했습니다.
“빠른 CPU가 느린 메모리를 기다리는 시대”가 시작된 거예요.

레지스터가 전체 메모리에서 차지하는 비율은 점점 작아져 왔어요.

프로세서는 보통 RAM으로 이뤄진 주 메모리main memory와 통신하는데, 주 메모리는 프로세서보다 1/10 정도밖에 속도가 나지 않아서 느려요.

디스크 드라이브 등의 대량 저장장치는 프로세서보다 백만 배 느릴 수도 있습니다.

2) 메모리 계층 구조란?

이런 문제를 해결하기 위해 나온 개념이 바로

📚 메모리 계층(Memory Hierarchy)

계층	비유	특징	속도
레지스터	냉장고	아주 작고 빠름, CPU 안에 있음	최고속
캐시(L1~L3)	저장고, 미니냉장고	작지만 빠름, CPU 가까이	매우 빠름
주 메모리(RAM)	슈퍼마켓	큼직하지만 느림	중간
디스크(HDD/SSD)	창고	아주 큼, 엄청 느림	느림

사용자 프로그램 입장에서는 전부 "메모리"처럼 보이지만, 실제로는 이처럼 속도도 용량도 전혀 다릅니다.

3) 메모리를 기다리는 CPU를 구하라: 캐시와 프리페치

캐시(Cache)는 뭘까?

• 캐시는 CPU 바로 옆에 붙어 있는 초고속 메모리
• CPU가 자주 사용하는 데이터를 캐시에 미리 저장해두면,
• RAM까지 가지 않고 더 빠르게 작업 가능

프리페치(Prefetch)?

• CPU가 프로그램 실행 흐름을 예측해서, 앞으로 쓸 데이터를 미리 캐시에 가져다 놓는 것
• 예: "이 사람이 아침마다 시리얼을 먹네? 그럼 시리얼은 미리 꺼내놔야겠다!" 같은 자동화된 습관

4) 캐시는 왜 여러 단계로 나뉘어 있을까?

• L1 캐시: 아주 작고 빠름 (CPU와 거의 일심동체)
• L2 캐시: L1보다 크고 조금 느림
• L3 캐시: 더 크지만 느림, 여러 CPU 코어가 공유

멀어질수록 커지지만 느려지고, 가까울수록 빠르지만 작아져요.

5) 캐시에도 실패가 있다?

출처 : https://velog.io/@skypinkhs0718/%EC%BA%90%EC%8B%9C-%EB%A9%94%EB%AA%A8%EB%A6%AC%EB%8A%94-%EB%AC%B4%EC%97%87%EC%9D%BC%EA%B9%8C

'용량이 작은' 캐시 메모리는 CPU가 사용할 법한 대상을 "예측"하여 저장하는데,

• 이때 CPU가 활용해야 하는 데이터를 캐시메모리가 잘 저장하고 있다면 "캐시 히트"
• 반대로 CPU가 원하는 데이터가 아닌 다른 엉뚱한 데이터를 저장하여 CPU가 직접 메모리를 통해 데이터를 가져가야 하는 상황일 때를 "캐시 미스"라고 한다.

용어	뜻
✅ 캐시 히트 (Cache Hit)	CPU가 필요한 데이터가 캐시에 있어서 빠르게 접근 성공
❌ 캐시 미스 (Cache Miss)	캐시에 데이터가 없어서 느린 메모리나 디스크까지 가야 함

6) CPU가 메모리보다 10배 빠르다고 가정하면? 🧠 CPU 성능을 높이기 위한 두 가지 핵심 기법

• CPU가 1초에 10개의 명령을 실행할 수 있는데,
• 메모리는 1초에 1개밖에 못 넘겨줘요.
• 👉 CPU는 나머지 9초 동안 '멍 때리는 셈'이죠.

그래서 더 복잡한 장치들이 등장합니다:

✅ 1. Branch Prediction (분기 예측)

• 설명: 프로그램에는 if, for, while 같은 분기 명령어가 자주 등장합니다.
  CPU는 이런 분기를 만났을 때 다음 명령어가 어디로 갈지 기다리지 않고 미리 예측해서 실행 준비를 해요.

• 예시 비유:
  마트에서 계산대가 두 줄 있을 때, 사람들이 보통 어디 줄로 가는지 예측하고 먼저 줄 서는 것과 비슷해요!

• 효과:

  • 분기 결과가 예측과 일치하면 👉 시간 절약!
  • 예측 실패해도 👉 다시 실행하면 되니까 전반적으로 대기 시간이 줄어듦

✅ 2. Out-of-Order Execution (순서 무시 실행)

• 설명: CPU는 명령어를 무조건 위에서 아래로 실행하지 않아요.
  먼저 실행할 수 있는 명령어부터 골라서 처리해요.
  의존성이 없는 연산부터 먼저 끝내서 대기 시간을 줄이는 거예요.

• 예시 비유:
  라면 끓이기 순서를 생각해보면, 물을 끓이는 동안 반찬을 꺼내는 것처럼, 할 수 있는 일을 먼저 처리하는 방식이에요.

• 효과:

  • 메모리를 기다리는 동안 놀지 않음
  • CPU가 놀지 않고 쉴 틈 없이 일하게 해줌

기법	역할
Branch Prediction (분기 예측)	분기 명령(if, loop 등)이 어디로 갈지 미리 예측해서 기다리지 않음
Out-of-Order Execution	코드 순서 상관없이, 할 수 있는 명령어부터 먼저 실행함

7) 멀티코어 환경에서는 더 어려운 문제 등장

• 여러 CPU 코어가 같은 메모리 영역을 캐시에 가지고 있으면?
• 한 코어가 수정한 내용을 다른 코어는 모를 수 있음
• 👉 이걸 해결하기 위한 개념이 바로 캐시 일관성(Cache Coherency)

예:

• 라이트 스루(Write Through): 캐시 + 메모리에 동시에 씀 → 안전하지만 느림
• 그래서 더 복잡한 캐시 일관성 프로토콜(MESI 등)이 개발됨

💡 한 줄 요약

메모리 계층 구조는 빠른 CPU와 느린 메모리 사이의 속도 차이를 메우기 위한 구조적 해법이다.

📌 비유로 다시 정리하면

계층	비유	특징
레지스터	냉장고	공간 작음, 아주 빠름
캐시	주방 식품장	크진 않지만 빠름, 자주 쓰는 것만 저장
주 메모리	슈퍼마켓	크지만 느림
디스크	창고	매우 큼, 매우 느림
디스패처	식재료 분배기	어디서 어떤 걸 꺼내고 채울지 결정함

메모리는 빠르지만 비싼 공간에서 느리지만 저렴한 공간으로 구성됩니다. 캐시 미스가 생기면 하위 계층에서 데이터를 가져오느라 시간이 더 걸립니다.

"집 – 냉장고 – 식료품 가게 – 창고
이 흐름이 컴퓨터 메모리와 정확히 닮았죠."

11. 🚀 앞을 내다보는 CPU – 캐시와 분기 예측의 세계

멀티코어 환경에서는 캐시 일관성 문제도 생깁니다. 여러 코어가 같은 메모리를 접근할 때, 캐시에 있는 값과 메모리에 있는 값이 다를 수 있기 때문이죠. 이를 해결하기 위해:

• Write-through 방식
• 캐시 동기화 프로토콜 (MESI 등)

그리고 고급 프로세서는 다음 명령어를 미리 예측하는 분기 예측기와 순서를 바꿔 효율적으로 실행하는 Out-of-Order Execution 기능도 탑재합니다.

12. 👷 일은 CPU만 하는 게 아냐 CPU 혼자 다 하기엔 벅차다! - 그래서 등장한 코프로세서 & DMA

1) 코프로세서(Coprocessor): CPU의 ‘작업 분담 파트너’

CPU는 굉장히 복잡하고 중요한 회로라서 모든 일을 혼자 처리하긴 어려워요.
그래서 특정 작업은 “보조 프로세서”, 즉 코프로세서에 맡깁니다.

📌 왜 코프로세서를 쓰나요?

출처 : https://recipes.tistory.com/203

코프로세서는 메인 CPU와 함께 동작하며, 특정 기능을 보조하거나 제어하는 하드웨어 유닛입니다.
ARM 구조에서는 CP15(Coprocessor 15)가 대표적이며, 아래와 같은 중요한 제어 기능을 담당합니다:

기능	설명
MMU ON/OFF 제어	가상 메모리 사용 여부 설정
캐시 ON/OFF	I-Cache(명령어 캐시), D-Cache(데이터 캐시) 사용 제어
페이지 테이블 주소 설정	MMU가 참조할 페이지 테이블 위치 지정
권한 제어 (DACR 등)	메모리 접근 권한(읽기/쓰기 등) 설정

✅ 코프로세서가 왜 필요한가?

ARM의 CPU 코어는 이미 연산/분기/파이프라인 등 다양한 복잡한 연산을 수행하고 있어요.
하지만 시스템 제어나 메모리 관리 같은 제어용 기능까지 모두 직접 담당하면:

❌ 복잡성 증가
❌ CPU 자원 낭비
❌ 소프트웨어-하드웨어 인터페이스가 어려워짐

그래서 제어 관련 기능만 따로 분리한 것이 코프로세서예요.

✅ CR 레지스터가 하는 일 (CP15 내부)

CR (Control Register) 주요 비트 설명

비트	기능	설명
M	MMU 제어	ON이면 가상 주소 → 물리 주소 변환 가능
C	D-Cache 제어	데이터 캐시 사용 여부
I	I-Cache 제어	명령어 캐시 사용 여부

즉, CR 레지스터를 조작하면 MMU 활성화 + 캐시 활성화 여부를 소프트웨어에서 제어할 수 있습니다.

✅ MMU가 ON 되면 무슨 일이 일어날까?

• CPU는 가상 주소(Virtual Address)로 메모리에 접근합니다.
• MMU는 가상 주소를 물리 주소(Physical Address)로 변환합니다.
• 이 변환을 위해 페이지 테이블(Page Table)을 참조합니다.

📌 예시

가상 주소	실제 물리 주소	접근 권한
0x13D00000	0x46200000	읽기/쓰기
0x14100000	0x74600000	읽기/쓰기
0x14300000	0x66300000	접근 불가

✅ 캐시 사용 조건: MMU가 반드시 ON이어야 함

왜냐하면:

• 캐시의 주소 라인이 MMU를 통해 연결되어 있기 때문이에요.
• 즉, MMU가 OFF면 캐시도 OFF 상태처럼 작동합니다.

✅ 하버드 아키텍처도 한몫해요

• ARM9 이후는 Harvard 방식을 많이 씁니다.
• I-Cache와 D-Cache가 분리되어 있어, 명령어와 데이터를 동시에 읽고 쓸 수 있어요.
• 병렬화 덕분에 성능이 더 향상됩니다.

✅ 한 줄 정리

ARM의 코프로세서(CP15)는 MMU와 캐시, 페이지 테이블, 권한 제어를 담당하는 핵심 제어기이며, 소프트웨어에서 이를 제어함으로써 시스템 메모리 관리가 가능해집니다.

🧠 예시

시기	역할
과거	부동소수점 연산(FPU)을 코프로세서가 담당
요즘	그래픽 처리(GPU), AI 연산(NPU) 같은 복잡한 연산을 코프로세서가 처리

과거엔 칩 공간이 부족해서 FPU(부동소수점 유닛)를 외부 코프로세서로 빼놓았지만,
요즘은 하나의 칩에 GPU나 NPU가 함께 들어있는 SoC(System on Chip) 구조가 일반적이에요.

2) DMA(Direct Memory Access): 데이터 복사 담당 특화 회로

CPU는 계산만 잘하는 게 아니라, 데이터를 이리저리 옮기는 일도 많이 해요.
그런데 이런 건 시간은 오래 걸리고... 두뇌는 필요 없어요! 그래서 이 일은 DMA가 맡습니다.

💡 DMA는 어떤 일을 하나요?

• 디스크 → 메모리, 메모리 → 디바이스 사이에 데이터를 CPU 없이 직접 복사해요.
• 예:

  “여기서 이만큼 데이터를 저기로 복사해줘. 다 끝나면 나한테 알려줘!”

📦 왜 DMA가 중요할까?

DMA에 대한 정리 내용

항목	CPU만 처리	DMA가 처리
데이터 복사	CPU가 계속 바쁨	CPU는 계산에 집중 가능
효율성	떨어짐	높아짐

특히 디스크는 블록 단위(512B, 4KB)로 데이터를 옮기기 때문에, 대량 복사가 자주 발생해요.
이런 걸 CPU가 직접 처리하면 낭비라서 DMA가 대신 해주는 거예요.

전송이 완료되면 DMA모듈은 CPU에게 인터럽트 신호를 보내고 CPU는 전송의 시작과 끝 부분에만 관여

🧩 코프로세서 vs DMA

구분	코프로세서	DMA
하는 일	계산 보조 (FPU, GPU, NPU 등)	데이터 복사 전담
목적	CPU 연산 분산	CPU 복사 부담 줄이기
처리 대상	특정 연산	메모리 ↔ 디스크 등 데이터 전송

💡 정리 한 줄

CPU가 혼자 다 하지 않도록, 계산은 코프로세서에게, 데이터 복사는 DMA에게 맡긴다.

그래픽 연산은 GPU가, 단순 복사는 DMA가 맡음으로써 CPU는 더 중요한 일에 집중할 수 있습니다.

13. 🧵 흩어진 코드 조각, 어떻게 실행 파일이 될까? - 프로그램 실행 구조와 링커

1) 📦 메모리에는 "명령어"만 담는 게 아니다!

메모리는 단순히 실행할 코드(명령어)뿐만 아니라, 다양한 종류의 데이터도 함께 저장합니다.

구분	설명
명령어(Instruction)	CPU가 실행할 기계어 코드
정적 데이터(Static Data)	프로그램 시작 시 크기와 위치가 정해진 데이터 (예: 전역 변수, 상수)
스택(Stack)	함수 호출/복귀 시 사용하는 임시 저장 공간
힙(Heap)	실행 중 필요한 동적 메모리 할당 공간 (예: 사용자 입력, 가변 길이 리스트 등)

2) 🧱 전통적인 메모리 배치 방식

그림 5-15. MMU가 없을 때의 메모리 배치

구조	구성 설명
폰 노이만 구조	명령어와 데이터가 같은 메모리 공간에 저장됨
하버드 구조	명령어와 데이터가 완전히 분리된 메모리 공간에 저장됨 (속도↑)

둘 다 구조적으로는 비슷하지만, 하버드는 명령어 캐시와 데이터 캐시를 별도로 운용할 수 있어 성능 면에서 유리해요.

3) 📈 동적 메모리인 힙(Heap)의 등장

정적 데이터는 미리 크기를 알지만, 현실 세계의 프로그램은 동적으로 변하는 데이터를 많이 다룹니다.

예:

• 메시지 큐
• 사용자 입력 리스트
• 웹 요청 버퍼 등

이럴 때는 동적으로 메모리를 할당해야 하므로, 다음과 같이 메모리를 씁니다:

그림 5-16. 힙이 있는 메모리 배치

[ 메모리 최상단 ]
┌────────────┐
│   스택 (아래로 자람)   │ ← 함수 호출 시마다 증가
├────────────┤
│   힙 (위로 자람)      │ ← malloc, new 등으로 증가
├────────────┤
│   정적 데이터           │ ← 전역 변수, static 등
├────────────┤
│   명령어                │ ← 프로그램 코드
└────────────┘
[ 메모리 하단 ]

힙과 스택이 서로 충돌하지 않게 관리하는 것이 매우 중요합니다.
충돌하면 프로그램이 뻗거나, 보안 취약점이 생길 수 있어요.

4) ⚙️ MMU(Memory Management Unit)가 있다면?

MMU가 있으면 이런 배치를 물리 메모리와 분리된 가상 메모리 공간에서 자유롭게 구성할 수 있어요.

항목	MMU 없음	MMU 있음
메모리 배치	프로그램이 직접 설계	OS/커널이 페이지 단위로 매핑
공간 제약	힙/스택 충돌 위험	페이지 단위 분리로 유연
보안성	낮음	접근 제어 가능 (예: read-only)

MMU를 활용하면 메모리 보호, 동적 확장, 접근 제어 등 더 안정적이고 유연한 운영이 가능해요.

💡 한 줄 요약

프로그램은 명령어뿐 아니라 정적/동적 데이터, 스택 등을 메모리에 배치하며, MMU가 있으면 이 배치를 가상 주소로 더 유연하게 구성할 수 있다.

📌 용어 정리 요약표

용어	설명
정적 데이터	프로그램 시작 시 크기 고정, 전역 변수 등
동적 데이터 (힙)	실행 중 크기 변동 가능, malloc/new
스택	함수 호출/복귀, 지역 변수
폰 노이만 구조	명령어/데이터 메모리 통합
하버드 구조	명령어/데이터 메모리 분리
MMU	가상 주소 → 물리 주소 매핑, 메모리 보호/격리

14. 🎬 프로그램은 어디서부터 실행될까? – Entry Point와 런타임

1) 📦 함수도 나눠 쓰고, 파일도 나눠 쓴다!

• 프로그래머들은 자주 쓰는 함수(예: 문자열 비교, 수학 계산)를 재사용 가능한 형태로 묶어 둡니다.
• 이렇게 묶인 파일을 라이브러리(library)라고 부릅니다.
• 팀 단위 개발을 위해 하나의 프로그램도 여러 개의 소스 파일로 나누어 작성하는 경우가 많습니다.

2) 🔗 여러 코드 조각을 하나로 묶는 과정: 링크(link)

• 여러 파일로 나뉘어 작성된 프로그램은 중간 단계 파일(매개 파일, object file)로 컴파일됩니다.
• 이를 하나로 묶어서 하나의 실행 파일(executable)을 만드는 과정을 링킹(linking)이라고 해요.
• 이 과정을 해주는 툴이 바로 링커(Linker)입니다.

3)🧰 ELF: 실행 가능한 파일의 표준 형식

ELF(Executable and Linkable Format)는 프로그램을 여러 섹션으로 나눈 실행 파일 형식입니다.

• 📦 “팝니다” 영역 → 내가 제공하는 함수 (cube() 같은 것)
• 🛒 “삽니다” 영역 → 내가 필요한 외부 함수나 변수 (printf, date 등)

링커는 이들을 서로 연결(resolve)해서 실행 가능한 형태로 만드는 역할을 합니다.

4) 🧲 정적 링크 vs 동적 링크

구분	설명	장점	단점
정적 링크	필요한 라이브러리를 실행 파일에 포함시킴	빠름, 독립 실행 가능	실행 파일이 커지고 중복됨
동적 링크	프로그램 실행 시 공유 라이브러리를 따로 참조	메모리 절약, 업데이트 용이	실행 시점에 외부 파일 필요

정적 링크는 복붙,
동적 링크는 “공유 파일 참조”라고 생각하면 쉬워요.

5) 📚 공유 라이브러리란?

• 여러 프로그램이 같은 라이브러리를 참조할 수 있도록 만든 공통 모듈
• 동적 링크(dynamic linking)를 통해 실행 중 로드
• 메모리를 절약하고, 업데이트가 편리함

📌 예시 그림 (그림 5-17)

[ 프로그램 1 ]          [ 프로그램 2 ]
     │                         │
     └─────┐           ┌──────┘
           ↓           ↓
      [ 공통 라이브러리 ] ← MMU가 공유 관리

단, 공유 라이브러리는 프로그램마다 독립적인 스택과 힙을 사용하도록 설계해야 합니다!

6) 🎯 진입점(Entry Point)은 첫 줄이 아니다?

• 모든 프로그램은 "진입점"이라는 곳에서 실행이 시작됩니다. (보통 main() 함수)
• 그런데 실제로는, main()보다 먼저 실행되는 코드가 있습니다.
• 그건 바로 런타임 라이브러리(runtime library)입니다.

7) ⚙️ 런타임 라이브러리의 역할

프로그램 실행 직전에 준비 작업을 해주는 "도우미 코드"입니다.

역할	설명
📌 스택/힙 설정	메모리 레이아웃 구성
📌 정적 데이터 초기화	전역 변수 등 초기값 복사
📌 main() 호출	진짜 실행 시작점으로 넘김

고급 언어일수록 런타임 라이브러리의 역할도 많아져요 (예: 예외 처리, 객체 생성 등)

💡 한 줄 정리

프로그램은 여러 코드 조각과 라이브러리를 링커가 엮고, 런타임 라이브러리가 실행 환경을 마련한 후에야 진짜 실행이 시작된다.

📌 용어 요약표

용어	의미
라이브러리	자주 쓰는 함수를 모아둔 파일
링커(Linker)	여러 개의 오브젝트 파일을 하나의 실행 파일로 묶는 도구
ELF	실행 가능한 파일 포맷 (Executable and Linkable Format)
정적 링크	실행 파일에 직접 함수 코드 삽입
동적 링크	실행 중 외부 라이브러리 호출
공유 라이브러리	여러 프로그램이 동시에 사용하는 공통 함수 모음
런타임 라이브러리	프로그램 실행 전 초기화 작업을 해주는 코드 묶음
진입점(Entry Point)	프로그램에서 main() 이전에 실행되는 시작 주소

15. MMU로는 부족하다 세그먼테이션

✅ MMU(Memory Management Unit)와 세그멘테이션(Segmentation)은 어떤 관계?

📌 결론부터 말하자면:

세그멘테이션은 MMU가 수행할 수 있는 메모리 관리 방식 중 하나입니다.
즉, MMU는 "세그멘테이션"이라는 방식을 구현하기 위한 하드웨어예요!

🧠 그럼 MMU가 뭐길래?

✔️ MMU는 하드웨어 장치입니다.

• Memory Management Unit: 가상 주소 → 물리 주소 변환을 담당하는 하드웨어
• 운영체제가 MMU에 설정값을 넣고, 이후 주소 변환은 MMU가 자동으로 처리

MMU가 할 수 있는 일들 (운영체제의 설정에 따라)

주소 변환 방식	설명	예시
✅ 단일 베이스/바운드	모든 주소에 같은 변환 적용	가장 단순한 방식
✅ 세그멘테이션	영역별(Base/Bound)로 주소 변환	힙, 스택, 코드 등 구분
✅ 페이징(Paging)	고정 크기 블록(페이지) 단위로 변환	현대 시스템 대부분
✅ 세그먼트+페이징	세그먼트를 페이지로 나눠 관리	Intel x86 구조 등

즉, MMU는 "주소 변환 전략"을 실행하는 하드웨어고,
그 전략이 "세그멘테이션"일 수도 있고, "페이징"일 수도 있고, 심지어 둘 다 쓸 수도 있어요.

✅ 그럼 왜 세그멘테이션이라는 방식이 필요했을까?

MMU만 있다고 끝이 아닙니다.
MMU가 ‘어떻게 변환할 것인가’를 운영체제가 정하고, 그 방식 중 하나가 세그멘테이션이에요.

세그멘테이션이 필요한 이유:

문제 상황	세그멘테이션으로 해결 가능?	설명
힙/스택이 자라면서 충돌	✅ 해결	서로 다른 세그먼트로 나눔
프로그램마다 다른 메모리 구조	✅ 해결	코드/데이터/스택 분리 가능
코드 공유 (메모리 절약)	✅ 해결	코드 세그먼트를 읽기 전용으로 공유
유연한 주소 공간	✅ 해결	각 세그먼트마다 독립된 물리 위치 허용
접근 권한 제어	✅ 해결	읽기/쓰기/실행 권한 비트 설정 가능

✅ 페이징 vs 세그멘테이션은 경쟁 관계일까?

❌ 경쟁이라기보단, 각자 장단점이 다르고, 때로는 함께 쓰이기도 합니다!

방식	장점	단점
세그멘테이션	논리적 구조 구분 쉬움, 유연한 크기	외부 단편화 발생 가능
페이징	내부 단편화 줄이고, 메모리 활용 효율적	논리적 구조 파악 어려움
혼합 방식	세그먼트를 페이지로 나눔	x86에서 사용

✅ 실제 시스템은 어떻게 했을까?

시스템	방식
초창기 시스템	단순 MMU + 단일 Base/Bound
중간 단계 시스템	MMU + 세그멘테이션 (x86 초기)
현대 OS (Linux, Windows)	MMU + 페이징 방식
고급 시스템	MMU + 세그멘테이션 + 페이징 (x86 호환 아키텍처 등)

💡 비유로 이해해보자

• MMU는 주소를 바꿔주는 네비게이션 시스템
• 세그멘테이션은 목적지를 구역별로 나누는 지도 방식
• 페이징은 지도를 블록 단위로 잘게 자른 방식

👉 운영체제가 "이렇게 주소 관리하자"라고 지시하면,
MMU는 그 방식에 맞게 빠르게 변환을 수행합니다.

🔧 예시로 비교하면

MMU 단독 (단일 Base/Bound):

가상 주소 = 1234
물리 주소 = Base + 1234 (단 하나의 Base만 존재)

세그멘테이션 사용 시 (MMU + 세그먼트):

가상 주소 = [세그먼트 번호: 01][오프셋: 0345]
→ 세그먼트 1의 Base + 오프셋 = 물리 주소

🧩 최종 정리

항목	역할
MMU	주소 변환을 수행하는 하드웨어
세그멘테이션	MMU가 사용할 수 있는 주소 변환 방식 중 하나
운영체제	어떤 방식으로 주소를 변환할지 결정하고 MMU를 설정

✅ 한 줄 요약

MMU는 주소를 바꿔주는 기계이고, 세그멘테이션은 그 기계가 따르는 규칙이다.

✅ 요약 표: 5장 핵심 정리

키워드	개념 요약
컴퓨터 구조	폰 노이만 vs 하버드 (명령어/데이터 메모리 분리 여부)
멀티코어	전력 문제 해결책으로 등장한 다중 코어 시스템
MMU	가상 주소 ↔ 물리 주소 매핑 장치, 프로그램 격리 가능
스택	함수 호출/복귀를 위한 LIFO 저장소
인터럽트	외부 이벤트 처리 (예: 초인종) 시스템
가상 메모리	실제보다 더 큰 메모리를 제공하는 환상 시스템
스와핑	필요 없는 페이지를 디스크로 이동시키는 전략
시스템 공간	운영체제 전용, 사용자 프로그램과 분리
캐시	L1~L3 계층 구조, 속도와 용량의 균형
링커	여러 코드 조각을 하나로 묶어 실행 파일 생성

남은 것은 I/O뿐인데, 이 주제를 6장에서 다
룬다.

출처

• https://imjeongwoo.tistory.com/152