Load

In a Unix system, the system load refers to the amount of computational work performed by the computer. Usually, we use the term average load, which means the load on the system for a specific period. It is a convention to compute the average load in three forms: the load during the last minute, the last five minutes, or the last fifteen minutes.

Calculating the load in Unix System

The Unix system returns a dimensionless metric of three average load numbers in the kernel. The first, second and third represent the load average during the last minute, last five minutes, and last fifteen minutes, respectively. If the user wants to check the average load, the user can do so by executing the uptime command in the Unix shell.

The uptime command is as follows:

• The user can compute or access the average load in a Linux system by reading the /proc/loadavg file. The user can use the w and top commands to display the same three average load results. For an Idle computer, the load number is 0. Only the idle process is executed when the computer is idle, which is not included in the count of load number. Every process that is either waiting for the resources or currently using the resources is added to the system. Each process in the ready or run queue adds 1 to the load number. When the process is terminated, the load number is decremented by 1.
• Most UNIX systems include processes that are in running or runnable states. The runnable processes are the ones waiting for the CPU. These processes are usually waiting for disk activity. In Linux, the process that is in an uninterruptible sleep state is also included in the load number. This resulted in different results if several processes were blocked in I/O, that is if the I/O system was busy or stalled. For Instance, the load number will also add the processes that were blocked either because of an NFS server failure or the media device being too slow. In this situation, the result will be an increased load number which does not represent an increase in CPU use, but rather it provides the user an idea about how long the user will have to wait.
• The system will compute the average load as the exponentially damped or the weighted average of the load number. The system returns three average load values since the system starts. The system also returns the three values accordingly. The decay is exponential. The decay is exponential by e in everyone, five and fifteen minutes, respectively.
• Since the one-minute load average consists of 63 percent of the load from the total load in the last minute. And 37 percent of the load since the system was started, excluding the last minute. For computing the load for 5 and 10 minutes duration. The ratio is the same as 63 and 37. That is, for five minutes, it takes 63 percent from the last 5 minutes and 37 percent since the system started up, excluding the last 5 minutes and so in the case of 15 minutes.

Interpretation of load

• In the case of a single CPU system that is bounded by the CPU, the user may think that the average load is the value after computing the utilization of the system resources in a specific period. But in the case of multiple CPUs, the user can divide the load by the total processors to get a comparable value.
• For Instance, if you provide someone with the given values "1.73 0.60 7.98," then one might interpret that the average load for a single CPU system means that during the last minute, the system was 73 percent occupied on average. There were 1.73 runnable processes which mean that 0.73 processes were made to wait to be executed by the single CPU system on average. And for the last five minutes, the computer was idle for 40 percent of the time on average, and for the last 15 minutes, the computer was overburdened 698 percent on average.
• During the last 5 minutes, the CPU was average idling 40% of the time. This means that 6.98 processes had to wait for their turn on the CPU system on average.
• The user can also infer that the system could work on all the processes scheduled to be finished at the last minute without waiting if the system was 1.73 times as fast.
• But if the system has multiple processing units, like, there are four CPUs with an average load of 3.73, this would mean that there are 3.73 processes that are runnable, and each process will be scheduled to one of the processing units.

In the UNIX systems, the threading is treated differently depending on the average load. In some systems, threads are treated as processes. This makes it easier to compute the load average. This means that for every thread waiting for the resources to run, 1 will be incremented to the load number. But in the systems that implement M: N threading. It works on a different approach. It counts the process exactly one time for computing the load. It is not affected by the number of threads in the system. It will only count those threads currently in the user thread scheduler to the kernel. The load number may differ depending upon the level of concurrency set on the process. The thread is counted separately in the Linux system, and 1 is added every time to the load.

CPU load vs. CPU Utilization

Ferrari et al. performed a comparative study of several load indices. He draws several conclusions regarding CPU load based on the CPU queue length. He concluded that CPU queue length is better when compared to CPU utilization. It is better as the system is heavily loaded. The system will work closest to 100 percent capacity, making it difficult to compute the exact load level of the utilization.

In contrast, the CPU queue lengths can tell the user better about the amount of load on the CPU. For Instance, if there are two systems, one has 3 processes, and the other has 6 processes aligned in the queue. They will work close to 100 percent CPU utilization, but they are different.

Loader

In computer systems, a loader is the component of the operating system that is used for loading the programs and libraries in the system. The loader is responsible for placing the memory and making them ready to execute. It is the beginning stage in the process of beginning of the program.

Steps Performed by the Loader to load a Program

To load the program, the system is required to perform the following steps:

• The first step is memory mapping the contents of the executable file that stores the program instructions in the memory. Then it may require some preparatory tasks to perform the executable file for running the program. Once the loading is completed, the operating system begins by passing the controls to the loaded program code.
• All the operating system that requires the program requires loaders to perform the above tasks. Only some of the specialized computing system does not require loaders. They have a fixed set of specialized programs. In embedded systems, there are no loaders to load the program; instead, they execute the program's code directly from the ROM or something similar.

Loading the Operating System

• The operating system is a special program that provides a platform for another program to execute. The loading of the operating system is a part of booting. It also needs to load itself.
• To load the operating system, the machine should have a specialized bootloader. The loader is inside the program's memory in most operating systems.
• Though in some operating systems, the loader may be present in a region of memory that is pageable. But this is only possible for the operating systems that provide support for virtual memory.
• In the operating systems that provide support for virtual memory, the loader may not copy the components of the executable files into the actual memory of the system; instead, it will declare a virtual memory in the subsystem.
• The virtual memory is mapped with the part of the memory assigned to store the running code of the program. It also stores the components of the related executable file.
• The virtual memory is then notified about the pages with that the part of the memory that is required to be filled if demanded. The memory is also filled if the program is executed and hits the areas with unoccupied memory.
• This means that the part of the program's code is filled into the memory once the program is implemented and occupies that part of the memory. It is possible that the code that still needs to be implemented will never be implemented again.