Very Computer

Hello,

How do I go about opening a pipe to a new process? What I would
like to write a program that monitors another program. Ideally,
I would like the parent program to start the child monitor program
and then write data to it (likely via pipe), which the monitor
program would consume and use to update it's progress display.

How do I create a pipe from a parent process to a child process
that the parent starts? I don't think I can use fork() and
pipe() because my parent process uses lots of memory. As I
understand it, calling fork() gives the child process a copy of
the parent's heap, which is not a realistic option given that my
program eats as much memory as I can feed it. I think popen()
also uses fork(), which as I said before probably isn't a good
idea in my case.

Any hints that might point me in the right direction would be
tremendously appreciated.

Thanks.

Derek

While it is true that a `fork()-ed' process _conceptually_ receives a
copy of its parent's address space, this is normally implemented as
copy-on-write, i.e. pages are physically copied only when written to by
either parent or child.
Of course, once the child `exec*()'s, it's moot anyway.

If I understand what you're trying to do correctly (i.e. it's a one-way
pipe), popen() would be the simplest way to go. Just `popen()' in write
mode and have the monitor read from stdin.

HTH,
--ag
--
Artie Gold, Austin, TX  (finger the cs.utexas.edu account for more info)

--
If it's of it it's its.

Quote:"Arthur H. Gold" wrote...

<snip>

Quote:> While it is true that a `fork()-ed' process _conceptually_
> receives a copy of its parent's address space, this is normally
> implemented as copy-on-write, i.e. pages are physically copied
> only when written to by either parent or child. Of course, once
> the child `exec*()'s, it's moot anyway.

And that's exactly the problem.

Quote:> If I understand what you're trying to do correctly (i.e. it's a
> one-way pipe), popen() would be the simplest way to go. Just
> `popen()' in write mode and have the monitor read from stdin.

And while that's the simplest solution, it doesn't get around
the forking-a-huge-process problem. I could try to guarantee that
popen() is called relatively early (i.e., before the parent
process allocates all its memory), but perhaps I'm just better
off using pthreads or a messaging API.

D.

But it's *not* a problem.  Since the child process immediately calls
exec(), it never modifies most of those shared pages.  Its memory is
instantly replaced with the program being exec'ed.

Quote:>> If I understand what you're trying to do correctly (i.e. it's a
>> one-way pipe), popen() would be the simplest way to go. Just
>> `popen()' in write mode and have the monitor read from stdin.

>And while that's the simplest solution, it doesn't get around
>the forking-a-huge-process problem.

But it's not a real problem.

--

Genuity, Burlington, MA
*** DON'T SEND TECHNICAL QUESTIONS DIRECTLY TO ME, post them to newsgroups.
Please DON'T copy followups to me -- I'll assume it wasn't posted to the group.

Actually you've missed the point. The function popen() uses vfork(),
which, as stated above, is an optimization of fork() _for exactly the
problem you mention_.

There is no `vforking-a-huge-process' problem.

HTH,
--ag

--
Artie Gold, Austin, TX  (finger the cs.utexas.edu account for more info)

--
This space for rent.

<snip>

Quote:> Actually you've missed the point. The function popen() uses vfork(),
> which, as stated above, is an optimization of fork() _for exactly the
> problem you mention_.

> There is no `vforking-a-huge-process' problem.

Appologies. I was being a space cadet when I wrote my reply. Everything
makes sense now. A million thanks.

...and all without the application of a clue-stick! ;-)

Cool.

Now go forth and write code!

Cheers,
--ag
--
Artie Gold, Austin, TX  (finger the cs.utexas.edu account for more info)

--
"I wonder why I wonder why I wonder why..." -- S. Ulam