[Caml-list] Garbage Collecting

[Caml-list] Garbage Collecting

[Jonathan Roewen]

Hi,

We're trying to figure out why memory doesn't get collected in our OS
by the OCaml GC, and seems like it doesn't want to reclaim any memory.
We also suspect that Gc.allocated_bytes has a memory leak.

Here is our test case:
(* File mod.ml -- some ``useful'' Caml functions *)
open Printf

let fib (n:int) =1 + n

;;

let mem = ref 0;;
let do_stuff () = 
(* 	making this loop more increases mem usage *)
	for i=1 to 900000 do
		fib i;
		int_of_float (Gc.allocated_bytes()); (* A *)
	done;
	mem := int_of_float (Gc.allocated_bytes())
;;

let do_results() = 
	printf "allocated %d\n" !mem;
	Gc.full_major(); (* B1 *)
	Gc.compact();
	Gc.major();
	Gc.minor(); (*B2 *)
	printf "allocated %d\n" (int_of_float (Gc.allocated_bytes()))
;;
do_stuff ();;
do_results ();;

My results:
Test 1)
allocated 57600272
allocated 57600788
Test 2)
allocated 272
allocated 956
Test 3)
allocated 272
allocated 744

Where test 1 is using the above code; test 2 is with line A commented
out; and test 3 is with both line A and lines B1-B2 commented out.

As you can see from our tests, that invoking the Gc increases memory,
and Gc.allocated_bytes appears to gobble it up like candy.

Would appreciate someone shedding some light on this topic, as writing
our OS in OCaml is going to have some major issues if it won't reclaim
memory.

Regards,

Jonathan

Re: [Caml-list] Garbage Collecting

[Jonathan Roewen]

Okay, so we didn't look at the documentation properly.
Gc.allocated_bytes is for lifetime of the program. Now things suddenly
make a whole lot of sense =)

Re: [Caml-list] Garbage Collecting

[Olivier Andrieu]

 > Jonathan Roewen [Sun, 2 Jan 2005]:
 > 
 > Hi,
 > 
 > We're trying to figure out why memory doesn't get collected in our
 > OS by the OCaml GC, and seems like it doesn't want to reclaim any
 > memory.  We also suspect that Gc.allocated_bytes has a memory leak.
 > 
 > Here is our test case:
 > (* File mod.ml -- some ``useful'' Caml functions *)
 > open Printf
 > 
 > let fib (n:int) =1 + n
 > 
 > ;;
 > 
 > let mem = ref 0;;
 > let do_stuff () = 
 > (* 	making this loop more increases mem usage *)
 > 	for i=1 to 900000 do
 > 		fib i;
 > 		int_of_float (Gc.allocated_bytes()); (* A *)
 > 	done;
 > 	mem := int_of_float (Gc.allocated_bytes())
 > ;;
 > 
 > let do_results() = 
 > 	printf "allocated %d\n" !mem;
 > 	Gc.full_major(); (* B1 *)
 > 	Gc.compact();
 > 	Gc.major();
 > 	Gc.minor(); (*B2 *)
 > 	printf "allocated %d\n" (int_of_float (Gc.allocated_bytes()))
 > ;;
 > do_stuff ();;
 > do_results ();;
 > 
 > My results:
 > Test 1)
 > allocated 57600272
 > allocated 57600788
 > Test 2)
 > allocated 272
 > allocated 956
 > Test 3)
 > allocated 272
 > allocated 744
 > 
 > Where test 1 is using the above code; test 2 is with line A commented
 > out; and test 3 is with both line A and lines B1-B2 commented out.
 > 
 > As you can see from our tests, that invoking the Gc increases memory,
 > and Gc.allocated_bytes appears to gobble it up like candy.

Well, what do you expect ? Gc.allocated_bytes is a pretty
regular-looking function : it computes stuff, using a couple of
intermediate values, so it allocates a couple of bytes to store
these. Now, if you stick this a loop, number_of_iterations times
couple_of_bytes bytes get allocated. This has nothing to do with
reclaiming memory actually, Gc.allocated_bytes simply keeps track of
how many bytes were requested to the runtime; all those bytes are not
"live".

 > Would appreciate someone shedding some light on this topic, as
 > writing our OS in OCaml is going to have some major issues if it
 > won't reclaim memory.

I wouldn't worry. There is some anecdotal evidence that the OCaml GC
is not a fraud and that it _does_ reclaim memory.

-- 
   Olivier