Eit mislukka innlegg om akselerering av refleksjon

Jeg skal straks forklare tittelen pÄ artikkelen. Det var opprinnelig planlagt Ä gi et godt, pÄlitelig rÄd om hvordan man kan akselerere bruken av refleksjon med et enkelt, men realistisk eksempel, men under benchmarking viser det seg at refleksjon ikke fungerer sÄ sakte som jeg trodde, mens LINQ fungerer saktere enn jeg noen gang kunne drÞmme om. Resultatet var ogsÄ at jeg hadde gjort en feil i mÄlingene... Detaljene i denne livshistorien finner du under og i kommentarene. Siden eksemplet er ganske vanlig og implementert slik som det vanligvis gjÞres i nÊringslivet, er det en interessant, som jeg mener, demonstrasjon av livet: innflytelse pÄ hastigheten til hovedtemaet i artikkelen var usynlig pÄ grunn av den eksterne logikken: Moq, Autofac, EF Core og annen 'innpakning'.

Jeg begynte arbeidet mitt under inntrykk av denne artikkelen: Hvorfor er refleksjon sakte

Som man kan se, foreslÄr forfatteren Ä bruke kompilte delegater i stedet for direkte tilgang til refleksjonsmetodene som en utmerket mÄte Ä Þke hastigheten pÄ applikasjonen betydelig. Det er ogsÄ IL-generering der, men jeg vil helst unngÄ det, da det er den mest tidkrevende mÄten Ä utfÞre oppgaven pÄ, og som kan fÞre til feil.

Med tanke pÄ at jeg alltid har hatt en lignende oppfatning om hastigheten til refleksjon, hadde jeg ikke tenkt Ä stille spÞrsmÄl ved forfatterens konklusjoner.

Jeg mĂžter ofte naiv bruk av refleksjon i nĂŠringslivet. Man tar en type. Man henter informasjon om en egenskap. Metoden SetValue blir kalt, og alle er glade. Verdien har ankommet det aktuelle feltet, alle er fornĂžyde. Folk er ganske kloke — seniorer og teamledere — skriver sine utvidelser til object, basert pĂ„ en sĂ„ naiv implementering av 'universelle' mapper fra Ă©n type til en annen. Vanligvis er poenget slik: vi tar alle feltene, vi tar alle egenskapene, og itererer over dem: ved samsvar av navnene pĂ„ medlemmene i typen, utfĂžrer vi SetValue. Av og til fanger vi unntak pĂ„ feil der vi ikke fant en eller annen egenskap i Ă©n av typene, men det er ogsĂ„ en lĂžsning her som forbedrer ytelsen. Try/catch.

Eg har sett folk gjenoppfinne parserar og mapparar utan Ä vere fullt utstyrte med informasjon om korleis dei tidlegare oppfunne syklane fungerer. Eg har sett folk skjule sine naive implementasjonar bak strategiar, bak grensesnitt, bak injeksjonar, som om det skulle unnskylde den pÄfÞlgjande vakhalda. Slike implementasjonar har eg snudd nesen frÄ. Faktisk har eg ikkje mÄlt reelle ytelsestap, og nÄr muligheten byrde seg, har eg berre bytta ut implementasjonen med ein meir «optimal» ein, dersom eg hadde tid. SÄ dei fÞrste mÄlingane som vert omtalt nedanfor, overraska meg alvorleg.

Eg trur mange av dykk, nÄr de leser Richter eller andre ideologar, har kome over det heilt rette utsagnet om at refleksjon i koden er eit fenomen som har ekstremt negative konsekvensar for ytelsen til applikasjonen.

Å kalle pĂ„ refleksjon tvingar CLR til Ă„ gĂ„ gjennom samlingar pĂ„ jakt etter den nĂždvendige, dra inn metadata, parse dei, o.s.v. I tillegg fĂžrer refleksjonen under parcouring av sekvensar til ein stor allokering av minne. Vi bruker minne, CLR avdekkjer GC, og sĂ„ rullar det pĂ„ med hakking. Dette mĂ„ vere merkbart sakte, tru meg. Store mengder minne pĂ„ moderne produksjonsserverar eller sky-maskinar reduserer ikkje hĂžge forsinkelser i prosesseringa. Faktisk, jo meir minne, jo stĂžrre er sjansen for at du MERKAR korleis GC fungerer. Refleksjon er, i teorien, ein unĂždvendig raud klut for det.

Likevel nyttar vi alle bĂ„de IoC-containerar og datamapparar, der prinsippet for drift ogsĂ„ er basert pĂ„ refleksjon, men det oppstĂ„r som regel ingen spĂžrsmĂ„l om ytelsen deira. Nei, ikkje fordi avhengigheitsinjeksjon og abstraksjon frĂ„ modeller i eksterne avgrensa kontekstar er sĂ„ nĂždvendige at vi mĂ„ ofre ytelsen uansett. Det er enklare enn som sĂ„ – det pĂ„verkar faktisk ikkje ytelsen i stor grad.

Saka er den at dei mest utbreidde rammeverka som er basert pĂ„ refleksjonsteknologi, nyttar ulike strategiar for Ă„ arbeide meir optimalt med det. Vanlegvis er dette caching. Vanlegvis – er det Expressions og kompilert frĂ„ uttrykkstre-delegatar. Den same automapperen har eit trĂ„d-sikkert ordbok som kartlegg typar til funksjonar som kan konvertere den eine til den andre utan Ă„ kalle pĂ„ refleksjon.

Hvordan oppnÄs dette? I bunn og grunn er det ikke annerledes enn logikken brukt av plattformen for Ä generere JIT-kode. Ved fÞrste kall til metoden kompilert den (og ja, denne prosessen er ikke rask), ved pÄfÞlgende kall blir kontrollen overfÞrt til den allerede kompilerte metoden, og her vil det ikke vÊre noen betydelige ytelsestap.

I vÄrt tilfelle kan vi ogsÄ benytte JIT-kompilering og deretter bruke det kompilerte oppfÞrselsmÞnsteret med samme ytelse som AOT-analogene. I denne sammenhengen vil uttrykk hjelpe oss.

Kort sagt kan prinsippet det her er snakk om formuleres som fĂžlger:
Det er nĂždvendig Ă„ cache det endelige resultatet av refleksjonen i form av en delegat som inneholder den kompilerte funksjonen. Alle nĂždvendige objekter med informasjon om typer bĂžr ogsĂ„ caches i felter utenfor objektene av din type – arbeideren.

Det er en logikk her. Sunn fornuft forteller oss at hvis noe kan kompileres og caches, sÄ bÞr vi gjÞre det.

For Ä vÊre klart, bÞr det nevnes at cache i arbeid med refleksjon har sine fordeler, selv uten Ä bruke den foreslÄtte metoden for kompilering av uttrykk. Egentlig vil jeg her gjenta tesene fra artikkelen jeg refererer til ovenfor.

NÄ om koden. La oss se pÄ et eksempel basert pÄ min nylige smerte som jeg mÄtte hÄndtere i et seriÞst produksjonsmiljÞ i en seriÞs kredittinstitusjon. Alle entiteter er fiktive, slik at ingen kan gjette.

Det finnes en viss entitet. La oss kalle den Kontakt. Det finnes e-poster med en standardisert kropp, fra hvilken parseren og hydratoren lager disse kontaktene. En e-post kommer inn, vi leser den, deler den opp i par med nĂžkkel-verdi, oppretter kontakt og lagrer i databasen.

Dette er elementĂŠrt. La oss si at kontakten har egenskapene Navn, Alder og kontakttelefon. Disse dataene sendes i e-posten. Videre Ăžnsker bedriften at supportteamene raskt skal kunne legge til nye nĂžkler for Ă„ kartlegge egenskaper ved entiteten til par i kroppen av e-posten. I tilfelle noen har skrevet feil i malen eller hvis det hastes med Ă„ lansere kartlegging fra en ny partner i forkant av lanseringen, slik at den kan tilpasses det nye formatet. Da kan vi legge til den nye kartleggingen som en rimelig datafix. Det vil si, et livsnĂŠrt eksempel.

Vi utfĂžrer, lager tester. Fungerer.

Jeg vil ikke gi koden: det ble mange kilder, og de er tilgjengelige pÄ GitHub via lenken pÄ slutten av artikkelen. Du kan laste dem ned, torturere dem til de ikke er gjenkjennelige og mÄle hvordan dette ville pÄvirket ditt tilfelle. Jeg vil bare gi koden til to malmetoder, som skiller hydratÞren som skulle vÊre rask fra hydratÞren som skulle vÊre treg.

Logikken er som fÞlger: malmetoden mottar par, dannet av den grunnleggende logikken til parseren. LINQ-nivÄet er parseren og den grunnleggende logikken til hydratÞren, som henter forespÞrselen til databasen og sammenligner nÞklene med parene fra parseren (for disse funksjonene er det kode uten LINQ for sammenligning). Deretter sendes parene til hovedmetoden for hydrering, og verdiene settes i de respektive egenskapene til enheten.

«Rask» (Prefiks Fast i benchmarkene):

 protected override Contact GetContact(PropertyToValueCorrelation[] correlations)
        {
            var contact = new Contact();
            foreach (var setterMapItem in _proprtySettersMap)
            {
                var correlation = correlations.FirstOrDefault(x => x.PropertyName == setterMapItem.Key);
                setterMapItem.Value(contact, correlation?.Value);
            }
            return contact;
        }

Som vi ser, brukes en statisk kolleksjon med property-settere – kompilerte lambdaer som kaller setter for enheten. De opprettes med fþlgende kode:

        static FastContactHydrator()
        {
            var type = typeof(Contact);
            foreach (var property in type.GetProperties())
            {
                _proprtySettersMap[property.Name] = GetSetterAction(property);
            }
        }

        private static Action GetSetterAction(PropertyInfo property)
        {
            var setterInfo = property.GetSetMethod();
            var paramValueOriginal = Expression.Parameter(property.PropertyType, "value");
            var paramEntity = Expression.Parameter(typeof(Contact), "entity");
            var setterExp = Expression.Call(paramEntity, setterInfo, paramValueOriginal).Reduce();
            
            var lambda = (Expression<Action>)Expression.Lambda(setterExp, paramEntity, paramValueOriginal);

            return lambda.Compile();
        }

Generelt er det forstÄelig. Vi gÄr gjennom egenskapene, oppretter delegater som kaller setterne, lagrer dem. SÄ kaller vi dem nÄr vi trenger det.

«Treg» (Prefiks Slow i benchmarkene):

        protected override Contact GetContact(PropertyToValueCorrelation[] correlations)
        {
            var contact = new Contact();
            foreach (var property in _properties)
            {
                var correlation = correlations.FirstOrDefault(x => x.PropertyName == property.Name);
                if (correlation?.Value == null)
                    continue;

                property.SetValue(contact, correlation.Value);
            }
            return contact;
        }

Her gÄr vi direkte gjennom egenskapene og kaller SetValue umiddelbart.

For clarity and as a benchmark, I implemented a naive method that directly writes the correlation values of their pairs into the entity fields. Prefix – Manual.

Now we take BenchmarkDotNet and investigate performance. And suddenly... (spoiler — this is not the correct result, details below)

Eit mislukka innlegg om akselerering av refleksjon

What do we see here? The methods triumphantly bearing the Fast prefix are, in almost all passes, slower than the methods with the Slow prefix. This is true for both allocation and execution speed. On the other hand, the beautiful and elegant implementation of mapping that uses designated LINQ methods wherever possible significantly hinders performance. The difference is significant. The trend does not change with different numbers of passes. The difference is only in scale. With LINQ, it is 4 — 200 times slower, and there is more garbage roughly in the same scales.

UPDATED

I couldn't believe my eyes, but more importantly, neither could our colleague — Dmitry Tikhonov 0x1000000. After double-checking my solution, he brilliantly discovered and pointed out an error that I overlooked due to a series of changes in the implementation from initial to final. After correcting the found bug in the Moq setup, all results fell into place. According to the retest results, the main trend remains unchanged — LINQ still strongly affects performance more than reflection. However, it is nice that working with Expression compilation pays off, and the results are evident in both allocation and execution time. The first run, when static fields are initialized, is predictably slower for the "fast" method, but then the situation changes.

Here are the retest results:

Eit mislukka innlegg om akselerering av refleksjon

Conclusion: When using reflection in enterprise, special tricks are rarely required — LINQ will consume performance more severely. Nevertheless, in high-load methods requiring optimization, reflection can be preserved in the form of initializers and delegate compilers that will then provide "fast" logic. This way, you can maintain both the flexibility of reflection and the speed of application.

The code with the benchmark is available here. Anyone can verify my words:
HabraReflectionTests

PS: Koden i testene bruker IoC, mens i benchmarkene brukes en eksplisitt konstruksjon. Grunnen til det er at jeg i den endelige implementeringen fjernet alle faktorer som kunne pÄvirke ytelsen og forstyrre resultatet.

PPS: Takk til brukeren Dmitry Tikhonov @0x1000000 for Ä avdekke feilen min i Moq-konfigurasjonen, som pÄvirket de fÞrste mÄlingene. Hvis noen av leserne har tilstrekkelig karma, vennligst gi han en tommel opp. Personen stoppet opp, leste nÞye, dobbeltsjekket og pÄpekte feilen. Jeg mener dette fortjener respekt og anerkjennelse.

PPPS: Takk til den detaljorienterte leseren som pÄpekte stilen og utformingen. Jeg stÄr for ensartethet og brukervennlighet. Diplomatikken i presentasjonen kan forbedres, men jeg har tatt kritikken til meg. Ber om oppmerksomhet.

Kilde: habr.com

KjĂžp pĂ„litelig hosting for nettsteder med DDoS-beskyttelse, VPS VDS-servere đŸ”„ KjĂžp pĂ„litelig hosting for nettsteder med DDoS-beskyttelse, VPS VDS-servere | ProHoster