os211

Top 10 List of Week 06

  1. I/O scheduling in Operating Systems
    Scheduling is used for efficient usage of computer resources avoiding deadlock and serving all processes waiting in the queue. I/O Schedulerfunctions similar toProcess scheduler, it allocates the devices, control units, and communication channels. However, under heavy load of I/O requests, Scheduler must decide what request should be served first and for that we multiple queues to be managed by OS.

  2. Context Switching
    Context Switching involves storing the context or state of a process so that it can be reloaded when required and execution can be resumed from the same point as earlier. This is a feature of a multitasking operating system and allows a single CPU to be shared by multiple processes.

  3. Remote Procedure Call (RPC)
    Remote Procedure Call (RPC) is a protocol that one program can use to request a service from a program located in another computer on a network without having to understand the network’s details. RPC is used to call other processes on the remote systems like a local system. A procedure call is also sometimes known as a function call or a subroutine call.

  4. Long-Term and Short-Term Scheduler
    • Long-Term Scheduler is also known as Job Scheduler. Long-term scheduler regulates the programs which are selected to system for processing. In this the programs are setup in the queue and as per the requirement the best one job is selected and it takes the processes from job pool. It regulates the Degree of Multi-programming (DOM).
    • Short-Term Scheduler is also known as CPU Scheduler. Short-Term Scheduler ensures which program is suitable or important for processing. It regulates the less DOM (Degree of Multi-programming).
  5. Three Major Triggers for Context Switching
    • Multitasking: In a multitasking environment, a process is switched out of the CPU so another process can be run. The state of the old process is saved and the state of the new process is loaded. On a pre-emptive system, processes may be switched out by the scheduler.
    • Interrupt Handling: The hardware switches a part of the context when an interrupt occurs. This happens automatically. Only some of the context is changed to minimize the time required to handle the interrupt.
    • User and Kernel Mode Switching: A context switch may take place when a transition between the user mode and kernel mode is required in the operating system.

  6. What is Multicore Programming?
    Multicore programming helps to create concurrent systems for deployment on multicore processor and multiprocessor systems. A multicore processor system is basically a single processor with multiple execution cores in one chip. It has multiple processors on the motherboard or chip.

  7. Concurrency and Parallelism Combinations
    Concurrency refers to how a single CPU can make progress on multiple tasks seemingly at the same time (AKA concurrently). Parallelism on the other hand, is related to how an application can parallelize the execution of a single task - typically by splitting the task up into subtasks which can be completed in parallel. These two execution styles can be combined within the same application

  8. Multi-Threading
    Multithreading allows the execution of multiple parts of a program at the same time. These parts are known as threads and are lightweight processes available within the process. Therefore, multithreading leads to maximum utilization of the CPU by multitasking.The main models for multithreading are one to one model, many to one model and many to many model.

  9. Many to One Model Multi-Threading
    Implementations of the many-to-one model (many user threads to one kernel thread) allow the application to create any number of threads that can execute concurrently. In a many-to-one (user-level threads) implementation, all threads activity is restricted to user space. Additionally, only one thread at a time can access the kernel, so only one schedulable entity is known to the operating system. As a result, this multithreading model provides limited concurrency and does not exploit multiprocessors. The initial implementation of Java threads on the Solaris system was many-to-one.

  10. One-to-One Model Multi-Threading
    The one-to-one model (one user thread to one kernel thread) is among the earliest implementations of true multithreading. In this implementation, each user-level thread created by the application is known to the kernel, and all threads can access the kernel at the same time. The main problem with this model is that it places a restriction on you to be careful and frugal with threads, as each additional thread adds more “weight” to the process. Consequently, many implementations of this model, such as Windows NT and the OS/2 threads package, limit the number of threads supported on the system.