[VB.net] if snelheid vraag.

[Michali]

Wat is sneller.

Visual Basic:

If a > 10 Then
      'Iets
End if

een integer test

of

Visual Basic:

If a = True Then
      'Iets
End if

een boolean test

[Verwijderd]

Die vraag is eigenlijk nogal onzinnig... mocht er verschil tussen de snelheid zijn, dan is het zeker te verwaarlozen, vooral als je ook andere factoren zoals de huidige toestand van de processor (bevindt de operand zich in een register?) in oogschouw neemt.

[henkleerssen]

Je zu het een en ander gewoon in VB kunnen timen.. Onderstaand voorbeeld kun je een andere functie aanroepen van een VBA project (excel in dit geval .. met een beetje freubelen kan dat in je vb appje...):

Visual Basic .NET:

Public Declare Function GetTickCount Lib "kernel32" () As Long

Function TimeFunctionPerformance(FunctionName As String)
Dim iNumberOTest As Integer
Dim iNumberArgs As Integer
Dim Args As String
Dim TimerBefore As Double
Dim TicksBefore As Double

TimerBefore = CDbl(Now)
TicksBefore = GetTickCount

For iNumberOTest = 1 To 100
    Call Application.Run("Book1.xls!" & FunctionName, "Paramater1", "Paramater2")
Next

Debug.Print CDbl(Now) - TimerBefore & ":" & (GetTickCount - TicksBefore) '/ 1000 & "s"

End Function

zelf bedachte timings functie.. want ik was ook wel benieuwd hoe ik mijn eigen progjes sneller kon maken....

[henkleerssen]

Verwijderd schreef op 14 oktober 2002 @ 14:35:
Die vraag is eigenlijk nogal onzinnig... mocht er verschil tussen de snelheid zijn, dan is het zeker te verwaarlozen.

Bullshit.. als iets veel wordt gerepeteerd (of dat je for.. next loop hebt .. of functie veel moet aanroepen, dan kan het wel degelijk van belang zijn wat nu precies sneller is..

[Michali]

Verwijderd schreef op 14 oktober 2002 @ 14:35:
Die vraag is eigenlijk nogal onzinnig... mocht er verschil tussen de snelheid zijn, dan is het zeker te verwaarlozen, vooral als je ook andere factoren zoals de huidige toestand van de processor (bevindt de operand zich in een register?) in oogschouw neemt.

Niet als het tegen de duizenden if-jes gaat zitten.

[Verwijderd]

Snelste :

If a Then
'Iets
End if

de'= true' doet de server erzelf wel aanplakken, scheelt weer code
Een Boolean test is altijd het snelste, omdat er dan maar 2 waardes mogelijk zijn, nl 0 en 1 wat dus minder plek nodig heeft in het geheugen. Ook hoeft er geen vergelijking te gebeuren.

DD

[alley]

Michali schreef op 14 oktober 2002 @ 14:37:
[...]


Niet als het tegen de duizenden if-jes gaat zitten.

Volgens mij zal het eerder in de miljoenen (zoniet miljarden) if-jes moeten lopen voordat het verschil merkbaar is voor de eindgebruiker... Met duizenden ifjes zal het wel in de milli-seconden blijven....

Maar goed, idd gewoon een
if (true) then
is het snelst, immers anders moet de vergelijking eerst naar een boolean worden omgezet terwijl het nu meteen een boolean is....

[Verwijderd]

Best practices inclusief performance practices zoals hierboven

http://msdn.microsoft.com...art/html/vbtchperfopt.asp

[marcusk]

Nope, ze kosten beide evenveel (IA32) assembly instructies, dus het maakt helemaal niets uit.

[Janoz]

Verwijderd schreef op 14 oktober 2002 @ 14:50:
Snelste :

If a Then
'Iets
End if

de'= true' doet de server erzelf wel aanplakken, scheelt weer code
Een Boolean test is altijd het snelste, omdat er dan maar 2 waardes mogelijk zijn, nl 0 en 1 wat dus minder plek nodig heeft in het geheugen. Ook hoeft er geen vergelijking te gebeuren.

DD

Nou, zal ik deze droom ook maar ff doorprikken.... Een boolean wordt niet in 1 bit opgeslagen..

Daarnaast maakt het niks uit of je nu een check doet tussen twee bits of tussen twee longs. De huisige 32 bits proccessoren hebben voor bijden hetzelfde aantal clockticks nodig.

[Orphix]

Zonder benchmarking kan je hier weinig over zeggen. VB.NET wordt gecompileerd naar een intermediate language, het is goed mogelijk dat er al wat optimalisaties overheen zijn gevoerd in deze fase. Verder is het afhankelijk van de status van je programma op dat moment, thread-switching, garbage collector, etc.

En zoals altijd geldt dat je eerste opzet altijd in duidelijke logische code moet worden geimplementeerd. Mocht _dan_ blijken dat de performance niet goed is, dan kan je gaan goochelen met je statements om te kijken of er nog wat meer uit te halen valt.

[Verwijderd]

Nope, ze kosten beide evenveel (IA32) assembly instructies, dus het maakt helemaal niets uit.

Niet helemaal waar. met .Net praat je over een intermediate language. Daar zit de vertraging.

[marcusk]

Bij .NET wordt de IL eerst naar native code gecompileerd voordat het uitgevoerd wordt.

[Verwijderd]

marcusk,
uiteindelijk is het meer leesbare code en is het verschil zo verdomde klein dat het niet eens van belang is. In tegenstelling tot 10 jaar geleden.

[marcusk]

Verwijderd schreef op 14 oktober 2002 @ 15:12:
marcusk,
uiteindelijk is het meer leesbare code en is het verschil zo verdomde klein dat het niet eens van belang is. In tegenstelling tot 10 jaar geleden.

Erm... wat wil je daar nou mee zeggen? Mijn reaktie was een antwoord op jouw opmerking erboven. (ik zei dus juist dat het niets uitmaakt kwa snelheid)

[Verwijderd]

Ik dus ook :-/

[Michali]

Ok bedankt allen. Ik kan weer rustig slapen

[Verwijderd]

Bool 10,9611648
Int 11,1626568
Long 11,8477296

De boolean is de winnaar.

Uiteraard zijn er 100-en redenen waarom deze tests oneerlijk zijn (don't get me started, als iemand anders dit zou posten zou ik meteen gaan katten ) maar feit is gewoon dat het met booleans het snelste gaat!


Dat is de uitkomst van dit VB.NET progje

code:

Module Module1

    Public totalInt As Long = 0
    Public totalBool As Long = 0
    Public totalLong As Long = 0

    Sub main()
        dotests()
        dotests()
        dotests()
        dotests()
        dotests()

        Console.WriteLine("Bool" & vbTab & totalBool / 5000000)
        Console.WriteLine("Int" & vbTab & totalInt / 5000000)
        Console.WriteLine("Long" & vbTab & totalLong / 5000000)
        Console.ReadLine()
    End Sub

    Sub dotests()
        Dim i As Integer = 8000I
        Dim b As Boolean = False
        Dim l As Long = 80000000000L
        Dim loopInt As Long
        Dim endloop As Long = 100000000
        Dim timestart As DateTime
        Dim timestop As DateTime


        Dim tStart As Long
        Dim tStop As Long

        tStart = DateTime.Now.Ticks
        For loopInt = 0 To endloop
            compInt(i)
        Next
        tStop = DateTime.Now.Ticks
        totalInt = totalInt + (tStop - tStart)
        'Console.WriteLine("Integer test : " & tStop - tStart)


        tStart = DateTime.Now.Ticks
        For loopInt = 0 To endloop
            compBool(b)
        Next
        tStop = DateTime.Now.Ticks
        totalBool = totalBool + (tStop - tStart)
        'Console.WriteLine("Boolean test : " & tStop - tStart)


        tStart = DateTime.Now.Ticks
        For loopInt = 0 To endloop
            compLong(l)
        Next
        tStop = DateTime.Now.Ticks
        totalLong = totalLong + (tStop - tStart)
        'Console.WriteLine("Long test : " & tStop - tStart)
    End Sub

    Function compInt(ByVal i As Integer) As Boolean
        If i > 10000I Then
            Return True
        Else
            Return False
        End If
    End Function

    Function compBool(ByVal b As Boolean) As Boolean
        If b = True Then
            Return True
        Else
            Return False
        End If
    End Function

    Function compLong(ByVal l As Long) As Boolean
        If l > 10000L Then
            Return True
        Else
            Return False
        End If
    End Function
End Module

[Glimi]

alley schreef op 14 oktober 2002 @ 14:58:
Maar goed, idd gewoon een
if (true) then
is het snelst, immers anders moet de vergelijking eerst naar een boolean worden omgezet terwijl het nu meteen een boolean is....

een verschil tussen if bool en if bool == true in code geeft geen verschil in code genereerd door de compiler, anders zuigt ie echt heel erg qua optimalisatie.
Tevens zal een bool ook gewoon naar een int geconvert worden in machinecode/vm code, die gewoon op de C(++) manier gaat werken, dus 0 == false en !0 == true. Echter je gooit met de if x > 10 een extra vergelijking er bij, die dus wel vertragend zal werken

edit:
jhuuuuist, spuit 11 hier

[Verwijderd]

[...]
Echter je gooit met de if x > 10 een extra vergelijking er bij, die dus wel vertragend zal werken

Dat was ook een van mijn 100 puntjes