[C] allocazione dinamica(e non) limitata

[yngwie21]

Salve a tutti!

Ho realizzato un programmino in C che effettua una ricerca di soluzioni espandendo ricorsivamente un albero. Per far questo, ad ogni nuova espansione di un nodo creo altri nodi dinamicamente (malloc() ) fino a che la ricerca non termina con successo.

Quando la soluzione è a profondità accettabile non vi sono problemi visto che il programma termina correttamente restituendo la soluzione corretta, mentre quando la soluzione è ad una profondità eccessiva il programma non termina correttamente (crasha).

Ogni nodo occupa 88 byte... le ricerche più complesse arrivano a creare parecchie migliaia di istanze in memoria. Il crash si verifica a 21000 nuovi nodi allocati dinamicamente, sotto winsows, col dev C++ , mentre col gcc di linux arriva a 81000 istanze dopo di che termina col seguente messaggio "segmentation fault".

Pensavo fosse solo una questione di allocazione dinamica relativa a malloc() e quindi al limitato spazio della heap, ma mi sono accorto che non è cosi poichè ottengo gli stessi risultati se in un qualsiasi programma istanzio (non dinamicamente) un vettore delle dimensioni succitate. Ad esempio :

struct nodo N[21000]

dove la struct nodo è di dimensione 88 byte, genera errori.

Come posso risolvere questo problema?
E' possibile dare al programma maggior spazio?
Se SI questo implica delle impostazione del compilatore o del sis. op.?


Grazie in anticipo per le risposte!

[sottovento]

Spannometricamente: hai un crash dopo aver creato circa 21000 nodi, dove ogni nodo occupa 100 bytes. Quindi hai allocato 2100000 bytes, cioe' 2 Mb.
Per i computer attuali non e' poi cosi' tanto. Io cercherei da un'altra parte.
Sei sicuro al 100% delle tue ricerche? Potrebbe essere che c'e' un bug che si verifica dopo il suddetto numero di passaggi?

Inoltre: se il problema e' davvero e' la mancanza di memoria, devo supporre che non hai fatto controlli! (in azienda viene considerato errore da lapis rosso), vale a dire:

buf = malloc (100);
if (buf == NULL)
{
   // Gestisci l'errore. Se non sai come gestirlo, segnala l'errore in qualche modo ed esci!!!
}
else
{
   // Usa pure la tua memoria
}

Se hai fatto questi controlli (correttamente) non dovresti andare in crash, giusto? Quindi, se li hai fatti, non stiamo parlando di mancanza di memoria.
Se non li hai fatti, non sai distinguere il problema, quindi mettili.

Una volta aggiunti, fai girare l'applicazione sotto debugger ed analizza i tuoi puntatori al momento del crash. E' probabile che manchi una condizione particolare...

Originariamente inviato da yngwie21

Salve a tutti!

Ho realizzato un programmino in C che effettua una ricerca di soluzioni espandendo ricorsivamente un albero. Per far questo, ad ogni nuova espansione di un nodo creo altri nodi dinamicamente (malloc() ) fino a che la ricerca non termina con successo.

Quando la soluzione è a profondità accettabile non vi sono problemi visto che il programma termina correttamente restituendo la soluzione corretta, mentre quando la soluzione è ad una profondità eccessiva il programma non termina correttamente (crasha).

Ogni nodo occupa 88 byte... le ricerche più complesse arrivano a creare parecchie migliaia di istanze in memoria. Il crash si verifica a 21000 nuovi nodi allocati dinamicamente, sotto winsows, col dev C++ , mentre col gcc di linux arriva a 81000 istanze dopo di che termina col seguente messaggio "segmentation fault".

Pensavo fosse solo una questione di allocazione dinamica relativa a malloc() e quindi al limitato spazio della heap, ma mi sono accorto che non è cosi poichè ottengo gli stessi risultati se in un qualsiasi programma istanzio (non dinamicamente) un vettore delle dimensioni succitate. Ad esempio :

struct nodo N[21000]

dove la struct nodo è di dimensione 88 byte, genera errori.

Come posso risolvere questo problema?
E' possibile dare al programma maggior spazio?
Se SI questo implica delle impostazione del compilatore o del sis. op.?


Grazie in anticipo per le risposte!

[yngwie21]

Non è un problema di controlli (che cmq ho fatto) infatti come avevo spiegato prima ho lo stesso problema se dichiaro un array di dimensione di strutture di 21000 elementi.

[GByTe87]

Magari dico una cazzata.

Provato a settare ulimit (in particolare per quato riguarda lo stack, per le variabili statiche) a valori più alti?

Bye!

[yngwie21]

Originariamente inviato da GByTe87

Magari dico una cazzata.

Provato a settare ulimit (in particolare per quato riguarda lo stack, per le variabili statiche) a valori più alti?

Bye!

Ma ulimit, che io sappia, può essere usato se opportunamente settato per fare in modo che in caso di errori si generi un dump nella RAM di dimensione illimitata. Ha cmq a che vedere con la fase di debug.

[Supdario]

Originariamente inviato da yngwie21

Per far questo, ad ogni nuova espansione di un nodo creo altri nodi dinamicamente (malloc() ) fino a che la ricerca non termina con successo.

Ti sei assicurato che una volta che il nodo non è più utile, venga rimosso dalla memoria con la funzione free()?

[WarDuck]

Non è che il problema sia di diversa natura? Magari potrebbe essere un accesso in memoria sbagliato...

Sotto Linux usa l'ottimo Valgrind, ti saprà aiutare .

[sottovento]

Originariamente inviato da yngwie21

Non è un problema di controlli (che cmq ho fatto) infatti come avevo spiegato prima ho lo stesso problema se dichiaro un array di dimensione di strutture di 21000 elementi.

E' sempre piu' probabile che ci sia un piccolo bug nel software. Come suggerito da WarDuck, usa Valgrind oppure fai girare l'applicazione sotto debugger, immagino che troverai il crash facilmente.

In alternativa, posta il codice qui