• CPU Profili: İşlemcinin zamanının çoğunu hangi fonksiyonlarda harcadığını gösterir. Bu, en çok zaman alan hesaplama yoğunluğunu belirlemenize yardımcı olur.
• Bellek Profili (Heap): Uygulamanızın ne kadar bellek kullandığını ve hangi nesnelerin bellekte kaldığını izlemenizi sağlar. Özellikle bellek sızıntılarını veya gereksiz bellek ayrımlarını tespit etmek için önemlidir. Bellek ayak izini küçültmek, çöp toplayıcının (GC) iş yükünü azaltır.
• Goroutine Profili: Aktif goroutine'lerin yığın izlerini ve durumlarını gösterir. Kilitlenmiş, beklemede olan veya gereksiz yere çalışan goroutine'leri bulmakta faydalıdır. Bu, eşzamanlılık sorunlarını gidermenin ilk adımıdır.
• Engelleme Profili (Block): Senkronizasyon ilkellerinde (mutex'ler, kanallar) goroutine'lerin ne kadar süreyle engellendiğini gösterir. Eşzamanlılık sorunlarını ve kilit çekişmelerini teşhis etmek için kritik öneme sahiptir.
• Mutex Profili: Mutex çekişmelerini ve kilitlenmeleri analiz eder. Özellikle çok çekirdekli sistemlerde, paylaşılan kaynaklara erişimdeki darboğazları ortaya çıkarır.

go tool pprof http://localhost:8080/debug/pprof/profile?seconds=30

go tool pprof http://localhost:8080/debug/pprof/heap

• Gereksiz Tahsisatları Azaltın: Özellikle döngüler içinde sık sık yeni bellek tahsis etmekten kaçının. Küçük nesnelerin sürekli olarak oluşturulup yok edilmesi GC'ye ek yük bindirir. Mümkün olduğunca mevcut bellek alanlarını veya önceden tahsis edilmiş yapıları yeniden kullanmaya çalışın.
• sync.Pool Kullanın: Tekrar tekrar kullanılan nesneler için sync.Pool kullanarak nesneleri yeniden kullanabilirsiniz. Bu, pahalı nesne oluşturma ve yok etme maliyetlerini önleyerek GC'nin iş yükünü önemli ölçüde azaltır. Özellikle network buffer'ları veya geçici veri yapıları için idealdir.
• Ön Tahsisat (Pre-allocation): Slice veya map gibi veri yapılarını oluştururken, boyutunu önceden biliyorsanız
  Kod:

  make([]T, initialCapacity, maxCapacity)

  veya
  Kod:

  make(map[K]V, initialCapacity)

  ile ön tahsisat yapmak, kapasite aşımında yeniden tahsisat maliyetlerini önler. Bu, özellikle büyük veri kümeleri üzerinde çalışırken önemlidir.
• Pointer'lardan Kaçının (Gerektiğinde): Büyük veri yapılarını veya dizileri bir fonksiyona geçirirken kopyalamak yerine pointer kullanmak cazip gelebilir ancak bu, GC'nin takip etmesi gereken pointer sayısını artırır ve bellek kaçış analizini (escape analysis) zorlaştırabilir. Gerektiğinde değer kopyalamayı tercih edin veya daha verimli bir yaklaşım düşünün. Küçük struct'lar genellikle değer olarak geçirilmelidir.
• Global Değişkenlerin Kullanımı: Global değişkenler veya uzun ömürlü nesneler, GC'nin bunları daha uzun süre takip etmesine neden olabilir. Kapsamı dar tutulmuş değişkenler genellikle GC için daha kolaydır. Bellek sızıntılarını önlemek için kullanılmayan global referansları temizlemeye özen gösterin.

• Goroutine Havuzları (Worker Pools): Çok sayıda kısa ömürlü goroutine yerine, görevleri işlemek için sabit sayıda çalışan goroutine'den oluşan bir havuz kullanmak, goroutine oluşturma/yok etme maliyetini azaltır. Bu, özellikle veritabanı bağlantı havuzları veya mesaj işleme sistemlerinde etkilidir.
• Kanal Kullanımı: Kanallar goroutine'ler arası güvenli iletişim için harikadır, ancak gereksiz tamponlama veya kilitlemeler performans düşüklüğüne neden olabilir. Doğru kanal boyutunu seçmek ve bloklamayı minimumda tutmak önemlidir. Tamponsuz kanallar genellikle daha hızlıdır ancak bloklama riskini artırır.
• Kilit Çekişmesini Azaltma: `sync.Mutex` veya `sync.RWMutex` gibi kilitler, paylaşılan verilere erişimi senkronize etmek için kullanılır. Ancak, yüksek çekişme (contention) durumları performansı ciddi şekilde etkiler. Mümkün olduğunca kilitli bölümlerin süresini kısaltın ve atomik işlemler (`sync/atomic` paketi) veya eşzamanlı veri yapıları kullanmayı düşünün. Lock-free algoritmalar genellikle daha iyi performans sunar ancak uygulanması daha zordur.
• Bağlamı (Context) Kullanma: Uzun süren işlemler veya ağ çağrıları için `context` paketi ile zaman aşımı (timeout) ve iptal (cancellation) mekanizmalarını doğru uygulamak, kaynak israfını önler. Ayrıca, istek yaşam döngüsünü yönetmek ve goroutine sızıntılarını önlemek için de kritik öneme sahiptir.
• select Kullanımında Dikkat: `select` ifadesi güçlüdür ancak çok sayıda kanal ile birlikte kullanıldığında performansı etkileyebilir. Gereksiz veya çok karmaşık `select` yapılarını sadeleştirmeye çalışın.

"Veri yapıları ve algoritmalar hakkında iyi bir anlayışa sahip olmadan performans odaklı kod yazmak, rüzgara karşı yelken açmaya benzer. Doğru araçları seçmek, işin yarısıdır."

Genişletmek için tıkla ...

• Doğru Veri Yapısını Seçin:
  Kod:

  slice

  (dilim),
  Kod:

  map

  (harita),
  Kod:

  struct

  (yapı) veya custom veri yapıları arasında doğru seçimi yapmak, bellek erişim desenlerini ve işlem karmaşıklığını etkiler. Örneğin, sık arama işlemleri için `map` yerine `slice` üzerinde sıralı arama yapmak bazen daha yavaş olabilir.
• Özyinelemeden Kaçınma: Go'da kuyruk çağrısı optimizasyonu (tail call optimization) yoktur. Derin özyinelemeler yığın taşmasına (stack overflow) veya gereksiz kaynak tüketimine yol açabilir. Mümkünse döngü tabanlı yaklaşımları tercih edin, çünkü döngüler genellikle daha az bellek kullanır ve daha hızlıdır.
• Algoritma Karmaşıklığı (Big O): Büyük O gösterimini göz önünde bulundurarak, büyük veri setleri için O(N^2) veya daha kötü algoritmalar yerine O(N log N) veya O(N) algoritmaları tercih edin. Veri büyüdükçe, daha düşük karmaşıklığa sahip algoritmalar arasındaki performans farkı katlanarak artar.
• İç içe Döngüleri Optimize Etme: Özellikle iç içe döngülerde, en içteki döngünün en az işi yapmasını sağlayın. Dış döngüden mümkün olduğunca fazla hesaplamayı çıkarın. Bu tür optimizasyonlar genellikle küçük görünse de, sıkça çalıştırıldıklarında büyük fark yaratabilirler.
• Küçük Slice ve Map'ler İçin Değer Kopyalama: Küçük `slice` veya `map`'leri fonksiyonlara geçirirken, çoğu zaman pointer kullanmak yerine değer kopyalamak daha az overhead yaratabilir çünkü kaçış analizi sayesinde çoğu durumda yığında (stack) tahsis edilebilirler.

• Tamponlama (Buffering):
  Kod:

  bufio

  paketi, disk ve ağ I/O işlemlerini tamponlayarak okuma/yazma çağrısı sayısını azaltır ve performansı artırır. Küçük, sık okuma/yazma işlemleri yerine daha büyük bloklar halinde işlem yapmak daha verimlidir. Özellikle büyük dosyaları okurken veya yazarken etkilidir.
• Keep-Alive Bağlantıları: HTTP istemcileri ve sunucuları için "keep-alive" bağlantılarını etkinleştirmek, her istek için yeni bir TCP bağlantısı kurma maliyetini ortadan kaldırır. Bu, özellikle yüksek frekanslı ağ iletişimi gerektiren servisler için önemlidir.
• Bağlantı Havuzları (Connection Pooling): Veritabanı veya diğer dış servislerle etkileşimde bulunurken bağlantı havuzları kullanmak, her istek için yeni bir bağlantı açma/kapama yükünü azaltır. Bu, veritabanı sunucusu üzerindeki yükü de hafifletir.
• Async I/O Yaklaşımları: Go'nun eşzamanlılık modeli, I/O işlemlerini bloklamadan verimli bir şekilde yönetmek için doğal bir yapı sunar. `net/http` gibi paketler bunu zaten içsel olarak yapar. Uzun süreli I/O beklemeleri sırasında diğer goroutine'lerin çalışmaya devam etmesini sağlamak, genel sistem verimliliğini artırır.

• String İşlemleri: Go'da string'ler immutable'dır (değişmez). Çok sayıda string birleştirme işlemi yapıyorsanız (örneğin bir döngü içinde),
  Kod:

  strings.Builder

  kullanmak
  Kod:

  +

  operatörüne göre çok daha verimlidir, çünkü fazladan bellek tahsisatlarını ve kopyalamaları önler.
• Refleksiyondan Kaçının: Refleksiyon (reflection) Go'da güçlü bir araçtır ancak çalışma zamanında tip bilgilerini çözümlemesi gerektiğinden oldukça yavaştır. Performans kritik yollarda mümkün olduğunca refleksiyondan kaçının. Statik tip kontrolü her zaman daha hızlıdır.
• Standart Kütüphaneyi Akıllıca Kullanın: Go'nun standart kütüphanesi oldukça optimize edilmiştir ve genellikle deneyimli geliştiriciler tarafından yazılmıştır. Kendi algoritmalarınızı yazmadan önce standart kütüphanede benzer bir işlevi olup olmadığını kontrol edin ve mümkünse onu kullanın.
• Derleyici İpuçları (Inline, Noinline): Nadiren ihtiyaç duyulsa da, derleyiciye fonksiyonların inlining (iç içe yerleştirilmesi) hakkında ipuçları vermek mümkündür (`go:noinline`). Ancak bu, genellikle derleyicinin otomatik kararından daha iyi sonuç vermez ve dikkatli kullanılmalıdır. Aşırı inlining, ikili dosya boyutunu büyütebilir ve önbellek performansını düşürebilir.
• Gereksiz Arayüz Kullanımından Kaçınma: Arayüzler (interfaces) esneklik sağlar ancak somut tiplere göre küçük bir overhead getirirler. Performans kritik yollarda, doğrudan somut tiplerle çalışmak daha verimli olabilir.

testing

package mypackage

import "testing"

func MyFunction() {
    // Yavaş çalışan bir işlem olduğunu varsayalım
    for i := 0; i < 100000; i++ {
        _ = i * 2 // Basit bir hesaplama
    }
}

func BenchmarkMyFunction(b *testing.B) {
    for i := 0; i < b.N; i++ {
        // Test edilecek kod
        MyFunction()
    }
}

// Örnek bir optimize edilmiş fonksiyon
func MyOptimizedFunction() {
    for i := 0; i < 100000; i++ {
        _ = i << 1 // Bitwise shift, genellikle daha hızlı
    }
}

func BenchmarkMyOptimizedFunction(b *testing.B) {
    for i := 0; i < b.N; i++ {
        MyOptimizedFunction()
    }
}

go test -bench=. -benchmem