Em termos de eficiência de alocação de memória é correto dizer que depois de um fork()
no código do filho se eu executar um programa com execve()
isso seria mais eficiente do que o mesmo programa executado sem execve()
porque o filho não terá alocado a pilha e a pilha de o pai mas só é próprio?
Exemplo ingênuo:
sem executivo
[..some father code...]
int i;
if(!fork()) {
sum() //from an #include "porg.h"
}
com executivo
[..some father code...]
if(!fork()) {
execve("sum", NULL, NULL); //sum is a program which executes i=2+3
}
O segundo em termos de alocação de memória é melhor? É melhor substituir todo o espaço de endereço virtual do meu processo ou é melhor executar o código mencionado com uma chamada para uma função em outro programa incluído com #include "prog" em termos de número de operações realizadas pelo assim e em termos da memória transportada para trás durante a execução do programa?
O código dentro
if
de seu primeiro snippet contém uma adição e uma atribuição. Isso é o mais simples possível, seria compilado em cerca de duas instruções em código de máquina.No segundo, há um monte de argumentos carregados e colocados na pilha, uma chamada de função, algum processamento interno pela libc, que envolve mover os argumentos para os locais corretos para uma chamada do sistema e, em seguida, a própria chamada do sistema.
A chamada do sistema requer uma mudança para o modo kernel (com qualquer custo que isso implique, depende do sistema), uma pesquisa no kernel para encontrar qual chamada do sistema realmente processar e, em seguida, executar o programa
sum
. A execução do programa requer encontrar o arquivo que contém o programa, carregá-lo na memória (possivelmente esperando pelo disco), interpretar os cabeçalhos ELF para saber onde colocar cada parte do programa na memória, configurar alguns mapeamentos de memória, provavelmente tabelas de páginas e entao...Eu suponho que você entendeu.
Não é certo supor isso. Nem
sum
o filho da bifurcação usa o heap explicitamente. Mas emsum
, o tempo de execução C pode inicializar algumas estruturas de heap no início do programa. Existe uma possibilidade semelhante para a pilha.No entanto, esta é uma questão razoável para se pensar. Se o pai também estiver modificando a memória enquanto o filho é executado, o filho hospedará cópias de toda a memória modificada (cópia na gravação). Freqüentemente, a criança está executando uma subtarefa e usa apenas um subconjunto desses dados.
É possível que seja significativo com um processo pai maior e um processo filho de execução mais longa.