PyO3를 활용한 파이썬 모듈의 멀티프로세싱 처리 방법

10 Nov 2023

pyo3

파이썬은 강력한 스크립팅 언어로 많은 개발자들에게 인기가 있습니다. 그러나 파이썬은 GIL(Global Interpreter Lock)이라는 제약 때문에 CPU 집약적인 작업에서 성능이 저하될 수 있습니다. 이러한 문제를 해결하기 위해 멀티프로세싱을 사용할 수 있습니다.

PyO3는 파이썬과 Rust 간의 상호 운용성을 제공하는 도구입니다. 이를 사용하여 Rust로 작성된 고성능 모듈을 파이썬에서 호출할 수 있습니다. 이 글에서는 PyO3를 활용하여 파이썬 모듈을 멀티프로세싱으로 처리하는 방법에 대해 알아보겠습니다.

1. PyO3로 모듈 작성하기

먼저, PyO3를 사용하여 파이썬 확장 모듈을 작성해야 합니다. 다음은 간단한 예제 코드입니다.

use pyo3::types::IntoPyDict;
use pyo3::prelude::*;
use rayon::prelude::*;

#[pyfunction]
fn process_data(data: Vec<u32>) -> Vec<u32> {
    // 데이터 처리 로직
    data.par_iter().map(|&x| x * 2).collect()
}

#[pymodule]
fn mymodule(py: Python, m: &PyModule) -> PyResult<()> {
    m.add_function(wrap_pyfunction!(process_data, m)?)?;
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_process_data() {
        let gil = Python::acquire_gil();
        let py = gil.python();
        let module = PyModule::new(py, "mymodule").unwrap();
        mymodule(py, &module).unwrap();
        pyo3::types::IntoPyDict::set_item(&pyo3::types::PyModule::new(py, "builtins").unwrap(), "mymodule", module).unwrap();

        let gil = Python::acquire_gil();
        let py = gil.python();
        let process_fn: &PyAny = py
            .eval("mymodule.process_data", Some(pyo3::types::PyDict::new(py)), None)
            .unwrap();

        let result: Vec<u32> = process_fn.call1((vec![1, 2, 3, 4, 5],)).unwrap().extract().unwrap();

        assert_eq!(result, vec![2, 4, 6, 8, 10]);
    }
}

위 코드는 Rust로 작성된 PyO3 모듈인 mymodule입니다. process_data 함수는 입력으로 받은 data 벡터를 멀티스레드로 처리하여 2배로 만들어 반환합니다.

2. 멀티프로세싱으로 모듈 호출하기

위에서 작성한 PyO3 모듈을 멀티프로세싱으로 호출하는 방법은 다음과 같습니다.

import multiprocessing
import mymodule

def process_data_parallel(data):
    pool = multiprocessing.Pool()
    result = pool.map(mymodule.process_data, [data])[0]
    pool.close()
    pool.join()
    return result

if __name__ == "__main__":
    data = [1, 2, 3, 4, 5]
    result = process_data_parallel(data)
    print(result)

위 코드는 process_data_parallel 함수를 통해 멀티프로세싱으로 mymodule.process_data 함수를 호출하는 예제입니다. multiprocessing.Pool을 사용하여 멀티프로세싱을 생성하고, map 함수를 통해 전달된 data를 처리합니다. 처리 결과는 result에 저장되며, 이를 출력합니다.

결론

PyO3를 활용하여 Rust로 작성된 파이썬 모듈을 멀티프로세싱으로 처리할 수 있습니다. 이를 통해 GIL 제약으로 인한 성능 저하 문제를 해결할 수 있으며, CPU 집약적인 작업의 성능을 향상시킬 수 있습니다. 또한 Rust의 안전성과 성능을 파이썬에서 활용할 수 있습니다.

해시태그: #PyO3 #멀티프로세싱