We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

The Labs \ Source Viewer \ SSCLI \ System.Runtime.InteropServices \ HandleCollector

SSCLI
  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  16. namespace System.Runtime.InteropServices
  17. {
  18.     using System;
  19.     using System.Threading;
  20.    
  21.     public sealed class HandleCollector
  22.     {
  23.         private const int deltaPercent = 10;
  24.         // this is used for increasing the threshold.
  25.         private string name;
  26.         private int initialThreshold;
  27.         private int maximumThreshold;
  28.         private int threshold;
  29.         private int handleCount;
  30.        
  31.         private int[] gc_counts = new int[3];
  32.         private int gc_gen = 0;
  33.        
  34.         public HandleCollector(string name, int initialThreshold) : this(name, initialThreshold, int.MaxValue)
  35.         {
  36.         }
  37.        
  38.         public HandleCollector(string name, int initialThreshold, int maximumThreshold)
  39.         {
  40.             if (initialThreshold < 0) {
  41.                 throw new ArgumentOutOfRangeException("initialThreshold", SR.GetString(SR.ArgumentOutOfRange_NeedNonNegNumRequired));
  42.             }
  43.            
  44.             if (maximumThreshold < 0) {
  45.                 throw new ArgumentOutOfRangeException("maximumThreshold", SR.GetString(SR.ArgumentOutOfRange_NeedNonNegNumRequired));
  46.             }
  47.            
  48.             if (initialThreshold > maximumThreshold) {
  49.                 throw new ArgumentException(SR.GetString(SR.Argument_InvalidThreshold));
  50.             }
  51.            
  52.             if (name != null) {
  53.                 this.name = name;
  54.             }
  55.             else {
  56.                 this.name = String.Empty;
  57.             }
  58.            
  59.             this.initialThreshold = initialThreshold;
  60.             this.maximumThreshold = maximumThreshold;
  61.             this.threshold = initialThreshold;
  62.             this.handleCount = 0;
  63.         }
  64.        
  65.         public int Count {
  66.             get { return handleCount; }
  67.         }
  68.        
  69.         public int InitialThreshold {
  70.             get { return initialThreshold; }
  71.         }
  72.        
  73.         public int MaximumThreshold {
  74.             get { return maximumThreshold; }
  75.         }
  76.        
  77.         public string Name {
  78.             get { return name; }
  79.         }
  80.        
  81.         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability", "CA2001:AvoidCallingProblematicMethods")]
  82.         // Keep call to GC.Collect()
  83.         public void Add()
  84.         {
  85.             int gen_collect = -1;
  86.             Interlocked.Increment(ref handleCount);
  87.             if (handleCount < 0) {
  88.                 throw new InvalidOperationException(SR.GetString(SR.InvalidOperation_HCCountOverflow));
  89.             }
  90.            
  91.             if (handleCount > threshold) {
  92.                 lock (this) {
  93.                     threshold = handleCount + (handleCount / deltaPercent);
  94.                     gen_collect = gc_gen;
  95.                     if (gc_gen < 2) {
  96.                         gc_gen++;
  97.                     }
  98.                 }
  99.             }
  100.            
  101.             if ((gen_collect >= 0) && ((gen_collect == 0) || (gc_counts[gen_collect] == GC.CollectionCount(gen_collect)))) {
  102.                 GC.Collect(gen_collect);
  103.                 Thread.Sleep(10 * gen_collect);
  104.             }
  105.            
  106.             //don't bother with gen0.
  107.             for (int i = 1; i < 3; i++) {
  108.                 gc_counts[i] = GC.CollectionCount(i);
  109.             }
  110.         }
  111.        
  112.         public void Remove()
  113.         {
  114.             Interlocked.Decrement(ref handleCount);
  115.             if (handleCount < 0) {
  116.                 throw new InvalidOperationException(SR.GetString(SR.InvalidOperation_HCCountOverflow));
  117.             }
  118.            
  119.             int newThreshold = handleCount + handleCount / deltaPercent;
  120.             if (newThreshold < (threshold - threshold / deltaPercent)) {
  121.                 lock (this) {
  122.                     if (newThreshold > initialThreshold) {
  123.                         threshold = newThreshold;
  124.                     }
  125.                     else {
  126.                         threshold = initialThreshold;
  127.                     }
  128.                     gc_gen = 0;
  129.                 }
  130.             }
  131.            
  132.             for (int i = 1; i < 3; i++) {
  133.                 gc_counts[i] = GC.CollectionCount(i);
  134.             }
  135.         }
  136.     }
  137. }

Developer Fusion