그림으로 배우는 리눅스 구조 3장. 프로세스 스케줄러

출처: 그림으로 배우는 리눅스 구조

시스템에 존재하는 프로세스는 대부분 슬립 상태

프로세스 스케줄러 : 프로세스에 CPU 자원 할당을 담당하는 리눅스 커널 기능(이하 스케줄러)

하나의 논리 CPU는 동시에 하나의 프로세스만 처리

실행 가능한 여러 프로세스가 타임 슬라이스 단위로 순서대로 CPU를 사용

p0, p1, p2 프로세스

기본 지식: 경과 시간과 사용 시간

경과 시간(real) : 프로세스가 시작부터 종료할 때까지 경과한 시간

사용 시간(user+sys) : 프로세스가 실제로 논리 CPU를 사용한 시간

경과시간(real) ≒ 사용시간(user+sys)

time : 프로세스의 시작부터 종료까지 경과시간과 사용시간을 알 수 있다.

#!/usr/bin/python3

# 부하 정도를 조절하는 값.
# time 명령어를 사용해서 실행했을 때 몇 초 정도에 끝나도록 조절하면 결과를 확인하기 좋음
NLOOP=100000000

for _ in range(NLOOP):
    pass

CPU 자원을 소모하는 예제

real	0m1.523s # 경과시간
user	0m1.519s # 사용시간 : 사용자 공간에서 동작한 시간
sys	0m0.004s   # 사용시간 : 시스템 콜로인해 늘어난 커널이 동작한 시간

sleep은 CPU 거의 사용 안 함

논리 CPU 하나만 사용하는 경우

multiload.sh

#!/bin/bash

MULTICPU=0
PROGNAME=$0
SCRIPT_DIR=$(cd $(dirname $0) && pwd)

usage() {
    exec >&2
    echo "사용법: $PROGNAME [-m] <프로세스 개수>
    일정 시간 동작하는 부하 처리 프로세스를 <프로세스 개수>로 지정한 만큼 동작시켜서 모두 끝날 때까지 기다립니다.
    각 프로세스 실행에 걸린 시간을 출력합니다.
    기본값은 모든 프로세스가 1개의 논리 CPU에서 동작합니다.

옵션 설명:
    -m: 각 프로세스를 여러 CPU에서 동작시킵니다."
    exit 1
}

while getopts "m" OPT ; do
    case $OPT in
        m)
            MULTICPU=1
            ;;
        \?)
            usage
            ;;
    esac
done

shift $((OPTIND - 1))

if [ $# -lt 1 ] ; then
    usage
fi

CONCURRENCY=$1

if [ $MULTICPU -eq 0 ] ; then
    # 부하 처리를 CPU0에서만 실행시킴
    taskset -p -c 0 $$ >/dev/null
fi

for ((i=0;i<CONCURRENCY;i++)) do
    time "${SCRIPT_DIR}/load.py" &
done

for ((i=0;i<CONCURRENCY;i++)) do
    wait
done

프로세스를 1개로 지정해서 실행 → load 프로그램 실행 결과와 거의 동일하다.

동시 실행을 2, 3세개로 늘렸을 때는

스케줄러가 각 프로세스에 순서대로 CPU 자원을 할당하기 때문에 전체 실행 시간은 프로세스 개수에 비례한다.

논리 CPU 여러 개를 사용하는 경우

multiload.sh에 -m 옵션을 지정해서 실행하면 스케줄러가 부하 처리를 모든 논리 CPU에 균등하게 분배한다.

모든 프로세스에서 real과 user+sys 값이 거의 같다.

→ 프로세스마다 각각의 논리 CPU 자원을 독점했다는 뜻이다.

real보다 user+sys가 커지는 경우

real ≥ user + sys 일 것 같지만

실제로는 user + sys가 real 값보다 조금 더 큰 경우가 있다.

→ 측정 정밀도가 그다지 높지 않기 때문에 너무 신경 쓸 필요 ㄴㄴ

$ time ./multiload.sh -m 2

real	0m1.580s
user	0m1.576s
sys	0m0.004s

real	0m1.684s
user	0m1.683s
sys	0m0.000s

real	0m1.696s
user	0m3.266s
sys	0m0.011s

1, 2 : 부하처리 프로세스에 관련된 데이터

3 : 프로그램 그 자체에 관련된 데이터

time 명령어로 얻은 user와 sys 값은 정보 확인 대상의 프로세스 및 종료된 자식 프로세스의 값을 더한 값이다. 따라서 어떤 프로세스가 자식 프로세스를 생성하고 각각 다른 논리 CPU에서 동작한다면 real보다 user+sys 값이 커질 수 있다.

multiload.sh가 여기에 해당.

타임 슬라이스

타임 슬라이스 : CPU 스케줄링에서 각 프로세스가 CPU를 사용하는 시간을 나누는 단위

sched.py

#!/usr/bin/python3

import sys
import time
import os
import plot_sched

def usage():
    print("""사용법: {} <프로세스 개수>
        * 논리 CPU0에서 <프로세스 개수>만큼 동시에 100밀리초 동안 CPU 자원을 소비하는 부하 처리 프로세스를 기동하고 모든 프로세스 종료를 기다립니다.
        * 'sched-<프로세스 개수>.jpg' 파일에 실행 결과를 표시한 그래프를 저장합니다.
        * 그래프 x축은 부하 처리 프로세스의 경과 시간[밀리초], y축은 진척도[%]""".format(progname, file=sys.stderr))
    sys.exit(1)

# 실험에 알맞는 부하 정도를 찾기 위한 전처리에 걸리는 부하
# 너무 시간이 걸리면 더 작은 값을 사용
# 너무 빨리 끝나면 더 큰 값을 사용
NLOOP_FOR_ESTIMATION=100000000
nloop_per_msec = None
progname = sys.argv[0]

def estimate_loops_per_msec():
    before = time.perf_counter()
    for _ in  range(NLOOP_FOR_ESTIMATION):
        pass
    after = time.perf_counter()
    return int(NLOOP_FOR_ESTIMATION/(after-before)/1000)

def child_fn(n):
    progress = 100*[None]
    for i in range(100):
        for j in range(nloop_per_msec):
            pass
        progress[i] = time.perf_counter()
    f = open("{}.data".format(n),"w")
    for i in range(100):
        f.write("{}\t{}\n".format((progress[i]-start)*1000,i))
    f.close()
    exit(0)

if len(sys.argv) < 2:
    usage()

concurrency = int(sys.argv[1])

if concurrency < 1:
    print("<동시 실행>은 1이상의 정수를 사용합니다: {}".format(concurrency))
    usage()

# 강제로 논리 CPU0에서 실행
os.sched_setaffinity(0, {0})

nloop_per_msec = estimate_loops_per_msec()

start = time.perf_counter()

for i in range(concurrency):
    pid = os.fork()
    if (pid < 0):
        exit(1)
    elif pid == 0:
        child_fn(i)

for i in range(concurrency):
    os.wait()

plot_sched.plot_sched(concurrency)

plot_sched.py

#!/usr/bin/python3

import numpy as np
from PIL import Image
import matplotlib
import os

matplotlib.use('Agg')

import matplotlib.pyplot as plt

plt.rcParams['font.family'] = "NanumGothic"
plt.rcParams['axes.unicode_minus'] = False

def plot_sched(concurrency):
    fig = plt.figure()
    ax = fig.add_subplot(1,1,1)
    for i in range(concurrency):
        x, y = np.loadtxt("{}.data".format(i), unpack=True)
        ax.scatter(x,y,s=1)
    ax.set_title("타임 슬라이스 가시화(동시 실행={})".format(concurrency))
    ax.set_xlabel("경과 시간[밀리초]")
    ax.set_xlim(0)
    ax.set_ylabel("진척도[%]")
    ax.set_ylim([0,100])
    legend = []
    for i in range(concurrency):
        legend.append("부하 처리"+str(i))
    ax.legend(legend)

    # Ubuntu 20.04의 matplotlib 버그를 회피하기 위해 일단 png 파일로 저장한 후에 jpg로 변환
    # https://bugs.launchpad.net/ubuntu/+source/matplotlib/+bug/1897283?comments=all
    pngfilename = "sched-{}.png".format(concurrency)
    jpgfilename = "sched-{}.jpg".format(concurrency)
    fig.savefig(pngfilename)
    Image.open(pngfilename).convert("RGB").save(jpgfilename)
    os.remove(pngfilename)

def plot_avg_tat(max_nproc):
    fig = plt.figure()
    ax = fig.add_subplot(1,1,1)
    x, y, _ = np.loadtxt("cpuperf.data", unpack=True)
    ax.scatter(x,y,s=1)
    ax.set_xlim([0, max_nproc+1])
    ax.set_xlabel("프로세스 개수")
    ax.set_ylim(0)
    ax.set_ylabel("평균 턴어라운드 타임[초]")

    # Ubuntu 20.04의 matplotlib 버그를 회피하기 위해 일단 png 파일로 저장한 후에 jpg로 변환
    # https://bugs.launchpad.net/ubuntu/+source/matplotlib/+bug/1897283?comments=all
    pngfilename = "avg-tat.png"
    jpgfilename = "avg-tat.jpg"
    fig.savefig(pngfilename)
    Image.open(pngfilename).convert("RGB").save(jpgfilename)
    os.remove(pngfilename)

def plot_throughput(max_nproc):
    fig = plt.figure()
    ax = fig.add_subplot(1,1,1)
    x, _, y = np.loadtxt("cpuperf.data", unpack=True)
    ax.scatter(x,y,s=1)
    ax.set_xlim([0, max_nproc+1])
    ax.set_xlabel("프로세스 개수")
    ax.set_ylim(0)
    ax.set_ylabel("스루풋[프로세스/초]")

    # Ubuntu 20.04의 matplotlib 버그를 회피하기 위해 일단 png 파일로 저장한 후에 jpg로 변환
    # https://bugs.launchpad.net/ubuntu/+source/matplotlib/+bug/1897283?comments=all
    pngfilename = "throughput.png"
    jpgfilename = "throughput.jpg"
    fig.savefig(pngfilename)
    Image.open(pngfilename).convert("RGB").save(jpgfilename)
    os.remove(pngfilename)

for i in 1 2 3; do ./sched.py $i; done

해석
해당 명령어는 쉘 스크립트나 명령어 루프에서 사용되는 일반적인 구조입니다. 이 명령어는 for 루프를 사용하여 숫자 1, 2, 3을 순차적으로 변수 i에 할당하고, ./sched.py 스크립트에 이 변수를 전달하여 실행합니다. 목적은 ./sched.py 스크립트를 1, 2 및 3과 같은 다른 인수와 함께 세 번 실행하는 것입니다.
구체적으로 명령어를 분석하면 다음과 같습니다:
1. for i in 1 2 3; : 이 부분은 1, 2 및 3과 같은 숫자를 순차적으로 변수 i에 할당합니다.
1. do : 루프의 본문이 시작됨을 나타냅니다.
1. ./sched.py $i : $i는 변수 i의 값을 나타냅니다. 따라서 첫 번째 반복에서는 ./sched.py 1, 두 번째 반복에서는 ./sched.py 2, 세 번째 반복에서는 ./sched.py 3과 같이 ./sched.py 스크립트를 실행합니다.
1. done : 루프가 종료됨을 나타냅니다.
따라서 이 명령어는 ./sched.py 스크립트를 숫자 1, 2 및 3과 함께 세 번 실행합니다. 이를 통해 스크립트는 서로 다른 입력 매개변수와 함께 여러 번 실행될 수 있으며, 결과는 스크립트에 따라 다를 수 있습니다.

<실행 결과>

→ 1개의 논리 CPU에서 여러 처리를 동시에 실행하는 경우, 각각의 처리는 수밀리초 단위의 타임 슬라이스로 쪼개서 CPU를 교대로 사용하는 걸 알 수 있다.

Column) 타임 슬라이스 구조

리눅스 스케줄러는 sysctl의 kernel.sched_latency_ns에 지정한 목표 레이턴시 간격에 한 번씩 CPU 시간을 얻을 수 있다.

각 프로세스의 타임 슬라이스 = kernel.sched_latency_ns / <논리 CPU에 실행 중 또는 실행 가능 상태인 프로세스 개수>

어떤 논리 CPU에서 실행 가능한 프로세스가 2~4개일 때 목표 레이턴시와 타임 슬라이스 관계

⇒ 요즘 사용하는 스케줄러는 프로세스 개수에 따라 타임 슬라이스를 동적으로 변경함.(옛날에는 고정값이었음)

nice : 프로세스 우선도 값

부하처리 0이 부하처리 1보다 타임 슬라이스를 많이 가져갔다.

%nice : nice 값이 기본값 0보다 커진 프로세스가 사용자 모드로 실행된 시간

%user : nice값 0인 경우

💡스케줄러 구현 내용은 POSIX 사양으로 정해진 내용이 아니므로 커널 버진이 바뀌면 변할 가능성이 있다. ex. kernel.sched_latency_ns 기본값은 지금까지 몇 번씩 바뀌었다고 함. 앞으로 어떻게 바뀔지 모르니 주의하기

컨텍스트 스위치

컨텍스트 스위치 : 논리 CPU에서 동작하는 프로세스가 전환되는 것

컨텍스트 스위치는 프로세스가 어떤 코드를 실행하고 있든 간에 타임 슬라이스가 끝나면 반드시 발생된다.

foo() 직후에 bar()가 실행된다는 보장 X

처리에 생각보다 많은 시간이 걸릴 때, ‘처리 자체에 무슨 문제가 있는 게 분명하다’고 단순히 결론 내리기보다는 ‘처리를 하다가 컨텍스트 스위치가 발생해서 다른 프로세스가 동작했을 가능성이 있을지도 모른다.’라는 관점으로 볼 수 있다.

처리 성능

턴어라운드 타임 : 처리 시간. 시스템에 처리를 요청했을 때부터 처리가 끝날 때까지 걸린 시간

스루풋 : 처리량. 단위 시간당 처리를 끝낸 개수.

논리 CPU 1개만 사용하고 최대 프로세스 개수를 8로 지정해서 부하 처리 프로세스를 실행

평균 턴어라운드 타임 : 모든 부하 처리의 real 값의 평균

스루풋 : 프로세스 개수를 multiload.sh 프로그램의 real값으로 나눈 값

./cpuperf.sh 8

프로세스 개수 ↑ → 컨텍스트 스위치도 많아짐 → 평균 처리시간 ↑, 스루풋은 떨어짐 ↓

→ CPU를 다 쓰고 있다면 프로세스 개수만 늘린다고 성능 문제 해결 안됨(컨텍스트 스위칭 때문에)

응답 성능이 중요한 시스템이라면 스루풋이 중요한 시스템에 비해서 시스템을 구성하는 각기기의 CPU 사용률을 적게 유지하는 것이 중요

아래는 모든 논리 CPU를 사용해서 성능 데이터를 수집.

논리 CPU 개수 확인 : grep -c processor /proc/cpuinfo

./cpuperf.sh -m 8

프로세스 개수가 논리 CPU개수(여기서는 4)와 같아질 때까지는 평균 처리 시간이 천천히 늘어나지만 → 한 논리 CPU에 한 개의 프로세스

그 후는 갑자기 길어진다. → 한 논리 CPU가 여러 개의 프로세스 담당

스루풋은 프로세스 개수와 논리 CPU 개수와 같아질 때까지 향상되지만 그 후에는 한풀 꺾인다.

✅

<정리>

논리 CPU가 많이 내장된 경우라도 충분한 수의 프로세스가 실행되어야 비로소 스루풋이 향상된다.

무조건 프로세스 개수를 늘린다고 스루풋은 개선되지 않는다.

프로그램 병렬 실행의 중요성

이제는 더 이상 논리 CPU당 성능(싱글 스레드 성능)이 향상되기 어려운 단계까지옴.

→ 대신 CPU 코어 개수를 늘려서 CPU 전체 성능을 끌어올리는 쪽으로 방향이 바뀜.

커널도 이런 시대 흐름에 맞춰서 코어 개수가 늘어난 경우의 확장성 을 향상시켜 왔다고함.

❓퀴즈

퀴즈: 프로세스와 시스템 스케줄링

프로세스의 어떤 상태는 대부분 어떤 상태인가?
a) 실행 상태
b) 대기 상태
c) 슬립 상태
d) 준비 상태

논리 CPU는 동시에 몇 개의 프로세스를 처리할 수 있는가?
a) 1개
b) 2개
c) 4개
d) 8개

프로세스 스케줄러의 주요 역할은 무엇인가?
a) 파일 관리
b) 메모리 할당
c) CPU 자원 할당
d) 네트워크 관리

어떤 시간은 프로세스가 시작부터 종료할 때까지 경과한 시간을 나타낸다?
a) 사용 시간
b) 시스템 시간
c) 경과 시간
d) 대기 시간

time 명령어를 사용하여 어떤 정보를 확인할 수 있는가?
a) 사용자 이름
b) 파일 크기
c) 경과시간과 사용시간
d) 네트워크 연결 상태

CPU 자원을 소모하는 코드 예제가 주어졌을 때, real, user, sys 시간 중 어떤 시간은 사용자 공간에서 동작한 시간을 나타낼까?
a) real
b) user
c) sys

sleep 명령어의 특징은 무엇인가?
a) CPU 자원을 많이 사용함
b) CPU 자원을 전혀 사용하지 않음
c) 파일을 삭제하는 명령어
d) 네트워크 연결을 설정하는 명령어

답변을 기다립니다!

이해하신 내용을 기반으로 아래의 10개의 퀴즈 문제를 제시합니다:

컨텍스트 스위치는 언제 발생하는가?

컨텍스트 스위치는 어떤 역할을 하는가?

컨텍스트 스위치가 발생할 때, 현재 실행 중인 프로세스는 어떤 상태에 있는가?

컨텍스트 스위치가 발생하면 어떤 일이 일어나는가?

컨텍스트 스위치가 발생하는 이유 중 하나는 무엇인가?

턴어라운드 타임이 무엇을 의미하는가?

스루풋이란 무엇인가?

프로세스 개수를 늘릴 때 스루풋과 평균 턴어라운드 타임에 어떤 영향을 미치는가?

논리 CPU의 개수와 프로세스 개수 간의 관계에 대한 어떤 관찰이 있나?

왜 CPU 코어 개수를 늘리는 것이 성능 향상에 더 중요한가?

이러한 질문들을 사용하여 퀴즈나 테스트를 만들어 더 자세히 다루실 수 있습니다.

물론, 더 많은 퀴즈를 제공해 드리겠습니다:

컨텍스트 스위치와 처리 성능 간의 관계를 설명하십시오.

프로세스 개수를 증가시키면 어떻게 컨텍스트 스위치가 영향을 미치는가?

컨텍스트 스위치와 응답 성능 간의 관련성을 설명하십시오.

논리 CPU와 물리 CPU의 차이는 무엇인가?

프로세스 개수가 논리 CPU 개수와 같을 때, 어떤 현상이 관찰되는가?

스루풋이 어떻게 측정되는가?

프로세스 개수를 늘릴 때 스루풋이 왜 감소하는지 설명하십시오.

스루풋이 개선되지 않을 때 어떻게 시스템을 최적화할 수 있는가?

CPU 코어 개수를 늘리는 것이 왜 논리 CPU의 성능 향상보다 중요한가?

커널이 코어 개수를 늘린 경우의 확장성을 개선하는 방법은 무엇인가?

이러한 질문을 사용하여 컨텍스트 스위치와 처리 성능, CPU 성능 및 시스템 최적화 관련 지식을 테스트할 수 있습니다.

Uploaded by N2T

그림으로 배우는 리눅스 구조 6장. 장치 접근 (0)	2024.02.09
그림으로 배우는 리눅스 구조 5장. 프로세스 관리(응용편) (0)	2024.02.09
그림으로 배우는 리눅스 구조 4장. 메모리 관리 시스템 (0)	2024.02.02
그림으로 배우는 리눅스 구조 2장. 프로세스 관리(기초편) (0)	2024.01.29
그림으로 배우는 리눅스 구조 1장. 리눅스 개요 (0)	2024.01.29

일	월	화	수	목	금	토
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

Done is better than perfect