Here is a quick outline of this unit.
We'll start our discussion by processes.
What is the process?
What are various states of a process?
How these processes are represented in the operating system with the help of process control blocks?
What is the context switch and so forth?
Next, we'll talk about the scheduling basics here.
We'll see what is CP scheduling, what is what are Iowan processes, what are CPU bound processes?
We'll also talk about preempt you and non preempt you scheduling algorithms.
So essentially we'll work on defining these terms here.
After that, we'll dive into discussing some specific CPU scheduling algorithms.
So for example, first come, first serve shortage of first priority scheduling, round robin scheduling
and some more.
Next, we'll see how programs can create multiple child processes.
So, for example, in context of UNIX, we'll see how processes can use the fork system, call for creating
multiple child processes and how this is useful.
Finally, we'll briefly talk about process communication.
So essentially here we will see how how operating processes can communicate and collaborate with each
other.
So let's begin with the conception of a program, the program creation itself.
How a program is created.
If you think about it, every program is is trying to solve a problem.
It is written to help us solve some computation problem.
Awesome.
Some real world problem.
Every program is conceived as a problem specification.
So there is a problem that we are trying to solve, which is specified in this problem specification.
A human programmer looks at this problem specification and then comes up with an algorithm to solve
this problem.
The programmer then uses an editor and a programming language of his or her choice to implement this
algorithm into a program.
For now, we are assuming that the language of choice is C or C++.
Once the program is ready, once the coding is done, the algorithm has been quoted in, let's say,
C or C++, we'll use a compiler to translate the C C++ code into object files and some partial binaries.
Next, using a linker program, we'll link together these partial binaries or object files and any other
libraries that our program might be using.
So we'll link together all of these files to create a single executable binary file.
The executable binary file is typically a static file sitting on the hard disk.
When the user, let's say, double clicks on this file, a loader would load this executable binary
from the hard disk and bring it into the main memory.
For execution.