STUDY - Operating System

📒 운영체제

📕 운영체제와 컴퓨터시스템의 구조

1. 운영체제의 종류

• 1) GUI (Grapic User Interface)

  • 그래픽 사용
  • 그래픽 기반으로 컴퓨터와 상호작용하는 인터페이스
  • 🗒️ 예시 : WindowOS, MacOS

• 2) CLI (Character User Interface)

  • 키보드만을 사용
  • 문자 기반으로 컴퓨터와 상호작용하는 인터페이스
  • 🗒️ 예시 : MS-DOS, ChatGPT

2. 운영체제의 역할

• 1) 특징
  • 운영체제의 커널이 담당
  • 사용자 프로그램와 하드웨어간 연결
• 2) 종류
  • CPU 스케줄링과 프로세스 상태관리
    • CPU 소유권을 어떤 프로세스에 할당할지
    • 프로세스 생성과 삭제
    • 자원 할당 및 반환 관리
  • 메모리 관리
    • 한정된 메모리를 어떤 프로세스에 얼만큼 할당할지
  • 디스크 파일 관리
    • 디스크 파일을 어떤 방법으로 보관하는지
  • I/O 디바이스 관리
    • 마우스, 키보드와 컴퓨터 간에 데이터 주고받는 것 관리

3. 운영체제의 구조

• 인터페이스 (CLI/GUI)
  • Linux의 경우 CUI만 존재
• 시스템콜
• 커널 (I/O 드라이버, 파일시스템)
• 드라이버
  • 하드웨어를 제어하기 위한 소프트웨어

4. 컴퓨터 시스템의 구조

• 1) CPU (Central Proccesing Unit)

  • 운영체제 커널이 프로그램을 메모리에 올려 프로세스로 만들면 CPU가 처리
  • 인터럽트에 의해 메모리에 존재하는 명령어 해석하여 실행
  • 산술논리연산장치 (ALU) : 산술연산(사칙연산) + 논리연산(배타적 논리합, 논리곱)하는 회로장치
    
  • 제어장치 (CU) : 프로세스의 조작을 지시 + 명령어 읽고 해석 + 데이터 처리 순서 해석
  • 레지스터 : CPU 안에 있는 빠른 임시기억장치

    📖 참고 📖 CPU 연산처리 1️⃣ 제어장치가 메모리에 레지스터에 계산할 값을 로드
    2️⃣ 제어장치가 레지스터에 있는 값을 계산할 것을 산술논리연산장치에 명령
    3️⃣ 제어장치가 계산된 값을 다시 레지스터에서 메모리로 저장

• 2) DMA 컨트롤러

  • CPU를 일을 보조
  • I/O디바이스가 메모리에 직접 접근할 수 있도록 하는 하드웨어 장치
  • CPU에 많은 인터럽트 요청이 들어오는 것을 분담

• 3) 메모리

  • 전자회로에서 데이터, 상태 등을 기록하는 장치
  • CPU는 계산 담당, 메모리 기억 담당
  • 메모리 클 수록 많은 일 동시에 처리 가능
  • 🗒️ 예시 : RAM (Random Access Memory)

• 4) 타이머

  • 특정 프로그램에 시간 제한을 거는 목적
  • 시간이 많이 걸리는 프로그램 작동시 제한을 위해 존재

• 5) device 컨트롤러

  • 컴퓨터와 연결되어 있는 I/O 디바이스들의 작은 CPU

• 6) 로컬 버퍼

  • 디바이스에 있는 작은 메모리

📕 인터럽트

1. 인터럽트 개념

• 어떤 신호가 들어왔을 때 CPU를 일시 정지

• 인터럽트간에 우선순위가 있고 우선순위에 따라 실행

• 과정

  • CPU는 메모리에 있는 명령어 순차 실행 중 인터럽트 발생
    ➡️ 인터럽트 핸들러 함수가 모여있는 인터럽트 벡터로 가서 인터럽트 서비스 함수(ISR) 실행
    ➡️ 인터럽트 종료시 다시 순차적으로 실행
    

  📖 참고 📖 인터럽트 핸들러 함수

  • 인터럽트가 발생했을 때 핸들링하기 위한 함수
  • 커널 내부의 IRQ를 통해 호출되며 request_irq()를 통해 인터럽트 핸들러 함수 등록 가능

2. 인터럽트 종류

• 1) 하드웨어 인터럽트

  • I/O 디바이스 등 하드웨어에서 발생 (키보드, 마우스 연결)
  • 인터럽트 라인이 설계된 이후 순차적인 인터럽트 실행을 중지 ➡️ 운영체제에 시스템콜 요청 ➡️ 디바이스에 있는 작온 로컬 버퍼에 접근하여 수행
  • 🗒️ 예시
    • 입출력 인터럽트 : 입출력 작업 종료/오류에 의해 CPU 기능 요청
    • 정전, 전원 이상 인터럽트 : 전원 공급의 이상
    • 기계 착오 인터럽트 : CPU의 기능적 오류
    • 외부 신호 인터럽트 : I/O 장치가 아닌 오퍼레이터나 타이머에 의해 의도적으로 프로그램 중단

• 2) 소프트웨어 인터럽트

  • 트랩(trap)
  • 프로세스 오류/종류/시작 등으로 프로세스가 시스템콜 호출시 발생
  • 하드웨어 인터럽트보다 우선순위 높음
  • 🗒️ 예시
    • 프로그램 인터럽트 : 0으로 숫자를 나누는 연산오류
    • SVC(SuperVisor Call)

• 3) 인터럽트 우선순위
  

3. 실습

• a.js

const express = require('express');
const app = express();
const path = require('path')
const pt = path.join(__dirname, "a.json")
const fs = require('fs')
app.get("/", (req, res) => {
const ret = fs.readFileSync(pt)
res.json(JSON.parse(ret))
})
app.listen(3000, () => {
console.log('Server listening on port 3000');
});

• a.json

{
"id": 1,
"title": "자바스크립트 풀스택 MEVN",
"author": "큰돌1",
"links": [{
"rel": "self",
"href": "/books/1"
}]
}

• 명령어

ps -ef | grep node
kill -9 {PID} 

📕 시스템콜과 modebit

1. 시스템콜

• 1) 개념
  • 사용자나 응용 프로그램이 커널에서 제공하는 기능을 사용하기 위한 인터페이스
  • 운영체제는 커널이 제공하는 서비스를 Systemcall을 사용해야만 이용할 수 있도록 제한
  • 유저 프로그램이 운영체제의 서비스를 받기 위해 커널 함수를 호출할 때 사용
• 2) I/O 요청을 위한 트랩 발동할 경우 과정
  • 1️⃣ : 유저 프로그램이 I/O 요청 트랩 발동
  • 2️⃣ : 올바른 I/O 요청인지 확인
  • 3️⃣ : 유저모드가 시스템콜을 통해 커널모드로 변환
  • 4️⃣ : 커널함수 실행
    
• 3) 모드
  • 유저모드 : 유저가 컴퓨터 자원에 침범하지 못하게 접근 가능한 영역 제한
  • 커널 모드 : 모든 컴퓨터 자원에 접근 가능
    
• 4) 장점
  • 시스템콜 기반으로 유저프로그램을 커널과 분리 ➡️ 사용자가 파일 시스템 및 프로세스 생성 등 내부동작 관여X
  • 유저프로그램에서 함부로 컴퓨터 자원에 접근X ➡️ 시스템 안정성, 보안⬆️

📖 참고 📖 커널

• ✏️ 커널
  • 운영체제의 중추적인 역할
  • 시스템콜 제공
  • 보안, 메모리, 프로세스, 파일 시스템, I/O 디바이스, I/O 요청 관리
• ✏️ 커널함수 (native function)
  • 커널 안에 있는 여러개의 함수
• ✏️ 커널함수 호출 경우
  • 프로세스 관리(생성, 삭제)
  • 파일 관리, 디바이스 관리
  • 시간 및 날짜 관련 시스템
  • 프로세스간 통신

2. modebit

• 시스템콜이 작동될 때 유저모드와 커널모드 구분하는 플래그 변수
  • 유저 모드(1)
  • 커널 모드(0)

📕 메모리계층

1. memory hierachy

• 레지스터 > 캐시 > 주기억장치 > 보조기억장치
• 1) 레지스터
  • CPU 내의 작은 메모리
  • 휘발성, 속도⬆️
  • 기억 용량⬇️
• 2) 캐시
  • CPU 내의 L1, L2 캐시
  • 휘발성, 속도⬆️
  • 기억 용량⬇️
• 3) 주기억장치
  • RAM
  • 휘발성, 속도⬇️
  • 기억 용량⬆️
• 4) 보조기억장치
  • HDD, SDD
  • 비휘발성, 속도⬇️
  • 기억 용량⬆️

2. 계층이 존재하는 이유

• 1) 더 빠른 접근과 처리속도 증가
  • 특정 데이터에 빠르게 접근 가능
  • 처리속도⬆️
• 2) 비용 효율성 (경제성)
• 3) 자원의 효율적 사용

📕 가상메모리와 스와핑, 페이지폴트, 스레싱

1. 가상 메모리

• 1) 개념
  • 프로세스 전체가 메모리 내에 올라오지 않더라도 실행 가능한 기법
  • 컴퓨터의 물리적 메모리 크기에 제약X

2) 특징

• 더 많은 프로그램을 동시에 실행 가능

  • 응답시간 유지
  • CPU 이용률과 처리율⬆️

• 보조메모리를 주메모리 처럼 처리
  - RAM에서 disk storage로 데이터를 일시적으로 전송하는 스와핑
  

• 2) 가상주소와 실제주소

  • Logical Address (Virtual) : 가상적으로 지어진 주소
  • Physical Address : 실제 메모리상에 있는 주소
  • 가상주소는 메모리관리장치(MMU)와 페이지테이블에 의해 실제 주소로 변환

• 3) 페이지테이블

  • 페이지테이블에 가상주소-실제주소 매핑 + 프로세스 주소 정보 저장
  • 속도 향상을 위해 캐싱계층인 TLB 사용
    

📖 참고 📖 TLB

• 메모리와 CPU 사이에 있는 주소 변환을 위한 캐시
• 페이지 테이블에 있는 리스트 보관
• CPU가 TLB에 있는지 확인하고 없으면 페이지테이블로 가서 실제주소 가져옴 ➡️ 속도 향상

📖 참고 📖 메모리 단위

• 페이지 : 가상 메모리를 사용하는 최소 크기 단위
• 프레임 : 실제 디스크나 메모리를 사용하는 최소 크기 단위

• 4) 가상메모리 필요성

  • 주기억장치의 효율적 관리(스와핑)
    • 하드디스크를 주기억장치에 대한 캐시로 설정
    • 필요할 때만 램에 데이터를 불러와 사용하고, 그외에는 하드디스크에 저장하여 RAM 효과적 관리
  • 메모리 관리의 단순화
    • 각 프로세스마다 가상메모리의 통일된 주소 공간을 배정
  • 메모리 용량 및 안전성 보장
    • 무한한 가상메모리 공간으로 프로세스들끼리 메모리 침범할 여지 줄임

  

3. 페이지폴트와 스와핑

• 1) 페이지폴트 개념

  • 참조하는 메모리 영역이 실제로 없는 경우
  • 가상 메모리에는 존재하지만 실제 메모리인 RAM에 현재 없는 데이터나 코드에 접근하는 경우 발생

• 2) 스와핑 개념

  • 메모리에서 현재 사용하지 않는 영역을 옮기고 하드디스크 일부분을 메모리처럼 사용
    

• 3) 페이지폴트 과정

  • 1️⃣ : 물리 메모리에 있는 실행될 프로세스는 사용하고자 하는 페이지가 페이지테이블에 있는지 확인
  • 2️⃣ 없을 경우 트랩 발생 (Pagefault exception)
    ➡️ 운영체제에 알리고, CPU 동작 잠시 멈춤
    ➡️ 커널 모드로 진입
  • 3️⃣ : 운영체제는 페이지 테이블 확인하여 가상 메모리 어디에 페이지 존재하는지 확인
  • 4️⃣ : 없었던 페이지를 물리 메모리에 로드
    • 사용하지 않는 프레임 찾음
    • 빈 프레임 없을 경우, 페이지교체 알고리즘 사용해 스와핑
  • 5️⃣ : 페이지테이블 갱신
  • 6️⃣ : 중단했던 작업 재실행
    

4. 스레싱

• 1) 개념

  • 메모리의 페이지폴트 비율이 높은 것
  • 메모리에 너무 많은 프로세스가 동시에 올라가면 스와핑이 많이 일어나서 발생
  • 컴퓨터의 심각한 성능 저하 초래

• 2) 스레싱 원인

  • 페이지폴트가 일어나면 CPU 이용률⬇️
    ➡️ 운영체제는 CPU의 가용성을 높이기 위해 더 많은 프로세스를 메모리에 올림
    ➡️ 악순환 반복되며, 스레싱 발생
    

• 2) 하드웨어적 해결

  • 메모리 늘리기
  • HDD 사용할 경우 SSD로 바꾸기

• 3) 운영체제적 해결

  • 작업세트 (working set) : process 과거 사용이력(지역성) 기반으로 많이 사용하는 페이지집합을 만들어 한꺼번에 미리 메모리에 로드
    ➡️ 탐색 비용⬇️, 스와핑⬇️
  • PFF (Page Fault Frequency) : 상한선과 하한성 정하고, 상한선에 도달하면 프레임 늘리고 하한선에 도달하면 프레임 줄임
    

📕 페이지교체 알고리즘

1. LFD (Longest Forward Distance)

• 1) 개념

  • 오프라인 알고리즘
  • 가장 먼 미래에 참조되는 페이지와 현재의 페이지를 바꾸는 알고리즘

• 2) 특징

  • 미래에 사용되는 프로세스 알지 못해서 사용X
  • 다른 알고리즘 성능 비교에대한 기준으로 사용

• 🗒️ 예시 : 프레임의 페이지 중 1이 뒤에 쓰일 것을 알고 미리 교체
  

2. FIFO (First In First Out)

• 1) 개념

  • 가장 먼저 온 페이지부터 교체

• 2) 특징

  • 구현 간단, 성능⬇️
  • 큐를 이용해 저장
  • Belady's Anomaly 현상 발생 가능

• 🗒️ 예시 : 가장 오래된 7 교체
  

  📖 참고 📖 Belady's Anomaly

  • 직관적으로, 프레임의 수가 많아질 수록 페이지 결함의 횟수는 감소함
  • 프레임 개수 많아져도 page-fault가 줄어들지 않고 늘어나는 현상
    
    

3. LRU (Least Recently Used)

• 1) 개념
  • 가장 오래 사용하지 않은 페이지 교체
  • 시간 지역성 성질 고려 (최근에 참조된 페이지가 가까운 미래에 다시 참조될 가능성 높음)
• 2) 특징
  • 성능 좋음
  • 최적 알고리즘과 비슷한 효과
  • 각 페이지마다 최근 사용한 시간 저장하는 구조 필요 (계수기, 스택)
  • 프로세스가 주기억장치에 접근할 때마다 참조된 페이지 시간을 기록해야함 ➡️ 막대한 오버헤드
• 🗒️ 예시 : 가장 오랫동안 사용하지 않은 1 교체
  

4. NUR (Not Used Recently)

• 1) 개념

  • clock 알고리즘, LRU에서 발전된 알고리즘
  • 최근에 사용하지 않은 페이지 교체
  • 0과 1가진 비트 필요
    • 1 : 최근에 참조됨
    • 0 : 참조되지 않음
      ➡️ 시계 방향으로 돌면서 0을 찾으면 해당 페이지 1로 교체

• 2) 특징

  • 동일 그룹 내에서 선택 무작위
  • 각 페이지마다 2개의 참조비트 / 변형 비트 사용
    • 페이지 프레임에 적재 : r = 0, m = 0
    • 페이지를 참조 : r = 1 (주기적으로 0으로 변경)
    • 페이지 수정 : m = 1
  • 교체 우선순위 : 참조비트 > 변형비트
    • 1️⃣ : r = 0, m = 0
    • 2️⃣ : r = 0, m = 1
    • 3️⃣ : r = 1, m = 0
    • 4️⃣ : r = 1, m = 1

• 🗒️ 예시 : 우선순위 낮은 B 교체
  

5. LFU (Least Frequently Used)

• 1) 개념

  • 가장 참조 횟수가 적은 페이지 교체
  • 교체 대상이 여러개라면 가장 오랫동안 사용하지 않은 페이지 교체

• 2) 특징

  • LRU는 직전 참조된 시점만 반영
  • LFU는 참조 횟수를 통해 장기적으로 참조를 고려 가능
    ➡️ 막대한 오버헤드

• 🗒️ 예시 : 각각 1번씩 참조한 페이지 2, 3 중 LRU에 따라 더 오래 쓰지 않은 2 교체
  

📖 참고 📖 LFD 알고리즘 (Longest Forward Distance)

• 오프라인 알고리즘, 최적 페이지 교체 알고리즘
  • 🗒️ 예시 : 요청 i + 1이 페이지 폴트가 일어나지 않을 경우
    • 스왑이 일어나지 X
  • 🗒️ 예시 : 요청 i + 1이 페이지 폴트가 일어날 경우
    • '서로 다른 페이지'를 스왑한다고 가정
    • 페이지 p를 제거하고 필요한 페이지를 가져옴
    • p를 제거하고 p'와 스와핑을 j - 1 전에 한 상태라면, p가 왔을 때 1번 스와핑
    • p를 제거하고 다른 페이지와 스와핑 해서 p'일 때, p일 때 2번 스와핑

📕 프로세스와 스레드

1. process

• 1) 개념

  • 실행중인 프로그램
  • CPU 스케줄링 대상이 되는 작업(task)
  • 디스크로부터 메모리에 적재되어 CPU의 할당(주소 공간, 파일, 메모리 등) 받을 수 있음

• 2) 구성

  • 스택 (함수의 매개변수, 로컬변수 등 임시 자료 저장)
  • 데이터 (전역변수 저장)
  • 힙 (동적 할당 메모리)
  • 코드
    

• 3) prgram과 process 차이

  • 프로그램이 메모리에 올라가면 프로세스가 되는 인스턴스화 발생
  • 운영체제의 CPU 스케줄러에 따라 CPU가 프로세스 실행
    

2. thread

• 1) 개념

  • 프로세스의 실행 단위
  • 한 프로세스 내에서 동작되는 실행 흐름, 프로세스 내의 주소 공간이나 자원 공유

• 2) 구성

  • 스레드 ID
  • 프로그램 카운터 : 스레드가 스케줄러에 의해 CPU 할당 받을 때 명령어 어디까지 수행했는지 저장
    ➡️ PC 레지스터 독립적 할당
  • 레지스터 집합
  • 스택 : 함수 호출시 전달 인자, 되돌아갈 주소값, 함수 내 선언 변수 저장
    ➡️ 독립적인 함수 호출 등 실행을 위해 스택 독립적 할당

• 3) 특징

  • 동시성 (서로 독립적인 작업들을 작은 단위로 나누고, 동시에 실행되는 것처럼 보여줌)
  • 자원의 생성과 관리 중복성 최소화
  • 한 스레드가 중단(block)되어도 다른 스레드는 실행(runnig) 상태 일수 있어 중단되지 않고 빠르게 처리

• 4) 구분

  • 싱글스레드 프로세스 : 하나의 스레드로 이루어진 프로세스
  • 멀티스레드 프로세스 : 여러개의 스레드로 이루어진 프로세스
    

3. process와 thread 차이점

• 1) 작업 메모리 영역
  • process : 코드, 데이터, 스택, 힙 메모리 영역
  • thread : 스택 제외한 다른 메모리 영역을 스레들과 공유
• 2) 프로세스간 통신
  • process : 타 프로세스와 격리되어 있어 IPC 사용
  • thread : 타 스레드와 연결되어 있어 정보 공유 쉽지만, 동기화 문제점
• 3) 프로세스간 영향
  • process : 프로세스 문제가 타 프로세스에 영향X
  • thread : 한 스레드에 문제시 타 스레드에 영향 미침
• 4) 생성과 종료
  • process : 많은 시간 소요
  • thread : 적은 시간 소요
    

📕 프로그램의 컴파일 과정

1. 컴파일 과정

프로그램은 컴파일러를 통해 컴파일 과정을 거쳐 기계어로 번역되어 실행 파일 생성

• 1) 전처리
  • 소스코드 주석 제거 + #include 등 헤더파일 병합하여 매크로를 치환
• 2) 컴파일러
  • 어셈블리어로 변환
  • 오류처리, 코드최적화 작업
• 3) 어셈블러
  • 목적코드로 변환 (.c ➡️ .o)
  • 운영체제에 따라 확장자에 맞는 파일 생성
• 4) 링커
  • 실행파일로 변환 (.o ➡️ .exe/.out)
  • 프로그램 내 라이브러리 함수또는 다른 파일드로가 목적 코드를 결합

📖 참고 📖 정적/동적 라이브러리

• ✏️ 정적 라이브러리
  • 프로그램 빌드시 라이브러리가 제공하는 모든 코드를 실행 파일에 넣는 방식
  • 장점 : 시스템 환경 등 외부 의존도가 낮음
  • 단점 : 코드 중복 등 메모리 효율성 떨어짐
• ✏️ 동적 라이브러리
  • 프로그램 실행시 필요할 때만 DLL이라는 함수 정보를 통해 참조하는 방식
  • 장점 : 메모리 효율성 좋음
  • 단점 : 외부 의존도가 높아짐
    

2. 실습

• 명령어
  g++ -save-temps=obj -c a.cpp -o dir/foo.o
  • .ii : 전처리된 C++ 파일
  • .s : 어셈블리어 파일
  • .o : 오브젝트 파일

#include <bits/stdc++.h>
using namespace std;
int main(){
	cout << "hello kundol\n";
	return 0;
}

📕 프로세스의 메모리 구조

1. 메모리 구조

• 1) 스택 (stack)

  • 위 주소부터 할당
  • 지역변수, 매개변수, 함수 저장
  • 컴파일시 크기가 결정됨
  • 함수가 함수 호출하는 등 런타임시에도 크기 변경 가능 (동적 할당)

• 2) 힙 (heap)

  • 아래 주소부터 할당
  • 런타임시 크기 결정 (동적 할당)

• 3) 데이터 영역 (BSS, Data segment)

  • 정적 할당
  • BSS, Data 영역으로 나뉨

• 4) 코드 영역 (code segment)

  • 정적 할당
  • 소스 코드

2. 정적할당

• 1) 정적할당
  • 컴파일단계에서 메모리 할당
  • BSS segment, Data segment, Code/Text segment에 나눠 저장
• 2) BSS segment
  • 전역변수, static, const로 선언된 변수 중 0으로 초기화 또는 초기화가 되지 않은 변수들이 메모리 영역에 할당

#include<bits/stdc++.h>
using namespace std;

int a;
int b = 0;
const int c = 0; // BSS

int main(){
	static int d; // BSS
    static int e = 0; // BSS
    return 0;
}

• 3) Data segment
  • 전역변수, static, const로 선언된 변수 중 0이 아닌 값으로 초기화된 변수들이 메모리 영역에 할당

#include<bits/stdc++.h>
using namespace std;

int a = 1;
const int b = 2; // Data
int main(){
	static int c = 3; // Data
	return 0;
}

• 4) Code/Text segment
  • 프로그램 코드

3. 동적할당

• 1) 동적할당
  • 런타임단계에서 메모리를 할당 받음
  • Stack, Heap에 나눠 저장
• 2) Stack
  • 지역변수, 매개변수, 실행되는 함수에 의해 가변적인 메모리 영역
  • 함수가 호출될 때마다 호출환경 등 특정 정보 저장
  • 재귀함수 호출시 새로운 스택 프레임이 매번 사용되어, 함수간 인스턴수 변수에 영향X
• 3) Heap
  • 동적으로 할당되는 변수
  • malloc(), free() 함수를 통해 관리
  • 🗒️ 예시 : vector는 내부적으로 heap 영역 사용

📕 PCB와 컨텍스트 스위칭

1. PCB (Process Control Block)

• 1) PCB 개념
  • 운영체제에서 관리하는 프로세스에 대한 메타데이터 저장한 데이터 블록
  • 프로세스가 생성될 때마다 고유의PCB 생성 / 프로세스 종료되면 PCB 제거
  • 프로세스 중요 정보를 담고 있어 일반 사용자가 접근하지 못하도록 커널 스택의 가장 앞부분에서 관리

📖 참고 📖 커널스택

• 가상 메모리는 사용자 공간과 커널 공간으로 구분되고, 스택 자료구조 기반으로 관리되어 사용자 스택, 커널 스택으로 불림
• 커널 스택은 가상 메모리 주소의 윗부분 (가장 처음 시작하는 주소값)
  • 커널 스택 : 커널모드에서만 접근 가능
  • 사용자 스택 : 유저모드에서만 접근 가능

📖 참고 📖 메타데이터

• 데이터에 대한 구조화된 데이터 (데이터를 설명하는 데이터)
• 대량의 정보 중 효율적으로 정보를 찾기 위해 일정한 규칙에 따라 콘텐츠에 부여되는 데이터

• 2) PCB 구조
  • 프로세스 상태 : 프로세스가 CPU에 대한 소유권을 얻은 이후의 상태 (준비, 일시중단)
  • 프로세스 번호(PID) : 각 프로세스의 고유 식별 번호, 프로세스의 자식 프로세스 ID
  • 프로세스 권한 : 컴퓨터 자원 또는 I/O 디바이스에 대한 권한 정보
  • 프로그램 카운터 (PC) : 프로세스에 대해 실행될 다음 명령의 주소에 대한 포인터
  • CPU 레지스터 : 프로세스를 실행하기 위해 저장해야 할 레지스터에 대한 정보
  • CPU 스케줄링 정보 : CPU 스케줄러에 의해 중단된 시간 등 정보
  • 메모리 제한 : 프로세스의 메모리 관련 정보
  • 열린 파일 정보 : 프로세스를 위해 열린 파일 목록
  • 계정 정보 : 프로세스 실행에 사용된 CPU 사용량, 실행한 유저의 정보
  • I/O 상태 정보 : 프로세스에 할당된 I/O 디바이스 목록
    

2. Context Switching

• 1) Context Switching 개념

  • PCB 기반으로 프로세스 상태를 저장하고 복원하는 과정
  • 프로세스가 종료되거나 인터럽트에 의해 발생
    

• 2) Context Switching 비용

  • 유휴 시간의 발생 ➡️ CPU 가용성⬇️
  • 캐시미스
    • 프로세스가 가지고 있는 메모리 주소가 그대로 있으면 잘못된 주소 변환 발생
    • 캐시클리어 과정 필요
      

• 3) 스레드에서 Context Switching

  • 스레드는 스택 영역을 제외한 모든 메모리 공유
  • 비용 적고, 시간이 적게 걸림

📕 프로세스의 상태

1. 프로세스 상태

• 1) 생성 상태 (create/new)
  • 프로세스가 생성된 상태
  • fork() 또는 exec() 함수를 통해 생성
  • PCB 할당됨

📖 참고 📖 fork()와 exec() 함수

• ✏️ fork()
  • 부모 프로세스의 주소 공간을 그대로 복사
  • 새로운 자식 프로세스를 생성하는 함수
  • 주소 공간만 복사되고, 부모 프로세스의 비동기 작업 등 상속X
• ✏️ exec()
  • 새로 프로세스 생성하는 함수

• 2) 대기 상태 (ready)

  • 처음 프로세스가 생성된 이후 대기 중이 상태
  • 메모리 공간 충분할 경우 : 메모리 할당
  • 메모리 공간 부족할 경우 : 준비큐(준비 순서열)에 들어감
  • CPU 스케줄러로부터 CPU 소유권이 넘어오기를 기다리는 상태

• 3) 대기 중단 상태 (ready suspended)

  • 준비큐가 가득 찬 상태
  • 메모리 부족으로 일시 중단된 상태

• 4) 실행 상태 (running)

  • CPU 소유권과 메모리 할당받고, 명령 수행 중인 상태
  • CPU burst 일어남

• 5) 중단 상태 (blocked)

  • 어떤 이벤트가 발생한 이후 기다리며 프로세스가 차단된 상태
  • 🗒️ 예시 : 프린트 인쇄 버튼 눌렀을 때 실행하고 있던 프로세스가 잠깐 멈춘 경우
    • 프린트 인쇄에 관한 IO 요청으로 인해 인터럽트 발생
    • 현재 실행하고 있던 프로세스가 중단 상태로 잠시 변경된 것

• 6) 일시 중단 상태 (blocked suspended)

  • 대기 중단과 유사
  • 중단된 상태에서 실행되려고 했지만, 메모리 부족으로 일시 중단된 상태

• 7) 종료 상태 (terminated / exit)

  • 프로세스 실행 완료
  • 해당 프로세스에 대한 자원 반납, PCB 삭제되는 상태
  • abort (비자발적 종료)
    • 부모 프로세스가 자식 프로세스 강제적으로 종료
    • 자식 프로세스에 할당된 자원의 한계치를 넘어섰을 경우
    • 부모 프로세스가 종료됐을 경우
    • 사용자가 process.kill 등 명령어로 프로세스 종료시킬 경우 발생

📖 참고 📖 waiting 상태

• ready suspended (대기 중단)+ block suspended(일시 중단) + blocked(중단)

📕 멀티프로세싱과 멀티스레딩

1. 멀티프로세싱

• 1) 개념

  • 멀티프로세스를 통해 동시에 2가지 이상의 일을 수행할 수 있는 것 (병렬 처리)
  • 특정 프로세스 중 일부에 문제가 발생되더라도 다른 프로세스에 이용해서 처리 가능 ➡️ 높은 신뢰성
    
  • 🗒️ 예시 : 브라우저는 멀티프로세스 + 멀티스레드 아키텍처를 가진 소프트웨어
    • 브라우저 프로세스 : 네트워크 요청이나 파일 접근 권한 담당 (주소 표시줄, 북마크 막대, 뒤로가기 버튼, 앞으로 가기 버튼)
    • 렌더러 프로세스 : 웹 사이트가 보이는 부분 제어
    • 플러그인 프로세스 : 웹 사이트에서 사용하는 플러그인 제어
    • GPU 프로세스 : GPU를 이용해서 화면을 그리는 부분 제어
      

• 2) 특징

  • 격리성, 신뢰성 높음

• 3) 구조
  

• 4) 실습

import os
from multiprocessing import Process
import requests

def f(name):
x = requests.get('https://w3schools.com/python/demopage.htm')
print('pid of parent:', os.getppid())
print('pid of %s : %d' %(name, os.getpid()))
print(x.text)

if __name__ == '__main__':
print('pid of main:', os.getpid())
p1 = Process(target=f, args=("프로세스 1",))
p2 = Process(target=f, args=("프로세스 2",))
p1.start(); p1.join()
p2.start(); p2.join()

2. 멀티스레딩

• 1) 개념

  • 프로세스 내 작업을 멀티스레드로 처리

  • 한 스레드가 중단(blocked)되어도 다른 스레드는 실행(running)상태로 중단되지 않은 빠른 처리 가능 (동시성)
    

  • 🗒️ 예시 : 브라우저는 멀티프로세스 + 멀티스레드 아키텍처를 가진 소프트웨어
    

• 2) 특징

  • 스레드끼리 서로 자원을 공유하고, 프로세스보다 가벼워서 효율성 높음
  • 한 스레드에 문제가 생기면, 다른 스레드에 영향을 끼쳐 프로세스에 영향 끼침

• 3) 구조
  

📕 IPC

1. IPC (Inter-Process Communication)

• 1) 개념
  • 프로세스끼리 데이터 주고받고, 공유 데이터 관리하는 메커니즘
  • 🗒️ 예시 : 브라우저 띄워서 Naver 서버와 HTTP 통신해서 html 파일을 가져오는 경우
    • 클라이언트 : 데이터 요청
    • 서버 : 클라이언트 요청에 응답
• 2) 종류
  • 공유메모리
  • 파일
  • 소켓
  • 파이프
  • 메세지 큐

2. 공유메모리

• 1) 개념
  • 여러 프로세스가 서로 통신할 수 있도록 메모리를 공유하는 것
  • 여러 프로세스가 서로 통신할 수 있도록 공유 버퍼 생성
  • 하드웨어 관점에서 공유 메모리는 CPU가 접근할 수 있는 큰 메모리인 RAM을 가리킴
• 2) 특징
  • 데이터를 주고 받지 않고 메모리를 공유하여 불필요한 오버헤드 발생X, 가장 빠름
  • 같은 메모리 영역을 여로 프로세스가 공유하여 동기화 필요

3. 파일

• 1) 개념
  • 디스크에 저장된 데이터/파일 서버에서 제공한 데이터를 기반으로 통신
• 2) 실습
  • a.js

    const path = require('path')
    const pt = path.join(__dirname, "a.json")
    const fs = require('fs')
    setInterval(()=>{
    	try {
    		if (fs.existsSync(pt)) {
    			console.log("파일을 읽습니다.")
    			const ret = JSON.parse(fs.readFileSync(pt))
    			console.log(ret)
    			}
    		} catch(err) {
    	console.error(err)
    		}
    }, 3000)
    console.log("process 1이 가동됩니다.")

  • b.js

    const path = require('path')
    const pt = path.join(__dirname, "a.json")
    const fs = require('fs')
    setTimeout(()=>{
    	const a = {"a" : 1}
    	fs.writeFileSync(pt, JSON.stringify(a))
    }, 3000)
    console.log("process 2가 가동됩니다.")

4. 소켓

• 1) 개념
  • 동일 컴퓨터의 다른 프로세스나 네트워크의 다른 컴퓨터로 네트워크 인터페이스를 통해 전송하는 데이터
  • 네트워크 인터페이스(TCP, UDP, HTTP) 기반으로 통신

5. 파이프

• 1) 개념

  • 익명 파이프, 명명 파이프

• 2) 익명 파이프 (anonymous/unnamed pipe)

  • 프로세스 사이에 FIFO 기반의 통신채널을 만들어 통신하는 것
  • 부모, 자식 프로세스 간에만 사용 가능
    • 다른 네트워크 상에는 사용 불가능)
  • 파이프 데이터 용량 제한 있음
  • 쓰기 프로세스가 읽기 프로세스보다 빠를 수 없음
    
  • 단방향 통신 (양방향 통신을 위해서 2개 파이프 필요)
    

• 3) 명명 파이프 (named pipe)

  • 파이프 서버와 하나 이상의 파이프 클라리언트 간의 통신을 위한 명명된 단방향/이중 파이프
  • 클라이언트/서버 통신을 위한 별도의 파이프 제공
  • 여러 파이프를 동시에 사용 가능
  • 로컬 프로세스 뿐만 아니라 다른 네트워크 상에서도 통신할 수 있는 파이프
    - 서버, 클라이언트용 파이프를 구분해서 동작
    - 하나의 인스턴스를 열거나 여러 개의 인스턴스를 기반으로 통신
    

6. 메세지 큐

• 1) 개념

  • 큐(queue) 형태로 관리하는 버퍼를 만들어 통신
  • 커널의 전역변수 형태 등으로 커널에서 전역적으로 관리
    

• 2) 특징

  • 다른 IPC 방식에 비해 구현이 단순함
    • 다른 코드의 수정 없이 단지 몇 줄 코드 추가하여 간단하게 메시지큐 접근 가능함
  • 쓰기 및 읽기 빈도 높을 경우 공유 메모리 대안으로 사용

• 3) 과정

  • 1️⃣ : 프로세스가 메시지를 보내거나 받기 전에 큐 초기화
  • 2️⃣ : 보내는 프로세스(sender)의 메시지는 큐에 복사되어 받는 프로세스(receiver)에 전달됨

📕 공유 자원과 경쟁 상태, 임계영역

1. 공유 자원 (shared resource)

• 시스템 안에서 각 프로세스, 스레드가 함께 접근할 수 있는 모니터, 프린터, 메모리, 파일, 데이터 등 자원이나 변수

2. 경쟁 상태 (race condition)

• 1) 개념
  • 공유 자원을 둘 이상의 프로세스 또는 스레드가 동시에 읽거나 쓰는 상황
  • 동시에 접근 시도할 때 타이밍에 예상되는 결과값에 영향을 줄 수 있는 상태
• 2) 경쟁 상태 관리의 중요성
  • 데이터 정합성 (data consistency) : 예상되는 데이터의 값과 달라짐
  • 데이터 무결성 (data integerity) : 데이터의 어떠한 규칙을 위반하면 안됨, 데이터가 변경/손상되지 않고 완전성, 정확성, 일관성을 유지함
    

3. 임계 영역 (critical section)

• 1) 개념
  • 둘 이상의 프로세스 또는 스레드가 공유 자원에 접근할 때 순서 등 이유로 결과가 달라지는 코드 영역
  • 한 번에 둘 이상의 프로세스나 스레드가 들어갈 수 없도록 함
    
• 2) 실습
  • a.js / b.js

const fs = require('fs')
const path = require('path')
const pt = path.join(__dirname, "a.json")
let ret = JSON.parse(fs.readFileSync(pt))
ret.num -= 1000;
setTimeout(() =>{
fs.writeFileSync(pt, JSON.stringify(ret))
}, 3000)

• a.json

{"num" : 1000}

• a.js, b.js가 파일을 읽고 쓰는 부분에 lock을 걸어 실행

📕 뮤텍스, 세마포어, 모니터

1. 경쟁상태 해결

• 1) 경쟁상태 해결 조건
  • 상호 배제 (mutual exclusion)
    • 한 프로세스가 임계 영역에 들어갔을 때 다른 프로세스는 들어갈 수 없음
  • 한정 대기 (bounded waiting)
    • 특정 프로세스가 임계영역 진입을 요청한 후 해당 요청이 승인되기 전까지 다른 프로세스가 임계영역에 진입하는 횟수를 제한하는 것
    • 다른 프로세스가 영원히 임계 영역에 들어가지 못하게 하는 것을 방지함
  • 진행의 융통성 (progress)
    • 만약 어떤 프로세스도 임계영역을 사용하지 않는다면, 임계영역 외부의 어떠한 프로세스도 들어갈 수 있음
    • 프로세스간 서로 방해하지 않는 것
  • CPU의 개수나 속도에 대한 어떤 가정도 하지 않음
• 2) 경쟁상태 해결 방법
  • 뮤텍스
  • 세마포어
  • 모니터

2. 뮤텍스 (mutex)

• 1) 개념

  • 객체 lock을 기반으로 경쟁상태 해결
    • 공유 자원을 lock()을 통해 잠금 설정
    • 사용한 후에 unlock()을 통해 잠금 해제
  • 공유자원을 사용하기 전에 설정하고, 사용한 후에 잠금 해제하는 방식
    • 잠금이 설정되면 다른 프로세스나 스레드는 잠긴 코드 영역에 접근X
    • 뮤텍스는 하나의 상태(잠금/잠금해제)만 가짐
  • 공유자원이나 코드의 일부분에 대해 상호배제하는 경우 사용
    

• 2) 실습

Mutex lock;
void f(){
	mutex_lock(&lock);
...
	{Critical Section}
...
	mutex_unlock(&lock);
}

3. 세마포어 (semaphore)

• 1) 개념

  • 일반화된 뮤텍스
  • 간단한 정수 S값과 2가지 함수 wait(), signal()로 공유 자원에 대한 접근 처리
  • 여러 프로세스가 동시에 임계영역에 접근 할 수 있음
  • 바이너리 세마포어, 카운팅 세마포어로 구분

• 2) 구성

  • S : 현재 쓸 수 있는 공유자원의 수
  • wait() = down() = P()
    • S = 0일 경우 : 대기
    • S > 0일 경우 : 1 감소하고, 계속 수행
    • S < 0일 경우 : 공유자원 쓸 수 없어 프로세스 차단되고 대기열에 프로세스 집어 넣음
  • signal() = up() = V()
    - S를 1 증가시킴
    - S = 0이고, 대기중인 프로세스 있을 경우 : 대기열에 있는 프로세스 동작함 (S는 그대로 0)
    

• 3) 실습

struct Semaphore {
	int value;
	Queue<process> q; // PCB를 담고 있음.
};
wait(Semaphore s)
{
	s.value = s.value - 1;
	if (s.value < 0) {
    // 대기열에다 집어 넣는다.
		q.push(p);
		block();
	} else return;
}
signal(Semaphore s)
{
	s.value = s.value + 1;
	if (s.value <= 0) {
	// 대기열에 있던 프로세스를 끄집어내서 공유자원에 대한 작업을 진행합니다.
		Process p = q.pop();
		wakeup(p);
	}
	else return;
}

• 4) 바이너리 세마포어
  • 0, 1 값만을 가지는 세마포어
  • 구현의 유사성으로 인해 뮤텍스와 유사
• 5) 카운팅 세마포어
• 여러 개의 값을 가지는 세마포어
• 여러 자원에 대한 접근 제어하는데 사용

📖 참고 📖 뮤텍스와 바이너리 세마포어 차이

4. 모니터 (monitor)

• 1) 개념
  • 둘 이상의 스레드/프로세스가 공유 자원에 안전하게 접근하도록 공유 자원을 숨기고 해당 접근에 대한 인터페이스만 제공하는 객체
  • 모니터 큐를 통해 공유 자원에 대한 작업을 순차적으로 처리
    

📖 참고 📖 모니터와 세마포어 차이

• ✏️ 모니터
  • 구현 쉬움
  • 1번에 1개 프로세스만 공유자원 접근 가능
  • 상호배제 자동
  • 인터페이스 기반으로 구축
• ✏️ 세마포어
  • 구현 어려움
  • 1번에 여러개의 프로세스가 공유자원 접근 가능
  • 상호배제 명시적 구현 필요
  • 정수변수 기반으로 구축

📕 교착상태

1. deadlock

• 1) 개념

  • 2개 이상의 프로세스가 서로 가진 자원을 기다리며 중단된 상태
  • 각 프로세스는 서로가 원하는 유지한채 다른 프로세스의 자원을 얻기를 기다리는 것
    

• 2) 필요 조건

  • 상호 배제 (Mutual Exclusion)
    • 주어진 시간 내에 하나의 프로세스만 독점함
    • 다른 프로세스들은 접근 불가능
  • 점유 대기 (Hold and Wait)
    • 특정 프로세스가 점유한 자원을 다른 프로세스가 요청하며 대기하는 상태
  • 비선점 (No Preemption)
    • 다른 프로세스의 자원을 강제적으로 가져올 수 없음
  • 환형 대기 (Circular Wait)
    • 서로가 서로의 자원을 요구하는 상황

• 3) 해결 방법

  • 교착상태 예방 (prevention)
    • 자원을 할당할 때, 교착상태 조건이 성립되지 않도록 설계
    • 발생원인 4가지 중 1개를 부정함
    • 실제 구현이 난해하거나 불가능함
  • 교착상태 회피 (avoidance)
    • 교착상태 가능성이 없을 때만 자원 할당
    • 프로세스가 요청한 자원의 최대치를 통해서 자원 할당가능 여부를 파악함
    • 은행원 알고리즘
  • 교착상태 탐지 (detection)
    • 탐지알고리즘을 통해 교착상태인지 판별
    • 탐지알고리즘은 오버헤드가 있어서, 얼마나 자주 교착상태가 발생하는지 얼마나 많은 프로세스가 교착상태에 연관되어있는 지에 따라 호출 빈도 조절
  • 교착상태 복구 (recovery)
    • 교착상태 발생하면 회복
    • 사용자가 작업 종료 / 시스템에 의해 처리 (프로세스 중지/자원 선점)

2. 은행원 알고리즘 (banker's algorithm)

• 1) 개념
  • 교착상태 회피 알고리즘
  • 총 자원의 양과 현재 할당한 자원의 양을 기준으로 안정/불안정 상태로 나눔
  • 안정 상태가 되도록 자원을 항당하는 알고리즘
  • n * m 2차원 배열 3개 + n 1차원 배열 2개 사용
• 2) 단점
  • 할당할 수 있는 자원의 수가 일정해야 함
  • 프로세스의 수가 일정해야 함
  • 항상 안전상태를 유지해야 하므로, 자원 이용률 낮음
  • 프로세스가 요구하는 최대 자원 수를 예측하기 어려움
  • 프로세스는 반드시 유한 시간 내에 사용한 자원을 반납해야 함
  • 해당 알고리즘에 대한 자원소모량이 증가하여 프로그램 수는 고정되어 있지 않고, 항상 변함

📖 참고 📖 안정 상태와 불안정 상태

• 안정 상태
  • 교착상태를 일으키지 않은 상태
  • 프로세스의 최대자원 요구량을 운영체제가 충족시킬 수 있는 상태
• 불안정 상태
  • 안정 상태로 가는 순서열이 존재하지 않는 상태

• 3) 구성
  • available[i]
    • 운영체제가 프로세스에게 자원을 줄 수 있는 양
    • i번째 사용가능한 자원의 양
  • max[i][j]
    • 프로세스 최대 요구량
    • 프로세스 i가 자원 j를 최대 요청할 수 있는 양
  • allocation[i][j]
    • 프로세스 자원할당 양
    • 프로세스 i에 자원 j를 할당한 양
  • need[i][j]
    • 프로세스의 자원 추가요구량
    • 프로세스 i가 자원 j를 추가요청하는 양
  • finish[i]
    • i번째 프로세스가 요청하는 양을 운영체제가 만족할 수 있는지를 파악하는 boolean 배열
• 4) 순서
  • 1️⃣ : requesh[i] <= need[i]
    • 해당 조건 불총족시 오류
  • 2️⃣ : requesh[i] <= available[i]
    • 해당 조건 불충족시 대기
  • 3️⃣ : request[i] += available[i], need[i] -= request[i]
  • 4️⃣ : 1️⃣ ~ 3️⃣ 과정을 모든 프로세스가 반복한 뒤 모든 finish[i]가 True라면 안정 상태
• 5) 실습
  
  • 안정상태 되는 순서 : P1 ➡️ P3 ➡️ P4 ➡️ P0 ➡️ P2
  • P1 : 1, 2, 2에 해당하는 need[1]에 대한 자원을 할당하고, finish[1] = True로 만듦
    • ➕ 2 0 0
    • available : 5 3 2
  • P3 : 0, 1, 1에 해당하는 need[3]에 대한 자원 할당하고, finish[3] = True로 만듦
    • ➕ 2 1 1
    • available : 7 4 3
  • P4 : 4, 3, 1에 해당하는 need[4]에 대한 자원 할당하고, finish[4] = True로 만듦
    • ➕ 0 0 2
    • available : 7 4 5
  • P0 : 7, 4, 3에 해당하는 need[0]에 대한 자원 할당하고, finish[0] = True로 만듦
    • ➕ 0 1 0
    • available : 7 5 5
  • P2 : 6, 0, 0에 해당하는 need[2]에 대한 자원 할당하고, finish[2] = True로 만듦
    • ➕ 3 0 2
    • available : 10 5 7

let n, m, i, j, k;
n = 5; // 프로세스의 갯수 0 ~ 4
m = 3; // 자원의 갯수
//이미 할당한 양
let alloc = [ [ 0, 1, 0 ], // P0
[ 2, 0, 0 ], // P1
[ 3, 0, 2 ], // P2
[ 2, 1, 1 ], // P3
[ 0, 0, 2 ] ]; // P4
// 프로세스가 최대치로 요구하는 양
let max = [ [ 7, 5, 3 ], // P0
[ 3, 2, 2 ], // P1
[ 9, 0, 2 ], // P2
[ 2, 2, 2 ], // P3
[ 4, 3, 3 ] ]; // P4
// 운영체제의 가용할 수 있는 자원의 양
let avail = [ 3, 3, 2 ], ans = []
let need = Array.from({ length: n }, (v, i) => Array.from({
length: m }, (v, j) => 0));
let finish = Array.from({ length: n }, (v, i) => 0);
for (i = 0; i < n; i++) {
	for (j = 0; j < m; j++){
		need[i][j] = max[i][j] - alloc[i][j]
	}
}
//프로세스를 돌면서 확인합니다.
for (let k = 0; k < n; k++) {
	for (let i = 0; i < n; i++) {
		if (finish[i] == 0) {
			let flag = 0;
			for (j = 0; j < m; j++) {
				if (need[i][j] > avail[j]){
					flag = 1;
					break;
				}
			}
			if (flag == 0) {
				ans.push(i)
				for (let y = 0; y < m; y++)
					avail[y] += alloc[i][y];
				finish[i] = 1;
			}
		}
	}
}
let safe_flag = 1
for(let i = 0; i < n; i++){
	if(finish[i] == 0) 
    	safe_flag = 0
}
if(safe_flag){
	console.log("안정상태 순서는 다음과 같습니다. ");
	for (let i = 0; i < n; i++){
		console.log("Process " + ans[i]);
	}
}else{
	console.log("불안정상태입니다.");
}

📕 CPU 스케줄링 알고리즘

1. 비선점형 방식 (non-preemptive)

• 1) 개념

  • 프로세스가 스스로 CPU를 포기하는 방식, 강제로 중지X
  • 컨텍스트 스위칭으로 인한 부하 적음

• 2) FCFS (First Come First Served)

  • 가장 먼저 온 것을 먼저 처리
  • 단점 : 프로세스가 길다면, 준비 큐에서 오래 기다리는 현상(convoy effect) 발생
    

• 3) SJF (Shortest Job First)

  • 실행 시간이 가장 짧은 프로세스를 먼저 실행
  • 장점 : 평균 대기 시간이 가장 짧음
  • 단점 : 긴 프로세스가 실행되지 않는 현상(starvation) 발생
    

• 4) 우선순위를 높이는 방법 (aging)

  • 작업의 시간, 프로세서의 메모리 요구사항, 열린 파일 수, 평균 CPI 사용량 고려해 설정

2. 선점형 방식 (preemptive)

• 1) 개념

  • 현대 운영체제가 쓰는 방식
  • 지금 사용하고 있는 프로세스를 중단시키고, 강제로 다른 프로세스에 CPU 소유권 할당

• 2) RR (Round Robin)

  • 현대 컴퓨터가 쓰는 스케줄링 방법 (로드 밸런서에서 트래픽 분산 알고리즘에 사용)
  • 각 프로세스는 동일한 할당 시간을 주고, 그 안에 끝나지 않으면 다시 준비 큐 뒤로 가는 알고리즘
  • 🗒️ 예시 : q만큼의 할당 시간이 부여되고, N개의 프로세스가 운영되는 경우
    • (N - 1) * q 시간이 지나면 다시 할당
    • 할당 시간이 클 경우 : FCFS
    • 할당 시간이 짧을 경우 : 컨텍스트 스위칭이 잦아져서 오버헤드 비용 커짐
  • 전체 작업 시간은 길어지지만, 평균 응답 시간이 짧아짐
    

• 3) SRF (Shortest Remaining Time First)

  • 중간에 짧은 작업이 들어오면, 수행하던 프로세스를 중지하고 해당 프로세스를 수행

• 4) 다단계 큐

  • 우선순위에 따른 준비 큐를 여러 개 사용
    • 큐마다 RR/FCFS 등 다른 스케줄링 알고리즘을 적용 (비선점형으로된 다단계 큐도 존재)
    • 큐 간의 프로세스 이동이 안됨 ➡️ 스케줄링 부담⬇️, 유연성⬇️
  • 우선순위가 높은 큐부터 처리되어, 낮은 큐 프로세스 처리 안되는 기아현상(starvation) 발생
    

📖 참고 📖 CPU 선정 조건

• 스케줄링 알고리즘을 통해 프로세스 선택됨
• 비선점형/선점형 선택 조건
  • 1️⃣ : CPU 사용률이 높은지
  • 2️⃣ : 단위 시간당 작업을 마친 프로세스의 수(처리량)이 높은지
  • 3️⃣ : 작업을 요청한 프로세스가 작업을 시작하기 전 대기시간, 응답시간은 짧은지

📕 캐시

1. 캐시

• 1) 캐시

  • 데이터를 미리 복사해 놓는 임시 저장소
  • 빠른 장치와 느린 장치의 속도 차이에 따른 병목 현상을 줄이기 위한 메모리
    ➡️ 데이터 접근시간의 단축, 데이터를 다시 계산하는 등 시간 절약
  • 성능 개선은 참조의 지역성 성질로 발생
  • 🗒️ 예시 : CPU 레지스터
    • CPU가 메모리부터 데이터를 가져올 때의 시간이 큼
    • 캐시(중간 레지스터 계층)으로 속도차이 해결
      

• 2) 캐시히트 / 캐시미스

  • 캐시히트 : 캐시에서 원하는 데이터를 찾은 것
  • 캐시미스 : 캐시에서 원하는 데이터를 찾지 못한 것 (메모리로 가서 원하는 데이터를 레지서트에 등록)
    
  • 🗒️ 예시 : 데이터베이스에서의 redis데이터베이스를 캐시계층으로 둔 사례
    
  • 🗒️ 예시 : 웹서버 앞단에 nginx 서버를 캐시계층으로 둔 사례
    

• 3) 지역성의 원리

  • 캐시는 자주 사용하는 데이터(지역성)를 기반으로 설정
  • 시간 지역성 (temporal locality)
    • 최근 사용한 데이터에 다시 접근

  let arr = Array.from({length : 10}, ()=> 0);
  
  		console.log(arr)
  		for (let i = 0; i < 10; i += 1) { // 시간 지역성
  			arr[i] = i;                   // 공간 지역성
  		}
    console.log(arr)
    
  		/*
  		[
  		0, 0, 0, 0, 0,
  		0, 0, 0, 0, 0
  		]
  		[
  		0, 1, 2, 3, 4,
  		5, 6, 7, 8, 9
  		]
    */

  • 공간 지역성 (spatial locality)
    • 최근 접근한 데이터를 이루고 있는 공간이나 그 가까운 공간에 접근

• 4) 실습

  • 모듈 설치

  npm install node-cache express

  • 코드

  	const express = require('express');
  		const NodeCache = require('node-cache');
  		const app = express();
  		const cache = new NodeCache();
    
  		const obj = {
  			"userId": 1,
  			"id": 1,
  			"title": "kundol is god?",
  			"completed": false
  		}
  		app.get('/kundol', (req, res) => {
  			const value = cache.get('kundol');
  			if (value) {
  				console.log('캐시가 있습니다. 캐시를 전달합니다.')
  				return res.send(value);
  			} else {
  			//가상의 데이터베이스 로직
  				console.log('캐시가 없습니다. 캐시를 셋팅하고 데이터베이스로 부터 값을 가져옵니다. ')
  				setTimeout(() => {
  					cache.set('kundol', obj);
  					return res.json(obj);
  				}, 2000);
  			}
  		});
    app.listen(3000, () => {
  			console.log('Cache server running on port 3000 ::
  			http://127.0.0.1:3000/kundol');
  		});

2. 캐시매핑

• 1) Mapping Function
  • CPU가 쓰는 주소는 가상 메모리 주소이기 때문에 메모리가 인식X
  • 중간에 메모리 관리 장치(MMU)가 번역을 하여 물리 주소로 변환
  • 캐시에 데이터를 저장하는 방식에 따라 물리주소를 다르게 해석 가능
    
    

📖 참고 📖 블록 (block)

• 메인 메모리에서 캐시로 데이터를 저장할 때 참조의 지역성으로 인접한 곳까지 한꺼번에 캐시메모리에 저장하는 단위
  • 메모리는 블록으로 나누고, 캐시는 라인으로 나눔
  • 블록 크기 = 라인 크기
• <P, D>로 나누어 관리
  • P(Block Number) : 페이지 번호 (변환)
  • D(Block Offset) : 페이지 번호로부터 해당 주소까지의 거리 (변환X)
• P를 직접매핑에서는 {tag, bd}로 세분화하여 구현
  • tag : 메인 메모리의 몇번째 블록인지 저장
  • bd(block distance) : <tag, bd, D>로 세분화하여 bd가 같은 라인만 매핑되도록 함
    
  • Block Offset : 메인 메모리에서 블록의 위치
  • Line Number : 캐시에 들어갈 라인 번호
  • Tag : 한 블록 안에서 페이지를 구분
    

• 2) 직접 매핑 (direct mapping)
  • 직접 블록별 매핑
  • 캐시에 저장된 데이터들은 메인 메모리와 동일한 배열을 가지도록 매핑
    • 장점 : 단순하고, 탐색 쉬움
    • 단점 : 적중률(Hit ratio)가 낮음
  • 🗒️ 예시 : 메모리가 A개의 페이지, 캐시가 B개의 페이지로 구성될 경우
    • 블록의 수 = A(메모리의 페이지 수) / B(캐시의 페이지 수)
      

📖 참고 📖 CPU가 데이터 받아오는 과정

• 🗒️ 예시 : 주소 010100000의 데이터 a 참조
  • 1️⃣ : CPU가 주소 010100000 생성하여 캐시 메모리에 데이터 요청
  • 2️⃣ : 캐시는 주소를 CPU 태그(01), 인덱스(010), 블록 오프셋(0000)으로 분할
  • 3️⃣ : 인덱스 필드(010)가 가리키는 캐시의 태그를 추출
  • 4️⃣ : CPU 태그와 캐시 태그를 비교
  • 5️⃣ : 유호 비트가 0이므로 캐시 실패 발생 (CPU에 알림)
  • 6️⃣ : CPU는 메모리에 동일한 주소를 보내어 데이터 요청
  • 7️⃣ : 메모리는 데이터 a가 있는 메모리 블록(주소 : 01010)를 복사하여 캐시 메모리로 전송
  • 8️⃣ : 메모리 블록을 인덱스 필드(010)가 가리키는 캐시 블록으로 사상하고 캐시 태그를 01로 갱신, 유효 비트를 1로 설정
  • 9️⃣ : 블록 오프셋(0000)을 사용하여 캐시 블록에서 데이터 a를 추출하고 CPU에 전송
    

• 3) 연관 매핑 (associative mapping)

  • 직접 매핑 단점 보완
  • 캐시에 저장된 데이터들은 메인 메모리 순서와 관련 없음
    • 장점 : 스와핑 발생⬇️, 적중률 높음
    • 단점 : 캐시의 모든 블록을 탐색해야 해서 속도 느림
      

• 4) 집합-연관 매핑 (set associate mapping)

  • 직접매핑 + 연관매핑
  • 직접매핑처럼 특정 캐시 영역에 정해진 인덱스만 들어갈 수 있지만, 여러 개의 집합으로 이뤄져서 그 집합 내에 아무 자리만 들어가면 되는 방식
    • 장점 : 적중률 높고, 저렴, 속도 빠름
    • 모든 블럭을 찾을 필요 없이 특정 블럭을 찾아 탐색 비용을 낮춤
  • 🗒️ 예시 : 캐시에서 bd=0인 집합을 2개로 나누고, bd가 같은 것만 들어올 수 있음
    • bd가 많지만, bd=0, bd=1 밖에 없도록 하고 집합을 2개로 나눔
    • bd=0이 2개 들어가도록, bd=1이 2개 들어가도록 나눔
      

📕 메모리할당

1. 연속할당

• 1) 연속할당 (contiguous memory allocation)

  • 필요 메모리를 할당할 때 시작 메모리의 위치, 메모리 할당 크기를 기반으로 할당
  • 메모리에 연속적으로 공간 할당
  • 사용 가능한 모든 메모리 공간이 같은 위치에 있음 (메모리 파티션이 분산 되어있지X)
    

• 2) 고정분할 방식 (fixed partition allocation)

  • 메모리를 미리 같은 크기로 분할해서 할당
  • 내부단편화 발생

• 3) 가변분할 방식 (variable partition allocation)

  • 프로그램에 필요한 만큼 동적으로 할당하는 방법
  • 외부단편화 발생
  • 적합 방식
    • 최초 적합 (first fit) : 할당 가능한 빈 공간 찾으면 바로 할당
    • 최적 적합 (best fit) : 필요한 메모리 크기보다 큰 공간 중 가장 작은 공간부터 할당
    • 최악 적합 (worst fit) : 프로세스 크기가 가장 많이 차이나는 공간에 할당
      

📖 참고 📖 단편화

• ✏️ 내부단편화
  • 프로그램이 필요한 공간보다 더 많은 메모리가 할당된 경우
  • 나중에 프로그램에 필요한 메모리를 할당하지 못한 현상 발생
    
• ✏️ 외부 단편화
  • 동적으로 할당한 외부에 작은 조각들이 생김
  • 큰 프로그램이 들어왔을 경우 메모리를 할당못하는 현상 발생
    

2. 불연속할당

• 1) 불연속할당 (non-contiguous memory allocation)

  • 메모리를 연속적으로 할당하지 않는 방법
  • 현대 운영체제가 사용하는 방법
  • 프로그램에 메모리를 쪼개어 서로 다른 위치에 있는 메모리 공간에 할당

• 2) 페이징 (memory paging)

  • 동일한 크기(보통 4KB)의 페이지 단위로 나눠 메모리의 서로 다른 위치에 프로세스 할당
  • 주소 변환을 페이지별로 해서 주소 변환이 복잡함
  • 외부단편화 해결, 내부단편화 발생
    

• 3) 세그멘테이션 (memory segmentation)

  • 세그먼트 단위로 나누는 방식
  • 공유와 보안 좋음
  • 내부단편화 해결, 외부단편화 발생

• 4) 페이지드세그멘테이션 (paged segmentation)

  • 세그멘테이션으로 나누고, 해당 세그멘테이션을 동일한 크기의 페이지로 나누는 방법

📖 참고 📖 convoy effect와 stavation 차이

• ✏️ convoy effect
  • 몇몇 오래 걸리는 프로세스로 인해 다른 프로세스의 실행이 느려지고, 대기 시간이 길어짐 (성능 저하)
  • FCFS(First Come First Server) 알고리즘 사용할 때 발생하는 현상
  • 🗒️ 예시 : P1:100ms, P2:5ms, P3:5ms의 프로세스가 있을 경우
    • P1 ➡️ P2 ➡️ P3, 평균대기시간 = (0 + 100 + 105)/3 = 68ms
    • P2 ➡️ P3 ➡️ P1, 평균대기시간 = (0 + 5 + 10)/3 = 5ms
• ✏️ stavation
  • 어떤 프로세스가 무기한으로 대기하며 CPU 소유권을 얻을 수 없음
  • SJF 알고리즘을 사용할 때 발생하는 현상
    • 원인 : 우선순위가 밀려서 프로세스가 실행이 안됨
    • 해결 : aging을 통해 우선순위를 높임
      

📖 참고 📖 busy wait

• 프로세스, 스레드가 어떠한 일을 실행하기 전에 만족하는 조건을 지속적으로 확인하는 동기화 기술
• 운영체제에서 프로세스가 공유자원에 동시에 접근하는 것을 방지하는 상호배제 달성에 사용
• 단점
  • 우선순위에 따라 작업을 바꿀 수 없어서, 우선순위가 높은 작업 완료시 비효율적
  • 대기시간이 많이 걸릴 경우 계속 기다리는데 CPU 자원을 사용 (자원 낭비가 심함)
    

📖 참고 📖 펌웨어와 운영체제 차이

• 1️⃣ : 메모리
  • 펌웨어 : ROM(비휘발성 메모리) 1개를 씀
  • 운영체제 : 휘발성, 비휘발성 메모리를 계층화하여 사용
• 2️⃣ : 프로그램 설치/업데이트
  • 펌웨어 : 자유롭게 프로그램 설치할 수 없고, 미리 설치해놓은 프로그램을 기반으로 업데이트 (ROM에 해당 소프트웨어 수정하며 업데이트)
  • 운영체제 : 운영체제 위에 프로그램을 자유롭게 설치, 정기적으로 업데이트
• 3️⃣ : 사용 예시
  • 펌웨어 : 키보드, 세탁기 등 안에 들어있는 소프트웨어
  • 운영체제 : MacOS, WindowOS