Newsgroup: it.comp.os.linux.development
Titolo: problema allocazione

Salve, sto facendo il porting di un'applicazione che avevo scritto per
Windows sotto Linux e riscontro un problema nell'allocazione di una
matrice, il programma deve allocare una matrice Nx2, sotto windows
questo codice funziona bene:
unsigned int **mappa;
mappa = (unsigned int **)malloc(2*sizeof(unsigned int));
for(int i=0; i<2; i++) {
   mappa[i] = (unsigned int *)malloc(((w/32)*(h/32))*sizeof(unsigned
int));
}
dove w ed h sono due valori interi divisibili per 32.
Compila anche sotto Linux senza problemi ma all'esecuzione ottengo un
segmentation fault poichè non mi alloca come sotto win una matrice Nx2
ma 2xN (almeno credo), quindi se nel programma cerco di leggere o
scrivere mappa[3][0] sono già fuori.
E' veramente così (e perchè?) o c'è qualcosa che non so ?
Grazie mille.
Fabrizio.
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 E' veramente cosě (e perchč?) o c'č qualcosa che non so ?
Questo dovrebbe essere:
mappa = (unsigned int **)malloc(2*sizeof(unsigned int *));
Tuttavia e' strano che crashi visto che tipicamente
sizeof(unsigned int) == sizeof(void *) == 4....
Occhio anche che w/32 o h/32 non siano 0, forse la glibc non digerisce 
bene malloc di 0 bytes :)
Bye,
  Gabry

 Fabrizio.
Ciao
Matic

 
Grazie!
Ho provato e funziona, anche ragionando č piů logico, prima 
devo allocare la prima dimensione e poi l'altra....non ci avevo 
mica pensato perň.....
Quello che non capisco č perchč sotto win funziona, qualche idea a 
riguardo? Puň essere che win permetta di scrivere in ram (fintanto 
che non entro nella ram risrvata al s.o), anche se non č allocata,
avendo solo un indirizzo base allocato e poi scrivendo in maniera 
adiacente e successiva facendo base[0], base[1].... ? 
Una cosa cosě sarebbe un baco indecente del s.o.
(probabilmente non si č capito una sega di quello che ho scritto...:-))
Ciao!
ancora grazie.


 adiacente e successiva facendo base[0], base[1].... ? 
dipende dal windows. Non tutte le versioni hanno la protezione della
memoria. Solo NT e le versioni professional.

 memoria. Solo NT e le versioni professional.
ok ok, sarà pure un sistema di m***a, ma non credo che non abbia
abilitata la protezione della memoria.. voglio dire, se un sistema è
multitasking deve per forza implementare un meccanismo di protezione, e
anche windows 95 lo fa. Basta pensare al famoso "Chiudi Dettagli", che
scattava in caso di segmentation fault.
Per tornare al problema originale, non è detto che 'sforando' di uno o
due elementi in un array si abbia necessariamente un segfault: è
possibile per esempio sovrascrivere altre zone di memoria appartenenti al
proprio programma che non siano indirizzi di ritorno nello stack o i chunk
della malloc()&co.) oppure è possibile scrivere laddove il compilatore
aveva paddato la memoria per raggiungere un allineamento. Poi non so bene
come funzioni la gestione della memoria su windoz quindi non so dirti di
preciso.
Ciau
Matico

 preciso.
no, vabbé anche su linux dovrebbe essere possibile perché l'heap viene
esteso dinamicamente e mi sembra sia di un mega e mezzo all'inizo per ogni
programma appena istanziato. E in quel mega e mezzo se sbagli non dovresti
avere segfault. Perň non ne sono sicurissimo.

 dovresti avere segfault. Però non ne sono sicurissimo.
Di sicuro l'area di memoria ritornata da malloc è circondata da chunk, e
se li sovrascrivi molto probabilmente ogni successiva chiamata a malloc
calloc realloc free ti farà crashare il programma. 
Ciao
Matic
_____________________
..in a world far away
 we may meet again..

 
[CUT]
Scusa l'ignoranza, mi potresti spiegare a grandi linee cosa sono i
filtri fir e iir ? Grazie.


 Aspetto che qualcun'altro si pronunci
Win95 protegge la pagina 0 e la memoria NON esistente, per il resto se 
al posto di = NULL a pippo assegni un puntatore valido puoi crashare il 
sistema (e non solo l'applicazione come succede su linux).

 filtri fir e iir ? Grazie.
parto dal presupposto che abbia un'idea di cosa sia un filtro numerico.
FIR = finite impulsive response
IIR = infinite impulsive response
In particat i filtri fir sono filti che hanno il denominatore uguale a 1 e
quindi non hanno poli nella funzione di trasferimento (per cui la risposta
impulsiva e finita). Gli iir invece hanno come denominatore una
espressione polinomiale e quindi dei poli e quindi hanno una risposta
impulsiva infinita. Se non ci credi basta che fai qualche prova con la
trasformata Z e lo verifichi.