[Python] Flask와 FastAPI로 Python 동시성 테스트 | LIM

📌 파이썬의 동시성

파이썬에서는 쓰레드를 사용하는 threading 모듈, 태스크를 사용하는 asyncio 모듈, 그리고 프로세스를 사용하는 multiprocessing 모듈이 있는데 여기서 병렬적으로 작업을 처리하는 것은 실제로 multiprocessing 뿐이다.

threading 과 asyncio 모듈은 모두 하나의 프로세서를 사용하기 때문에 한 번에 하나씩 실행할 수밖에 없다. 서로 context switching 되면서 동시에 실행되는 것처럼 보이게 되는 것이다. 이렇게 해서 작업 시간을 줄인다. 

 

📌 threading과 asyncio 차이(concurrency)

파이썬에서 동시적인 작업을 할 때 사용하는 threading과 asyncio의 차이점은 threading은 모듈에서 실행되고 있는 각 쓰레드를 운영체제가 언제든지 멈추고 다른 쓰레드를 진행시킬 수 있는 것이다. 운영체제가 스레드를 선점할 수 있기 때문에, 이걸 선점형 멀티태스킹(pre-emptive multitasking) 이라고 한다. 

 

반면에 asyncio 모듈은 협력식 멀티태스킹(cooperative multitasking) 방식을 사용한다. 이 방식은 각 태스크가 직접 언제 스위칭될 준비가 되었는지 명시해주어야 한다. 이 방식의 장점은 언제 다른 태스크로 넘어갈지를 코드를 짜는 사람이 정할 수 있는 것이다. 

 

📌 병렬 작업을 가능하게 하는 Multiprocessing(parallelism)

threading과 asyncio는 한 프로세서에서 이루어지는 동시성이었다. multiprocessing 모듈을 사용하면, 파이썬은 완전히 새로운 프로세서를 생성한다. 즉 완전히 같은 시간에 병렬적으로 처리가 가능해지는 것이다.

---

🧐 동시성의 종류 I/O bound,  CPU bound

I/O bound 작업의 의미는 입출력 작업이 주가 된다는 것이다. I/O bound라고 해서 cpu 작업이 이루어지지 않는 것은 아니다. 즉 I/O waiting 시간이 많은 경우다. 파일 쓰기, 디스크 작업, 디비 접근, 네트워크 통신을 할 때 주로 나타나며 작업에 의한 병목에 의해 작업 속도가 결정된다

 

그렇다면 CPU bound 작업의 의미는 I/O bound 작업의 의미와 반대로 생각하면 된다. CPU 작업이 주를 이루는 것이다. 주로 연산을 할 때 나타나며 CPU 성능에 의해 작업 속도가 결정된다.

 

따라서 적절하게 작업이 I/O 중심인 지 CPU 작업 중심인 지 파악할 필요가 있다. 이와 관련해서 간단하게 테스트를 진행해보았다. 

---

🔖 FastAPI와 Flask 비교를 통한 I/O bound와 CPU bound 작업 동시성 테스트

기본적으로 10개의 request를 한 번에 보내는 설정으로 테스트를 진행했다. 성능 테스트 도구는 Apache Jmeter를 사용했다.

https://mosei.tistory.com/entry/JMeter-%EC%A0%9C%EC%9D%B4%EB%AF%B8%ED%84%B0-%EC%82%AC%EC%9A%A9%EB%B0%A9%EB%B2%95

[JMeter] 제이미터 사용방법

 

I/O bound test

테스트한 코드는 다음과 같다. 모든 테스트는 도커로 진행했다. 

 

flask 코드

from flask import Flask
import os
import datetime
import time

@app.route('/test-flask', methods=['GET'])
def test():
    print(f'start-time - {datetime.datetime.now()}')
    time.sleep(10)
    print(f'finish-time - {datetime.datetime.now()}')
    return 'Done!'
    
    
if __name__ == '__main__':
	app.run(host='0.0.0.0', port=int(os.environ.get('PORT', 8080)))

 

fastAPI 코드

from fastapi import FastAPI
import uvicorn
import os
import datetime
import time

@app.get('/test-fast')
def test():
    print(f'start-time - {datetime.datetime.now()}')
    time.sleep(10)
    print(f'finish-time - {datetime.datetime.now()}')
    return 'Done!'
    
    
 
if __name__ == '__main__':
	uvicorn.run(app, host='0.0.0.0', port=int(os.environ.get('PORT', 8080)))

 

* Flask - gunicorn 설정: worker 1, thread 5 개인 경우 *

20초가 소요되었다. thread가 5개이기 때문에 request 5 개를 처리한 후 이전 request가 종료되는 대로 나머지 5개의 request가 실행되었다. thread를 10개로 늘리면 10개의 request를 한 번에 처리하기 때문에 11초에 종료된다. 로그에서 보다시피 처음 request의  start-time 5개가 실행이 되고 finsih-time이 찍히며 끝나면서 다른 start-time 이 시작되었다. 

 

*FastAPI - gunicorn with uvicorn 설정: worker 1, thread 5개인 경우 *

11초가 소요되었다. fastAPI는 기본적으로 async def를 쓰지 않아도 def만으로 비동기 처리되도록 FastAPI 프레임워크로 구현하고 있다. 위 작업이 현재 time.sleep(10) 을 사용해서 CPU 가 쉬고 있는 I/O bound 작업이어서 비동기 처리가 되었고 속도는 Flask를 사용해서 동기적으로 실행했을 때보다 시간이 절반이 줄어든 것이다. thread를 10개로 늘려도 11초로 동일하다. 비동기 처리가 얼마나 I/O bound 작업에서 성능을 높여주는지 확인할 수 있었다.

로그에서 보다시피 위의 flask를 사용한 로그와는 다르게 request시작인 start-time이 10개가 찍힌 후 finish-time 10개가 순서대로 찍힌 것을 볼 수 있다. 

 

 

CPU bound test

위의 I/O bound 테스트와는 다르게 계산식을 넣어서 연산 작업을 하는 테스트 코드를 짰다.

 

flask 코드

from flask import Flask
import os
import datetime

@app.route('/test-flask', methods=['GET'])
def test():
    print(f'start-time - {datetime.datetime.now()}')
    num_list = list(range(10000000))
    square_sum = sum(x**2 for x in num_list)
    print(f'finish-time - {datetime.datetime.now()}')
    return 'Done!'
    
    
if __name__ == '__main__':
	app.run(host='0.0.0.0', port=os.environ.get('PORT', 8080)))

 

fastAPI 코드

from fastapi import FastAPI
import uvicorn
import os
import datetime

@app.get('/test-fast')
def test():
    print(f'start-time - {datetime.datetime.now()}')
    num_list = list(range(10000000))
    square_sum = sum(x**2 for x in num_list)
    print(f'finish-time - {datetime.datetime.now()}')
    return 'Done!'
    
    
 
if __name__ == '__main__':
	uvicorn.run(app, host='0.0.0.0', port=int(os.environ.get('PORT', 8080)))

 

* Flask - gunicorn 설정: worker 1, thread 10 개인 경우 *

25초가 소요되었다. thread가 10개이기 때문에 10개의 request를 동시에 처리한다.

* Flask - gunicorn 설정: worker 2, thread 5 개인 경우 *

worker의 개수를 늘리니 thread를 줄여도 시간이 14초로 줄었다. 즉 연산 작업인 CPU Bound 작업에서는 worker의 개수를 늘려서 병렬 처리를 진행할 수 있는 것이다. 위의 로그와는 다르게 start-time과 finsih-time이 번갈아 찍히는 것을 볼 수 있다. worker process 2개가 동시에 실행되고 있기 때문이다. 

 

다음으로는 fastAPI를 이용하여 진행해보겠다.

 

*FastAPI - gunicorn with uvicorn 설정: worker 1, thread 10개인 경우 *

27초가 소요되었다. 비동기 작업은 CPU 연산 위주의 작업을 하지 않기 때문에 FastAPI를 이용해도 Flask와 다를 바가 없다. 

 

*FastAPI - gunicorn with uvicorn 설정: worker 2, thread 5개인 경우 *

17초가 소요되었다. 역시 worker의 개수를 늘리니 병렬 프로그래밍을 통해 worker가 1개였을 때보다 처리 속도가 빨라졌다.

---

📝 정리하면서..

이로써 파이썬의 동시성 개념에 대해 좀 더 명확해진 것 같다. 기본적으로 파이썬은 GIL(Global Interpreter Lock) 정책을 사용하기 때문에 하나의 스레드만 사용할 수 있다. 그러나 이것은 CPU Bound 작업에만 해당되고 I/O Bound 작업에서는 내부적으로 GIL을 해제한다고 한다. 따라서 파이썬에서 연산을 이용해서 동시성의 효과를 보기 위해서는 Multiprocessing 을 이용해야 한다. 

 

다음에는 CPU bound인 연산 위주의 작업에서 Multiprocessing 을 이용하여 연산의 속도를 높인 예제를 적어봐야겠다. 사실 동일한 테스트를 M1 mac pro 와 Intel mac pro(32GB) 로 Multiprocessing을 이용하지 않고(Cpu core 1개) 테스트했는데 동일한 연산이 M1 mac pro에서는 3-4분 만에 끝났고 Intel mac pro에서는 7-8분 걸렸다.

 

진짜 M1 칩이 얼마나 대단한 지 한 번 더 느꼈다...