Bölüm 5: CPU Planlama( Scheduling )

Silberschatz, Galvin and Gagne ©2009Operating System Concepts – 8th Edition,

Bölüm 5: CPU Planlama(Scheduling)

5.2 Silberschatz, Galvin and Gagne ©2009Operating System Concepts – 8th Edition

CPU Planlama(cpu Scheduling)

Temel Kavramlar Planlama Kriterleri Planlama Algoritmaları Multiple-Processor Planlama İşletim Sistemi Örnekleri Algoritma Değerlendirilmesi


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


İşlemci Planlama(cpu Schedulıng) Mikroişlemci programlaması işletim sistemlerinin temelini oluşturmaktadır. Mikroişlemcinin işlemler arasında geçişini sağlamak bilgisayar kullanımını

daha üretken yapmaktadır. Bu bölümde mikroişlemci programlamasının içeriğini ve var olan

mikroişlemci planlama algoritmalarını inceleyeceğiz.


Temel İçerik

Çok programlı sistemlerin amacı aynı anda yürütülen işlem sayısını artırarak mikroişlemciyi maksimum etkinliğe ve üretkenliğe kavuşturmaktır.

Tek işlemcili sistemlerde aynı anda sadece bir işlem yürütülebilir. Birden fazla işlem olduğunda, bunlar mikroişlemcinin işinin bitmesi için bekleyeceklerdir.

Çok programlı sistemlerde birden fazla işlem bellekte tutulabilmektedir. İşlemci zamanlama algoritmalarına göre de sırası gelen işlem bekleme

sırasından(Hazır Kuyruk) alınarak görevlendirici (dispatcher) ismi verilen bir işlem tarafından CPU’ya gönderilir. CPU’da yine işlemci zamanlama algoritmasının izin verdiği kadar (ya bitene ya da belirli bir zaman geçene kadar) çalışan program ya biter ve hafızadan kaldırılır ya da tekrar bekleme sırasına bir sonraki çalışma için yerleştirilir.

http://www.bilgisayarkavramlari.com/2008/11/19/gorevlendirici-dispatcher/







İşlemci Planlama(cpu Schedulıng) Programlama ve plan işletim sistemi fonksiyonunun temelini oluşturur. Tabii ki, mikroişlemci de bilgisayarın en önemli parçası olduğu için onun

nasıl çalışacağına dair bir programın yapılması işletim sistemi tasarımının da merkezini oluşturur

Mikroişlemci boş kaldığında işletim sistemi sırada hazır bekleyen işlemlerden birini seçerek mikroişlemciye yerleştirmektedir.

Bu seçme işlemi kısa-dönem programlayıcı tarafından yapılmaktadır. Mikroişlemciye yerleştirilecek işlemin ilk gelen işlem olması şart değildir. İşlemlerin sıralanması hiç sıralama kriteri düşünülmeden yapılabileceği gibi

geliş sıralarına göre de sıralama yapılabilir. Sıralama işinin yapılması için farklı programlama algoritmaları mevcuttur.


CPU-burst zaman Histogramı


CPU ve I/O Bursts arasındaki geçişler


Kesintili(preemptive) ve Kesmeyen(non-preemptive) Kavramı

Hazır sırası ile işlemci arasında zamanlama ilişkisini kuran işlemci zamanlama algoritmalarını (cpu scheduling algorithms) temel olarak 2 grupta incelenebilir:

kesintili algoritmalar (preemptive): yürütülen işlemin mikroişlemciden kaldırılması ve istenilen başka bir işlemin mikroişlemcide yürütülmesi sağlanabilir.

kesmeyen algoritmalar (nonpreemptive): işlem mikroişlemciye yerleştikten sonra; işlem tamamlanıncaya veya durana kadar mikroişlemciyi kullanır.

Kendi kodunda bulunan bir I/O isteği ile bloklanıncaya kadar ya da kendi isteği ile işlemciden çıkıncaya kadar çalışır.

http://www.bilgisayarkavramlari.com/2008/11/19/kesintili-zamanlama-preemptive-scheduling/

http://www.bilgisayarkavramlari.com/2008/11/19/kesmeyen-zamanlama-non-preemptive-scheduling/


CPU planlama

Mikroişlemci planlaması aşağıdaki durumlardan biri olduğunda yapılmaktadır.

1. İşlemin yürütmeden bekleme duruma geçme2. İşlemin yürütmeden hazır duruma geçme3. İşlemin beklemeden hazır duruma geçme 4. İşlemin Durması

1. ve 4. durumlardaki planlama kesintisiz (nonpreemptive) planlama Diğer tüm durumlar kesintili (preemptive) planlamadır.


Gönderici-Dispatcher

İşletim sistemi tasarımında kullanılan gönderici, işlemci zamanlama algoritmasına (CPU scheduling algorithm) göre beklemekte olan işlemlerden sıradakini alıp işlemciye yollayan programın ismidir.

İşte görevlendirici (dispatcher) bu işlemlerden sırası gelenin bekleme sırasından (ready queue) alınarak işlemciye gönderilmesi işlemini yerine getirir.

Bu fonksiyon şunları kapsamaktadır: İçerik değişimi Kullanıcı moduna geçiş Programı tekrar başlatmak için kullanıcı programında uygun

bölgeye geçişin sağlanması Gönderici zamanı göndericinin bir işlemi bitirip diğerine geçişi

arasındaki süredir. Gönderici mümkün olduğu karar hızlı olmalıdır.

http://www.bilgisayarkavramlari.com/2008/11/19/bekleme-sirasi-ready-queue/


Planlama Kriterleri -Scheduling Criteria Mikroişlemci programlama algoritmasında mikroişlemcileri kıyaslamak

için bir çok kriter bulunmaktadır. Bu karakteristikler de en iyi algoritmanın oluşturulması için kullanılır. Kullanılan kriterler şunlardır:

Mikroişlemci yararı (CPU utilizitation):Mikroişlemci mümkün olduğu

kadar meşgul edilmeye çalışılır. Mikroişlemci yararı 0’dan 100’e kadar değişebilmektedir. Normal sistem-40, yoğun sistem-90

Yapılan İş(Throughput): Birim zamanda yapılan işlem sayısı miktarı

yapılan iş olarak adlandırılır. (saniyede, saatte yapılan işlem) Dönüş Süresi( Turnaround time): Bir işlemin yürütülmesi sırasında

geçen süredir. İşlemin dönüş süresi ;belleğe yüklenirken, işlem sırasında beklerken, mikroişlemcide yürütülürken ve giriş/çıkış aygıtları tarafından tamamlanırken geçen sürelerin tamamıdır.


Planlama Kriterleri -Scheduling Criteria

Bekleme Süresi( Waiting time): İşlemin mikroişlemci tarafından yürütülene kadar, hazır durumdaki sırada geçirdiği süre bekleme süresi olarak adlandırılır.

Cevaplama Zamanı(Response time): İşlemin mikroişlemci idaresine bırakılışından, sistemin ilk cevabı gelişine kadar geçen süre cevaplama zamanı olarak adlandırılır. Bu süre sistemin cevap vermeye başladığı ana kadar geçen süredir. Bu zaman, çıkış aygıtlarının sisteme cevap verme süresi ile karıştırılmamalıdır.



Planlama Algoritması Optimizasyon Kriterleri

Max CPU utilization Max throughput Min turnaround time Min waiting time Min response time


Planlama Algoritmaları

First-Come, First-Served(FCFS ) Shortest-Job-First (SJF) Priority Multilevel Queue


İlk gelene-İlk hizmet (FCFS) Planlaması

En basit mikroişlemci programlama algoritması ilk gelene-ilk hizmet (first come, first served (FCFS)’dır.

Bu sistemde mikroişlemciye ilk gelen işlem mikroişlemciye yerleştirilir.

İşlemler geliş sıralarına göre bir sıra oluştururlar. Bir işlem mikroişlemciye geldiğinde hazır durumdaki işlem sırasının en sonuna yerleştirilir.



İşlem İşlem Süresi (BurstTime) P1 24 P2 3 P3 3

İşlemlerin Geliş Sırası: P1 , P2 , P3 The Gantt Şeması:

Bekleme Zamanı P1 = 0; P2 = 24; P3 = 27 Ortalama Bekleme Zamanı: (0 + 24 + 27)/3 = 17

P1 P2 P3

24 27 300



İşlemler aşağıdaki geliş sırası ile gelmiş olsalardı: P2 , P3 , P1

Gantt şeması:

Bekleme zamanı P1 = 6; P2 = 0; P3 = 3 Ortalama bekleme zamanı: (6 + 0 + 3)/3 = 3 Bir önceki örnekten çok daha iyi değerler Uzun bir işlemi bekleme durumu konvoy etkisi oluşturabilir.

P1P3P2

63 300


Kısa-iş öncelikli Planlama –Shortest-Job-First (SJF)

Başka bir mikroişlemci programlama yaklaşımı da kısa olan görevin öncelikli olması (shortest-job first, SFJ)’dir.

Bu yaklaşımda en kısa süreye sahip olan işlem mikroişlemciyi kullanabilir. Eğer iki işlem aynı uzunlukta ise, bu durumda FCFS prensibine göre önce

gelen işlem mikroişlemciyi kullanabilir. SJF optimaldir – Bir işlem grubu için minimum ortalama bekleme süresi verir

Zorluk sonraki işlemci isteği uzunluğu bilmektir


Kısa-iş öncelikli Planlama

İşlem İşlem Süresi (Burst Time) P1 6

P2 8

P3 7

P4 3 SJF planlama çizelgesi

Ortalama Bekleme Zamanı = (3 + 16 + 9 + 0) / 4 = 7

P4 P3P1

3 160 9

P2

24


Determining Length of Next CPU Burst

Can only estimate the length Can be done by using the length of previous CPU bursts, using exponential

averaging

:Define 4.10 , 3.

burst CPU next the for value predicted 2.burst CPU of length actual 1.

1n

thn nt

.1 1 nnn t


Prediction of the Length of the Next CPU Burst


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


FCFS ile Karşılaştırma

FCFS:10.25 SJF:7



Kısa- iş öncelikli algoritması minimum ortalama bekleme zamanını vermektedir. Çünkü kısa işlem uzun olandan daha önce yapılmaktadır. Böylece kısa işlemin bekleme zamanının, uzun işlemin bekleme zamanından daha fazla azalması sağlanmaktadır.

Bu algoritmada gelecek işlemlerin uzunluğu bilmek oldukça zor olmaktadır.

İşlem Süresinin tahmini için kullanılan yöntemler bulunmktadır.



Ayrıca SFJ preemptive ve nonpreemptive olabilmektedir. Yeni bir işlem hazır durumdaki işlemler kuyruğuna geldiğinde bir seçim söz

konusu olmaktadır. Eğer yeni gelen işlem daha kısa bir mikroişlemci zamanına sahipse preemmtive SFJ algoritması yeni gelen işleme mikroişlemcide bir yer ayırır ve onun yapılmasını sağlar.

Nonpreemptive prensibinde ise mikroişlemcinin yürüttüğü işlem bitene kadar, işlem kesilemez.


Kısa-iş öncelikli Planlama (preemptive )

Aşağıdaki işlemler verilen şu mikroişlemci zamanları ve sıralarıyla mikroişlemciye ulaşmış olsunlar:

İşlem Erişim zamanı Süre

P1 0 8 P2 1 4 P3 2 9 P4 3 5 Gelen işlemlerin yürütülmesi aşağıdaki sıra ve zaman aralıkları ile

yapılmaktadır.



P1 P2 P4 P1 P3

0 1 5 10 17 26

P1, P2, P 3 ve P4 işlemlerinin preemptive özellik taşıyan SFJ algoritması ile

sıralanması NONPREEMPTİVE P1, P2,P4, P3 İşlem Erişim zamanı Süre

P1 0 8 P2 1 4 P3 2 9 P4 3 5



Ortalama bekleme zamanı ise: =6,5 msn’dir. Bu şekilde davranan sistem “preemptive” özelliğini taşımaktadır.

Bekleme süresi nonpreemptive bir sistem için 7,75 msn olmaktadır.


Process Arrival Time Burst TimeP1 0.0 7

P2 2.0 4

P3 4.0 1

P4 5.0 4 SJF (non-preemptive)

Average waiting time = (0 + 6 + 3 + 7)/4 = 4

Example of Non-Preemptive SJF

P1 P3 P2

73 160

P4

8 12


Example of Preemptive SJF

Process Arrival Time Burst TimeP1 0.0 7

P2 2.0 4

P3 4.0 1

P4 5.0 4 SJF (preemptive, SRJF)

Average waiting time = (9 + 1 + 0 +2)/4 = 3

P1 P3P2

42 110

P4

5 7

P2 P1

16


Öncelikli (Priority) Planlama

Her işlemin sahip olduğu bir öncelik değeri mevcuttur. Bu programlama prensibine göre de, en yüksek önceliğe sahip işlem mikroişlemcide önce yapılır. Eğer işlemler eşit önceliğe sahiplerse, önce gelen işlem daha önce yapılır.

SJF algoritması aslında öncelikli planlama algoritmasıdır. Öncelik değer,

işlem zamanının tersi ile elde edilmektedir. Öncelikler genelde belli sayı aralıklarında olmaktadır; örneğin 0’den 7’ye,

0’dan 400’e kadar. Fakat burada küçük sayının az öncelik olmasını gerektiren bir zorunluluk yoktur, bazı sistemlerde “0” en fazla öncelik için kullanılabilmektedir.



Örnek olarak aşağıda verilen işlemleri ve özelliklerini ele alalım : (Düşük değer yüksek öncelik) İşlem Süresi Öncelik P1 10 3 P2 1 1 P3 2 4 P4 1 5 P5 5 2 Öncelik programlaması kullanıldığında işlem sırası aşağıdaki gibi

olmaktadır. Ortalama bekleme zamanı ise 8,2 msn olmaktadır.



Öncelik programlaması preemptive ve nonpreemptive olabilmektedir. Preemptive öncelik programlaması ile çalışan bir sistemde; yeni işlem mikroişlemcide hazır durumda bekleyen işlemler kuyruğuna ulaştığında, yeni gelen işlemin önceliği o anda yürütülen işlem ile karşılaştırılır.

Yeni gelen işlemin önceliği yürütülen işlemin önceliğinden fazla ise, yeni gelen işlem için mikroişlemcide yer ayrılır ve işlemin yürütülmesi sağlanır.

Nonpreemptive bir sistemde ise yeni gelen işlem mikroişlemcide bekleyen işlem kuyruğunun en sonuna yerleştirilir.

Problem Starvation – low priority processes may never execute Solution Aging – as time progresses increase the priority of the process


Round Robin (RR)

Round- robin algoritması zaman paylaşımlı sistemler için tasarlanmıştır. Robin- round algoritması FCFS algoritmasına benzemektedir, ama robin- round için bir zaman aralığı tanımlanmıştır, bu zaman aralığı 10 ile 100 msn arasında değişmekterdir.

Mikroişlemci programlayıcısı hazır durumdaki işlemleri zaman aralığına bağlı olarak mikroişlemcide yürütür.

RR algoritmasını uygulayabilmek için hazır durumdaki işlem

sırası FIFO algoritmasına göre sıralanır. Yani işlemler de hazır durumdaki sıraya eklenir. Mikroişlemci

programlayıcısı hazır durumdaki sıradan ilk işlemi alır ve zamanlayıcının 1 zaman aralığı (time quantum) sonunda kesme göndermesi sağlanır.


Round Robin (RR)

İki olayın olma ihtimali vardır. İşlemin süresi zaman aralığından daha az olabilir. Bu durumda işlem kendisi

mikroişlemciyi bırakacak ve mikroişlemci hazır durumdaki sıradan bir sonraki işlemi yürütmek üzere alacaktır.

Diğer durumda ise, yürütülen işlem zaman aralığından daha büyük bir süreye sahip olabilir.

Zaman aralığı dolduğunda, zamanlayıcı işletim sistemine bir kesme gönderir ve yürütülmek olan işlem sıranın sonuna gönderilir.

Bu durumda mikroişlemci programlayıcısı hazır durumdaki sıradan bir sonraki işlemi yürütmek üzere alır.


RR Örneği Time Quantum = 4

İşlem Süre (Burst Time)P1 24 P2 3 P3 3

Gantt Şeması

P1 için bekleme(10-4)=6 , P2=4 , P3=7 bekleme süresine sahiptir. Ortalama bekleme zamanı= 17/3=5.66

P1 P2 P3 P1 P1 P1 P1 P1

0 4 7 10 14 18 22 26 30


Time Quantum ve Context Switch


Turnaround Zamanı, Time Quantum İlişkisi

• Tek bir time-quantumda işlemin tamamlanması en ideal durumdur. Küçük time-quantum da çok fazla içerik değişimi de yapılmaktadır.

• Çok uzun time-quantum belirlendiğinde ise FCFS yöntemi gibi planlama yapılmaktadır.

• Genel bir yaklaşımla, işlemlerin %80 inin süresi time quantumdan daha kısa olmalıdır.


Çok Seviyeli Kuyruk (Multilevel Queue)

Hazır kuyruk iki parçaya ayrılmıştır:Önplan: foreground (interactive)Arkaplan: background (batch)

Her kuyruğun kendi sıralama yöntemi bulunmaktadır. Önplan ..foreground – RR Arkaplan..background – FCFS

Sıralar arasında da planlama yapılmalıdır: Sabit öncelikli planlama (Fixed priority scheduling) (Örneğin önce

arkaplandaki işelemleri yapi sonra önplandakileri yap.) Bu durumda starvation problemi ortaya çıkabilir.

Time slice – Her kuyruk işlemlerini planlamak için belli bir CPU zamanını alır (Örneğin 80% to foreground in RR, 20% to background in FCFS )





Çok seviyeli sıra programlamasında hazır durumdaki işlem sırası farklı gruplara ayrılmıştır.

Yani hazır durumdaki sıra bir tane değildir, farklı özelliklere sahip işlem sıraları mevcuttur.

Her işlem bu sırlardan birine sürekli olarak dahil olmaktadır. İşlemin hangi sıraya dahil olacağında işlemin öncelik değeri, büyüklüğü,

işlem tipi gibi özellikleri etkili olmaktadır. İşlem sıralarının da kendi aralarında öncelik durumları vardır. Her sıra düşük öncelikli sıraya göre mutlak bir önceliğe sahiptir. Sistem preemptive olarak çalışmaktadır. Örneğin interaktif bir işlem, grup

işlemi yürütülürken mikroişlemciye gelirse interaktif işlemin yapılması sağlanır.


Çok Seviyeli Geri Beslemeli Kuyruk (Multilevel Feedback Queue)

Çok seviyeli sıra programlamasında işlemler sürekli olarak bir sırada bulunmaktadırlar ve sıralar arasında yer değiştirme olayı olmamaktadır.

Çok seviyeli geribeslemeli sıra programlamasında ise işlemler farklı

sıralar arasında hareket edebilme, yer değiştirebilme özelliğine sahiptirler.

Eğer mikroişlemciyi çok meşgul edecek uzun süreli bir işlem varsa, bu işlem düşük öncelikli b ir sıraya geçirilebilir.

Ayrıca düşük öncelikli bir sırada çok beklemesi gerekecek bir işlem de yüksek öncelikli bir sıraya geçirilebilir



Bu prensiple çalışan sistemler aşağıdaki parametrelere göre tanımlanırlar:

Kuyruk adedi Her sıranın planlama algoritması Bir işlemin daha yüksek öncelikli sıraya taşınmasında kullanılan metot Bir işlemin daha düşük öncelikli sıraya taşınmasında kullanılan metot İşlemin yürütülmesi sırasında hangi sırada yer alacağına karar veren

metot


Örnek: 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.




Operating System Examples

Solaris scheduling Windows XP scheduling Linux scheduling


Multiple-Processor Scheduling

Multiple processors ==> divide load among them More complex than single CPU scheduling

How to divide load? Asymmetric multiprocessor

One master processor does the scheduling for others Symmetric multiprocessor (SMP)

Each processor runs its own scheduler One common ready queue for all processors, or one ready

queue for each Win XP, Linux, Solaris, Mac OS X support SMP


SMP Issues Processor affinity

When a process runs on a processor, some data is cached in that processor’s cache

A process migrates to another processor ==> Cache of new processor has to be re-populated Cache of old processor has to be invalidated ==> performance penalty

Load balancing One processor has too much load and another is idle Balance load using

Push migration: A specific task periodically checks load on all processors and evenly distributes it by moving (pushing) tasks

Pull migration: Idle processor pulls a waiting task from a busy processor

Some systems (e.g., Linux) implement both Tradeoff between load balancing and processor affinity: what would you do?

May be, invoke load balancer when imbalance exceeds a threshold


Solaris Dispatch Table


Solaris Scheduling


Windows XP Scheduler Priority-based, preemptive scheduler

The highest-priority thread will always run 32 levels of priorities, each has a separate queue Scheduler traverses queues from highest to lowest till it finds

a thread that is ready to run Priorities are divided into classes, each has several relative

priorities


Windows XP Priorities


Linux Scheduling

Constant order O(1) scheduling time Two priority ranges: time-sharing and real-time Real-time range from 0 to 99 and nice value from 100 to 140 (figure 5.15)


Priorities and Time-slice length


List of Tasks Indexed According to Priorities


Algorithm Evaluation

Deterministic modeling – takes a particular predetermined workload and defines the performance of each algorithm for that workload

Queueing models Implementation


Evaluation of CPU schedulers by Simulation

Silberschatz, Galvin and Gagne ©2009Operating System Concepts – 8th Edition,

End of Chapter 5


5.08


In-5.7


In-5.8


In-5.9


Dispatch Latency


Java Thread Scheduling

JVM Uses a Preemptive, Priority-Based Scheduling Algorithm

FIFO Queue is Used if There Are Multiple Threads With the Same Priority


Java Thread Scheduling (cont)

JVM Schedules a Thread to Run When:

1. The Currently Running Thread Exits the Runnable State2. A Higher Priority Thread Enters the Runnable State

* Note – the JVM Does Not Specify Whether Threads are Time-Sliced or Not


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


Thread Priorities

Priority CommentThread.MIN_PRIORITY Minimum Thread PriorityThread.MAX_PRIORITY Maximum Thread PriorityThread.NORM_PRIORITY Default Thread Priority

Priorities May Be Set Using setPriority() method:setPriority(Thread.NORM_PRIORITY + 2);


Solaris 2 Scheduling

Documents

Bölüm 5: CPU Planlama( Scheduling )