vysryoo

[DS] deque 모듈

vysryoo — Fri, 22 Aug 2025 12:39:37 +0900

파이썬 deque 모듈
- double-ended queue (양쪽 끝에서 데이터를 삽입/삭제할 수 있는 큐)
- collections 모듈에 포함되어 있고,
내부적으로 이중 연결 리스트(doubly linked list) 로 구현되어 있어 양쪽 끝에서 O(1) 시간에 삽입/삭제가 가능
- 파이썬 리스트(list)는 맨 앞쪽에서 요소를 삽입/삭제할 때 O(n)시간이 걸리지만, deque는 O(1) 성능을 보장

deque 모듈에 주요 메서드

삽입/삭제
append(x) : 오른쪽(뒤)에 요소 추가
appendleft(x) : 왼쪽(앞)에 요소 추가
pop() : 오른쪽(뒤) 요소 제거 후 반환
popleft() : 왼쪽(앞) 요소 제거 후 반환

확장
extend(iterable) : iterable을 오른쪽에 확장
extendleft(iterable) : iterable을 왼쪽에 확장 (역순으로 들어감)

회전
rotate(n) : 양수 n이면 오른쪽으로 회전, 음수 n이면 왼쪽으로 회전

제거/삽입
insert(i, x) : 인덱스 i에 요소 삽입
remove(x) : 첫 번째로 등장하는 x 삭제

기타
clear() : 모든 요소 제거
count(x) : x의 개수 세기
reverse() : deque를 제자리에서 뒤집기
maxlen : deque 생성 시 최대 길이 지정 가능 (슬라이딩 윈도우 등에 활용)

deque 활용 (큐, 스택, 연결리스트, 슬라이딩 윈도우)

(1) FIFO 큐

from collections import deque

queue = deque()

queue.append(1)
queue.append(2)
queue.append(3)

print(queue.popleft())  # 1
print(queue.popleft())  # 2
print(queue.popleft())  # 3

(2) 스택 (LIFO 구조)

stack = deque()

stack.append(1)
stack.append(2)
stack.append(3)

print(stack.pop())  # 3
print(stack.pop())  # 2
print(stack.pop())  # 1

(3) 연결리스트

linked = deque([10, 20, 30])

linked.appendleft(5)   # 앞에 추가
linked.append(40)      # 뒤에 추가
linked.insert(2, 15)   # 인덱스 2에 삽입

print(linked)  # deque([5, 10, 15, 20, 30, 40])

linked.remove(20)  
print(linked)  # deque([5, 10, 15, 30, 40])

(4) 슬라이딩 윈도우

maxlen 속성을 활용하면 고정 크기 버퍼나 슬라이딩 윈도우를 쉽게 구현 가능

from collections import deque

window = deque(maxlen=3)  # 최대 길이 3

for i in range(1, 7):
    window.append(i)
    print(list(window))


'''
[1]
[1, 2]
[1, 2, 3]
[2, 3, 4]
[3, 4, 5]
[4, 5, 6]
'''

[Web] Node.js

vysryoo — Tue, 8 Jul 2025 14:52:28 +0900

Node.js는 Chrome의 V8 JavaScript 엔진 위에서 동작하는 서버 사이드 JavaScript 런타임 환경

원래 웹 브라우저에서만 동작하던 JavaScript를 브라우저 바깥,

즉 서버나 로컬 컴퓨터에서도 실행할 수 있도록 해주는 플랫폼

새로운 패키지 생성

npm init

이후, package.json 파일 생성을 위한 여러 질문을 차례대로 입력 (패키지 이름, 버전, 설명 등)

빠르게 생성하려면 (기본값으로 자동 설정)

npm init -y

Node.js 환경에서 자바스크립트 파일 실행 터미널 명령어

node index.js

패키지 스크립트(package script)

package.json 파일의 "scripts" 항목에 정의되어 있으며,

주로 터미널에서 실행할 수 있는 명령어 모음

이렇게 package.json을 설정한 후에

{
  "name": "my-app",
  "version": "1.0.0",
  "scripts": {
    "start": "node app.js",
    "dev": "nodemon app.js",
    "test": "echo \"Error: no test specified\" && exit 1"
  }
}

터미널에서 아래처럼 실행

npm run start     # "node app.js" 실행
npm run dev       # "nodemon app.js" 실행
npm test          # "npm run test"와 같음

// start와 test는 특별한 예약어로, npm start, npm test 처럼 run 생략 가능

자주 쓰는 스크립트 예시

"start"	서버 시작 (node index.js, ts-node, 등)
"dev"	개발 모드 실행 (nodemon, webpack-dev-server 등)
"build"	프로젝트 빌드 (webpack, tsc 등)
"lint"	코드 스타일 검사 (eslint .)
"test"	테스트 실행 (jest, mocha, 등)

모듈

(1) commonJS (CJS)

// test/src/math.js

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

function sub(a, b){
    return a-b;
}

module.exports = {
    add: add,   // add (key와 value 이름 같을 경우) 
    sub: sub    // sub
}

// test/src/index.js
 
const mathModule = require("./math.js");
console.log(mathModule.add(1,2));
console.log(mathModule.sub(4,3));

// const {add, sub} = require("./math.js");
// console.log(add(3,4));
// console.log(sub(5,6));

(2) ECMAScript Module (ESM)

pakage.jason 파일에 설정 필요: "type": "module" 항목 추가

ES 모듈 시스템을 사용하겠다고 설정하면, CJS는 사용할 수 없다

{
  "name": "test",
  "version": "1.0.0",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "start": "node src/index.js"
  },
  "author": "",
  "license": "ISC",
  "description": "",
  "type": "module"
}

import {add, sub} from "./math.js"
// import mul, {add, sub} from "./math.js"

console.log(add(3,4));
console.log(sub(5,6));

// 방법 1

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

function sub(a, b){
    return a-b;
}

export {add, sub};

// 방법2

export function add(a, b){
    return a+b;
}

export function sub(a, b){
    return a-b;
}

export default funcion mult(a, b){
	return a*b;
}
// export 뒤에 default 키워드를 붙이면 모듈을 대표하는 기본값이 된다
// import할때, 중괄호 없이 불러오도록 설정해 주어야 하고, 이름을 바꿔서 불러오는 것도 가능하다

node.js 라이브러리

https://www.npmjs.com/

npm | Home

Bring the best of open source to you, your team, and your company Relied upon by more than 17 million developers worldwide, npm is committed to making JavaScript development elegant, productive, and safe. The free npm Registry has become the center of Java

www.npmjs.com

원하는 모듈의 설치 명령어를 터미널에 입력하면 해당 라이브러리 설치가 진행된다

- package.jason 파일 dependencies 항목에 라이브러리 이름, 버전이 추가됨

- node_modules 폴더 추가됨 (설치한 라이브러리가 실제로 저장되는 공간)

- package-lock.jason에는 좀 더 정확한 버전 정보가 저장됨

node_modules 폴더나, package-lock.jason 파일이 삭제되면 정상적으로 동작하지 않는데,

이때 터미널에 npm install 또는 npm i 명령어를 입력하면

package.jason 파일의 dependencies 부분을 참고하여 자동으로 필요한 라이브러리를 설치해 준다

라이브러리로부터 import 할 때에는 from 뒤에 경로를 명시할 필요 없이,

그냥 "라이브러리 이름"만 명시해 주면 된다

import randomColor from "randomcolor";

[Web] JavaScript 비동기 처리

vysryoo — Tue, 8 Jul 2025 00:15:34 +0900

https://levelup.gitconnected.com/javascript-and-asynchronous-magic-bee537edc2da

Web APIs: 웹 브라우저가 직접 관리하는 별도의 영역

비동기 처리의 핵심 구성 요소

1. 자바스크립트 엔진 (런타임 / Call Stack)

- 자바스크립트 코드를 한 줄씩 실행하는 공간

- 동기 코드는 여기서 처리됨

console.log("A"); // 실행됨 → Stack에서 빠짐

2. Web APIs (브라우저가 제공)

- setTimeout, fetch, DOM 이벤트 리스너 등을 처리

- 이 작업들은 자바스크립트 엔진이 아니라 브라우저가 처리함

setTimeout(() => {
  console.log("비동기 실행");
}, 1000);

- setTimeout 함수는 엔진이 아니라 Web API 영역으로 보내짐

- 1초가 지난 뒤, 콜백은 Callback Queue로 이동

3. Callback Queue (Task Queue)

- Web API 작업이 끝나고, 실행할 준비가 된 콜백 함수들이 대기하는 곳

4. Event Loop (이벤트 루프)

- Call Stack이 비어 있으면 → Callback Queue에서 콜백을 가져와 Stack에 올려서 실행시킴

console.log("A");

setTimeout(() => {
  console.log("B");
}, 1000);

console.log("C");


// console.log("A") → 바로 실행 (Call Stack → 출력)
// setTimeout(...) → Web API에게 넘김 → 1초 기다림
// console.log("C") → 바로 실행
// 1초 후 → 콜백 함수가 Callback Queue로 이동
// Call Stack이 비었으므로, Event Loop가 콜백을 실행함 → "B" 출력

[Multicore] Final

vysryoo — Wed, 11 Jun 2025 21:39:56 +0900

OpenMP is a framework for shared memory parallel computing

Raytracing: graphics rendering technique by tracing the path of light from the view camera
through the 2D viewing plane, out into the 3D scene, and back to the light sources

GPU provides much higher insturction throughput and memory bandwidth than CPU
GPU is designed for highly parallel computations and
therefore designed such that more transistors are devoted to data processing
rather than data control and flow caching

CPU: Optimized for sequential code execution
- sophisticated control logic
- large cache memory
- powerful ALU
GPU: Optimized for execution of multiple threads
- minimize control logic and cache memory
- energy efficient ALU
- cores are grouped

host code: the part of code which will be run on the CPU
device code: the part of code which will be run on the GPU

guided is a type of OpenMP schedule
that is similar to the dynamic schedule, but the chunk size decreases as the program runs

NVCC is a proprietary compiler by Nvidia intended for use with CUDA

Thrust is a C++ template library for CUDA based on STL: high-level interface

omp_get_thread_num()
omp_set_num_threads()

meaning of #pragma omp sections:
Each section runs by only one thread in parallel

similarity between private and firstprivte:
Each thread gets a copy of shared variable

difference between private and firstprivate:
private: uninitialized per-thread copy of shared variable
firstprivate: initialized per-thread copy of shared variable

CUDA로 stencil 구현 시, <<N+THREAD_NUM-1/THREAD_NUM, THREAD_NUM>> 사용하는 이유:
The vector size is an arbitrary number,
so we cannot ensure that N/THREAD_NUM blocks can cover all elements
Thus I used N+THREAD_NUM-1 to round up and ensure full coverage

Parallel algorithms
Tp = running time on p processors
T1 (work) = running time on 1 processorss
Tinf (span) = longest time to execute algorithm on inf # of processors

Lower bounds
Tp >= T1 / P
Tp >= Tinf

Speed up
T1 / Tp

Parallelism (max speed up)
T1 / Tinf

[Parallel Merge Sort]

Problem
Parallelism is T1 / Tinf is Theta(logn) and that is too small so Merge step needs to
be parallelized

spwan 부분은 두 스레드가 동시에 진행하는 것이기 때문에 2를 곱할 필요 없이
더 오래걸리는 하나의 함수 기준으로 시간 복잡도 측정하면 된다

Par-Merge
O(3n/4) <- largest possible size of function
T(n) = O(logn) + T(3n/4) => theta(log^2(n))

Par-Merge-Sort
T(n) = T(n/2) + theta(log^2(n)) => theta(log^3(n))

Parallelism = T1 / Tinf
이때 T1은 일반적인 merge sort O(nlgn)
Tinf는 theta(log^3(n))
따라서 Parallelism은 theta (n/log^2(n))

[Parallel Quick Sort]

In CUDA, warp is a group of 32 threads where multiprocessors execute the same instructions at each clock cycle.

__global__ runs on device, callable from host code, should have void return type
__host__ runs on host, callable from host
__device__ runs on device, callable fron device

Local, Global: Off-chip memory
Shared, Register: On-chip memory
In fact, shared memory latency is roughly 100x lower than uncached global memory latency

Any call to a __global__ function must specify execution configuration for that call

In GPU, a stream multiprocessor (SM) is basically SIMT processor that executes a warp simultaneously

(1) Static scheduling:
#pragma omp parallel for schedule(static, n)
→ Chunks of size n are assigned to threads in round-robin fashion before execution,
resulting in low overhead but potential load imbalance.

(2) Dynamic scheduling:
#pragma omp parallel for schedule(dynamic, n)
→ Chunks of size n are assigned to threads at runtime as they become available,
resulting in good load balance but high overhead.

double start_time = omp_get_wtime();
// parallel section
double end_time = omp_get_wtime();
printf("execution time = %.10lf second", end_time - start_time);

In OpenMp, values of private variables are undefined on entry and exit of parallel region

Characteristics of __global__ functions:
1) Must specify execution configuration
2) Exected on device
3) Callable from host code
4) Must return void

cudaMemcpy() parameters:
destination pointer, source pointer, size in byte, type of transfer

Prefix sum: si = x1⊕x2⊕⋯⊕xi. for 1 ≤ i ≤ n

__syncthreads():
__syncthreads() acts as a barrier,
ensuring that all threads have reached the same point in execution
before any can proceed.

Main advantages of PSRS (Parallel Sorting by Regular Sampling)
over parallel quicksort and hyper-quicksort algorithms are:

Better load balancing
Repeated communications of a same value are avoided
The number of processes does not have to be a power of two, which is required by the other two algorithms.

OpenMP에서 #pragma omp parallel for는 순서를 반드시 지켜야 하지만, 그 뒤에 오는 reduction, private, shared 같은 clause들은 순서를 자유롭게 바꿔도 된다.

PSRS algorithm
In phase 1, each process uses the sequential quicksort algorithm to sort its share of elements, Each process selects regular sample of sorted list
In phase 2, all samples are gathered, sorted and p-1 global pivots are selected and broadcasted
In phase 3, each process partitions its list into p pieces using pivot values and sends partitions to other processes
In phase 4, each process merges its partitions into a single sorted partition

[OS] Memory #2

vysryoo — Wed, 11 Jun 2025 20:11:27 +0900

1. Fetch Policy

Demand Paging
페이지에 접근이 있을 때만 메모리에 적재하는 방식
처음엔 페이지 폴트가 많지만 지역성 원리에 따라 점차 줄어든다.

Prepaging: 필요한 페이지 외에 근처 페이지도 미리 적재하는 방식
적재된 페이지가 사용되지 않으면 비효율적

2. Placement Policy
세그먼테이션에서는 중요하지만(처음 어떻게 배치되느냐에 따라 컴팩션 달라질 수..)
페이징에서는 별로 중요하지 않다

3. Replacement Policy

Frame Locking: 교체를 방지하기 위해 프레임에 잠금을 설정하여 메모리에 유지되도록 하는 것

Optimal: 가장 나중에 참조될 페이지를 교체 대상으로 선정 (미래를 다 알아야 하기 때문에 현실적으로 불가능)
LRU(Least Recently Used): 가장 오래 전에 참조한 페이지를 교체 대상으로 선정
FIFO: 가장 오래 전에 들어온 페이지를 교체 대상으로 선정 (오래 전에 들어왔어도 사용 될 수 있다)
Clock: 처음 들어오거나 참조되면 use-bit 1이 되고, 원형 큐에서 0인 페이지를 찾아서 교체 대상으로 선정

(일단 프레임에 있는 페이지가 들어오면 그대로 진행)
(프레임에 없는 페이지가 들어오면)
(OPT는 뒤로 가면서 나오는 페이지 빼다가 가장 마지막에 빠지는 애 교체)
(LRU는 앞으로 가면서 나오는 페이지 빼다가 가장 마지막에 빠지는 애 교체)
(FIFO는 교체된 칸 기억해 뒀다가, 교체해야 하면 다음 칸 교체: 점 이동은 폴트 날 때에만)
(CLOCK는 새로 추가/이미 있는 프레임이면 * 넣고, 없으면 *떼면서 다음 칸으로: 점 이동 & 떼는 것은 폴트 날 때에만)

(FIFO랑 CLOCK에서 .은 반드시 순차적으로 진행)

Page Buffering (=Page Cache): 교체된 페이지를 메모리에 잠시 유지해 재참조 시 비용을 줄이는 기법

Free Frame List에 있는 프레임 최대한 먼저 쓰고
Modified Page List에 있는 애들의 프레임을 쓰려면 디스크로 가서 수정해 주고 와서 써야하기
때문에 시간이 걸린다
Modified Page List에 있는 애들 모아뒀다가 한 번에 팍 적고 FFL로 옮겨 주는 cluster하면 효율적으로 운용 가능

Fixed-allocation: 프로세스에 고정된 수의 프레임을 할당, 폴트 시 해당 프로세스 내에서 페이지를 교체
Variable-allocation: 페이지 폴트율에 따라 할당된 프레임 수를 동적으로 조절, 효율적이나 오버헤드가 발생

Local replacement policy: 폴트 시 프로세스의 페이지만 교체 후보로 고려
Global replacement policy: 폴트 시 언락인 모든 페이지를 교체 후보로 고려

fixed implies local
variable can be either local global
variable + local: 폴트율에 따라 동적으로 조절되되, 프로세스의 페이지만 가능
variable + global: 폴트율에 따라 동적으로 조절되되, 메모리의 모든 프레임 선택 가능 (레지던트 셋 크기 변경)

레지던트 셋 할당이 너무 적으면: 페이지 폴트 증가로 시스템이 느려짐
레지던트 셋 할당이 너무 많으면: 메모리 내 프로세스 수가 줄어 CPU Utilization이 떨어짐

Variable+gloabal
페이지 폴트 발생 시,
FFL에 free frame이 있으면 레지던트 셋에 추가하고,
FFL이 비어있으면, 다른 프로세스의 레지던트 셋에서 하나 뺏어서 자신의 레지던트 셋에 넣는다
=> 이런 식으로 작동하면 비효율 초래 가능
==> 해결: Page Buffering

4. Cleaning Policy
modified page는 반드시 디스크에 기록되어야 하는데.

Demand Cleaning
modified page를 페이지 교체 시 디스크에 기록하는 방법
페이지 폴트 시 두 번의 디스크 접근으로 CPU 활용도가 낮아질 수 있다.

Precleaning
modified page를 미리 미리 디스크에 기록해두고, 실제 교체 시 지연을 줄이는 방법
한 번 수정된 페이지들은 다시 수정될 가능성 높기 때문에 디스크 기록이 더 많이 필요할 수 있다

5. Load Contorol

메모리 내의
너무 적은 프로세스 수는 스와핑이 늘어난다
너무 많은 프로세수 수는 스레싱이 늘어난다

L = 페이지 폴트 간 시간
S = 페이지 폴트로 처리 시간

L > S: 폴트 발생 x, 너무 안정됨 => CPU 활용률이 너무 낮다
L < S: 처리하기도 전에 또 다른 폴트 발생 => 스레싱
L = S일 때 최적이다

Clock이 너무 천천히 돈다: CPU 활용률이 너무 낮다
Clock이 너무 빨리 돈다: 페이지 폴트가 너무 많이 발생, 스레싱 (멀티프로그래밍 레벨을 줄여야 한다)

멀티프로그래밍 레벨을 줄이기 위한 Process suspension 기준
우선순위가 가장 낮은 프로세스,
페이지 폴트를 일으킨 프로세스,
마지막으로 활성화된 프로세스(최근에 들어왔으니까 레지던트 셋 작을 것이므로),
레지던트 집합이 가장 작은 프로세스,
가장 큰 프로세스(한 방에 큰 공간 확보할 수 있으므로),
남은 실행 시간이 가장 긴 프로세스(짧게 남은 애들 빨리 빨리 처리하기 위해서).

I/O Buffering -> I/O 성능을 높일 수 있다

블록 지향 장치(Block-oriented device)
고정 크기 블록 단위로 데이터 전송 (예: 디스크, USB)

스트림 지향 장치(Stream-oriented device)
바이트 스트림 형태로 데이터 전송하며 (예: 터미널, 프린터, 포트, 마우스)

Disk Scheduling

PRI: 우선순위대로 처리
FIFO: 요구순서대로 처리
SSTF(Shortest Service Time First): 근처에 있는 요청 먼저 처리(멀리 있는 요청 기아 가능)
SCAN: 한번 주욱 갔다가 주욱 오면서 요청 처리 (최대 2*h 대기)
LOOK: SCAN과 유사하지만 끝까지 가지 않고, 더 이상 요청이 없을 때 방향을 바꿔 불필요한 이동을 줄인다.
C-SCAN: 한 방향으로만 스캔 (최대 h+c 대기)
N-step-SCAN: 큐를 길이 N의 하위 큐로 나누고 각 큐를 SCAN으로 처리
(N이 너무 작으면 C-SCAN이랑 동일, N이 너무 크면 FIFO랑 동일)
arm stickiness problem: 디스크 암이 특정 구간에 머물러 다른 요청이 오래 대기하는 현상
FSCAN: 두 개의 하위 큐를 사용해,
한 큐에만 요청을 모으고 다른 큐는 주욱 실행하고,
다른 큐의 실행이 끝나면 해당 큐에서 요청을 모으고 다른 큐에서 요청을 주욱 실행하는 방법

RAID
여러 독립 디스크를 하나의 논리 드라이브로 구성해
데이터를 스트라이핑하고, 패리티를 통해 고장 시 데이터 복구를 보장하는 것

RAID 0: 중복성 없이 데이터를 디스크에 스트라이핑해 성능을 높이나 데이터 보호 기능은 없다.

RAID 1: 모든 데이터를 미러링해 고장 시 데이터 접근이 가능하며, 쓰기 병목이 없으나 비용이 높다

(RAID 2: 해밍 코드를 사용해 단일 비트 오류를 수정)

RAID 3: 비트 단위 스트라이핑과 단일 패리티 디스크를 사용

RAID 4: 블록 단위 스트라이핑과 단일 패리티 디스크를 사용, 쓰기 병목이 발생할 수 있다.

RAID 5: 블록 단위 스트라이핑과 하나의 분산 패리티를 사용해

쓰기 병목을 해결하고, 하나의 디스크 손실 시 복구가 가능하다.

RAID 6: 블록 단위 스트라이핑과 두 개의 분산 패리티를 사용해

디스크 2개가 동시에 고장 나도 복구 가능, 쓰기 시 패리티 두 개를 갱신하여야하므로 성능이 RAID 5보다 저하된다

디스크 하나 고장 시
RAID 0+1은 스트라이프 전체가 무효화되지만
RAID 1+0은 고장 난 디스크의 미러를 사용해 계속 작동 가능하기 때문에
RAID 1+0이 RAID 0+1 보다 더 우수하다

[SE] 소프트웨어 테스팅

vysryoo — Sat, 7 Jun 2025 14:50:06 +0900

소프트웨어 테스트의 목적

• 잠재적 오류와 결함의 발견

• 요구사항의 준수 여부(기능/비기능) 확인

• 소프트웨어 신뢰성 등 품질 확인

오류를 발견하기 위한 활동으로, 테스팅이 오류가 없음을 확인시켜 주지는 않음

테스팅의 원칙

- 개발자가 자신의 프로그램을 직접 테스팅하지 않음

- 테스팅의 목적은 결함이 존재함을 밝히는 것

- 완벽한 테스팅은 불가능

- 개발 초기에 테스팅 시작

살충제 패러독스

동일한 테스트를 반복하면 새로운 결함을 찾기 어려워, 테스트 케이스를 주기적으로 개선해야 한다.

테스트에 대한 시각

검증: 개발 단계의 산출물이 설정된 조건을 만족하는 지 평가 (소프트웨어 프로세스가 잘 진행되는 지 평가)

확인: 요구사항들을 만족하는 지 평가

테스트의 목적

회복 테스트: 고의적 실패 유도

보안 테스트: 불법적인 침해

스트레스 테스트: 과부하 테스트

성능 테스트: 응답시간, 처리량, 속도

회귀 테스트: 변경이 새로운 오류를 발생시키지 않음을 확인

V-모델: 개발 단계와 테스트 단계를 대응시켜 검증과 추적성을 강조하는 모델

단위 테스팅: 개발자가 각 모듈 완성 후 독립된 환경에서 모듈 단위로 기능을 검증하는 테스트

- 화이트박스 / 블랙박스 테스팅 모두 가능

- 스텁: 테스팅 대상 모듈이 호출하는 모듈

- 드라이버: 테스팅 대상 모듈을 호출하는 환경

통합 테스팅: 모듈을 통합하는 과정에서 모듈 간 상호작용을 검사하는 테스팅

빅뱅 기법: 모듈을 한꺼번에 통합해 테스트하나, 오류 위치 파악이 어렵다.

하향식 기법: 상위 모듈부터 순차적 통합, 하위 모듈은 스텁 사용한다.

상향식 기법: 하위 모듈부터 순차적 통합, 상위 모듈은 테스트 드라이버가 필요하다.

시스템 테스팅: 통합 완료된 시스템이 사용자 기능 및 비기능 요구사항을 충족하는지 검증하는 개발 조직 주체의 최종 테스트

인수 테스팅: 시스템이 사용자에게 인도되기 전, 사용자에 의해 실시되는 테스팅

알파 테스팅: 개발자 환경에서 사용자가 실시 (완료 시, 알파 버전)

베타 테스팅: 실제 사용자 환경에서 사용자가 실시 (완료 시, 베타 버전)

인수 테스팅을 통과해야지만, 시스템이 사용자에게 인도되고 프로젝트는 종료됨

Selenium

다양한 브라우저와 언어를 지원한다

사용자처럼 동작을 재현해 정확한 테스트가 가능

코드 수정 시 자동으로 테스트하고 배포까지 연결되어 효율적 사용이 가능하다

블랙박스 테스팅 (Black-Box Testing)

소스 코드 자체의 로직에는 관심이 없고 입출력 값에만 관심이 있음

- 사용자 관점의 테스트 가능

- 코드 지식이 불필요하기 때문에 비기술적 테스트도 참여 가능

- 입출력 관계를 중심으로 테스트하기 때문에,인터페이스 검증에 적합하다

구문 테스팅 (Syntax Testing)

입력 값을 적합(Valid)과 부적합(Invalid)으로 분류한 뒤 예상되는 결과를 검증하는 방법

동등 분할 (Equivalence Partitioning)

입력값 각 범위의 대표값을 이용하여 테스팅

경계 값 분석 (Boundary Value Analysis)

입력 값의 주요 오류 대상인 경계 값을 입력 값으로 하는 테스트 케이스로 테스팅

(같은 구간 포함 시 중복을 제거한다)

(가령, 1~50, 50~100이 범위 일때, 50은 중복이므로 한 번만 사용한다는 것)

의사결정 테이블 (Decision Table)

입/출력 값이 True, False로 결정될 수 있는 경우, 테이블로 모든 경우의 수를 확인해보는 방법

- 입력. 출력 값이 Yes, No로 결정될 수 있는 경우

- 적은 수의 조건을 가진 입력 값에 유용

화이트박스 테스팅 (White-Box Testing)

소스 코드를 직접 참조하면서 수행하는 테스팅

(커버리지: 테스트 케이스가 얼마나 많은 상황들을 커버할 수 있는 지 나타내는 척도)

(소프트웨어 목적성에 맞는 구조를 잘 정리한 후 테스트)

- 철저한 검증이 가능하다

- 로직의 논리적 결함을 찾기에 유리하다

- 테스트를 진행하면서 비효율 부분을 개선할 가능성이 있다

문장 커버리지 (Statement Coverage)

프로그램을 구성하는 문장들이 최소 한번은 실행될 수 있는 입력 값을 테스트 케이스로 선정

분기 커버리지 (Branch Coverage)

프로그램에 있는 분기를 최소한 한번은 실행하게 하는 테스팅 방법

(yes / no를 한 번씩은 거쳐야 한다)

조건 커버리지 (Condition Coverage)

&&, || 등의 조건을 가진 분기문이

전체 조건식의 결과와 관계없이,

&& 나 || 전후의 각 개별 조건식이 참 한 번, 거짓 한 번을 갖도록 테스트 케이스를 만드는 방법

(개별 조건 컴럼 당 참, 거짓 하나씩만 있으면 됨, 가령 TF. FT만 해도 각 개별 조건이 한 번씩은 가지게 된 것)

다중 조건 커버리지 (Multiple Condition Coverage)

다중 조건 커버리지는 전체 조건식의 모든 경우의 조건을 검사하는 테스트 케이스를 만드는 방법

(모든 개별 조건의 조합을 다 테스트 해야한다)

기본 경로 테스팅 (Basic Path Testing)

1. 테스팅 대상의 플로우 그래프를 그린다

2. 순환복잡도(Cyclomatic Complexity)를 계산한다.

▪ 프로그램 내부구조를 시험 할 수 있는 독립적인 경로의 수를 계산

▪ 프로그램의 논리적인 복잡도를 나타냄

• CC = R의 수

• CC = E - N + 2

• CC = P + 1

✓ CC(Cyclomatic Complexity): 순환복잡도

✓ R(Region): 노드로 둘러싸인 영역과 그래프 밖 영역의 수

✓ E(Edge): 화살표의 수

✓ N(Node): 노드의 수

✓ P(Predicate): 분기 노드의 수

3. 독립적인 경로들을 정의한다.

▪ 순환복잡도를 통해 계산된 횟수를 기반으로 독립적인 경로들을 정의

▪ 단계 1: 조건 노드를 최대한 많이 거쳐 가도록 하는 기본 경로를 하나 선택

▪ 단계 2: 기본 경로의 첫번째 분기를 바꾸어 새로운 기본 경로를 생성

▪ 단계 3: 단계 2에서 생성된 기본 경로의 노드 중 다음 결정 구조의 분기를 기본 경로와 다르게하여 생성

▪ 단계 4: 기본경로로부터 첫번째 결정구조에 관하여 더 이상 새로운 경로가 없으면

두번째 결정구조에 관하여 같은 방법으로 기본 경로를 구함

▪ 단계 5: 더 이상 기본 경로 중 결정구조가 없으면 기본 경로 생성을 중지

4. 정의된 각 경로의 테스트 케이스를 작성한다

예) 국어, 영어, 수학 점수를 입력받아 평균 점수가 70점 이상이면 PASS를 미만이면 FAIL을 출력한다

✓경로 1: 1 - 2 - 3 - 2 - 4 - 5 - 6 - 8

✓경로 2: 1 - 2 - 3 - 2 - 4 - 5 - 7 - 8

✓경로 3: 1 - 2 - 4 - 5 - 6 - 8

예)

• 휴대폰 배터리 표시 기능 예

• 2.5 V 이상 2.8 V 미만: 배터리 0칸

• 2.8 V 이상 3.3 V 미만: 배터리 1칸

• 3.3 V 이상 3.8 V 미만: 배터리 2칸

동등 분할, 경계 값 분석로 테스트 케이스를 작성하시오

• 모바일 은행 어플리케이션

• 사용자는 은행으로부터 발급받은 공인인증서 칩을 넣은 상태에서 해당은행에서 제공한 소프트웨

어를 이용하여 은행업무를 볼 수 있다.

• 폰에 칩이 없을 경우 칩이 필요하다는 경고를 보여준다.

• 칩이 있을 경우, 칩이 유효한지 검사한다. 칩이 유효하지 않다면 유효하지 않다는 경고를 보여준다.

• 칩이 유효한 경우, 해당 칩을 발행한 은행에서 제공한 소프트웨어가 폰에 다운로드 되었는지 검사

하는데, 소프트웨어가 없다면 다운로드를 시도한다. 이 때 폰에 다른 은행의 소프트웨어가 이미 저

장되어 있다면 둘 중 하나를 지울 것을 사용자에게 요청한다.

• 해당 은행 소프트웨어 다운로드가 확인되면 은행 업무 메뉴를 보여준다.

의사 결정 테이블 테스트 케이스를 작성하시오

[SE] 소프트웨어 관리

vysryoo — Sat, 7 Jun 2025 14:11:05 +0900

1. 위험 관리

위험 관리 절차

1. 위험 식별
(일반적인 프로젝트 위험 리스트 + 이전 유사 프로젝트 위험 리스트)
=> 브레인 스토밍, 조사, 인터뷰
=> (현재 프로젝트 위험 리스트: 분야, 위험 요소, 원인)

2. 위험 계량화
식별된 위험 요소들은 발생 확률과 영향도에 따라 구분 (상, 중, 하)

3. 위험 우선순위 선정
우선순위를 설정하여 대응책을 만들고 위험을 관리

4. 위험 관리 계획
위험 관리 계획에는 위험을 언제, 어떠한 방법으로 관리할 것인가에 대한 내용 등이 포함

5. 위험 해결
위험은 어느 시점에나 문제로 발생할 수 있으므로,
위험 관리는 프로젝트 초반부터 프로젝트 종료 시까지 수행해야하고
주기 별로 식별된 위험 요소에 대한 평가가 수행되어야 함

6. 결과 측정 및 문서화
대응 방안에 대한 수행 결과가 어느 정도 효과가 있었는지 평가하고, 그 결과를 기록해야 함
위험 관리 결과는 조직의 위험 요소 리스트에 다시 반영시켜야 함

2. 형상 관리
형상 항목을 식별하고 그 변경을 제어·추적하여 제품의 무결성과 변경에 대한 추적성을 유지하는 관리 활동

형상 관리의 필요성
: 소프트웨어의 비가시성, 변경 추적 어려움, 관리 통제 어려움, 요구사항의 잦은 변경 때문에 발생할 수 있는
위험을 최소화하기 위해서 필요하다

형상 담당자(Configuration Manager), 형상 통제 위원회(CCB)

1. 형상 식별
형상 항목 선정, 형상 식별자 선정, 베이스라인 기준 선정

형상 식별자: 형상 항목에 유일한 이름과 번호를 정하고 버전을 부여하는 체계
(일정한 규칙이 있다, 버전 관리의 핵심)

베이스라인
형상 항목이 소프트웨어 개발에 하나의 완전한 산출물로써 쓰여질 수 있는 상태(버전 1.0으로 표기)
추후 개발의 기초가 되며, 오직 공식 통제 절차(CCB의 평가와 승인)에 의해서만 변경될 수 있다
형상 관리 계획서 작성 시 수립

2. 형상 제어

변경 요청, 변경 심사 후
변경을 실시하기 위해 형상 저장소에서 해당 항목을 체크아웃
변경이 확인되면 변경한 베이스라인은 형상 저장소에 체크인되고, 변경 항목은 다시 베이스라인으로 수립됨

3. 형상 상태 보고
변경 상태를 기록하여, 형상 항목의 개발 상태에 대한 가시성을 제공(변경 사항 로그로 남긴다)

4. 형상 감사
베이스라인의 무결성을 검증하는 것을 목적으로 한다

형상 관리 도구
CVS: 중앙 저장소 기반의 초기 버전 관리 시스템, 파일별 이력 관리와 덮어쓰기 방지 기능을 제공
SVN: CVS의 단점을 개선한 중앙 집중식 시스템으로, 변경 사항만 저장하며 복구가 용이함
Git: 로컬에서도 작업 가능한 분산 버전 관리 시스템으로, 성능과 협업 효율이 뛰어나다

[SE] 소프트웨어 구조 설계

vysryoo — Sat, 7 Jun 2025 02:27:59 +0900

소프트웨어 설계

요구사항 명세서를 토대로 소프트웨어의 뼈대를 이루는 구조를 정의해 구현의 기반을 만드는 것

요구사항 명세서는 What 관점, 설계는 How 관점

상위 설계 (=아키텍쳐 설계)

- 구성 모듈들의 관계로 표현되는 시스템 전체 구조

- 시스템 구조도, 외부 피일 및 DB 설계(ERD), 인터페이스 설계

하위 설계 (=모듈 설계)

- 모듈의 내부 구조, 동적 행위등을 결정

- 모듈 설계, 알고리즘 설계등 포함

좋은 설계: 모듈이 독립적이어야 하고, 모듈 간의 결합이 낮게 설계되어야함

프로세스 지항 설계: 처리 절차를 중심으로 설계 (기능, 데이터 분리)

객체 지향 설계: 객체 요소를 중심으로 설계 (기능, 데이터 객체 단위로 뭉쳐짐)

설계 원리

(1) 추상화

필요 정보만 추출하여 강조하고, 관련 없는 사항은 생략하여 본질적인 문제에 집중

상위 단계에서 설계를 고려하고 하위 단계로 구체화

과정 추상화: 입력이 출력으로 변환되는 과정을 추상화

데이터 추상화: 데이터 구조를 대표할 수 있는 표현으로 대체하는 것

제어 추상화: 제어 로직을 대표할 수 있는 표현으로 컴팩트하게 표현

(2) 단계적 분해

상위 개념부터 더 구체적 단계로 분할하는 하향식 기법의 원리

(3) 모듈화

모듈(=component)의 특성

- 독립적으로 컴파일 및 수행

- 다른 모듈 사용 가능

- 다른 프로그램에서 사용 가능

모듈 내의 응집력은 높게, 모듈 간의 결합력은 약하게하는 정도의 크기

- explicit invocation(function call): 모듈 간 결합력 높음

- Implicit invocation(메세지 던져 놓으면 해당하는 애가 수행): 모듈간 결합력 낮음, scailability 높음

효과적인 설계: 정보 은닉

효과적인 설계: 강한 모듈의 응집력

(= 모듈을 이루는 요소들이 서로 관련되어 있는 정도)

효과적인 설계: 약한 모듈의 결합도

설계 시 주의사항

- 넓게 퍼지고, 깊이는 낮을 수록 좋다

- 복잡한 모듈 간 연결 지양

- 과도한 깊이나 넓이를 가진 구조 지양

- 모듈의 영향권을 해당 모듈의 하위에 위치시킨다

변환 분석은 DFD를 입력 흐름 → 변환 센터 → 출력 흐름으로 분할

• 입력 흐름: 입력을 준비하는 단계(입력, 검증...)

• 출력 흐름: 출력을 준비하는 단계(포매팅, 출력)

• 변환 센터: 실제 자료가 변환

①~② 자료 흐름의 요소를 분해: 입력 자료 흐름, 출력 자료 흐름, 변환 센터

③ 변환 중심부를 축으로 최상위 구조 작성

④ 각 모듈의 하위 구조도 같은 방법으로 분석

⑤ 설계 기준을 적용하여 수정, 최적화

객체 = 속성(Attribute)과 행위(Behavior)를 가지고 있는 개체(Entity)

클래스 이름은 반드시 적어야한다

+가 붙으면 public, -가 붙으면 private

#가 붙으면 protected, ~가 붙으면 default,

readonly가 붙으면 final, 밑줄이 쳐지면 static

아키텍쳐 유형 => 개발 기간 단축하고 의사소통을 수월하게 할 수 있다

계층식 (Layered)
정의: 시스템을 계층화하여, 상위 계층이 하위 계층의 기능에 의존하는 구조이다.

인터페이스 계층 / 응용&도메인 계층 / 인프라스트럭쳐 계층
장점: 유지보수가 용이하며 확장성이 높다

클라이언트-서버 (Client-server)
정의: 클라이언트가 요청하고 서버가 응답하는 분산 구조이다.
장점: 자원을 중앙 집중화하여 관리 효율성과 보안성을 높일 수 있다.

마스터-슬레이브 (Master-slave)
정의: 마스터가 제어하고 슬레이브가 작업을 수행하는 구조이다.
장점: 병렬 처리와 작업 일관성 유지에 유리하다.

파이프-필터 (Pipe-filter)
정의: 데이터를 필터들이 파이프를 통해 순차적으로 처리하는 구조이다. 데이터 스트림 처리 시스템에서 자주 사용된다.
장점: 재사용성과 확장성이 뛰어나고 처리 흐름이 명확하다.

브로커 (Broker)
정의: 컴포넌트 간 통신을 중개자가 관리하는 구조이다. 서버의 대행자 역할을 하며 메인 서버의 부하를 분산할 수 있다
장점: 결합도가 낮아 유연한 확장과 유지보수가 가능하다.

피어 투 피어 (Peer to peer)
정의: 모든 노드가 동등하게 요청과 서비스를 수행하며, 중앙 서버 없이 서로 직접 연결되는 구조이다.
장점: 확장성과 신뢰성이 높고 중앙 장애점이 없다.

이벤트 기반 (Event driven)
정의: 이벤트를 기반으로 컴포넌트들이 비동기적으로 동작하는 구조이다.
장점: 반응성이 뛰어나고 비동기 처리가 효과적이다.

모델-뷰-컨트롤러 (MVC)
정의: 모델, 뷰, 컨트롤러로 역할을 분리한 아키텍쳐 유형이다

- 모델 (Model): 애플리케이션의 핵심 데이터 보관과 비즈니스 로직을 담당

- 뷰 (View): 사용자에게 보여지는 화면을 구성

- 컨트롤러 (Controller): 사용자 입력을 처리하고, 모델과 뷰 사이를 연결한다.

- 역할 별로 관심사를 분리하여 협업에 유리하며 충돌 없이 효율적으로 개발할 수 있다

- 기능 수정 시 해당 역할만 수정하면 되어서 유지보수와 확장성이 높다

- 모델, 뷰, 컨트롤러는 서로 독립적이기 때문에, 테스트를 뷰를 제외하고 모델과 컨트롤러에 집중해서 진행할 수 있다

- 다수의 웹 프레임워크가 MVC 아키텍쳐를 지원하기 때문에 편리하게 구현할 수 있다

블랙보드 (Blackboard)
정의: 여러 컴포넌트가 공유된 데이터 공간을 통해 협력하는 구조이다. 데이터를 한 곳에 저장하고 모든 컴포넌트가 이를 참조하는 방식이다.
장점: 다양한 지식 기반 시스템이 협력해 복잡한 문제를 해결할 수 있다.

인터프리터 (Interpreter)
정의: 코드를 한 줄씩 해석하며 즉시 실행하는 구조이다.
장점: 실시간 실행과 디버깅에 유리하다.

모놀리식 (Monolithic)
정의: 모든 기능이 하나의 일체형 애플리케이션에 포함된 구조이다.
장점: 개발과 배포가 단순하고 초기 구축이 빠르다.

마이크로서비스 (Microservice)
정의: 기능을 독립적인 작은 서비스로 나눈 분산 아키텍처이다. 각 서비스를 끼웠다 뺐다 하듯이 독립적으로 개발하고 배포할 수 있다.
장점: 독립 배포와 스케일링이 가능하며 기술 선택이 유연하다.

[OS] Memory

vysryoo — Wed, 4 Jun 2025 13:20:37 +0900

Frame
메인 메모리에서 사용되는 고정 길이의 블록

Page
고정 길이의 메모리 블록으로
페이지를 일시적으로 메인 메모리의 프레임에 올릴 수 있다

Segment
가변 길이의 메모리 단위
전체 세그먼트를 메인 메모리에 일시적으로 올릴 수 있고(세그멘테이션),
페이지 단위로 나눈 세그먼트의 페이지를 개별적으로 메인 메모리에 올릴 수도 있다 (세그멘테이션과 페이징의 결합)

메모리 관리 요구사항

재배치(Relocation)
보호(Protection)
공유(Sharing)
논리적 구성(Logical organization)
물리적 구성(Physical organization)

재배치(Relocation)
프로세스들이 스왑 아웃되었다가 스왑 인될때, 메모리의 동일한 영역로 돌아오는 것은 시스템 상 제한을 초래하므로,
다른 영역으로 재배치하는 기능이 필요하다

보호(Protection)
Memory Protection은 OS가 아니라 하드웨어에 의해 충족
OS가 일일이 메모리 참조 위반이 없는지 매번 확인하는 것은 지나치게 많은 시간을 소모하게 되기 때문이다

Hardware Address Protection
합법적인 주소 범위를 판단할 수 있는 기능
Base register: 가장 작은 합법적인 물리적 메모리 주소를 저장
Limit or Bounds register: 주소 범위의 크기를 저장
베이스 레지스터에 300040이 저장되어 있고 리밋 레지스터에 120900이 저장되어 있다면,
300040부터 420939까지의 모든 주소에 합법적으로 접근 가능
(Base ~ Base+Limit)인 주소에는 합법적으로 접근할 수 있다
CPU는 사용자 모드에서 발생하는 모든 메모리 접근이 해당 사용자의 베이스와 리밋 사이에 있는지 반드시 검사해야 한다.

공유(Sharing)
여러 프로세스가 동일한 프로그램을 실행할 경우, 별도의 복사본을 가지기보다 동일한 복사본에 접근할 수 있도록 하는 것

논리적 구성(Logical Organization)
메인 메모리는 linear address로 구성.
프로그램은 nonlinear하며, 모듈 단위로 작성
모듈은 독립적으로 작성 및 컴파일. 모듈별로 보호도 다르게. 모듈은 여러 프로세스 간에 공유 가능
세그멘테이션은 이러한 요구사항에 적합

물리적 구성(Physical Organization)
프로그래머가 메모리 관리를 맡는 것은 바람직하지 않다.
- 구현 프로그램이 가용 데이터보다 클 수 있다
Overlay를 사용해 필요할 때마다 모듈들이 특정 메모리 영역에 교체, 로딩, 실행
- 프로그래머가 가용 공간의 크기나 위치를 알 수 없다
Overlay: 작은 메모리에서 큰 프로그램을 실행하기 위해 필요한 부분만 교체하며 사용하는 기법

메모리는 프로세서 실행을 위해 프로세스를 메인 메모리로 불러온다
- 가상 메모리 (세그멘테이션, 페이징 or 둘 다)
- 메모리 파티셔닝(더 단순한 방법, Simple Paging, Simple Segmentation..)

고정 분할(Fixed Partitioning)
시스템 생성 시점에 메모리를 정해진 크기와 개수의 분할로 나눈다

단점1: 내부 단편화의 발생
단점2: 활성 프로세스 수가 분할 개수만큼으로 제한된다

내부 단편화(Internal fragmentation)
고정 크기로 메모리 블록을 할당할 때, 실제 필요 공간보다 더 큰 블록이 할당되어 낭비되는 공간들

Equal-size Fixed Partitions
구현이 간단하고 오버헤드가 적다
프로그램이 분할 크기보다 크면 오버레이(overlay)를 사용하도록 설계되어야 함

Unequal-size Fixed Partitions
가용 공간에서 내부 단편화를 최소화하도록 프로세스를 할당 가능한 분할 중 가장 작은 분할에 할당한다

(1) 분할별로 스케줄링 큐 사용: 큰 분할들은 잘 사용되지 않을 수 있으므로, 시스템 전체 관점에서는 최적이 아니다
(2) 싱글 큐를 사용: 모든 분할이 사용 중이면 스와핑을 하여야 한다

가변 분할(Dynamic Partitioning)

프로세스가 필요한 만큼의 메모리를 정확히 할당받음
내부 단편화가 없다, 외부 단편화를 제거하기 위해 컴팩션이 필요하다

단점: 외부 단편화로 컴팩션 오버헤드가 발생한다

외부 단편화 (External Fragmentation)
동적으로 메모리의 할당과 해제를 반복하면서, 사이 사이에 조각나서 낭비되는 작은 공간들

압축 (Compaction)
외부 단편화를 해소하기 위해 OS가 메모리 내 프로세스를 연속되게 재배치하여 빈 공간을 하나로 모으는 기법

First-fit
메모리의 처음부터 스캔하여 할당 가능한 첫 번째 빈 공간에 할당하는 방식
간단하고 기징 빠른 성능
Next-fit
이전 할당 위치부터 스캔하여 할당 가능한 다음 빈 공간에 할당하는 방식
전체적으로 할당이 일어나기 때문에 Compaction이 더 자주 필요하다
Best-fit
요청 크기와 가장 가까운 크기의 빈 공간에 할당하는 방식 (외부 단편화가 가장 작게 생기도록)
외부 단편화가 너무 잘게 만들어지기 때문에 컴팩션이 자주 필요
Worst-fit
가장 큰 빈 공간에 할당하는 방식
실제로 가장 비효율적 (큰 공간들이 사라지면서 컴팩션이 더 자주 필요하다)

버디 시스템(Buddy System)
고정 분할과 동적 분할 기법의 절충안

초기에는 전체 공간이 크기 2^U인 하나의 블록으로 취급
2^U는 할당 가능한 전체 메모리 크기
메모리 블록은 크기 2^K 단위, L ≤ K ≤ U
(2^L = 할당 가능한 가장 작은 블록 크기)
(2^U = 할당 가능한 가장 큰 블록 크기(대개 전체 메모리 크기)

버디 시스템(Buddy System) 알고리즘
2^(k-1) < s ≤ 2^k를 만족할 때까지 분할하고, 2^k인 블록을 할당한다
인접한 버디를 직전의 더 큰 분할 크기로 합칠 수 있을 때 합친다
(같거나 살짝 큰 단위까지 나눈다)

페이징(Paging)

메인 메모리는 동일 크기의 여러 프레임으로 나뉘고
프로세스가 프레임과 같은 크기의 여러 페이지로 나뉘고,
페이지들을 연속될 필요 없이 가능한 프레임에 적재하는 방식
외부 단편화는 없으나, 프로세스의 마지막 페이지에 작은 내부 단편화가 발생할 수 있다.

페이지 테이블(Page Table)
프로세스의 페이지가 위치한 프레임 정보를 담고 있다.
페이지 번호(0부터 시작)를 인덱스로 사용
메인 메모리의 사용되지 않는 프레임을 관리하는 하나의 free-frame list를 관리
프로세서는 logical addresss(페이지 번호, 오프셋)를 page table을 통해 physical address(프레임 번호, 오프셋)로 변환
고정 분할과 유사하지만, (1) 분할 크기가 매우 작고 (2) 연속적일 필요 없다는 점에서 다르다

페이지 번호(p): 페이지 테이블의 인덱스로 사용, 물리 메모리 내 각 페이지의 base address를 가리킨다
페이지 오프셋(d): base address에 더해져 실제 물리 메모리 주소를 구할 수 있고, 이 주소가 메모리로 전달됨

세그멘테이션(Segmentation)
프로세스가 최대 길이가 정해져 있는 가변적 길이의 여러 개의 세그먼트로 나뉘고
세그먼트들을 연속될 필요 없이 가능한 분할에 적재하는 방식
Logical Address는 (Segment #, Offset)
동적 분할과 유사지만, 연속적이지 않아도 되는 분할에 적재
내부 단편화는 없지만 외부 단편화는 발생할 수 있다

Simple segmentation 기법은
각 프로세스마다 세그먼트 테이블과 빈 블록 리스트를 사용
1. 논리 주소의 왼쪽 n비트를 세그먼트 번호로 추출
2. 세그먼트 번호를 인덱스로 세그먼트 테이블에서 해당 세그먼트의 Base를 찾는데, 논리 주소의 오른쪽 m비트로 Offset이 세그먼트 Length보다 크거나 같으면 주소가 유효하지 않다.
3. 원하는 물리 주소는 세그먼트 Base address와 offset의 합이다

(페이징과 유사하나, 세그먼트 테이블에 length가 추가적으로 있어서 offset과의 비교를 통해 유효한 주소인지 확인한다)

가상 메모리
보조 기억 장치를 마치 메인 메모리의 일부처럼 프로그램 주소를 변환해 사용하는 저장 방식

프로그램 주소는 물리 주소와 구별
프로그램이 생성한 주소는 자동으로 기계 주소로 변환
가상 저장 공간의 크기는 주소 정책이나 보조 기억 장치의 용량에 의해 제한

실행 중에 프로세스의 모든 페이지나 세그먼트가 메인 메모리에 있을 필요는 없다

필요한 주소가 메인 메모리에 없을 경우, 페이지 폴트 인터럽트가 발생한다.
운영체제는 인터럽트가 발생한 프로세스를 블로킹 상태로 전환
논리적 주소를 포함하는 프로세스 조각이 메인 메모리로 불러져 와야 한다
운영체제는 디스크 I/O 읽기 요청을 수행
디스크 I/O가 수행되는 동안, 다른 프로세스가 실행된다.
디스크 I/O가 완료되면 인터럽트가 발생하고 제어가 운영체제로 돌아가며, 운영체제는 해당 프로세스를 레디 상태로 전환

(페이지 테이블 확인했을 때, 메인 메모리에 있으면 물리 주소를 계산해서 메인 메모리로 접근)
(페이지 테이블을 확인했을 때, 메인 메모리에 없으면(i) 해당 프로세스를 블로킹한다음 디스크로 가서 메인 메모리로
가서 가져온 다음 레디 상태로 전환)

가상 메모리의 장점
(1) 더 많은 프로세스를 메모리에 수용 가능해서 CPU Utilization이 높아짐
(2) 프로세스의 크기가 물리적 메모리의 크기보다 커질 수 있다

지역성의 원리: 프로그램은 짧은 시간 동안 한정된 메모리 영역만을 집중적으로 참조하는 경향이 있다는 원리

Thrashing: OS가 페이지 교체에 과도하게 많은 시간을 소비하여 실제 작업은 거의 수행되지 않는 상태
(사용되기 직전의 조각을 계속해서 내보낸다면 비효율적으로 작동하게 됨)
OS는 최근 사용 이력을 기반, 가까운 미래에 사용될 가능성이 가장 낮은 조각을 추측하여 내보내려고 한다.

가상 메모리가 효과적으로 동작하기 위해서:
하드웨어 지원(주소 변환)
OS는 어떤 페이지가 들어가고 나오는지를 관리하는 소프트웨어를 포함해야함

각 프로세스는 고유한 페이지 테이블을 가진다
각 PTE(Page Table Entry)는 메모리 내 해당 페이지의 프레임 번호, 컨트롤 비트(P-bit, M-bit)
OS는 free-frame list를 관리
P bit(valid-invalid bit): 페이지가 메모리에 존재함을 나타냄
M bit: 페이지가 변경되었음을 나타냄

[Paging]
Virtual address: Page #, Offset
PTE: Page #, Frame #, Control bit(P-bit, M-bit)
Physical address: Frame #, Offset

[Inverted Page Table]
Virtual address: Page #, Offset
Inverted Page Table: Index(Frame #), Pid, VPN, Chain, Control bit
Physical address: Frame #, Offset

[Segmentation]
Virtual address: Segment #, Offset
STE: Segment #, Length, Base, Control bit
Physical address: Base + Offset

Two Level Hierarchical Page Table
한 페이지의 크기 4KB(2^12) , 32비트(2^32 = 2^20개 * 한 개당 2^12) 주소를 가정
4GB(2^32) 가상 주소 공간은 2^20개 페이지로 구성
총 용량: 4GB(2^32) = 2^20개 * 4KB(2^12)

따라서 하나의 페이지 테이블은 2^20개의 PTE로 구성되고 하나의 PTE는 4Byte(32비트)
user 페이지 테이블 용량: 4MB = 2^20개 * 4Byte
각 프로세스마다 페이지 테이블 용량으로 4MB(2^22)차지

root 페이지 테이블 용량: 4KB = 엔트리 2^10개 * 엔트리당 4Byte

프로세스들은 4KB(4 * 2^10)의 root 페이지 테이블만 메인 메모리에 상주시키고
나머지는 필요할 때만 디스크에서 가져온다
4GB 저장하는데
1계층이었으면 프로세스당 페이지 테이블을 저장하는데 4M 필요했는데
2계층으로 구성함으로써 프로세스당 페이지 테이블 저장하는데 4K만 필요

(2 * 2^10 = 2^12)
(2^12 * 2 ^10 = 2^22)

페이지 테이블의 크기가 virtual address space(VAS)의 크기에 비례
=> 대안 : Inverted Page Table

각 엔트리는 다음을 포함
VPN (페이지 번호) – 가상 주소(Virtual Address)의 페이지 번호
pid – 이 페이지의 소유 프로세스
제어 비트
chain 포인터 – 체인 내 다음 항목의 인덱스 값

Hash (PID, VPN(Virtual Page Number)) => Index(Frame #)
Inverted Page Table에서 해당 테이블 인덱스의 항목에서,
pid, VPN이 같으면 => (Index == Frame #) + Offset 해서 실제 주소로 이동
pid, VPN이 다르면 => 체인을 타고 다음 인덱스 항목으로 넘어간다

가상 페이지마다 하나씩이 아니라, 실제 물리적 메모리 프레임마다 엔트리들이 존재
프레임 번호로 페이지 테이블 항목(PTE)을 인덱싱
(페이지 번호 X, 프레임 번호 O)

TLB
가상 메모리 참조는 두 번의 메모리 접근을 유발(한 번은 페이지 테이블, 한 번은 데이터)
최근에 사용된 PTE를 저장하는 캐시

Direct Mapping:
PTE를 TLB의 고정된 엔트리에 매핑하고, 찾는 방식
Associative Mapping:
PTE를 TLB의 어떤 엔트리에든 저장할 수 있으며, 하드웨어가 동시에 모든 엔트리를 한방에 확인하는 방식

캐쉬는 블록단위로 불러오고 블록단위로 저장 (지역성의 원리를 활용하기 위해서)
TLB 히트 + 캐쉬 히트 시, 메모리에 한 번도 접근하지 않고 값을 바로 가져올 수 있다

Page Size

페이지 크기 결정 시 고려 세 요소

내부 단편화 감소: 페이지 크기가 작을수록 내부 단편화는 줄지만, 페이지 수 증가로 페이지 테이블이 커진다.
페이지 폴트 감소: 큰 페이지는 PTE 수를 줄여서 해당 페이지 테이블이 메인 메모리에 유지될 확률을 높여서
이중 페이지 폴트를 줄일 수 있으나, 내부 단편화가 발생할 수 있다
효율적인 데이터 블록 전송: 큰 페이지 크기가 I/O 성능에 유리하나, 내부 단편화가 발생한다

페이지 폴트율
1. 큰 페이지는 지역성의 효과를 약화시켜 페이지 폴트율을 증가시킬 수 있지만, 페이지 크기가 프로세스 크기에 가까워지면 다시 감소한다.
2. 페이지 폴트율은 페이지 크기뿐만 아니라 프로세스에 할당된 프레임 수에도 영향을 받는다(SW issue)
(할당 프레임 수가 증가함에 따라 확 줄다가 서서이 줄어든다)

Segmentation Only

메모리를 세그먼트로 나누어서 관리
장점: 동적 구조 처리, 모듈화, 공유 및 보호 지원

P-bit: 세그먼트가 이미 메모리에 있는지 확인
M-bit: 세그먼트가 수정되었는지 확인

(Simple Segmentation과 유사하게 동작)

Combining Paging and Segmentation
각 세그먼트는 페이지 여러 개로 나뉜다.

장점:
- 세그멘테이션은 프로그래머에게 visible
- 동적 구조 처리, 모듈화, 공유 및 보호 지원
- segmentation과 달리, 외부 단편화가 없다
- 매핑이 단순
- segment 테이블에서 꺼내는 base address로 page 테이블을 찾고
- Page 테이블에서 page #로 frame #를 찾아 물리 주소로 변환

(프로세스마다 세그먼트 테이블)
(세그먼트 별로 페이지 테이블)
(메모리를 3번 접근해야 한다는 단점이 있다)

[Alg] NP Problem

vysryoo — Fri, 30 May 2025 15:53:58 +0900

Two approaches

1) develope a more efficient algorithm.

2) try to prove that more efficient algorithm is NOТ possible

==> Quit/Stop.

1) try to find a more efficient algorithm using NEW design

: O(n^3) -> O(n^2) -> O(nlogn)

2) try to find a greater(better) lower bound using computational analysis.

Example

1. Sorting: nlogn (comparison)

-> omega(nlogn): lower bound already found, algoritms already found/used

2. Search

-> binary search (TC) is as good as lower bound

-> omega(logN)

=> upper bound를 점점 낮추는 것이 알고리즘 developement

=> lower bound를 점점 높여서 만나는 지점에서, 알고리즘 개발을 멈출 수 있을 것

NP Theory

Solving a problem (for Normal/Classic Problems)

1. Design algorithms (for optimal/exact solution)

2. Analysis: time complexity, proofs, lower bound

IF we can NOT find efficient algorithms? (NP문제)

1. very slow algorithm for optimal solution

2. optimal solution 포기-> approximate solution 채택 (suboptimal, near-optimal solutions)

===> Approximation algorithm (NEW) 설계/분석

Problem Classification

"P <= NP <= EXP <= Solvable <= Countable"

Q1: 0~10 사이 정수	9개	Finite, Countable	P
Q2: 0~10 사이 실수	무한개	Uncountable	Not countable / unsolvable as counting
Q3: 0~∞ 사이 정수	무한개	Infinite, Countable	Solvable (정의 가능), Not finite
Q4: 0~1 실수 > 0~10 정수?	예	Uncountable vs Finite	P (간단한 비교)

Q5. Sort 문제(P)는 KS(NP)보다 쉬운가? 증명하시오
→ 문제의 난이도 클래스 확인 → proper design/analysis

- 자연수 집합과 일대일 대응이 가능하면 countable

- 자연수 집합과 일대일 대응이 불가능하면 uncountable

- 문제가 애초에 어떤 정답이 있는지조차 컴퓨터로 항상 판단할 수 없는 경우면 unsolvable

Easy problem vs intractable problem

1) easy problem: good algorithm 존재, polynomial TC.

2) intractable problem: difficult to treat or work

(NO Polynomial-time algorithm), NP(X)

P-class:

1. the class of decision problems that are polynomially bounded

2. T(n) = polynomial function of 'n'

3. problems solvable in polynomial time

EXP-class:

problems solvable in Exponential time

me (N-queens, KS, ...)

polynomial 알고리즘을 찾지 못했다고 해서 그 문제가 p-class가 아니라고 단정지을 수 없다

exp 알고리즘을 찾았다고 해서 그 문제가 exp-class라고 단정지을 수도 없다

=> 언젠가 polynomial 알고리즘을 찾을 수도 있다 ==> 수학적 정의 필요!

3 categories:

1. Problem proven to be in P-class:

sort, search, CMM, SP, Dijkstra, ... -> easy, efficient, fast, optimal, tractable.

2. Problem proven to be NOT in P-class: "a few"

"intractable"

: O(n^2) X, O(n^4) X O(n!) O

: determine ALL Hamiltonian paths -> O(n!) only BF

: Non-polynomial amount of output

"halting problem": given a computer program(algorithm), does it stop/halt? YES/NO.
: NOT in P-class임이 증명
: famous because it was the FIRST problem proven to be uncomputable/undecidable.

halting problem은 unsolvable

3. Problem proven "neither" to be in P "nor" to be intractable.
== neither (1) nor (2)
: Knapsack, Graph coloring, TSP, Subset sum, ....

심증 : ( 1 ) 난이도 << ( 3 ) 난 이 도
(3) could be (1) in the future
(3) 문제 범주 = NP-class 문제

NP Definition (loosely speaking):
NP is the class of decision problems for which a given
solution can be checked quickly (in polynomial time) to see if it is true solution

- Solution을 빠르게 계산하는 nice algorithm을 찾지 못했을 때,
- 일단 가정: Solution이 주어졌다고 가정하고 출발

Optimization Problem vs Decision Problem

TSP (Optimization problem → optimization prob ver, decision prob ver)

- Optimization problem: find optimal tour

- Decision problem: Is there a TSP tour with cost < 200? → Yes / No

Knapsack

- Optimization problem: maximize total profit

- Decision problem: Is there a set AA with profit > 100? → Yes / No

Graph Coloring

- Optimization problem(version): minimize the number of colors

- Decision problem: Is the graph m-colorable? → Yes or No (e.g., via backtracking)

Clique Problem

- Clique: 완전 부분 그래프 (예: Bioinformatics, SNS 등에서 활용)

- Clique size 예시: size = 4 (파란색), size = 3 (초록색)

- Optimization Problem: 최대 clique를 찾아라 (find max. clique)

- Decision Problem: 그래프에 크기 k 이상의 clique가 존재 하는가? → Yes or No

Q: TSP는 P인가? NP인가?
A: Optimization version TSP는 NP-Hard, Decision version은 NP-Complete

Q: Sorting 문제는 P인가? NP인가?:

A: Sorting문제는 P문제

Knapsack_Optimization ver : NP (x) NP-Hard (o)

Item set A가 주어졌을 때, 최대 500 profit이 maximum인지 P-time에서 확인 가능한가?

→ 2ⁿ개의 조합을 비교하여 real max, optimal 여부를 판별할 수 있다.

Knapsack_Decision ver : NP (o)

Deterministic (결정적)

어떤 입력을 넣으면 항상 똑같은 출력이 나오는 시스템

Stochastic (확률적, random, probabilistic)

무작위(randomness)를 기반으로 가능한 선택지 중 하나를 랜덤하게 고르고,

그 결과가 성공인지 실패인지는 운에 따라 결정됨.

동일한 인풋에서 아웃풋이 살짝 살짝씩 변한다

Nondeterministic

마치 모든 가능한 경우를 동시에 시도해보고, 그 중에서 정답인 경우만 딱 골라서 결과를 내는 것처럼 동작.

이론적 개념(현재의 폰노이만 아키텍쳐에서는 구현 불가능)

Magic algorithm = Nondeterministic algorithm

Nondeterministic Algorithm Machine

1. Nondeterministic Guess (step 1)
: given a problem instance, guess a correct solution

in unit time if exists. (without trying all options)

2. Deterministic Verification (step 2)
: verify the gussed solution

NP의 정의
1. Decision problems in P.time via a magic algorithm
2. Decision problems with solutions that can be checked(verifiable) in P time

3. set of all problems solvable by polynomial time Nondeterministic algorithm

4. solvable in polynomial time by Nondeterministic algorithm

=> Nondeterministic 알고리즘이 Polynomial time 안에 풀 수 있는 문제

= set of decision problems solvable in polynomial time by nondeterministic algorithm

P == NP (미해결 문제, probably no)

P⊆NP (Yes)

Almost all important problems in CS are in NP.

Too many problems cannot be proven to be in P.

Only one of NP-C is in P ⇒ All of them are in P.

NP 중에서 제일 대표적이고 어려운, core, 완전한 문제 → NP-Complete 문제

only one of NP-C problems is polynomial time solvable, then so are all of them

(하나의 NP-C라도 다항 시간 내에 풀 수 있다는 것이 밝혀지면 다른 모든 NP 문제도 다항 시간 내에 풀 수 있는 것이 증명되므로)

(P == NP임이 증명된다, 현재는 P가 NP에 포함된다는 것만 밝혀진 상태: P이면 NP이다)

- A문제가 B문제로 바뀔 수 있다 (transform, reduce)

- A is transfromed into B

- A is reduced into B

Def: NP-Complete

Problem B is NP-Complete if

[Definition 1]

Problem B is NP-Complete
if 1) B is in NP and
2) for all A in NP, A => B (transform, reduce).

(B가 NP이고, 모든 NP 문제를 polynomial 시간 안에 B로 환원할 수 있어야 한다)

(그러나 수학적으로 2번을 증명하기가 너무 어려움)

[Definition 2]

Problem C is NP-Complete
if 1) C is NP and
2) for NP-Complete B, B = > C. (transform, reduce)
NP-C인 B를 알 수 없기 때문에, C가 NP-C임을 증명할 수도 없다

(C가 NP이고, 모든 NP-C 문제를 polynomial 시간 안에 B로 환원할 수 있어야 한다)

(NP-C인 B를 알 수 없기 때문에, C가 NP-C로 임을 증명할 수도 없었는데..)

NP-Complete 문제란

NP에 속하는 문제이면서,
다른 모든 NP 문제(좁은 정의에서는 이미 알려진 하나의 NP-Complete 문제)가 다항시간 내에 환원될 수 있는 문제

Cook's Theorem (1971)
"If CNF problem is P, then P==NP."

CNF problem는 NP-C임이 증명된 최초의 문제

- CNF를 해결하는 polynomial 알고리즘이 하나 존재한다면, 다른 모든 np

CNF-Satisfiability (Boolean SAT) Problem
CNF: Conjunctive Normal Form (논리곱 표준형)

= SAT (Satisfactory Problem, 논리식 만족 문제)
ex. (x1 or x2) and (x2 or not x3) and not x2 = F (bool expr)
CNF (DP ver): is there a truth assignment for x1, x2, x3

- true로 만드는 x1, x2, x3에 대한 진리표 할당이 있을 수 있느냐 (Decision Problem: 대답 예/아니요)

Theorem: If Decision Problem B is P-class and A =>p B, then A is also P

SAT는 Decision Problem, transform 가능한 문제 역시 DP 형태를 가져야함

SAT(Decision Problem ver) ⇒ p(나의 문제, Decision Problem)

Motivation: 주어진 어려운 문제를 NP-C로 해결할 수 있다

SAT =>p (My Problem)

: NP-C 중에 하나가 해결되면, 다른 NP-C도 변환해서 해결할 수 있다

Hamiltonian Circuit

간선에 가중치가 없음.

순수하게 경로의 존재 유무만 판단.

본질적으로 Decision Problem임

NP-Complete 문제.

TSP Decision Problem

간선에 가중치가 있음.

역시 NP-Complete 문제.

(SAT ≤p HC)

(HC ≤p TSP-DP)

1) TSP의 Decision Problem은 NP이다: 정답이 주어졌을 때, O(n)만에 판별 가능

2) HC가 NC-Complete이고, HC를 polynomail time 안에 TSP Decision Problem으로 환원할 수 있다

[HC → TSP Decision Problem 환원]

- HC에 있던 엣지는 TSP로 옮기면서 웨이트를 1로 주고

- HC에 없던 엣지는 TSP로 옮기면서 기존에 있던 값보다 훨씬 큰 값을 넣어준다

- 2가 할당되어 있는 엣지는 절대 정답에 포함될 수 없으므로, TSP로 답을 풀면 HC 문제의 답을 구할 수 있다

전제: Subset sum 문제가 NP-C이다

1) 0/1 Knapsack은 NP문제이다: 특정 해가 주어졌을 때, O(n)만에 검증할 수 있으므로 NP임을 증명 가능

2) Subset sum 문제가 NP-C이고, subset sum을 polynomial time 안에 0/1 KS로 환원할 수 있다

따라서 0/1 KS도 NP-C이다

[Subset Sum → 0/1 Knapsack 환원]

Subset Sum 문제:

- 입력: 정수 집합 S={a1,a2,…,an}, 목표합 T

- 질문: 의 어떤 부분집합의 합이 정확히 T가 되는가?

이걸 0/1 Knapsack 문제로 바꾸는 방법:

아이템	원소 a_i	아이템 i
무게 wi	a_i	a_i
가치 vi	없음	a_i ← 무게와 동일하게 설정
배낭 용량 W	목표합 T	T

1) Clique의 Decision Problem은 NP이고

2) SAT가 polynomial time안에 Clique의 DP로 환원될 수 있기 때문에, Clique의 DP도 NP-Complete이다

TSP는 NP-Complete? => No

TSP-DP는 NP-Complete? => Yes

Subset Sum, HC, N-Queens는 본질적으로 Decision Problem

Knapsack, TSP는 본질적으로 Optimization Problem

Optimization 버전으로 제시된 문제는 ==> NP-Hard category

[Definition]

A is NP-Hard

if for NP-Complete인 B에 대해서, B =>p A

(A가 NP 문제일 것을 요하지 않는다)

HC-DP: 100개 도시를 1시간 내에 다 돌고 돌아올 수 있느냐? => O(n)에 검증 가능 => NP

TSP-DP: “비용이 k 이하인 해가 존재하는가? ”해답(경로)을 주면 그 해답을 다항 시간 내에 검증 가능 => NP

TSP-OP: 최소 경로가 주어졌을 때, 이 경로가 optimal이라는 것 검증 => O(n!) 필요하다 => NP에 속하지 않음!

Knapsack (default OP) => NP-Hard

=> given sollution: O(2^n) verified required

대응하는 결정 문제가 NP-Complete라면
그 최적화 문제는 적어도 NP-Hard임이 보장

[Approximation Algorithm: TSP]

: MST만든 다음에 pre-order 순회

MST: short edge 연결, no cycle

Approximation design:
1. determine a MST (using Prim's alg) : ranking (=> 가장 dominant한 것은 mst 만드는 것: O(n^2))
2. Create a path around the MST (using preorder visit)

Approximation analysis:

1. Time complexity: poly.time O(n^2)

2. Boundness (theorm, proof)

: approximate sol < opt sol (관계성 보여주는 것)

Boundness: approxiate path (p) < 2*optimal path (p*)

cost(MST.path) < cost(p*)
cost(Full walk on MST) = 2 * cost(MST.path)
-> cost(Full walk on MST) < 2 * cost(p*)
cost(p) < cost(Full walk on MST) (by triangular inequality)
-> cost(p) < 2 * cost(p*)

(여기서 p*는 optimal이고, p는 mst를 preorder로 순회한 것)

[Approximation: Bin Packing]

n items with sizes: s1, s2, ... sn (0 < si <= 1)

--> find min # bins (unit-cap bins)

Bin Packing Problem은 NP-Hard 문제

Subset Sum 문제를 Bin Packing 문제로 환원

Subset Sum의 목표 합 t를 bin의 크기 1로 정규화(normalization)

각각의 정수 aᵢ를 bin packing의 item으로 바꾸고, sᵢ = aᵢ / t 로 정규화

subset sum은 NP-Complete이고, 다항 시간 안에 bin packing 문제로 환원될 수 있지만

bin packing 문제가 NP가 아니기 때문에(Optimization), bin packing은 NP-Hard에 속한다

Example: n=8, item size= 0.85, 0.1, 0.5, 0.2, 0.4, 0.4, 0.3, 0.2

Approximation design: NFF(Nonincreasing First-Fit)

1. sort the items in nonincreasing order (greedy ranking)

2. pack into as close bin as possible in First Fit manner

=> 이 방식으로 위의 예시를 풀면 4개가 필요하지만, Optimal은 3개이다

Approximation analysis:

1. time complexity: T(n) = O(nlogn) : 이 알고리즘의 dominant part는 정렬하는 부분

2. bound theorm (qaulity)

---> approximate bin < optimal bin * 1.5 (theorm)

---> "any items placed by NFF in an extra bin has size <= 1/3" (lemma)를 이용하여 위의 관계 증명 가능