[Autogenerated] The interact functions.
That we've seen are definitely nice but they only provide solutions.
To very specific simple problems such as manipulating,
these integers with incrementing decrementing,
and So on in more complex cases such as the link list example,
we need something else.
These interact functions.
Are not good enough.
And So for this purpose, Windows provides a bunch of kernel objects,
that are known as dispatcher objects,
and these dispatcher objects maintain a state which is
called signaled or non signaled where the meaning of
signaled depends on the object type.
And we've seen.
In fact already the meaning of signal for several object types.
In previous courses.
Specifically, we looked at processes.
And the process is signaled when its terminated.
Same goes for a thread, the thread, is signaled when its terminated.
In fact,
we've used that in the Previous example by waiting
until all the threads became signaled,
which means we wait until all the threads terminated.
And no longer running any piece of code sometimes these dispatcher objects,
are referred to as weight, able object, these is the same thing.
So some kernel objects or some kernel object types, are weight, able in nature.
They have this meaning of signal, and non signal, but others don't.
And and waiting on them has really no meaning.
For example, a section object called memo wrapped,
file in in Windows user mode APIs SS, is not a dispatcher,
project There's no meaning on waiting on that kind of thing.
So what we can do is wait on certain object types.
And This would allow us to synchronize,
things Because one thread can wait while another continues executing.
Code and What we get from the Windows API is set of functions.
The most common ones you can see here on the slide,
wait for single object allows us to wait,
a Certain amount of time for a particular object,
to become signaled.
There's a generalized function weight for multiple objects,
which does the same thing for a bunch of objects
where we can wait for all of them.
To become signaled at the same time or wait until one of them,
whichever one becomes signaled there.
Are some other variants,
but these are the most important functions on the kernel side of
things kernel drivers on the kernel itself can use the K weight for
single object K weight for multiple objects.
To achieve the same thing.
In fact, these are the real functions underneath that actually,
do the weighting, app properly,
or at least initiate the weighting properly if needed.
The main difference between the user mode functions.
And the kernel functions you can see here,
is that user mode always works with handles.
Whereas the K E functions work with pointers,
pointers, to the actual kernel objects because they are in kernel space,
and accessible here.
Are Some examples of dispatch or object types process,
and thread we've talked about already.
And in the This course we'll discuss events which we
actually used in the Previous course as well.
We'll discuss be access and sema, four but there are some others,
some of which I'll describe in the Next clip.