You
Watch
Curric behöver
And then
Go get this
And there
And then
The
Hi everyone, my name is Manor and I'm speaking from Ghana and I took this going to be on
MPF, but then it's here, this bucket is filled up and the foundation has it's in my
handouts, we want to upgrade the MPF to match it so we can stop this in peer, we call it
action. As me as a peer, there's only a thing, so and in developments we came across something
very interesting about the performance, I initially wanted to leave that talk on the performance
in the cano, but I had to come and give it, I've come with a course on the game, just
when I discovered that there is a space and two, I started to give a very short talk on it
and so for me, I started my name is Manor and I recently sent a couple of songs, I joined
in the SPSD, I think a few months ago and I joined the coming work on an alternate Q&A
year for 23 years old Q&A in MPF and it's almost a complete project and it's still in my
review and yeah so the current amount on the email, join this build the org and my free
base language is at C, C++ and D, so the MPF is the primary package with our front end
with a good stem, support IPP-4 and IPP-6 and Lyaphyr protocol, CPE, asset of features, network
addition, listen tables, almost like modern packages without you how you can build
kind of content with MPF and you are good to go, the MPF has a super high efficiency
I cannot very high performance can know it, which is designed to actually very skill very well
so the design for both asset and MPF was actually developed by our mind to actually take
advantage of multiple core CPUs, so if you actually used it before you realize that it's very
efficient, it's very efficient and it's the first time I'm handled large with your clients
and but in this time I've been moved, the SPSD is good, but it's a very good boost
and it's very easy to understand and very interesting one, so the example of the MPF is heavily
and gives the design is heavily dependent on the MP library, the BSM library and that
it passes rules and components of the configuration into name value in place, under global
ambient structure and I'm sure most of us will be familiar with them is library them in the
structure and yes, so due to the context of the ambient structure, if we pass if you want
to pass the data to the cannot, it's not really at the same time because if you're living
copy, data, that's held by the MPF, it's held by MPF, you can even go and actually get the data
you're copying, using our space addresses, which would also need some attention because
there's just this addresses won't be valid in the cannot, so there's a need to serialize the
name value pass to a binary buffer and then some of the end is binary buffer when copying
in into the cannot, it's copied with elements, you cannot copy more than so you gave this data
serializes buffer, it's serialized, it's more than four megabytes, it feels, you cannot copy
and to the one in the line, it impacts the data buffer to the available data structure to be
possessed in the cannot, so above you of the design as I said, the original name value has a very good
structure, it makes the course very easy to read and understand and maintain, because the human
I am really very well, if references to identify as references to unknowns, I very so much includes
proximity, anything we don't know as humans, if the argument is so close to what it is, it's
actually understand, that when they are far from us, so if you pass your rules like pass rule,
you know the okay action to be taken, it's passing, trying to trace what it says, you actually
see the right foot of you, and it's supposed to be going to different files to actually go and
trace the differences of them, you actually see the right foot of you passing them and then
then the advantage is that the performance overhead costs in the design copy of the data,
because of the need to see what I say, you actually try to convert them to binary buffer before
these sent to the cannot, so what to be super destocked, and my actually came across a link,
I know Twitch, that was talking about the use of an MPF to watch a link, and to check
photo for an IP table, because of 32,000 entries of IPs and a field, so I alluded to this, and
when I alluded to it, I realized that it was due to the limits of the data buffer, so
obviously the 52 IP tables were compacted into the data buffer, that was more than forming
a byte, and so you get a nice error, and then when I was trying to do this test, I also
realized that when I was new, I realized that a large IP is also taken out with you by like
64 seconds to complete to complete, and that is very long, and that's the tendency, so
that's the reason why I tried to keep this talk, and I tried to create awareness for that,
so that course of the configuration through this for IP tables, if you run your
configuration, for just 52 IPs and 52 IPs and a simple default, you are getting your
it to be a error, your argument is too long, and definitely if you hear something, this is just
good to come to you, that maybe there's a confusion buffer, so I changed the bytes, that will be
copied, and I realized that was five megabytes, and so according to the design structure,
the design philosophy of MPF, you cannot copy buffer size of more than forming a brightness, they
cannot, but considering scalability is it, is it a very good approach considering if we
want MPF to subscribe in research environments now, if you're going through such a
parameter, people are feeding periods and clays of data, and so if we limit MPF, we allow
we need to have this power, we allow MPF to reach as far as it can, because this gravity, I think
we should find an dynamic way to actually load the data, not necessarily put
elements to it, because I understand they need to actually minimize the memory usage in the
cano, and it's always sensitive, but if we are ready to let MPF expand the research environment,
and I think you have to do something about it, so I think it's a very large real time, so
for a lot of our business, I think when it came, I'm so quick to blame the cano and everything like
I think the cano is the cano, so I did a profile on the cano, I tell you to choose the cano
and some Cisco's, and some entry and return groups, and I produce a distribution for the
ISOC tiers for ISOC tiers, and I realize that the entry when the ISOC is called, the data is being
the transition is being done to the cano, it's taking less than two seconds to complete,
despite the huge amount of data being copied, it was taking less than two seconds to complete, so
I even provided a slim graph for that scenario, that's no, we should pay attention to the ISOC space,
and so I tried to also choose the ISOC space, and choose the ISOC space, then some few functions,
I used the D-tracing, and it was able to cut us a few functions, so I decided to use the
traditional print that method to put some print-off statements at entry and return points,
function that, or into the function tree to, before I get to the ISOC system code, which sends
the data into the profile, and to my observation, I realized that when the data is being
packed or serialized into the profile, then to the serialized profile, it takes originally about 62 seconds,
and I realized that 62 seconds was very long, but it could be happening for that to happen,
because I had a start in 52,000 copies, it's very huge, but 62 seconds is intense, that's so long,
so I did my own testing, I realized that I needed a new tool, just then I peed, and I thought
it to print the buffer to see what was actually going on, and so I totally see the size of the buffer.
So for this, then I peed, I realized that we were getting 2,000 bytes of buffer,
which was the canon, and I printed what was in the canon, so it's garbage,
values, and I lost to, because the size of most of our entries are very huge and bigger than the
data content, so it makes sense for me, but I think, because I'm smiling, it's because if you look at
the buffer size, the canon is so garbage, it's so much, a little garbage, but it's, so I thought
to give a simple, to show a simple way that our data is being plugged into the buffer, and
there is a simple and repeat endless table for a single, the IP, a simple, the single IP,
and I decided to actually print it to show how it is being done, and if we are loading the, if we,
any time we are building the configuration, it starts with a very fast root MVP,
which is the version of the MPF, and the name, the version and the value of the version,
and then, so for a single IP, it also creates a new table, an MVP for the table, the IP,
and it's value. So, and then it's then creates the types for the table configuration,
the name, the ID, the type, and it's value, it's given, and these are decided to enable this
app string, and this app number, based on the type, and then the IP address has been added as
a bytes, bytes, I read it, so we realized that it's added onto the entry, and the
MPA, the entry, and then IP, and the pair. So this is the additional how the bytes are being stored
into a 16-bit, a 16 bytes, I read, but only four bytes are being used to tow by discarded,
and you think this is going to be a problem, but I think along the line, we copy when we are
copying it into the buffer, we are going to copy the size of it, there's a four, the size of the,
the MVP, the size of the IP, so there's 12 bits that are not actually copied. So, so now,
let's look at the package with two, so we are packaging the good time to the buffer,
what's up is that we first pack the root and the list header, which gives the whole idea of
that the cluster of ND lists, which gives us information about it, and then when we are done,
it gives us, we get the MVP header of it, so for others who have the whole ambulance,
who do contain five MB pages, is the ID, our name, our version, and then our table,
and then you'll continue the IP address of it, so for this five MB, there was actually a good one
is that they answer into a whole loop, where the type is actually checked for each MVP,
and then there's going to be a package of piece on that type, and then stored into the buffer.
So now we're going to look at the original simple packing, and then we see why our tables are keeping
so, so, so long, notice our tables were conditioned to keep so, so, so, so long to
actually serialize in the buffer. So, we have always the size of the ND lists, and we allocate
the database on the size into an unsigned buffer, and then we set an active pointer to the buffer,
where we actually do how many places we set our data into the buffer. So, imagine we have the
ambulance header, which is going to print the whole data, we have a 24 by 19 bytes, memory fields,
and five-parted bytes, and so far as we copy, we perform the immune coefficient of this data
to the staff not just of an active pointer, but to support the staff not just of the buffer.
And so, we perform the immune coefficient of this into the active pointer, and then we add
our trees, the pointer, in the steps of the size of the new buffer. So, it points to the new
available memory buffer. And then, so, when we add and we set a left scantahoot to show us
our data, let's not buffer, or we do not go. The less scantahoot decreases in steps of the bytes,
so that when it gets zero, we reach a certain level, and we are not able to
add any more bytes to the data buffer. So, after this, ambulance header has been copied into
it this way, we have now another new pointer point, this is the next available free space. So,
we are done, we increase our data, and then we decrease our left over. So, we actually,
after that, we pack the MVP header. So, page MVP, we pack a header. The header being
admitted data on information about the MVP, which gives me the number the MVP about to pack.
And so, if we enter any header also, it's 24 bytes 19 bytes of 19 bytes of
memory memory memory and five-parted bytes. So, we also pack the MVP header by
admin copy operation. We copy the mb header into the buffer, that's going to be
must be the canal. And then when we are done, we also perform an admin copy of the name,
if you know the MVP, the name, if you know the name, we also being copied into the buffer.
And then when we are done, we come and also copy the value, value part of the MVP into the
buffer. All true copy operation, and then after that, we increase our size of our pointer,
our page, we increase our size of our pointer, and then we decrease the size of our size of
our pointer. So, how this is going on so this, then you what we have, after our phasing copy,
so we copy this, after our first ambulance header, and then we added our MVP header for the
first MVP, which is a fashion in 22, and then we added that we add the version to that for the
header. We add the version, and then our first copy, our pointer will be here, and the
pointer is supposed to a new memory in the buffer region. So, when data is being added, it's been
pushing to the address of the start, the start is not the address of the points of the attitude
points are. And so when we are done, realize that we now pack the value of the MVP into
its true immunocopy operation, and then we add that we increase the pointer in size of the steps
of the size of the value in bytes, and then we decrease our left pointer, and then so we realize
that maybe the version was 22, so now we pack 22, and 22 is starting a new N64 type. So,
on page, byte, memory will just turn the value 22, 22 is actually just used by identifying
four bytes, you use 45 bits, 45 bits of a six-folded stream, and we actually copied the
code of this version, but I also possible that also can't see the performance. And when we are done,
I've copied the V, and so after we copied the value 22, that's what actually happens, just to copy
a single MVP. Copy the whoever this structure, and then copy an MVP structure for the MVP,
and then, after that you copy the value portion, the name fits, and the value all on that,
and then copy your machine, and then, and then, and then, and then, we move the pointer,
we actually go to the next MVP, and then, for the next example, like the name, and the blackness
MVP, we actually copied the name of V. So, we actually copied the header of this name,
blackness, and V. into the buffer, and then, and then, and then, we copied the name portion of
it into the buffer, and then, we are done, we copied the value portion of it into the buffer,
and all of this is followed by an increments in the pointer, in the calculator, so that we can
point to a new starting point, a new freshman year, which is on use, so we can use to allocate
to receive new items in the memory, so this was actually going on in the MVP, and to this is the
whole portion of their insertion into the buffer, after we click about this, and so, this is the whole
section of it, so, for just a single pack, we actually have about, I think, six, I mean, copies in the
seven to eight, I just change, and we have, like, increments and increments, and, um, and then, so,
for this one, like, this, the name, blackness, we copied the MVP, header, and then, we copied the name,
version of it, and they will copy the, the value version of the MVP, then, where we are done,
we increment the pointer to point to the new address, which is on use, buffer, in the buffer,
which is so, it comes to store new data, new parameters, so, we realized that for our memory, we
didn't become like this, and then, server operations, just for this, just for this, just for two
MVP's, so, imagine if you have, like, 52 key IPs, we are actually packing, or far, I did a
chase on it, and for 52 key, I visually are actually producing over 180,000 MVP's, and so, for each
MVP, we pack an MVP header, and then we also pack the MVP name, there you also pack the MVP
value, so, for each MVP header, we have three packets, and then, for each, and we have, for each
MVP header, we have three packets, and each pack performs quite not expensive copies, but numerous copies,
and so, this is consumed in a raw loop of the number of NDP's we have, so we have 180,000, we are going
to a 180,000 loop of NDP packet, and that is what's actually going on, when we are sending
serializing data to the kernel.