you hello dot necks how you doing I they already presented me bad I'm going to talk you about how to achieve high performance C sharp just buttering C sharp enough to not been able to recognize it as C sharp anymore the really hard this talk is to actually show you the kind of performance improvements you can actually get when you need them but it's definitely not something that you're going to be able to use on general problem on general problems out there you have to have very specific use cases to be able to be successful
with this kind of techniques my name is faragonda's lewis i am also the founder of core values what we do is research and development and we have been working with our one of our most demanding clients which is a database engine so we have been working on optimization for four years already if you think about this this is more or less the amount of time you had to have been optimizing a single product to be able to use this kind of techniques because it is very easy it is very important to actually figure out where
your bottlenecks are to be able to understand how your software is behaving on almost every every metric so every everything that I'm going to talk to you about here you can actually look samples on this github repo where there's not only these examples but there are there are ups so let's start with some simple math what happens if tomorrow after coming to this great conference your boss said okay now now you know a lot of about performance so we want you to design a system that is able to process twenty billion operations per day I'm
gonna take a second so you can think in this number okay you're crazy right going to achieve this but the thing is when you start digging deeper you can think of this about 20 billions over 24 hours sustained we're not about big performance we're going to talk about sustaining performance so now the number it's more or less better right no really no so we can just try to narrow it down a little bit like say okay how much do I have to process per minute so the number kind of get something that you can actually
count yeah so you know you know where I'm going right so we're talking about roughly 2200 K operations per second what kind of an operation be whatever you like it to be so this is how we typically solve this kind of issue now not really this is a number we can all understand we can actually count this but typically what we do is like this so now we have something we can work with this so if you think about it this is like a big number but it's not so big because if you think about
it you can dedicate an entire machine an entire node five milliseconds one after another and you can get something like this five milliseconds per operation per second per node so if you think about it we make games with badges of 13 milliseconds so we are we have something to work with so the interesting thing here is when you are optimizing typically what you see in the wild and I mean most systems out there this is long tail distribution are able to process in sustained and 600 requests per second per note where's the trick you may
ask so you can have requests like this is more tech tech and power benchmark when you just return a single a single return every single time the same thing or you can have this thing that it's going to send messages all over the world all over the world and doing whatever and definitely it's not the same thing but the thing is from a database point of view if you are going to have 600 sustained requests per second per node I have to plan sorry I have to plan for 6,000 and the thing is that planning
for 6000 requires a different and different and totally different engineering effort that planning for 600 so on 600 you can actually be reactive about performance you actually don't do not need to have like oh we have these team of performance guys that are going to come here and say this is wrong do it again no oh what I do here so this 600d 600 guys can actually go on and go and measure and say okay fine these are the 600 do we need oh and you know what this method sucks and you can just go
to that method just figure out what is wrong fix it on voila 3x or whatever you need essentially we have seen even more but on 600 you actually need a you actually need a plan you actually plan for 600 truckers per second you actually need someone that is actively looking that it's looking that nothing that gets into the code it's gonna hurt those 600 sustained riggers per second but it doesn't end there eventually you hit that but the very same techniques that take you there are not going to take you there two orders of magnitude
difference it's going to be hard for that you have to cheat and you have to cheat a lot so essentially when I'm what I'm going to show you is how we teach how we cheat so you know I'm using the multiplicative so I can say this metric unit the 1010 next metric unit and 100 but the core this works on the lesser is better to just divide it so I'm going to tell you what this talk is not going to be about we are not going to talk about interrupts or the cost of interrupt or
that allocations are bad or that you don't have to use you know actually it's not that you don't have you cannot use try/catch you cannot use link if you allocate on this code path you are crazy and in the bad way so there are many many optimizations that you can perform but your code path has to be so lean that being able to handle that it's going to be a major engineering effort we are also not going to take going to talk about how we can take advantage of several technologies are that are currently available
on many compilers included the just-in-time compiler linker in course alert so we're not going to talk about the side effects that inlining has on your call sides we are not going to talk about the collateral effects that certain optimizations have we are going to talk about how after we know all this we can still cheat so to be able to understand what you are it's always better trying to be able to name that so this is essentially what we did in our work we just figure out based on empirical evidence so there's nothing published here
there's no field paper that you can go to it's just how it looks that it happens to us Europe and my mileage may vary so when we're talking about our to rule I everybody knows but it's a rule right so we are talking that roughly 20% of the code consumes 80% of the resources and that sounds about right but then we can square potato so we're going to square the left side and we're going to square the right side these are less than one numbers so instead of growing up they're going down so when we
are talking about but it's a square we are talking about roughly four percent of your code actually consumes a little bit of more than half your resources roughly one third sorry 2/3 but we can x squared we can we can multiply the deck in so we get pareto cubed we are talking about here of about 0.8% of the code in a 1 million code base that's roughly 5,000 lines of code so it's actually quite manageable so the interesting thing about this is we can now put many many of the stuff that we use we are
used to optimize in an ice bucket and this is what I like about being a programmer we always want to put things in buckets so on the higher are on the upper level bucket we are going to put the stuff like your architecture your network your algorithms and with algorithms I'm talking about order I'm talking about Big O on the next level it's typically what the typical techniques that work are those techniques are at aim at algorithm time how to avoid doing more than once what you can do once a Pareto cube the thing gets
nasty this is where you are actually cheating a lot so now that we know this the problem is this is where our bottlenecks lie so if you if you system is below a certain level of optimization you don't care about the to the other tune just thought missing this one because getting 60 X performance improvements just focusing on this one it's not something that it's far-fetched so I'm going to talk to you about a little bit of what our particular bottlenecks where two versions before so repeat EP is an entirely managed document database that at
the time of to 0 we also were we were we were using a SAN storage engine essent from Microsoft which is a very good database but the problem was that every time that I have to store something I had to go and do an interrupt and those we know are costly so these were our bottlenecks so we weren't doing enough batching batching is like the very first technique that you would use to help the upper ones we were doing a lot of hashing we are talking about cryptography hashing we do we did a lot of
JSON processes processing so we set up to optimize the to zero code base and we said okay we have this problem with interrupts we just build our own storage we build our own storage everything all right no wait we just introduced two different new bottlenecks down the line and we just say we are going to batch yeah again we are going to make JSON processing better okay it was not good enough so all these things the only thing that did was changed where a bottlenecks are even though this we actually got 10x improvement on critical
path which is a lot so from 3 0 to 4 0 actually we take the other route we say ok let's forget about this let's start over let's start from the very basic and let's design performance first I don't care what the client wants I want performance first so we started working with things like specialized local memory locators we built our own string guys that shouldn't that shouldn't be done we also design our own binary civilisations format that ensured that we are not copying information so we can just get this bunch of memory and just
do whatever we want with it we also implemented our own versions of algorithms especially tuned for the particular case of data that we were storing we focused on how to manage the IOR memory access patterns so we are we have to tell the colonel ok colonel step wait this particular page in memory I'm going to use it do not take it out or hey I'm going to use the next two so bring it on so making sure that everything everything works it's like being chained in small different things and and most of the time the
improvement is uncertain until you try it and you measure it when interesting thing about the performance improvements is they multiply so it's not the same thing to actually achieve 2x then to actually achieve 4x because if you actually achieve 2x achieving 4x it's actually doubling and again and probably the most important thing that we did in this code words with rewrite was actually removing all oh I'm not going to say all I still have a few nasty ones that I want to tackle but I can't beautiful calls so whenever you're bills well calls are killing
you is when you know you have to go back to this kind of playbook so from all the bottlenecks that we have in 3-0 I'm going to concentrate on these three and why because well they're manageable for an hour so we're going to make a simple assumption this is and actually this is not a post-mortem assumption this is this was actually an assumption when we started the project and it was we serve requests we start a request and then it ends simple as that it there's there's no magic here but the thing is when you
think about this assumption it has many interesting interesting things that are going to start cropping up like for instance if we measure allocations under this model you can find an for each request what dominated and I mean by far I say 90% of the Asians were like strings we are we are database we did with strings and on their next down there in line we're actually talking about collections objects that we create that are going to be reclaiming genes 0 so stop that is far and forget also way down there the a sink machinery so
when you have to do in a way it you're essentially allocating it's not much but it had ups pretty fast and also the lambda captured context so to getting rid of allocations and this was around the end of 2015 we actually decide ok the screwed we are dealing with memory when we have to go to the disk what's the other thing it's just going get rid of it and now we have our own and manage strings that we can straight right from the disk so we have to work around who is the owner of this
memory type of questions or I'm go first I'm going to allocate or what's the typical density over the size of our strings that we are going to allocate so we tune our and manage the strings to actually been able to have frequent high frequency allocation for small strings which is which was our typical case on most cases you are not being able to know this if you haven't have your product already pretty lean because your bottlenecks are going to prevent you from knowing this stuff the other thing and this is a Soria and one of
the important thing here is that this is a party to one decision this is something that it's going to ripple across your entire architecture this is not something that it's a light decision to make for this to happen we have to decide ok we are going to start over and there's not going to be any binary ability be two inversions that introduce a lot of issues so another pallet ohm but it's a thing that we found is that we are now able to pull by request because if request gets executed in the same thread memory
it's already gonna be hot so if I have been using this memory from the strings then I've reused that very same memory from the strings that processor already has that memory probably near in the cache lines a party to Chu decision was like okay in either cases where request is not enough we can't do it in request but there there's a better approach which is okay I don't want to deal with having to pass this context every every single line up to the bottom so we say okay for these kind of things we are going
to use general pools so if you get if you get an object that have been used on a different processor okay we're fine it's it's not a part and a microp Tamizh ation thing that we did on this is like we avoid the stack allocation we avoid sorry key publications like they play so when you are designing high performance software the very best thing that you can do for your garbage collection a collector is not needing him so I'm going to talk a little bit about our byte string because we're gonna use a string it's
already taken so our byte string has sort of this form we had some flags that's a byte the length of the actual string the unmanage pointer to the memory to the actual memory that holds this byte stream and also the size of T of the allocated segment in case I have to return it back for being reused not much different from C++ a string right it also sounds familiar to something that we do have on course Euler which is a span this was introduced early early 2016 but it really got mainstreamed right now but the
idea here is what you have a reference to a type what's a reference it's a pointer it's a very well design and very very very hidden pointer and the length but the thing is that we needed unmanaged memory we cannot do this so by trim it's essentially an expand like but regal C sharp construct so this thing has a problem this is 36 bytes that means that whenever I have to move a byte string passing it as parameter or returning it as a return as a function call I'm going to be copying 30 36 bytes
you know assembler how big a register is 8 bytes that's long how big they common biggest registers that we have we are the SM I team registers 32 bytes so we are in trouble passing these guys as parameters is going to be troublesome we cannot do it the things that we win for being able to handle this this stuff we are losing it passing these as parameters but this is not something that other communities have haven't solved before if you count from Z and C++ how could you fix this like we fix everything in computer
science are in another level of interaction so what we did pointer to a structure so now how big our by string is in memory a by it's nice but a question remains and it's how much does really really really cost passing this as a parameter so the better the better way to figure this out is to actually do the experiment this is what everybody in the performance feel do we experiment so let's say that we have this we are taking a byte string a and we are just returning it essentially nothing we are just telling
the just-in-time compiler that you are not allowed to you want this method to be cold to actually understand what's the cost and because we know it's eight bytes right then you implementation because it's a pointer so what can we compare it to a long which is a byte soon so I implemented a simplified version of our byte string but it essentially does nothing but it's good enough approxi for the actual thing and whatever you create one of these guys you're essentially going to assign the pointer and that's it so we're going to start here this
is this a very simple thing we're going to get along from a field and a static field and we are going to call our function and to avoid just-in-time compiler to just kill everything because there's no side effect we are going to call it to write to the console to force this just inside to for the just-in-time compiler not being able to optimize this code and we get something like this I didn't ask are you prepared to see assembly okay here we have first move we are getting stuff straight from memory into our our CX
register and we are calling a function now you may realize our CX is the first parameter so we are going to call that method and then we are going to copy from the air ax to the earth CX you get it right every X is where the functions are returned and then we are going to do a call which is our right line so good luck dip just and that didn't get rid of our code and now we're going to do exactly the same we're going to get our pointer we are going just to create
it we are going to call our method and we for the purpose of this we are just going to do a cast just to consult line to be friendly with us and when you look at the code essentially we are going to do a mob to the move operation to the RCX we are going to call the function we are going to go to the array X and we're going back to copy that to the air CX to call yet another function South sisters team right and this is because there's actually no difference at the
just-in-time compiler level between these two and Charlie semantically and Charlie different pieces of code so I think you know where this is going but wait for it because we're going to see something else that it's going to be paired with this to make our life our life not easy to recode by the way we are going to talk about a pretty nasty trick that the just-in-time compiler played with us and it's art and the street art like this let's say that we have this nice interface I marker which is empty and we make this too
particularly doing two implementations which is marker i and marker J an interesting thing here is that we are going to put the stripped in there instead of a class as we would always do so not much a difference right well not exactly let's say that we build this simple code this is pretty boy a play I just call a method it gets a parameter T if the marker is marker a we just return a if the if the parameter is not marker a it's going to return G simple everybody follow it up to here so
what's this go what the just-in-time compiler looks when it looks at our code what she looks she looks something like this she said okay this is method and this method is has a parameter which is marker I so yeah it's an AI marker the constraint is true so I'm going to continue I have no need to know about that constraint anymore and it's going to do this interesting to say the least comparison which is okay marker is equal to marker I yeah no question but the thing is that because marker AI is instruct and it's
not a class it's able to figure out that there's no way this thing can change so the actual code that gets emitted is this same exercise we do the same with marker G so now what we get marker G it's equal to market a mmm I don't think so so we essentially wrote two entirely different copass using a single a simple trick so the question is why should we use generic metaprogramming for those that come from C++ same reasons okay no questions asked for those that are not what it essentially allows us this interesting behaviour
we can actually get rid of virtual calls on high frequency calls so you have something that it's a butyl call and you want to get rid of it you can just plane a plane along with these kind of tricks to actually get rid of those spiritual calls you can actually tell your algorithms based on how you plan to use them think about an alligator oh this alligator is high-frequency oh this a locator it's not gonna return the memory and I'm fine with it we also can exploit other optimization behaviors of the just in time because
essentially now that just in time says oh all this is fixed so now I can do constant propagation and also the interesting thing is that we can avoid any embodiment conditional so someone are going and some are going to say but the CPU can't predict the branch right yeah but better than having to it than a branch predictor is not having to branch at all so I'm going to show you a use case for it so you can actually can get a sense of it let's talk about object pools so an object pool that typical
option pool is okay I have a pool a habbit type i have objects with them but actually our objects do live so we can actually create them and they are they can actually be reclaimed reclaimed and when you are dealing also with a managed memory you have to actually do it by yourself there's also other interesting things like for instance you can say okay I want to keep these objects especially tailored for this particular processor so if the last time I got this object from processor one I wanted to be kept at that at that
budget budget as soon as possible so I returned it oh this was from process one put it in their process to comes now get this one process one comes again oh-ho-ho get this one so a typical locator that we used today would look something like this we have an object pool with non-threat aware behavior or processor a web behavior and we just pass a function telling it okay this is how you create this object simple and the trick is here we are fixing our types so let's say we compare these two implementations one is the
usual approach the other one is using an explicit allocator and explicit a locator is no more than an instruct that also it's going to tell you oh you want a new objective the object pool just executes new how do you think this fight is going to be even or an even I kind of give it up come on guys this fight is an even using a factory is roughly 1.7 times slower than actually using the new we are talking about and think about this 87 inch return instructions against 57 sorry 84 up until against 57
which is actual assembler right but the question is should I care about this 27 instructions per operation so let's do the same exercise with something far more interesting we can go and implement the dictionary and instead of having the usual two parameters we add a third which is the actual compiler so now this is how our typical dictionary would look like if we model it based on these assumptions so as you see the Equality compiler it's an interface so how are numeric compiler good look this is pretty simple we have a struct which is an
eye a quality compiler long we get long values we check oh I guess x equals 2 I yeah okay but then notice the aggressive inlining here we are explicitly telling to the just-in-time this is small enough just try to aggressive put it in the color in the color side so for this what we did it will protect early check if this is true we actually implement a different dictionary so what we are going to do is the first case is our dictionary use exactly the same that the dictionary of dotnet works with the second case
is we are instead of baking the interface in there we are going to try to get our numerical quality compiler in there as soon as possible during the load of that particular that particular type and then just for completeness we are doing the exactly same thing on our dictionary the course yell our dictionary so when you check you get something like this but the number is like it really doesn't look like very well so we're going to go like this der difference in behaviors because of the algorithm that the first dictionary uses but still the
person that has the numeric Equality compiler is more than two times faster than the very same code using the interface so the question is okay these are micro benchmarks can we trust them can we trust them no so what do we do we test it in what real-life you can see here they compare actually didn't get in line because it was too big and still this is 3.25 X better on an actual workload so this looks interesting but how it works and that it's an interesting question because you may think oh I'll do this and
it will just work no just-in-time compiler optimizations are very tricky to get right let's see this example so we have these duties posed which takes something that the just-in-time compiler just-in-time can know at the time of implementing this but the problem is that unless T is an instructor she won't be able to know that this is a constant so the next time when we are going to actually check for that we will have to actually have the two code paths in code in assembler I have to deal with it so for this purpose I'm going
to say we are going to try to simplify this because I wanted to show you the techniques but you have to be very careful about these kind of deviations because they can they can create they can also be very impactful for your code because you don't you don't know how you are going to be cold this is this is up to the user not us the ones that provide this class so let's simplify this now we are going to say okay we have this clear which has this decibel actually either the addiction strategy we are
going to call it the addiction instead so in this case we know that we have been constructed by a thread aware behavior so what we are going to be asking here oh you asked me to just liberate all these objects for the garbage collector to be reclaimed but should I get rid also the ones are that are hot that are in my minimal set that it's hot for each processor so you can use like lots of different at different alternatives you can say okay if they are longer than one hour just get rid of them
or if they have been lived for 15 minutes or they have been idle there for 15 minutes just get rid of them we are not going to use it anywhere but for the purpose of this of this example I'm going to take a different approach I'm going to say okay I pick shown of T can actually you can actually ask it do i objection this thing and we are going to have two different addiction techniques one is get rid of it we don't care the other one is do not ever think about touching this so
as you can see actually the implementation is pretty simple we just return true or false no questions asked with them so let's say that this is the code of our clear what we are going to do we are going to go to this minimal bucket we are going to get the object if there's no object nothing to do here but if there is we are going to last the policy a what do we do here do we do what do we return this or not in the case of always this is what the just-in-time compiler
sees realize that there's no longer a parameter a type parameter in the clear we have a type parameter here we don't have it here this is an entirely different code path in this code path what we get is a fixed reference to always a bit a strategy of T so the interesting thing is that they come a big becomes true because it is a constant constant usually get in line even if we don't ask them to so as it is a true well there's no reason why I will ha I will just check and with
truth just get it rid of it in the case of never a big the strategy of T things is slightly different what we get there is a false what happens when these branches Falls never execute right so what you get is this and what happens when we go and get a reference that is never been used no reason to acquired here and what happened when a method is empty holy this code had a problem - want optimize this look at least not yet I reported it so it's gonna get get fixin I hope so let's
talk about a different application of the very same techniques let's say that we have a limited output the river directive so now we have to know limited and limited same technique we do the same thing about the eye table type directive right if we are using unsigned inter integrals of 32 bits or we are using unsigned integrals of 16 bits so that's how a code looks like and actually I have to cut it out because I had I haven't have enough of pace so I took out several several of the of the parameters so how
this works how the code looks like by the way this code you can actually access it it is there on the performance repo and it's also on our code so you can actually go and look it in this case what we are doing is if we are using one type of compression what we are going to do is we are going to execute the top path if we are going to use the other one we are going to use the one at the back if known apply because someone was funny enough to inject us a
different type sorry guys I'm throwing so you can a specialized code to your users but there is a more interesting example what is that it's creating Co codes for kids and this is interesting because now I can go and write an interface pretty simple one and write like two different implementations with zero cost one using streams that you know everybody knows here that they are slow right because they have the most of the their calls are beautiful so you have to minimize those and they were the one that is going to aggregate that stuff and
then it's going to just say okay now write all these bunch of memory on this will the interesting thing about this is that you can actually start baking these types upwards and because this is a struct it get generated immediately so you can use it like for instance in a new environment you can just you it it's there you don't need anything you need to use you need to use parameters you just execute the method you set up a method for construction so you can start it your your little writer type okay call the constructor
of these of these two writer and you're done the interesting thing about this is that you can start writing things like this this is the actual right number implementation after several passes of optimizations and interesting thing about this is because this is aggressively in mind it's going to go upwards and get back seen on every call side in this particular case we don't care if you're actually calling a beautiful call if you are actually doing a pitch roll call to your stream or you are actually aggregating this bite into a memory and an axe in
your memory and execute for the upper level they don't know about it they don't care for the code that executes this but the just-in-time compiler at some time will figure out oh these guys are calling me with the efficient guy okay so I have to execute this code instead of this one generally interesting uses of this that you can actually hide pointers and references under structs so the very same thing that we did in this case you can actually use it for indexing objects now I have my struct which is actually which actually has two
things one is a reference to the pool the other one is the index where this object is standing so you can actually do interactions and whatever you can think of using this approach this is basically what you do when when you implement an enumerator and their struct constraint in our case what we do is okay we are going to pass on a passive parameter and be done with it just using this so the question is is this really it's really all this work worth the trouble well it actually is this is like six months ago
or so the idea here is we were actually optimizing Mike optimizing our JSON parser and to be fair this was quite optimized at the time still for this workload Jason parsing was actually 500 seconds that's roughly eight minutes so after our first round of optimization using this kind of techniques we were able to get it to roughly two minutes and uh 3 minutes and something it's pretty good 5 minutes less but the thing is that one week later we were actually over a little over 2 minutes and we don't want in it we actually went
down 2 minutes so we're talking a difference of 8 minutes execution time serial execution time 22 minutes serial execution time I think if you want to run this on average berry pie which has a smaller CPU it's a net win it's a net wing on enormous appeal it's an absurd win on those small processors think about the power you're not going to spend if you're running this on a big cluster of say a thousand machines and eventually all HPC stuff ends up in being how much do I have to pay for it so what we're
talking about here is we got from this technique 6.6 X improvement on top of all the improvements that we also had that's a ton so putting it all together we are talking about genetic metal programming using a stroke wrappers of time this is essentially you can you can do like lots of crazy stuff here in fact whenever you find a technique that I didn't talked about please email me because this is interesting stuff so the idea here is there are some ideas on the c-sharp committee that they are looking for them more or less what
it what this looks like is like they're defining something that is called shapes and extensions but when you look under the cover on how they intend to implement it it looks like exactly the very same thing but back at the say sharp language itself so it's allowing this idiom is straight into the into the language which is now looks like an different language not c-sharp so also hiding pointer and references allows you to do like a lot of stuff so make sure that if you really really really need to apply these kind of techniques to
be very careful well about what you do because six months from now probably only a handful of developers are going to be able to deal with this code it happens to us probably two or three are actually know enough about how this works to actually being able to touch it so one final thought and and this is important because for everyone working in performance there's one thing that you should know is that bottlenecks do not disappear they just become harder and harder and harder to get rid off so I can tell you today what our
bundle next to pay and most of them involves the CPU not being able to have the memory in its cache to actually being able to work so essentially I can upload 64 gigabytes in under six minutes to a database with some using 17% of CPU so the problem is how do I have better IO buttons and how do i how i am sure that every time that the database need to have the memory ready to work with it has it so we have lots of work to do we know we have lots of work to
do so probably there will be future talks about this kind of tricks in the future so thank you for coming and I hope you have enjoyed the talk [Applause] oh sorry one more thing if you want to start you can just out here just remember the first link are my commits and those are not the commits you are looking for right you can okay we have time for one or two questions and another questions you can ask Derek in discussions own a process is that installation oh hello the question is simple really hmm and does
a compiler behavior changed when you switched from regular donate - donate call good question quick answer yes a lot [Applause] so what you need to do so whenever you run time what you need to do with with this kind of code that was my question actually so again and again and again and know that you don't have progressions in it and also there are other things you optimizations at getting at getting included every single time so all tricks may work but there's probably a better way to do it now so I'm guessing you probably have
some kind of I don't know performance test for the year for these kind of things yes yeah thanks thanks for a great talk I have a really simple question you've talked about struct inlining in your code and what can you say about the situation when you have few fused few generic parameters who every of which are is a strike and you have a you know exponential growth of memory taking by the by the code which resides in jeet cache so we had a simple situation on a when we used a ot and iOS and submarine
and we had some methods that accepted few generic parameters which was tracked and they generated amount of code was huge it was much higher than the normal code base have you measured that for your case and how has your app but if I got the question right if I not let's just tuck it in there in the discussion area I think it was Matt Warren that talked about it like a week ago you can actually deny of service that just-in-time compiler with a simple construct that is going to take its type and it's going to
generate when the just-in-time needs to generate that it's going to enter in a loop probably you can get like a bite of memory and you just kill it rustling and the just-in-time compiler both the question was actually about the amount of memory taken budget cache when the application runs so it has to generate the code for every every struct when use reference types we generate just one code right one and four struck we should generate for every time did the memory footprint for that increase oh you haven't measured not measurably yet okay thank you there
is a spicy bonus conscious free mixtures the new approach you've emerged is that that's by the way the just-in-time compiler is freaking awesome it just can get it just can do like these amazing things I haven't hit yet a case when you can actually not on purpose of course being the source of your issues it's typically on your source thank you [Applause]