Rust 병렬 프로그래밍 기법 (21)

1

 

데이터 병렬화(Data Parallelism)

안녕하세요 친구들, 이번에는 Rust에서 병렬 프로그래밍 기법 중 하나인 데이터 병렬화(Data Parallelism) 에 대해 알아보겠습니다. 데이터 병렬화란 무엇일까요? 데이터 병렬화는 큰 데이터 집합을 작은 조각으로 나누고, 각 조각을 별도의 스레드나 프로세스에서 동시에 처리하는 기법입니다.

 

왜 데이터 병렬화가 중요할까요? 대량의 데이터를 처리해야 하는 경우, 단일 스레드로는 처리 속도가 느려질 수 있습니다. 이때 데이터를 여러 부분으로 나누어 병렬적으로 처리하면 전체 실행 시간을 단축할 수 있습니다. 예를 들어, 이미지 처리, 과학 계산, 데이터베이스 쿼리 등의 작업에서 데이터 병렬화를 활용할 수 있습니다.

 

Rust에서는 rayon 크레이트를 사용하여 쉽게 데이터 병렬화를 구현할 수 있습니다. rayon은 작업 분배를 자동으로 최적화하고, 스레드 풀을 사용하여 스레드 생성 및 관리의 오버헤드를 줄입니다.

use rayon::prelude::*;

fn main() {
    let data = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

    let result: Vec<_> = data.par_iter()
        .map(|x| x * x)
        .collect();

    println!("결과: {:?}", result);
}

 

위 예시에서 par_iter()를 사용하여 벡터의 요소를 병렬로 반복합니다. map 함수를 사용하여 각 요소를 제곱한 결과를 새로운 벡터에 수집합니다. 이처럼 rayon을 사용하면 간단한 코드 변경만으로 데이터 병렬화를 구현할 수 있습니다.

 

하지만 데이터 병렬화를 적용할 때는 공유 상태(Shared State) 에 주의해야 합니다. 여러 스레드가 동시에 같은 데이터에 접근하면 데이터 레이스(Data Race)와 같은 문제가 발생할 수 있습니다. Rust에서는 뮤텍스(Mutex) 와 원자적 참조 카운팅(Arc) 을 통해 이러한 문제를 안전하게 해결할 수 있습니다.

작업 기반 병렬화(Task Parallelism)

작업 기반 병렬화(Task Parallelism) 는 하나의 큰 작업을 여러 개의 작은 작업으로 분할하고, 이들을 병렬적으로 실행하는 기법입니다. 이를 통해 CPU 코어를 효율적으로 활용할 수 있습니다.

 

작업 기반 병렬화는 분할 정복(Divide and Conquer) 알고리즘과 밀접한 관련이 있습니다. 큰 문제를 작은 부분 문제로 나누고, 각 부분 문제를 병렬적으로 해결한 후, 그 결과를 합치는 방식으로 동작합니다.

 

Rust에서는 스레드 풀(Thread Pool) 을 사용하여 작업 기반 병렬화를 구현할 수 있습니다. 스레드 풀은 미리 생성된 스레드 집합으로, 작업이 들어오면 이를 대기열에 넣고 사용 가능한 스레드에 할당하여 처리합니다.

use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();

    for i in 0..10 {
        let tx = tx.clone();
        thread::spawn(move || {
            let result = expensive_computation(i);
            tx.send(result).unwrap();
        });
    }

    let mut results = vec![];
    for _ in 0..10 {
        results.push(rx.recv().unwrap());
    }

    println!("결과: {:?}", results);
}

fn expensive_computation(i: i32) -> i32 {
    // 시간이 오래 걸리는 계산 작업 수행
    i * i
}

 

위 예시에서는 스레드 풀을 사용하여 10개의 작업을 병렬적으로 실행합니다. expensive_computation 함수는 시간이 오래 걸리는 계산 작업을 나타내며, 각 작업은 별도의 스레드에서 실행됩니다. 메인 스레드는 모든 작업이 완료될 때까지 기다린 후 결과를 수집합니다.

 

작업 기반 병렬화는 암달의 법칙(Amdahl's Law) 에 따라 성능 향상의 한계가 있습니다. 즉, 병렬화할 수 없는 순차적인 부분이 존재하므로, 무한정 성능 향상을 기대할 수 없습니다. 따라서 작업 분할과 스레드 관리에 따른 오버헤드를 고려해야 합니다.

파이프라인 병렬화(Pipeline Parallelism)

파이프라인 병렬화(Pipeline Parallelism) 는 작업을 여러 단계로 나누고, 각 단계를 병렬적으로 실행하는 기법입니다. 이를 통해 전체 작업의 처리 속도를 높일 수 있습니다.

 

파이프라인 병렬화는 생산자-소비자 문제(Producer-Consumer Problem) 와 밀접한 관련이 있습니다. 생산자 스레드는 데이터를 생성하고, 소비자 스레드는 이를 처리합니다. 생산자와 소비자 사이에 버퍼를 두어 데이터를 주고받습니다.

Rust에서는 채널(Channel) 과 스레드 풀(Thread Pool) 을 조합하여 파이프라인 병렬화를 구현할 수 있습니다.

use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();

    let tx1 = tx.clone();
    thread::spawn(move || {
        for i in 0..10 {
            let data = format!("데이터 {}", i);
            tx1.send(data).unwrap();
        }
    });

    let tx2 = tx.clone();
    thread::spawn(move || {
        while let Ok(data) = rx.recv() {
            let processed_data = expensive_computation(data);
            tx2.send(processed_data).unwrap();
        }
    });

    while let Ok(data) = rx.recv() {
        println!("결과: {}", data);
    }
}

fn expensive_computation(data: String) -> String {
    // 시간이 오래 걸리는 계산 작업 수행
    data.to_uppercase()
}

 

위 예시에서는 세 개의 스레드를 사용하여 파이프라인 병렬화를 구현합니다. 첫 번째 스레드는 데이터를 생성하고, 두 번째 스레드는 이 데이터를 처리한 후 다음 단계로 전달합니다. 마지막으로 세 번째 스레드는 처리된 데이터를 출력합니다.

 

각 단계는 병렬적으로 실행되므로, 전체 처리 속도가 높아집니다. 그러나 단계 간 데이터 전송에 따른 오버헤드가 발생할 수 있으므로, 작업의 특성에 따라 적절한 버퍼 크기와 스레드 수를 설정해야 합니다.

파이프라인 병렬화는 데이터 처리 파이프라인, 스트리밍 애플리케이션, 웹 서버 등 다양한 분야에 적용될 수 있습니다.

GPU 병렬화(GPU Parallelism)

GPU 병렬화(GPU Parallelism) 는 중앙 처리 장치(CPU)가 아닌 그래픽 처리 장치(GPU)를 활용하여 병렬 계산을 수행하는 기법입니다. GPU는 수천 개의 작은 코어로 구성되어 있어 대량의 데이터를 동시에 처리할 수 있습니다.

GPU 병렬화는 주로 데이터 병렬화 와 관련이 깊습니다. 대규모 데이터 집합을 GPU의 수많은 코어에 분산시켜 동시에 처리함으로써 높은 성능을 발휘할 수 있습니다.

 

Rust에서 GPU 병렬화를 구현하려면 CUDA 나 OpenCL 과 같은 GPU 프로그래밍 모델을 사용해야 합니다. 이를 위해서는 Rust와 해당 프로그래밍 모델 간의 바인딩이 필요합니다.

예를 들어, cuda-rust 크레이트를 사용하면 Rust 코드에서 CUDA 프로그래밍 모델에 접근할 수 있습니다.

extern crate cuda_runtime_sys as cuda;

fn main() {
    let mut data = vec![1.0; 1024];
    let mut result = vec![0.0; 1024];

    let kernel = unsafe {
        cuda::launch(
            kernel_wrapper,
            1024,
            1,
            (data.as_ptr(), result.as_mut_ptr()),
        )
    };

    kernel.join().unwrap();

    println!("결과: {:?}", result);
}

unsafe fn kernel_wrapper(data: *const f32, result: *mut f32) {
    let idx = cuda::thread_idx_x();
    let elem = *data.offset(idx as isize);
    *result.offset(idx as isize) = elem * 2.0;
}

위 예시는 cuda-rust 크레이트를 사용하여 GPU에서 간단한 벡터 계산을 수행합니다. launch 함수를 통해 GPU 커널(kernel)을 호출하고, 데이터와 결과를 전달합니다. 각 GPU 스레드는 kernel_wrapper 함수에서 정의된 작업을 실행합니다.

GPU 병렬화는 대규모 데이터 처리, 과학 계산, 머신 러닝 등의 분야에서 활용됩니다. 그러나 GPU 프로그래밍은 복잡할 수 있으며, 메모리 관리 및 데이터 전송 오버헤드에 주의해야 합니다.

분산 병렬화(Distributed Parallelism)

분산 병렬화(Distributed Parallelism) 는 여러 개의 컴퓨터 노드에 걸쳐 병렬 계산을 수행하는 기법입니다. 각 노드는 작업의 일부를 처리하고, 결과를 통합하여 전체 작업을 완료합니다.

 

분산 병렬화는 단일 컴퓨터의 한계를 극복하고, 대규모 데이터와 계산 집약적인 작업을 처리할 수 있도록 해줍니다. 그러나 노드 간 통신 오버헤드, 장애 처리, 작업 분배 등의 문제를 고려해야 합니다.

 

Rust에서 분산 병렬화를 구현하려면 네트워크 프로그래밍과 메시지 전달 시스템이 필요합니다. tokio 크레이트와 actix-web 크레이트를 조합하면 분산 시스템을 구축할 수 있습니다.

use actix_web::{web, App, HttpServer};
use tokio::sync::mpsc;

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let (tx, rx) = mpsc::channel(100);

    HttpServer::new(move || {
        App::new()
            .route("/", web::get().to(handler))
            .data(tx.clone())
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await?;

    Ok(())
}

async fn handler(tx: web::Data<mpsc::Sender<String>>) -> String {
    let result = expensive_computation();
    tx.send(result).await.unwrap();
    "작업이 처리되었습니다.".to_string()
}

fn expensive_computation() -> String {
    // 시간이 오래 걸리는 계산 작업 수행
    "계산 결과".to_string()
}

위 예시는 actix-web를 사용하여 간단한 웹 서버를 구현합니다. 각 요청은 handler 함수에서 처리되며, 이 함수는 시간이 오래 걸리는 계산 작업을 수행합니다. 계산 결과는 채널을 통해 별도의 작업자 노드로 전송될 수 있습니다.

use tokio::sync::mpsc;

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let rx = {
        let (tx, rx) = mpsc::channel(100);

        // 웹 서버에 tx 전달

        tokio::spawn(async move {
            while let Some(result) = rx.recv().await {
                // 계산 결과 처리
                println!("받은 결과: {}", result);
            }
        });

        rx
    };

    // 웹 서버 실행

    Ok(())
}

위 코드는 별도의 작업자 노드를 시뮬레이션합니다. 작업자는 채널에서 계산 결과를 받아 처리합니다. 실제 분산 시스템에서는 각 노드가 독립적인 프로세스로 실행되며, 네트워크를 통해 통신합니다.

 

분산 병렬화를 구현할 때는 로드 밸런싱(Load Balancing), 장애 처리(Fault Tolerance), 데이터 분할(Data Partitioning) 등의 문제를 고려해야 합니다. 또한, 작업 분배와 결과 통합을 효율적으로 관리하는 것이 중요합니다.

참고 자료

[1] The Rust Programming Language Book: https://doc.rust-lang.org/book/ch16-04-extensible-concurrency-with-the-sync-and-send-traits.html [2] Rayon 공식 문서: https://crates.io/crates/rayon [3] "Programming Rust" by Jim Blandy and Jason Orendorff (O'Reilly Media, 2021) [4] "Parallel and Concurrent Programming in Haskell" by Simon Marlow (O'Reilly Media, 2013) [5] CUDA Rust 바인딩: https://crates.io/crates/cuda-rust [6] Tokio 공식 문서: https://tokio.rs/ [7] Actix Web 공식 문서: https://actix.rs/

 

 

한 고대 문서 이야기

유튜브 프리미엄 월 1만원 할인받고 월 4000원에 이용하는 방법

 

"이 포스팅은 쿠팡 파트너스 활동의 일환으로, 이에 따른 일정액의 수수료를 제공받습니다."