[vb2008] vb e la gestione della memoria

[eziogsv]

ho realizzato un programmino che legge centinaia di files contenuti in una cartella, per fare una serie di statistiche in relazione a ciò che trova o non trova.

per far ciò ad ogni ricerca vengono reinizializzate una ventina di variabili ed una decina di matrici a dimensione fissa, non superiore a 20.

la cosa che non mi spiego è questa: la prima volta che lancio il programma dopo la apertura di Windows l' elaborazione richiede una ventina di secondi

le volte successive l' elaborazione richiede una decina di secondi, e questo anche se chiudo e rilancio il programma!!

evidentemente dopo il primo lancio in assoluto succede "un qualcosa" che ottimizza la memoria per i lanci successivi, anche se il programma viene chiuso e riaperto.

la domada è: cosa è che succede e non viene modificato neanche chiudendo il programma?? come ottenere questa ottimizzazione già al primo lancio del programma dopo l' apertura di Windows?

[Pirelli72]

Prova a leggere questa parte di articolo:

Just-In-Time (JIT) compilation
As stated above, the Just in time compiler is a facility that is invoked by the CLR to convert the IL into machine code. The .NET framework assemblies (*.dll or *.exe) files cannot be executed by the target processor unless it is converted into native code. When the Assembly is loaded the method calls are invoked for compilation into native code. Since this is done just when the method needs to execute, it is called Just in time compilation. When the JIT is invoked for the first time there is an overhead or performance penalty, since the assembly is converted into its Native code or image using the Native Image Generator (Ngen.exe). All subsequent calls will load faster as the Native image alone is invoked thereafter from the Native image cache.

Non so se si può applicare al tuo caso, visto che qui mi sembra qui si parli di chiamate successive, non so se funzioni anche dopo il riavvio dell'applicazione. Forse chi è più esperto di me potrà risponderti.

[morocarlo]

con un applicazione che avevo fatto tempo fa avevo notato la stessa cosa... non so da cosa dipenda... ma lo avevo notato anch'io... ma non ho aproffondito il discorso.

Lo spezzone che ha postato pirelli potrebbe però dare una risposta...
Hai provato a vedere che accade quando riavvii il computer?

[eziogsv]

Quando riavvio il PC.. ogni prima volta che lancio il programma il tempo è tutte le volte doppio delle successive.

Interessante questo discorso della JIT... ho letto un pò in giro ma mi sfugge qualcosa.

Se ho ben capito JIT non interpreta nunc et semper il codice come VB6.0 e non compila il codice una tantum come un compilatore C++... è un pò una cosa intermendia: interpreta ma con la creazione di una "cache" di codice "già letto" per cui dopo un rallentamento iniziale poi l' esecuzione si velocizza.

Inoltre JIT lavora solo quando una istruzione viene eseguita, per cui una istruzione mai eseguita non viene mai interpretata.

Ok, ciò premesso capisco che in un programma basato su JIT la prima volta che viene eseguita una routine l' esecuzione sia più lenta, per velocizzarsi alla successiva esecuzione delle stesse istruzioni.

Ma se ciò fosse vero, dato che la routine che legge le diverse centinaia di files è sempre la stessa, la lettura dovrebbe essere lenta SOLO ALLA LETTURA DEL PRIMO FILE, per velocizzarsi dalla seconda alla ultima.

Invece TUTTA LA PRIMA SERIE DI LETTURE E' LENTA, per velocizzarsi enormemente dalla seconda in poi, sia che chiuda il programma o no (evidentemente la cache non si azzera chiudendo il programma).

E questa non la capisco.

[gibra]

Si chiama CACHE.

Qualsiasi azione, eseguita la prima volta, è sempre più lenta perchè il computer legge ed 'incamera' i dati nella memoria cache di sistema.

La seconda volta, i dati sono già nella memoria cache, quindi è più veloce.

Poi, a seconda del programma, vi possono essere ulteriori motivi per cui avviene questo 'fenomeno', come nel caso del Just-In-Time indicato da Pirelli72.

Aggiungo che, oggi come oggi, anche gli antivirus ovvero i tool (suite) sulla sicurezza del tipo 'faccio tutto io ' sono sempre più invasivi (fanno la loro parte), in genere peggiorando l'accesso ai file per verificarlo. La seconda volta, anche in questo caso, l'accesso al file è più veloce perchè l'antivirus lo ha già verificato.
Comunque questo dipende anche dalle impostazioni della 'suite'.

Proprio stamattina ero da un cliente che ha migrato da Windows XP a Windows7, ed una mia applicazione ha iniziato a dare messaggi di errore strani.
Ho capito subito che non era un problema di applicazione, ma di impostazioni della suite Kaspersky Internet Suite 2010.
Ho apero Kaspersky ed impostato la mia applicazione come 'attendibile' ed i messaggi di errore sono scomparsi.

[eziogsv]

@ gibra

interessanti considerazioni che hanno meritato una serie di prove

1)
Non è l' antivirus: alla apertura del PC ho chiuso il servizio (NOD32) e poi ho avviato le statistiche: nessuna variazione di tempi di lettura apprezzabile.

2)
Ho creato due nuove cartelle, ed ho inserito in ciascuna metà dei files totali. A questo punto ho letto prima una "mezza cartella", poi la seconda mezza cartella ed in ultimo la cartella con tutti i files. La prima volta che ho letto le tre cartelle i tempi erano lunghi, dalla seconda in poi i tempi dimezzati, come al solito: questo vuole dire NON E' QUESTIONE DI JIT (che se no già leggere la seconda cartella avrebbe dovuto comportare tempi dimezzati), ma in effetti di CACHE.

3)
A questo punto una curiosità: ma come fanno .net o Winzozz a "sapere" che ogni diverso ciclo for - next legge ed elabora files diversi ed aprire quindi gli spazi riservati a tre caches diverse??????

Cioè, io immagazzino innanzitutto tutti i nomi dei files della cartella, path comprese, in una matrice MyFiles(). Premendo il pulsante "Elabora" parte un ciclo:

For x=0 to MyFiles.Lenght-1
fileReader = My.Computer.FileSystem.ReadAllText(MyFiles(x))
...
...
Next

che esegue le elaborazioni spulciando ciò che è contenuto in fileReader.

Ma ad ogni nuova pressione del tasto "Elabora" (sia dei files contenuti nella stessa cartella di prima sia dei files contenuti in un altra) le variabili vengono dimensionate (e quindi azzerate). Che nella CACHE, con tutti i valori delle variabili sia salvata L' ULTIMA LETTURA posso capirlo, ma che a letture di files diversi venga riservato spazio per una nuova cache relativa a quella diversa lettura, questa non me la spiego

4)
Anche questa è un vero mistero.... come ho detto ho creato tre cartelle, due contenenti metà dei files ed una contenente tutti i files. Un ciclo For...Next legge poi questi files uno per uno, elaborandoli.

Ciò premesso per senso verrebbe da pensare che la somma dei tempi necessari ad elaborare le due "mezze cartelle" dovrebbe eguagliare il tempo necessario a leggere la cartella intera: NON E' COSI'... sia la prima lettura (coi tempi doppi) sia le seconde letture (coi tempi dimezzati) per leggere la cartella con tutti i files occorre MOLTO più della somma dei tempi necessari a leggere le due mezze cartelle !!!!!

Come detto, questa non me la spiego... nessuna matrice viene ridimensionata (che allora potrei pensare AL LIMITE ad un rallentamento dovuto al fatto di trovare più spazio in memoria, anche se sicuramente questo non aumenterebbei tempi di così tanto), i loro elementi sono fissi ed acquistano singolarmente, passaggio dopo passaggio, solo valori pari alla somma dei valori delle "mezze matrici"...

Forse si potrebbe intervenire su questo versante per ottimizzare i tempi, se capissi l' arcano...

Mi sa che tutto si riduca ad una ottimizzazione della cache... ma come????