Limites do Sistema

Quantos processos podem ser criados?

O limite de números de processos no Linux existe e era usado por um tipo de software malicioso para travar máquinas. Estes programas são chamados de "fork bombs". Devido a existência deles, muitas das distribuições atualmente limitam o número de criação de processos por um determinado usuário. No Bash, pode-se utilizar o comando ulimit para configurar esse limite. Neste teste, não modificamos esse limite e verificamos o que acontece no momento em que não foi mais possível realizar a chamada fork().

O código criado para esse teste foi:

#include <stdio.h>
#include <stdlib.h>

int i;

void escreve_em_arquivo() {
    FILE* fp;
    fp = fopen("max.txt","w+");
    if(fp == NULL) {
        printf("Falha ao abrir arquivo!");
        exit(0);
    }

    fprintf(fp, "%d\n", i++);
    fclose(fp);

    system("ps -ef | wc -l > max2.txt");
}

int main() {

    i = 1;

    while(fork() != 0)
        escreve_em_arquivo();

    sleep();

}

Este código sempre abre o mesmo arquivo e escreve o número de processos que estão criados assim, quando o sistema travar devido ao número de processos, bastará reiniciar e ver o número no arquivo.
O resultado final no arquivo foi o seguinte (depois do computador não permitir mais nenhuma operação porque a simples execução de um comando no Bash exige ao menos um fork):

/ Conteúdo do arquivo max.txt /

788517

/ Fim do arquivo. /

Qual é o maior tamanho do processo?

Para determinar o maior tamanho possível de processo, verificaremos esse valor nos limites configurados para o sistema através da função getrlimit(), o código criado é o seguinte:

#include <sys/resource.h>
#include <stdlib.h>
#include <stdio.h>

int main() {

    struct rlimit rlp;

    if(getrlimit(RLIMIT_AS, &rlp) == 0) {
        printf("Tamanho máximo do processo: %ld %ld\n",rlp.rlim_max, rlp.rlim_cur);
    }

    if(getrlimit(RLIMIT_DATA, &rlp) == 0) {
        printf("Tamanho máximo do heap: %ld %ld\n",rlp.rlim_max,rlp.rlim_cur);
    }

    return 0;

}

Neste código, além de verificar o tamanho máximo do processo, verificou-se, também, o maior tamanho de heap, o qual propôs-se um experimento diferente, mostrado no próximo item.

Qual é a maior área de heap?

A área do heap é utilizada para atender pedido de alocação dinâmica de memória realizadas pelo processo.
Utilizando o seguinte código, podemos verificar o momento a partir do qual o pedido de alocação de memória não é mais atendido (atente para o fato da memória sempre ser liberada):

#include <stdlib.h>
#include <stdio.h>

int main() {

    int i;
    void* pr;
    for( i=0; pr=malloc(i);++i) {
        free(pr);
    }
    printf("%d\n",i);
    return 0;
}

O programa foi executado várias vezes, após até mesmo reiniciar a máquina, e o valor obtido foi, sempre foi em torno de, 80132. Ou seja, o tamanho máximo do heap neste caso foi de 80132 bytes.

A área de swap pode ser esgotada?

Este experimento não foi realizado mas isto pode ser visualizado em vários exemplos discutidos na internet:
a área de swap pode ser esgotada, sim, e isso leva ao travamento do sistema.

Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-ShareAlike 3.0 License