_Thread
thread란?
일반적으로 프로그램은 직렬처럼 동작한다. 여기에 쓰레드를 적용하게 되면 병렬적으로 작업을 처리할 수 있게 된다.
전체적인 쓰레드 실행 흐름은 다음과 같다.
Python
├─ 스레드 1: 작업 A → 작업 B → 작업 C
└─ 스레드 2: 작업 X → 작업 Y → 작업 Z
저 쓰레드들은 실제로 CPU 안에 있는 코어들이 작업을 수행한다. CPU 내부는 다음과 같다.
CPU
├─ 물리 코어 0
├─ 물리 코어 1
├─ 물리 코어 2
└─ 물리 코어 3
물리 코어 안에는 논리 코어가 존재한다. OS는 물리 코어에 직접 배정하지 않고 논리 코어에 작업을 배정시킨다. 만약, 아래와 같이 물리 코어 안에 논리 코어가 2개라면 운영 체제는 마치 코어가 8개인 것처럼 프로그램을 가동시킬 수 있다.
CPU
├─ 물리 코어 0
│ ├─ 논리 코어 0
│ └─ 논리 코어 1
├─ 물리 코어 1
│ ├─ 논리 코어 2
│ └─ 논리 코어 3
├─ 물리 코어 2
│ ├─ 논리 코어 4
│ └─ 논리 코어 5
└─ 물리 코어 3
├─ 논리 코어 6
└─ 논리 코어 7
그럼 왜 물리 코어안에 여러 개의 논리 코어로 나누는 것일까? 실제로 하나의 작업만 실행하면 모든 장치들이 100% 실행되는 것이 아니다.
예를 들어 작업 A가 메모리 데이터를 기다리는 동안 다른 연산 장치들은 대기할 수 있다. 이 때 같은 물리 코어 내부에 다른 논리 코어에 해당 연산 장치를 사용하는 작업을 배정하면 효율적으로 처리할 수 있게 된다. 그래서 물리 코어 안에 논리 코어를 여러 개 두는 것이다.
자신의 물리 코어와 논리 코어를 확인하려면 psutil를 사용할 수 있다. 참고로 os의 cpu_count()는 논리 코어만 반환한다.
import psutil
print("물리 코어 수:", psutil.cpu_count(logical=False))
print("논리 코어 수:", psutil.cpu_count(logical=True))
경쟁 상태
두 쓰레드가 동시에 똑같은 변수 접근을 한다고 해보자. 코어들은 스레드의 스택이나 실행된 위치 빼고는 같은 전역 변수와 객체를 바라본다. 그래서 코어들의 경쟁 상태가 발생하는 것이다. 경쟁 상태란 두 개 이상의 코어가 공유된 데이터를 사용했을 때 결과가 실행 순서에 따라 달라지는 현상이다. 아래와 같은 모식도를 봐보자.
초기 count = 10
Core 0 Core 1
────────────────────── ──────────────────────
count에서 10을 읽음 count에서 10을 읽음
10 + 1 계산 10 + 1 계산
11 저장 11 저장
Core 0에서 1을 증가시키고, Core 1에서도 1을 증가시켰으므로 마지막 count의 결과 값은 12가 되어야 할 것 같지만, 실제로 코어들이 연산 하기 전 동시에 읽는 값은 10이므로, count에 덮어씌울 때 11로 덮어씌워지는 것이다. 그래서 이를 해결하려 Lock을 보통 사용한다.
Lock
Lock은 공유 데이터를 한 번만 접근 가능하도록 제한하는 것을 의미한다. 아까와 같은 상황을 예로 들어보면, core 0이 count에 접근하고 있을 때는 core 1이 count에 접근할 수 없다. 동작 원리는 해당 쓰레드가 lock을 가지고 있을 때만 공유 자원을 사용하도록 코드를 설계하면 문제 없이 원하는 결과값을 얻을 수 있다. 원리와 사용 방법은 아래 코드와 같다.
Core 0이 Lock 획득
│
▼
공유 자원 사용 중
│
Core 1은 대기
│
▼
Core 0이 Lock 해제
│
▼
Core 1이 Lock 획득
import _thread
count = 0
lock = _thread.allocate_lock()
def add_count():
global count
for _ in range(1000):
with lock:
count += 1
Thread 중지 방법
MicroPython에서는 thread를 강제로 종료하는 kill()이나 stop() 메서드가 없기 떄문에 이럴 땐 오히려 공유 데이터를 이용한다.
flag를 하나 만들고 스레드를 생성하여 작업을 수행시킨 다음 main 같은 코어 단계에서 해당 플레그 값을 조절하면 Thread가 종료되도록 유도할 수 있다. 참고로 스레드가 자원을 해제하고 나올 때는 해당 스레드의 코드가 종료되었을 때이다. 아래 코드를 남겨두겠다.
import _thread
import time
running = True
def worker():
while running:
print("작업 중")
time.sleep(0.5)
print("worker 종료")
_thread.start_new_thread(worker, ())
time.sleep(5)
running = False
thread 파라미터와 메서드
전체 구조부터 먼저 보이고 설명을 진행하겠다.
_thread 모듈
├─ start_new_thread()
├─ allocate_lock()
├─ get_ident()
├─ stack_size()
├─ exit()
└─ LockType
├─ acquire()
├─ release()
├─ locked()
├─ __enter__()
└─ __exit__()
_thread.start_new_thread()
_thread.start_new_thread()는 새로운 스레드를 생성하고 그 스레드에 함수를 넘긴다.
_thread.start_new_thread(function, args, kwargs)
function
스레드에 전달할 funcion을 지정한다. 이후 등장할 args와 kwargs를 위해서 해당되는 function의 파라미터를 잘 알아두어야 한다.
args와 kwargs
args와 kwargs는 function에 지정되어 있는 파라미터를 넘기는 것이다. args는 위치 기반으로 파라미터를 넘기고 kwargs는 키워드 기반으로 파라미터를 넘긴다.
def func1(a, b, c):
pass
이렇게 작성 되어 있다고 했을 때, args를 통해서 넘기려면 아래와 같이 작성하면 된다.
_thread.start_new_thread(func1, (10, 20, 30))
무조건 튜플 또는 리스트로 넘겨야 한다. 그렇지 않으면 TypeError가 발생한다.
kwargs로 넘기려면 아래와 같이 작성하면 된다.
_thread.start_new_thread(func1, (), {"a":10, "b":20, "c":30})
args를 사용하지 않을 때도 빈 튜플이나 리스트를 꼭 넣어 주어야 한다. 해당 메서드를 정의할 때 kwargs는 None으로 기본값이 지정되어 있지만, args는 기본값이 지정되어 있지 않기 때문이다.
args와 kwargs를 동시에 사용해도 된다. 해당 파라미터를 접근하는 것이 중복되지만 않으면 된다.
_thread.start_new_thread(func1, (10), {"b":20, "c":30})
만약 아래처럼 중복되어 접근하였다면, TypeError가 발생한다.
_thread.start_new_thread(func1, (10, 20), {"b":20, "c":30})
만약, func2가 아래와 같이 작성되어 있다면 꼭 kwargs를 사용해야 한다.
def func2(a, b, *, c):
pass
_thread.start_new_thread(func2, (10, 20), {"c":30})
반환값
_thread.start_new_thread()의 반환값은 생성된 스레드의 식별자를 int형으로 반환한다.
스레드의 식별자는 운영체제가 스레드끼리를 구별하기 위해 붙인 id 값이라고 생각하면 된다.
그러므로 function의 반환값 역시 해당 메서드를 통해서 절대 반환되지 않으므로, 위에서 설명한 바와 같이 공유 변수를 이용하여 해당 값을 저장해야 한다.
_thread.get_ident()
_thread.get_ident()는 스레드 식별자를 반환하는 메서드이다. 위에서 설명했듯이 해당 쓰레드 식별자는 운영체제가 스레드를 구별하기 위해 사용한다.
_thread.stack_size()
_thread.stack_size()는 앞으로 생성할 새 스레드가 사용할 스택 크기를 지정할 수 있다. 이미 실행되고 있는 스레드의 스택 크기는 바꾸지 않는다. 사용법은 아래 코드와 같다.
_thread.stack_size(size)
해당 스택은 워드 크기 단위로 공간이 할당된다. 그래서, _thread.stack_size(7) 이라고 해도, 4B만큼만 할당되는 것이다.
이론적으로는 저게 맞지만, 실제로는 MicroPython안에 최소 스택 크기가 2048B로 정해져 있다. 그래서 1~2047B까지는 자동으로 2048B 할당이 된다.
_thread.stack_size(2020) # 실제 할당 크기 : 2048B
2048 바이트보다 크게 설정할 경우, 워드 크기 단위로 내림이 발생한다. 스택 크기를 워드 단위로 할당해야 하기 때문이다. 아래와 같은 연산이 수행된다고 보면 된다.
core1_stack_num_words = *stack_size / sizeof(uint32_t);
*stack_size =
core1_stack_num_words * sizeof(uint32_t);
_thread.stack_size(4003) # 실제 할당 크기 : 4000B
_thread.stack_size(4005) # 실제 할당 크기 : 4004B
만약, size값을 비워두거나 0으로 설정하게 되면, 스택 크기의 기본값인 4KB(4096B)로 잡힌다.
따로 512B는 빼놓는다?
여기서 중요한 것은, MicroPython은 설정된 스택 값에서 512B를 따로 특정 목적으로 할당 시켜 놓는다는 것이다.
만약 내가 _thread.stack_size(0)으로 설정했다면, 512B만큼은 스택 한계에 도달했거나, 오류를 처리하는 등 안전 공간 할당 목적으로 약간의 스택을 남겨 놓는다. 즉, 스택에 문제가 발생했을 때 복구할 수 있는 공간인 것이다.
어떻게 복구가 진행되는가?
여기서 하나 오해를 잡고 가자면 복구의 의미가 스택의 값을 원래대로 되돌려 놓는다 라는 것이 아니라, 스레드 내부에서 수행되고 있는 함수 호출들을 안전하게 빠져나와 예외 처리 지점으로 무사히 가도록 안내한다 라는 뜻이다.
RP2 같은 경우는 추가로 256 바이트를 빼놓는다. 이는 실제 사용하는 스택 범위와 여유로 두었던 스택 범위가 충돌하지 않게 마진을 두는 것이다. 실제 구조는 아래와 같다.
스택 시작점
│
▼
┌──────────────────────────────┐
│ 정상 실행 영역 │
│ │
│ 3328B까지 │
├ - - - - 검사 한계 - - - - - ┤ 3328B
│ 검사 사이 마진 256B │
├ - - - - - - - - - - - - - ┤ 3584B
│ 복구 여유 512B │
└──────────────────────────────┘ 4096B
스택 메모리의 실제 끝
전체: 4096바이트
위 구조를 조금 더 설명하자면 3328B + 256B까지는 코드 실행하면서 저장되는 데이터들이 스택에 저장된다. 256B는 특정 예외적인 공간이 아니라 512B를 넘어가지 않도록 마진을 두는 공간이라고 생각하면 된다. 메모리를 할당하다보면 3328바이트보다 커질수도 있기 때문이다. 물론 256바이트의 여유 공간을 두더라도 그 이상의 범위를 침범할 수 있는 가능성도 존재한다. 그 가능성에 대해서는 공간을 침범했을 때 내부적으로 어떻게 동작하는지 먼저 설명하고 해당 내용을 설명하겠다.
512바이트는 뒤에 설명하겠지만 예외가 발생했을 때 호출하는 함수나 여러 공간 할당 필요시 사용되는 공간이다. 이는 앞서 말했던 3328바이트와 256바이트와는 구별되는 공간이다. 이전 Timer Class 설명할 때 Hard IRQ에서 emergency_exception를 지정하는 로직과 비슷한 개념이다.
침범되는 예시를 재귀 호출을 예로 들어 설명하겠다. 함수를 한 번 호출할 때마다 스택에는 재귀 호출이 끝날 때까지 현재 함수 위치를 기록해두고 다음 함수로 점프한다. 결국 끝까지 같을 때 return 하고 기록해둔 순서대로 스택에서 하나씩 꺼내면서 나머지 함수도 수행한다. MicroPython은 함수 호출 시점에서 mp_cstack_check()를 호출하여 현재 스택 사용량을 확인한다. mp_cstack_check()는 매번 아래와 같은 구조를 가진다.
if (mp_cstack_usage() >= MP_STATE_THREAD(stack_limit)) {
mp_raise_recursion_depth();
}
현재 사용량을 검사 한계값을 넘게 되는지 확인하는 것이다. 만약 4096B라면 4096 - 512 - 256 = 3328바이트가 검사 한계값이다.
만약, 스택 검사 한계값을 넘으면 mp_raise_recursion_depth()이 호출되면서 RuntimeError를 발생시킨다. 그 후 NLR(Non-Local Return) 구조를 사용하여 정상적으로 함수를 빠져나간다. NLR은 예외가 처리되는 지점, 예를 들면 try를 하고 except로 받을 때 except 내부를 예외가 처리되는 지점이라고 할 수 있다. 즉 예외 처리 지점으로 돌아가는 구조를 NLR이라고 하는 것이다. 예외 처리 지점의 주소는 CPU의 레지스터에 저장해두었다가 발생했을시 해당 주소를 가져와 예외 처리 지점으로 점프한다. 아래 코드를 봐보자.
def recurse():
recurse()
def worker():
try:
recurse()
except RuntimeError as e:
print("스택 한계 감지:", e)
print("worker는 계속 실행 가능")
_thread.start_new_thread(worker, ())
설명을 위해 대부분의 코드를 생략하였다. try 내부에서 재귀함수인 recurse()를 수행한다. MicroPython은 mp_cstack_check()를 매번 수행하여 스택 한계값을 넘는지 체크하고, 만약에 넘었다면 mp_raise_recursion_depth()를 수행시켜 RuntimeError를 발생시켜 except 내부로 이동한다. 만약, 프로그래머가 except영역을 지정하지 않았어도 괜찮다. MicroPython에서는 스레드함수를 실행하기 전에 nlr_push()를 사용해 예외 처리 지점을 등록하기 때문이다. 프로그래머가 예외를 잡지 않으면 RuntimeError는 해당 예외 처리 지점까지 전달된다. except가 없어도 예외 처리가 수행되는 것이다.
아까 이후에 설명하려다 미룬 스택 영역 3328B를 넘어버리면 어떻게 되는가에 대해서 마저 설명하도록 하겠다.
우선, 스택 한계값을 넘으면 즉 3328B를 넘으면 RuntimeError를 발생시킨다. 마진으로 남겨두었던 256B를 침범해도 복구할 때의 영역인 512B를 침범하지 않으므로 문제가 발생하지 않는다. 256B는 그냥 혹시 모르는 상황을 대비해서 만들어놓은 공간일 뿐이다. 만약 512B인 복구 영역을 침범했다면 except내부에서 스택을 사용하는 공간이 해당 침범되는 영역만큼 차감되어 원래 배정되었던 메모리 공간보다 적게 사용된다. 만약 512B까지 전부 침범해버린다면 except내부에서 사용하는 스택값이 다른 프로그램, 다른 스레드 영역의 메모리를 덮어 씌워버릴 수 있는 참사가 발생한다. 즉 메모리 오염이 발생하는 것이다.
반환값
이전 stack 크기를 반환한다.
_thread.exit()
_thread.exit()란 스레드 내부에서 작업을 즉시 종료시키는 메서드이다. 매개변수와 반환값은 따로 존재하지 않는다. 내부 동작은 SystemExit 예외를 발생시켜 종료시키는 방식이다.
_thread.exit()
오해하면 안 될 것이, 위에서 설명했듯이 MicroPython에서는 kill()이나 stop()처럼 스레드를 종료시킬 수 있는 메서드가 존재하지 않아 공유 변수를 이용하여 종료시킨다고 하였는데, 이는 외부에서 종료시킬 수 있는 메서드가 존재하지 않는다는 것이지 해당 스레드를 내부에서 종료시킬 수 있는 메서드가 없다는 뜻이 아니다. _thread.exit()같은 경우는 내부에서 스레드를 종료시키는 방식이고, 외부에서 특정 스레드를 종료시키고 싶다면 앞서 말했듯이 공유 자원을 이용하여 스레드를 종료시켜야 한다.
_thread.allocate_lock()
_thread.allocate_lock()은 lock 객체를 생성하는 메서드이다.
lock = _thread.allocate_lock()
lock은 아까도 설명했듯이, 스레드가 공유 자원을 사용하기 전에, lock을 만들어 스레드들끼리 주거니 받거니 하면서 공유 자원을 안전하게 관리할 수 있다.
lock.acquire()
lock.acquire()는 해당 스레드에 lock을 부여하는 메서드이다. lock을 스레드 밖에서 생성하고, 해당 스레드 안에서 lock.acquire()로 lock을 가져올 수 있는 메서드이다. 해당 메서드 안에는 waitflag라는 파라미터가 있다. True일 때는 lock이 다른 스레드에서 해제될 때까지 기다리지만, False일 때는 해제됨과 상관없이 즉시 lock을 가져온다. 이는 공유 자원의 오염을 초래할 수 있다.
lock.release()
lock.release()는 lock 객체를 해제한다. lock을 가져오지도 않고 release()를 사용하면 RuntimeError가 발생한다.
또한 아래와 같이 사용하면 lock이 해제되지 않는 문제가 생길 것이다.
lock.acquire()
result = 10 / 0
locl.release()
0으로 나눈 예외가 발생하여 release()메서드가 수행되지 않고 해당 스레드가 종료된다. lock은 해제되지 않고 계속 상주할 것이므로 다른 스레드에서 lock을 가져올 수 없다. 그래서 with를 함께 사용한다.
with를 간단히 설명하자면, 객체 안에 정의되어 있는 __enter()__ 메서드와 __exit()__ 메서드를 각각 시작과 끝에 수행 시켜준다.
lock 객체 안에는 해당 메서드가 정의되어 있고 __enter()__ 메서드에는 lock.acquire()를 수행하고, __exit()__ 메서드에는 lock.release() 메서드를 수행한다. with내부에서 중간에 예외가 발생하여 빠져나감에도 불구하고 __exit()__가 실행되는 구조니 매우 안전한 방법이라고 할 수 있다. 해당 아래 코드와 동일한 작업을 수행한다고 보면 된다.
lock.acquire()
try:
count += 1
finally:
lock.release()