Now, you should see my slides. Cool. Yeah, thank you. Thank you for your kind introduction.
Yeah. You were always told, I'm showing you about skatex, and I've stick a slider, so
you can teach us whatever. Anyway, let's get started. You probably all know that we have
multiple CPUs, and I always assume for example, in this system, I have 8 CPUs, but
I have multiple tasks. For example, I've fully like 8 IDs or something running, and so
what we now want is we want to scale release on the CPU. To make it easier, we say we have
only like 2 tasks, and we have only 1 CPUs, like in the older days. And what we want to do,
we want to run both applications of both tasks. These tasks might be purchased. They might be
referred to or what else. And so what we could do, we could just run task 1 all the time,
but this won't be fair. We will be starving task 2 and everyone will be great. So what we
usually do, we scale task 1 for a bit, we scale task 2 for a bit, then we are like a task 1,
and we scale with it, but then task 2 doesn't want to come, because it's probably
writing for a database connection, so we scale task 1 again, and so on. And that's essentially
called scheduling. The thing is scaling is really nice, and everything, but the only problem is,
it's in the older days, like before Linux 6.12, it was really hard to create your own,
because as someone told me, within the now we taught my life here, it was like 3, 4 people in the
whole world knew how to do it, it was a cane code. That was pretty much a problem, because we
started innovation with this. And so what's nowadays is that we can create our own using
the scalar extensions and EVPF. You probably all know about EVPF here, so I won't be
going into details, but I tell you now about schedule a bit. So what is schedule, it's essentially
the scalar extensions of the Linux code, which means these extensions made to EVPF like you,
for example, know the XCP subsystem, which you can write, package filters, or other subsystems
like the Linux security model, this is essentially the same bad for scheduling. The person that you
see here with his halo, his vision, he wrote, tell us later, getting this in, and I quote him
here with, or he thought was the most important stuff about analytics. He said, the benefits are
of one, the ease of experimentation. I can show you here on the slides of full working
scheduler that can run a whole presentation. It allows us to customize, because we can write
our own scheduler, we're not stuck with like EVDF, that's in this code, it's called, but
there are some instance where we might want to have a different scheduler, and it also allows us
the rapid deployment of schedulers. The main thing is, as someone told me, who did some
call involvement with like in the olden days when we wanted to write a scheduler, and deployed,
we had to restart like 1000 machines, and then wait, of course, before we had to recompile a comma,
everything, and that's horrible. So we get all the benefits of EVPF in the scheduler world,
and that's pretty cool, and it allows us to make rapid progress, as many of you have
probably seen because like the BVF scaler are beating scaler in the gaming world, for example,
and it's pretty nice. So I want to show you the simple schedule dance. It's essentially how
a basic scheduler works. More than more complex scalers have more things, but this is like the
most basic version. So on top of our task day come in, and then we have essentially two kinds
of cues. We have global cues that our scheduler uses to have state. These can be priority cues
are usually day addressed, simple cues, as you know them from computer science classes.
And then we have local cue scenes, local cues are fine to CPUs, so every CPU has a
local key on what we do when the task comes free. It's like going into the trouble too,
usually, and then every time a CPU is like, I need some work, or we tell the CPU,
you need some work, drop everything you do, it's called kicking. So we literally kick our CPUs,
which is kind of implored, but so what we do when the CPU asks us, I'll say,
give me a task, and we're like, we're using our totally cool new algorithms,
ask the global cue from the element, and then we'll find. And then when the CPU is like finished,
and it's like with the task, because task run in a specific time size, as I showed you in the
beginning, then the task goes back into a global cue. And essentially these distance,
how we cope with the choreography of this dance, this is what we do with scale extensions.
And the cool thing is, it's highly abstracted, so you don't have to implement the project. You
don't have to implement all the medically details of how the signals really can scaling,
which makes it usable. And even the best thing here is that whenever one task is stuck in
not executing these parts, it's gone for like 30 seconds, then Linux is like 30 seconds is almost
infinity and scaling. I just kick your scheduler, and it's really nice, and I can't tell you how
often this happened with this machine, and it's cool, because don't have to restart the system.
After 30 seconds, even if you do some creation mistake, it's back mobile, and it's cool for
life timers, I can't tell you. As we see in a minute. Anyway, so essentially how our basic
serial rigs is, we have here our NT work, that's essentially called whenever task is like,
I'm ready to be pushed on, then we have our main scale link to you, and then essentially we move
it to the local queue, and then we have an NQR, the NQR is also called when the task is like,
finished with its time slides. Be aware that there have been name changes, so the names
they show here are the 6, the 30 names. They were changed, because the openings were really
confusing, because there were two things that were called dispatch. I can tell you, that's not
great, and then we change it. That's cool, and my code in this, it's a really cool community,
it's something that's confusing, just follow them, and in the end, you see your name on the
local mail list. Anyway, so these are the main changes, I don't go over them, it's just when
you see existing examples, but the openings work, because as we know, EPPF is like stable and such,
so how to say now to our scale loss, a basic cell law works, a basic title scale law works
essentially by we get tasks in, and the same all that they get, and we take them out. It's pretty
simple, it has advantages, because we don't, we scale in, in like a deterministic fashion,
but there are also another print, as we probably see now, if anything goes correct. So here you see,
he's a simple schedule, before he's just some, some definition, some definitions that we need,
but they are not important, so what we, what we start with, we start with creating our scale
on Q, so in the end it method, we create our scale on Q and we can then use it as our global
Q, and what we don't do, we have to end Q, so totally that's when the task is like,
ready, and it's like, I want to be scheduled, please, and then what we do, we compute the
slices like the amount of time that the process can run at the time, and then we insert into a
local Q, here we just, and then we insert it into the global Q, so totally before, and then take
it out later. The cool thing is here the slices in, in micro seconds, and I, in nano seconds,
and I can show you later what happens when we make it a little bit larger, and you can see the
direct effect, what we usually want to do is, and what makes the scale of, somewhat usable
in the direct to seconds, that the longer the Q is the, the smaller our time slices become,
it just makes it so that when our system gets overloaded, we can still schedule stuff,
and then, um, to this point, it's pretty simple, which is so like, pet the fruit's task,
I don't care, and it's just more than this, so for example, it takes care,
you know, that maybe some process can't be run on all, some tasks can be run on all CPUs,
and it takes cage of this, and it's pretty cool, because cave threads are slightly different,
as you see in a minute, so that works. Let's see, it's a live demo, it's a live demo, wish me luck.
Um, thank you, um, the major task for presentation, remember in one's password,
I think that's like, that that's like the major task, so, no, I'm imploshing, it will get worse,
it's quite embarrassing, but a bit, so, um, essentially, um, it's, it's essentially,
I have to schedule our attention, it's cool, and what we can, to look at, what skin law we have,
we can just say, um, you see, to cut, get a fruit up, so we can, we can look up the name,
and we define the name here later, so it's just struck up, so we define the name here,
and that's pretty simple, so we can have a schedule, as you see, maybe the demos is slightly,
it could be a little bit more responsive, so if we add to your service, so our time source is
now 50 milliseconds, don't do this at home, kids, um, start, now it's the out, yeah, I have to
no, it should work, yeah, it's still the minimum skill, like it, now it's getting a little bit more
choppy, um, and you can use this, and G, with like two cores, there should be some sloppiness,
anyway, um, they is trust me, um, you see here, that's a pretty basic skill, and that's really cool,
that you have like 10 lines of C-code, and you have a stellar, now on to more interesting
servers, um, this is one scale that I really like when I was in operating system class,
because it's called a lottery scale, so then she, um, like a lottery, you pull, um, you pull,
you put all the tasks that you have in, in your queue, into a ball, in, in, like a lottery ball,
and then from randomly from it, and that's nice, because, um, it gives us non, non-determinism,
we can use this ball, for like a maybe in ranges of cryptography, I don't know, and for testing,
if you want to know about how we can use non-determinism, and testing,
there was a talk in the testing that room this morning, um, I can really recommend it,
because it was mine, or by the person's alley there, because that only came after the talk was finished,
um, trains are also under-deterministic. Anyway, um, how do you implement a lottery scale?
It's pretty simple, let's get in it, as you see here, it's the same,
the scattering queue is also the same, because we're also putting it in a cloud book here,
the only difference is here. Um, it might seem like a lot of code, but it isn't, so essentially,
what we do here, we, we loop, we can loop over the queue. We can, in, in, in this line, we can loop
over the queue, and essentially what we're doing, we're first taking us to run the number,
and then we like take a random number between like the, the start of between a zero,
and the end of the queue, and then it's just walked away, got there, and also you see a BTF CPU
mask has, we, we just sit more if we can't run it there and like skip it, because sometimes
it's that like all flights, they can only be run on certain CPUs, and then we just switch it,
and the important here in this example is I added a print, so I can show you that it really works,
so let's, let's look at it, start as H lottery, now, and if everything goes well,
you see here, um, well, it's still all of us. It tells us exactly, because it's just that
BTF in case, you probably all know, like, for logging, and you see here, where we're
selling the multicolored scaling cable, because the system is quite idle, when we move the
cruiser, we see something more, and that's pretty cool, because we've now written a
scale that locks us every scale length decision, we can insert BTF in case everywhere, we could
even like, um, recorded to output sound and anything, I've done weird stuff, um, if you have
other weird ideas, wait for it to all the end, um, so that's that's all, um, so of course, um,
faster than I expected, but anyway, so of course, um, you don't have to write C code,
um, you can also write Java code, because with a simple, with a simple, because with a simple,
implement schedule, you have a scheduler, and in Rust, it's also, uh, comparably easy, so
you don't have to write C code all the time, and what you also don't have to do, you don't have to,
like, manually, use BTF tool, like, I did, um, if you want to know more of these,
like, to correct code for this, and the cool thing with, well, for if the scale, like,
sentient that it opens to door for, for other people to work with skills, because before it
works like, the, the reclusive thing of, like, a few nodes, and now we can show this to people,
and be like, and I can show you, like, write your own scheduler, like, it's not hard,
and it's a cool thing with EVPF, because the choice of words at all, it is. But so,
pretty small group of people that really distinguish it at a conference, ask us about scale X,
when you see them, um, and that's pretty cool, and, and nothing they want to mention,
during the, during the work and this, um, I felt that verify issues can be quite nasty,
so it started a verify error project, so if you want to contribute, contribute your verify errors,
because in the end I think, um, what we want to do with EVPF is, make it also
educational to it, because before we start learning and scale in, in, like, operating system
classes, we told them like, oh, scale, scale, scale, it's really hard, it's like,
no, you can't implement your own, but now we can be like, here are 10 lines of sea code,
and you have your scheduler, and that's, and that's very cool and do experiments on it.
And, now I'm coming to the end, um, the thing that, that we launched just for customers,
you see the t-shirt, and you see this mark. The thing is, we, we made a scheduler context,
we, that's like, all the people behind scatex, you can win a mark, and the t-shirt,
if you submit your own scheduler, um, so you can either submit your best-scaling ideas that
gets you t-shirt, or you can submit the tiny implementation of a scheduler, whatever you want
to do with the scatex, we're open to any language, program it in batch, if you write the
library for this. But just submit it here, and, um, you have time till tomorrow at 10,
and then be able to give the prizes to the best, whatever best means, that's, there are
our interpretation, um, in, um, trail release talk, in the, uh, Linux, in the, I think it was the
code that room, you can find all the informations here in this repository, and I hope you submit something.
I was Johannes Bechtberger, you find my blog at mostly another study, but write random stuff,
counting most scaling, um, and you can find more about, uh, my team, uh, which is submission here,
and the QR code should lead you to the scheduler context. And I think that's all here. Thank you.
Thank you.
Do we have time for questions?
Yes.
Yes. So the question was, is, is, is, is, is it, it could be a real benefit for real-time
comments, these custom scalars? This custom scalars are a benefit for everything that has
dominated, where we know more than like the schedule developers, which are many applications,
for example, that the companies developing their own scalars to improve gaming, to improve the
server performance of websites that you use daily, because if they can like, inch out, get out,
like, half a percent of performance, that's really a lot if you have a couple of hundreds of
thousands of service. Um, yeah.
Good for a lot of questions. Oh, even one more, yes.
Thank you for the invitation. Thanks for that energy.
I have anybody's right, sure, like, free hands, uh, the existing schedule just to see how much
I covered the screen. So the, the question was, could we could implement existing scalars with this?
The thing is probably, but it doesn't make any sense for honest. Uh, yeah, to check the overheads,
yes, it could make sense, but the thing is in the end, the overhead is, uh, negligible,
because scheduling is never like the thing that costs you performance, that she is going
to say, and we want to make them as fast as possible, and typically we want to implement
new cool scheduling decisions. So most of the workers focus there, you find more and you find
more in this in like the schedule of contest. So please submit within have any submission.
So your chances are really high together. Nice, you should. And this is exactly how.