Provided by: manpages-pl-dev_20051117-1_all bug

NAZWA

       sched_setscheduler,   sched_getscheduler   -   ustawienie   i  pobranie
       algorytmu/parametrów szeregowania zadań

SKŁADNIA

       #include <sched.h>

       int sched_setscheduler(pid_t pid, int policy, const struct  sched_param
       *p);

       int sched_getscheduler(pid_t pid);

       struct sched_param {
           ...
           int sched_priority;
           ...
       };

OPIS

       sched_setscheduler  ustawia  dla  procesu  identyfikowanego  przez  pid
       politykę szeregowania zadań oraz związane z nią  parametry.  Jeśli  pid
       jest  równe  zeru,  to skonfigurowane zostanie szeregowanie dla procesu
       wołającego tę funkcję.  Interpretacja parametru p  zależy  od  wybranej
       polityki.   Obecnie,  pod  Linuksem  obsługiwane  są  następujące  trzy
       polityki: SCHED_FIFO, SCHED_RR i SCHED_OTHER; ich semantyki są  opisane
       poniżej.

       sched_getscheduler  zapytuje  o  bieżącą  politykę  szeregowania zadań,
       która dotyczy procesu określonego przez pid. Jeśli pid jest równe zeru,
       to pobierana jest polityką dotycząca procesu wywołującego tę funkcję.

   Polityki szeregowania zadań
       Procedura  szeregująca  jest częścią jądra, która decyduje o kolejności
       wykonywania działających procesów przez procesor.  Linuksowa  procedura
       szeregująca  oferuje  trzy różne polityki szeregowania zadań: jedną dla
       zwykłych procesów oraz dwie dla aplikacji czasu rzeczywistego.  Każdemu
       procesowi    przypisywana    jest   wartość   priorytetu   statycznego,
       sched_priority,  która  może  być  zmieniana  tylko  poprzez  wywołania
       systemowe.   Koncepcyjnie,   procedura   szeregująca  zarządza  listami
       działających  procesów  przypisanymi  każdej  z   możliweych   wartości
       sched_priority,  która  to  wartość musi mieścić się w zakresie od 0 do
       99. Aby  zdecydować,  który  proces  należy  uruchomić  jako  następny,
       procedura   szeregująca   poszukuje   niepustej   listy   o  najwyższym
       priorytecie statycznym i bierze proces z początku tej  listy.  Polityka
       szeregowania  zadań  określa  dla  każdego z procesów o danyej wartości
       priorytetu statycznego, gdzie zostanie on  wstawiony  na  listę  i  jak
       będzie się w jej obrębie przemieszczał.

       SCHED_OTHER   jest  domyślną,  uniwersalną  polityką  dzielenia  czasu,
       używaną przez większość procesów. SCHED_FIFO i SCHED_RR są przeznaczone
       dla  specjalnych  aplikacji,  dla  których czas jest sprawą krytyczną i
       które muszą mieć dokładną kontrolę nad sposobem, w jaki podejmowane  są
       decyzje  o  wykonywaniu  działających  procesów. Procesy korzystające z
       polityki  szeregowania  SCHED_OTHER  muszą  mieć  przypisany  priorytet
       statyczny  równy  0,  a  procesy korzystające z SCHED_FIFO lub SCHED_RR
       mogą mieć wartość tego priorytetu z  zakresu  od  1  do  99.  Priorytet
       statyczny  wyższy  niż  0  mogą  uzyskiwać  tylko  procesy działające z
       uprawnieniami superużytkownika i wobec tego tylko one mogą korzystające
       z  polityk  szeregowania  SCHED_FIFO  i  SCHED_RR.  Wywołania systemowe
       sched_get_priority_min i  sched_get_priority_max  służą  do  określania
       zakresów  priorytetów  odpowiadających  określonym  politykom  w sposób
       przenośny, właściwy dla systemów zgodnych z POSIX.1b.

       Szeregowanie  zadań  jest  wywłaszczające:  jeśli  proces   o   wyższym
       priorytecie  statycznym  staje  się gotowy do działania, proces bieżący
       zostanie wywłaszczony i wróci do swojej kolejki  oczekiwania.  Polityka
       szeregowania  zadań  określa  tylko  kolejność  na  liście działających
       procesów o tym samym priorytecie statycznym.

   SCHED_FIFO: Szeregowanie typu pierwszy na wejściu-pierwszy na wyjściu
       (First In-First Out), SCHED_FIFO, może być używane tylko ze statycznymi
       priorytetami  wyższymi  niż  0  oznaczającymi, że gdy proces SCHED_FIFO
       stanie się gotowy do działania,  to  zawsze  i  natychmiast  wywłaszczy
       wszystkie  aktualnie  działające  procesy  SCHED_OTHER. SCHED_FIFO jest
       prostym  algorytmem  szeregowania  bez  kwantowania   czasu.   Procesów
       szeregowanych  według  polityki  SCHED_FIFO dotyczą następujące reguły:
       Proces SCHED_FIFO,  który  został  wywłaszczony  przez  inny  proces  o
       wyższym priorytecie pozostanie na początku listy dla swojego priorytetu
       i jego wykonywanie zostanie wznowione,  gdy  tylko  procesy  o  wyższym
       priorytecie  zostaną  znów zablokowane. Gdy proces SCHED_FIFO staje się
       gotowy do działania, jest on wstawiany  na  koniec  listy  dla  swojego
       priorytetu.  Wywołanie  sched_setscheduler  lub  sched_setparam wstawia
       proces SCHED_FIFO (lub SCHED_RR), określony przez pid na początek listy
       (o  ile  był  on  uruchamialny).  W  wyniku  tego,  może on wywłaszczyć
       aktualnie działający proces, jeśli oba mają ten sam  priorytet.  (POSIX
       1003.1  określa,  że  proces powinien trafiać na koniec listy.)  Proces
       wywołujący sched_yield zostanie wstawiony na koniec listy.  Żadne  inne
       zdarzenia  nie  mogą  przesunąć  procesu,  szeregowanego wedłu polityki
       SCHED_FIFO, a  znajdującego  się  na  liście  procesów  oczekujących  o
       jednakowych  statycznych  priorytetach. Proces SCHED_FIFO działa dopóki
       nie zostanie  zablokowany  przez  żądanie  we/wy,  wywłaszczenie  przez
       proces o wyższym priorytecie, lub przez wywołanie (samodzielne) funkcji
       sched_yield.

   SCHED_RR: Szeregowanie typu cyklicznego (Round Robin),
       SCHED_RR,  jest  prostym   rozszerzeniem   SCHED_FIFO.   Wszystko,   co
       powiedziano  o  SCHED_FIFO,  dotyczy  także  SCHED_RR, z tym że każdy z
       procesów może działać tylko przez określony okres (kwant) czasu.  Jeśli
       proces  działający  według  polityki SCHED_RR działa przez czas dłuższy
       lub równy temu okresowi, zostanie on  wstawiony  na  koniec  listy  dla
       swojego  priorytetu.  Proces  SCHED_RR, który został wywłaszczony przez
       proces  o   wyższym   priorytecie   i   wznowił   działanie,   dokończy
       niewykorzystaną  część  cyklicznego  kwantu czasu. Długość kwantu czasu
       można odczytać za pomocą funkcji sched_rr_get_interval.

   SCHED_OTHER: Domyślne szeregowanie linuksowe,
       SCHED_OTHER, może być używane tylko ze statycznym priorytetem równym 0.
       SCHED_OTHER  jest  standardową  linuksową  procedurą szeregowania zadań
       poprzez przydzielanie  czasu,  przeznaczoną  dla  wszystkich  procesów,
       które   nie  mają  specjalnych  wymagań  odnośnie  czasu  rzeczywistego
       wymagających wykorzystania mechanizmu priorytetów statycznych.  Proces,
       który  ma  być  uruchomiony,  jest  wybierany  z  listy  dla priorytetu
       statycznego  0  w  oparciu  o  określany  jedynie  wewnątrz  tej  listy
       priorytet  dynamiczny.  Wspomniany  priorytet dynamiczny jest oparty na
       wartości "nice"  (ustawianej  za  pomocą  funkcji  systemowych  nice  i
       setpriority)  i zwiększany w każdym kwancie czasu, w którym proces jest
       gotów do  działania,  lecz  procedura  szeregująca  mu  tego  zabrania.
       Zapewnia to uczciwy postęp wszystkim procesom polityki SCHED_OTHER.

   Czas odpowiedzi
       Zablokowany  proces  o  wysokim  priorytecie,  oczekujący  na  we/wy ma
       określony czas odpowiedzi  przed  ponownym  jego  szeregowaniem.  Autor
       sterownika   urządzenia   może  znacznie  zmniejszyć  czas  odpowiedzi,
       używając procedury obsługi przerwań typu "slow interrupt".

   Różne
       Procesy potomne dziedziczą  poprzez  fork(2)  algorytm  szeregowania  i
       parametry.

       Procesom   czasu   rzeczywistego  do  unikania  opóźnień  stronicowania
       zazwyczaj potrzebne jest blokowanie pamięci. Może ono być  wykonane  za
       pomocą mlock(2) lub mlockall(2).

       Ponieważ  nieblokująca  nieskończona  pętla  w  procesie,  szeregowanym
       wegług polityki SCHED_FIFO  lub  SCHED_RR  będzie  (wiecznie)  blokować
       wszystkie procesy o niższym priorytecie, twórca oprogramowania powinien
       na konsoli zawsze  trzymać  dostępną  powłokę,  szeregowaną  z  wyższym
       priorytetem  statycznym  niż testowana aplikacja. Umożliwi ona awaryjne
       ubicie testowanych aplikacji czasu rzeczywistego,  które  nie  blokują,
       lub  nie kończą się zgodnie z oczekiwaniami. Jako że procesy SCHED_FIFO
       i SCHED_RR mogą wywłaszczać inne procesy na zawsze, tylko procesy roota
       mogą włączać te polityki szeregowania zadań.

       Systemy   POSIX-owe,   na  których  dostępne  są  sched_setscheduler  i
       sched_getscheduler, definiują w <unistd.h>  _POSIX_PRIORITY_SCHEDULING.

WARTOŚĆ ZWRACANA

       Po pomyślnym zakończeniu, sched_setscheduler zwraca zero.  Po pomyślnym
       zakończeniu, sched_getscheduler zwraca politykę dla procesu  (nieujemna
       liczba   całkowita).   Po  błędzie,  zwracane  jest  -1  i  odpowiednio
       ustawiane errno.

BŁĘDY

       ESRCH  Proces o identyfikatorze pid nie został znaleziony.

       EPERM  Proces wołający nie ma  odpowiednich  uprawnień.  Tylko  procesy
              roota  mogą  włączać  polityki  SCHED_FIFO oraz SCHED_RR. Proces
              wołający sched_setscheduler musi mieć efektywny uid  równy  euid
              lub uid procesu identyfikowanego przez pid lub musi być procesem
              superużytkownika.

       EINVAL Polityka szeregowania zadań policy nie  jest  żadną  ze  znanych
              polityk lub parametr p nie ma sensu dla danej polityki.

ZGODNE Z

       POSIX.1b (wcześniej POSIX.4)

USTERKI

       W systemie linux-1.3.81 polityka SCHED_RR nie została jeszcze dokładnie
       przetestowana i może nie zachowywać się dokładnie tak,  jak  opisano  w
       POSIX.1b.

UWAGA

       Standardowy  Linux  jest  systemem operacyjnym do ogólnych zastosowań i
       wspiera:  procesy  drugoplanowe,  aplikacje  interakcyjne  i  aplikacje
       miękkiego czasu rzeczywisyego (aplikacje, które zazwyczaj napotykają na
       nieprzekraczalne terminy w  przebiegach  czasowych).  Niniejsza  strona
       podręcznika jest zorientowana na te rodzaje aplikacji.

       Standardowy Linux nie jest zaprojektowany do obsługi aplikacji twardego
       czasu rzeczywistego, to znaczy aplikacji,  w  których  nieprzekraczalne
       terminy  (często znacznie krótsze niż sekunda) muszą być zagwarantowane
       lub system zawiedzie katastroficznie.  Podobnie, jak wszystkie  systemy
       do ogólnych zastosowań, Linux został zaprojektowany aby zmaksymalizować
       wydajność  dla  przypadków   przeciętnych,   zamiast   wydajności   dla
       przypadków  najgorszych. Wydajność Linuksa w obsłudze przerwań jest dla
       przypadków najgorszych znacznie gorsza niż dla przypadków przeciętnych.
       Jego  liczne  blokady  kernela  (takie,  jak  dla  SMP) powodują długie
       maksymalne czasy oczekiwania, a wiele z  zastosowanych  w  nim  technik
       zwiększających  wydajność,  zmniejsza  średni  czas poprzez zwiększenie
       czasu dla przypadków najgorszych.  W większości sytuacji  jest  to  to,
       czego  się  oczekuje,  lecz  gdy  rzeczywiście rozwijana jest aplikacja
       twardego czasu rzeczywistego, należy rozważyć  zastosowanie  rozszerzeń
       twardego   czasu   rzeczywistego   dla   Linuksa,  takich  jak  RTLinux
       (http://www.rtlinux.org) lub skorzystać z innego systemu  operacyjnego,
       zaprojektowanego specjalnie dla aplikacji twardego czasu rzeczywistego.

ZOBACZ TAKŻE

       sched_setaffinity(2),     sched_getaffinity(2),      sched_setparam(2),
       sched_getparam(2),      sched_yield(2),      sched_get_priority_max(2),
       sched_get_priority_min(2),      sched_rr_get_interval(2),      nice(2),
       setpriority(2),  getpriority(2),  mlockall(2), munlockall(2), mlock(2),
       munlock(2)

       Programming for  the  real  world  -  POSIX.4  Billa  O.  Gallmeistera,
       O'Reilly & Associates, Inc., ISBN 1-56592-074-0
       IEEE Std 1003.1b-1993 (standard POSIX.1b)
       ISO/IEC  9945-1:1996  -  jest  to  nowa  rewizja  (1996) POSIX.1, która
       zawiera jako jednolity tekst standardy  POSIX.1(1990),  POSIX.1b(1993),
       POSIX.1c(1995) i POSIX.1i(1995).