netcore/System.Private.CoreLib/src/System/GC.cs

   1 // Licensed to the .NET Foundation under one or more agreements.
   2 // The .NET Foundation licenses this file to you under the MIT license.
   3 // See the LICENSE file in the project root for more information.
   4
   5 using System.Runtime.CompilerServices;
   6
   7 namespace System
   8 {
   9         public enum GCCollectionMode
  10         {
  11                 Default = 0,
  12                 Forced = 1,
  13                 Optimized = 2
  14         }
  15
  16         public enum GCNotificationStatus
  17         {
  18                 Succeeded = 0,
  19                 Failed = 1,
  20                 Canceled = 2,
  21                 Timeout = 3,
  22                 NotApplicable = 4
  23         }
  24
  25         public static partial class GC
  26         {
  27                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
  28                 extern static int GetCollectionCount (int generation);
  29
  30                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
  31                 extern static int GetMaxGeneration ();
  32
  33                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
  34                 extern static void InternalCollect (int generation);
  35
  36                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
  37                 extern static void RecordPressure (long bytesAllocated);
  38
  39                 // TODO: Move following to ConditionalWeakTable
  40                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
  41                 internal extern static void register_ephemeron_array (Ephemeron[] array);
  42
  43                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
  44                 extern static object get_ephemeron_tombstone ();
  45
  46                 internal static readonly object EPHEMERON_TOMBSTONE = get_ephemeron_tombstone ();
  47
  48                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
  49                 public static extern long GetAllocatedBytesForCurrentThread ();
  50
  51                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
  52                 public static extern long GetTotalAllocatedBytes (bool precise = false);
  53
  54                 public static void AddMemoryPressure (long bytesAllocated)
  55                 {
  56                         if (bytesAllocated <= 0)
  57                                 throw new ArgumentOutOfRangeException (nameof (bytesAllocated), SR.ArgumentOutOfRange_NeedPosNum);
  58                         if (IntPtr.Size == 4 && bytesAllocated > Int32.MaxValue)
  59                                 throw new ArgumentOutOfRangeException (nameof (bytesAllocated), SR.ArgumentOutOfRange_MustBeNonNegInt32);
  60                         RecordPressure (bytesAllocated);
  61                 }
  62
  63                 public static void RemoveMemoryPressure (long bytesAllocated)
  64                 {
  65                         if (bytesAllocated <= 0)
  66                                 throw new ArgumentOutOfRangeException (nameof (bytesAllocated), SR.ArgumentOutOfRange_NeedPosNum);
  67                         if (IntPtr.Size == 4 && bytesAllocated > Int32.MaxValue)
  68                                 throw new ArgumentOutOfRangeException (nameof (bytesAllocated), SR.ArgumentOutOfRange_MustBeNonNegInt32);
  69                         RecordPressure (-bytesAllocated);
  70                 }
  71
  72                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
  73                 public static extern int GetGeneration (object obj);
  74
  75                 public static void Collect (int generation)
  76                 {
  77                         Collect (generation, GCCollectionMode.Default);
  78                 }
  79
  80                 public static void Collect ()
  81                 {
  82                         InternalCollect (MaxGeneration);
  83                 }
  84
  85                 public static void Collect (int generation, GCCollectionMode mode) => Collect (generation, mode, true);
  86
  87                 public static void Collect (int generation, GCCollectionMode mode, bool blocking) => Collect (generation, mode, blocking, false);
  88
  89                 public static void Collect (int generation, GCCollectionMode mode, bool blocking, bool compacting)
  90                 {
  91                         if (generation < 0)
  92                                 throw new ArgumentOutOfRangeException (nameof (generation), "generation", SR.ArgumentOutOfRange_GenericPositive);
  93                         if ((mode < GCCollectionMode.Default) || (mode > GCCollectionMode.Optimized))
  94                                 throw new ArgumentOutOfRangeException (nameof (mode), SR.ArgumentOutOfRange_Enum);
  95
  96                         InternalCollect (generation);
  97                 }
  98
  99                 public static int CollectionCount (int generation)
 100                 {
 101                         if (generation < 0)
 102                                 throw new ArgumentOutOfRangeException (nameof (generation), SR.ArgumentOutOfRange_GenericPositive);
 103                         return GetCollectionCount (generation);
 104                 }
 105
 106                 [MethodImplAttribute (MethodImplOptions.NoInlining)] // disable optimizations
 107                 public static void KeepAlive (object obj)
 108                 {
 109                 }
 110
 111                 public static int GetGeneration (WeakReference wo)
 112                 {
 113                         object obj = wo.Target;
 114                         if (obj == null)
 115                                 throw new ArgumentException ();
 116                         return GetGeneration (obj);
 117                 }
 118
 119                 public static int MaxGeneration {
 120                         get {
 121                                 return GetMaxGeneration ();
 122                         }
 123                 }
 124
 125                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 126                 public static extern void WaitForPendingFinalizers ();
 127
 128                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 129                 static extern void _SuppressFinalize (object o);
 130
 131                 public static void SuppressFinalize (object obj)
 132                 {
 133                         if (obj == null)
 134                                 throw new ArgumentNullException (nameof (obj));
 135                         _SuppressFinalize (obj);
 136                 }
 137
 138                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 139                 static extern void _ReRegisterForFinalize (object o);
 140
 141                 public static void ReRegisterForFinalize (object obj)
 142                 {
 143                         if (obj == null)
 144                                 throw new ArgumentNullException (nameof (obj));
 145                         _ReRegisterForFinalize (obj);
 146                 }
 147
 148                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 149                 public extern static long GetTotalMemory (bool forceFullCollection);
 150
 151                 static bool _RegisterForFullGCNotification (int maxGenerationPercentage, int largeObjectHeapPercentage)
 152                 {
 153                         throw new NotImplementedException ();
 154                 }
 155
 156                 static bool _CancelFullGCNotification ()
 157                 {
 158                         throw new NotImplementedException ();
 159                 }
 160
 161                 static GCNotificationStatus _WaitForFullGCApproach (int millisecondsTimeout)
 162                 {
 163                         throw new NotImplementedException ();
 164                 }
 165
 166                 static GCNotificationStatus _WaitForFullGCComplete (int millisecondsTimeout)
 167                 {
 168                         throw new NotImplementedException ();
 169                 }
 170
 171                 public static void RegisterForFullGCNotification (int maxGenerationThreshold, int largeObjectHeapThreshold)
 172                 {
 173                         if ((maxGenerationThreshold <= 0) || (maxGenerationThreshold >= 100))
 174                                 throw new ArgumentOutOfRangeException (nameof (maxGenerationThreshold),
 175                                                                                                            SR.Format (SR.ArgumentOutOfRange_Bounds_Lower_Upper, 1, 99));
 176                         if ((largeObjectHeapThreshold <= 0) || (largeObjectHeapThreshold >= 100))
 177                                 throw new ArgumentOutOfRangeException (nameof (largeObjectHeapThreshold),
 178                                                                                                            SR.Format (SR.ArgumentOutOfRange_Bounds_Lower_Upper, 1, 99));
 179
 180                         if (!_RegisterForFullGCNotification (maxGenerationThreshold, largeObjectHeapThreshold))
 181                                 throw new InvalidOperationException (SR.InvalidOperation_NotWithConcurrentGC);
 182                 }
 183
 184                 public static void CancelFullGCNotification ()
 185                 {
 186                         if (!_CancelFullGCNotification ())
 187                                 throw new InvalidOperationException (SR.InvalidOperation_NotWithConcurrentGC);
 188                 }
 189
 190                 public static GCNotificationStatus WaitForFullGCApproach ()
 191                 {
 192                         return (GCNotificationStatus) _WaitForFullGCApproach (-1);
 193                 }
 194
 195                 public static GCNotificationStatus WaitForFullGCApproach (int millisecondsTimeout)
 196                 {
 197                         if (millisecondsTimeout < -1)
 198                                 throw new ArgumentOutOfRangeException (nameof (millisecondsTimeout), SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
 199
 200                         return _WaitForFullGCApproach (millisecondsTimeout);
 201                 }
 202
 203                 public static GCNotificationStatus WaitForFullGCComplete ()
 204                 {
 205                         return _WaitForFullGCComplete (-1);
 206                 }
 207
 208                 public static GCNotificationStatus WaitForFullGCComplete (int millisecondsTimeout)
 209                 {
 210                         if (millisecondsTimeout < -1)
 211                                 throw new ArgumentOutOfRangeException (nameof (millisecondsTimeout), SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
 212                         return _WaitForFullGCComplete (millisecondsTimeout);
 213                 }
 214
 215                 static bool StartNoGCRegion (long totalSize, bool hasLohSize, long lohSize, bool disallowFullBlockingGC)
 216                 {
 217                         throw new NotImplementedException ();
 218                 }
 219
 220                 public static bool TryStartNoGCRegion (long totalSize) => StartNoGCRegion (totalSize, false, 0, false);
 221
 222                 public static bool TryStartNoGCRegion (long totalSize, long lohSize) => StartNoGCRegion (totalSize, true, lohSize, false);
 223
 224                 public static bool TryStartNoGCRegion (long totalSize, bool disallowFullBlockingGC) => StartNoGCRegion (totalSize, false, 0, disallowFullBlockingGC);
 225
 226                 public static bool TryStartNoGCRegion (long totalSize, long lohSize, bool disallowFullBlockingGC) => StartNoGCRegion (totalSize, true, lohSize, disallowFullBlockingGC);
 227
 228                 public static void EndNoGCRegion ()
 229                 {
 230                         throw new NotImplementedException ();
 231                 }
 232
 233                 internal static ulong GetSegmentSize ()
 234                 {
 235                         // coreclr default
 236                         return 1024 * 1024 * 16;
 237                 }
 238
 239                 public static GCMemoryInfo GetGCMemoryInfo ()
 240                 {
 241                         // TODO: Implement
 242                         return default;
 243                 }
 244
 245                 internal static T[] AllocateUninitializedArray<T> (int length)
 246                 {
 247                         // Mono only does explicit zeroning if the array is to big for the nursery, but less than 1 Mb - 4 kb.
 248                         // If it is bigger than that, we grab memoroy directly from the OS which comes pre-zeroed.
 249                         // Experimentation shows that if we just skip the zeroing in this case, we do not save a measurable
 250                         // amount of time. So we just allocate the normal way here.
 251                         // Revist if we change LOS implementation.
 252                         return new T [length];
 253                 }
 254         }
 255 }