프로세스 제어 블록(Process Control Block, PCB)

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

#!/usr/bin/env python3
"""
PCB 정보 기반 프로세스 모니터링 시스템
- /proc 파일시스템을 통해 PCB 정보에 접근
- 실시간 프로세스 상태 분석 및 이상 탐지
"""

import os
import time
import threading
from dataclasses import dataclass
from typing import Dict, List, Optional
import json

@dataclass
class PCBInfo:
    """PCB 핵심 정보를 나타내는 데이터 클래스"""
    pid: int
    ppid: int
    name: str
    state: str
    utime: int      # 사용자 모드 CPU 시간 (PCB의 utime 필드)
    stime: int      # 커널 모드 CPU 시간 (PCB의 stime 필드)
    vmsize: int     # 가상 메모리 크기 (PCB의 mm 구조체 정보)
    vmrss: int      # 실제 메모리 사용량
    num_threads: int # 스레드 개수
    
class PCBMonitor:
    """PCB 정보 기반 프로세스 모니터링 클래스"""
    
    def __init__(self):
        self.processes: Dict[int, PCBInfo] = {}
        self.monitoring = False
        
    def read_proc_stat(self, pid: int) -> Optional[PCBInfo]:
        """
        /proc/[pid]/stat 파일에서 PCB 정보 읽기
        - 이 파일은 커널이 PCB 정보를 사용자 공간에 노출하는 인터페이스
        """
        try:
            with open(f'/proc/{pid}/stat', 'r') as f:
                fields = f.read().split()
                
                # PCB 구조체의 주요 필드들을 파싱
                return PCBInfo(
                    pid=int(fields[0]),           # PCB의 pid 필드
                    ppid=int(fields[3]),          # PCB의 ppid 필드  
                    name=fields[1].strip('()'),   # 프로세스 명
                    state=fields[2],              # PCB의 state 필드
                    utime=int(fields[13]),        # PCB의 utime 필드
                    stime=int(fields[14]),        # PCB의 stime 필드
                    vmsize=int(fields[22]),       # PCB->mm 구조체의 가상 메모리 정보
                    vmrss=int(fields[23]) * 4096, # 실제 메모리 사용량 (페이지 단위)
                    num_threads=int(fields[19])   # 스레드 개수
                )
        except (FileNotFoundError, ValueError, IndexError):
            return None
    
    def scan_all_processes(self) -> Dict[int, PCBInfo]:
        """
        시스템의 모든 프로세스 PCB 정보 수집
        - /proc 디렉토리를 스캔하여 각 프로세스의 PCB 정보 수집
        """
        processes = {}
        
        for entry in os.listdir('/proc'):
            if entry.isdigit():  # PID 디렉토리만 처리
                pid = int(entry)
                pcb_info = self.read_proc_stat(pid)
                if pcb_info:
                    processes[pid] = pcb_info
                    
        return processes
    
    def detect_anomalies(self, current: Dict[int, PCBInfo], 
                        previous: Dict[int, PCBInfo]) -> List[str]:
        """
        PCB 정보 기반 이상 프로세스 탐지
        - 메모리 사용량 급증, 좀비 프로세스 등 탐지
        """
        anomalies = []
        
        for pid, pcb in current.items():
            # 좀비 프로세스 탐지 (PCB state 필드 확인)
            if pcb.state == 'Z':
                anomalies.append(f"좀비 프로세스 탐지: PID {pid} ({pcb.name})")
            
            # 메모리 사용량 급증 탐지
            if pid in previous:
                prev_pcb = previous[pid]
                memory_growth = pcb.vmrss - prev_pcb.vmrss
                if memory_growth > 100 * 1024 * 1024:  # 100MB 이상 증가
                    anomalies.append(
                        f"메모리 급증 탐지: PID {pid} ({pcb.name}) "
                        f"- {memory_growth // (1024*1024)}MB 증가"
                    )
            
            # 과도한 메모리 사용량 탐지
            if pcb.vmrss > 1024 * 1024 * 1024:  # 1GB 이상
                anomalies.append(
                    f"과도한 메모리 사용: PID {pid} ({pcb.name}) "
                    f"- {pcb.vmrss // (1024*1024)}MB"
                )
        
        return anomalies
    
    def start_monitoring(self, interval: int = 5):
        """실시간 PCB 모니터링 시작"""
        self.monitoring = True
        previous_scan = {}
        
        while self.monitoring:
            current_scan = self.scan_all_processes()
            
            # 이상 탐지 수행
            if previous_scan:
                anomalies = self.detect_anomalies(current_scan, previous_scan)
                if anomalies:
                    print(f"\n[{time.strftime('%Y-%m-%d %H:%M:%S')}] 이상 탐지:")
                    for anomaly in anomalies:
                        print(f"  - {anomaly}")
            
            # 통계 정보 출력
            print(f"\n[{time.strftime('%Y-%m-%d %H:%M:%S')}] "
                  f"프로세스 수: {len(current_scan)}")
            
            previous_scan = current_scan
            time.sleep(interval)
    
    def stop_monitoring(self):
        """모니터링 중지"""
        self.monitoring = False

# 사용 예시
if __name__ == "__main__":
    monitor = PCBMonitor()
    
    try:
        print("PCB 기반 프로세스 모니터링 시작…")
        print("Ctrl+C로 중지 가능")
        monitor.start_monitoring(interval=3)
    except KeyboardInterrupt:
        print("\n모니터링을 중지합니다.")
        monitor.stop_monitoring()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# PCB 구조체 예시 및 컨텍스트 스위칭
class ProcessControlBlock:
    def __init__(self, pid):
        self.pid = pid  # 프로세스 식별자
        self.state = 'ready'  # 상태 (ready, running, waiting)
        self.program_counter = 0  # 프로그램 카운터
        self.registers = [0]*8  # CPU 레지스터
        self.open_files = []    # 열린 파일 목록
    
# 컨텍스트 스위칭 함수
def context_switch(current_pcb, next_pcb):
    """
    컨텍스트 스위칭 핵심 로직
    PCB의 정보를 활용하여 각 프로세스의 상태를 저장/복원
    """
    # 현재 프로세스 상태 저장
    current_pcb.state = 'waiting'
    # 다음 프로세스 상태 복원
    next_pcb.state = 'running'
    # 기타 상태 전환 및 CPU 자원 할당

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

#!/usr/bin/env python3
# PCB 관측 기반 컨텍스트 스위치 급증 탐지기
# - 주제 연관: PCB가 /proc/<pid>/status로 노출하는 ctxt_switches를 사용
from __future__ import annotations
import time, sys, re, requests  # requests는 선택사항(웹훅용)

STATUS_KEYS = ("voluntary_ctxt_switches", "nonvoluntary_ctxt_switches")

def read_ctxt(pid: int):
    m = {}
    with open(f"/proc/{pid}/status") as f:
        for line in f:
            for k in STATUS_KEYS:
                if line.startswith(k + ":"):
                    m[k] = int(re.findall(r"\d+", line)[0])
    if len(m) != 2:
        raise RuntimeError("필드 파싱 실패")
    return m

def monitor(pid: int, sec: float = 2.0, threshold: int = 5000, webhook: str | None = None):
    prev = read_ctxt(pid)
    while True:
        time.sleep(sec)
        cur = read_ctxt(pid)
        dv = cur["voluntary_ctxt_switches"] - prev["voluntary_ctxt_switches"]
        dnv = cur["nonvoluntary_ctxt_switches"] - prev["nonvoluntary_ctxt_switches"]
        total = dv + dnv
        print(f"[{time.strftime('%H:%M:%S')}] dv={dv} dnv={dnv} total={total}")
        if total > threshold:
            msg = f"[경고] PID {pid} 컨텍스트 스위치 급증: {total}/~{sec}s"
            if webhook:
                try:
                    requests.post(webhook, json={"text": msg}, timeout=2)
                except Exception:
                    pass
            else:
                print(msg)
        prev = cur

if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("사용법: monitor.py <pid> [threshold]")
        sys.exit(1)
    pid = int(sys.argv[1]); thr = int(sys.argv[2]) if len(sys.argv) > 2 else 5000
    monitor(pid, threshold=thr)

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205

// Kubernetes CRI 구현에서 PCB 정보 활용 예시
package main

import (
    "fmt"
    "os"
    "strconv"
    "strings"
    "time"
    "context"
    "path/filepath"
)

// ContainerStats는 PCB 정보 기반 컨테이너 통계를 나타냄
type ContainerStats struct {
    ContainerID string
    PID         int
    CPUUsage    CPUStats    // PCB의 utime, stime 필드 기반
    MemoryUsage MemoryStats // PCB의 mm 구조체 정보 기반
    ProcessCount int        // PCB 기반 프로세스/스레드 개수
}

type CPUStats struct {
    UserTime   uint64 // PCB의 utime 필드
    SystemTime uint64 // PCB의 stime 필드
    TotalTime  uint64
}

type MemoryStats struct {
    VirtualSize uint64 // PCB->mm의 가상 메모리 크기
    ResidentSet uint64 // PCB->mm의 실제 메모리 사용량
    SharedMem   uint64 // 공유 메모리 크기
}

// CRIStatsCollector는 PCB 정보를 수집하는 CRI 구현체
type CRIStatsCollector struct {
    containers map[string]int // containerID -> PID 매핑
}

func NewCRIStatsCollector() *CRIStatsCollector {
    return &CRIStatsCollector{
        containers: make(map[string]int),
    }
}

// RegisterContainer는 새로운 컨테이너 프로세스 등록
// 실제로는 컨테이너 런타임이 프로세스 생성 시 호출
func (c *CRIStatsCollector) RegisterContainer(containerID string, pid int) {
    c.containers[containerID] = pid
    fmt.Printf("컨테이너 등록: %s (PID: %d)\n", containerID, pid)
}

// readProcStat은 /proc/[pid]/stat에서 PCB 정보를 읽어옴
func (c *CRIStatsCollector) readProcStat(pid int) (*CPUStats, error) {
    statFile := fmt.Sprintf("/proc/%d/stat", pid)
    data, err := os.ReadFile(statFile)
    if err != nil {
        return nil, fmt.Errorf("PCB stat 파일 읽기 실패: %v", err)
    }
    
    fields := strings.Fields(string(data))
    if len(fields) < 15 {
        return nil, fmt.Errorf("PCB stat 파일 형식 오류")
    }
    
    // PCB 구조체의 CPU 시간 필드들을 파싱
    utime, _ := strconv.ParseUint(fields[13], 10, 64)  // PCB의 utime 필드
    stime, _ := strconv.ParseUint(fields[14], 10, 64)  // PCB의 stime 필드
    
    return &CPUStats{
        UserTime:  utime,
        SystemTime: stime,
        TotalTime: utime + stime,
    }, nil
}

// readProcStatus는 /proc/[pid]/status에서 메모리 정보를 읽어옴
func (c *CRIStatsCollector) readProcStatus(pid int) (*MemoryStats, error) {
    statusFile := fmt.Sprintf("/proc/%d/status", pid)
    data, err := os.ReadFile(statusFile)
    if err != nil {
        return nil, fmt.Errorf("PCB status 파일 읽기 실패: %v", err)
    }
    
    lines := strings.Split(string(data), "\n")
    stats := &MemoryStats{}
    
    for _, line := range lines {
        fields := strings.Fields(line)
        if len(fields) < 2 {
            continue
        }
        
        switch fields[0] {
        case "VmSize:": // PCB->mm 구조체의 가상 메모리 크기
            if len(fields) >= 2 {
                if val, err := strconv.ParseUint(fields[1], 10, 64); err == nil {
                    stats.VirtualSize = val * 1024 // KB to bytes
                }
            }
        case "VmRSS:": // PCB->mm 구조체의 실제 메모리 사용량
            if len(fields) >= 2 {
                if val, err := strconv.ParseUint(fields[1], 10, 64); err == nil {
                    stats.ResidentSet = val * 1024 // KB to bytes
                }
            }
        case "RssAnon:": // 프로세스 고유 메모리
            // PCB를 통해 추적되는 프로세스별 메모리 사용량
        }
    }
    
    return stats, nil
}

// GetContainerStats는 특정 컨테이너의 PCB 기반 통계를 반환
func (c *CRIStatsCollector) GetContainerStats(containerID string) (*ContainerStats, error) {
    pid, exists := c.containers[containerID]
    if !exists {
        return nil, fmt.Errorf("컨테이너 %s를 찾을 수 없음", containerID)
    }
    
    // PCB 정보 기반 CPU 통계 수집
    cpuStats, err := c.readProcStat(pid)
    if err != nil {
        return nil, fmt.Errorf("CPU 통계 수집 실패: %v", err)
    }
    
    // PCB 정보 기반 메모리 통계 수집
    memStats, err := c.readProcStatus(pid)
    if err != nil {
        return nil, fmt.Errorf("메모리 통계 수집 실패: %v", err)
    }
    
    // 프로세스/스레드 개수 계산 (PCB 기반)
    taskDir := fmt.Sprintf("/proc/%d/task", pid)
    entries, err := os.ReadDir(taskDir)
    processCount := 0
    if err == nil {
        processCount = len(entries) // 각 스레드는 별도의 PCB를 가짐
    }
    
    return &ContainerStats{
        ContainerID:  containerID,
        PID:          pid,
        CPUUsage:     *cpuStats,
        MemoryUsage:  *memStats,
        ProcessCount: processCount,
    }, nil
}

// MonitorContainers는 모든 등록된 컨테이너의 PCB 정보를 주기적으로 수집
func (c *CRIStatsCollector) MonitorContainers(ctx context.Context, interval time.Duration) {
    ticker := time.NewTicker(interval)
    defer ticker.Stop()
    
    for {
        select {
        case <-ctx.Done():
            fmt.Println("모니터링 종료")
            return
        case <-ticker.C:
            fmt.Printf("\n=== PCB 기반 컨테이너 통계 [%s] ===\n", 
                      time.Now().Format("15:04:05"))
            
            for containerID := range c.containers {
                stats, err := c.GetContainerStats(containerID)
                if err != nil {
                    fmt.Printf("컨테이너 %s 통계 수집 실패: %v\n", 
                              containerID, err)
                    continue
                }
                
                // PCB 정보 기반 통계 출력
                fmt.Printf("컨테이너: %s (PID: %d)\n", 
                          stats.ContainerID, stats.PID)
                fmt.Printf("  CPU: User=%d, System=%d (PCB utime/stime)\n", 
                          stats.CPUUsage.UserTime, stats.CPUUsage.SystemTime)
                fmt.Printf("  메모리: Virtual=%dMB, RSS=%dMB (PCB mm 구조체)\n", 
                          stats.MemoryUsage.VirtualSize/1024/1024,
                          stats.MemoryUsage.ResidentSet/1024/1024)
                fmt.Printf("  프로세스/스레드 수: %d (PCB 기반)\n", 
                          stats.ProcessCount)
            }
        }
    }
}

// 사용 예시 - Kubernetes CRI 시뮬레이션
func main() {
    collector := NewCRIStatsCollector()
    
    // 현재 프로세스를 컨테이너로 등록 (시뮬레이션)
    currentPID := os.Getpid()
    collector.RegisterContainer("nginx-container-1", currentPID)
    
    // 컨텍스트 생성
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()
    
    // PCB 기반 모니터링 시작
    fmt.Println("Kubernetes CRI PCB 모니터링 시작…")
    fmt.Println("각 컨테이너의 PCB 정보를 5초마다 수집합니다.")
    
    collector.MonitorContainers(ctx, 5*time.Second)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# Kubernetes Pod 내 프로세스 관리 예시(설정 중심)
apiVersion: v1
kind: Pod
metadata:
  name: pcb-managed-demo
spec:
  containers:
    - name: demo-container
      image: pcb-demo:latest
      resources:
        limits:
          cpu: "500m"
          memory: "256Mi"
      # 주제명: 프로세스 제어 및 상태 관리 관련 설정 포함

1
2
3
4
5

# 목적: 스케줄러 컨텍스트 스위치 이벤트를 태스크명 기준 집계
sudo bpftrace -e '
tracepoint:sched:sched_switch
/ pid != 0 /
{ @cswitch[comm] = count(); }'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

# 이 설정은 노드 단위로 컨텍스트 스위치 이벤트를 수집하기 위한 것(eBPF 필요)
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: ebpf-cswitch-agent
spec:
  selector:
    matchLabels: {app: ebpf-cswitch-agent}
  template:
    metadata:
      labels: {app: ebpf-cswitch-agent}
    spec:
      hostPID: true
      containers:
        - name: agent
          image: bpftrace/bpftrace:latest
          securityContext:
            privileged: true   # eBPF 로딩 필요. 보안검토 필수
          command: ["bash","-lc","bpftrace -e 'tracepoint:sched:sched_switch { @cswitch[comm] = count(); }'"]
          resources: {limits: {cpu: "200m", memory: "256Mi"}}
      nodeSelector: {"kubernetes.io/os": linux}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

import json
import time
from datetime import datetime
import socket

# PCB 구조체
class PCB:
    def __init__(self, pid, state, pc):
        self.pid = pid
        self.state = state
        self.program_counter = pc
        self.last_updated = datetime.now().isoformat()

    def to_dict(self):
        return vars(self)

# PCB 복제 전송 함수
def replicate_pcb(pcb, target_ip, target_port):
    """
    PCB 데이터를 JSON으로 직렬화 후 소켓을 통해 전송
    """
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect((target_ip, target_port))
    s.send(json.dumps(pcb.to_dict()).encode())
    s.close()
    print(f"[{datetime.now()}] PCB 복제 완료 → {target_ip}:{target_port}")

# 테스트 실행
if __name__ == "__main__":
    pcb1 = PCB(101, "running", 55)
    replicate_pcb(pcb1, "192.168.0.2", 9000)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

// PCB 기반 메트릭 수집 구조체
type PCBMetrics struct {
    ProcessCount    int64     // 현재 프로세스 수
    ZombieCount     int64     // 좀비 프로세스 수
    ContextSwitches int64     // 컨텍스트 스위치 횟수
    MemoryUsage     int64     // PCB 메모리 사용량
    CPUTime         int64     // 총 CPU 시간
    
    // 프로세스별 상세 메트릭
    ProcessMetrics  map[int]ProcessMetric
}

type ProcessMetric struct {
    PID           int       // PCB의 PID 필드
    State         string    // PCB의 state 필드  
    CPUPercent    float64   // CPU 사용률
    MemoryBytes   int64     // 메모리 사용량 (PCB->mm 정보)
    OpenFiles     int       // 열린 파일 수
    Threads       int       // 스레드 수
    LastUpdate    time.Time // 마지막 업데이트 시간
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241

#!/usr/bin/env python3
"""
PCB 성능 최적화 모니터링 도구
- 시스템 성능 지표 실시간 추적
- 최적화 포인트 자동 탐지 및 권장사항 제공
"""

import time
import psutil
import numpy as np
from dataclasses import dataclass
from typing import List, Dict, Tuple

@dataclass
class PerformanceMetrics:
    """PCB 관련 성능 메트릭"""
    context_switches_per_sec: float    # 초당 컨텍스트 스위치 수
    process_creation_rate: float       # 초당 프로세스 생성률
    memory_usage_mb: float            # PCB 메모리 사용량 (MB)
    cpu_utilization: float            # CPU 사용률
    zombie_process_count: int         # 좀비 프로세스 수
    average_process_memory: float     # 프로세스당 평균 메모리 사용량

class PCBPerformanceOptimizer:
    """PCB 성능 최적화 도구"""
    
    def __init__(self):
        self.metrics_history: List[PerformanceMetrics] = []
        self.optimization_recommendations: List[str] = []
        
    def collect_metrics(self) -> PerformanceMetrics:
        """
        현재 시스템의 PCB 관련 성능 메트릭 수집
        - /proc/stat의 컨텍스트 스위치 정보 활용
        - 프로세스 목록에서 PCB 관련 정보 추출
        """
        # 시스템 통계 정보 수집
        cpu_percent = psutil.cpu_percent(interval=1)
        memory_info = psutil.virtual_memory()
        
        # 프로세스 정보 수집 (각 프로세스는 PCB로 관리됨)
        processes = list(psutil.process_iter(['pid', 'status', 'memory_info']))
        
        # 좀비 프로세스 수 계산 (PCB state == 'Z')
        zombie_count = sum(1 for p in processes 
                          if p.info['status'] == psutil.STATUS_ZOMBIE)
        
        # 평균 프로세스 메모리 사용량 계산
        total_memory = sum(p.info['memory_info'].rss for p in processes 
                          if p.info['memory_info'] is not None)
        avg_process_memory = total_memory / len(processes) if processes else 0
        
        # 컨텍스트 스위치 정보 수집
        with open('/proc/stat', 'r') as f:
            for line in f:
                if line.startswith('ctxt'):
                    # 이전 측정값과 비교하여 초당 컨텍스트 스위치 계산
                    current_switches = int(line.split()[1])
                    context_switches_rate = self._calculate_rate(
                        current_switches, 'context_switches'
                    )
                    break
            else:
                context_switches_rate = 0
        
        # 프로세스 생성률 계산
        current_process_count = len(processes)
        process_creation_rate = self._calculate_rate(
            current_process_count, 'process_count'
        )
        
        return PerformanceMetrics(
            context_switches_per_sec=context_switches_rate,
            process_creation_rate=process_creation_rate,
            memory_usage_mb=memory_info.used / (1024 * 1024),
            cpu_utilization=cpu_percent,
            zombie_process_count=zombie_count,
            average_process_memory=avg_process_memory / (1024 * 1024)  # MB
        )
    
    def _calculate_rate(self, current_value: float, metric_name: str) -> float:
        """이전 값과 비교하여 변화율 계산"""
        if not hasattr(self, '_previous_values'):
            self._previous_values = {}
            self._previous_time = time.time()
        
        if metric_name not in self._previous_values:
            self._previous_values[metric_name] = current_value
            return 0
        
        current_time = time.time()
        time_diff = current_time - self._previous_time
        value_diff = current_value - self._previous_values[metric_name]
        
        rate = value_diff / time_diff if time_diff > 0 else 0
        
        self._previous_values[metric_name] = current_value
        self._previous_time = current_time
        
        return rate
    
    def analyze_performance(self, metrics: PerformanceMetrics) -> List[str]:
        """
        성능 메트릭 분석 및 최적화 권장사항 생성
        - PCB 관련 성능 병목 구간 탐지
        - 최적화 우선순위 결정
        """
        recommendations = []
        
        # 컨텍스트 스위칭 빈도 분석
        if metrics.context_switches_per_sec > 10000:
            recommendations.append(
                f"⚠️ 높은 컨텍스트 스위치 율 ({metrics.context_switches_per_sec:f}/sec)\n"
                "   권장사항: 프로세스 수 감소, CPU 친화성 설정, 스케줄링 정책 최적화"
            )
        
        # 좀비 프로세스 탐지
        if metrics.zombie_process_count > 0:
            recommendations.append(
                f"⚠️ 좀비 프로세스 탐지 ({metrics.zombie_process_count}개)\n"
                "   권장사항: 부모 프로세스의 wait() 호출 확인, 프로세스 정리 스크립트 실행"
            )
        
        # 메모리 사용량 분석
        if metrics.average_process_memory > 100:  # 100MB 이상
            recommendations.append(
                f"⚠️ 높은 프로세스당 메모리 사용량 ({metrics.average_process_memory:f}MB)\n"
                "   권장사항: 메모리 누수 확인, 프로세스 최적화, 메모리 풀링 고려"
            )
        
        # 프로세스 생성률 분석
        if metrics.process_creation_rate > 10:  # 초당 10개 이상
            recommendations.append(
                f"⚠️ 높은 프로세스 생성률 ({metrics.process_creation_rate:f}/sec)\n"
                "   권장사항: 프로세스 풀링, 스레드 사용 고려, fork() 호출 최적화"
            )
        
        # CPU 사용률 분석
        if metrics.cpu_utilization > 80:
            recommendations.append(
                f"⚠️ 높은 CPU 사용률 ({metrics.cpu_utilization:f}%)\n"
                "   권장사항: 프로세스 부하 분산, 스케줄링 정책 조정, 하드웨어 증설 고려"
            )
        
        return recommendations
    
    def suggest_optimizations(self, history_length: int = 10) -> Dict[str, str]:
        """
        성능 기록 분석을 통한 장기적 최적화 제안
        - 성능 트렌드 분석
        - 주기적 패턴 탐지
        """
        if len(self.metrics_history) < history_length:
            return {"status": "데이터 수집 중… 더 많은 데이터가 필요합니다."}
        
        recent_metrics = self.metrics_history[-history_length:]
        optimizations = {}
        
        # 컨텍스트 스위치 트렌드 분석
        cs_rates = [m.context_switches_per_sec for m in recent_metrics]
        cs_trend = np.polyfit(range(len(cs_rates)), cs_rates, 1)[0]
        
        if cs_trend > 100:  # 증가 추세
            optimizations["context_switching"] = (
                "컨텍스트 스위칭이 지속적으로 증가하고 있습니다. "
                "프로세스 아키텍처 재검토가 필요합니다."
            )
        
        # 메모리 사용량 트렌드 분석
        memory_usage = [m.average_process_memory for m in recent_metrics]
        memory_trend = np.polyfit(range(len(memory_usage)), memory_usage, 1)[0]
        
        if memory_trend > 1:  # MB/측정주기
            optimizations["memory_management"] = (
                "프로세스 메모리 사용량이 지속적으로 증가하고 있습니다. "
                "메모리 누수 검사와 가비지 컬렉션 최적화를 권장합니다."
            )
        
        # 좀비 프로세스 패턴 분석
        zombie_counts = [m.zombie_process_count for m in recent_metrics]
        if any(count > 0 for count in zombie_counts):
            optimizations["process_cleanup"] = (
                "주기적으로 좀비 프로세스가 발생하고 있습니다. "
                "프로세스 생명주기 관리를 개선해야 합니다."
            )
        
        return optimizations
    
    def run_optimization_analysis(self, duration_minutes: int = 5):
        """지정된 시간 동안 성능 모니터링 및 최적화 분석 실행"""
        print(f"PCB 성능 최적화 분석 시작 ({duration_minutes}분간)")
        print("=" * 60)
        
        end_time = time.time() + (duration_minutes * 60)
        measurement_count = 0
        
        while time.time() < end_time:
            # 메트릭 수집
            metrics = self.collect_metrics()
            self.metrics_history.append(metrics)
            measurement_count += 1
            
            # 실시간 분석
            recommendations = self.analyze_performance(metrics)
            
            # 결과 출력
            print(f"\n[측정 #{measurement_count}] {time.strftime('%H:%M:%S')}")
            print(f"컨텍스트 스위치: {metrics.context_switches_per_sec:f}/sec")
            print(f"프로세스 생성률: {metrics.process_creation_rate:f}/sec")
            print(f"좀비 프로세스: {metrics.zombie_process_count}개")
            print(f"CPU 사용률: {metrics.cpu_utilization:f}%")
            print(f"프로세스당 평균 메모리: {metrics.average_process_memory:f}MB")
            
            if recommendations:
                print("\n📋 즉시 조치 권장사항:")
                for rec in recommendations:
                    print(f"  {rec}")
            
            time.sleep(10)  # 10초 간격 측정
        
        # 최종 최적화 제안
        print("\n" + "=" * 60)
        print("📊 장기적 최적화 분석 결과")
        print("=" * 60)
        
        long_term_opts = self.suggest_optimizations()
        for category, suggestion in long_term_opts.items():
            print(f"\n🔧 {category.replace('_', ' ').title()}:")
            print(f"   {suggestion}")

# 사용 예시
if __name__ == "__main__":
    optimizer = PCBPerformanceOptimizer()
    
    try:
        # 5분간 성능 모니터링 및 최적화 분석
        optimizer.run_optimization_analysis(duration_minutes=5)
    except KeyboardInterrupt:
        print("\n분석을 중단합니다.")
    
    print(f"\n총 {len(optimizer.metrics_history)}개의 성능 데이터 포인트를 수집했습니다.")