CPU Scheduling

It consists of CPU scheduling algorithms, examples, scheduling problems, realtime scheduling algorithms and issues. Multiprocessing and multicore scheduling.

Multilevel queue scheduling divides processes into separate queues based on attributes like priority or process type. The ready queue is divided into a system process queue, interactive process queue, and background process queue, which are run in order of decreasing priority. Each queue can use a different scheduling algorithm like first come first serve, shortest job first, or round robin. This scheduling method allows for different treatment of process types but risks starvation of lower priority queues if higher priority processes continue arriving.

The document discusses different memory management strategies: - Swapping allows processes to be swapped temporarily out of memory to disk, then back into memory for continued execution. This improves memory utilization but incurs long swap times. - Contiguous memory allocation allocates processes into contiguous regions of physical memory using techniques like memory mapping and dynamic storage allocation with first-fit or best-fit. This can cause external and internal fragmentation over time. - Paging permits the physical memory used by a process to be noncontiguous by dividing memory into pages and mapping virtual addresses to physical frames, allowing more efficient use of memory but requiring page tables for translation.

This document discusses semaphores, which are integer variables that coordinate access to shared resources. It describes counting semaphores, which allow multiple processes to access a critical section simultaneously up to a set limit, and binary semaphores, which only permit one process at a time. Key differences are that counting semaphores can have any integer value while binary semaphores are limited to 0 or 1, and counting semaphores allow multiple slots while binary semaphores provide strict mutual exclusion. Limitations of semaphores include potential priority inversion issues and deadlocks if not used properly.

The document summarizes key concepts in process synchronization and concurrency control, including: 1) Process synchronization techniques like semaphores, monitors, and atomic transactions that ensure orderly access to shared resources. Semaphores use wait() and signal() operations while monitors provide mutual exclusion through condition variables. 2) Concurrency control algorithms like locking and two-phase locking that ensure serializability of concurrent transactions accessing a database. Locking associates locks with data items to control concurrent access. 3) Challenges in concurrency control like deadlocks, priority inversion, and starvation that synchronization mechanisms aim to prevent. Log-based recovery with write-ahead logging and checkpoints is used to ensure atomicity of transactions in

To decide which process to execute first and which process to execute last to achieve maximum CPU utilisation, there are some defined algorithms.

Process Scheduling : Scheduling criteria, preemptive & non-preemptive scheduling, scheduling algorithms

Inter-process communication (IPC) allows processes to communicate and synchronize. Common IPC methods include pipes, message queues, shared memory, semaphores, and mutexes. Pipes provide unidirectional communication while message queues allow full-duplex communication through message passing. Shared memory enables processes to access the same memory region. Direct IPC requires processes to explicitly name communication partners while indirect IPC uses shared mailboxes.

The document discusses various scheduling algorithms used in operating systems including: - First Come First Serve (FCFS) scheduling which services processes in the order of arrival but can lead to long waiting times. - Shortest Job First (SJF) scheduling which prioritizes the shortest processes first to minimize waiting times. It can be preemptive or non-preemptive. - Priority scheduling assigns priorities to processes and services the highest priority process first, which can potentially cause starvation of low priority processes. - Round Robin scheduling allows equal CPU access to all processes by allowing each a small time quantum or slice before preempting to the next process.

The document provides an overview of operating systems, including what constitutes an OS (kernel, system programs, application programs), storage device hierarchy, system calls, process creation and states, process scheduling, inter-process communication methods like shared memory and pipes, synchronization techniques like mutexes and semaphores, readers-writers problem, and potential for deadlocks. Key concepts covered include kernel mode vs user mode, process control blocks, context switching, preemption, and requirements for deadlock situations.

The document discusses the actions taken by the kernel during a context switch between processes. It explains that a context switch involves suspending the currently running process, storing its context in the Process Control Block (PCB), and loading and resuming the context of another process from its PCB. The PCB contains information about the process state, registers, memory management, and more. Context switching has significant overhead as it involves saving and loading all this process context data.

This document provides an overview of CPU scheduling concepts including multiprogramming, multitasking, process creation, the short-term scheduler, process control blocks, the long-term scheduler, and the medium-term scheduler. It also discusses classifications of processes as interactive, batch, or real-time processes and as I/O-bound or CPU-bound processes. Finally, it introduces common CPU scheduling algorithms like first-come first-served (FCFS), shortest job first (SJF), and round-robin (RR).

CS8461 - Operating System Laboratory Manual prepared for the Engineering graduates admitted under 2017 Regulations, Anna University affiliated institutions of TamilNadu,India

The document discusses Windows XP's scheduling algorithm. It uses a priority-based, preemptive approach with 32 priority levels divided into variable and real-time classes. The scheduler ensures the highest priority thread runs by maintaining queues for each priority level and traversing from highest to lowest. Threads start at the process' base priority and may have their priority lowered after time quantums expire to limit CPU consumption of compute-intensive threads.

This presentation discusses system calls and provides an overview of their key aspects: System calls provide an interface between processes and the operating system. They allow programs to request services from the OS like reading/writing files. There are different methods of passing parameters to the OS, such as via registers, parameter blocks, or pushing to the stack. System calls fall into categories including process control, file management, device management, information maintenance, and communication. An example is given of how system calls would be used in a program to copy data between two files.

The document discusses different CPU scheduling algorithms used in operating systems. It describes non-preemptive and preemptive scheduling and explains the key differences. It then covers four common scheduling algorithms - first come first served (FCFS), round robin, priority scheduling, and shortest job first (SJF) - and compares their advantages and disadvantages.

The document discusses memory management techniques used in operating systems. It describes logical vs physical addresses and how relocation registers map logical addresses to physical addresses. It covers contiguous and non-contiguous storage allocation, including paging and segmentation. Paging divides memory into fixed-size frames and pages, using a page table and translation lookaside buffer (TLB) for address translation. Segmentation divides memory into variable-sized segments based on a program's logical structure. Virtual memory and demand paging are also covered, along with page replacement algorithms like FIFO, LRU and optimal replacement.

The document discusses different scheduling algorithms used by operating systems. It begins by explaining that the scheduler decides which process to activate from the ready queue when multiple processes are runnable. There are long-term, medium-term, and short-term schedulers that control admission of jobs, memory allocation, and CPU sharing respectively. The goal of scheduling is to optimize system performance and resource utilization while providing responsive service. Common algorithms include first-come first-served (FCFS), shortest job first (SJF), priority scheduling, and round-robin. FCFS schedules processes in the order of arrival while SJF selects the shortest job first. Priority scheduling preempts lower priority jobs.

CPU SCHEDULING

The document discusses operating system scheduling. It defines key scheduling criteria like CPU utilization, throughput, turnaround time, waiting time, and response time. It also outlines common scheduling algorithms like first-come first-served (FCFS), shortest-job-next (SJN), priority scheduling, shortest remaining time, and round robin. For each algorithm, it provides examples of how they work and how to calculate metrics like waiting time and turnaround time. It also distinguishes between time-sharing systems, which context switch between processes frequently for fast response, and parallel processing systems, which divide programs across multiple processors.

1. Process management is an integral part of operating systems for allocating resources, enabling information sharing, and protecting processes. The OS maintains data structures describing each process's state and resource ownership. 2. Processes go through discrete states and events can cause state changes. Scheduling selects processes to run from ready, device, and job queues using algorithms like round robin, shortest job first, and priority scheduling. 3. CPU scheduling aims to maximize utilization and throughput while minimizing waiting times using criteria like response time, turnaround time, and fairness between processes.

The document discusses process scheduling in operating systems. It covers basic concepts like scheduling criteria, algorithms like FCFS, SJF, priority and round robin scheduling. It explains key process states and scheduling techniques like preemptive and non-preemptive. Examples are provided to illustrate different scheduling algorithms and how they optimize criteria like waiting time, response time and CPU utilization.

* Using SJF preemptive scheduling: P2 will execute from time 0 to 5 ms. P3 will execute from time 5 to 8 ms. P1 will execute from time 8 to 18 ms. P4 will execute from time 18 to 38 ms. P5 will execute from time 38 to 40 ms. Total waiting time = (10-5) + (8-5) + (18-0) + (38-5) + (40-10) = 5.6 + 3 + 18 + 33 + 30 = 90 Average waiting time = Total waiting time / Number of processes = 90/5 = 5.6 ms * Using Priority preemptive scheduling

The document discusses different CPU scheduling algorithms: 1. First Come First Served scheduling allocates CPU to the longest waiting process first, which can result in longer processes waiting behind shorter ones (convoy effect). 2. Shortest Job First scheduling allocates CPU to the process with the shortest estimated run time, minimizing average wait time. Preemptive SJF allows interrupting the current process if a shorter one arrives. 3. Priority scheduling assigns priority levels and allocates CPU to the highest priority ready process. Preemption and aging policies address starvation of lower priority processes. 4. Round Robin scheduling allocates a time quantum (e.g. 10-100ms) to each ready process

The document discusses various CPU scheduling algorithms used in operating systems. It describes the main objective of CPU scheduling as maximizing CPU utilization by allowing multiple processes to share the CPU. It then explains different scheduling criteria like throughput, turnaround time, waiting time and response time. Finally, it summarizes common scheduling algorithms like first come first served, shortest job first, priority scheduling and round robin scheduling.

The document describes CPU scheduling concepts in a multiprogramming operating system. It discusses how CPU scheduling depends on CPU bursts and I/O waits as processes alternate between the two states. The scheduler selects processes from the ready queue to run on the CPU. Scheduling can be preemptive, occurring when a process changes states, or non-preemptive. Common scheduling algorithms like first-come, first-served, shortest job first, priority, and round robin are described. Optimization criteria for scheduling like CPU utilization, throughput, turnaround time and waiting time are also covered.

The document discusses various scheduling algorithms: First Come First Served (FCFS), Shortest Job First (SJF), priority scheduling, and round robin (RR). FCFS schedules processes in the order that they arrive. SJF selects the process with the shortest estimated runtime. Priority scheduling prioritizes processes based on assigned priorities. Round robin gives each process a time slice or quantum to use the CPU before switching to another process. Examples are provided to illustrate how each algorithm works.

CPU Scheduling is a function on which our operating system word This presentation contain all of the types of scheduling

CPU scheduling is the process by which the CPU selects which process to execute next from among processes in memory that are ready to execute. The CPU scheduler selects processes from the ready queue to execute. The goal of CPU scheduling is to maximize CPU utilization and throughput while minimizing waiting time and response time. Common CPU scheduling algorithms include first come first serve (FCF) which services processes in the order they arrive, and shortest job first (SJF) which selects the process with the shortest estimated run time to execute next.

The document discusses operating system concepts including CPU scheduling, process states, and scheduling algorithms. It covers historical perspectives on CPU scheduling and bursts, preemptive vs. nonpreemptive scheduling, and scheduling criteria. Common scheduling algorithms like first-come, first-served (FCFS), shortest-job-first (SJF), priority, and round robin are described. The roles of long-term and short-term schedulers are defined.