Rust로 작성된 PyO3를 사용하여 파이썬 성능 향상하기

10 Nov 2023

pyo3

PyO3는 Rust 언어를 사용하여 작성된 Python 확장 모듈로, CPython 인터프리터에서 사용할 수 있습니다. PyO3를 사용하면 파이썬 코드의 성능을 향상시킬 수 있으며, Rust의 안정성과 성능을 함께 활용할 수 있습니다.

PyO3란?

PyO3는 Python과 Rust 간의 상호 운용성을 제공하는 라이브러리입니다. 이 라이브러리는 Rust 언어로 작성된 확장 모듈을 CPython에서 사용할 수 있도록 합니다. PyO3는 Rust의 안정성과 성능을 활용하면서도 Python의 풍부한 생태계를 그대로 사용할 수 있는 장점을 가지고 있습니다.

PyO3의 장점

성능 향상: PyO3는 Rust 언어의 뛰어난 성능을 활용하여 파이썬 코드의 실행 속도를 향상시킬 수 있습니다. Rust는 메모리 안전성과 병렬 처리를 위한 도구를 제공하기 때문에, PyO3를 사용하면 빠른 속도로 작업을 처리할 수 있습니다.
안정성: Rust는 컴파일 타임에 엄격한 타입 검사를 수행하며, 메모리 안전성에 대한 강력한 보장을 제공합니다. 이러한 특성을 PyO3에 적용하면, 예기치 않은 메모리 오류 및 다른 버그로부터 안전한 확장 모듈을 만들 수 있습니다.
간편한 상호 운용성: PyO3는 Python과 Rust 간의 상호 운용성을 강화시켜 줍니다. Rust로 작성한 확장 모듈을 CPython에서 직접 사용할 수 있으므로, 다른 Python 라이브러리와의 통합이 손쉽게 이루어집니다.

PyO3 사용하기

PyO3를 설치합니다. Rust 환경에서 cargo를 통해 PyO3를 설치할 수 있습니다. 다음은 Cargo.toml 파일의 예시입니다.
```
 [dependencies]
 pyo3 = "0.14"
```

Rust로 확장 모듈을 작성합니다. 예시 코드는 다음과 같습니다.

 use pyo3::prelude::*;
 use pyo3::types::{IntoPyDict, PyDict};

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

 #[pyfunction]
 fn add(a: u32, b: u32) -> u32 {
     a + b
 }

 #[test]
 fn test_add() {
     let gil = Python::acquire_gil();
     let py = gil.python();
     let locals = PyDict::new(py);
     let module = PyModule::new(py, "mymodule").unwrap();
     module.add_function(wrap_pyfunction!(add, module)).unwrap();
     locals.set_item("mymodule", module).unwrap();

     let code = r#"
         import mymodule
         result = mymodule.add(1, 2)
         assert result == 3
     "#;

     py.run_code(code, Some(locals), None).unwrap();
 }

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

     #[test]
     fn test_add() {
         assert_eq!(add(1, 2), 3);
     }
 }

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

 #[pymodule]
 fn my_module(py: Python, m: &PyModule) -> PyResult<()> {
     m.add_module(rust_module)?;
     Ok(())
 }

 #[pymodule]
 fn my_final_module(py: Python, m: &PyModule) -> PyResult<()> {
     m.add_module(my_module)?;
     Ok(())
 }

 pyo3::create_exception!(my_module_name, MyCustomError, pyo3::exc::Exception);

 #[pymodule]
 fn my_custom_module(py: Python, m: &PyModule) -> PyResult<()> {
     m.add_exception::<MyCustomError>(my_module_name::MyCustomError)?;
     Ok(())
 }

 pyo3::create_exception!(mymodule_name::MyCustomError2, MyCustomError2, pyo3::exc::Exception);

 #[pymodule]
 fn my_custom_module2(py: Python, m: &PyModule) -> PyResult<()> {
     m.add_exception::<MyCustomError2>(mymodule_name::MyCustomError2)?;
     Ok(())
 }

 #[pyfunction]
 fn wrapper(api_key: String) -> PyResult<String> {
     // some logic using `api_key`
     Ok("Success".to_string())
 }

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

 #[pymodule]
 fn my_module(py: Python, m: &PyModule) -> PyResult<()> {
     m.add_module(my_final_module)?;
     Ok(())
 }

 #[pymodule]
 fn rust_module(py: Python, m: &PyModule) -> PyResult<()> {
     m.add_module(my_module)?;
     Ok(())
 }

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

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

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

     #[test]
     fn test_wrapper() {
         let gil = Python::acquire_gil();
         let py = gil.python();
         let locals = PyDict::new(py);
         let module = PyModule::new(py, "my_final_module").unwrap();
         module.add_function(wrap_pyfunction!(wrapper, module)).unwrap();
         locals.set_item("my_final_module", module).unwrap();

         let code = r#"
             import my_final_module
             result = my_final_module.wrapper('api_key')
             assert result == "Success"
         "#;

         py.run_code(code, Some(locals), None).unwrap();
     }
 }

Python에서 Rust로 작성한 확장 모듈을 import하여 사용할 수 있습니다. 다음은 Python에서 확장 모듈을 사용하는 예시 코드입니다.
```
 import mymodule

 result = mymodule.add(1, 2)
 print(result)  # 3
```

결론

PyO3를 사용하여 Rust로 작성된 확장 모듈을 Python에서 활용할 수 있습니다. 이를 통해 파이썬 코드의 성능 향상과 안정성을 동시에 얻을 수 있습니다. Rust의 메모리 안전성과 성능을 활용하여 빠르고 안정적인 확장 모듈을 개발해 보세요.

#rust #python #성능 #확장모듈