Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / wpf / src / Shared / MS / Win32 / handlecollector.cs / 1305600 / handlecollector.cs
using System; using MS.Win32 ; using System.Runtime.InteropServices; namespace MS.Win32 { internal static class HandleCollector { private static HandleType[] handleTypes; private static int handleTypeCount = 0; private static Object handleMutex = new Object(); ////// Adds the given handle to the handle collector. This keeps the /// handle on a "hot list" of objects that may need to be garbage /// collected. /// internal static IntPtr Add(IntPtr handle, int type) { handleTypes[type - 1].Add(); return handle; } internal static SafeHandle Add(SafeHandle handle, int type) { handleTypes[type - 1].Add(); return handle; } internal static void Add(int type) { handleTypes[type - 1].Add(); } ////// Registers a new type of handle with the handle collector. /// internal static int RegisterType(string typeName, int expense, int initialThreshold) { lock (handleMutex) { if (handleTypeCount == 0 || handleTypeCount == handleTypes.Length) { HandleType[] newTypes = new HandleType[handleTypeCount + 10]; if (handleTypes != null) { Array.Copy(handleTypes, 0, newTypes, 0, handleTypeCount); } handleTypes = newTypes; } handleTypes[handleTypeCount++] = new HandleType(typeName, expense, initialThreshold); return handleTypeCount; } } ////// Removes the given handle from the handle collector. Removing a /// handle removes it from our "hot list" of objects that should be /// frequently garbage collected. /// internal static IntPtr Remove(IntPtr handle, int type) { handleTypes[type - 1].Remove(); return handle ; } internal static SafeHandle Remove(SafeHandle handle, int type) { handleTypes[type - 1].Remove(); return handle ; } internal static void Remove(int type) { handleTypes[type - 1].Remove(); } ////// Represents a specific type of handle. /// private class HandleType { internal readonly string name; private int initialThreshHold; private int threshHold; private int handleCount; private readonly int deltaPercent; ////// Creates a new handle type. /// internal HandleType(string name, int expense, int initialThreshHold) { this.name = name; this.initialThreshHold = initialThreshHold; this.threshHold = initialThreshHold; this.deltaPercent = 100 - expense; } ////// Adds a handle to this handle type for monitoring. /// internal void Add() { bool performCollect = false; lock(this) { handleCount++; performCollect = NeedCollection(); if (!performCollect) { return; } } if (performCollect) { #if DEBUG_HANDLECOLLECTOR Debug.WriteLine("HC> Forcing garbage collect"); Debug.WriteLine("HC> name :" + name); Debug.WriteLine("HC> threshHold :" + (threshHold).ToString()); Debug.WriteLine("HC> handleCount :" + (handleCount).ToString()); Debug.WriteLine("HC> deltaPercent:" + (deltaPercent).ToString()); #endif GC.Collect(); // We just performed a GC. If the main thread is in a tight // loop there is a this will cause us to increase handles forever and prevent handle collector // from doing its job. Yield the thread here. This won't totally cause // a finalization pass but it will effectively elevate the priority // of the finalizer thread just for an instant. But how long should // we sleep? We base it on how expensive the handles are because the // more expensive the handle, the more critical that it be reclaimed. int sleep = (100 - deltaPercent) / 4; System.Threading.Thread.Sleep(sleep); } } ////// Determines if this handle type needs a garbage collection pass. /// internal bool NeedCollection() { if (handleCount > threshHold) { threshHold = handleCount + ((handleCount * deltaPercent) / 100); #if DEBUG_HANDLECOLLECTOR Debug.WriteLine("HC> NeedCollection: increase threshHold to " + threshHold); #endif return true; } // If handle count < threshHold, we don't // need to collect, but if it 10% below the next lowest threshhold we // will bump down a rung. We need to choose a percentage here or else // we will oscillate. // int oldThreshHold = (100 * threshHold) / (100 + deltaPercent); if (oldThreshHold >= initialThreshHold && handleCount < (int)(oldThreshHold * .9F)) { #if DEBUG_HANDLECOLLECTOR Debug.WriteLine("HC> NeedCollection: throttle threshhold " + threshHold + " down to " + oldThreshHold); #endif threshHold = oldThreshHold; } return false; } ////// Removes the given handle from our monitor list. /// internal void Remove() { lock(this) { handleCount--; handleCount = Math.Max(0, handleCount); } } } } } // File provided for Reference Use Only by Microsoft Corporation (c) 2007. // Copyright (c) Microsoft Corporation. All rights reserved. using System; using MS.Win32 ; using System.Runtime.InteropServices; namespace MS.Win32 { internal static class HandleCollector { private static HandleType[] handleTypes; private static int handleTypeCount = 0; private static Object handleMutex = new Object(); ////// Adds the given handle to the handle collector. This keeps the /// handle on a "hot list" of objects that may need to be garbage /// collected. /// internal static IntPtr Add(IntPtr handle, int type) { handleTypes[type - 1].Add(); return handle; } internal static SafeHandle Add(SafeHandle handle, int type) { handleTypes[type - 1].Add(); return handle; } internal static void Add(int type) { handleTypes[type - 1].Add(); } ////// Registers a new type of handle with the handle collector. /// internal static int RegisterType(string typeName, int expense, int initialThreshold) { lock (handleMutex) { if (handleTypeCount == 0 || handleTypeCount == handleTypes.Length) { HandleType[] newTypes = new HandleType[handleTypeCount + 10]; if (handleTypes != null) { Array.Copy(handleTypes, 0, newTypes, 0, handleTypeCount); } handleTypes = newTypes; } handleTypes[handleTypeCount++] = new HandleType(typeName, expense, initialThreshold); return handleTypeCount; } } ////// Removes the given handle from the handle collector. Removing a /// handle removes it from our "hot list" of objects that should be /// frequently garbage collected. /// internal static IntPtr Remove(IntPtr handle, int type) { handleTypes[type - 1].Remove(); return handle ; } internal static SafeHandle Remove(SafeHandle handle, int type) { handleTypes[type - 1].Remove(); return handle ; } internal static void Remove(int type) { handleTypes[type - 1].Remove(); } ////// Represents a specific type of handle. /// private class HandleType { internal readonly string name; private int initialThreshHold; private int threshHold; private int handleCount; private readonly int deltaPercent; ////// Creates a new handle type. /// internal HandleType(string name, int expense, int initialThreshHold) { this.name = name; this.initialThreshHold = initialThreshHold; this.threshHold = initialThreshHold; this.deltaPercent = 100 - expense; } ////// Adds a handle to this handle type for monitoring. /// internal void Add() { bool performCollect = false; lock(this) { handleCount++; performCollect = NeedCollection(); if (!performCollect) { return; } } if (performCollect) { #if DEBUG_HANDLECOLLECTOR Debug.WriteLine("HC> Forcing garbage collect"); Debug.WriteLine("HC> name :" + name); Debug.WriteLine("HC> threshHold :" + (threshHold).ToString()); Debug.WriteLine("HC> handleCount :" + (handleCount).ToString()); Debug.WriteLine("HC> deltaPercent:" + (deltaPercent).ToString()); #endif GC.Collect(); // We just performed a GC. If the main thread is in a tight // loop there is a this will cause us to increase handles forever and prevent handle collector // from doing its job. Yield the thread here. This won't totally cause // a finalization pass but it will effectively elevate the priority // of the finalizer thread just for an instant. But how long should // we sleep? We base it on how expensive the handles are because the // more expensive the handle, the more critical that it be reclaimed. int sleep = (100 - deltaPercent) / 4; System.Threading.Thread.Sleep(sleep); } } ////// Determines if this handle type needs a garbage collection pass. /// internal bool NeedCollection() { if (handleCount > threshHold) { threshHold = handleCount + ((handleCount * deltaPercent) / 100); #if DEBUG_HANDLECOLLECTOR Debug.WriteLine("HC> NeedCollection: increase threshHold to " + threshHold); #endif return true; } // If handle count < threshHold, we don't // need to collect, but if it 10% below the next lowest threshhold we // will bump down a rung. We need to choose a percentage here or else // we will oscillate. // int oldThreshHold = (100 * threshHold) / (100 + deltaPercent); if (oldThreshHold >= initialThreshHold && handleCount < (int)(oldThreshHold * .9F)) { #if DEBUG_HANDLECOLLECTOR Debug.WriteLine("HC> NeedCollection: throttle threshhold " + threshHold + " down to " + oldThreshHold); #endif threshHold = oldThreshHold; } return false; } ////// Removes the given handle from our monitor list. /// internal void Remove() { lock(this) { handleCount--; handleCount = Math.Max(0, handleCount); } } } } } // File provided for Reference Use Only by Microsoft Corporation (c) 2007. // Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- GridToolTip.cs
- ReceiveMessageRecord.cs
- ServerValidateEventArgs.cs
- WindowsUpDown.cs
- MetadataCollection.cs
- DetailsViewDeleteEventArgs.cs
- DesignObjectWrapper.cs
- CurrentTimeZone.cs
- KeyProperty.cs
- RelationshipNavigation.cs
- XmlDataProvider.cs
- RequestTimeoutManager.cs
- UIAgentInitializationException.cs
- BaseValidatorDesigner.cs
- COM2Enum.cs
- WebBrowserEvent.cs
- BulletedList.cs
- SoapReflectionImporter.cs
- LogSwitch.cs
- DocumentCollection.cs
- ExitEventArgs.cs
- PrintPreviewGraphics.cs
- DataGridViewColumnDesignTimeVisibleAttribute.cs
- EncoderFallback.cs
- SafeRegistryKey.cs
- ObjectStateEntry.cs
- TreeIterator.cs
- XmlQueryOutput.cs
- XmlDomTextWriter.cs
- DataGridTablesFactory.cs
- DbParameterHelper.cs
- XmlNamespaceManager.cs
- DefaultTraceListener.cs
- LineBreakRecord.cs
- ComplexBindingPropertiesAttribute.cs
- ThreadAbortException.cs
- RelationshipEndMember.cs
- PersistenceTypeAttribute.cs
- TreeNodeBinding.cs
- safemediahandle.cs
- ObjectTokenCategory.cs
- DropShadowEffect.cs
- DesignerOptionService.cs
- DES.cs
- ScopelessEnumAttribute.cs
- XamlContextStack.cs
- ReliableReplySessionChannel.cs
- Separator.cs
- DiagnosticEventProvider.cs
- ListViewItem.cs
- SoapEnumAttribute.cs
- ValidatedControlConverter.cs
- HtmlTernaryTree.cs
- BinaryUtilClasses.cs
- SmiRequestExecutor.cs
- AssemblyBuilder.cs
- PathFigure.cs
- DataGridViewSelectedColumnCollection.cs
- StylusPointDescription.cs
- WebPartConnectionsCancelVerb.cs
- Variant.cs
- TrackingProfile.cs
- odbcmetadatacolumnnames.cs
- StaticFileHandler.cs
- D3DImage.cs
- SQLMembershipProvider.cs
- Point.cs
- XmlnsDefinitionAttribute.cs
- DesignObjectWrapper.cs
- FontEmbeddingManager.cs
- TransformerConfigurationWizardBase.cs
- _Win32.cs
- GlyphRunDrawing.cs
- CodeTypeMember.cs
- CqlQuery.cs
- CroppedBitmap.cs
- TrackingServices.cs
- AuthenticationConfig.cs
- WinEventTracker.cs
- PseudoWebRequest.cs
- Line.cs
- CompositeTypefaceMetrics.cs
- ColorMap.cs
- StreamResourceInfo.cs
- TiffBitmapDecoder.cs
- AuthenticationModuleElementCollection.cs
- WebBrowserUriTypeConverter.cs
- ErrorTableItemStyle.cs
- Clock.cs
- SecurityCapabilities.cs
- FixedSOMElement.cs
- DirectionalLight.cs
- MetadataItemCollectionFactory.cs
- WebPartConnectVerb.cs
- MulticastIPAddressInformationCollection.cs
- webeventbuffer.cs
- DesignerTransactionCloseEvent.cs
- Overlapped.cs
- Single.cs
- AmbientValueAttribute.cs