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.Threading \ OverlappedDataCache

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. // ==--==
  15. /*=============================================================================
  16. **
  17. ** Class: Overlapped
  18. **
  19. **
  20. ** Purpose: Class for converting information to and from the native
  21. **          overlapped structure used in asynchronous file i/o
  22. **
  23. **
  24. =============================================================================*/
  27. namespace System.Threading
  28. {
  29.     using System;
  30.     using System.Runtime.InteropServices;
  31.     using System.Runtime.CompilerServices;
  32.     using System.Security;
  33.     using System.Security.Permissions;
  34.     using System.Runtime.ConstrainedExecution;
  35.    
  36.     // Valuetype that represents the (unmanaged) Win32 OVERLAPPED structure
  37.     // the layout of this structure must be identical to OVERLAPPED.
  38.     // The first five matches OVERLAPPED structure.
  39.     // The remaining are reserved at the end
  40.     [System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
  41.     [System.Runtime.InteropServices.ComVisible(true)]
  42.     public struct NativeOverlapped
  43.     {
  44.         public IntPtr InternalLow;
  45.         public IntPtr InternalHigh;
  46.         public int OffsetLow;
  47.         public int OffsetHigh;
  48.         public IntPtr EventHandle;
  49.     }
  50.    
  51.     unsafe internal class _IOCompletionCallback
  52.     {
  53.         IOCompletionCallback _ioCompletionCallback;
  54.         ExecutionContext _executionContext;
  55.         uint _errorCode;
  56.         // Error code
  57.         uint _numBytes;
  58.         // No. of bytes transferred
  59.         NativeOverlapped* _pOVERLAP;
  60.        
  61.         internal _IOCompletionCallback(IOCompletionCallback ioCompletionCallback, ref StackCrawlMark stackMark)
  62.         {
  63.             _ioCompletionCallback = ioCompletionCallback;
  64.             // clone the exection context
  65.             _executionContext = ExecutionContext.Capture(ref stackMark);
  66.             ExecutionContext.ClearSyncContext(_executionContext);
  67.         }
  68.         // Context callback: same sig for SendOrPostCallback and ContextCallback
  69.         static internal ContextCallback _ccb = new ContextCallback(IOCompletionCallback_Context);
  70.         static internal void IOCompletionCallback_Context(object state)
  71.         {
  72.             _IOCompletionCallback helper = (_IOCompletionCallback)state;
  73.             BCLDebug.Assert(helper != null, "_IOCompletionCallback cannot be null");
  74.             helper._ioCompletionCallback(helper._errorCode, helper._numBytes, helper._pOVERLAP);
  75.         }
  76.        
  77.        
  78.         // call back helper
  79.             // Error code
  80.             // No. of bytes transferred
  81.         // ptr to OVERLAP structure
  82.         unsafe static internal void PerformIOCompletionCallback(uint errorCode, uint numBytes, NativeOverlapped* pOVERLAP)
  83.         {
  84.             Overlapped overlapped = OverlappedData.GetOverlappedFromNative(pOVERLAP).m_overlapped;
  85.             _IOCompletionCallback helper = overlapped.iocbHelper;
  86.            
  87.             if (helper == null || helper._executionContext == null || helper._executionContext.IsDefaultFTContext()) {
  88.                 // We got here because of UnsafePack (or) Pack with EC flow supressed
  89.                 IOCompletionCallback callback = overlapped.UserCallback;
  90.                 callback(errorCode, numBytes, pOVERLAP);
  91.             }
  92.             else {
  93.                 // We got here because of Pack
  94.                 helper._errorCode = errorCode;
  95.                 helper._numBytes = numBytes;
  96.                 helper._pOVERLAP = pOVERLAP;
  97.                 ExecutionContext.Run(helper._executionContext.CreateCopy(), _ccb, helper);
  98.             }
  99.         }
  100.     }
  101.    
  102.     internal sealed class OverlappedData : CriticalFinalizerObject
  103.     {
  104.         // ! If you make any change to the layout here, you need to make matching change
  105.         // ! to OverlappedObject in vm\nativeoverlapped.h
  106.         internal IAsyncResult m_asyncResult;
  107.         internal IOCompletionCallback m_iocb;
  108.         internal _IOCompletionCallback m_iocbHelper;
  109.         internal Overlapped m_overlapped;
  110.         private object m_userObject;
  111.         internal OverlappedDataCacheLine m_cacheLine;
  112.         private IntPtr m_pinSelf;
  113.         private IntPtr m_userObjectInternal;
  114.         private int m_AppDomainId;
  115.         internal short m_slot;
  116.         #pragma warning disable 414 // Field is not used from managed.
  117.         #pragma warning disable 169
  118.         private byte m_isArray;
  119.         private byte m_toBeCleaned;
  120.         #pragma warning restore 414
  121.         #pragma warning restore 169
  122.         internal NativeOverlapped m_nativeOverlapped;
  123.        
  124.         internal OverlappedData(OverlappedDataCacheLine cacheLine)
  125.         {
  126.             m_cacheLine = cacheLine;
  127.         }
  128.        
  129.         ~OverlappedData()
  130.         {
  131.             if (null != m_cacheLine && false == m_cacheLine.Removed) {
  132.                 // If user drops reference to Overlapped before calling Pack,
  133.                 // let us return the entry to cache
  134.                 if (!Environment.HasShutdownStarted && !AppDomain.CurrentDomain.IsFinalizingForUnload()) {
  135.                     // If user drops reference to OverlappedData before pack,
  136.                     // we return the object to cache.
  137.                     // We try to keep all items in cache until the whole cache line is not needed.
  138.                     OverlappedDataCache.CacheOverlappedData(this);
  139.                     GC.ReRegisterForFinalize(this);
  140.                 }
  141.             }
  142.         }
  143.        
  144.         internal void ReInitialize()
  145.         {
  146.             m_asyncResult = null;
  147.             m_iocb = null;
  148.             m_iocbHelper = null;
  149.             m_overlapped = null;
  150.             m_userObject = null;
  151.             BCLDebug.Assert(m_pinSelf.IsNull(), "OverlappedData has not been freed: m_pinSelf");
  152.             m_pinSelf = (IntPtr)0;
  153.             m_userObjectInternal = (IntPtr)0;
  154.             BCLDebug.Assert(m_AppDomainId == 0 || m_AppDomainId == AppDomain.CurrentDomain.Id, "OverlappedData is not in the current domain");
  155.             m_AppDomainId = 0;
  156.             m_nativeOverlapped.EventHandle = (IntPtr)0;
  157.             m_isArray = 0;
  158.             m_nativeOverlapped.InternalHigh = (IntPtr)0;
  159.         }
  160.        
  161.         unsafe internal NativeOverlapped* Pack(IOCompletionCallback iocb, object userData)
  162.         {
  163.             if (!m_pinSelf.IsNull()) {
  164.                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_Overlapped_Pack"));
  165.             }
  166.             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
  167.            
  168.             if (iocb != null) {
  169.                 m_iocbHelper = new _IOCompletionCallback(iocb, ref stackMark);
  170.                 m_iocb = iocb;
  171.             }
  172.             else {
  173.                 m_iocbHelper = null;
  174.                 m_iocb = null;
  175.             }
  176.             m_userObject = userData;
  177.             if (m_userObject != null) {
  178.                 if (m_userObject.GetType() == typeof(object[])) {
  179.                     m_isArray = 1;
  180.                 }
  181.                 else {
  182.                     m_isArray = 0;
  183.                 }
  184.             }
  185.             return AllocateNativeOverlapped();
  186.         }
  187.        
  188.         [SecurityPermissionAttribute(SecurityAction.LinkDemand, ControlEvidence = true, ControlPolicy = true)]
  189.         unsafe internal NativeOverlapped* UnsafePack(IOCompletionCallback iocb, object userData)
  190.         {
  191.             if (!m_pinSelf.IsNull()) {
  192.                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_Overlapped_Pack"));
  193.             }
  194.             m_userObject = userData;
  195.             if (m_userObject != null) {
  196.                 if (m_userObject.GetType() == typeof(object[])) {
  197.                     m_isArray = 1;
  198.                 }
  199.                 else {
  200.                     m_isArray = 0;
  201.                 }
  202.             }
  203.             m_iocb = iocb;
  204.             m_iocbHelper = null;
  205.             return AllocateNativeOverlapped();
  206.         }
  207.        
  208.         [ComVisible(false)]
  209.         internal IntPtr UserHandle {
  210.             get { return m_nativeOverlapped.EventHandle; }
  211.             set { m_nativeOverlapped.EventHandle = value; }
  212.         }
  213.        
  214.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  215.         unsafe private extern NativeOverlapped* AllocateNativeOverlapped();
  216.        
  217.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  218.         unsafe static internal extern void FreeNativeOverlapped(NativeOverlapped* nativeOverlappedPtr);
  219.        
  220.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  221.         unsafe static internal extern OverlappedData GetOverlappedFromNative(NativeOverlapped* nativeOverlappedPtr);
  222.     }
  223.    
  224.     /// <internalonly/>
  225.     [System.Runtime.InteropServices.ComVisible(true)]
  226.     public class Overlapped
  227.     {
  228.         private OverlappedData m_overlappedData;
  229.        
  230.         public Overlapped()
  231.         {
  232.             m_overlappedData = OverlappedDataCache.GetOverlappedData(this);
  233.         }
  234.        
  235.         public Overlapped(int offsetLo, int offsetHi, IntPtr hEvent, IAsyncResult ar)
  236.         {
  237.             m_overlappedData = OverlappedDataCache.GetOverlappedData(this);
  238.             m_overlappedData.m_nativeOverlapped.OffsetLow = offsetLo;
  239.             m_overlappedData.m_nativeOverlapped.OffsetHigh = offsetHi;
  240.             m_overlappedData.UserHandle = hEvent;
  241.             m_overlappedData.m_asyncResult = ar;
  242.         }
  243.        
  244.         [Obsolete("This constructor is not 64-bit compatible. Use the constructor that takes an IntPtr for the event handle. http://go.microsoft.com/fwlink/?linkid=14202")]
  245.         public Overlapped(int offsetLo, int offsetHi, int hEvent, IAsyncResult ar) : this(offsetLo, offsetHi, new IntPtr(hEvent), ar)
  246.         {
  247.         }
  248.        
  249.         public IAsyncResult AsyncResult {
  250.             get { return m_overlappedData.m_asyncResult; }
  251.             set { m_overlappedData.m_asyncResult = value; }
  252.         }
  253.        
  254.         public int OffsetLow {
  255.             get { return m_overlappedData.m_nativeOverlapped.OffsetLow; }
  256.             set { m_overlappedData.m_nativeOverlapped.OffsetLow = value; }
  257.         }
  258.        
  259.         public int OffsetHigh {
  260.             get { return m_overlappedData.m_nativeOverlapped.OffsetHigh; }
  261.             set { m_overlappedData.m_nativeOverlapped.OffsetHigh = value; }
  262.         }
  263.        
  264.         [Obsolete("This property is not 64-bit compatible. Use EventHandleIntPtr instead. http://go.microsoft.com/fwlink/?linkid=14202")]
  265.         public int EventHandle {
  266.             get { return m_overlappedData.UserHandle.ToInt32(); }
  267.             set { m_overlappedData.UserHandle = new IntPtr(value); }
  268.         }
  269.        
  270.         [ComVisible(false)]
  271.         public IntPtr EventHandleIntPtr {
  272.             get { return m_overlappedData.UserHandle; }
  273.             set { m_overlappedData.UserHandle = value; }
  274.         }
  275.        
  276.         internal _IOCompletionCallback iocbHelper {
  277.             get { return m_overlappedData.m_iocbHelper; }
  278.         }
  279.        
  280.         internal IOCompletionCallback UserCallback {
  281.             get { return m_overlappedData.m_iocb; }
  282.         }
  283.        
  284. /*====================================================================
  285.         *  Packs a managed overlapped class into native Overlapped struct.
  286.         *  Roots the iocb and stores it in the ReservedCOR field of native Overlapped
  287.         *  Pins the native Overlapped struct and returns the pinned index.
  288.         ====================================================================*/       
  289.         [Obsolete("This method is not safe. Use Pack (iocb, userData) instead. http://go.microsoft.com/fwlink/?linkid=14202")]
  290.         [CLSCompliant(false)]
  291.         unsafe public NativeOverlapped* Pack(IOCompletionCallback iocb)
  292.         {
  293.             return Pack(iocb, null);
  294.         }
  295.        
  296.         [CLSCompliant(false), ComVisible(false)]
  297.         unsafe public NativeOverlapped* Pack(IOCompletionCallback iocb, object userData)
  298.         {
  299.             return m_overlappedData.Pack(iocb, userData);
  300.         }
  301.        
  302.         [Obsolete("This method is not safe. Use UnsafePack (iocb, userData) instead. http://go.microsoft.com/fwlink/?linkid=14202")]
  303.         [CLSCompliant(false)]
  304.         [SecurityPermissionAttribute(SecurityAction.LinkDemand, ControlEvidence = true, ControlPolicy = true)]
  305.         unsafe public NativeOverlapped* UnsafePack(IOCompletionCallback iocb)
  306.         {
  307.             return UnsafePack(iocb, null);
  308.         }
  309.        
  310.         [CLSCompliant(false), ComVisible(false)]
  311.         [SecurityPermissionAttribute(SecurityAction.LinkDemand, ControlEvidence = true, ControlPolicy = true)]
  312.         unsafe public NativeOverlapped* UnsafePack(IOCompletionCallback iocb, object userData)
  313.         {
  314.             return m_overlappedData.UnsafePack(iocb, userData);
  315.         }
  316.        
  317. /*====================================================================
  318.         *  Unpacks an unmanaged native Overlapped struct.
  319.         *  Unpins the native Overlapped struct
  320.         ====================================================================*/       
  321.         [CLSCompliant(false)]
  322.         unsafe public static Overlapped Unpack(NativeOverlapped* nativeOverlappedPtr)
  323.         {
  324.             if (nativeOverlappedPtr == null)
  325.                 throw new ArgumentNullException("nativeOverlappedPtr");
  326.            
  327.             Overlapped overlapped = OverlappedData.GetOverlappedFromNative(nativeOverlappedPtr).m_overlapped;
  328.            
  329.             return overlapped;
  330.         }
  331.        
  332.         [CLSCompliant(false)]
  333.         unsafe public static void Free(NativeOverlapped* nativeOverlappedPtr)
  334.         {
  335.             if (nativeOverlappedPtr == null)
  336.                 throw new ArgumentNullException("nativeOverlappedPtr");
  337.            
  338.             Overlapped overlapped = OverlappedData.GetOverlappedFromNative(nativeOverlappedPtr).m_overlapped;
  339.             OverlappedData.FreeNativeOverlapped(nativeOverlappedPtr);
  340.             OverlappedData overlappedData = overlapped.m_overlappedData;
  341.             overlapped.m_overlappedData = null;
  342.             OverlappedDataCache.CacheOverlappedData(overlappedData);
  343.         }
  344.        
  345.     }
  346.    
  347.     // We try to reuse all items in a cache line.
  348.     // When the cache line is not needed, we release all items associated.
  349.     internal sealed class OverlappedDataCacheLine
  350.     {
  351.         internal OverlappedData[] m_items;
  352.         internal OverlappedDataCacheLine m_next;
  353.         private bool m_removed;
  354.         internal const short CacheSize = 16;
  355.        
  356.         internal OverlappedDataCacheLine()
  357.         {
  358.             m_items = new OverlappedData[OverlappedDataCacheLine.CacheSize];
  359.             // Allocate some dummy objects before and after the cacheLine.
  360.             // These objects will allow GC to move two cacheLine's closer.
  361.             new object();
  362.             for (short i = 0; i < OverlappedDataCacheLine.CacheSize; i++) {
  363.                 m_items[i] = new OverlappedData(this);
  364.                 m_items[i].m_slot = i;
  365.             }
  366.             new object();
  367.         }
  368.        
  369.         ~OverlappedDataCacheLine()
  370.         {
  371.             m_removed = true;
  372.         }
  373.        
  374.         internal bool Removed {
  375.             get { return m_removed; }
  376.             set { m_removed = value; }
  377.         }
  378.     }
  379.    
  380.     internal sealed class OverlappedDataCache : CriticalFinalizerObject
  381.     {
  382.         // OverlappedData will be pinned during async io operation.
  383.         // In order to avoid pinning in gen 0, we use a cache to recycle OverlappedData.
  384.         private static OverlappedDataCacheLine m_overlappedDataCache;
  385.         private static int m_overlappedDataCacheAccessed;
  386.         private static int m_cleanupObjectCount;
  387.         private static float m_CleanupThreshold;
  388.         private const float m_CleanupStep = 0.05f;
  389.         private const float m_CleanupInitialThreadhold = 0.3f;
  390.        
  391.         private int m_gen2GCCount;
  392.         private bool m_ready;
  393.        
  394.         //static private int m_CollectionCount;
  395.        
  396. /*
  397.         static private int m_Create = 0;
  398.         static private int m_Total = 0;
  399.         static private int m_Cache = 0;
  400.         */       
  401.        
  402.         // Setup the cache.
  403.         private static void GrowOverlappedDataCache()
  404.         {
  405.             OverlappedDataCacheLine data = new OverlappedDataCacheLine();
  406.             if (m_overlappedDataCache == null) {
  407.                 // Add the first node in the list
  408.                 if (Interlocked.CompareExchange<OverlappedDataCacheLine>(ref m_overlappedDataCache, data, null) == null) {
  409.                     // Use GC to remove items.
  410.                     new OverlappedDataCache();
  411.                     return;
  412.                 }
  413.             }
  414.            
  415.             // If there is already a first node in the list we'll add the new OverlappedDataCacheLine at the end
  416.             if (m_cleanupObjectCount == 0) {
  417.                 new OverlappedDataCache();
  418.             }
  419.            
  420.             while (true) {
  421.                 // Chain the new node
  422.                 OverlappedDataCacheLine walk = m_overlappedDataCache;
  423.                 while (null != walk && null != walk.m_next) {
  424.                     // There's a race with the finalizer here between testing if walk.m_next is null and assigning
  425.                     // Note 1.
  426.                     // If walk has been removed from the list by the finalizer thread we still have a valid
  427.                     // walk.next chain that will eventually lead us back to the original list, or to NULL.
  428.                     // If NULL see Note 4 below.
  429.                     // Note 2.
  430.                     // If walk.next was removed from list the next time through the loop we'll be in the
  431.                     // situation described in Note 1.
  432.                     // Note 3.
  433.                     // If walk.next was set to NULL by the finalizer thread we'll need to test for that in the
  434.                     // while condition and after exiting the loop.
  435.                     walk = walk.m_next;
  436.                 }
  437.                 // if walk has become null (due to finalizer race) after the while test
  438.                 // simply return and let GetOverlappedData retry!
  439.                 if (null == walk)
  440.                     return;
  441.                
  442.                 // Add the new OverlappedDataCacheLine at the end of the list.
  443.                 // Note 4.
  444.                 // Even if the node that walk points to has been removed from the list we simply
  445.                 // add the new node to an unreachable graph. GetOverlappedData() will notice that
  446.                 // there are still no empty OverlappedData elements and call us again. The
  447.                 // "unreachable list" will be reclaimed during the next GC.
  448.                 if (Interlocked.CompareExchange<OverlappedDataCacheLine>(ref walk.m_next, data, null) == null)
  449.                     break;
  450.             }
  451.         }
  452.        
  453.        
  454.         static internal OverlappedData GetOverlappedData(Overlapped overlapped)
  455.         {
  456.             OverlappedData overlappedData = null;
  457.            
  458.             Interlocked.Exchange(ref m_overlappedDataCacheAccessed, 1);
  459.            
  460.             while (true) {
  461.                 OverlappedDataCacheLine walk = m_overlappedDataCache;
  462.                 while (null != walk) {
  463.                     for (short i = 0; i < OverlappedDataCacheLine.CacheSize; i++) {
  464.                         if (walk.m_items[i] != null) {
  465.                             overlappedData = Interlocked.Exchange<OverlappedData>(ref walk.m_items[i], null);
  466.                             if (overlappedData != null) {
  467.                                 overlappedData.m_overlapped = overlapped;
  468.                                 return overlappedData;
  469.                             }
  470.                         }
  471.                     }
  472.                    
  473.                     walk = walk.m_next;
  474.                 }
  475.                
  476.                 GrowOverlappedDataCache();
  477.             }
  478.            
  479.             /*
  480.             Interlocked.Increment(ref m_Total);
  481.             Console.WriteLine("OverlappedDataCache get " + m_Total +
  482.                               " create " + m_Create +
  483.                               " Cache " + m_Cache);
  484.             */           
  485.         }
  486.        
  487.         // Return a free OverlappedData to cache if the cache has slot available.
  488.         static internal void CacheOverlappedData(OverlappedData data)
  489.         {
  490.             data.ReInitialize();
  491.            
  492.             data.m_cacheLine.m_items[data.m_slot] = data;
  493.         }
  494.        
  495.         internal OverlappedDataCache()
  496.         {
  497.             if (m_cleanupObjectCount == 0) {
  498.                 m_CleanupThreshold = m_CleanupInitialThreadhold;
  499.                 if (Interlocked.Exchange(ref m_cleanupObjectCount, 1) == 0) {
  500.                     m_ready = true;
  501.                 }
  502.             }
  503.         }
  504.        
  505.         // Per GC, if the cache has not been accessed, remove some items from cache.
  506.         ~OverlappedDataCache()
  507.         {
  508.             if (!m_ready) {
  509.                 return;
  510.             }
  511.            
  512.             if (null == m_overlappedDataCache) {
  513.                 Interlocked.Exchange(ref m_cleanupObjectCount, 0);
  514.                 return;
  515.             }
  516.            
  517.             if (!Environment.HasShutdownStarted && !AppDomain.CurrentDomain.IsFinalizingForUnload()) {
  518.                 GC.ReRegisterForFinalize(this);
  519.             }
  520.            
  521.             int gen2GCCount = GC.CollectionCount(GC.MaxGeneration);
  522.             if (gen2GCCount == m_gen2GCCount) {
  523.                 // Only do the cleanup when a Gen2 GC happens.
  524.                 return;
  525.             }
  526.            
  527.             m_gen2GCCount = gen2GCCount;
  528.            
  529.             // reclaim cache
  530.             OverlappedDataCacheLine prev = null;
  531.             OverlappedDataCacheLine walk = m_overlappedDataCache;
  532.             OverlappedDataCacheLine empty = null;
  533.             OverlappedDataCacheLine preempty = prev;
  534.             int total = 0;
  535.             int used = 0;
  536.             while (walk != null) {
  537.                 total++;
  538.                 bool fUsed = false;
  539.                 for (short i = 0; i < OverlappedDataCacheLine.CacheSize; i++) {
  540.                     if (walk.m_items[i] == null) {
  541.                         fUsed = true;
  542.                         used++;
  543.                     }
  544.                 }
  545.                 if (!fUsed) {
  546.                     preempty = prev;
  547.                     empty = walk;
  548.                 }
  549.                 prev = walk;
  550.                 walk = walk.m_next;
  551.             }
  552.             total *= OverlappedDataCacheLine.CacheSize;
  553.            
  554.             if (null != empty && total * m_CleanupThreshold > used) {
  555.                 // We can remove one cache line
  556.                 // We only remove a cache line if it is empty.
  557.                 if (preempty == null) {
  558.                     m_overlappedDataCache = empty.m_next;
  559.                 }
  560.                 else {
  561.                     preempty.m_next = empty.m_next;
  562.                 }
  563.                
  564.                 empty.Removed = true;
  565.             }
  566.            
  567.             if (m_overlappedDataCacheAccessed != 0) {
  568.                 m_CleanupThreshold = m_CleanupInitialThreadhold;
  569.                 Interlocked.Exchange(ref m_overlappedDataCacheAccessed, 0);
  570.             }
  571.             else {
  572.                 m_CleanupThreshold += m_CleanupStep;
  573.             }
  574.             /*
  575.             OverlappedData[] cache1 = m_overlappedDataCache;
  576.             int length1 = cache1.Length;
  577.             int count1 = 0;
  578.             for (int i1 = 0; i1 < length1; i1 ++)
  579.             {
  580.                 if (cache1[i1] != null)
  581.                 {
  582.                     count1 ++;
  583.                 }
  584.             }
  585.             Console.WriteLine("cleanup left " + count1);
  586.             */           
  587.         }
  588.     }
  589. }

Developer Fusion