I added some additonal explanation to the answer.
The performance difference is marginal now and its use can be dangerous. See this SO question stackoverflow. Isn't it absurd and inefficient to copy one that is only going to be replaced right away? In fact, that would probably not be as efficient for a few reasons: The "copy" produced by fork is a bit of an abstraction, since the kernel uses a copy-on-write system; all that really has to be created is a virtual memory map.
Various significant aspects of the child process e. They're just assumed to be the same as that of the calling process, and this is the fairly intuitive system we are familiar with. To explain 1 a little further, memory which is "copied" but never subsequently accessed is never really copied, at least in most cases.
An exception in this context might be if you forked a process, then had the parent process exit before the child replaced itself with exec. I say might because much of the parent could be cached if there is sufficient free memory, and I am not sure to what extent this would be exploited which would depend on the OS implementation.
Of course, that doesn't on the surface make using a copy more efficient than using a blank slate -- except "the blank slate" is not literally nothing, and must involve allocation.
So 1 just demonstrates that using a "new" empty process would not be more efficient. Point 2 does explain why using the fork is likely more efficient. A child's environment is inherited from its parent, even if it is a completely different executable.
The one in the child is produced by the original fork. A strategy that may not make much literal sense, but my point is that creating a process involves more than copying it's image into memory from disk.Processes - fork and exec Programs and processes.
It is important to distinguish between programs and processes. A program is a set of instructions (and probably some data, like initialized variables) that is stored in a device, most probably a hard drive.
When a C language program is processed as a result of an exec call, the program is entered as a C function call as follows, where argc is the argument count and argv is an array of character pointers to the arguments themselves: int main (int argc, char *argv);.
Yes, copy-on-write is lazy copying, child process copy the page when try to write it.
So basically, after a fork, almost child's memory is shared with parent. However, before any of the processes made, every child process still have some private memory, modified from parent's or new allocating.
But yes in case of recent Linux with MMU the fork(2) will work with copy-on-write. It will only (allocate and) copy a few system structures and the page table, but the heap pages actually point to the ones of the parent until written.
I guess the question says it all. I want to fork on windows.
What is the most similar operation and how do I use it. The big difference is that system() creates a fork process and waits to see if the command succeeds or fails — returning a value. exec() does not return anything, it simply executes the command.