Ders 10: SIMD ve Performans

⚡ Süper Hız!Super Speed!

Normalde işlemler tek tek yapılır. Ama SIMD ile aynı anda 4, 8 hatta 16 işlem yapabilirsin! 🚀

📝 Örnek 1: Süper Kahraman SaldırısıExample 1: Superhero Attack

🦸 super_attack.berk

// Normal saldırı - tek tek
fonksiyon normal_saldir(dusmanlar: &mut [tamsayı], hasar: tamsayı) {
    yazdir("👊 Normal Saldırı (tek tek)");
    icin i in 0..dusmanlar.uzunluk() {
        dusmanlar[i] = dusmanlar[i] - hasar;
        yazdir("  Düşman {}: {} can kaldı", i, dusmanlar[i]);
    }
}

// SÜPER SALDIR - hepsine aynı anda!
fonksiyon super_saldir(dusmanlar: &mut [tamsayı], hasar: tamsayı) {
    yazdir("⚡ SÜPER SALDIRI (hepsine aynı anda!)");
    // SIMD: 4 düşmana aynı anda vur!
    dusmanlar.simd_cikar(hasar);
    icin (i, can) in dusmanlar.numarala() {
        yazdir("  Düşman {}: {} can kaldı", i, can);
    }
}

fonksiyon ana() {
    değişken mut dusmanlar1 = [100, 100, 100, 100];
    değişken mut dusmanlar2 = [100, 100, 100, 100];
    
    yazdir("🎮 SAVAŞ BAŞLIYOR!\n");
    yazdir("4 düşman, her birinin 100 canı var\n");
    
    normal_saldir(&mut dusmanlar1, 25);
    yazdir("");
    super_saldir(&mut dusmanlar2, 25);
    
    yazdir("\n✨ Sonuç aynı, ama SÜPER saldırı 4x hızlı!");
}

📝 Örnek 2: Piksel BoyamaExample 2: Pixel Painting

🎨 pixels.berk

// Ekranda 1000 piksel var
// Her pikseli tek tek boyamak yavaş!

fonksiyon ana() {
    değişken mut pikseller = [0; 1000];  // 1000 siyah piksel
    
    yazdir("🎨 1000 piksel boyama yarışı!\n");
    
    // Normal: Tek tek boya
    değişken baslangic1 = zaman_al();
    icin i in 0..1000 {
        pikseller[i] = 255;  // Beyaz yap
    }
    değişken sure1 = zaman_al() - baslangic1;
    yazdir("👆 Normal boyama: {} ms", sure1);
    
    // SIMD: 8 piksel aynı anda!
    değişken baslangic2 = zaman_al();
    pikseller.simd_doldur(255);  // Hepsini aynı anda!
    değişken sure2 = zaman_al() - baslangic2;
    yazdir("⚡ SIMD boyama: {} ms", sure2);
    
    yazdir("\n🏆 SIMD {} kat daha hızlı!", sure1 / sure2);
}

🎯 SIMD Ne Zaman Kullanılır?When to Use SIMD?

🎮 Oyunlarda grafik işleme🎮 Graphics processing in games
🎵 Ses ve müzik işleme🎵 Audio and music processing
🤖 Yapay zeka hesaplamaları🤖 AI calculations

📖 SIMD Nedir?What is SIMD?

Single Instruction Multiple Data - Tek komut, çok veri. CPU'nun süper gücü!

Karşılaştırma

// Skaler (normal): 4 toplama = 4 işlem
a[0] = b[0] + c[0];  // İşlem 1
a[1] = b[1] + c[1];  // İşlem 2
a[2] = b[2] + c[2];  // İşlem 3
a[3] = b[3] + c[3];  // İşlem 4

// SIMD: 4 toplama = 1 işlem!
a[0..4] = b[0..4] + c[0..4];  // Tek işlem, 4 sonuç!

📝 Örnek 1: Vektör ToplamaExample 1: Vector Addition

➕ vector_add.berk

kullan berk::simd::f32x4;

fonksiyon ana() {
    // 4 elemanlı vektörler
    değişken a = f32x4::yeni([1.0, 2.0, 3.0, 4.0]);
    değişken b = f32x4::yeni([5.0, 6.0, 7.0, 8.0]);
    
    // SIMD toplama - 4 toplama tek seferde!
    değişken sonuc = a + b;
    yazdir("a + b = {:?}", sonuc);  // [6.0, 8.0, 10.0, 12.0]
    
    // SIMD çarpma
    değişken carpim = a * b;
    yazdir("a * b = {:?}", carpim);  // [5.0, 12.0, 21.0, 32.0]
    
    // Toplam (horizontal sum)
    değişken toplam = sonuc.toplam();
    yazdir("Toplam: {}", toplam);  // 36.0
}

📝 Örnek 2: Görüntü ParlaklıkExample 2: Image Brightness

🖼️ brightness.berk

use berk::simd::u8x16;

function adjust_brightness(pixels: &mut [u8], factor: u8) {
    // 16 piksel aynı anda işle
    for chunk in pixels.chunks_exact_mut(16) {
        let vec = u8x16::from_slice(chunk);
        let adjusted = vec.saturating_add(u8x16::splat(factor));
        adjusted.write_to_slice(chunk);
    }
}

function main() {
    // 1920x1080 görüntü = 2 milyon piksel
    let mut image = vec![128u8; 1920 * 1080];
    
    // Benchmark
    let start = Instant::now();
    adjust_brightness(&mut image, 30);
    let duration = start.elapsed();
    
    print("✅ {} piksel işlendi", image.len());
    print("⏱️ Süre: {:?}", duration);
    print("📊 Hız: {:.2} MB/s", 
        image.len() as f64 / duration.as_secs_f64() / 1_000_000.0);
}

🎯 BerkVect: BERK'in SIMD KütüphanesiBerkVect: BERK's SIMD Library

SSE, AVX2, AVX-512 desteği
Otomatik vektörizasyon
Cache-aware algorithms
GPU fallback (CUDA/OpenCL)

📝 Örnek 1: Matrix MultiplicationExample 1: Matrix Multiplication

BERK (BerkVect)

use berkvect::{Matrix, simd_matmul, CacheConfig};

function optimized_matmul(a: &Matrix, b: &Matrix) -> Matrix {
    // Cache-blocking parameters
    let config = CacheConfig {
        l1_block: 64,   // L1 cache block size
        l2_block: 256,  // L2 cache block size
        prefetch: true,
    };
    
    // Detect best SIMD level
    let simd_level = detect_simd();
    print!("Using: {:?}", simd_level);  // AVX2, AVX512, etc.
    
    // Blocked matrix multiplication with SIMD
    simd_matmul(a, b, &config)
}

// Manual SIMD implementation
#[target_feature(enable = "avx2")]
unsafe function matmul_avx2(
    a: &[f32], 
    b: &[f32], 
    c: &mut [f32],
    m: usize, n: usize, k: usize
) {
    use std::arch::x86_64::*;
    
    for i in 0..m {
        for j in (0..n).step_by(8) {
            let mut sum = _mm256_setzero_ps();
            
            for p in 0..k {
                let a_val = _mm256_broadcast_ss(&a[i * k + p]);
                let b_vec = _mm256_loadu_ps(&b[p * n + j]);
                sum = _mm256_fmadd_ps(a_val, b_vec, sum);
            }
            
            _mm256_storeu_ps(&mut c[i * n + j], sum);
        }
    }
}

function main() {
    let size = 1024;
    let a = Matrix::random(size, size);
    let b = Matrix::random(size, size);
    
    // Benchmark
    let start = Instant::now();
    let c = optimized_matmul(&a, &b);
    let elapsed = start.elapsed();
    
    // Calculate GFLOPS
    let flops = 2.0 * (size as f64).powi(3);
    let gflops = flops / elapsed.as_secs_f64() / 1e9;
    
    print!("Matrix: {}x{}", size, size);
    print!("Time: {:?}", elapsed);
    print!("Performance: {:.2} GFLOPS", gflops);
}

📝 Örnek 2: Neural Network LayerExample 2: Neural Network Layer

BERK (NN)

use berkvect::{Tensor, ops};

struct DenseLayer {
    weights: Tensor,
    bias: Tensor,
}

impl DenseLayer {
    function forward(&self, input: &Tensor) -> Tensor {
        // SIMD-accelerated matrix multiplication
        let output = ops::matmul(input, &self.weights);
        
        // SIMD-accelerated bias addition
        let output = ops::add(&output, &self.bias);
        
        // SIMD-accelerated ReLU
        ops::relu(&output)
    }
}

// Fused operations for better performance
function fused_forward(
    input: &Tensor,
    weights: &Tensor,
    bias: &Tensor,
) -> Tensor {
    // Fused: Y = ReLU(X @ W + b)
    // Avoids intermediate allocations
    ops::fused_matmul_bias_relu(input, weights, bias)
}

function benchmark_layer() {
    let batch = 256;
    let input_size = 1024;
    let output_size = 512;
    
    let input = Tensor::random(&[batch, input_size]);
    let layer = DenseLayer {
        weights: Tensor::random(&[input_size, output_size]),
        bias: Tensor::zeros(&[output_size]),
    };
    
    // Warmup
    for _ in 0..10 {
        let _ = layer.forward(&input);
    }
    
    // Benchmark
    let iterations = 1000;
    let start = Instant::now();
    for _ in 0..iterations {
        let _ = layer.forward(&input);
    }
    let elapsed = start.elapsed();
    
    let avg_time = elapsed / iterations;
    let throughput = batch as f64 / avg_time.as_secs_f64();
    
    print!("Batch size: {}", batch);
    print!("Avg forward time: {:?}", avg_time);
    print!("Throughput: {:.0} samples/sec", throughput);
}

function main() {
    print!("🧠 Neural Network SIMD Benchmark\n");
    benchmark_layer();
}

📌 ÖzetSummary

SIMD = Tek komut, çoklu veri (4x-16x hızlanma)
Vektör işlemleri için idealdirIdeal for vector operations
BerkVect kütüphanesi ile kolay kullanımEasy usage with BerkVect library

🎉 TEBRİKLER!CONGRATULATIONS!

BERK 101 kursunu tamamladınız! Artık BERK ile sistem programlamaya hazırsınız.

🏠 Ana Sayfaya Dön