[C#] Wat is nu sneller / efficienter?

[evolution536]

Na wat onderzoek naar c# i.c.m. pointers, puur uit interesse, kwam ik op een voorbeeld uit. ik heb dit voorbeeld gebruikt in een programma voor mezelf, maar ik weet eigenlijk niet wat nu sneller / efficienter is. De MSDN beschrijft dat het gebruik van unsafe code in c# sneller is dan het gebruik van normale code. Het onderstaande was origineel, en werkte:

C#:

[DllImport("iphlpapi.dll", ExactSpelling = true)]
        private static extern int SendARP(int DestIP, int SrcIP, byte[] pMacAddr, ref uint PhyAddrLen);

C#:

public static bool CheckAddressAvailability(IPAddress addr)
        {
            byte[] macAddr = new byte[6];
            uint macAddrLen = (uint)macAddr.Length;
            int res = SendARP(BitConverter.ToInt32(addr.GetAddressBytes(), 0), 0, macAddr, ref macAddrLen);
                if ((res == 0 || res == 31))
                {
                    if (macAddr[0] != 0 || macAddr[1] != 0 || macAddr[2] != 0 || macAddr[3] != 0
                        || macAddr[4] != 0 || macAddr[5] != 0)
                    {
                        return false;
                    }
                }
            return true;
        }

Het bovenstaande werkt zoals ik het wil. Nu heb ik het onderstaande gemaakt, wat ook werkt zoals ik het wil

C#:

[DllImport("iphlpapi.dll", ExactSpelling = true)]
        private static unsafe extern int SendARP(int DestIP, int SrcIP, void* pMacAddr, ref uint PhyAddrLen);

C#:

public static unsafe bool CheckAddressAvailability(IPAddress addr)
        {
            byte[] macAddr = new byte[6];
            uint macAddrLen = (uint)macAddr.Length;
            fixed (byte* ptr = macAddr)
            {
                int res = SendARP(BitConverter.ToInt32(addr.GetAddressBytes(), 0), 0, ptr, ref macAddrLen);
                if ((res == 0 || res == 31))
                {
                    if (macAddr[0] != 0 || macAddr[1] != 0 || macAddr[2] != 0 || macAddr[3] != 0
                        || macAddr[4] != 0 || macAddr[5] != 0)
                    {
                        return false;
                    }
                }
            }
            return true;
        }

De vraag die mij nu berust: Wat is sneller?

[NickThissen]

Probeer het gewoon?

[Mavamaarten]

Inderdaad?
Herhaal het een duizendtal keer en kijk hoeveel miliseconden er voorbij zijn. Dan weet je welke sneller is

[Phyxion]

Aangezien de code nagenoeg hetzelfde is verwacht ik niet dat je dit verschil gaat merken. Als je al gaat testen, probeer het dan minstens 100 keer per functie en niet één keer.

[afraca]

offtopic:
nevermind

[ Voor 95% gewijzigd door afraca op 25-02-2012 15:50 ]

[SideShow]

Waarom toon je 2 keer dezelfde code ?

[Phyxion]

SideShow schreef op zaterdag 25 februari 2012 @ 17:24:
Waarom toon je 2 keer dezelfde code ?

Beter kijken, er zit maar liefst 1 regel verschil tussen.

[jip_86]

SideShow schreef op zaterdag 25 februari 2012 @ 17:24:
Waarom toon je 2 keer dezelfde code ?

Het is niet hetzelfde, hij maakt alleen van de byte[] een byte*

Verwacht er niet heel veel van. Je geeft alleen het argument net iets anders. Onder water zal de functie waarschijnlijk hetzelfde doen als wat jij nu zelf doet.

[RobIII]

Tenzij je deze code honderden keren per seconde uitvoert zie ik sowieso niet in waarom 't zou boeien welke van de twee 't snelst is. Typisch gevalletje microoptimalisatie.

[Kevinp]

RobIII schreef op zondag 26 februari 2012 @ 22:59:
Tenzij je deze code honderden keren per seconde uitvoert zie ik sowieso niet in waarom 't zou boeien welke van de twee 't snelst is. Typisch gevalletje microoptimalisatie.

Dit,

Ik vermoed dat het tweede (de unsafe versie) iets sneller is. Echter niet nuttig sneller.

Daarnaast moet je wel ineens gaan oppassen (niet voor niks unsafe) met het uitlezen.

[pedorus]

Ik zie nog wel een optimalisatie waarbij je in plaats van 6 bytes gewoon 1 long pakt en vergelijkt of die 0 is... Kan in beide versies.

[MLM]

1) Je zit te micro-optimizen om een API call. Over het algemeen kan je aannemen dat een API zoals deze echt 1000x langer duurt dan jouw code.
2) Je kan ook 1 uint64 als buffer gebruiken (dat is 8 bytes), dan kan je het hele unsafe gedeelte skippen

[Woy]

Buiten het feit dat de bovenstaande posters al aanhalen ( Dat het niet iets is om je in dit geval druk over te maken):

Het tweede zal iets sneller kunnen zijn aangezien er een marshalling stap minder nodig is voor de pointer. Maar aangezien die stap waarschijnlijk zo goed als hetzelfde doet wat jij doet zal het verschil niet al te groot zijn. Zeker aangezien de call zelf al netwerk IO uit moet voeren en dus enkele ordes van grote langer zal duren dan het aanroepen zelf.

Ik zou in ieder geval altijd eerst voor de meest leesbare en duidelijke versie gaan, en als je er achter komt dat je een performance bottleneck hebt kun je verder gaan kijken.

[ Voor 10% gewijzigd door Woy op 27-02-2012 09:43 ]

[evolution536]

Ik heb het weer terugveranderd naar de normale versie. Het was puur uit interesse, en dit is eigenlijk ook niet performance kritiek. zeker omdat er ook netwerk io nodig is zal het inderdaad weinig verschil maken.

Bedankt in ieder geval voor jullie reacties, die zijn wel nuttig voor een ander aspect waarin bijvoorbeeld veel IO nodig is en performance dus wel uitmaakt.