fork() and execve() efficiency

Question

In terms of memory allocation efficiency is it right to say that after a fork() in the code of the child if I execute a program with execve() this would be more efficient than the same program executed without execve() because the child won't have allocated the stack and heap of the father but only is own?

Naife example:

without execve

 [..some father code...]
int i;
if(!fork()) {
 sum() //from an #include "porg.h"
}

with execve

 [..some father code...]

if(!fork()) {
 execve("sum", NULL, NULL); //sum is a program which executes i=2+3
}

The second in terms of memory allocation is better? Is it better to replace the entire virtual address space of my process or it is better to get running the mentioned code with a call to a function in another program which is included with #include "prog" in terms of number of number of operations done by the so and in terms of the memory carried behind during the execution of the program?

Answer 1

Read carefully some book on Linux or POSIX programming, perhaps the old ALP. Read also intro(2), fork(2), execve(2).

After a successful execve, the entire virtual address space of your process has been replaced and reinitialized , according to the ELF executable that was executed (see elf(5); so execve does not return except on failure).

So your sum program don't see anything from the previous program executing it (except the mandatory argv & environ, which get copied by execve). BTW, your usage of execve is wrong. You should provide some argv array, and some environ array (both should be non-null, the argv should be non-empty, and both should end with a NULL string)... You often would prefer some exec*(3) function.

And after a successful fork both (child and father) processes have their own virtual address space (initially, nearly identical copies). BTW, your code forgot to check failure of fork.

The second in terms of memory allocation is better?

So that question has no sense. The entire "memory" -actually, virtual address space- has been reset and reinitialized (and that includes the call stack and the heap).

You can explore the virtual address space of your process by using /proc/. See proc(5). Try cat /proc/$$/maps and cat /proc/self/maps to get a better intuition about virtual address space.

Play also with strace(1) to understand the system calls done by some program or process. Try for example strace date (and see also this).

than the same program executed without execve()

That is impossible, since execve is the only way to execute a program (except of course init, today called systemd - see init(1), which gets started magically by the kernel at boot time; and some few other weird kernel initiated processes....)