수치/공식 정리

처리량 = 완료된 작업 수 / 시간

예: 1초에 1000 트랜잭션 = 1000 TPS

응답시간 = 대기시간 + 서비스시간

평균 응답시간 = Σ(각 요청 응답시간) / 총 요청 수

L = λ × W

L = 시스템 내 평균 요청 수
λ = 평균 도착률 (요청/초)
W = 평균 체류 시간 (초)

예: 100 req/s 도착, 0.5초 처리 → 평균 50개 동시 요청

Speedup = 1 / ((1-P) + P/N)

P = 병렬화 가능 비율
N = 프로세서 수

예: 90% 병렬화, 4코어 → 1/(0.1 + 0.9/4) = 3.08배
극한: P=0.9일 때 최대 10배 (1/0.1)

가용성(%) = (MTBF / (MTBF + MTTR)) × 100

MTBF = Mean Time Between Failures (평균 고장 간격)
MTTR = Mean Time To Repair (평균 복구 시간)

직렬 (AND): A_total = A1 × A2 × A3 × ...
병렬 (OR):  A_total = 1 - (1-A1) × (1-A2) × ...

예: 99% 두 개 직렬 → 0.99 × 0.99 = 98.01%
예: 99% 두 개 병렬 → 1 - (0.01 × 0.01) = 99.99%

높이 = ⌈logₙ(레코드 수)⌉

n = 분기 계수 (보통 100-500)
예: 1억 레코드, 분기 200 → log₂₀₀(100,000,000) ≈ 4

→ 최대 4번 I/O로 검색 가능

C (Consistency) + A (Availability) + P (Partition Tolerance)
→ 분산 시스템에서 3개 중 2개만 선택 가능

CP: MongoDB, HBase (일관성 + 분할 내성)
AP: Cassandra, DynamoDB (가용성 + 분할 내성)
CA: 단일 노드 RDBMS (분할 없는 경우만)

권장 연결 수 = (CPU 코어 수 × 2) + 유효 스핀들 수

예: 4코어 + SSD → (4 × 2) + 1 = 9개 연결

O(1) < O(log n) < O(n) < O(n log n) < O(n²) < O(2ⁿ) < O(n!)

n = 2^(b/2) 에서 50% 충돌 확률

b = 해시 비트 수
MD5 (128 bit): 2^64 ≈ 10^19 개에서 충돌
SHA-256 (256 bit): 2^128 ≈ 10^38 개에서 충돌

Effort = a × (KLOC)^b × M

a, b = 프로젝트 유형 상수
KLOC = 천 라인 코드
M = 노력 조정 계수

예: 중간 규모 (a=3.0, b=1.12)
   50 KLOC → 3.0 × 50^1.12 ≈ 239 인월

정확도 (Accuracy) = (TP + TN) / (TP + TN + FP + FN)

정밀도 (Precision) = TP / (TP + FP)

재현율 (Recall) = TP / (TP + FN)

F1 Score = 2 × (Precision × Recall) / (Precision + Recall)

AUC-ROC = TPR vs FPR 곡선 아래 면적 (0.5 ~ 1.0)

[현행] ISO 27001:2022
  4개 테마: 조직(Organizational) / 인적(People) / 물리(Physical) / 기술(Technological)
  93개 통제 항목 (신규 11개 포함)

(구) ISO 27001:2013
  14개 보안통제 영역
  35개 보안통제 목적
  114개 보안통제 항목

1. 처리량 = 완료 작업 / 시간
2. 가용성 = MTBF / (MTBF + MTTR)
3. 리틀의 법칙: L = λ × W
4. 암달의 법칙: S = 1/((1-P) + P/N)
5. 직렬 가용성: A₁ × A₂ × ...
6. 병렬 가용성: 1 - (1-A₁) × (1-A₂) × ...

7. 호스트 수 = 2^(32-서브넷) - 2
8. 서브넷 수 = 2^(서브넷-기본마스크)
9. 전송시간 = 데이터크기 / 대역폭
10. 왕복시간 = 2 × (전파지연 + 전송지연 + 처리지연)

11. 브루트포스: 경우의 수 = 문자종류^길이
12. 해시 충돌 (Birthday): 2^(비트/2)에서 50%
13. 엔트로피: H = -Σ p(x) × log₂(p(x))

14. Accuracy = (TP+TN) / (TP+TN+FP+FN)
15. Precision = TP / (TP+FP)
16. Recall = TP / (TP+FN)
17. F1 = 2 × P × R / (P+R)

위험도 (Risk) = 위협(Threat) × 취약점(Vulnerability) × 자산가치(Asset)

또는 간략화:
위험도 = 발생가능성(Likelihood) × 영향도(Impact)

ALE = SLE × ARO

SLE (Single Loss Expectancy) = 자산가치 × 노출계수(EF)
ARO (Annual Rate of Occurrence) = 연간 발생 빈도

예시:
- 서버 가치: 1억원
- 노출계수: 30% (피해 비율)
- 연간 발생률: 0.5회
- SLE = 1억 × 0.3 = 3000만원
- ALE = 3000만 × 0.5 = 1500만원/년

ROSI = (ALE_before - ALE_after - 통제비용) / 통제비용 × 100

예시:
- 통제 전 ALE: 1500만원
- 통제 후 ALE: 300만원
- 통제 비용: 500만원
- ROSI = (1500 - 300 - 500) / 500 × 100 = 140%

유효 접근시간 = h × Tc + (1-h) × Tm

h = 캐시 히트율 (0~1)
Tc = 캐시 접근시간
Tm = 메인 메모리 접근시간

예: h=0.95, Tc=1ns, Tm=100ns → 0.95×1 + 0.05×100 = 5.95ns

CPI = 총 클럭 사이클 수 / 명령어 수
MIPS = 클럭(MHz) / CPI
IPC = 1 / CPI (클럭당 명령어 수)

예: 3GHz CPU, CPI=1.5 → MIPS = 3000/1.5 = 2000 MIPS

P = C × V² × f

C = 정전용량 (스위칭 캐패시턴스)
V = 공급 전압
f = 동작 주파수

→ 전압 30% 감소 시 전력 ~51% 감소 (0.7² ≈ 0.49)

S = (n × k) / (k + n - 1)

k = 파이프라인 단계 수
n = 명령어 수

n → ∞ 일 때: S → k (이론적 최대 = 단계 수)
예: 5단계, 100개 명령어 → (100×5)/(5+99) = 4.81배

[암달] Speedup = 1 / ((1-P) + P/S)
  P = 병렬화 가능 비율, S = 프로세서 수
  → 병렬화 불가 부분이 병목 (비관적)

[구스타프손] Speedup = S + (1-S) × P
  S = 프로세서 수, P = 순차 비율
  → 문제 크기 확장으로 성능 향상 가능 (낙관적)

Java HashMap: 0.75 (기본)
일반 권장: 0.7 ~ 0.75
→ 이 이상이면 충돌 급증, 리사이징 필요

FPR = (1 - e^(-kn/m))^k

k = 해시 함수 수
n = 삽입된 원소 수
m = 비트 배열 크기

최적 k = (m/n) × ln2 ≈ 0.693 × (m/n)

h ≤ log_t((n+1)/2)

t = 최소 차수 (각 노드 최소 t-1개, 최대 2t-1개 키)
n = 총 키 수

예: t=100, n=1억 → h ≤ log₁₀₀(50,000,000) ≈ 4

h ≤ 2 × log₂(n + 1)

→ AVL보다 느슨하지만 삽입/삭제 회전 횟수 적음
→ AVL 최대 높이: 1.44 × log₂(n + 2)

엔트로피 = log₂(문자종류^길이)

8자 영숫자 (62종): log₂(62^8) ≈ 48 bit
12자 영숫자+특수 (95종): log₂(95^12) ≈ 78 bit

n비트 해시 → 2^(n/2) 시도로 50% 충돌 확률

MD5 (128 bit): 2^64 ≈ 1.8×10^19 시도
SHA-256 (256 bit): 2^128 ≈ 3.4×10^38 시도

CPU 바운드: 스레드 수 = 코어 수
I/O 바운드: 스레드 수 = 코어 수 × (1 + 대기시간/처리시간)

예: 4코어, I/O 대기 80% → 4 × (1 + 0.8/0.2) = 20 스레드

P50 < P90 < P95 < P99 < P99.9

→ SLA에서는 P99 또는 P99.9 기준으로 설정
→ 평균값은 이상치에 왜곡되므로 백분위수 사용

메모리 = 파라미터 수 × (정밀도 바이트 + 옵티마이저 상태)

정밀도별 파라미터당 메모리:
  FP32: 4 Bytes/param
  FP16: 2 Bytes/param
  INT8: 1 Byte/param

Adam 옵티마이저 (FP32 학습 시):
  파라미터(4B) + Gradient(4B) + m(4B) + v(4B) = 16B/param
  → 약 12배 추가 메모리 (옵티마이저 상태만)

예: 7B 모델 FP16 추론 = 14GB, FP32 학습 ≈ 112GB+

학습 파라미터: 원본의 0.1% ~ 1%
성능 유지율: 풀 파인튜닝의 90% ~ 99%

→ VRAM 대폭 절감, 다중 어댑터 관리 용이

3: 최소 3개의 데이터 복사본
2: 최소 2개의 서로 다른 미디어 유형
1: 최소 1개는 오프사이트(원격지) 보관

백업 주기 예시:
- 전체 백업 (Full): 주 1회
- 차등 백업 (Differential): 일 1회
- 증분 백업 (Incremental): 시간 단위

EMV (Expected Monetary Value) = 확률 × 영향(금액)

예시:
- 위험1: 30% 확률, 1000만원 손실 → EMV = -300만원
- 위험2: 20% 확률, 500만원 손실 → EMV = -100만원
- 기회1: 40% 확률, 200만원 이익 → EMV = +80만원
- 총 EMV = -300 - 100 + 80 = -320만원

예비비 = |총 EMV| = 320만원 확보 권장

필요 대역폭 = (동시 사용자 × 사용자당 트래픽) / 효율 계수

예시:
- 동시 사용자: 10,000명
- 사용자당 평균: 1Mbps
- 네트워크 효율: 70%
- 필요 대역폭 = (10,000 × 1) / 0.7 = 14.3Gbps

전송 시간 = 데이터 크기 / 대역폭

예시:
- 10GB 파일, 1Gbps 회선
- 10GB = 80Gbit
- 이론적: 80 / 1 = 80초
- 실제 (70% 효율): 80 / 0.7 = 약 114초

최대 처리량 = Window Size / RTT

예시:
- Window Size: 64KB (65,536 bytes)
- RTT: 100ms
- 최대 처리량 = 65,536 / 0.1 = 655,360 bytes/s ≈ 5.2 Mbps

고지연 환경에서 처리량 개선:
- Window Scaling 옵션 사용 (최대 1GB 윈도우)
- 또는 병렬 연결 사용

Cache Hit Rate = (캐시 히트 수 / 전체 요청 수) × 100%

예시:
- 전체 요청: 1,000,000
- 캐시 히트: 850,000
- 히트율 = 85%

평균 접근 시간 = (Hit Rate × Cache 접근 시간) + (Miss Rate × 원본 접근 시간)

예시:
- Cache 히트율: 90%
- Cache 접근 시간: 1ms
- 원본 접근 시간: 100ms
- 평균 = (0.9 × 1) + (0.1 × 100) = 0.9 + 10 = 10.9ms

히트율 95%로 개선 시:
- 평균 = (0.95 × 1) + (0.05 × 100) = 0.95 + 5 = 5.95ms

캐시 용량 = 작업 세트 크기 / (1 - 히트율 목표)

또는 경험적:
- 히트율 80% → 전체 데이터의 20% 캐싱
- 히트율 90% → 전체 데이터의 10% 캐싱 (Hot Data)
- 파레토 법칙: 20% 데이터가 80% 접근

권장 비율:
- Memory: Requests ≈ Limits (OOM 방지)
- CPU: Limits = 2~4 × Requests (버스트 허용)

예시:
resources:
  requests:
    cpu: "250m"      # 0.25 코어
    memory: "256Mi"  # 256 MiB
  limits:
    cpu: "1000m"     # 1 코어
    memory: "256Mi"  # 메모리는 같게 (OOM 방지)

필요 노드 수 = (총 Pod 리소스 요청) / (노드 가용 리소스 × 사용률)

예시:
- Pod 100개, 각 1 CPU 요청
- 노드: 8 CPU
- 시스템 예약: 1 CPU
- 버퍼: 20%
- 노드당 가용: (8 - 1) × 0.8 = 5.6 CPU
- 필요 노드 = 100 / 5.6 = 18노드

원하는 레플리카 수 = ceil(현재 레플리카 × (현재 메트릭 / 목표 메트릭))

예시:
- 현재 Pod: 3개
- 현재 CPU: 80%
- 목표 CPU: 50%
- 원하는 Pod = ceil(3 × (80/50)) = ceil(4.8) = 5개

컨테이너 메모리 = JVM Heap + Metaspace + 네이티브 메모리 + 버퍼

권장:
- JVM Heap: 컨테이너 메모리의 50-70%
- Metaspace: 128MB ~ 256MB
- 버퍼: 20% 여유

예시 (1GB 컨테이너):
- Heap: 512MB (-Xmx512m)
- Metaspace: 128MB (-XX:MaxMetaspaceSize=128m)
- 나머지: 384MB (Native, Stack, etc.)

선택도 = 고유 값 수 / 전체 행 수

예시:
- 테이블 100만 행
- 'status' 컬럼: 5개 값 → 선택도 = 5/1,000,000 = 0.000005 (낮음, 비효율)
- 'user_id' 컬럼: 50만 개 값 → 선택도 = 0.5 (높음, 효율)

권장:
- 선택도 > 0.1 (10%) → 인덱스 효과적
- 선택도 < 0.01 → 인덱스 비효율적 (풀스캔이 나을 수 있음)

카디널리티 = 해당 컬럼의 고유 값 개수

복합 인덱스 순서:
- 높은 카디널리티 → 낮은 카디널리티
- 예: INDEX(user_id, status) (O)
- 예: INDEX(status, user_id) (X)

단순 추정:
- Full Table Scan: O(N)
- Index Scan: O(log N)
- Index Seek: O(log N)

예시 (100만 행):
- Full Scan: 1,000,000 I/O
- B-Tree 인덱스: log₂(1,000,000) ≈ 20 I/O

파티션 수 = 전체 데이터 / 파티션당 권장 크기

권장 파티션 크기:
- PostgreSQL: 10GB ~ 100GB
- MySQL: 10GB ~ 50GB
- Oracle: 100GB ~ 1TB

예시:
- 전체 데이터: 500GB
- 파티션 크기: 50GB
- 파티션 수: 10개

필요 서버 수 = (최대 동시 요청 수 × 평균 응답 시간) / (1초 × 효율)

예시:
- 최대 TPS: 10,000
- 평균 응답시간: 100ms
- 서버당 처리량: 500 TPS
- 필요 서버 = 10,000 / 500 = 20대
- 이중화 고려: 20 × 1.5 = 30대

세션 수 = 동시 연결 수 × (1 + 재사용률)

예시 (L4 LB):
- 동시 연결: 100,000
- 연결 유지 시간: 60초
- 초당 신규 연결: 10,000
- 메모리 필요: 연결당 약 1KB → 100MB

L = λ × W

동시 사용자 수 = 요청률 × 평균 체류 시간

예시:
- 시간당 요청: 36,000 (= 10 req/sec)
- 평균 페이지 체류: 30초
- 동시 사용자 = 10 × 30 = 300명

읽기 정족수(R) + 쓰기 정족수(W) > 노드 수(N)

일반적 구성:
- 강한 일관성: R + W > N
- 약한 일관성: R + W ≤ N

예시 (5노드):
- 강한 일관성: R=3, W=3 (3+3 > 5)
- 쓰기 최적화: R=5, W=1 (5+1 > 5)
- 읽기 최적화: R=1, W=5 (1+5 > 5)

분할(P) 발생 시: A(가용성) vs C(일관성) 선택
분할 없을 때(E): L(지연시간) vs C(일관성) 선택

예시:
- Cassandra: PA/EL (가용성, 지연시간 우선)
- MongoDB: PC/EC (일관성 우선)

월 비용 = (vCPU × CPU 단가) + (Memory GB × 메모리 단가) × 시간

예시 (AWS EKS + EC2):
- m5.large (2 vCPU, 8GB): 약 $0.096/시간
- 월 720시간: $69.12/노드
- 10노드 클러스터: $691.20/월

비용 = (요청 수 × 요청 단가) + (GB-초 × 메모리 단가)

예시:
- 월 100만 요청
- 평균 실행시간: 200ms
- 메모리: 1GB
- 요청 비용: 100만 × $0.0000002 = $0.20
- 컴퓨팅 비용: 100만 × 0.2초 × 1GB × $0.0000166667 = $3.33
- 총 비용: $3.53/월

비교:
- 동일 워크로드 EC2 (t3.medium): 약 $30/월
- Lambda가 저비용인 경우: 간헐적, 짧은 실행, 불규칙한 트래픽