Vetor Gigante = Segmentation fault [RESOLVIDO]

anagrossi
(usa Ubuntu)

Enviado em 19/06/2017 - 05:23h

Olá! Tenho o seguinte código e preciso fazê-lo funcionar com um vetor de 1,6 milhão de posições, mas quando tento recebo o mensagem "Segmentation fault (core dumped)". Como proceder?

#include<stdio.h>

#include<stdlib.h>

#include<time.h>

#include<omp.h>

#define MAX 1600000



void intercalar(int array[], int aux[], int ini1, int ini2, int fim2);

void mergeSort(int array[], int temp[], int esq, int dir);



int main() {    



    int array[MAX];

    int cont; 

    

    srand(time(NULL)); 

    

    for (cont = 0; cont < MAX; cont++) {

        array[cont] = rand() % MAX + MAX; 

    }



    FILE *salvatxt;

    salvatxt = fopen("ordenado.txt", "w");



    fprintf(salvatxt, "Desordenado: \n");

    for (cont = 0; cont < MAX; cont++) {

        fprintf(salvatxt, "%d, ",array[cont]);

    }



    int aux[MAX];



    

	#pragma omp parallel

    {

		mergeSort(array, aux, 0, MAX);

        int cont;

        int divide = MAX / 32;

        

		#pragma omp for schedule(dynamic,divide) nowait

			

			 for (cont = 0; cont < MAX; cont++)

            printf("%d, ",  array[cont]);

			

    }



    fprintf(salvatxt, "\nMerge Sort aplicado:");

    for (cont = 0; cont < MAX; cont++) {

        fprintf(salvatxt, "%d, ", array[cont]);

	}

    return 0;



}



void intercalar(int array[], int aux[], int ini1, int ini2, int fim2) {

#pragma omp parallel

    {

        int in1 = ini1, in2 = ini2, fim1 = in2 - 1, au = 0, cont;

        int tid = omp_get_thread_num();



#pragma omp sections

        {

#pragma omp section

            {

                while (in1 <= fim1 && in2 <= fim2) {

                    if (array[in1] < array[in2]) {

                        aux[au++] = array[in1++];

                    } else {

                        aux[au++] = array[in2++];

                    }

                }

            }

#pragma omp section

            {

                while (in1 <= fim1) {

                    aux[au++] = array[in1++];

                }

            }

#pragma omp section

            {

                while (in2 <= fim2) {

                    aux[au++] = array[in2++];

                }

            }

#pragma omp section

            {

                for (cont = 0; cont < au; cont++) {

                    array[cont + ini1] = aux[cont];

                }

            }

        }

    }

}

void mergeSort(int array[], int temp[], int esq, int dir) {

    int meio;

    if (esq < dir) {

#pragma omp parallel sections

        {

#pragma omp section

            {

                meio = (esq + dir) / 2;

            }

#pragma omp section

            {

                mergeSort(array, temp, esq, meio);

                mergeSort(array, temp, meio + 1, dir);

                intercalar(array, temp, esq, meio + 1, dir);

            }

        }

    }

    

}

 

paulo1205
(usa Ubuntu)

Enviado em 19/06/2017 - 10:21h

O problema é que você está tentando criar esse vetor gigante na pilha (memória automática, no jargão do C), cujo limite de alocação é geralmente mais restrito do que outros tipos de memória.

O SamL indicou uma solução adequada, sugerindo que você use o tipo de memória que costuma ter menos restrições possíveis. Mas existem outras abordagens possíveis:

- aumentar o limite para alocação de memória na pilha antes de executar o programa (não recomendado, e fora do controle do próprio programa);

- usar memória estática, declarando seu array como global (fora da função), ou mantendo local (dentro da função) mas com atributo explícito static.

anagrossi
(usa Ubuntu)

Enviado em 20/06/2017 - 08:16h

Obrigada, gente!! Vocês são demais! (: