La memoria

[misterx]

Cionci, guarda questo scorcio di programma che ad ogni passaggio
crea un nuovo spazio in memoria atto a contenere un'immagine, nel
programma ne vengono caricate ben 100!

Come gestisca ogni singolo puntatore alle singole immagini mi è oscuro
ma la mia domanda è la seguente:

possibile che con una semplice chiamata: delete MyImage la
memoria allocata dalle 100 immagini viene deallocata tutta in un colpo
solo?

Usando le API di windows, sembrerebbe di si: occhio, ho usato il condizionale
in quanto non ne sono affatto sicuro perchè: uscendo dal programma e rilanciando
il medesimo più volte, la memoria totale fisica di sistema continua incessantemente
a diminuire

a te l'ardua sentenza

TImage *MyImage = new TImage(Form1);

for (int i =0; i <100; i++)
{

Image = new TImage(this);

MyImage->Picture->LoadFromFile(FileListBox1->Items->Strings[i])

}
delete MyImage;

[cionci]

Image = new TImage(this);

Ma questo quando lo deallochi ?

[misterx]

mai, e qui sta il punto

prima di caricare le 100 immagini visualizzo la memoria disponibile con:
_MEMORYSTATUS lp_membuf;

GlobalMemoryStatus(&lp_membuf);
StatusBar1->Panels->Items[1]->Text = (int)lp_membuf.dwAvailPhys;



e dopo aver caricato le 100 immagini richiamo:

_MEMORYSTATUS lp_membuf;

GlobalMemoryStatus(&lp_membuf);
StatusBar1->Panels->Items[1]->Text = (int)lp_membuf.dwAvailPhys;


e calcolo la differenza che è sempre zero: questo non mi spiego

possibile che chiamando il delete una sola volta e fuori dal loop venga deallocata tutta la memoria?

[cionci]

No...però ci potrebbero essere meccanismi interni del BCB che fanno questo in automatico...

[misterx]

ho approfondito ed è tutto clamorosamente cannato il mio ragionamento perchè con:

delete MyImage

fuori dal loop, viene cancellata solo l'ultima allocazione; le funzioni di gestione della memoria ritornano zero perchè l'indirizzo delle precedenti allocazioni viene perso per sempre: memory leak

morale: BCB non dealloca automaticamente

grazie cionci in ogni caso

[misterx]

pensa che se io scrivo:


TForm *Form2 = new TForm(this);
TImage *MyImage = new TImage(Form2);

for (int i =0; i <100; i++)
{
Image = new TImage(Form2);
MyImage->Picture->LoadFromFile(FileListBox1->Items->Strings[i])
}

ed ora scrivo

delete Form2;

viene cancellato tutto quanto allocato in un colpo solo; una caratteristica di BCB

[misterx]

come non detto, i problemi di memoria continuano

sapete se la memoria virtuale in windows è gestita automaticamente?

grazie

[cionci]

Originariamente inviato da misterx
[b]sapete se la memoria virtuale in windows è gestita automaticamente?

In che senso ? Se è memoria virtuale DEVE essere gestita automaticamente per definizione

Non capisco ancora bene il tuo codice...
Qaul'è l'oggetto che deve avere 100 istanze ?

[misterx]

Originariamente inviato da cionci
[b]
In che senso ? Se è memoria virtuale DEVE essere gestita automaticamente per definizione

Non capisco ancora bene il tuo codice...
Qaul'è l'oggetto che deve avere 100 istanze ?

in questo senso

se tu compili il codice da me postato e lo utilizzi per visualizzare su un form 1500 immagini ad esempio; ti accorgerai che ad un certo punto verranno emessi dei messaggi di errore alquanto depistanti del tipo: "Canvas does not allow"

questo mi ha fatto pensare che il codice da me postato utilizzi solo la ram fisica di sistema a meno che non si informi windows di ciò attraverso opportune funzioni

anch'io ho sempre pensato che la memoria virtuale fosse gestita da windows in modo automatico ma gli strani messaggi e bada bene, non ripetibili, mi hanno depistato

per questo chiedevo conferme

[Angus]

Mi ricordo che nessuno si preoccupa di deallocare niente (al contrario del GarbageCollector Java per esempio).
Quindi ad ogni new qualcosa dovrebbe corrispondere un delete quel qualcosa. A meno che non si cancellino oggetti che hanno figli, ossia oggetti che avevano come parent o owner o qualcosa simile l'oggetto cancellato.
Sono solo ricordi offuscati dal tempo passato da quando smanettavo col bcb... ah bei tempi!!! Quindi ditemi se ho sparato troppo grosso

[cionci]

Ma quei 100 TImage quando li deallochi ??!?!?!

[misterx]

x Angus

tutto vero quanto hai detto


x Cionci

li dealloco solo al termine della visualizzazione, se li deallochi prima, non li visualizzi più

[cionci]

Originariamente inviato da misterx
[b]li dealloco solo al termine della visualizzazione, se li deallochi prima, non li visualizzi più

Ma ne deallochi solo uno perchè tutte le volte con new perdi il puntatore a quello precedente... Ecco dov'è il memory leak...

[misterx]

hai ragione ma, BCB offre anche questo che dovrebbe ricatturare il vecchio puntatore; almeno credo sia così:



for(int i=0; i < Form2->ComponentCount;i++)
if(Form2->Components[i]->ClassNameIs("TImage"))
{
TImage *img = (TImage*)Form2->Components[i];
delete img;
}

[Angus]

Originariamente inviato da misterx
[b]hai ragione ma, BCB offre anche questo che dovrebbe ricatturare il vecchio puntatore; almeno credo sia così:



for(int i=0; i < Form2->ComponentCount;i++)
if(Form2->Components[i]->ClassNameIs("TImage"))
{
TImage *img = (TImage*)Form2->Components[i];
delete img;
}

ogni qual volta trovi un TImage e lo deallochi, sei sicuro che il vettore Form2->Components rimanga invariato? E se invece cambiasse ogni volta come pure il valore di ComponentCount?
Per essere sicuro in entrambi i casi potresti scrivere il codice in modo da mettere prima i riferimenti ai TImage in un vettore temporaneo e poi ciclare su quello.

[misterx]

Originariamente inviato da Angus
[b]

ogni qual volta trovi un TImage e lo deallochi, sei sicuro che il vettore Form2->Components rimanga invariato? E se invece cambiasse ogni volta come pure il valore di ComponentCount?
Per essere sicuro in entrambi i casi potresti scrivere il codice in modo da mettere prima i riferimenti ai TImage in un vettore temporaneo e poi ciclare su quello.

ho fatto delle prove e ad ogni TImage allocato ho salvato il puntatore su file

quando dealloco, salvo nuovamente su file il puntatore di ogni TImage ritornato dalla:

TImage *img = (TImage*)Form2->Components[i];

sino ad ora, dopo numerose prove, sono sempre i medesimi indirizzi


la morale è che preferisco scrivere questo:

TImage *MyImage;
MyImage = new TImage(Form2);

in luogo di questo:

TImage *MyImage[100];

in quanto, con la prima, alloco memoria in modo dinamico


faccio in questo modo perchè non vorrei sprecare prezioso spazio nella memoria stack

BCB, se non ricordo male, ha di default 2 valori per l'area stack:

min=4Kb
max=100Kb

ma quando compilo non so se crea automaticamente lo spazio necessario per tutte le variabili ed i vettori

qualcuno mi ha detto che in teoria potrei scrivere anche:

TImage *MyImage[1000000]; (un milione) di puntatori di tipo (TImage da 4 byte per puntatore), in quanto è esclusivamente in funzione della memoria del PC

però così facendo sprecherei preziosa memoria

mi ricordo che in turbo C, l'area stack doveva essere impostata con: __stklen(......) o similare


se ho scritto qualche cavolata correggetemi pure

[Angus]

Originariamente inviato da misterx
[b]

ho fatto delle prove e ad ogni TImage allocato ho salvato il puntatore su file

quando dealloco, salvo nuovamente su file il puntatore di ogni TImage ritornato dalla:

TImage *img = (TImage*)Form2->Components[i];

sino ad ora, dopo numerose prove, sono sempre i medesimi indirizzi

Questo farebbe pensare che il vettore Components non tenga conto di quello che gli succede sotto il <vl0... mi spiego: all'inizio il vettore contiene 10 componenti, io ne posso deallocare alcuni e lui continua a dirmi che i componenti sono 10?!? Se così fosse... ROBE DA PAZZI!!!

[misterx]

Originariamente inviato da Angus
[b]

Questo farebbe pensare che il vettore Components non tenga conto di quello che gli succede sotto il <vl0... mi spiego: all'inizio il vettore contiene 10 componenti, io ne posso deallocare alcuni e lui continua a dirmi che i componenti sono 10?!? Se così fosse... ROBE DA PAZZI!!!

Ho già sperimentato anche questo ed il numero di componenti ritornati è sempre quello corretto.

Stranamente, facendo girare il programma sotto win2k non si hanno i benchè minimi problemi.

Il programma che sto sviluppando, per darti un'idea, è una sorta di ACDSee

[cionci]

Originariamente inviato da misterx
[b]Il programma che sto sviluppando, per darti un'idea, è una sorta di ACDSee

Chissà perchè me lo ero immaginato

[Angus]

Originariamente inviato da misterx
[b]

Ho già sperimentato anche questo ed il numero di componenti ritornati è sempre quello corretto.

Cosa intendi per sempre corretto?
Se intendi dire che deallocando un componente il numero dei componenti totali diminuisce di uno, mi domando se quel ciclo for ti vada a pescare TUTTI i TImage. Mi spiego:

Array Components: [Oggetto, TImage, TImage, Oggetto]
ComponentCount = 4;
quando i == 1 cancello il primo TImage.
A questo punto come è fatto Components?

Se fosse così:
[Oggetto, TImage, Oggetto]
ComponentCount = 3;
allora i++ ti porterebbe a saltare un TImage...

Se invece fosse cosà:
[Oggetto, NULL, TImage, Oggetto]
allora li beccheresti tutti.

MAH!

ps: vado a casa, a domani!