Newsgroup: it.comp.lang.visual-basic
Titolo: [VB.NET] Calcolo tempo impiego e riscaldamento CLR

Salve a tutti
Stavo calcolando la differenza di tempo di impiego nel passare i tipi per
riferimento e per valore,
(utilizzo di Environment.TickCount e Now)
e ho notato una variazione di calcolo di impiego tra il primo ciclo e i
successivi.
Al primo i due tempi sono differenti per uniformarsi per i successivi.
Che il CLR abbia bisogno di riscaldamento iniziale ?
Di seguito l'es.
  Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles Button1.Click
        Dim start As Date
        Dim i As Int32 = 0
        Dim res As Int32 = 0
        Dim env1 As Int32 = 0
        'Boxing
        env1 = Environment.TickCount
        start = Now
        For i = 0 To 10000000
            res = GetObject(i)
        Next
         Console.WriteLine("Boxing Now.Subtract: {0}", Now.Subtract(start))
        Console.WriteLine("Boxing Unvironment.TickCount Boxing: {0}",
(Environment.TickCount - env1))
    End Sub
  Function GetObject(ByVal n As Object)
        Return n
    End Function
giuseppeD

 Che il CLR abbia bisogno di riscaldamento iniziale ?
Non ho ancora ben chiara la dinamica del compilatore "JIT" del CLR, però ti
direi che all'inizio (anch'io noto lo stesso "problema") il CLR si deve
tirare su tutto quello che gli serve man mano che lo incontra
nell'applicazione.
In realtà una cosa del genere avviene anche con COM e DLL standard, solo che
il Framework .NET è molto più pesante da far partire.
Per fortuna che una volta in piedi è una lippa, anche se non paragonabile a
compilati C/C++ :)
Ciao
--
Math Parser : 
http://www.neodatatype.net
Sito Comune : 
http://www.it-lang-vb.net

 nell'applicazione.
Ho notato che il tutto entra a regime dopo che il programma funziona un pň.
L'impressione se inizi , chiudi, riparti, funziona piů velocemente.
La sequenza di tirare il codice all'occorrenza,stenti la partenza, cui la
costruzione di una immagine nativa,for me, aiuti poco.
Per test delicati, le prime conviene gettarli ?
giuseppeD

 Che il CLR abbia bisogno di riscaldamento iniziale ?
certo. Deve compilare il programma. E' come Java. E' uno schifo & una pena
ogni volta che usi un programma.


uhm... mi sembra una affermazione eccessiva: dipende da quale è il termine
di paragone. Rispetto a VB6, VB .NET è _tipicamente_ più performante, almeno
sulle performance di calcolo. Prova a realizzare (ad esempio) il calcolo di
pi greco con la formula di Eulero, e esegui (tanto per dire) 100 milioni di
cicli:
VB6
Public Function CalcolaPiGreco(ByVal numeroIterazioni As Long) As Double
    Dim parzialeSerie As Double
    Dim iterazione As Long
    parzialeSerie = 1
    For iterazione = 3 To numeroIterazioni Step 4
        parzialeSerie = parzialeSerie - (1 / iterazione)
        parzialeSerie = parzialeSerie + (1 / (iterazione + 2))
    Next
    CalcolaPiGreco = parzialeSerie * 4
End Function
VB .NET
Public Function CalcolaPiGreco(ByVal numeroIterazioni As Int32) As Double
    Dim parzialeSerie As Double = 1
    For iterazione As Int32 = 3 To numeroIterazioni Step 4
        parzialeSerie -= 1 / iterazione
        parzialeSerie += 1 / (iterazione + 2)
    Next
    Return (parzialeSerie * 4)
End Function
tutte le ottimizzazioni di entrambi i compilatori dovrebbero, ovviamente,
essere attivate. Sulle macchine che ho utilizzato per questo (rudimentale)
test, .NET sfoggia tempi inferiori (mediamente) del 30%
VB .NET non salverà certo il mondo, ma da qui a dire che è "uno schifo ed
una pena" ce ne passa... :-))
--
.A
UGIdotNET - User Group Italiano .NET
http://www.ugidotnet.org