This document provides an overview of CPU scheduling concepts and algorithms. It discusses the objectives of CPU scheduling, basic concepts like process bursts and context switching. It then covers various scheduling algorithms like FCFS, SJF, priority scheduling and round robin. It also discusses criteria for evaluating scheduling algorithms and threading concepts. Finally, it summarizes multiple processor scheduling and operating system examples of scheduling.
This document discusses CPU scheduling in operating systems. It begins by introducing CPU scheduling and describing the goals of scheduling algorithms. It then explains common scheduling algorithms like first-come first-served (FCFS), shortest job first (SJF), priority scheduling, and round robin (RR). The document also covers multilevel queue scheduling, thread scheduling, multiple processor scheduling, and real-time CPU scheduling.
The document discusses CPU scheduling in operating systems. It covers basic concepts like CPU bursts and scheduling criteria. It then describes common scheduling algorithms like FCFS, SJF, priority scheduling, and round robin. It also discusses thread scheduling, multiprocessor scheduling, and examples of scheduling in Solaris, Windows, and Linux.
This document summarizes key concepts in CPU scheduling, including:
1) CPU scheduling algorithms like FCFS, SJF, priority, and round robin and how they optimize different criteria.
2) The role of dispatchers in context switching between processes.
3) Scheduling criteria like CPU utilization, throughput, turnaround time.
4) Advanced scheduling techniques like multilevel queues, multilevel feedback queues, and multiprocessor scheduling.
CPU scheduling involves selecting which process to execute next from among processes in memory. There are several criteria for evaluating CPU scheduling algorithms, including CPU utilization, throughput, turnaround time, waiting time, and response time. Common algorithms include first-come, first-served (FCFS), shortest-job-first (SJF), priority scheduling, and round robin (RR). Multilevel queue and feedback queue scheduling involve partitioning processes into multiple queues that use different scheduling policies.
This document discusses various CPU scheduling algorithms and concepts. It covers scheduling criteria like CPU utilization and turnaround time. Algorithms discussed include first-come first-served (FCFS), shortest job first (SJF), priority scheduling, and round robin (RR). It also covers multiple processor scheduling, real-time scheduling, and evaluating scheduling algorithms.
This document discusses various CPU scheduling algorithms and concepts. It covers scheduling criteria like CPU utilization and turnaround time. Algorithms discussed include first-come first-served (FCFS), shortest job first (SJF), priority scheduling, and round robin (RR). It also covers multiple processor scheduling, real-time scheduling, and evaluating scheduling algorithms.
The document discusses various CPU scheduling concepts and algorithms. It covers basic concepts like CPU-I/O burst cycles and scheduling criteria. It then describes common scheduling algorithms like first come first served (FCFS), shortest job first (SJF), priority scheduling, and round robin (RR). It also discusses more advanced topics like multi-level queue scheduling, multi-processor scheduling, and thread scheduling in Linux.
This document discusses CPU scheduling in operating systems. It begins by introducing CPU scheduling and describing the goals of scheduling algorithms. It then explains common scheduling algorithms like first-come first-served (FCFS), shortest job first (SJF), priority scheduling, and round robin (RR). The document also covers multilevel queue scheduling, thread scheduling, multiple processor scheduling, and real-time CPU scheduling.
The document discusses CPU scheduling in operating systems. It covers basic concepts like CPU bursts and scheduling criteria. It then describes common scheduling algorithms like FCFS, SJF, priority scheduling, and round robin. It also discusses thread scheduling, multiprocessor scheduling, and examples of scheduling in Solaris, Windows, and Linux.
This document summarizes key concepts in CPU scheduling, including:
1) CPU scheduling algorithms like FCFS, SJF, priority, and round robin and how they optimize different criteria.
2) The role of dispatchers in context switching between processes.
3) Scheduling criteria like CPU utilization, throughput, turnaround time.
4) Advanced scheduling techniques like multilevel queues, multilevel feedback queues, and multiprocessor scheduling.
CPU scheduling involves selecting which process to execute next from among processes in memory. There are several criteria for evaluating CPU scheduling algorithms, including CPU utilization, throughput, turnaround time, waiting time, and response time. Common algorithms include first-come, first-served (FCFS), shortest-job-first (SJF), priority scheduling, and round robin (RR). Multilevel queue and feedback queue scheduling involve partitioning processes into multiple queues that use different scheduling policies.
This document discusses various CPU scheduling algorithms and concepts. It covers scheduling criteria like CPU utilization and turnaround time. Algorithms discussed include first-come first-served (FCFS), shortest job first (SJF), priority scheduling, and round robin (RR). It also covers multiple processor scheduling, real-time scheduling, and evaluating scheduling algorithms.
This document discusses various CPU scheduling algorithms and concepts. It covers scheduling criteria like CPU utilization and turnaround time. Algorithms discussed include first-come first-served (FCFS), shortest job first (SJF), priority scheduling, and round robin (RR). It also covers multiple processor scheduling, real-time scheduling, and evaluating scheduling algorithms.
The document discusses various CPU scheduling concepts and algorithms. It covers basic concepts like CPU-I/O burst cycles and scheduling criteria. It then describes common scheduling algorithms like first come first served (FCFS), shortest job first (SJF), priority scheduling, and round robin (RR). It also discusses more advanced topics like multi-level queue scheduling, multi-processor scheduling, and thread scheduling in Linux.
This document discusses various CPU scheduling algorithms and concepts. It covers scheduling criteria like CPU utilization and turnaround time. Algorithms discussed include first-come first-served (FCFS), shortest job first (SJF), priority scheduling, and round robin (RR). It also covers multiple queue scheduling, real-time scheduling, and ways to evaluate scheduling algorithm performance like deterministic modeling and simulation.
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 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.
Unit iios process scheduling and synchronizationdonny101
The document discusses process scheduling and synchronization in operating systems. It covers CPU scheduling algorithms like first-come first-served, shortest job first, priority scheduling, and round robin. It also discusses concepts like critical section problem, synchronization methods using semaphores and monitors, and solutions to deadlocks. Process synchronization ensures that processes access shared resources in a mutually exclusive way.
This document discusses the slides for Unit 2 of the Operating Systems course. It includes an index of lecture topics that will be covered, such as process concepts and threads, scheduling criteria and algorithms, thread scheduling, case studies of UNIX/Linux and Windows operating systems, and revision. Key concepts that will be covered include processes and threads, process state diagrams, process control blocks, CPU scheduling queues, producer-consumer problem solutions, scheduling criteria and algorithms like FCFS, SJF, priority and round robin, and thread scheduling models.
The document discusses various scheduling algorithms used in operating systems including:
- First Come First Serve (FCFS) scheduling which services processes in the order they arrive but can lead to long wait times.
- Shortest Job First (SJF) scheduling which prioritizes the shortest processes first to minimize wait times. This can be preemptive or non-preemptive.
- Priority scheduling which assigns priorities to processes and services the highest priority first, which can cause starvation of low priority processes.
- Round Robin scheduling which allows fair sharing of the CPU by allocating a time quantum or slice to each process in a cyclic manner.
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 before being preempted. It has lower average waiting times than FCFS but higher than SJF.
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 discusses several topics related to CPU scheduling, including basic concepts, scheduling criteria, algorithms like first-come first-served (FCFS) and shortest-job-first (SJF), determining CPU burst lengths, priority scheduling, and approaches to scheduling on multiple processors. Key concepts are that the CPU scheduler selects ready processes to run and aims to maximize CPU utilization while minimizing waiting times using algorithms like FCFS, SJF, priority, and round robin scheduling. Load sharing and affinity are considerations for multiprocessor scheduling.
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 discusses various concepts related to CPU scheduling in operating systems, including:
1) CPU scheduling aims to maximize CPU utilization by allowing other processes to run when one process is waiting for I/O. Short-term schedulers select ready processes from memory to run on the CPU.
2) Scheduling can be preemptive or nonpreemptive depending on when context switches occur. Dispatchers are responsible for context switches between processes.
3) Common scheduling criteria include CPU utilization, throughput, turnaround time, waiting time, and response time.
4) Scheduling algorithms like FCFS, SJF, priority, round robin, and multilevel queue scheduling aim to optimize
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
CPU Scheduling is the process through which we can find the best way to check the shortest and fastest working. Different Algorithms are explained here in this chapter. First-come-first-servers, Shortest Job First, Shortest remaining time first,
Round Robin, Priority Scheduler.
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.
cpu scheduling bassically tell us about the outer structure or the managemnet of the computer tha how it is done ,it bassically tell us about how our cpu is scheduled.
Operating Systems Third Unit - Fourth Semester - EngineeringYogesh Santhan
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.
* 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
This document discusses distributed operating systems and CPU scheduling. It covers basic concepts of CPU scheduling like processes, context switching, and dispatching. It then discusses different scheduling algorithms like first-come first-served, shortest job first, priority scheduling, and round robin. It also covers multiple processor scheduling, real-time scheduling, and algorithm evaluation. Deadlocks are discussed including characterization, handling methods like prevention, avoidance, and detection. Memory management techniques like swapping, paging, segmentation and their implementation are also summarized.
Here are the steps to solve this problem:
a) Non-Preemptive Priority Scheduling:
- Process order based on priority: P2, P4, P1, P3
- Number of context switches = 3
b) Round Robin Scheduling with time slice = 2:
- Process order: P1, P2, P1, P4, P1, P3, P1
- Number of context switches = 6
c) With RR, the behavior depends on the time slice size. With a small time slice of 2ms, most processes cannot complete within one time slice. This leads to a larger number of context switches compared to priority scheduling.
d)
Beyond Degrees - Empowering the Workforce in the Context of Skills-First.pptxEduSkills OECD
Iván Bornacelly, Policy Analyst at the OECD Centre for Skills, OECD, presents at the webinar 'Tackling job market gaps with a skills-first approach' on 12 June 2024
This document discusses various CPU scheduling algorithms and concepts. It covers scheduling criteria like CPU utilization and turnaround time. Algorithms discussed include first-come first-served (FCFS), shortest job first (SJF), priority scheduling, and round robin (RR). It also covers multiple queue scheduling, real-time scheduling, and ways to evaluate scheduling algorithm performance like deterministic modeling and simulation.
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 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.
Unit iios process scheduling and synchronizationdonny101
The document discusses process scheduling and synchronization in operating systems. It covers CPU scheduling algorithms like first-come first-served, shortest job first, priority scheduling, and round robin. It also discusses concepts like critical section problem, synchronization methods using semaphores and monitors, and solutions to deadlocks. Process synchronization ensures that processes access shared resources in a mutually exclusive way.
This document discusses the slides for Unit 2 of the Operating Systems course. It includes an index of lecture topics that will be covered, such as process concepts and threads, scheduling criteria and algorithms, thread scheduling, case studies of UNIX/Linux and Windows operating systems, and revision. Key concepts that will be covered include processes and threads, process state diagrams, process control blocks, CPU scheduling queues, producer-consumer problem solutions, scheduling criteria and algorithms like FCFS, SJF, priority and round robin, and thread scheduling models.
The document discusses various scheduling algorithms used in operating systems including:
- First Come First Serve (FCFS) scheduling which services processes in the order they arrive but can lead to long wait times.
- Shortest Job First (SJF) scheduling which prioritizes the shortest processes first to minimize wait times. This can be preemptive or non-preemptive.
- Priority scheduling which assigns priorities to processes and services the highest priority first, which can cause starvation of low priority processes.
- Round Robin scheduling which allows fair sharing of the CPU by allocating a time quantum or slice to each process in a cyclic manner.
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 before being preempted. It has lower average waiting times than FCFS but higher than SJF.
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 discusses several topics related to CPU scheduling, including basic concepts, scheduling criteria, algorithms like first-come first-served (FCFS) and shortest-job-first (SJF), determining CPU burst lengths, priority scheduling, and approaches to scheduling on multiple processors. Key concepts are that the CPU scheduler selects ready processes to run and aims to maximize CPU utilization while minimizing waiting times using algorithms like FCFS, SJF, priority, and round robin scheduling. Load sharing and affinity are considerations for multiprocessor scheduling.
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 discusses various concepts related to CPU scheduling in operating systems, including:
1) CPU scheduling aims to maximize CPU utilization by allowing other processes to run when one process is waiting for I/O. Short-term schedulers select ready processes from memory to run on the CPU.
2) Scheduling can be preemptive or nonpreemptive depending on when context switches occur. Dispatchers are responsible for context switches between processes.
3) Common scheduling criteria include CPU utilization, throughput, turnaround time, waiting time, and response time.
4) Scheduling algorithms like FCFS, SJF, priority, round robin, and multilevel queue scheduling aim to optimize
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
CPU Scheduling is the process through which we can find the best way to check the shortest and fastest working. Different Algorithms are explained here in this chapter. First-come-first-servers, Shortest Job First, Shortest remaining time first,
Round Robin, Priority Scheduler.
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.
cpu scheduling bassically tell us about the outer structure or the managemnet of the computer tha how it is done ,it bassically tell us about how our cpu is scheduled.
Operating Systems Third Unit - Fourth Semester - EngineeringYogesh Santhan
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.
* 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
This document discusses distributed operating systems and CPU scheduling. It covers basic concepts of CPU scheduling like processes, context switching, and dispatching. It then discusses different scheduling algorithms like first-come first-served, shortest job first, priority scheduling, and round robin. It also covers multiple processor scheduling, real-time scheduling, and algorithm evaluation. Deadlocks are discussed including characterization, handling methods like prevention, avoidance, and detection. Memory management techniques like swapping, paging, segmentation and their implementation are also summarized.
Here are the steps to solve this problem:
a) Non-Preemptive Priority Scheduling:
- Process order based on priority: P2, P4, P1, P3
- Number of context switches = 3
b) Round Robin Scheduling with time slice = 2:
- Process order: P1, P2, P1, P4, P1, P3, P1
- Number of context switches = 6
c) With RR, the behavior depends on the time slice size. With a small time slice of 2ms, most processes cannot complete within one time slice. This leads to a larger number of context switches compared to priority scheduling.
d)
Beyond Degrees - Empowering the Workforce in the Context of Skills-First.pptxEduSkills OECD
Iván Bornacelly, Policy Analyst at the OECD Centre for Skills, OECD, presents at the webinar 'Tackling job market gaps with a skills-first approach' on 12 June 2024
Walmart Business+ and Spark Good for Nonprofits.pdfTechSoup
"Learn about all the ways Walmart supports nonprofit organizations.
You will hear from Liz Willett, the Head of Nonprofits, and hear about what Walmart is doing to help nonprofits, including Walmart Business and Spark Good. Walmart Business+ is a new offer for nonprofits that offers discounts and also streamlines nonprofits order and expense tracking, saving time and money.
The webinar may also give some examples on how nonprofits can best leverage Walmart Business+.
The event will cover the following::
Walmart Business + (https://business.walmart.com/plus) is a new shopping experience for nonprofits, schools, and local business customers that connects an exclusive online shopping experience to stores. Benefits include free delivery and shipping, a 'Spend Analytics” feature, special discounts, deals and tax-exempt shopping.
Special TechSoup offer for a free 180 days membership, and up to $150 in discounts on eligible orders.
Spark Good (walmart.com/sparkgood) is a charitable platform that enables nonprofits to receive donations directly from customers and associates.
Answers about how you can do more with Walmart!"
Level 3 NCEA - NZ: A Nation In the Making 1872 - 1900 SML.pptHenry Hollis
The History of NZ 1870-1900.
Making of a Nation.
From the NZ Wars to Liberals,
Richard Seddon, George Grey,
Social Laboratory, New Zealand,
Confiscations, Kotahitanga, Kingitanga, Parliament, Suffrage, Repudiation, Economic Change, Agriculture, Gold Mining, Timber, Flax, Sheep, Dairying,
A Visual Guide to 1 Samuel | A Tale of Two HeartsSteve Thomason
These slides walk through the story of 1 Samuel. Samuel is the last judge of Israel. The people reject God and want a king. Saul is anointed as the first king, but he is not a good king. David, the shepherd boy is anointed and Saul is envious of him. David shows honor while Saul continues to self destruct.
Temple of Asclepius in Thrace. Excavation resultsKrassimira Luka
The temple and the sanctuary around were dedicated to Asklepios Zmidrenus. This name has been known since 1875 when an inscription dedicated to him was discovered in Rome. The inscription is dated in 227 AD and was left by soldiers originating from the city of Philippopolis (modern Plovdiv).
Leveraging Generative AI to Drive Nonprofit InnovationTechSoup
In this webinar, participants learned how to utilize Generative AI to streamline operations and elevate member engagement. Amazon Web Service experts provided a customer specific use cases and dived into low/no-code tools that are quick and easy to deploy through Amazon Web Service (AWS.)
ISO/IEC 27001, ISO/IEC 42001, and GDPR: Best Practices for Implementation and...PECB
Denis is a dynamic and results-driven Chief Information Officer (CIO) with a distinguished career spanning information systems analysis and technical project management. With a proven track record of spearheading the design and delivery of cutting-edge Information Management solutions, he has consistently elevated business operations, streamlined reporting functions, and maximized process efficiency.
Certified as an ISO/IEC 27001: Information Security Management Systems (ISMS) Lead Implementer, Data Protection Officer, and Cyber Risks Analyst, Denis brings a heightened focus on data security, privacy, and cyber resilience to every endeavor.
His expertise extends across a diverse spectrum of reporting, database, and web development applications, underpinned by an exceptional grasp of data storage and virtualization technologies. His proficiency in application testing, database administration, and data cleansing ensures seamless execution of complex projects.
What sets Denis apart is his comprehensive understanding of Business and Systems Analysis technologies, honed through involvement in all phases of the Software Development Lifecycle (SDLC). From meticulous requirements gathering to precise analysis, innovative design, rigorous development, thorough testing, and successful implementation, he has consistently delivered exceptional results.
Throughout his career, he has taken on multifaceted roles, from leading technical project management teams to owning solutions that drive operational excellence. His conscientious and proactive approach is unwavering, whether he is working independently or collaboratively within a team. His ability to connect with colleagues on a personal level underscores his commitment to fostering a harmonious and productive workplace environment.
Date: May 29, 2024
Tags: Information Security, ISO/IEC 27001, ISO/IEC 42001, Artificial Intelligence, GDPR
-------------------------------------------------------------------------------
Find out more about ISO training and certification services
Training: ISO/IEC 27001 Information Security Management System - EN | PECB
ISO/IEC 42001 Artificial Intelligence Management System - EN | PECB
General Data Protection Regulation (GDPR) - Training Courses - EN | PECB
Webinars: https://pecb.com/webinars
Article: https://pecb.com/article
-------------------------------------------------------------------------------
For more information about PECB:
Website: https://pecb.com/
LinkedIn: https://www.linkedin.com/company/pecb/
Facebook: https://www.facebook.com/PECBInternational/
Slideshare: http://www.slideshare.net/PECBCERTIFICATION
How to Make a Field Mandatory in Odoo 17Celine George
In Odoo, making a field required can be done through both Python code and XML views. When you set the required attribute to True in Python code, it makes the field required across all views where it's used. Conversely, when you set the required attribute in XML views, it makes the field required only in the context of that particular view.
3. OBJECTIVES
To introduce CPU scheduling, which is the basis for
multiprogrammed operating systems
To describe various CPU-scheduling algorithms
To discuss evaluation criteria for selecting a CPU-
scheduling algorithm for a particular system
4. BASIC CONCEPTS
Maximum CPU utilization obtained with
multiprogramming
CPU–I/O Burst Cycle – Process execution consists of
a cycle of CPU execution and I/O wait
CPU burst distribution
7. CPU SCHEDULER
Selects from among the processes in ready queue, and
allocates the CPU to one of them
Queue may be ordered in various ways
CPU scheduling decisions may take place when a process:
1. Switches from running to waiting state
2. Switches from running to ready state
3. Switches from waiting to ready
4. Terminates
Scheduling under 1 and 4 is nonpreemptive
All other scheduling is preemptive
Consider access to shared data
Consider preemption while in kernel mode
Consider interrupts occurring during crucial OS activities
8. DISPATCHER
Dispatcher module gives control of the CPU to the
process selected by the short-term scheduler; this
involves:
switching context
switching to user mode
jumping to the proper location in the user program to restart
that program
Dispatch latency – time it takes for the dispatcher to
stop one process and start another running
9. SCHEDULING CRITERIA
CPU utilization – keep the CPU as busy as possible
Throughput – # of processes that complete their execution per
time unit
Turnaround time – amount of time to execute a particular
process
Waiting time – amount of time a process has been waiting in the
ready queue
Response time – amount of time it takes from when a request
was submitted until the first response is produced, not output (for
time-sharing environment)
10. SCHEDULING ALGORITHM OPTIMIZATION CRITERIA
Max CPU utilization
Max throughput
Min turnaround time
Min waiting time
Min response time
11. FIRST-COME, FIRST-SERVED (FCFS) SCHEDULING
Process Burst Time
P1 24
P2 3
P3 3
Suppose that the processes arrive in the order: P1 , P2 , P3
The Gantt Chart for the schedule is:
Waiting time for P1 = 0; P2 = 24; P3 = 27
Average waiting time: (0 + 24 + 27)/3 = 17
P1 P2 P3
24 27 30
0
12. FCFS SCHEDULING (CONT.)
Suppose that the processes arrive in the order:
P2 , P3 , P1
The Gantt chart for the schedule is:
Waiting time for P1 = 6; P2 = 0; P3 = 3
Average waiting time: (6 + 0 + 3)/3 = 3
Much better than previous case
Convoy effect - short process behind long process
Consider one CPU-bound and many I/O-bound processes
P1
P3
P2
6
3 30
0
13. SHORTEST-JOB-FIRST (SJF) SCHEDULING
Associate with each process the length of its next CPU
burst
Use these lengths to schedule the process with the shortest
time
SJF is optimal – gives minimum average waiting time
for a given set of processes
The difficulty is knowing the length of the next CPU request
Could ask the user
14. EXAMPLE OF SJF
ProcessArriva l Time Burst Time
P1 0.0 6
P2 2.0 8
P3 4.0 7
P4 5.0 3
SJF scheduling chart
Average waiting time = (3 + 16 + 9 + 0) / 4 = 7
P4
P3
P1
3 16
0 9
P2
24
15. DETERMINING LENGTH OF NEXT CPU BURST
Can only estimate the length – should be similar to the previous one
Then pick process with shortest predicted next CPU burst
Can be done by using the length of previous CPU bursts, using
exponential averaging
Commonly, α set to ½
Preemptive version called shortest-remaining-time-first
:
Define
4.
1
0
,
3.
burst
CPU
next
the
for
value
predicted
2.
burst
CPU
of
length
actual
1.
1
n
th
n n
t
.
1
1 n
n
n t
17. EXAMPLES OF EXPONENTIAL AVERAGING
=0
n+1 = n
Recent history does not count
=1
n+1 = tn
Only the actual last CPU burst counts
If we expand the formula, we get:
n+1 = tn+(1 - ) tn -1 + …
+(1 - )j tn -j + …
+(1 - )n +1 0
Since both and (1 - ) are less than or equal to 1, each
successive term has less weight than its predecessor
18. EXAMPLE OF SHORTEST-REMAINING-TIME-FIRST
Now we add the concepts of varying arrival times and preemption
to the analysis
ProcessAarri Arrival TimeTBurst Time
P1 0 8
P2 1 4
P3 2 9
P4 3 5
Preemptive SJF Gantt Chart
Average waiting time = [(10-1)+(1-1)+(17-2)+5-3)]/4 = 26/4 = 6.5
msec
P1
P1
P2
1 17
0 10
P3
26
5
P4
19. PRIORITY SCHEDULING
A priority number (integer) is associated with each process
The CPU is allocated to the process with the highest priority
(smallest integer highest priority)
Preemptive
Nonpreemptive
SJF is priority scheduling where priority is the inverse of
predicted next CPU burst time
Problem Starvation – low priority processes may never
execute
Solution Aging – as time progresses increase the priority of
the process
21. ROUND ROBIN (RR)
Each process gets a small unit of CPU time (time quantum
q), usually 10-100 milliseconds. After this time has elapsed,
the process is preempted and added to the end of the ready
queue.
If there are n processes in the ready queue and the time
quantum is q, then each process gets 1/n of the CPU time in
chunks of at most q time units at once. No process waits
more than (n-1)q time units.
Timer interrupts every quantum to schedule next process
Performance
q large FIFO
q small q must be large with respect to context switch,
otherwise overhead is too high
22. EXAMPLE OF RR WITH TIME QUANTUM = 4
Process Burst Time
P1 24
P2 3
P3 3
The Gantt chart is:
Typically, higher average turnaround than SJF, but better
response
q should be large compared to context switch time
q usually 10ms to 100ms, context switch < 10 usec
P1 P2 P3 P1 P1 P1 P1 P1
0 4 7 10 14 18 22 26 30
25. MULTILEVEL QUEUE
Ready queue is partitioned into separate queues, eg:
foreground (interactive)
background (batch)
Process permanently in a given queue
Each queue has its own scheduling algorithm:
foreground – RR
background – FCFS
Scheduling must be done between the queues:
Fixed priority scheduling; (i.e., serve all from foreground then from
background). Possibility of starvation.
Time slice – each queue gets a certain amount of CPU time which
it can schedule amongst its processes; i.e., 80% to foreground in
RR
20% to background in FCFS
27. MULTILEVEL FEEDBACK QUEUE
A process can move between the various queues;
aging can be implemented this way
Multilevel-feedback-queue scheduler defined by the
following parameters:
number of queues
scheduling algorithms for each queue
method used to determine when to upgrade a process
method used to determine when to demote a process
method used to determine which queue a process will
enter when that process needs service
28. EXAMPLE OF MULTILEVEL FEEDBACK QUEUE
Three queues:
Q0 – RR with time quantum 8 milliseconds
Q1 – RR time quantum 16 milliseconds
Q2 – FCFS
Scheduling
A new job enters queue Q0 which is served FCFS
When it gains CPU, job receives 8 milliseconds
If it does not finish in 8 milliseconds, job is moved to queue Q1
At Q1 job is again served FCFS and receives 16 additional
milliseconds
If it still does not complete, it is preempted and moved to queue Q2
30. THREAD SCHEDULING
Distinction between user-level and kernel-level threads
When threads supported, threads scheduled, not processes
Many-to-one and many-to-many models, thread library schedules user-
level threads to run on LWP
Known as process-contention scope (PCS) since scheduling competition is
within the process
Typically done via priority set by programmer
Kernel thread scheduled onto available CPU is system-contention
scope (SCS) – competition among all threads in system
31. PTHREAD SCHEDULING
API allows specifying either PCS or SCS during thread
creation
PTHREAD_SCOPE_PROCESS schedules threads using
PCS scheduling
PTHREAD_SCOPE_SYSTEM schedules threads using SCS
scheduling
Can be limited by OS – Linux and Mac OS X only allow
PTHREAD_SCOPE_SYSTEM
32. PTHREAD SCHEDULING API
#include <pthread.h>
#include <stdio.h>
#define NUM THREADS 5
int main(int argc, char *argv[])
{
int i;
pthread t tid[NUM THREADS];
pthread attr t attr;
/* get the default attributes */
pthread attr init(&attr);
/* set the scheduling algorithm to PROCESS or SYSTEM */
pthread attr setscope(&attr, PTHREAD SCOPE SYSTEM);
/* set the scheduling policy - FIFO, RT, or OTHER */
pthread attr setschedpolicy(&attr, SCHED OTHER);
/* create the threads */
for (i = 0; i < NUM THREADS; i++)
pthread create(&tid[i],&attr,runner,NULL);
33. PTHREAD SCHEDULING API
/* now join on each thread */
for (i = 0; i < NUM THREADS; i++)
pthread join(tid[i], NULL);
}
/* Each thread will begin control in this function */
void *runner(void *param)
{
printf("I am a threadn");
pthread exit(0);
}
34. MULTIPLE-PROCESSOR SCHEDULING
CPU scheduling more complex when multiple CPUs are available
Homogeneous processors within a multiprocessor
Asymmetric multiprocessing – only one processor accesses the
system data structures, alleviating the need for data sharing
Symmetric multiprocessing (SMP) – each processor is self-scheduling,
all processes in common ready queue, or each has its own private queue
of ready processes
Currently, most common
Processor affinity – process has affinity for processor on which it is
currently running
soft affinity
hard affinity
Variations including processor sets
35. NUMA AND CPU SCHEDULING
Note that memory-placement algorithms can also consider
affinity
36. MULTICORE PROCESSORS
Recent trend to place multiple processor cores on same
physical chip
Faster and consumes less power
Multiple threads per core also growing
Takes advantage of memory stall to make progress on
another thread while memory retrieve happens
38. VIRTUALIZATION AND SCHEDULING
Virtualization software schedules multiple guests onto
CPU(s)
Each guest doing its own scheduling
Not knowing it doesn’t own the CPUs
Can result in poor response time
Can effect time-of-day clocks in guests
Can undo good scheduling algorithm efforts of guests
40. SOLARIS
Priority-based scheduling
Six classes available
Time sharing (default)
Interactive
Real time
System
Fair Share
Fixed priority
Given thread can be in one class at a time
Each class has its own scheduling algorithm
Time sharing is multi-level feedback queue
Loadable table configurable by sysadmin
43. SOLARIS SCHEDULING (CONT.)
Scheduler converts class-specific priorities into a per-
thread global priority
Thread with highest priority runs next
Runs until (1) blocks, (2) uses time slice, (3) preempted by
higher-priority thread
Multiple threads at same priority selected via RR
44. WINDOWS SCHEDULING
Windows uses priority-based preemptive scheduling
Highest-priority thread runs next
Dispatcher is scheduler
Thread runs until (1) blocks, (2) uses time slice, (3)
preempted by higher-priority thread
Real-time threads can preempt non-real-time
32-level priority scheme
Variable class is 1-15, real-time class is 16-31
Priority 0 is memory-management thread
Queue for each priority
If no run-able thread, runs idle thread
45. WINDOWS PRIORITY CLASSES
Win32 API identifies several priority classes to which a
process can belong
REALTIME_PRIORITY_CLASS,
HIGH_PRIORITY_CLASS,
ABOVE_NORMAL_PRIORITY_CLASS,NORMAL_PRIORI
TY_CLASS, BELOW_NORMAL_PRIORITY_CLASS,
IDLE_PRIORITY_CLASS
All are variable except REALTIME
A thread within a given priority class has a relative
priority
TIME_CRITICAL, HIGHEST, ABOVE_NORMAL, NORMAL,
BELOW_NORMAL, LOWEST, IDLE
Priority class and relative priority combine to give
47. LINUX SCHEDULING
Constant order O(1) scheduling time
Preemptive, priority based
Two priority ranges: time-sharing and real-time
Real-time range from 0 to 99 and nice value from
100 to 140
Map into global priority with numerically lower values
indicating higher priority
Higher priority gets larger q
Task run-able as long as time left in time slice (active)
If no time left (expired), not run-able until all other
tasks use their slices
All run-able tasks tracked in per-CPU runqueue data
structure
48. LINUX SCHEDULING (CONT.)
Real-time scheduling according to POSIX.1b
Real-time tasks have static priorities
All other tasks dynamic based on nice value plus or
minus 5
Interactivity of task determines plus or minus
More interactive -> more minus
Priority recalculated when task expired
This exchanging arrays implements adjusted priorities
51. ALGORITHM EVALUATION
How to select CPU-scheduling algorithm for an OS?
Determine criteria, then evaluate algorithms
Deterministic modeling
Type of analytic evaluation
Takes a particular predetermined workload and defines the
performance of each algorithm for that workload
52. QUEUEING MODELS
Describes the arrival of processes, and CPU and I/O
bursts probabilistically
Commonly exponential, and described by mean
Computes average throughput, utilization, waiting time, etc
Computer system described as network of servers,
each with queue of waiting processes
Knowing arrival rates and service rates
Computes utilization, average queue length, average wait
time, etc
53. LITTLE’S FORMULA
n = average queue length
W = average waiting time in queue
λ = average arrival rate into queue
Little’s law – in steady state, processes leaving queue
must equal processes arriving, thus
n = λ x W
Valid for any scheduling algorithm and arrival distribution
For example, if on average 7 processes arrive per
second, and normally 14 processes in queue, then
average wait time per process = 2 seconds
54. SIMULATIONS
Queueing models limited
Simulations more accurate
Programmed model of computer system
Clock is a variable
Gather statistics indicating algorithm performance
Data to drive simulation gathered via
Random number generator according to probabilities
Distributions defined mathematically or empirically
Trace tapes record sequences of real events in real systems
56. IMPLEMENTATION
Even simulations have limited accuracy
Just implement new scheduler and test in real systems
High cost, high risk
Environments vary
Most flexible schedulers can be modified per-site or per-system
Or APIs to modify priorities
But again environments vary
63. JAVA THREAD SCHEDULING
JVM Uses a Preemptive, Priority-Based Scheduling
Algorithm
FIFO Queue is Used if There Are Multiple Threads With
the Same Priority
64. JAVA THREAD SCHEDULING (CONT.)
JVM Schedules a Thread to Run When:
1. The Currently Running Thread Exits the Runnable State
2. A Higher Priority Thread Enters the Runnable State
* Note – the JVM Does Not Specify Whether Threads
are Time-Sliced or Not
65. TIME-SLICING
Since the JVM Doesn’t Ensure Time-Slicing, the yield()
Method
May Be Used:
while (true) {
// perform CPU-intensive task
. . .
Thread.yield();
}
This Yields Control to Another Thread of Equal Priority
66. THREAD PRIORITIES
Priority Comment
Thread.MIN_PRIORITY Minimum Thread Priority
Thread.MAX_PRIORITY Maximum Thread
Priority
Thread.NORM_PRIORITY Default Thread
Priority
Priorities May Be Set Using setPriority() method:
setPriority(Thread.NORM_PRIORITY + 2);