UNIX for Dummies Questions & Answers

Disclaimer: This is just a rainy day experiment. There is no expected "goal" other than to understand UNIX better.

After reading about fork and exec, my understanding is that forking, as the UNIX shell does by design, consequentially may sacrafice some speed versus an approach that runs in only a single process. (Is this correct?)

Further, my understanding is also that when we execute programs in a pipe, the programs are not executed sequentially, but they are executed simultaneously. (Is that correct?)

For better or worse, I began thinking about the idea of running only a single process at time, and conserving the number of processes that are running simultaneously.

I know that the shell builtin exec can be used to set up file descriptor redirects or to exit the last process in a script. I have used these techniques. But I do not think I truly understand the execve() system call.

Allow me to demonstrate my lack of understanding. (You may want to stop reading here if your intelligence is easily insulted.)

I made a shell function (see bottom of this post) which I named "nf0". "nf" stands for "no fork". "0" means "with zero arguments". It takes a base utility, plugs $1 into the text of execve C function, saves this as a file called "nf.c", then compiles that file to an ELF executable named "nf[utilityname]".

e.g.

Code:

nf0 cat ===> nfcat
nf0 sed ===> nfsed

Then I constructed a pipe:

Code:

trace ./nfcat < big-file | trace ./nfsed | trace ./nfcat

where "trace" is any vendor-specific UNIX trace utility.

I also monitored the output of ps.

As far as I can tell, as a naive UNIX neophyte, I have managed to stop the fork() calls. But have I actually achieved any efficiencies?

In terms of processing, how is this pipeline different from:

Code:

trace cat < big-file| trace sed | trace cat

I doubt I have increased job efficiency here. And I have not tested this properly. But I do want to understand what's happening "behind the scenes" of the shell when I run programs in a pipe.

Sorry for the long post.

Cheers!

Code:

nf0(){
path=$(command -v $1)
printf "
#include <stdio.h>
#include <stdlib.h>
main(int argc, char **argv, char **envp)
{
  char *a[2];
  int i;

  a[0] = \"$1\";
  a[1] = NULL;

  i = execve(\"${path-$1}\", a, envp);
  perror(\"nf$1: execve failed\");
  exit(1);
}
" > nf.c 
cc nf.c -o nf$1 

}

As an example,think about the pipline

Code:

cat hugefile | head -1 | od -c

Lets ignore the fact that this script is badly written and just look at the result.
If you run the commands sequentially, cat cannot detect that it's stdout has closed and so must process the whole file, even though the head command will exit after it's read the 1st line.

Also when running sequentially, the pipe will need to contain the full contents of the cat output . With parallel processes the pipe is only buffering between the two processes as data is going in one side and out the other at the same time.

Also if system has more that 1 CPU later processes in the chain can make use of otherwise idle resources.