Benchmark Nedir? Performans Testi ve Rakip Analizi Rehberi 2026 | Digitexa

Yazılım geliştirmede "hızlı" veya "performanslı" ifadeleri sübjektif kavramlardır. Gerçek performansı anlamak için sayısal verilere ihtiyacınız var. İşte tam bu noktada benchmark devreye giriyor.

Benchmark Nedir?

Benchmark, bir sistem, yazılım veya sürecin performansını standartlaştırılmış testlerle ölçme ve karşılaştırma yöntemidir. Kelime anlamı olarak "referans noktası" veya "kıyaslama ölçütü" demektir.

Teknik açıdan benchmark, şu soruların cevabını verir:

Sistemim ne kadar hızlı?
Rakiplerimle karşılaştırıldığında neredeyim?
Hangi optimizasyonlar gerçek fark yaratıyor?
Darboğazlarım nerede?

// Basit bir benchmark örneği
function benchmarkFunction(fn: () => void, iterations: number = 1000): number {
  const start = performance.now();
  
  for (let i = 0; i < iterations; i++) {
    fn();
  }
  
  const end = performance.now();
  return (end - start) / iterations; // Ortalama süre (ms)
}

// Kullanım
const avgTime = benchmarkFunction(() => {
  const arr = Array.from({ length: 10000 }, (_, i) => i);
  arr.sort((a, b) => b - a);
});

console.log(`Ortalama çalışma süresi: ${avgTime.toFixed(4)}ms`);

Benchmark Türleri

Benchmark kavramı farklı alanlarda farklı anlamlar taşır. İşte en yaygın benchmark türleri:

1. Performans Benchmarkı (Performance Benchmarking)

Sistemin veya yazılımın teknik performansını ölçer. Metrikler genellikle şunlardır:

Metrik	Açıklama	Örnek
Throughput	Birim zamanda işlenen iş miktarı	10.000 request/saniye
Latency	İşlemin tamamlanma süresi	45ms response time
Resource Utilization	Kaynak kullanım oranı	%75 CPU kullanımı
Concurrency	Eşzamanlı işlem kapasitesi	500 concurrent user

2. Rekabetçi Benchmark (Competitive Benchmarking)

Ürün veya hizmetinizi rakiplerle karşılaştırır. Bu, iş stratejisi açısından kritik önem taşır:

Stratejik benchmark: İş modelleri ve stratejilerin karşılaştırılması
Süreç benchmarkı: Operasyonel süreçlerin analizi
Sonuç benchmarkı: KPI'lar ve iş sonuçlarının ölçümü

3. Sentetik Benchmark (Synthetic Benchmarking)

Yapay iş yükleri kullanarak performans ölçer. Gerçek dünya koşullarını simüle eder ancak tam olarak yansıtmaz:

// Sentetik CPU benchmark örneği
function syntheticCpuBenchmark(): number {
  const iterations = 1000000;
  let result = 0;
  
  const start = performance.now();
  
  for (let i = 0; i < iterations; i++) {
    result += Math.sqrt(i) * Math.sin(i) * Math.cos(i);
  }
  
  return performance.now() - start;
}

4. Uygulama Benchmarkı (Application Benchmarking)

Gerçek uygulamaları kullanarak performans ölçer. Sentetik testlere göre daha gerçekçi sonuçlar verir:

// E-ticaret uygulaması için gerçek dünya benchmarkı
async function applicationBenchmark() {
  const scenarios = [
    { name: 'Ürün Listeleme', endpoint: '/api/products' },
    { name: 'Sepete Ekleme', endpoint: '/api/cart/add' },
    { name: 'Ödeme İşlemi', endpoint: '/api/checkout' },
  ];
  
  const results = await Promise.all(
    scenarios.map(async (scenario) => {
      const times: number[] = [];
      
      for (let i = 0; i < 100; i++) {
        const start = performance.now();
        await fetch(scenario.endpoint);
        times.push(performance.now() - start);
      }
      
      return {
        scenario: scenario.name,
        avg: times.reduce((a, b) => a + b) / times.length,
        p95: times.sort((a, b) => a - b)[Math.floor(times.length * 0.95)],
        p99: times.sort((a, b) => a - b)[Math.floor(times.length * 0.99)],
      };
    })
  );
  
  return results;
}

Yazılım Benchmarkları

Yazılım geliştirmede benchmark testleri, sistemin farklı katmanlarında uygulanır.

CPU Benchmarkları

İşlemci performansını ölçer. Tek çekirdek ve çok çekirdek performansı ayrı değerlendirilir:

Cinebench R24: 3D rendering performansı
Geekbench 6: Genel işlemci performansı
SPEC CPU: Endüstri standardı benchmark suite

Bellek (RAM) Benchmarkları

Bellek hızı, bant genişliği ve gecikme süresini ölçer:

// Bellek erişim paterni benchmarkı
function memoryBenchmark() {
  const arraySize = 10_000_000;
  const arr = new Float64Array(arraySize);
  
  // Sequential access
  const seqStart = performance.now();
  for (let i = 0; i < arraySize; i++) {
    arr[i] = i * 1.5;
  }
  const seqTime = performance.now() - seqStart;
  
  // Random access
  const indices = Array.from({ length: arraySize }, () => 
    Math.floor(Math.random() * arraySize)
  );
  
  const randStart = performance.now();
  for (const idx of indices) {
    arr[idx] = idx * 1.5;
  }
  const randTime = performance.now() - randStart;
  
  return {
    sequentialAccess: `${seqTime.toFixed(2)}ms`,
    randomAccess: `${randTime.toFixed(2)}ms`,
    ratio: (randTime / seqTime).toFixed(2),
  };
}

Disk I/O Benchmarkları

Depolama cihazlarının okuma/yazma performansını ölçer:

Sequential read/write: Büyük dosya transferleri
Random read/write: Veritabanı operasyonları
IOPS: Saniyedeki input/output operasyonları

Network Benchmarkları

Ağ performansını ve gecikme sürelerini ölçer:

// Network latency benchmarkı
async function networkBenchmark(endpoints: string[]) {
  const results = [];
  
  for (const endpoint of endpoints) {
    const latencies: number[] = [];
    
    for (let i = 0; i < 10; i++) {
      const start = performance.now();
      
      try {
        await fetch(endpoint, { method: 'HEAD' });
        latencies.push(performance.now() - start);
      } catch (error) {
        latencies.push(-1); // Hata durumu
      }
    }
    
    const validLatencies = latencies.filter(l => l > 0);
    
    results.push({
      endpoint,
      avgLatency: validLatencies.reduce((a, b) => a + b, 0) / validLatencies.length,
      minLatency: Math.min(...validLatencies),
      maxLatency: Math.max(...validLatencies),
      successRate: (validLatencies.length / latencies.length) * 100,
    });
  }
  
  return results;
}

Web Performans Benchmarkları

Web uygulamaları için performans ölçümü, kullanıcı deneyimini doğrudan etkiler.

Core Web Vitals

Google'ın belirlediği üç kritik metrik:

Metrik	Açıklama	İyi	Orta	Kötü
LCP	Largest Contentful Paint	≤2.5s	≤4.0s	>4.0s
INP	Interaction to Next Paint	≤200ms	≤500ms	>500ms
CLS	Cumulative Layout Shift	≤0.1	≤0.25	>0.25

💡 Not: INP (Interaction to Next Paint), Mart 2024'te FID'in (First Input Delay) yerini aldı. Artık etkileşim yanıt süresi daha kapsamlı ölçülüyor.

Lighthouse Benchmarkları

Google Lighthouse, web sayfalarını beş kategoride değerlendirir:

// Lighthouse CI entegrasyonu örneği
// lighthouserc.js
module.exports = {
  ci: {
    collect: {
      url: ['http://localhost:3000/', 'http://localhost:3000/blog'],
      numberOfRuns: 3,
    },
    assert: {
      assertions: {
        'categories:performance': ['error', { minScore: 0.9 }],
        'categories:accessibility': ['error', { minScore: 0.9 }],
        'categories:best-practices': ['error', { minScore: 0.9 }],
        'categories:seo': ['error', { minScore: 0.9 }],
        'first-contentful-paint': ['error', { maxNumericValue: 2000 }],
        'largest-contentful-paint': ['error', { maxNumericValue: 2500 }],
        'cumulative-layout-shift': ['error', { maxNumericValue: 0.1 }],
        'interactive': ['error', { maxNumericValue: 3500 }],
      },
    },
    upload: {
      target: 'temporary-public-storage',
    },
  },
};

Real User Monitoring (RUM)

Gerçek kullanıcı verilerini toplayan benchmark yöntemi:

// Web Vitals RUM implementasyonu
import { onLCP, onINP, onCLS, Metric } from 'web-vitals';

function sendToAnalytics(metric: Metric) {
  const body = JSON.stringify({
    name: metric.name,
    value: metric.value,
    rating: metric.rating,
    delta: metric.delta,
    id: metric.id,
    navigationType: metric.navigationType,
  });
  
  // Beacon API ile gönderim
  if (navigator.sendBeacon) {
    navigator.sendBeacon('/api/analytics/vitals', body);
  } else {
    fetch('/api/analytics/vitals', { body, method: 'POST', keepalive: true });
  }
}

// Metrikleri topla
onLCP(sendToAnalytics);
onINP(sendToAnalytics);
onCLS(sendToAnalytics);

Benchmark Nasıl Yapılır?

Güvenilir benchmark sonuçları için sistematik bir yaklaşım gerekir.

1. Test Ortamının Hazırlanması

Benchmark ortamı, production ortamını mümkün olduğunca yansıtmalıdır:

# Minimum donanım gereksinimleri
# - 8+ CPU core
# - 32+ GB RAM
# - SSD/NVMe storage
# - 10 Gbps network (network testleri için)

Kritik kontroller:

Arka plan uygulamalarını kapatın
Thermal throttling'i engelleyin (yeterli soğutma)
Güç yönetimini "Yüksek Performans"a ayarlayın
Network testlerinde izolasyon sağlayın

2. Warmup Süresi

JIT (Just-In-Time) compilation ve cache'lerin ısınması için warmup süresi kritiktir:

async function benchmarkWithWarmup<T>(
  fn: () => T | Promise<T>,
  options: {
    warmupIterations?: number;
    testIterations?: number;
  } = {}
) {
  const { warmupIterations = 100, testIterations = 1000 } = options;
  
  // Warmup fazı - sonuçlar hesaba katılmaz
  console.log('Warmup başlıyor...');
  for (let i = 0; i < warmupIterations; i++) {
    await fn();
  }
  
  // Garbage collection (Node.js)
  if (global.gc) {
    global.gc();
  }
  
  // Gerçek test fazı
  console.log('Test başlıyor...');
  const times: number[] = [];
  
  for (let i = 0; i < testIterations; i++) {
    const start = performance.now();
    await fn();
    times.push(performance.now() - start);
  }
  
  // İstatistiksel analiz
  times.sort((a, b) => a - b);
  
  return {
    min: times[0],
    max: times[times.length - 1],
    mean: times.reduce((a, b) => a + b) / times.length,
    median: times[Math.floor(times.length / 2)],
    p95: times[Math.floor(times.length * 0.95)],
    p99: times[Math.floor(times.length * 0.99)],
    stdDev: calculateStdDev(times),
  };
}

function calculateStdDev(values: number[]): number {
  const mean = values.reduce((a, b) => a + b) / values.length;
  const squaredDiffs = values.map(v => Math.pow(v - mean, 2));
  return Math.sqrt(squaredDiffs.reduce((a, b) => a + b) / values.length);
}

3. Tekrarlı Testler

Tek bir test sonucu güvenilir değildir. İstatistiksel anlamlılık için çoklu çalıştırma gerekir:

// Çoklu çalıştırma ve güven aralığı hesaplama
function calculateConfidenceInterval(
  values: number[],
  confidence: number = 0.95
): { lower: number; upper: number; mean: number } {
  const n = values.length;
  const mean = values.reduce((a, b) => a + b) / n;
  const stdDev = calculateStdDev(values);
  const stdError = stdDev / Math.sqrt(n);
  
  // Z-score for 95% confidence
  const zScore = confidence === 0.95 ? 1.96 : 2.576; // 99% için 2.576
  const marginOfError = zScore * stdError;
  
  return {
    mean,
    lower: mean - marginOfError,
    upper: mean + marginOfError,
  };
}

4. Kontrollü Değişkenler

Her seferinde sadece bir değişkeni değiştirin:

// A/B benchmark karşılaştırması
async function compareBenchmarks(
  implementations: { name: string; fn: () => void }[]
) {
  const results: Record<string, ReturnType<typeof benchmarkWithWarmup>> = {};
  
  for (const impl of implementations) {
    console.log(`Testing: ${impl.name}`);
    results[impl.name] = await benchmarkWithWarmup(impl.fn);
  }
  
  // Karşılaştırma raporu
  const baseline = Object.values(results)[0];
  
  console.table(
    Object.entries(results).map(([name, stats]) => ({
      name,
      mean: `${stats.mean.toFixed(3)}ms`,
      p95: `${stats.p95.toFixed(3)}ms`,
      vsBaseline: `${((stats.mean / baseline.mean - 1) * 100).toFixed(1)}%`,
    }))
  );
  
  return results;
}

Rakip Analizi ve Benchmark

Teknik benchmark'ların ötesinde, rekabetçi benchmark analizi iş stratejisi için vazgeçilmezdir.

Rakip Analizi Adımları

Rakip Belirleme: Doğrudan ve dolaylı rakipleri tanımlayın
Metrik Seçimi: Karşılaştırılacak KPI'ları belirleyin
Veri Toplama: Objektif ve karşılaştırılabilir veriler edinin
Analiz: Güçlü ve zayıf yönleri tespit edin
Aksiyon: Stratejik öneriler geliştirin

Web Sitesi Rakip Benchmarkı

// Rakip web sitelerinin performans karşılaştırması
interface CompetitorMetrics {
  url: string;
  lcp: number;
  inp: number;
  cls: number;
  ttfb: number;
  pageSize: number;
  requestCount: number;
}

async function competitorBenchmark(
  competitors: string[]
): Promise<CompetitorMetrics[]> {
  const results: CompetitorMetrics[] = [];
  
  for (const url of competitors) {
    // PageSpeed Insights API kullanımı
    const apiUrl = `https://www.googleapis.com/pagespeedonline/v5/runPagespeed?url=${encodeURIComponent(url)}&strategy=mobile`;
    
    const response = await fetch(apiUrl);
    const data = await response.json();
    
    const metrics = data.lighthouseResult.audits;
    
    results.push({
      url,
      lcp: metrics['largest-contentful-paint'].numericValue,
      inp: metrics['interaction-to-next-paint']?.numericValue ?? 0,
      cls: metrics['cumulative-layout-shift'].numericValue,
      ttfb: metrics['server-response-time'].numericValue,
      pageSize: metrics['total-byte-weight'].numericValue,
      requestCount: metrics['network-requests'].details?.items?.length ?? 0,
    });
  }
  
  return results;
}

Popüler Benchmark Araçları

Donanım Benchmarkları

Araç	Kategori	Kullanım Alanı
Cinebench R24	CPU	3D rendering performansı
Geekbench 6	CPU/GPU	Genel sistem performansı
3DMark	GPU	Oyun ve grafik performansı
CrystalDiskMark	Storage	SSD/HDD hız testi
AIDA64	Sistem	Kapsamlı donanım analizi

Yazılım ve Web Benchmarkları

Araç	Kategori	Kullanım Alanı
Lighthouse	Web	Web performans auditi
WebPageTest	Web	Detaylı sayfa analizi
k6	Load Testing	API yük testleri
Apache JMeter	Load Testing	Kapsamlı performans testi
Benchmark.js	JavaScript	JS fonksiyon benchmarkı

k6 ile Load Testing Örneği

// k6 load test senaryosu
import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
  stages: [
    { duration: '30s', target: 20 },   // Ramp-up
    { duration: '1m', target: 20 },    // Stay
    { duration: '30s', target: 100 },  // Spike
    { duration: '1m', target: 100 },   // Stay
    { duration: '30s', target: 0 },    // Ramp-down
  ],
  thresholds: {
    http_req_duration: ['p(95)<500'],  // 95% istekler 500ms altında
    http_req_failed: ['rate<0.01'],    // Hata oranı %1 altında
  },
};

export default function () {
  const res = http.get('https://api.example.com/products');
  
  check(res, {
    'status is 200': (r) => r.status === 200,
    'response time OK': (r) => r.timings.duration < 500,
  });
  
  sleep(1);
}

Benchmark Best Practices

Yapılması Gerekenler

✅ Test ortamını production'a benzetin
✅ Warmup süresi uygulayın
✅ Çoklu çalıştırma yapın (en az 10)
✅ İstatistiksel analiz kullanın (mean, median, p95, p99)
✅ Sonuçları belgeleyin ve tarihleyin
✅ Kontrollü değişkenler kullanın

Yapılmaması Gerekenler

❌ Tek çalıştırmaya güvenmeyin
❌ Development ortamında test etmeyin
❌ Sadece ortalamaya bakmayın (p95/p99 kritik)
❌ Arka plan işlemlerini açık bırakmayın
❌ Farklı koşullarda alınan sonuçları karşılaştırmayın

Sonuç

Benchmark, yazılım geliştirme ve iş stratejisinin temel taşlarından biridir. Doğru yapıldığında:

Objektif kararlar almanızı sağlar
Performans sorunlarını erkenden tespit etmenize yardımcı olur
Rakip avantajınızı ölçmenizi mümkün kılar
Optimizasyonların etkisini kanıtlar

Unutmayın: "Ölçemediğiniz şeyi iyileştiremezsiniz." Benchmark, bu ölçümün standartlaştırılmış ve güvenilir yoludur.

Uygulamanızın performansını benchmark testleriyle ölçmek ister misiniz? Bizimle iletişime geçin ve ücretsiz performans analizi alın.

Benchmark Nedir? Performans Ölçümü ve Rakip Analizi Rehberi