how to make python ignore an object for garbage collection?

In python 3.7 you might be able to hack something using https://docs.python.org/3/library/gc.html#gc.freeze

allocate_a_lot()
gc.freeze() # move all objects to a permanent generation.none will be collected
allocate_some_more()
gc.collect() # collect all non - frozen objects
gc.unfreeze() #
return to sanity

Suggestion : 2

Freeze all the objects tracked by gc - move them to a permanent generation and ignore all the future collections. This can be used before a POSIX fork() call to make the gc copy-on-write friendly or to speed up collection. Also collection before a POSIX fork() call may free pages for future allocation which can cause copy-on-write too so it’s advised to disable gc in parent process and freeze before fork and enable gc in child process.,Print information of uncollectable objects found (objects which are not reachable but cannot be freed by the collector). These objects will be added to the garbage list.,When set, all unreachable objects found will be appended to garbage rather than being freed. This can be useful for debugging a leaking program.,Returns a list of all objects tracked by the collector, excluding the list returned. If generation is not None, return only the objects tracked by the collector that are in that generation.

>>> gc.is_tracked(0)
False
   >>>
   gc.is_tracked("a")
False
   >>>
   gc.is_tracked([])
True
   >>>
   gc.is_tracked({})
False
   >>>
   gc.is_tracked({
      "a": 1
   })
False
   >>>
   gc.is_tracked({
      "a": []
   })
True

>>> x = None >>>
   class Lazarus:
   ...def __del__(self):
   ...global x
   ...x = self
   ...
   >>>
   lazarus = Lazarus() >>>
   gc.is_finalized(lazarus)
False
   >>>
   del lazarus >>>
   gc.is_finalized(x)
True

Suggestion : 3

Last Updated : 29 Nov, 2018

Xmx specifies the maximum memory allocation pool for a Java virtual machine (JVM), while Xms specifies the initial memory allocation pool. The following is an example:

java - Xms256m - Xmx2048m classfile

Output:

Object reference saved.The object won 't be collected by the garbage collector

Suggestion : 4

To have the garbage collector consider all objects regardless of their generation, use the version of this method that takes no parameters.,To have the garbage collector consider all objects regardless of their generation, use the version of this method that takes no parameters. To have the garbage collector reclaim objects based on a GCCollectionMode setting, use the GC.Collect(Int32, GCCollectionMode) method overload.,Use the mode parameter to specify whether garbage collection should occur immediately or only if the time is optimal to reclaim objects. Using this method does not guarantee that all inaccessible memory in the specified generation is reclaimed.,The garbage collector does not collect objects with a generation number higher than specified by the generation parameter. Use the MaxGeneration property to determine the maximum valid value of generation.

1._

public:
   static void Collect(int generation, GCCollectionMode mode, bool blocking);

public:
 static void Collect(int generation, GCCollectionMode mode, bool blocking);

public static void Collect(int generation, GCCollectionMode mode, bool blocking);

public static void Collect (int generation, GCCollectionMode mode, bool blocking);

static member Collect: int * GCCollectionMode * bool - > unit

1._

public:
   static void Collect(int generation, GCCollectionMode mode);

public:
 static void Collect(int generation, GCCollectionMode mode);

public static void Collect(int generation, GCCollectionMode mode);

public static void Collect (int generation, GCCollectionMode mode);

static member Collect: int * GCCollectionMode - > unit

The following example forces a garbage collection for generation 2 objects with the Optimized setting.

using System;

class Program {
   static void Main(string[] args) {
      GC.Collect(2, GCCollectionMode.Optimized);
   }
}

using System;

class Program
{
    static void Main(string[] args)
    {
        GC.Collect(2, GCCollectionMode.Optimized);
    }
}

open System

GC.Collect(2, GCCollectionMode.Optimized)

1._

public:
   static void Collect(int generation, GCCollectionMode mode, bool blocking, bool compacting);

public:
 static void Collect(int generation, GCCollectionMode mode, bool blocking, bool compacting);

public static void Collect(int generation, GCCollectionMode mode, bool blocking, bool compacting);

public static void Collect (int generation, GCCollectionMode mode, bool blocking, bool compacting);

static member Collect: int * GCCollectionMode * bool * bool - > unit

You can call the Collect(Int32, GCCollectionMode, Boolean, Boolean) method to reduce the managed heap to the smallest size possible, as the following code fragment illustrates.

GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.CompactOnce;
GC.Collect(2, GCCollectionMode.Forced, true, true);

GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.CompactOnce;
GC.Collect(2, GCCollectionMode.Forced, true, true);

GCSettings.LargeObjectHeapCompactionMode < -GCLargeObjectHeapCompactionMode.CompactOnce
GC.Collect(2, GCCollectionMode.Forced, true, true)

1._

public:
   static void Collect();

public:
 static void Collect();

public static void Collect();

public static void Collect ();

static member Collect: unit - > unit

The following example demonstrates how to use the Collect method to perform a collection on all generations of memory. The code generates a number of unused objects, and then calls the Collect method to clean them from memory.

using namespace System;

const int maxGarbage = 1000;

void MakeSomeGarbage() {
   Version ^ vt;
   for (int i = 0; i < maxGarbage; i++) {
      // Create objects and release them to fill up memory with unused objects.
      vt = gcnew Version;
   }
}

void main() {
   // Put some objects in memory.
   MakeSomeGarbage();
   Console::WriteLine("Memory used before collection:       {0:N0}",
      GC::GetTotalMemory(false));

   // Collect all generations of memory.
   GC::Collect();
   Console::WriteLine("Memory used after full collection:   {0:N0}",
      GC::GetTotalMemory(true));
}
// The output from the example resembles the following:
//       Memory used before collection:       79,392
//       Memory used after full collection:   52,640

using System;

class MyGCCollectClass {
   private
   const int maxGarbage = 1000;

   static void Main() {
      // Put some objects in memory.
      MyGCCollectClass.MakeSomeGarbage();
      Console.WriteLine("Memory used before collection:       {0:N0}",
         GC.GetTotalMemory(false));

      // Collect all generations of memory.
      GC.Collect();
      Console.WriteLine("Memory used after full collection:   {0:N0}",
         GC.GetTotalMemory(true));
   }

   static void MakeSomeGarbage() {
      Version vt;

      // Create objects and release them to fill up memory with unused objects.
      for (int i = 0; i < maxGarbage; i++) {
         vt = new Version();
      }
   }
}
// The output from the example resembles the following:
//       Memory used before collection:       79,392
//       Memory used after full collection:   52,640

1._

public:
   static void Collect(int generation);

public:
 static void Collect(int generation);

public static void Collect(int generation);

public static void Collect (int generation);

static member Collect: int - > unit

The following example demonstrates how to use the Collect method to perform a collection on individual layers of memory. The code generates a number of unused objects, and then calls the Collect method to clean them from memory.

using namespace System;
const long maxGarbage = 1000;
ref class MyGCCollectClass {
   public: void MakeSomeGarbage() {
      Version ^ vt;
      for (int i = 0; i < maxGarbage; i++) {

         // Create objects and release them to fill up memory
         // with unused objects.
         vt = gcnew Version;

      }
   }

};

int main() {
   MyGCCollectClass ^ myGCCol = gcnew MyGCCollectClass;

   // Determine the maximum number of generations the system
   // garbage collector currently supports.
   Console::WriteLine("The highest generation is {0}", GC::MaxGeneration);
   myGCCol - > MakeSomeGarbage();

   // Determine which generation myGCCol object is stored in.
   Console::WriteLine("Generation: {0}", GC::GetGeneration(myGCCol));

   // Determine the best available approximation of the number
   // of bytes currently allocated in managed memory.
   Console::WriteLine("Total Memory: {0}", GC::GetTotalMemory(false));

   // Perform a collection of generation 0 only.
   GC::Collect(0);

   // Determine which generation myGCCol object is stored in.
   Console::WriteLine("Generation: {0}", GC::GetGeneration(myGCCol));
   Console::WriteLine("Total Memory: {0}", GC::GetTotalMemory(false));

   // Perform a collection of all generations up to and including 2.
   GC::Collect(2);

   // Determine which generation myGCCol object is stored in.
   Console::WriteLine("Generation: {0}", GC::GetGeneration(myGCCol));
   Console::WriteLine("Total Memory: {0}", GC::GetTotalMemory(false));
}

using System;

namespace GCCollectIntExample {
   class MyGCCollectClass {
      private
      const long maxGarbage = 1000;

      static void Main() {
         MyGCCollectClass myGCCol = new MyGCCollectClass();

         // Determine the maximum number of generations the system
         // garbage collector currently supports.
         Console.WriteLine("The highest generation is {0}", GC.MaxGeneration);

         myGCCol.MakeSomeGarbage();

         // Determine which generation myGCCol object is stored in.
         Console.WriteLine("Generation: {0}", GC.GetGeneration(myGCCol));

         // Determine the best available approximation of the number
         // of bytes currently allocated in managed memory.
         Console.WriteLine("Total Memory: {0}", GC.GetTotalMemory(false));

         // Perform a collection of generation 0 only.
         GC.Collect(0);

         // Determine which generation myGCCol object is stored in.
         Console.WriteLine("Generation: {0}", GC.GetGeneration(myGCCol));

         Console.WriteLine("Total Memory: {0}", GC.GetTotalMemory(false));

         // Perform a collection of all generations up to and including 2.
         GC.Collect(2);

         // Determine which generation myGCCol object is stored in.
         Console.WriteLine("Generation: {0}", GC.GetGeneration(myGCCol));
         Console.WriteLine("Total Memory: {0}", GC.GetTotalMemory(false));
         Console.Read();
      }

      void MakeSomeGarbage() {
         Version vt;

         for (int i = 0; i < maxGarbage; i++) {
            // Create objects and release them to fill up memory
            // with unused objects.
            vt = new Version();
         }
      }
   }
}