파이썬 러스트 바인딩 성능 최적화 (NumPy + Rayon + Release Build)

// pyo3 라이브러리에서 파이썬 연동에 필요한 핵심 기능들을 가져옵니다.
use pyo3::prelude::*;

// #[pyfunction] 어트리뷰트는 이 러스트 함수를 파이썬에서 직접 호출할 수 있도록 변환해 줍니다.
#[pyfunction]
fn calculate_heavy_work(numbers: Vec<i64>) -> PyResult<i64> {
    // 1. 데이터 입력: 파이썬의 리스트(int)가 러스트의 Vec<i64> 형태로 자동 변환되어 들어옵니다.

    // 2. 연산 수행: 리스트의 각 숫자를 제곱(|&x| x * x)한 뒤 모두 더합니다(.sum()).
    let result: i64 = numbers.iter().map(|&x| x * x).sum();
    
    // 3. 데이터 반환 (중요): 
    // 파이썬과 러스트는 서로 다른 언어이므로, 연산이 '성공했는지 에러가 났는지'를 알려주는 
    // 안전한 주머니인 `PyResult` 형태로 감싸서 반환해야 합니다.
    // 성공 시에는 결과값을 `Ok(결과값)` 형태로 포장해서 파이썬으로 보냅니다.
    Ok(result)
}

// #[pymodule]은 파이썬에서 `import py_rust_hybrid`로 불러올 수 있는 하나의 '모듈'을 만듭니다.
#[pymodule]
fn py_rust_hybrid(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
    // 위에서 만든 `calculate_heavy_work` 함수를 이 파이썬 모듈에 등록합니다.
    m.add_function(wrap_pyfunction!(calculate_heavy_work, m)?)?;
    
    // 모듈 등록이 성공적으로 끝났음을 알리는 빈 포장지(Ok(()))를 반환합니다.
    Ok(())
}

// pyo3 라이브러리에서 파이썬 연동에 필요한 핵심 기능들을 가져옵니다.
use pyo3::prelude::*;

// #[pyfunction] 어트리뷰트는 이 러스트 함수를 파이썬에서 직접 호출할 수 있도록 변환해 줍니다.
#[pyfunction]
fn calculate_heavy_work(numbers: Vec<i64>) -> PyResult<i64> {
    // 1. 데이터 입력: 파이썬의 리스트(int)가 러스트의 Vec<i64> 형태로 자동 변환되어 들어옵니다.

    // 2. 연산 수행: 리스트의 각 숫자를 제곱(|&x| x * x)한 뒤 모두 더합니다(.sum()).
    let result: i64 = numbers.iter().map(|&x| x * x).sum();
    
    // 3. 데이터 반환 (중요): 
    // 파이썬과 러스트는 서로 다른 언어이므로, 연산이 '성공했는지 에러가 났는지'를 알려주는 
    // 안전한 주머니인 `PyResult` 형태로 감싸서 반환해야 합니다.
    // 성공 시에는 결과값을 `Ok(결과값)` 형태로 포장해서 파이썬으로 보냅니다.
    Ok(result)
}

// #[pymodule]은 파이썬에서 `import py_rust_hybrid`로 불러올 수 있는 하나의 '모듈'을 만듭니다.
#[pymodule]
fn py_rust_hybrid(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
    // 위에서 만든 `calculate_heavy_work` 함수를 이 파이썬 모듈에 등록합니다.
    m.add_function(wrap_pyfunction!(calculate_heavy_work, m)?)?;
    
    // 모듈 등록이 성공적으로 끝났음을 알리는 빈 포장지(Ok(()))를 반환합니다.
    Ok(())
}

import py_rust_hybrid
import time

# 1. 테스트용 대량 데이터 생성 (1부터 1,000,000까지의 정수 리스트)
data = list(range(1, 1000001))

print("=== 1단계: 퓨어 파이썬(Pure Python) 연산 테스트 ===")
start_time = time.perf_counter()

# 파이썬 자체 기능(리스트 컴프리헨션과 내장 sum 함수)으로 제곱의 합 계산
pure_python_result = sum(x * x for x in data)

end_time = time.perf_counter()
print(f"퓨어 파이썬 연산 결과: {pure_python_result}")
print(f"퓨어 파이썬 소요 시간: {end_time - start_time:.5f}초\n")


print("=== 2단계: 파이썬 러스트 하이브리드(PyO3) 연산 테스트 ===")
start_time = time.perf_counter()

# 러스트로 구현한 함수 호출
rust_result = py_rust_hybrid.calculate_heavy_work(data)

end_time = time.perf_counter()
print(f"파이썬 러스트 바인딩 연산 결과: {rust_result}")
print(f"파이썬 러스트 바인딩 소요 시간: {end_time - start_time:.5f}초\n")

import py_rust_hybrid
import time

# 1. 테스트용 대량 데이터 생성 (1부터 1,000,000까지의 정수 리스트)
data = list(range(1, 1000001))

print("=== 1단계: 퓨어 파이썬(Pure Python) 연산 테스트 ===")
start_time = time.perf_counter()

# 파이썬 자체 기능(리스트 컴프리헨션과 내장 sum 함수)으로 제곱의 합 계산
pure_python_result = sum(x * x for x in data)

end_time = time.perf_counter()
print(f"퓨어 파이썬 연산 결과: {pure_python_result}")
print(f"퓨어 파이썬 소요 시간: {end_time - start_time:.5f}초\n")


print("=== 2단계: 파이썬 러스트 하이브리드(PyO3) 연산 테스트 ===")
start_time = time.perf_counter()

# 러스트로 구현한 함수 호출
rust_result = py_rust_hybrid.calculate_heavy_work(data)

end_time = time.perf_counter()
print(f"파이썬 러스트 바인딩 연산 결과: {rust_result}")
print(f"파이썬 러스트 바인딩 소요 시간: {end_time - start_time:.5f}초\n")

// pyo3 라이브러리에서 파이썬 연동에 필요한 핵심 기능들을 가져옵니다.
use pyo3::prelude::*;


#[pyfunction]
fn calculate_heavy_work(numbers: Vec<i64>) -> PyResult<u128> { // 반환 타입을 u128로
    // 반복문에서 값을 계속 누적해야 하므로 mut 사용
    let mut result: u128 = 0; // 합계 변수도 u128로
    // 연산을 1000번 반복하여 CPU를 빡세게 돌립니다!
    for _ in 0..1000 {
        // x * x 결과를 u128로 변환해서 더함
        result+= numbers.iter().map(|&x| (x as u128) * (x as u128)).sum::<u128>();
    }

    Ok(result)
}

// #[pymodule]은 파이썬에서 `import py_rust_hybrid`로 불러올 수 있는 하나의 '모듈'을 만듭니다.
#[pymodule]
fn py_rust_hybrid(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
    // 위에서 만든 `calculate_heavy_work` 함수를 이 파이썬 모듈에 등록합니다.
    m.add_function(wrap_pyfunction!(calculate_heavy_work, m)?)?;

    // 모듈 등록이 성공적으로 끝났음을 알리는 빈 포장지(Ok(()))를 반환합니다.
    Ok(())
}

// pyo3 라이브러리에서 파이썬 연동에 필요한 핵심 기능들을 가져옵니다.
use pyo3::prelude::*;


#[pyfunction]
fn calculate_heavy_work(numbers: Vec<i64>) -> PyResult<u128> { // 반환 타입을 u128로
    // 반복문에서 값을 계속 누적해야 하므로 mut 사용
    let mut result: u128 = 0; // 합계 변수도 u128로
    // 연산을 1000번 반복하여 CPU를 빡세게 돌립니다!
    for _ in 0..1000 {
        // x * x 결과를 u128로 변환해서 더함
        result+= numbers.iter().map(|&x| (x as u128) * (x as u128)).sum::<u128>();
    }

    Ok(result)
}

// #[pymodule]은 파이썬에서 `import py_rust_hybrid`로 불러올 수 있는 하나의 '모듈'을 만듭니다.
#[pymodule]
fn py_rust_hybrid(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
    // 위에서 만든 `calculate_heavy_work` 함수를 이 파이썬 모듈에 등록합니다.
    m.add_function(wrap_pyfunction!(calculate_heavy_work, m)?)?;

    // 모듈 등록이 성공적으로 끝났음을 알리는 빈 포장지(Ok(()))를 반환합니다.
    Ok(())
}

import py_rust_hybrid
import time

# 1. 테스트용 대량 데이터 생성 (1부터 1,000,000까지의 정수 리스트)
data = list(range(1, 1000001))

print("=== 1단계: 퓨어 파이썬(Pure Python) 연산 테스트 ===")
start_time = time.perf_counter()

# 파이썬 자체 기능(리스트 컴프리헨션과 내장 sum 함수)으로 제곱의 합 계산
pure_python_result = 0
for _ in range(1000):
    pure_python_result += sum(x * x for x in data)

end_time = time.perf_counter()
print(f"퓨어 파이썬 연산 결과: {pure_python_result}")
print(f"퓨어 파이썬 소요 시간: {end_time - start_time:.5f}초\n")


print("=== 2단계: 파이썬 러스트 하이브리드(PyO3) 연산 테스트 ===")
start_time = time.perf_counter()

# 러스트로 구현한 함수 호출
rust_result = py_rust_hybrid.calculate_heavy_work(data)

end_time = time.perf_counter()
print(f"파이썬 러스트 바인딩 연산 결과: {rust_result}")
print(f"파이썬 러스트 바인딩 소요 시간: {end_time - start_time:.5f}초\n")

import py_rust_hybrid
import time

# 1. 테스트용 대량 데이터 생성 (1부터 1,000,000까지의 정수 리스트)
data = list(range(1, 1000001))

print("=== 1단계: 퓨어 파이썬(Pure Python) 연산 테스트 ===")
start_time = time.perf_counter()

# 파이썬 자체 기능(리스트 컴프리헨션과 내장 sum 함수)으로 제곱의 합 계산
pure_python_result = 0
for _ in range(1000):
    pure_python_result += sum(x * x for x in data)

end_time = time.perf_counter()
print(f"퓨어 파이썬 연산 결과: {pure_python_result}")
print(f"퓨어 파이썬 소요 시간: {end_time - start_time:.5f}초\n")


print("=== 2단계: 파이썬 러스트 하이브리드(PyO3) 연산 테스트 ===")
start_time = time.perf_counter()

# 러스트로 구현한 함수 호출
rust_result = py_rust_hybrid.calculate_heavy_work(data)

end_time = time.perf_counter()
print(f"파이썬 러스트 바인딩 연산 결과: {rust_result}")
print(f"파이썬 러스트 바인딩 소요 시간: {end_time - start_time:.5f}초\n")

[dependencies]
pyo3 = { version = "0.22", features = ["extension-module"] }
numpy = "0.22"

[dependencies]
pyo3 = { version = "0.22", features = ["extension-module"] }
numpy = "0.22"

use pyo3::prelude::*;

// 수정된 핵심 로직 (데이터 복사 없이 메모리 주소만 가져옴)
// NumPy 배열을 Rust에서 읽기 전용으로 접근하기 위한 타입
use numpy::PyReadonlyArray1;

#[pyfunction]
fn calculate_heavy_work(numbers: PyReadonlyArray1<i64>) -> PyResult<u128> {
    // NumPy 배열의 메모리 주소를 그대로 참조합니다.
    // Vec<i64>처럼 새로운 배열을 생성하지 않으므로 데이터 복사 비용이 발생하지 않습니다.
    let numbers = numbers.as_slice()?;
    // 반복 계산 결과를 계속 더해야 하므로 mut 사용
    let mut total: u128 = 0;
    // 연산을 1000번 반복하여 CPU 연산 비중을 높입니다.
    for _ in 0..1000 {
        total += numbers.iter().map(|&x| (x as u128) * (x as u128)).sum::<u128>();
    }
    Ok(total)
}

#[pymodule]
fn py_rust_hybrid(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
    m.add_function(wrap_pyfunction!(calculate_heavy_work, m)?)?;
    Ok(())
}

use pyo3::prelude::*;

// 수정된 핵심 로직 (데이터 복사 없이 메모리 주소만 가져옴)
// NumPy 배열을 Rust에서 읽기 전용으로 접근하기 위한 타입
use numpy::PyReadonlyArray1;

#[pyfunction]
fn calculate_heavy_work(numbers: PyReadonlyArray1<i64>) -> PyResult<u128> {
    // NumPy 배열의 메모리 주소를 그대로 참조합니다.
    // Vec<i64>처럼 새로운 배열을 생성하지 않으므로 데이터 복사 비용이 발생하지 않습니다.
    let numbers = numbers.as_slice()?;
    // 반복 계산 결과를 계속 더해야 하므로 mut 사용
    let mut total: u128 = 0;
    // 연산을 1000번 반복하여 CPU 연산 비중을 높입니다.
    for _ in 0..1000 {
        total += numbers.iter().map(|&x| (x as u128) * (x as u128)).sum::<u128>();
    }
    Ok(total)
}

#[pymodule]
fn py_rust_hybrid(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
    m.add_function(wrap_pyfunction!(calculate_heavy_work, m)?)?;
    Ok(())
}

import py_rust_hybrid
import numpy as np # 넘파이 불러오기
import time

# 100만 개의 데이터를 그냥 리스트가 아니라 np.array로 생성
data = np.arange(1, 1000001, dtype=np.int64)

# 이제 러스트가 복사 없이 이 데이터의 주소만 가져가서 계산합니다!
start = time.time()
result = py_rust_hybrid.calculate_heavy_work(data)
end = time.time()

print(f"속도 결과: {end - start:.5f}초")

import py_rust_hybrid
import numpy as np # 넘파이 불러오기
import time

# 100만 개의 데이터를 그냥 리스트가 아니라 np.array로 생성
data = np.arange(1, 1000001, dtype=np.int64)

# 이제 러스트가 복사 없이 이 데이터의 주소만 가져가서 계산합니다!
start = time.time()
result = py_rust_hybrid.calculate_heavy_work(data)
end = time.time()

print(f"속도 결과: {end - start:.5f}초")

use pyo3::prelude::*;

#[pyfunction]
fn calculate_heavy_work(numbers: PyReadonlyArray1<i64>) -> PyResult<u128> {
    let numbers = numbers.as_slice()?;
    let mut total: u128 = 0;
    for _ in 0..100 {
        total += numbers.iter().map(|&x| (x as u128) * (x as u128)).sum::<u128>();
    }
    Ok(total)
}

use pyo3::prelude::*;

#[pyfunction]
fn calculate_heavy_work(numbers: PyReadonlyArray1<i64>) -> PyResult<u128> {
    let numbers = numbers.as_slice()?;
    let mut total: u128 = 0;
    for _ in 0..100 {
        total += numbers.iter().map(|&x| (x as u128) * (x as u128)).sum::<u128>();
    }
    Ok(total)
}

import py_rust_hybrid
import numpy as np # 넘파이 불러오기
import time

# 1,000만 개의 데이터를 그냥 리스트가 아니라 np.array로 생성
data = np.arange(1, 10000001, dtype=np.int64)

print("=== 2단계: 파이썬 러스트 하이브리드(PyO3) 연산 테스트 ===")
start_time = time.perf_counter()
rust_result = py_rust_hybrid.calculate_heavy_work(data)
end_time = time.perf_counter()
print(f"파이썬 러스트 바인딩 연산 결과: {rust_result}")
print(f"파이썬 러스트 바인딩 소요 시간: {end_time - start_time:.5f}초\n")

import py_rust_hybrid
import numpy as np # 넘파이 불러오기
import time

# 1,000만 개의 데이터를 그냥 리스트가 아니라 np.array로 생성
data = np.arange(1, 10000001, dtype=np.int64)

print("=== 2단계: 파이썬 러스트 하이브리드(PyO3) 연산 테스트 ===")
start_time = time.perf_counter()
rust_result = py_rust_hybrid.calculate_heavy_work(data)
end_time = time.perf_counter()
print(f"파이썬 러스트 바인딩 연산 결과: {rust_result}")
print(f"파이썬 러스트 바인딩 소요 시간: {end_time - start_time:.5f}초\n")

use pyo3::prelude::*;

#[pyfunction]
fn calculate_heavy_work(numbers: Vec<i64>) -> PyResult<u128> { // 반환 타입을 u128로
    let mut result: u128 = 0; // 합계 변수도 u128로
    for _ in 0..100 {
        // x * x 결과를 u128로 변환해서 더함
        result+= numbers.iter().map(|&x| (x as u128) * (x as u128)).sum::<u128>();
    }

    Ok(result)
}

use pyo3::prelude::*;

#[pyfunction]
fn calculate_heavy_work(numbers: Vec<i64>) -> PyResult<u128> { // 반환 타입을 u128로
    let mut result: u128 = 0; // 합계 변수도 u128로
    for _ in 0..100 {
        // x * x 결과를 u128로 변환해서 더함
        result+= numbers.iter().map(|&x| (x as u128) * (x as u128)).sum::<u128>();
    }

    Ok(result)
}

import py_rust_hybrid
import time

data = list(range(1, 10000001))

print("=== 1단계: 퓨어 파이썬(Pure Python) 연산 테스트 ===")
start_time = time.perf_counter()

# 파이썬 자체 기능(리스트 컴프리헨션과 내장 sum 함수)으로 제곱의 합 계산
pure_python_result = 0
for _ in range(100):
    pure_python_result += sum(x * x for x in data)

end_time = time.perf_counter()
print(f"퓨어 파이썬 연산 결과: {pure_python_result}")
print(f"퓨어 파이썬 소요 시간: {end_time - start_time:.5f}초\n")


print("=== 2단계: 파이썬 러스트 하이브리드(PyO3) 연산 테스트 ===")
start_time = time.perf_counter()

# 러스트로 구현한 함수 호출
rust_result = py_rust_hybrid.calculate_heavy_work(data)

end_time = time.perf_counter()
print(f"파이썬 러스트 바인딩 연산 결과: {rust_result}")
print(f"파이썬 러스트 바인딩 소요 시간: {end_time - start_time:.5f}초\n")

import py_rust_hybrid
import time

data = list(range(1, 10000001))

print("=== 1단계: 퓨어 파이썬(Pure Python) 연산 테스트 ===")
start_time = time.perf_counter()

# 파이썬 자체 기능(리스트 컴프리헨션과 내장 sum 함수)으로 제곱의 합 계산
pure_python_result = 0
for _ in range(100):
    pure_python_result += sum(x * x for x in data)

end_time = time.perf_counter()
print(f"퓨어 파이썬 연산 결과: {pure_python_result}")
print(f"퓨어 파이썬 소요 시간: {end_time - start_time:.5f}초\n")


print("=== 2단계: 파이썬 러스트 하이브리드(PyO3) 연산 테스트 ===")
start_time = time.perf_counter()

# 러스트로 구현한 함수 호출
rust_result = py_rust_hybrid.calculate_heavy_work(data)

end_time = time.perf_counter()
print(f"파이썬 러스트 바인딩 연산 결과: {rust_result}")
print(f"파이썬 러스트 바인딩 소요 시간: {end_time - start_time:.5f}초\n")

[dependencies]
pyo3 = { version = "0.22", features = ["extension-module"] }
numpy = "0.22"
rayon = "1.10"

[dependencies]
pyo3 = { version = "0.22", features = ["extension-module"] }
numpy = "0.22"
rayon = "1.10"

use pyo3::prelude::*;
use numpy::PyReadonlyArray1;
use rayon::prelude::*; // 병렬 처리 크레이트 추가

#[pyfunction]
fn calculate_heavy_work(numbers: PyReadonlyArray1<i64>) -> PyResult<u128> {
    let numbers = numbers.as_slice()?; 
    
    // 100번의 루프를 병렬(Multi-threading)로 처리
    let total: u128 = (0..100)
        .into_par_iter() // 여기서부터 병렬 실행
        .map(|_| {
            numbers.iter().map(|&x| (x as u128) * (x as u128)).sum::<u128>()
        })
        .sum();
    
    Ok(total)
}
#[pymodule]
fn py_rust_hybrid(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
    m.add_function(wrap_pyfunction!(calculate_heavy_work, m)?)?;
    Ok(())
}

use pyo3::prelude::*;
use numpy::PyReadonlyArray1;
use rayon::prelude::*; // 병렬 처리 크레이트 추가

#[pyfunction]
fn calculate_heavy_work(numbers: PyReadonlyArray1<i64>) -> PyResult<u128> {
    let numbers = numbers.as_slice()?; 
    
    // 100번의 루프를 병렬(Multi-threading)로 처리
    let total: u128 = (0..100)
        .into_par_iter() // 여기서부터 병렬 실행
        .map(|_| {
            numbers.iter().map(|&x| (x as u128) * (x as u128)).sum::<u128>()
        })
        .sum();
    
    Ok(total)
}
#[pymodule]
fn py_rust_hybrid(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
    m.add_function(wrap_pyfunction!(calculate_heavy_work, m)?)?;
    Ok(())
}

use pyo3::prelude::*;
use numpy::PyReadonlyArray1;
use rayon::prelude::*; // 병렬 처리를 위해 추가

#[pyfunction]
#[allow(unsafe_op_in_unsafe_fn)]
fn calculate_heavy_work(numbers: PyReadonlyArray1<i64>) -> PyResult<u128> {
    let numbers = numbers.as_slice()?; 
    
    let total: u128 = (0..100)
        .into_par_iter()
        .map(|_| {
            // fold를 사용하여 컴파일러의 SIMD 자동 벡터화를 유도
            numbers.iter()
                   .fold(0u128, |acc, &x| acc + (x as u128 * x as u128))
        })
        .sum();
    
    Ok(total)
}
#[pymodule]
fn py_rust_hybrid(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
    m.add_function(wrap_pyfunction!(calculate_heavy_work, m)?)?;
    Ok(())
}

use pyo3::prelude::*;
use numpy::PyReadonlyArray1;
use rayon::prelude::*; // 병렬 처리를 위해 추가

#[pyfunction]
#[allow(unsafe_op_in_unsafe_fn)]
fn calculate_heavy_work(numbers: PyReadonlyArray1<i64>) -> PyResult<u128> {
    let numbers = numbers.as_slice()?; 
    
    let total: u128 = (0..100)
        .into_par_iter()
        .map(|_| {
            // fold를 사용하여 컴파일러의 SIMD 자동 벡터화를 유도
            numbers.iter()
                   .fold(0u128, |acc, &x| acc + (x as u128 * x as u128))
        })
        .sum();
    
    Ok(total)
}
#[pymodule]
fn py_rust_hybrid(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
    m.add_function(wrap_pyfunction!(calculate_heavy_work, m)?)?;
    Ok(())
}

[profile.release]
opt-level = 3
lto = "fat"            # 링크 타임 최적화 (코드 전체를 하나처럼 보고 최적화)
codegen-units = 1      # 더 정밀한 최적화 수행
panic = "abort"        # 패닉 시 안전 장치를 제거하여 속도 향상

[profile.release]
opt-level = 3
lto = "fat"            # 링크 타임 최적화 (코드 전체를 하나처럼 보고 최적화)
codegen-units = 1      # 더 정밀한 최적화 수행
panic = "abort"        # 패닉 시 안전 장치를 제거하여 속도 향상