C#

Luc Pattyn wrote:

You should implement IDisposable if your object is likely to hold large amounts of
(managed) memory that you want to make collectable immediately

ObjectWithHugeArray obj = new ObjectWithHugeArray();
obj.GetSomeData();
obj.DisplayTheData();
GetSomeUserInput();
obj.Dispose();
// the memory is not collectable until here
obj = null;

ObjectWithHugeArray obj = new ObjectWithHugeArray();
obj.GetSomeData();
obj.DisplayTheData();
// the memory is collectable here already
GetSomeUserInput();
obj = null;

Guffa wrote:

ObjectWithHugeArray obj = new ObjectWithHugeArray();
obj.GetSomeData();obj.DisplayTheData();
// the memory is collectable here already
GetSomeUserInput();
obj = null;

Luc Pattyn wrote:

with obj
a class member, not a local variable.

Luc Pattyn wrote:

the "obj=null;" statement would be chopped out
by the optimizer

Luc Pattyn wrote:

I assume you intend the example to be the code of a single method, with obj
a class member, not a local variable.

Luc Pattyn wrote:

Not having an obj.Dispose(); ends the life of the obj value sooner when
looking at the code in the method itself; IMO that on its own is insufficient to
expect the compiler to move "obj=null;" upwards.

Luc Pattyn wrote:

So I expect the obj variable be present on the stack, and be cleared only
after returning from the Input method; hence the GC would find the hugeobject
reference, and would have to keep it alive (together with its huge array, for
which my Dispose() would have removed the only reference).

Guffa wrote:

the object only have to be alive as long as there is a used reference to it. The garbage collector sees where the reference to the object is last used

Luc Pattyn wrote:

You assign magic powers to the GC; it does not understand your program

Luc Pattyn wrote:

it can't
predict whether an existing reference is still needed or not.

Luc Pattyn wrote:

The local ref-type variable is located on the stack (or JIT-optimized into a
register). If it is not null, the object it refers to is alive, even if the
program does not intend to use it any more.

using System;
using System.Collections.Generic;

namespace TestConsole {

	class Program {

		static List<WeakReference> refs; 

		static void Main(string[] args) {
			refs = new List<WeakReference>();
			byte[] ref1, ref2, ref3, ref4, ref5, ref6, ref7, ref8, ref9, ref10;

			ref1 = Create();
			ref2 = Create();
			ref3 = Create();
			ref4 = Create();
			ref5 = Create();
			ref6 = Create();
			ref7 = Create();
			ref8 = Create();
			ref9 = Create();
			ref10 = Create();

			int index = 1;
			foreach (WeakReference r in refs) {
				Console.WriteLine("Item {0} : {1}", index, r.IsAlive);
			}
		}

		static byte[] Create() {
			byte[] r = new byte[100000000];
			refs.Add(new WeakReference(r));
			return r;
		}

	}

}

Luc Pattyn wrote:

Now my problem was: why would the compiler actually generate code to assign
null to it, since there is no further use for it; a regular non-CLR compiler
(say a C compiler) would optimize it away immediately. But it seems the C# compiler
designer has not optimized assignments that far that "obj=null;" would be
removed. (Unfortunately he also did not remove useless val-type assignments,
try ending a method on int a=12; and watch its MSIL).

Guffa wrote:

Almost all optimising is done by the JIT compiler, so you should look at the actual code generated, not the IL code.

Luc Pattyn wrote:

The GC is not looking at code.

Luc Pattyn wrote:

There is no point in trying to figure
out what each of the threads in a program is going to do in the future.
How would the GC deal with changes in program flow, loops, recursive methods,
etc etc? It is just impossible.

Luc Pattyn wrote:

All the GC looks at is reachable data, everything it can reach (in the
way I explained before) is considered alive and will not be collected.

Luc Pattyn wrote:

I must add one refinement, the one your latest example is abusing
(I did not run your example, I understood what you meant with it): the GC
does not follow weak references when looking for reachable objects.

Luc Pattyn wrote:

can you tell me the easiest way to do that (find the code, then watch it;

class Program {

	static List<WeakReference> refs;

	static void Main(string[] args) {
		Console.WriteLine("===========================================");
		withoutConsumers();
		Console.WriteLine("===========================================");
		withConsumers();
		Console.WriteLine("===========================================");
		Console.WriteLine("Hit ENTER to terminate");
		Console.ReadLine();
	}

	// test case #1
	static void withoutConsumers() {
		Console.WriteLine("Arrays are created but never really used");
		refs = new List<WeakReference>();
		byte[] ref1, ref2, ref3;

		ref1 = Create_1MB();
		ref2 = Create_1MB();
		ref3 = Create_1MB();
		Show("after creates");
		Collect();
		Show("after collect");
		ref2=null;
		Show("after cref2=null");
		Collect();
		Show("after collect");
	}

	// test case #2
	static void withConsumers() {
		Console.WriteLine("This time arrays are really used");
		refs = new List<WeakReference>();
		byte[] ref1, ref2, ref3;

		ref1 = Create_1MB();
		ref2 = Create_1MB();
		ref3 = Create_1MB();
		Show("after creates");
		int n=ref1[1]+ref2[2]+ref3[3];
		Console.WriteLine("n="+n);
		Collect();
		Show("after collect");
		ref2=null;
		Show("after cref2=null");
		Collect();
		Show("after collect");
	}

	// create a 1MB array
	static byte[] Create_1MB() {
		byte[] r = new byte[1024*1024];
		for(int i=0; i<100; i++) r[i]=(byte)i;
		refs.Add(new WeakReference(r));
		return r;
	}

	// show alive state for 3 arrays
	static void Show(string title) {
		string s=title.PadRight(20);
		foreach(WeakReference r in refs) s+=" "+r.IsAlive;
		Console.WriteLine(s);
	}

	// try to collect everything, all generations, ...
	static void Collect() {
		GC.Collect();
		GC.Collect();
		GC.Collect();
	}
}

Arrays are created but never really used
after creates        True True True
after collect        True True True
after cref2=null     True True True
after collect        True False True
===========================================
This time arrays are really used
after creates        True True True
n=6
after collect        True True True
after cref2=null     True True True
after collect        True False True

Arrays are created but never really used
after creates        False False True
after collect        False False False
after cref2=null     False False False
after collect        False False False
===========================================
This time arrays are really used
after creates        True True True
n=6
after collect        True True True
after cref2=null     True True True
after collect        True False True

public static void GCCantPredictCodeExecution() {
    object doYouStillNeedMe = new object();
    // point A
    Thread.Sleep(1000);
    // point B
    Console.WriteLine("Type 1 to show the object, 0 to skip that");
    string s=Console.ReadLine();
    if (s=="1") Console.WriteLine(doYouStillNeedMe.ToString());
    // point C
#if withNullify
    doYouStillNeedMe=null;
#endif
    // point D
    Thread.Sleep(1000);
    // point E
}

using (Font font1 = new Font("Arial", 10.0f))