💡 왜 멀티코어가 중요할까?

🏗️ 컴퓨터 아키텍처의 기본 이해

📌 폰 노이만 아키텍처

📌 캐시 메모리의 중요성

⚙️ 멀티코어 프로세서의 구조

📌 코어의 종류와 구성

📌 캐시 일관성 문제

🔄 병렬 처리의 기본 개념

📌 병렬성의 종류

📌 암달의 법칙 (Amdahl's Law)

📌 병렬 처리의 도전 과제

🛠️ 멀티코어 프로그래밍 기법

📌 스레드 기반 프로그래밍

// C++에서 스레드 사용 예시
#include <thread>
#include <iostream>
#include <vector>

void processData(int start, int end) {
    for(int i = start; i < end; i++) {
        // 데이터 처리 작업
    }
}

int main() {
    const int NUM_THREADS = 4;
    std::vector<std::thread> threads;
    
    int dataSize = 1000;
    int chunkSize = dataSize / NUM_THREADS;
    
    // 4개의 스레드 생성
    for(int i = 0; i < NUM_THREADS; i++) {
        int start = i * chunkSize;
        int end = (i == NUM_THREADS - 1) ? dataSize : (i + 1) * chunkSize;
        threads.push_back(std::thread(processData, start, end));
    }
    
    // 모든 스레드가 끝날 때까지 대기
    for(auto& t : threads) {
        t.join();
    }
    
    return 0;
}

📌 동기화 메커니즘

// 뮤텍스 사용 예시
#include <mutex>

std::mutex mtx;
int sharedCounter = 0;

void incrementCounter() {
    for(int i = 0; i < 1000; i++) {
        mtx.lock();
        sharedCounter++;  // 임계 영역
        mtx.unlock();
    }
}

// 더 안전한 방법 (RAII 패턴)
void incrementCounterSafe() {
    for(int i = 0; i < 1000; i++) {
        std::lock_guard<std::mutex> lock(mtx);
        sharedCounter++;  // 자동으로 unlock됨
    }
}

📌 OpenMP로 쉽게 병렬화하기

// OpenMP 예시
#include <omp.h>

void parallelLoop() {
    #pragma omp parallel for
    for(int i = 0; i < 1000; i++) {
        // 이 루프가 자동으로 여러 스레드에 분산됨!
        processData(i);
    }
}

// 리덕션 연산
int parallelSum(int* arr, int size) {
    int sum = 0;
    #pragma omp parallel for reduction(+:sum)
    for(int i = 0; i < size; i++) {
        sum += arr[i];
    }
    return sum;
}

🎯 실전 최적화 전략

📌 캐시 친화적 프로그래밍

// 나쁜 예: 캐시 미스 많음
for(int j = 0; j < N; j++) {
    for(int i = 0; i < N; i++) {
        matrix[i][j] = 0;  // 열 우선 접근
    }
}

// 좋은 예: 캐시 히트 많음
for(int i = 0; i < N; i++) {
    for(int j = 0; j < N; j++) {
        matrix[i][j] = 0;  // 행 우선 접근
    }
}

// False Sharing 방지
struct alignas(64) PaddedCounter {
    std::atomic<int> counter;
    char padding[64 - sizeof(std::atomic<int>)];
};

📌 작업 분할 전략

📌 SIMD 활용

// 일반 코드
for(int i = 0; i < size; i++) {
    c[i] = a[i] + b[i];
}

// SIMD 코드 (AVX2 사용)
#include <immintrin.h>

for(int i = 0; i < size; i += 8) {
    __m256 va = _mm256_load_ps(&a[i]);
    __m256 vb = _mm256_load_ps(&b[i]);
    __m256 vc = _mm256_add_ps(va, vb);
    _mm256_store_ps(&c[i], vc);
}
// 한 번에 8개 float를 동시에 더함!

🌐 고급 병렬 처리 패러다임

📌 GPU 컴퓨팅 (GPGPU)

// CUDA 예시 (NVIDIA GPU)
__global__ void vectorAdd(float* a, float* b, float* c, int n) {
    int i = blockIdx.x * blockDim.x + threadIdx.x;
    if(i < n) {
        c[i] = a[i] + b[i];
    }
}

int main() {
    // GPU 메모리 할당
    float *d_a, *d_b, *d_c;
    cudaMalloc(&d_a, size);
    cudaMalloc(&d_b, size);
    cudaMalloc(&d_c, size);
    
    // 데이터 복사
    cudaMemcpy(d_a, h_a, size, cudaMemcpyHostToDevice);
    cudaMemcpy(d_b, h_b, size, cudaMemcpyHostToDevice);
    
    // 커널 실행 (1024개 스레드 블록)
    vectorAdd<<<numBlocks, 1024>>>(d_a, d_b, d_c, n);
    
    // 결과 복사
    cudaMemcpy(h_c, d_c, size, cudaMemcpyDeviceToHost);
}

📌 비동기 프로그래밍

// C++20 코루틴 예시
#include <coroutine>

Task<int> fetchDataAsync() {
    auto data1 = co_await readFromNetwork();
    auto data2 = co_await readFromDisk();
    co_return data1 + data2;
}

// 여러 작업을 동시에 시작하고 결과를 기다림
auto result = co_await fetchDataAsync();

📌 액터 모델

📌 데이터 병렬 라이브러리

📊 성능 측정과 프로파일링

📌 성능 측정 도구들

📌 측정 시 주의사항

// 간단한 시간 측정 코드
#include <chrono>

auto start = std::chrono::high_resolution_clock::now();

// 측정할 코드
performComputation();

auto end = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);

std::cout << "실행 시간: " << duration.count() << " μs" << std::endl;

📌 병목 지점 찾기

🎓 실전 사례 연구

📌 사례 1: 이미지 처리 애플리케이션

📌 사례 2: 과학 시뮬레이션

// 최적화 전: O(N²) 알고리즘
for(int i = 0; i < N; i++) {
    for(int j = 0; j < N; j++) {
        if(i != j) {
            calculateForce(particles[i], particles[j]);
        }
    }
}
// 처리 시간: 50초

// 최적화 후: Barnes-Hut 알고리즘 + 병렬화
#pragma omp parallel for
for(int i = 0; i < N; i++) {
    traverseTree(particles[i], rootNode);
}
// 처리 시간: 0.8초 (62.5배 향상!)

📌 사례 3: 데이터베이스 쿼리 최적화

🔮 미래의 병렬 처리 기술

📌 이종 컴퓨팅 (Heterogeneous Computing)

📌 양자 컴퓨팅

📌 뉴로모픽 컴퓨팅

💡 실무 적용 가이드

📌 1단계: 프로파일링으로 시작

📌 2단계: 알고리즘 개선

📌 3단계: 병렬화 적용

📌 4단계: 최적화

📌 5단계: 검증과 테스트

🎓 학습 리소스와 커뮤니티

📌 추천 도서

📌 온라인 강의

📌 실습 플랫폼

📌 커뮤니티

⚠️ 흔한 실수와 해결책

📌 실수 1: 과도한 병렬화

📌 실수 2: 동기화 과다

📌 실수 3: 캐시 무시

📌 실수 4: 측정 없는 최적화

📌 실수 5: 플랫폼 차이 무시

🎬 마무리하며