Question

Operating Systems Concepts

1. Why are special purpose machine instructions inefficient?

2. What are the two most common techniques, supported by the operating system, that are more efficient solution than special purpose machine instructions?

3. What are the two general uses of semaphores?

Answer 1

Answer:-

Why are special purpose machine instructions inefficient?

Giving too many instructions at one time.
Failing to make sure that instructions are understood.
Putting too many “don’ts” in instructions instead of stating things more positively.
Giving an insufficient number of instructions

What are the two most common techniques, supported by the operating system, that are more efficient solution than special purpose

1: Processes and Process Management

A process is basically a program in execution. The execution of a process must progress in a sequential fashion. To put it in simple terms, we write our computer programs in a text file, and when we execute this program, it becomes a process which performs all the tasks mentioned in the program.

When a program is loaded into the memory and it becomes a process, it can be divided into four sections ─ stack, heap, text, and data. The following image shows a simplified layout of a process inside main memory

• Stack: The process Stack contains the temporary data, such as method/function parameters, return address, and local variables.
• Heap: This is dynamically allocated memory to a process during its run time.
• Text: This includes the current activity represented by the value of Program Counter and the contents of the processor’s registers.
• Data: This section contains the global and static variables.

When a process executes, it passes through different states. These stages may differ in different operating systems, and the names of these states are also not standardized. In general, a process can have one of the following five states at a time:

• Start: The initial state when a process is first started/created.
• Ready: The process is waiting to be assigned to a processor. Ready processes are waiting to have the processor allocated to them by the operating system so that they can run. A process may come into this state after the Start state, or while running it by but getting interrupted by the scheduler to assign CPU to some other process.
• Running: Once the process has been assigned to a processor by the OS scheduler, the process state is set to running and the processor executes its instructions.
• Waiting: the process moves into the waiting state if it needs to wait for a resource, such as waiting for user input, or waiting for a file to become available.
• Terminated or Exit: Once the process finishes its execution, or it is terminated by the operating system, it is moved to the terminated state where it waits to be removed from main memory.

A Process Control Block is a data structure maintained by the Operating System for every process. The PCB is identified by an integer process ID (PID). A PCB keeps all the information needed to keep track of a process as listed below:

• Process State: The current state of the process — whether it is ready, running, waiting, or whatever.
• Process Privileges: This is required to allow/disallow access to system resources.
• Process ID: Unique identification for each of the processes in the operating system.
• Pointer: A pointer to the parent process.
• Program Counter: Program Counter is a pointer to the address of the next instruction to be executed for this process.
• CPU Registers: Various CPU registers where processes need to be stored for execution for running state.
• CPU Scheduling Information: Process priority and other scheduling information which is required to schedule the process.
• Memory Management Information: This includes the information of page table, memory limits, and segment table, depending on the memory used by the operating system.
• Accounting Information: This includes the amount of CPU used for process execution, time limits, execution ID, and so on.
• IO Status Information: This includes a list of I/O devices allocated to the process.

2: Threads and Concurrency

A thread is a flow of execution through the process code. It has its own program counter that keeps track of which instruction to execute next. It also has system registers which hold its current working variables, and a stack which contains the execution history.

A thread shares with its peer threads various information like code segment, data segment, and open files. When one thread alters a code segment memory item, all other threads see that.

A thread is also called a lightweight process. Threads provide a way to improve application performance through parallelism. Threads represent a software approach to improving the performance of operating systems by reducing the overhead. A thread is equivalent to a classical process.

Each thread belongs to exactly one process, and no thread can exist outside a process. Each thread represents a separate flow of control. Threads have been successfully used in implementing network servers and web servers. They also provide a suitable foundation for parallel execution of applications on shared memory multiprocessors.

Advantages of threads:

• They minimize the context switching time.
• Using them provides concurrency within a process.
• They provide efficient communication.
• It is more economical to create and context switch threads.
• Threads allow utilization of multiprocessor architectures to a greater scale and efficiency.

Threads are implemented in the following two ways:

• User Level Threads: User-managed threads.
• Kernel Level Threads: Operating System-managed threads acting on a kernel, an operating system core

What are the two general uses of semaphores?

• To control access to a shared device between tasks. A printer is a good example. ...
• Task synchronization. By tasks taking and giving the same semaphore, you can force them to perform operations in a desired order.