[ALOCAÇÃO DE MEMORIA] [VETORES DE MILHÕES DE POSIÇÕES]

hugodds97
(usa Ubuntu)

Enviado em 15/12/2017 - 01:16h

Olá,

Estou printando vetores >= a 1 milhão e <= 10 milhões, porem a partir de 2 milhões tenho problemas com a alocação de memoria.

#include<stdio.h>

#include<stdlib.h>



//PROTOTIPAGEM

void imprime_vetor(int v[], int *n);

void preencher_vetor(int v[], int *n);



int main (void)

{

    int *n;

    n = malloc(40000000*sizeof(int));

    *n = 10000000; //2000000;                                                                                                                                                                                                                                                                    ;

    int v[*n];



    preencher_vetor(v,n);

    imprime_vetor(v,n);

}



void preencher_vetor(int v[], int *n)

{

    int i;

    for(i = 0 ; i < *n ; i++) v[i] = i;

}



void imprime_vetor(int v[], int *n)

{

    int i;

    for(i = 0 ; i < *n ; i++) printf("[%d]",v[i]);

}   

 

Erro "segmentation fault (core dumped)

paulo1205
(usa Ubuntu)

Enviado em 15/12/2017 - 01:27h

Quais os limites impostos ao processo pelo sistema? O que imprime o comando “ulimit -a”?

removido
(usa Nenhuma)

Enviado em 15/12/2017 - 01:38h

* 1- se tem conhecimento do tamanho da variavel use um valor estatico, caso o contrario aloque mais tarde.
* 2- sempre verifique o retorno de uma alocaçao.
* 3- um ponteiro alocado do modo que fez ira acabar sendo equivalente a uma array.

#include <stdio.h>

#include <stdlib.h>



void

imprime_vetor(int *v, int n)

{

    int i;

    for (i = 0; i < n; i++)

        printf("[%d]", v[i]);

}



void

preencher_vetor(int *v, int n)

{

    int i;

    for (i = 0; i < n; i++)

        v[i] = i;

}



int

main(void)

{

    unsigned int *v, n;



    n = 40000000;

    if (!(v = malloc(n * sizeof(*v))))

        exit(1);



    preencher_vetor(v, n);

    imprime_vetor(v, n);



    return 0;

} 

paulo1205
(usa Ubuntu)

Enviado em 15/12/2017 - 01:46h

Aqui você aloca um vetor de quarenta milhões de inteiros na memória livre, e se refere a ele através do ponteiro n (um nome não muito bom, por sinal, porque n geralmente denota quantidades ou índices; mas não chega a ser um erro).



Aqui você grava o valor inteiro equivalente a dez milhões na primeira posição do vetor indicado por n. Na prática faz o mesmo que “n[0]=10000000;”.



E aqui você aloca outro vetor, usando o recurso de array de comprimento variável (ou VLA, do Inglês variable-length array) do C, com dez milhões de elementos (que é o valor que você gravou em n[0]). Esse VLA não é alocado na memória livre, mas sim na pilha, e a pilha costuma ter restrições de espaço mais rígidas do que a memória livre.

Tem certeza de que é isso mesmo que você quer? Dois vetores, sendo um (n) totalmente dinâmico e alocado numa memória mais geralmente mais farta, e outro (v) alocado de modo automático na pilha, que tem mais restrições?



É improvável que você queira realmente usar um ponteiro para n aqui. Seria seguramente mais eficiente passar um inteiro do que um ponteiro para inteiro, uma vez que você está interessado num único valor apontado (e dentro de um laço de repetição, ainda por cima), não no apontamento em si.

E o mesmo comentário vale para a função de impressão, também.



Certamente você está extrapolando os limites de memória. E eu chutaria que é na hora de alocar o vetor na pilha.

removido
(usa Nenhuma)

Enviado em 15/12/2017 - 01:51h

@paulo1205 o modo como as funções interagem com o vetor dão a ideia que ele esperava que "v" iria agir como uma array e "n" como um "int" ja que não passou os "n" por referencia. Sendo este o caso, além do possivel "overflow", interagir com uma array de arrays não poderia gerar algum "segfault" também (ao menos do modo feito) ou ao menos undefined behaviour?

paulo1205
(usa Ubuntu)

Enviado em 15/12/2017 - 18:20h

Não entendi sua dúvida. Que array de arrays?

No programa mostrado, o que me pareceu foi que o autor do tópico nunca quis que n fosse um vetor, tanto que ele usa apenas uma posição e, nas funções, usa essa posição exclusivamente para indicar o tamanho do outro vetor (v), que ele trata efetivamente como um vetor, ao aceder a vários de seus elementos.

removido
(usa Nenhuma)

Enviado em 16/12/2017 - 02:26h

Engano meu, eu confundi uma parte do codigo e acabei confundido como o v agiria.


exatamente, também acredito que seja este o caso, daria facilmente para usar n como uma constante e passar seu valor por copia, como você citou. Mas é quase certeza que o malloc falhou ou a pilha deu overflow que é o mais provavel devido aos limites do mesmo. Os "erros" que citei foram engano, desconsidere-os.