Quelltext der Seite Benutzer:MovGP0/NET/Performance

{{Benutzer:MovGP0/NavigationsleisteProgrammierung}}

== .NET Performance ==

=== Berechnungen ===
==== Amdahlsches Gesetz ==== 
{{Hauptartikel|Amdahlsches Gesetz}}

==== Perzentil ====
* Anteil der Fälle die einen bestimmten Wertebereich einhalten müssen.<br/>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

{|class="wikitable"
! Percentil !! benötigte Sichproben !! Anwendung
|-
|align="right"| 50% ||align="right"|  || [[Median]] (≠[[Durchschnitt]])
|-
|align="right"| 99% ||align="right"| ≈1.000 || Normale Anwendungen
|-
|align="right"| 99,9% ||align="right"| ≈10.000 ||rowspan="3"| High-Performance Anwendungen
|-
|align="right"| 99,99% ||align="right"| ≈100.000 
|-
|align="right"| 99,999% ||align="right"| ≈1.000.000
|}

''Siehe auch:'' [[Zufallsstichprobe#Stichprobenumfang|Stichprobenumfang]] und [[:en:Sample_size_determination|Sample size determination]]

==== Measurement Tools ====
* Performance Counters (perfmon.exe) 

* Event Tracing for Windows (ETW) 
* [http://www.microsoft.com/en-us/download/details.aspx?id=28567 PerfView]
* [http://clrprofiler.codeplex.com/ CLR Profiler]
* [[WinDbg]]
* .NET IL Analyzers
* [http://measureitdotnet.codeplex.com/ MeasureIt]
* Code Instrumentation<br />(<code>Stopwatch</code> class) 
* [http://technet.microsoft.com/en-us/sysinternals/bb842062 SysInternals Utilities Suite]
** ClockRes
** Diskmon
** Handle
** ProcDump
** ProcessMonitor
** VMMap

; Tipps
* Store measurement results in database for later reference and comparison!

=== [[Objektpool]] ===

<syntaxhighlight lang="csharp">
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);
   }
}
</syntaxhighlight>