High Performance

Giriş

High Performance programming, .NET uygulamalarında maximum performance elde etmek için kullanılan teknikler ve best practices'dir. Mid-level geliştiriciler için high performance programming'i anlamak, optimization, benchmarking ve performance tuning için kritik öneme sahiptir. Bu dosya, performance optimization, benchmarking, profiling ve high-performance patterns konularını kapsar.

Performance Optimization

1. Performance Optimizer

Performance optimization yapan servis.

public class PerformanceOptimizer
{
    private readonly ILogger<PerformanceOptimizer> _logger;
    private readonly IConfiguration _configuration;

    public PerformanceOptimizer(ILogger<PerformanceOptimizer> logger, IConfiguration configuration)
    {
        _logger = logger;
        _configuration = configuration;
    }

    public async Task<OptimizationResult> OptimizeAsync(OptimizationRequest request)
    {
        var stopwatch = Stopwatch.StartNew();
        var result = new OptimizationResult();

        try
        {
            _logger.LogInformation("Starting performance optimization for {Target}", request.Target);

            // Memory optimization
            if (request.OptimizeMemory)
            {
                result.MemoryOptimizations = await OptimizeMemoryAsync();
            }

            // CPU optimization
            if (request.OptimizeCpu)
            {
                result.CpuOptimizations = await OptimizeCpuAsync();
            }

            // I/O optimization
            if (request.OptimizeIo)
            {
                result.IoOptimizations = await OptimizeIoAsync();
            }

            // Network optimization
            if (request.OptimizeNetwork)
            {
                result.NetworkOptimizations = await OptimizeNetworkAsync();
            }

            stopwatch.Stop();
            result.Duration = stopwatch.Elapsed;
            result.Success = true;

            _logger.LogInformation("Performance optimization completed in {Duration}", result.Duration);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error during performance optimization");
            result.Success = false;
            result.Error = ex.Message;
        }

        return result;
    }

    private async Task<List<string>> OptimizeMemoryAsync()
    {
        var optimizations = new List<string>();

        // Force garbage collection
        var beforeMemory = GC.GetTotalMemory(false);
        GC.Collect();
        var afterMemory = GC.GetTotalMemory(false);

        optimizations.Add($"Memory freed: {beforeMemory - afterMemory} bytes");

        // Compact large object heap
        GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.CompactOnce;
        GC.Collect();

        optimizations.Add("Large Object Heap compacted");

        await Task.Delay(100); // Simulate async work
        return optimizations;
    }

    private async Task<List<string>> OptimizeCpuAsync()
    {
        var optimizations = new List<string>();

        // Set processor affinity
        var process = Process.GetCurrentProcess();
        process.ProcessorAffinity = (IntPtr)((1 << Environment.ProcessorCount) - 1);

        optimizations.Add($"Processor affinity set to {Environment.ProcessorCount} cores");

        // Set priority
        process.PriorityClass = ProcessPriorityClass.High;
        optimizations.Add("Process priority set to High");

        await Task.Delay(100);
        return optimizations;
    }

    private async Task<List<string>> OptimizeIoAsync()
    {
        var optimizations = new List<string>();

        // Optimize file system
        var drive = new DriveInfo(Path.GetPathRoot(Environment.CurrentDirectory));
        if (drive.DriveType == DriveType.Fixed)
        {
            // Enable write caching
            optimizations.Add("Write caching enabled for fixed drive");
        }

        await Task.Delay(100);
        return optimizations;
    }

    private async Task<List<string>> OptimizeNetworkAsync()
    {
        var optimizations = new List<string>();

        // Optimize TCP settings
        optimizations.Add("TCP optimization applied");

        await Task.Delay(100);
        return optimizations;
    }
}

public class OptimizationRequest
{
    public string Target { get; set; }
    public bool OptimizeMemory { get; set; } = true;
    public bool OptimizeCpu { get; set; } = true;
    public bool OptimizeIo { get; set; } = true;
    public bool OptimizeNetwork { get; set; } = true;
}

public class OptimizationResult
{
    public bool Success { get; set; }
    public TimeSpan Duration { get; set; }
    public string Error { get; set; }
    public List<string> MemoryOptimizations { get; set; } = new();
    public List<string> CpuOptimizations { get; set; } = new();
    public List<string> IoOptimizations { get; set; } = new();
    public List<string> NetworkOptimizations { get; set; } = new();
}

2. High-Performance Collections

Optimized collection implementations.

public class HighPerformanceList<T>
{
    private T[] _items;
    private int _count;
    private int _capacity;

    public HighPerformanceList(int initialCapacity = 16)
    {
        _capacity = initialCapacity;
        _items = new T[_capacity];
        _count = 0;
    }

    public void Add(T item)
    {
        if (_count == _capacity)
        {
            Grow();
        }

        _items[_count] = item;
        _count++;
    }

    public void AddRange(IEnumerable<T> items)
    {
        foreach (var item in items)
        {
            Add(item);
        }
    }

    public void Clear()
    {
        Array.Clear(_items, 0, _count);
        _count = 0;
    }

    public T this[int index]
    {
        get
        {
            if (index < 0 || index >= _count)
                throw new ArgumentOutOfRangeException(nameof(index));

            return _items[index];
        }
        set
        {
            if (index < 0 || index >= _count)
                throw new ArgumentOutOfRangeException(nameof(index));

            _items[index] = value;
        }
    }

    public int Count => _count;
    public int Capacity => _capacity;

    private void Grow()
    {
        var newCapacity = _capacity * 2;
        var newItems = new T[newCapacity];
        Array.Copy(_items, newItems, _count);
        _items = newItems;
        _capacity = newCapacity;
    }

    public T[] ToArray()
    {
        var result = new T[_count];
        Array.Copy(_items, result, _count);
        return result;
    }
}

public class ObjectPool<T> where T : class, new()
{
    private readonly ConcurrentQueue<T> _pool;
    private readonly int _maxSize;
    private int _currentSize;

    public ObjectPool(int maxSize = 100)
    {
        _pool = new ConcurrentQueue<T>();
        _maxSize = maxSize;
        _currentSize = 0;
    }

    public T Rent()
    {
        if (_pool.TryDequeue(out T item))
        {
            Interlocked.Decrement(ref _currentSize);
            return item;
        }

        return new T();
    }

    public void Return(T item)
    {
        if (item == null) return;

        if (_currentSize < _maxSize)
        {
            _pool.Enqueue(item);
            Interlocked.Increment(ref _currentSize);
        }
    }

    public void Clear()
    {
        while (_pool.TryDequeue(out _)) { }
        Interlocked.Exchange(ref _currentSize, 0);
    }
}

Benchmarking

1. Benchmark Runner

Performance benchmarking yapan servis.

public class BenchmarkRunner
{
    private readonly ILogger<BenchmarkRunner> _logger;

    public BenchmarkRunner(ILogger<BenchmarkRunner> logger)
    {
        _logger = logger;
    }

    public async Task<BenchmarkResult> RunBenchmarkAsync<T>(Benchmark<T> benchmark, int iterations = 1000)
    {
        var result = new BenchmarkResult
        {
            BenchmarkName = benchmark.Name,
            Iterations = iterations,
            StartTime = DateTime.UtcNow
        };

        try
        {
            // Warmup
            await WarmupAsync(benchmark);

            // Run benchmark
            var measurements = new List<long>();

            for (int i = 0; i < iterations; i++)
            {
                var stopwatch = Stopwatch.StartNew();
                await benchmark.Action();
                stopwatch.Stop();

                measurements.Add(stopwatch.ElapsedTicks);
            }

            // Calculate statistics
            result.Measurements = measurements;
            result.CalculateStatistics();

            _logger.LogInformation("Benchmark {Name} completed. Average: {Average} ticks, " +
                "Min: {Min}, Max: {Max}, StdDev: {StdDev}",
                benchmark.Name, result.AverageTicks, result.MinTicks, result.MaxTicks, result.StandardDeviation);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error running benchmark {Name}", benchmark.Name);
            result.Error = ex.Message;
        }

        result.EndTime = DateTime.UtcNow;
        result.Duration = result.EndTime - result.StartTime;

        return result;
    }

    private async Task WarmupAsync<T>(Benchmark<T> benchmark)
    {
        for (int i = 0; i < 10; i++)
        {
            await benchmark.Action();
        }
    }

    public async Task<List<BenchmarkResult>> CompareBenchmarksAsync<T>(IEnumerable<Benchmark<T>> benchmarks, int iterations = 1000)
    {
        var results = new List<BenchmarkResult>();

        foreach (var benchmark in benchmarks)
        {
            var result = await RunBenchmarkAsync(benchmark, iterations);
            results.Add(result);
        }

        // Sort by performance
        results.Sort((a, b) => a.AverageTicks.CompareTo(b.AverageTicks));

        return results;
    }
}

public class Benchmark<T>
{
    public string Name { get; set; }
    public Func<Task> Action { get; set; }

    public Benchmark(string name, Func<Task> action)
    {
        Name = name;
        Action = action;
    }
}

public class BenchmarkResult
{
    public string BenchmarkName { get; set; }
    public int Iterations { get; set; }
    public DateTime StartTime { get; set; }
    public DateTime EndTime { get; set; }
    public TimeSpan Duration { get; set; }
    public List<long> Measurements { get; set; } = new();
    public string Error { get; set; }

    // Statistics
    public double AverageTicks { get; private set; }
    public long MinTicks { get; private set; }
    public long MaxTicks { get; private set; }
    public double StandardDeviation { get; private set; }
    public double MedianTicks { get; private set; }

    public void CalculateStatistics()
    {
        if (!Measurements.Any()) return;

        var sorted = Measurements.OrderBy(x => x).ToList();

        AverageTicks = Measurements.Average(x => x);
        MinTicks = sorted.First();
        MaxTicks = sorted.Last();
        MedianTicks = sorted[sorted.Count / 2];

        // Calculate standard deviation
        var variance = Measurements.Average(x => Math.Pow(x - AverageTicks, 2));
        StandardDeviation = Math.Sqrt(variance);
    }
}

Mülakat Soruları

Temel Sorular

1. Performance optimization nedir?

2. Cevap: Uygulama performansını artırmak için yapılan iyileştirmeler.

3. Benchmarking neden önemlidir?

4. Cevap: Performance measurement, optimization validation, regression detection.

5. Object pooling nedir?

6. Cevap: Object reuse pattern, allocation overhead reduction, GC pressure minimization.

7. High-performance collections nelerdir?

8. Cevap: Optimized data structures, reduced allocations, better memory usage.

9. Performance profiling nasıl yapılır?

10. Cevap: Tools like dotTrace, custom profilers, performance counters.

Teknik Sorular

1. Performance optimization techniques nelerdir?

2. Cevap: Algorithm optimization, memory management, I/O optimization, caching.

3. Benchmarking best practices nelerdir?

4. Cevap: Warmup, multiple iterations, statistical analysis, environment consistency.

5. Object pooling nasıl implement edilir?

6. Cevap: Rent/Return pattern, thread safety, size management, cleanup.

7. Performance regression nasıl tespit edilir?

8. Cevap: Continuous benchmarking, threshold monitoring, trend analysis.

9. High-performance code nasıl yazılır?

10. Cevap: Avoid allocations, use value types, optimize algorithms, profile first.

Best Practices

1. Performance Optimization
2. Profile first, optimize second
3. Measure before and after
4. Focus on bottlenecks

5. Use appropriate data structures

6. Benchmarking

7. Consistent environment
8. Multiple iterations
9. Statistical analysis

10. Regression detection

11. Memory Management

12. Object pooling
13. Array pooling
14. Reduce allocations

15. Use value types

16. Algorithm Optimization

17. Choose right algorithms
18. Cache results
19. Parallel processing

20. Lazy evaluation

21. I/O Optimization

22. Async operations
23. Buffering
24. Connection pooling
25. Batch processing

Kaynaklar

• Performance Best Practices
• Benchmarking
• Performance Profiling
• High Performance
• Optimization Techniques