Re: [Caml-list] Ask for a more efficient way to deallocate memory (full version)

[Oliver Bandel <oliver@first.in-berlin.de>]

Hello,


Zitat von Fabrice.Pardo@lpn.cnrs.fr:

> Hello, and sorry for my previous unfinished message.
>
> As the function Unix.opendir returns a value,
> we can expect that Unix.closedir will be automatically
> called when the dir_handle value is no more referenced.
> That's not the case,

Yes, and that's a operating system issue, not OCaml's.
There btw. a long while ago was already a discussion on that.

opendir does only give back a handle, and that does not need much
memory. So it is not a problem for that you should use the Gc-module.

the error you got says: there are not more filedescriptors available to
you, and the system gives you an error because of that and OCaml then
throsws you an exception.

You have to open and to close by yourself.

There are many possiblities to do that work.
You can code it directly in a function.
So, you could open the directory, read the conetnst to alist,
then close the directory and give back the dircontens (list
of entries) as a return value.

The calling function then can collect the items.
Or give a list of dierctories to the function and
let it fo all opendir/readdir/closedir things,
collecting all dir-contents.

So, this all is possible without Gc-module, and using the
Gc-module shows me that you don't understand the rpoblem at hand: it is
not the garbage collector that must be used to throw away allocated
data, it is the Operating-System, which needs the files to be closed.

As it is not the Garbage Collector, it makes no sense to use
Gc-functions here.

Just open the dir, read the contents and then close the dir.
That's all.




> and calling opendir too many times as in
>
> for i = 1 to 2000 do
>   let d = Unix.opendir "/tmp" in ()
> done;;

This makles no sense.
Why to open directories and not use them?

Do you go to the bakery, buy 2000 breads and then
put them in your garage, not eating one of them?


[...]
>
> Replacing Unix.opendir by safe_opendir:
>
> let safe_opendir path =
>   let _ = Gc.major ()
>   and d = Unix.opendir path
>   in Gc.finalise Unix.closedir d
>
> seems a solution, but the efficiency is very low due to high
> cost of garbage collector calling function.

So, don't use it.


>
> My question is how to write a code as efficient
> as it would be possible using a reference-counted language.
[...]

So, it seems you think OCaml is very inefficient and so you try
to make coding "as efficient as possible" before you write any line of
code. This makes no sense. OCaml is astouningly efficient,
and you should better start to write your code and only if you
come to a limit, where you really think you have to optimize,
then you should.

So, do you really want to open some-thousand directories?
Then you can write a function, that gets a list of directories as
argument and then in a loop
  opens  --- reads (and daves data) --- closes


No Gc-stuff needed.

Ciao,
   Oliver