I am replying to myself, but anyway with it seems (from the
documentation) that
forkIO (do{ waitForProcess pid; return () })
is the best solution, and does not seem to lead to wasted resources.
Anyway I am still interested in knowing if there are better
solutions, or other places where one cannot assume that the garbage
collector will reclaim all the resources and one has to call a
special function to ensure it.
Fawzi
On Feb 6, 2007, at 2:38 PM, Fawzi Mohamed wrote:
I am just coming to haskell, and I wrote a simple command to get
some input from a pdf file
I just wanted the output of the command so I did something like
import System.Process (runInteractiveCommand)
import IO (hGetContents)
-- | returns the text of the first page of the pdf at the given
path, needs pdftotext
getTextOfPdf :: String -> IO String
getTextOfPdf pdfPath = do
(inp,out,err,pid) <- runInteractiveCommand ("pdftotext -l 1 "+
+pdfPath++" -")
return (hGetContents out)
I don't care about error handling, if something goes wrong it is ok
to hang or crash, but knowing unix I wondered if this would do the
right thing or if it would create a zombi process.
I was about to ask, but then I thought "let's test it", and sure
enough the zombi stays there.
I tried to even to allocate more than one, wait, I even managed to
exhaust the resources of my machine...
So here is what I would have liked to happen: when the pid gets
garbage collected it tries to wait for the process, and if that
fails the pid stays around longer and will try to wait later.
Too difficult? I don't know, but it is what I had expected from
haskell. Failing that I would have expected clear hints that one
should wait for external processes in the documentation, and I
found none.
So what is the way out? I could do a forkIO and wait for the
process but then I wonder do I have to wait for the thread, or dead
thread become zombi?
I that is the case then the only way out would be to give back also
the pid and make the waiting responsibility of the caller, not very
nice, but probably the real solution.
I have seen that in missingh there is a pipeout example but it
seems to me that you are still responsible to wait for the process
(with ensureSuccess).
Maybe the correct thing is not being able to ignore the return code
of the process.... but now I am becoming suspicious of other
things, for example a file handle, you need to close it or you can
expect that it will be closed when the handle is garbage collected?
Are there other places where you need to pay attention to be sure
that you are releasing the resources you acquired?
I suppose problems can come only when an external resource is
involved, or not
So
1) documentation should specify if one should do some specific
action to free resources, can someone fix this?
2) is there a clean (haskell;) way to deal with this?
3) other places apart external processes where you have to pay
attention?
What is your wisdom...
thanks
Fawzi
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe
