Re: [9fans] Fork: useless and painful?

[David Presotto <presotto@closedmind.org>]

[-- Attachment #1: Type: text/plain, Size: 295 bytes --]

That's why we have libthread with its threadcreate/proccreate/procexec.
I've been moving stuff over to windows and just kept the libthread
interface.

It's amazing how awkward win32 makes all of the same.  Every
process control call turns into a handful of calls, each with
a dozen params.

[-- Attachment #2: Type: message/rfc822, Size: 3652 bytes --]

From: rog@vitanuova.com
To: 9fans@cse.psu.edu
Subject: Re: [9fans] Fork: useless and painful?
Date: Thu, 10 Jul 2003 15:59:34 +0100
Message-ID: <212c59d55eb25badcbc00c9fe4121065@vitanuova.com>

> I'm hearing the claim that fork is "useless and painful" (from an IBM K42
> guy).
>
> Maybe it's just me, but I've always liked fork.

fork's kinda nice, but can be confusing.
plan9 has really moved away from fork for multithreaded programs
towards the "spawn" style proccreate.  (rfork for other resource
attributes is quite different, i think)

a day or so ago, i had occasion to write the following code:

	int
	mpipe(void)
	{
		char buf[BUFSIZE];
		int n, p[2];

		pipe(p);
		if(fork() == 0){
			if(fork() == 0){
				close(p[1]);
				return p[0];
			}
			close(p[0]);
			while((n = read(0, buf, sizeof(buf))) > 0)
				write(p[1], buf, n);
			exits(nil);
		}
		close(p[0]);
		while((n = read(p[1], buf, sizeof(buf))) > 0)
			write(1, buf, n);
		exits(nil);
	}

there's nothing particularly complicated going on and i don't *think*
the implementation is particularly obtuse, but i don't find reading
that code straightforward.

here's a different structure to the same end:

	int
	mpipe(void)
	{
		int p[2];
		pipe(p);
		spawn copy(0, p[1]);
		spawn copy(p[1], 1);
		return p[0];
	}

	void
	copy(int fd0, int fd1)
	{
		char buf[BUFSIZE];
		int n;
		while((n = read(fd0, buf, sizeof(buf))) > 0)
			write(fd1, buf, n);
	}

ok, i cheated, assuming that C has been given a "spawn" statement
similar to Limbo's.  nonetheless, i think the structure itself is
clearer, and the meaning of the code more transparent - no possibility
of accidentally duplicating the *caller* of mpipe...

given that forking a process in plan 9, unlike unix, is not synonymous
with forking its file descriptors, surely the only real reason to
prefer it is that the call fits more nicely into the C syntax; one
doesn't have to bypass typechecking in order to pass arguments to a
new process.

how often does anyone do anything with fork that could not be done at
least as easily with spawn?