Provided by: manpages-pl-dev_0.5-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

        Uwaga! To tłumaczenie może być nieaktualne!

       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).

INFORMACJE O TŁUMACZENIU

       Powyższe tłumaczenie pochodzi z nieistniejącego już Projektu Tłumaczenia  Manuali  i  może
       nie  być  aktualne.  W  razie  zauważenia  różnic  między  powyższym opisem a rzeczywistym
       zachowaniem opisywanego programu lub  funkcji,  prosimy  o  zapoznanie  się  z  oryginalną
       (angielską) wersją strony podręcznika za pomocą polecenia:

              man --locale=C 2 sched_setscheduler

       Prosimy  o  pomoc  w  aktualizacji stron man - więcej informacji można znaleźć pod adresem
       http://sourceforge.net/projects/manpages-pl/.