Benutzer:MovGP0/NET/Performance

Programmierung

.NET Performance

Berechnungen

Amdahlsches Gesetz

→ Hauptartikel: Amdahlsches Gesetz

Perzentil

• Anteil der Fälle die einen bestimmten Wertebereich einhalten müssen.
  Beispiel: 95% der Anforderungen müssen innerhalb von 100 ms bearbeitet werden.
• Es müssen genügend Stichproben gesammelt werden um das Perzentil zu berechnen

Percentil	benötigte Sichproben	Anwendung
50%		Median (≠Durchschnitt)
99%	≈1.000	Normale Anwendungen
99,9%	≈10.000	High-Performance Anwendungen
99,99%	≈100.000
99,999%	≈1.000.000

Siehe auch: Stichprobenumfang und Sample size determination

Measurement Tools

• Performance Counters (perfmon.exe)

• Event Tracing for Windows (ETW)
• PerfView
• CLR Profiler
• WinDbg
• .NET IL Analyzers
• MeasureIt
• Code Instrumentation
  (Stopwatch class)
• SysInternals Utilities Suite
  • ClockRes
  • Diskmon
  • Handle
  • ProcDump
  • ProcessMonitor
  • VMMap

Tipps

• Store measurement results in database for later reference and comparison!

Objektpool

public interface IPoolable : IDisposable
{
   int Sitze { get; }
   void Reset();
   void SetPoolManager(PoolManager poolManager);
}

private class Pool
{
   public Stack<IPoolable> Stack { get; private set; }
   public int PooledSize { get; set; }
   public int Count
   {
      get { return Stack.Count; }
   }

   public Pool()
   {
      Stack = new Stack<IPoolableObject>();
   }
}

public class PoolManager
{
   const int MaxSizePerType = 10 * (1 << 10); // 10 MB
   var pools = new Dictionary<Type, Pool>();
   
   public int TotalCount
   {
      int sum = 0;
      foreach(var pool in this.pools.Values)
      {
         sum += pool.Count;
      }
      
      return sum;
   }

   public T GetObject<T>()
      where T : class, IPoolable, new() // class with implements IPoolable and empty constructor
   {
      Pool pool;
      T valueToReturn = null;
      if(pools.TryGetValue(typeof(T), out pool))
      {
          if(pool.Stack.Count > 0)
          {
             valueToReturn = pool.Stack.Pop() as T;
          }
      }

      if(valueToReturn == null)
      {
         valueToReturn = new T();
      }

      valueToReturn.SetPoolManager(this);
      return valueToReturn;
   }

   public void ReturnObject<T>(T value)
      where T : class, IPoolableObject, new()
   {
      Pool pool;
      if(!pools.TryGetValue(typeof(T)))
      {
         pool = new Pool();
         pools[typeof(T)] = pool;
      }

      if(value.Size + pool.PooledSize < MaxSizePerType)
      {
         pool.PooledSize += value.Size;
         value.Reset();
         pool.Stack.Push(value);
      }
   }
}

public class MyObject : IPoolable
{
   private PoolManager poolManager;
   public byte[] Data { get; set; }
   public int UsableLength { get; set; }
   
   public int Size
   {
      get { return Data != null ? Data.Length : 0; }
   }

   void IPoolable.Reset()
   {
      UsableLength = 0;
   }

   public void Dispose()
   {
      poolManager.ReturnObject(this);
   }
}