Linux - Procesy (Processes)

Transkript

1 Linux - Procesy (Processes) Běžící instance programu se nazývá proces. Například dvě okna terminálu jsou instancemi stejného terminálového programu, ale jsou to dva různé procesy. V každém okně běží shell, který je zase jiný proces. Spuštěním programu v tomto shellu se vytvoří další nový proces. Více spolupracujících procesů v jedné aplikaci jí umožňuje dělat více věcí najednou. #include <unistd.h> typedef int pid_t; typedef pid_t pid_t; getpid(2) #include <unistd.h> pid_t getpid(void); vrací jedinečné pid aktuálního procesu Př. Napište program, který vypíše pid svého procesu. Program nemažte, budete ho rozšiřovat o další probírané funkce! getppid(2) #include <unistd.h> pid_t getppid(void); vrací jedinečné pid rodiče aktuálního procesu každý proces má rodiče (kromě procesu init), procesy jsou uspořádány do stromové struktury s procesem init jako vrcholem Př. Vypište pid rodiče. ps(1) ps [options] defaultně (bez parametrů) vypíše procesy kontrolované terminálem, ve kterém byl ps spuštěn přepínači lze určit, jaké procesy a informace o nich se mají vypsat, např. -e pro všechny procesy, -u user pro procesy uživatele user, -l pro dlouhý formát výpisu, -o pro vlastní formát, atd. Př. Vypište si všechny své procesy ve tvaru STAT USER PID PPID NICE CMD kill(1) kill pid... ukončí procesy pid... (pošle jim signál SIGTERM) Př. Spusťte si program top a ukončete ho pomocí SIGTERM. Vytvoření procesu system(3) #include <stdlib.h> int system (const char * string); spustí příkaz ve string voláním /bin/sh -c string její používání není bezpečné (blokuje některé signály), doporučuje se používat fork a exec vrací 127, pokud shell nelze spustit, -1 při jiné chybě, jinak návratový kód příkazu

2 Př. Spusťte příkaz ls -la. fork(2) #include <unistd.h> pid_t fork(void); vytvoří stejný proces jako svého potomka, který se liší jen v pid a ppid rodičovský proces i jeho potomek pokračují ve vykonávání programu od místa volání fork v rodiči vrací pid potomka, v potomkovi nulu, při chybě -1 v rodiči, potomek se nevytvoří Př. Vytvořte potomka, který vypíše svoje pid. exec(3) execve(2) #include <unistd.h> int execl( const char *path, const char *arg,...); int execlp( const char *file, const char *arg,...); int execle( const char *path, const char *arg,..., char * const envp[]); int execv( const char *path, char *const argv[]); int execvp( const char *file, char *const argv[]); int execve (const char *filename, char *const argv [], char *const envp[]); tyto funkce nahradí aktuální program jiným první argument je soubor (včetně cesty), který se má vykonat const char *arg,... jsou arg0,... spuštěného programu, poslední prvek seznamu musí být NULL char *const argv[] je seznam arg0,... spuštěného programu, poslední prvek pole musí být NULL char * const envp[] je seznam proměnných prostředí spuštěného programu, poslední prvek seznamu musí být NULL, prvky seznamu jsou očekávány ve tvaru "PROMENNA=hodnota" funkcím execvp a execlp stačí jen jméno souboru ke spuštění, který se hledá ve vyhledávací cestě (proměnná PATH) pokud se funkce ukončí (vždy -1), je to chyba Při vytváření nového procesu se nejdříve zavolá fork, který vytvoří kopii aktuálního procesu, a pak exec, který nový proces změní na instanci programu, který chceme spustit. Př. Spusťte příkaz date +%s pomocí fork a exec. Linux plánuje procesy nezávisle, není zaručeno, který poběží dřív, jak dlouho poběží. nice(1) nice [OPTION]... [COMMAND [ARG]...] spustí program s jinou prioritou (defaultně má nový proces prioritu 0) rozsah priorit je -20 (nejvyšší) až 19 (nejnižší) pro novou prioritu je přepínač -n jenom root může spustit proces se zápornou prioritou Př. Spusťte program yes s nice 5. Zkontrolujte si to pomocí ps. Zkuste -5. renice(1) renice priority [[-p] pid...] [[-g] pgrp...] [[-u] user...] změní prioritu běžících procesů procesy lze určit pomocí pid nebo všechny procesy uživatele user (defaultně pid) priority může být [+-]číslo, priority = nice jenom root může zvyšovat prioritu (snižovat nice)

3 Př. Zvyšte nice programu yes na 19. Zkontrolujte si to pomocí ps. Zkuste nice snížit. nice(2) #include <unistd.h> int nice(int inc); přidá inc k prioritě volájícího procesu jenom root může zadat záporný inc vrací 0, při chybě -1 Př. Zvyšte nice potomka. sleep(3) #include <unistd.h> unsigned int sleep(unsigned int seconds); "uspí" proces na seconds sekund, nebo ho probudí neignorovaný signál vrací 0, pokud čas uplynul, jinak zbývající počet sekund Př. Pozdržte potomka 2 sekundy a vypište datum znovu. Ukončení procesu exit(3) #include <stdlib.h> void exit(int status); normálně ukončí program, status je vrácen rodiči funkce se neukončí Př. Ošetřete neúspěšný fork pomocí exit. int main(int argc, char *argv[], char *envp[]); ukončení main je normální ukončení, návratová hodnota vrácena rodiči návratová hodnota funkce main je sice int, ale používat by se měly jen hodnoty 0-127, kódy nad 128 včetně mají speciální význam - když je proces ukončen signálem, návratová hodnota je číslo signálu Př. Ukončete korektně rodiče i potomka návratem z main. abort(3) #include <stdlib.h> void abort(void); abnormálně (s core souborem) ukončí program funkce se neukončí Př. Ošetřete neúspěšný exec pomocí abort. Potomek může proběhnout až po ukončení předka, protože oba procesy jsou plánovány nezávisle. To je někdy nežádoucí, někdy chceme, aby rodič počkal, až se potomek ukončí. wait(2) #include <sys/types.h> #include <sys/wait.h> pid_t wait(int *status) zastaví proces, dokud se neukončí nějaký potomek, nebo pokud proces dostane ukončující signál nebo se volá nějaký signal-handler pokud už potomek skončil (zombie), funkce se hned ukončí, všechny prostředky systému přidělené potomkovi

4 jsou uvolněny pokud status není NULL, na místo, kam ukazuje, se uloží informace o potomkovi vrací pid potomka, při chybě -1 Př. V rodiči počkejte na potomka. waitpid(2) #include <sys/types.h> #include <sys/wait.h> pid_t waitpid(pid_t pid, int *status, int options); zastaví proces, dokud se neukončí potomek s ID pid, nebo pokud proces dostane ukončující signál nebo se volá nějaký signal-handler pokud už potomek skončil (zombie), funkce se hned ukončí, všechny prostředky systému přidělené potomkovi jsou uvolněny pokud status není NULL, na místo, kam ukazuje, se uloží informace o potomkovi pokud je pid -1, funkce se chová jako wait vrací pid potomka, při chybě -1, nebo 0, pokud žádný potomek neskončil a v options bylo WNOHANG Ze status (int) lze získat různé informace o potomkovi těmito makry: WIFEXITED(status) vrací nenulové číslo, pokud potomek spončil normálně WEXITSTATUS(status) vrací návratový kód potomka smí se vyhodnotit, jen pokud WIFEXITED je nenulové Př. Vypište návratový kód potomka. WIFSIGNALED(status) vrací nenulové číslo, pokud potomka ukončil signál WTERMSIG(status) vrací číslo signálu, který ukončil potomka smí se vyhodnotit, jen pokud WIFSIGNALED je nenulové Zombie procesy Co se stane, když potomek skončí a rodič na něj nečeká voláním wait? Informace o jeho ukončení budou dočasně ztraceny a z něj se stane zombie. Zombie je proces, který skončil, ale ještě nebyl ze systému odstraněn, to je povinnost rodiče. Potom, co se proces ukončí, stane se z něj zombie, dokud si informace o jeho ukončení nevyzvedne jeho rodič pomocí wait. Pokud si rodič tyto informace nevyzvedne nikdy (ani po svém ukončení), zombie adoptuje proces init a odstraní jej ze systému. OTÁZKA: Co se s potomkem stane, když rodič skončí dřív než on? Bude bez rodiče? PŘÍKLAD Další funkce týkající se procesů jsou: getuid(2) / setuid(2) geteuid(2) / seteuid(2) getgid(2) / setgid(2) getegid(2) / setegid(2) clone(2) vfork(2) getpriority(2) / setpriority(2)

5 wait3(2) wait4(2) Linux - Signály (Signals) Signály je mechanizmus pro komunikaci a manipulaci s procesy. Signál je speciální zpráva zaslaná procesu. Signály jsou asynchronní, tj. když jej proces obdrží, ihned ho obslouží, bez dokončení aktuální funkce (ta se dokončí až pak). Každý signál je specifikován svým číslem, v programech se však používají jména definovaná v <bits/signum.h>. Všechny signály jsou pak popsány v signal(7). Zaslání signálu raise(3) #include <signal.h> int raise (int sig); pošle signál sig vlastnímu procesu vrací 0, při chybě nenulové číslo Př. Vytvořte program, který si pošle SIGTERM a tím se tedy ukončí. Program nemažte, budete ho rozšiřovat o další probírané funkce! Proces může poslat signál jinému procesu. Např. ho ukončit zasláním SIGTERM nebo SIGKILL. OTÁZKA: Jaký je rozdíl mezi SIGTERM a SIGKILL? kill(1) kill [signal] pid... pošle každému procesu (pid) SIGTERM (pokud není signal zadán), nebo signál signal přepínač -l vypíše všechny signály Př. Spusťte si program top a zabijte ho pomocí SIGKILL. kill(2) #include <sys/types.h> #include <signal.h> int kill(pid_t pid, int sig); pošle signál sig procesu s ID pid vrací 0, při chybě -1 Př. Nahraďte funkci raise funkcí kill. Pro zaslání příkazu procesu jsou rezervovány dva uživatelské signály, SIGUSR1 a SIGUSR2. Někdy se pro tento účel používá i SIGHUP, na "probuzení" nebo "restart" programu. strsignal(3) #define _GNU_SOURCE #include <string.h> char *strsignal(int sig); vrátí řetězec popisující singál s číslem sig psignal(3) #include <signal.h> void psignal(int sig, const char *s); napíše na stderr zprávu tvaru s: sig_d, kde sig_d je popis signálu sig

6 pause(2) #include <unistd.h> int pause(void); "uspí" proces, dokud nepřijde signál při přerušení (signálem) vrací -1 Př. Uspěte program a z jiného terminálu mu pošlete SIGCONT. Obdržení signálu Co proces udělá po obdržení signálu záleží na určení signálu. Každý signál má defaultní určení, která určuje, co se stane, když program nestanovuje jinak. Pro většinu signálů jej může program ignorovat nebo zavolat speciální funkci (signal-handler). Při volání handleru se program zastaví, vykoná se handler a pak program pokračuje. Např. SIGBUS (bus error), SIGSEGV (segmentation violation) a SIGFPE (floating point exception) jsou zaslány procesu, když se pokouší provést nepřípustnou akci. Defaultní určení signálu je ukončení procesu a vytvoření core souboru. signal(2) #define _GNU_SOURCE #include <signal.h> typedef void (*sighandler_t)(int); sighandler_t signal(int signum, sighandler_t action); instaluje nový signal-handler pro signál s číslem signum action může být: signal-handler funkce SIG_IGN pro ignorování signálu SIG_DFL pro defaultní určení signálu parametr signal-handler funkce je číslo signálu defaultní určení signálů jsou popsány v signal(7) nelze instalovat handler na SIGKILL a SIGSTOP sighandler_t je GNU rozšíření vrací předchozí signal-handler, nebo při chybě SIG_ERR Př. Napište signal-handler, který bude bude počítat, kolik signálů SIGTERM program dostane. Při SIGQUIT se ukončí a vypíše počet obdržených signálů SIGTERM. Pošlete programu pár signálů SIGTERM a pak SIGQUIT. Protože signály jsou asynchronní, program by mohl být při zpracovávání signálu v nekonzistentním stavu a proto by se v signal-handleru neměly volat knihovní a systémové funkce a vykonávat I/O operace. signal-handler by měl vykonat jen práci nezbytně nutnou k ošetření signálu. Je možné, že signal-handler bude přerušen obdržením jiného signálu. Pokud se to stane, je velmi těžké to debugovat, pokud je tam chyba, proto by se měl dávat velký pozor na to, co se v signal-handleru provádí. Nebezpečné je dokonce i přiřazení do globální proměnné, protože může probíhat ve více instrukcích, a druhý signál se může vyskytnout mezi nimi. Tato globální proměnná by měla být typu sig_atomic_t, do kterého se přiřazuje v jedné instrukci (protože je to int). #include <signal.h> typedef int sig_atomic_t; typedef sig_atomic_t sig_atomic_t; Př. Proměnnou, ve které počítáte počet signálů SIGTERM, změňte na typ sig_atomic_t. alarm(2) #include <unistd.h> unsigned int alarm(unsigned int seconds); pošle procesu SIGALRM za seconds sekund pokud seconds je 0, nic se nenačasuje vrací zbývající počet sekund do zaslání signálu, nebo 0, pokud není načasován žádný alarm

7 Př. Zařiďte, aby se program sám ukončil po 10 sekundách běhu. Procesy a signály Proces může skončit abnormálně, jako odpověď na signál. Např. SIGBUS, SIGSEGV a SIGFPE způsobí ukončení procesu. Další signály slouží k explicitnímu ukončení. SIGINT je procesu zaslán, když se jej uživatel snaží ukončit pomocí C-C. SIGTERM posílá kill. Při volání funkce abort si proces sám pošle SIGABRT, což jej také ukončí s core souborem. Nejmocnější je SIGKILL, který jej okamžitě ukončí a program tomu nemůže nijak zabránit (blokovat, ingnorovat, ošetřit). Čekání na potomka pomocí wait proces blokuje, dokud se potomek neukončí. Většinou ale chceme, aby i rodič pokračovat dál. Jak se ale postarat o potomka ihned po jeho ukončení, tak, aby nezůstávali zombie? Jedna možnost je periodicky volat wait3 nebo wait4, které lze volat i v neblokujícím módu. Mnohem lepší je ale rodiče informovat o ukončení potomka, pomocí signálu. Když se ukončí potomek, systém pošle rodiči signál SIGCHLD, který defaultně nemá žádné určení. Funkci wait tedy zavoláme v signal-handleru signálu SIGCHLD. PŘÍKLAD Další funkce týkající se signálů jsou: sigaction(2) sigprocmask(2) sigpending(2) sigsuspend(2) sigblock(2) siggetmask(2) sigsetmask(2) sigmask(2) siginterrupt(2) sigpause(2) Linux - Vlákna (Threads) Vykonávání programu může být rozděleno do více "proudů", vláken, které běží paralelně. Vlákna tedy, stejně jako procesy, umožňují aplikaci dělat více věcí najednou. Vlákno existuje uvnitř procesu. Při spuštění programu se vytvoří proces a v něm jedno vlákno, které může spustit další. Všechna tato vlákna běží paralelně ve stejném procesu, ale mohou vykonávat různé části (kód) programu. Dvě různá vlákna téhož procesu sdílejí stejnou paměť, deskriptory souborů a jiné systémové zdroje přidělené celému procesu. Protože proces a všechna jeho vlákna vykonávají jeden program, když jedno vlákno zavolá exec, všechna ostatní vlákna jsou ukončena. GNU/Linux implementuje API vláken podle standardu POSIX (pthreads). Všechny funkce a datové typy jsou deklarovány v <pthread.h>. Funkce nejsou ve standardní C knihovně, ale v knihovně libpthread, takže je potřeba linkovat s parametrem -lpthread. Vytvoření vlákna #include <bits/pthreadtypes.h> typedef unsigned long int pthread_t; pthread_self(3) pthread_t pthread_self(void); vrací id vlákna Př. Napište program, který vypíše ID svého hlavního vlákna. Program nemažte, budete ho rozšiřovat o další probírané funkce! pthread_equal(3)

8 int pthread_equal(pthread_t thread1, pthread_t thread2); vrací nenulové číslo, když thread1 a thread2 jsou id téhož vlákna, jinak 0 Po spuštění každé vlákno vykonává funkci vlákna. Když tato funkce skončí, skončí i vlákno. Má jediný parametr void*, vrací také void*. pthread_create(3) int pthread_create(pthread_t * thread, pthread_attr_t * attr, void * (*start_routine)(void *), void * arg); vytvoří nové vlákno, které vykoná funkci start_routine s parametrem arg attr specifikuje atributy vlákna (viz pthread_attr_init), pokud je NULL, jsou defaultní: joinable, defaultní priorita vrací 0 a id vlákna na místo, kam ukazuje argument thread, při chybě nenulové číslo funkce se vrací ihned, obě vlákna pak pokračují asynchronně Př. Vytvořte vlákno s defaultními atributy a bez parametrů funkce vlákna. Při vytváření atributů vlákna se postupuje takto: vytvoří se struktura pthread_attr_t pomocí pthread_attr_init se inicializuje na defaultní hodnoty změní se hodnoty ve struktuře zavolá se pthread_create a předá se jí tato struktura pthread_attr_destroy strukturu zruší, ale nedealokuje (pokud je vytvořena dynamicky) S jednou strukturou je možné vytvořit více vláken a je možné ji zrušit po vytvoření vlákna. pthread_attr_init(3) int pthread_attr_init(pthread_attr_t *attr); inicializuje strukturu atributů defaultními hodnotami vrací 0, při chybě nenulové číslo pthread_attr_destroy(3) int pthread_attr_destroy(pthread_attr_t *attr); zruší strukturu atributů, před dalším použitím se musí znova inicializovat vrací 0, při chybě nenulové číslo v Linuxu nedělá nic pthread_attr_setdetachstate(3) pthread_attr_getdetachstate(3) int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate); int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate); nastaví(vrací) atribut z(do) druhého parametru vrací 0, při chybě nenulové číslo atribut detachstate může být: PTHREAD_CREATE_JOINABLE - vlákno bude joinable, defaultní PTHREAD_CREATE_DETACHED - detached Joinable vlákno není po skončení automaticky odstraněno ze systému, jeho status ukončení je udržován, dokud si ho nevyzvedne jiné vlákno pomocí pthread_join (stejné jako zombie u procesu). Detached vlákno je naopak hned po skončení automaticky odstraněno a nelze získat jeho informace o ukončení pomocí pthread_join.

9 Př. Změňte vytvářené vlákno na detached. Typ argumentu funkce vlákna je void*, nelze tedy poslat data (>4B) přímo. Předává se ukazatel na strukturu dat. Tato struktura ale nesmí být lokální v jednom vláknu (př. hlavním), protože by mohlo skončit dříve než ostatní, která tuto strukturu používají. Pokud je lokální, možným řešením je ve vláknu počkat, až ostatní vlákna skončí. Struktura se nesmí dealokovat dřív, než vlákna, která ji používají, skončí. Př. Předejte funkci vlákna 2 řetězce jako parametry, ty spojte a výsledek vraťte jako návratovou hodnotu funkce vlákna. pthread_join(3) int pthread_join(pthread_t th, void **thread_return); pozastaví vlákno, dokud neskončí vlákno specifikované pomocí th pokud thread_return není NULL, vrátí návratovou hodnotu funkce vlákna na místo, kam ukazuje, pokud je vlákno zrušeno, je tam PTHREAD_CANCELED jen jedno vlákno může čekat na skončení jiného vlákna vrací 0, při chybě nenulové číslo vlákno nesmí čekat samo na sebe, to je deadlock! Př. Počkejte na dokončení vlákna a vypište výsledek spojení. pthread_detach(3) int pthread_detach(pthread_t th); "přepne" vlákno na detached, pokud jiné vlákno nečeká na jeho ukončení vrací 0, při chybě nenulové číslo Ukončení vlákna pthread_exit(3) void pthread_exit(void *retval); ukončí vlákno s návratovým kódem retval nikdy se neukončuje pthread_cancel(3) int pthread_cancel(pthread_t thread); pošle vláknu, specifikovanému pomocí thread, požadavek na ukončení vrací 0, při chybě nenulové číslo Vlákno často vykonává kód, který nesmí být přerušen. To je zajištěno tím, že vlákno samo si může určit místa, kde může být zrušeno a kde ne, pomocí svého stavu: asynchronně zrušitelné - může být zrušeno kdekoliv synchronně zrušitelné - může být zrušeno až v určitých místech (body zrušení), požadavek je zaznamenán, defaultní při vytvoření vlákna nezrušitelné - požadavky na zrušení jsou ignorovány pthread_setcanceltype(3) int pthread_setcanceltype(int type, int *oldtype); změní typ reakce na zrušení vlákna na type type může být: PTHREAD_CANCEL_ASYNCHRONOUS - asynchronní

10 PTHREAD_CANCEL_DEFERRED - synchronní pokud oldtype není NULL, na místo, kam ukazuje, je uložen předchozí typ vrací 0, při chybě nenulové číslo pthread_testcancel(3) void pthread_testcancel(void); vytvoří bod zrušení existují implicitní body zrušení (viz man), př. pthread_join Př. Změňte vlákno na synchronně zrušitelné a vytvořte body zrušení před a po spojení. pthread_setcancelstate(3) int pthread_setcancelstate(int state, int *oldstate); změní stav zrušení vlákna na state state může být: PTHREAD_CANCEL_ENABLE - zrušitelný stav PTHREAD_CANCEL_DISABLE - nezrušitelný pokud oldstate není NULL, na místo, kam ukazuje, je uložen předchozí stav vrací 0, při chybě nenulové číslo umožňuje vymezení kritických sekcí - nepřerušitelný kód Př. Uzavřete spojení do kritické sekce. PŘÍKLAD Lokální uložení dat Vlákna sdílejí stejný adresový prostor. Někdy je ale potřeba, aby každé vlákno mělo vlastní kopii určité globální proměnné. Každé vlákno poskytuje lokální uložení dat (thread-specific data - TSD - area), kde se ukládají kopie globálních proměnných specifické pro každé vlákno. Proměnné v tomto uložení jsou indexovány přes klíče. Klíče jsou společné všem vláknům, hodnota proměnné je v každém vláknu jiná. pthread_key_create(3) int pthread_key_create(pthread_key_t *key, void (*destr_function) (void *)); vytvoří nový TSD klíč a uloží ho, kam ukazuje key, asociovaná hodnota je NULL pokud destr_function není NULL, je to funkce, která se zavolá po ukončení vlákna s hodnotou asociované proměnné jako parametrem, před jejím voláním je ke klíči asociován NULL vrací 0, při chybě nenulovou hodnotu pthread_key_delete(3) int pthread_key_delete(pthread_key_t key); zruší TSD klíč vrací 0, při chybě nenulovou hodnotu pthread_setspecific(3) int pthread_setspecific(pthread_key_t key, const void *pointer); změní hodnotu proměnné asociované s klíčem key na pointer

11 vrací 0, při chybě nenulovou hodnotu pthread_getspecific(3) void * pthread_getspecific(pthread_key_t key); vrací hodnotu proměnné asociované s klíčem key, při chybě NULL PŘÍKLAD OTÁZKA: Procesy versus vlákna? Najděte co nejvíc rozdílů. Další funkce týkající se vláken jsou: pthread_cleanup_push(3) / pthread_cleanup_pop(3) pthread_setschedparam(3) / pthread_getschedparam(3) pthread_kill(3) pthread_sigmask(3) sigwait(3) Linux - Meziprocesní komunikace (Interprocess communication, IPC) Nejjednodušší forma IPC je, že rodič může zjistit, jak skončil jeho potomek. Rodič může potomkovi sdělit informace také přes jeho argumenty a proměnné prostředí. Žádný z těchto mechanizmů ale rodiči neumožňuje s potomkem komunikovat za jeho běhu a už vůbec neumožňuje komunikaci dvou procesů, které nejsou ve vztahu rodič-potomek. Za určitý primitivní druh komunikace se dají považovat signály, ale "skutečná" komunikace znamená výměna informací čili dat. Např. klasické balení souboru dvojicí tar+gzip, tar cf - * gzip - > soubor.tar.gz, využívá mechanizmu roury (pipes). Druhy IPC se liší těmito kritérii: zda komunikují dva příbuzné (mající společného rodiče) nebo zcela cizí procesy zda komunikující proces může jen číst či jen zapisovat data počet procesů zapojených do komunikace zda jsou komunikující procesy synchronizovány, např. čtecí proces čte, až je co číst Sdílená paměť (Shared memory) Jednou z nejjednodušších metod IPC je sdílená paměť, která umožňuje dvěma a více procesům přistupovat ke stejné oblasti paměti. Sdílená paměť je nejrychlejší formou IPC, protože procesy sdílí stejnou paměť a pro přístup do ní není potřeba žádné systémové volání. Protože ale systém neposkytuje žádnou formu synchronizace, musíme si ji zajistit sami. Např. dva procesy by neměly zapisovat zároveň na stejné místo v paměti. Tradičním nástrojem pro synchronizaci jsou semafory. Pro použití sdílené paměti ji jeden proces musí alokovat. Všichni si ji pak "připojí". Po používání ji "odpojí" a ten proces, který ji alokoval, ji dealokuje. Sdílená paměť se alokuje po celočíselných násobcích velikosti stránky paměti. getpagesize(2) #include <unistd.h> size_t getpagesize(void); vrací velikost (počet bytů) stránky paměti systému shmget(2) #include <sys/ipc.h> #include <sys/shm.h> int shmget(key_t key, int size, int shmflg); je vytvořen úsek paměti velikosti nahoru zaokrouhlené size na násobek stránky, pokud v key je IPC_PRIVATE anebo ke key není asociován žádný úsek sdílené paměti, a v shmflg je IPC_CREAT key je libovolný zvolený číselný klíč

12 v shmflg může být: IPC_CREAT - vytvoří nový úsek, pokud toto není, najde se úsek asociovaný ke klíči key IPC_EXCL - používá se s IPC_CREAT, chyba pokud úsek existuje mode_flags - specifikuje práva k úseku, definována v <sys/stat.h>, může být: S_IRUSR, S_IWUSR - čtení, zápis pro vlastníka úseku S_IROTH, S_IWOTH - pro ostatní vrátí identifikátor sdílené paměti asociovaný ke klíči key, při chybě -1 existují limity pro úsek sdílené paměti, viz man Př. Napište program, který vytvoří sdílenou paměť o velikosti stránky paměti s právy zápisu pro sebe a čtení pro ostatní. Potomek po fork zdědí připojené úseky, po exec a exit jsou všechny připojené úseky odpojeny, ale ne dealokovány! shmat(2) #include <sys/types.h> #include <sys/shm.h> void *shmat ( int shmid, const void *shmaddr, int shmflg ); připojí úsek sdílené paměti identifikovaný identifikátorem shmid na adresu shmaddr pokud je shmaddr NULL, systém si sám najde volnou adresu pokud je v shmflg SHM_RND, adresa se zaokroulí dolů na násobek stránky, jinak adresa musí být už zaokrouhlená pokud je v shmflg SHM_RDONLY, pameť je připojena jen pro čtení, jinak i pro zápis (pokud to práva dovolují) při chybě vrací -1, jinak adresu připojené paměti Př. Uložte něco (např. text) do sdílené paměti. shmdt(2) #include <sys/types.h> #include <sys/shm.h> int shmdt ( const void *shmaddr); odpojí sdílenou paměť na adrese shmaddr, paměť musí být připojená při chybě vrací -1, jinak 0 Př. Před ukončením programu sdílenou paměť odpojte. shmctl(2) #include <sys/ipc.h> #include <sys/shm.h> int shmctl(int shmid, int cmd, struct shmid_ds *buf); zjistí informace o úseku (identifikovaného pomocí shmid) sdílené paměti, mění práva a dealokuje úsek informace vrací do struktury shmid_ds, viz man cmd může být: IPC_STAT - vrací informace, potřebuje právo na čtení úseku IPC_SET - nastavuje práva IPC_RMID - označí úsek pro zrušení, ten se zruší až po posledním odpojení, zrušit úsek může jen ten, kdo ho vytvořil nebo root vrací 0, při chybě -1 Př. Vytvořte potomka, který si zjistí informace o této paměti a z nich vypíše její velikost, pak přečte, co tam rodič zapsal a vypíše to. Každý úsek sdílené paměti musí být explicitně zrušen, protože systém ji nezruší ani po ukončení procesů! Př. Před ukončením programu sdílenou paměť zrušte.

13 ipcs(8) ipcs -m vypíše úseky sdílené paměti Př. Podívejte se, zda v systému nezůstaly úseky nepoužívané sdílené paměti. ipcrm(8) ipcrm shm id... zruší úseky sdílené paměti specifikované pomocí id Př. Zrušte úseky nepoužívané sdílené paměti. PŘÍKLAD Mapovaná paměť (Mapped memory) Mapovaná paměť umožňuje různým procesům komunikovat přes sdílený soubor. Může se zdát, že je to stejné jako sdílená paměť, ale jsou zde technické rozdíly. Mapovaná paměť se dá použít jak pro komunikaci, tak pro jednoduchý přístup do souboru. Linux rozdělí soubor na paměťové stránky a ty zkopíruje do paměti, takže proces k nim může přistupovat jako do paměti, číst i zapisovat. mmap(2) #include <unistd.h> #include <sys/mman.h> caddr_t mmap(void *start, size_t length, int prot, int flags, int fd, off_t offset); namapuje length bytů na offsetu offset ze souboru specifikovaném deskriptorem fd na adresu start (v praxi se ovšem dává NULL - systém sám vybere adresu) prot specifikuje práva: PROT_EXEC - z paměti lze spouštět PROT_READ - číst PROT_WRITE - zapisovat flags určuje typ mapování, může být jen jedno z: MAP_SHARED - sdílení mapování souboru s ostatními procesy, které ho mapují také, zápis je nebufferovaný, okamžitý MAP_PRIVATE - privátní mapování vrací ukazatel na mapovanou paměť, při chybě -1 munmap(2) #include <unistd.h> #include <sys/mman.h> int munmap(void *start, size_t length); zruší mapování paměti na adrese start délky length vrací 0, při chybě -1 mapovaná paměť se automaticky zruší po skončení procesu Různé procesy mohou komunikovat použitím mapované paměti téhož souboru a použití MAP_SHARED. Stejně jako u sdílené paměti je potřeba explicitně zajistit synchronizaci, např. semafory nebo zamykáním souboru. Časté použití mapované paměti je také pro rychlé čtení a zápis do souboru nebo ukládání datových struktur do souboru. OTÁZKA: Když ukládaná datová struktura obsahuje ukazatele, po načtení této struktury budou tyto ukazatele neplatné. Proč? Jaké shody okolností by musely nastat, aby byly platné? PŘÍKLAD Další funkce týkající se sdílené nebo mapované paměti jsou: msync(2)

14 Roury (Pipes) Roura umožňuje jednosměrnou komunikaci. Data zapsaná do "zapisovacího konce" jsou čtena z "čtecího konce". Roury jsou sériová zařízení, data jsou čtena ve stejném pořadí, v jakém byla zapsána. Používají se ke komunikaci dvou vláken jednoho procesu nebo mezi rodičovským procesem a potomky. V shellu symbol vytvoří rouru. Např. ls less vytvoří dva potomky shellu, ls a less. Shell také vytvoří rouru spojující standardní výstup ls se standardním vstupem less. Kapacita roury je omezená. Pokud zapisující proces zapisuje rychleji než čtecí proces čte a roura už nemůže uchovat data, zapisovací proces je blokován, dokud se neuvolní místo. Pokud se proces pokouší číst z roury, ale není co číst, je blokován, dokud nebude co číst. Roura tedy automaticky synchronizuje dva procesy. pipe(2) #include <unistd.h> int pipe(int filedes[2]); vytvoří dva deskriptory souboru, ukazující na konce roury, a uloží je do filedes filedes[0] je pro čtení, filedes[1] pro zápis vrací 0, pří chybě -1 Deskriptory souboru, které vytvoří pipe, jsou platné jen v procesu a jeho potomcích. Při volání fork jsou deskriptory kopírovány do potomka, proto roura může spojovat pouze příbuzné procesy. Po volání fork mají jak rodič tak i potomek oba konce roury. Roura jako komunikační zařízení má však jen dva konce, proto se musí v rodiči i v potomkovi nepoužívané konce ihned uzavřít. Zvláště existence dvou zapisovacích konců roury způsobuje podivné chování. Při čtení z roury, která má zapisovací konec uzavřený, vrací read hodnotu 0. A při zápisu do roury, která má uzavřený čtecí konec, obdrží proces signál SIGPIPE. Př. Napište program, který vytvoří rouru a potomka. Jeden proces pak do roury něco zapíše, druhý to přečte a vypíše. K otevření konce roury ve formě streamu (FILE *) použijte funkci fdopen, k uzavření zase close. Často je potřeba vytvořit potomka tak, aby jeden konec roury byl jeho standardní vstup nebo výstup. dup(2) dup2(2) #include <unistd.h> int dup(int oldfd); int dup2(int oldfd, int newfd); funkce vytvoří kopii deskriptoru oldfd starý i nový deskriptor jsou zaměnitelné, sdílejí zámky, pozici, nesdílejí příznak uzavření při ukončení procesu dup2 vytvoří kopii jako newfd, který popřípadě nejdřív uzavře vrací nový deskriptor, při chybě -1 Př. Přesměrujte std. vstup potomka na čtecí konec roury a změňte program potomka na sort. V rodiči do roury zapište několik vět. Roura má buffer určité velikosti, proto po zápisu vět zavolejte fflush. Deskriptor std. vstupu je STDIN_FILENO. Běžné použítí rour je zasílání nebo příjímání dat od programu, který běží jako potomek. K vytvoření tohoto stavu je potřeba volat postupně funkce pipe, fork, dup2, exec a fdopen. Volání všech těchto funkcí nahrazují funkce popen a pclose. popen(3) #include <stdio.h> FILE *popen(const char *command, const char *type); vytvoří proces voláním pipe, fork a spuštěním shellu type může být jen jedno z: "r" - proces bude číst data od potomka, funkce vrátí standardní výstup potomka "w" - proces bude zapisovat data pro potomka, funkce vrátí standardní vstup potomka command je příkaz pro shell, spuštěn pomocí /bin/sh -c command vytvořený stream by měl být uzavřen pomocí pclose, ne fclose

15 při chybě (fork, pipe nebo alokace paměti) vrací NULL pclose(3) #include <stdio.h> int pclose(file *stream); uzavře stream vytvořený pomocí popen, čeká, až se spuštěný příkaz ukončí vrací návratový kód spuštěného příkazu, při chybě -1 Př. Poslední úkol (sort) proveďte pomocí popen a pclose. PŘÍKLAD FIFO FIFO (First In, First Out) je roura, která je souborem. Jakýkoliv proces může číst nebo zapisovat do FIFO, procesy nemusí být příbuzné. FIFO musí být otevřená pro čtení i zápis dřív, než se z ní může něco číst nebo do ní zapisovat. Otevření pro čtení proces blokuje, dokud ji neotevře jiný proces pro zápis a opačně. FIFO se někdy nazývá pojmenovaná roura. mkfifo(1) mkfifo [OPTION] NAME... vytvoří FIFO se jménem NAME volbou -m (--mode) se nastavují práva, která musí obsahovat práva čtení a zápisu Př. Vytvořte FIFO, např. /tmp/fifo. V jednom terminálu z ní čtěte pomocí cat < /tmp/fifo. V jiném do ní zapisujte pomocí cat > /tmp/fifo a zadávejte věty (ukončené ENTER). Sledujte, jak se věty vypisují v prvním terminálu. Zadávání vět ukončete pomocí C-D. Smažte FIFO. mkfifo(3) #include <sys/types.h> #include <sys/stat.h> int mkfifo ( const char *pathname, mode_t mode ); vytvoří FIFO se jménem pathname mode specifikuje práva, která musí obsahovat práva čtení a zápisu, stejné jako u funkce open s FIFO se pracuje jako s obyčejným souborem, tj. open, read, write, close (low-level I/O) nebo fopen, fread, fwrite, fclose (I/O C knihovny) vrací 0, při chybě -1 Z FIFO může číst nebo do ní zapisovat více procesů. Data z každého zapisujícího procesu jsou zapisována atomicky. Další funkce týkající se rour nebo FIFO jsou: Linux - Synchronizace (Synchronization) Programování vláken není jednoduché. Není způsob, jak předem zjistit, kdy systém spustí jedno vlákno a kdy druhé. Debugování vícevláknového programu je těžké, protože nelze vždy reprodukovat chybné chování. Většina problémů je způsobena tím, že vlákna přistupují ke stejným datům. Na jednu stranu je to velká výhoda vláken, ale na druhou stranu to může být nebezpečné. Když je jedno vlákno v půli cesty při zapisování (čtení) dat a druhé je čte (zapisuje), pravděpodobně vznikne chyba. Často program funguje jen pokud vlákno běží dříve nebo později než jiné vlákno. Chyby, které vznikají v důsledku nesprávného pořadí vykonávání vláken, se nazývají race conditions (chyby souběhu), vlákna soutěží o to, které poběží dřív. K eliminování race conditions je potřeba zajistit, aby se vlákna vykonávala ve správném pořadí nebo aby se některé operace prováděly atomicky, tzn. je potřeba vlákna synchronizovat. Atomická operace je nerozdělitelná a nepřerušitelná, když začne, nebude zastavena nebo přerušena, dokud se neukončí. Semafory pro vlákna (Semaphores for threads) Semafor je "počítadlo" umožňující synchronizaci více vláken. Systém zaručuje, že zjištění nebo modifikování hodnoty

16 semaforu je atomická operace. Hodnota semaforu je nezáporné číslo, umožňuje dvě operace: čekání (wait) - sníží hodnotu semaforu o 1. Pokud je hodnota 0, operace je blokována, dokud nebude hodnota kladná. Až bude kladná, sníží se o 1 a čekání končí. nastavení (post) - zvýší hodnotu semaforu o 1. Pokud byla hodnota 0 a nějaká vlákna jsou blokována při čekání na tento semafor, jedno z nich je odblokováno a jeho čekání se ukončí (a hodnota semaforu se vrátí na 0). Semafory pro vlákna jsou implementovány podle standardu POSIX, hlavičkový soubor je <semaphore.h>. sem_init(3) #include <semaphore.h> int sem_init(sem_t *sem, int pshared, unsigned int value); inicializuje semafor, na který ukazuje sem, na hodnotu value pshared specifikuje, zda je semafor lokální pro aktuální proces (0), nebo zda se má sdílet s ostatními procesy (!0), na Linuxu tohle ale není implementováno, musí být vždy 0 vrací 0, při chybě -1 sem_destroy(3) #include <semaphore.h> int sem_destroy(sem_t * sem); zruší semafor, na který ukazuje sem žádné vlákno by na semafor nemělo čekat, jinak chyba vrací 0, při chybě -1 sem_wait(3) #include <semaphore.h> int sem_wait(sem_t * sem); operace wait bod zrušení vlákna vrací vždy 0 sem_trywait(3) #include <semaphore.h> int sem_trywait(sem_t * sem); neblokující operace wait, pokud má semafor hodnotu 0, vrací se s chybou vrací 0, při chybě -1 sem_post(3) #include <semaphore.h> int sem_post(sem_t * sem); operace post nikdy neblokuje a může se bezpečně používat v asynchronních signal-handlerech vrací 0, při chybě -1 sem_getvalue(3) #include <semaphore.h> int sem_getvalue(sem_t * sem, int * sval); uloží aktuální hodnotu semaforu na místo, kam ukazuje sval neměla by se používat k rozhodnutí operace se semaforem, může to vést k race condition: jiné vlákno může změnit hodnotu semaforu mezi touto funkcí a operací vrací vždy 0

17 Př. Napište program, ve kterém vytvoříte vlákno. Jedno vlákno bude něco zapisovat do společného bufferu (naplní ho), druhé z něho číst (vyprázdní ho). Synchronizujte tyto dvě vlákna semafory tak, aby se zapisovalo, jen když je buffer prázdný, a četlo, jen když je plný, a do bufferu v danou chvíli přistupovalo jen jedno vlákno. Semafory pro procesy (Semaphores for processes) Procesy musí koordinovat přístup např. do společné sdílené a mapované paměti. Semafory jsou alokovány, používány a dealokovány stejně jako úseky sdílené paměti, jsou také součástí systémových volání původního unixového systému System V IPC (poslední jsou fronty zpráv). I když ve většině případů stačí jeden semafor, semafory pro procesy existují po množinách. semget(2) #include <sys/types.h> #include <sys/ipc.h> #include <sys/sem.h> int semget ( key_t key, int nsems, int semflg ) vytvoří množinu nsems semaforů ke klíči key, pokud v key je IPC_PRIVATE, nebo pokud ke klíči key již neexistuje množina semaforů a v semflg je IPC_CREAT v semflg může být: IPC_CREAT - vytvoří novou množinu semaforů, pokud toto není, najde se množina asociovaná ke klíči key IPC_EXCL - používá se s IPC_CREAT, chyba pokud množina semaforů s klíčem key existuje práva přístupu - definovaná v <sys/stat.h>, může být: S_IRUSR, S_IWUSR - čtení, změna pro vlastníka množiny semaforů S_IROTH, S_IWOTH - pro ostatní nsems může být 0, pak se nic nevytvoří, nebo kladné číslo udávající počet semaforů v množině vrací identifikátor množiny semaforů, jinak -1 existuje limit počtu semaforů v množině, viz man Semafory existují i když skončí všechny procesy, které je používají. Proces, který semafory vytvořil, je také musí dealokovat, jinak systému dojdou. Kromě alokace je potřeba semafory také inicializovat. semctl(2) #include <sys/types.h> #include <sys/ipc.h> #include <sys/sem.h> int semctl (int semid, int semnum, int cmd, union semun arg) zjistí informace o množině semaforů (identifikované pomocí semid) nebo o jednom semaforu, mění její práva, dealokuje ji a inicializuje ji strukturu semun si většinou musíme deklarovat sami, viz man cmd může být: IPC_STAT - vrací informace do semid_ds struktury arg.buf, viz man, potřebuje právo čtení IPC_SET - nastavuje práva IPC_RMID - ihned zruší množinu semaforů (a odblokuje všechny čekající procesy), může jen ten (uživatel), který ji vytvořil nebo vlastník (nebo root) GETALL - vrátí hodnotu všech semaforů do arg.array GETVAL - vrátí hodnotu semnum-tého semaforu (první je 0-tý) SETALL - nastaví hodnoty všech semaforů podle arg.array, čekající procesy jsou odblokovány SETVAL - nastaví hodnotu semnum-tého semaforu na arg.val, čekající procesy jsou odblokovány při chybě vrací -1, jinak záleží na cmd, při GETVAL vrací hodnotu semaforu Každý semafor má nezápornou hodnotu a podporuje operace wait a post. Tyto operace se provádějí pomocí funkce semop. semop(2) #include <sys/types.h> #include <sys/ipc.h>

18 #include <sys/sem.h> int semop ( int semid, struct sembuf *sops, unsigned nsops ) provede operaci na vybraných semaforech (počtu nsops) z množiny semid, operace se provedou jen pokud se všechny provedou úspěšně prvky pole sops specifikují operaci pomocí struktury sembuf, která má prvky: sem_num - číslo ovlivňovaného semaforu, pro první je 0 sem_flg - když je zde SEM_UNDO, při ukončení procesu je semafor vrácen na svou předchozí hodnotu, platí pro všechna volání této funkce během existence procesu, sem_undo struktury procesu se nedědí při fork, ale při exec ano sem_op - operace, může být: kladné číslo - přidá se k hodnotě semaforu, při 1 je to operace post nula - blokuje proces, dokud hodnota semaforu není 0 nebo množina semaforů není zrušena nebo proces nedostane signál, který se obslouží záporné číslo - pokud je hodnota semaforu větší nebo rovna absolutní hodnotě tohoto čísla, je tato absolutní hodnota odečtena od hodnoty semaforu, jinak je proces blokován, dokud hodnota semaforu nebude větší nebo rovna absolutní hodnotě nebo nebo množina semaforů není zrušena nebo proces nedostane signál, který se obslouží, při -1 je to operace wait vrací 0, při chybě -1 Př. Synchronizujte rodiče a potomka v programu ze cvičení 'Linux - Meziprocesní komunikace', část 'Sdílená paměť'. Použijte jeden binární semafor tak, aby proces četl, až tam druhý něco zapíše. ipcs(8) ipcs -s vypíše pole semaforů a informace o nich Př. Podívejte se, zda v systému nezůstaly nepoužívané množiny semaforů. ipcrm(8) ipcrm sem id... zruší množinu semaforů specifikovanou pomocí id Př. Zrušte nepoužívané množiny semaforů. PŘÍKLAD Další funkce týkající se semaforů jsou: Linux - Synchronizace (Synchronization) Mutexy (Mutexes) Řešením většiny race conditions problémů je dovolit v daném čase přístup ke sdíleným datům pouze jednomu vláknu. Když jedno vlákno data mění, žádné jiné by k nim nemělo přistupovat, dokud změna dat neskončí. Mutex (MUTual EXclusion lock) je speciální zámek, který může v daném čase zamčít pouze jedno vlákno. Když se druhé vlákno pokusí zamčít již zamčený mutex, je blokováno, dokud první vlákno mutex neodemče. pthread_mutex_init(3) int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr); inicializuje mutex na ukazateli mutex, nastaví atributy podle mutexattr, pokud je NULL, atributy jsou defaultní, viz pthread_mutexattr_init proměnná typu pthread_mutex_t může být inicializována také staticky pomocí konstanty PTHREAD_MUTEX_INITIALIZER, např. pro globální a statické proměnné

19 vždy vrací 0 pthread_mutex_destroy(3) int pthread_mutex_destroy(pthread_mutex_t *mutex); zruší mutex, který musí být odemčený, uvolní prostředky systému (v Linuxu nejsou mutexům přiděleny žádné prostředky, tzn. funkce se nemusí používat pro zrušení mutexu) vrací 0, při chybě nenulové číslo pthread_mutex_lock(3) int pthread_mutex_lock(pthread_mutex_t *mutex); zamče mutex, pokud je již zamčený, blokuje vlákno, dokud není odemčen vrací 0, při chybě nenulové číslo pthread_mutex_trylock(3) int pthread_mutex_trylock(pthread_mutex_t *mutex); zamče mutex, pokud je již zamčený, vrací chybu vrací 0, při chybě nenulové číslo pthread_mutex_unlock(3) int pthread_mutex_unlock(pthread_mutex_t *mutex); odemče mutex a jedno (náhodné) z blokovaných vláken je odblokováno mutex musí být uzamčený stejným vláknem, ze kterého je volána tato funkce vrací 0, při chybě nenulové číslo Před přístupem (čtení i zápis) ke sdíleným datům si každé vlákno uzamče mutex. Až po dokončení operace s daty mutex odemče. Př. Nahraďte patřičné semafory z příkladu ze cvičení 'Linux - Synchronizace', část 'Semafory pro vlákna', mutexy. Blokování vláken mutexem může způsobit deadlock, který vznikne, když vlákna čekají na něco, co se nikdy nestane. Např. když se vlákno pokusí uzamčít jím zamčený mutex, ale to záleží na typu mutexu: fast mutex - pokus o uzamčení zamčeného mutexu blokuje, dokud není odemčen, inicializační konstanta je PTHREAD_MUTEX_INITIALIZER, defaultní recursive mutex - může být uzamčen vícekrát, uzamčení stejným vláknem se počítá, až stejný počet odemčení (tím vláknem) jej odemče, inicializační konstanta je PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP error-checking mutex - při pokusu o uzamčení již zamčeného mutexu se vrátí chyba, ale neblokuje se, inicializační konstanta je PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP pthread_mutexattr_init(3) int pthread_mutexattr_init(pthread_mutexattr_t *attr); inicializuje atributy mutexu attr a naplní je defaultními hodnotami vrací vždy 0 pthread_mutexattr_setkind_np(3) int pthread_mutexattr_setkind_np(pthread_mutexattr_t *attr, int kind);

20 nastaví typ mutexu v atributech attr na hodnotu kind kind může být PTHREAD_MUTEX_FAST_NP, PTHREAD_MUTEX_RECURSIVE_NP nebo PTHREAD_MUTEX_ERRORCHECK_NP, NP znamená nonportable, tj. nepřenosné rozšíření POSIX standardu vrací 0, při chybě nenulové číslo pthread_mutexattr_getkind_np(3) int pthread_mutexattr_getkind_np(const pthread_mutexattr_t *attr, int *kind); vrátí typ mutexu v atributech attr na adresu kind vrací vždy 0 pthread_mutexattr_destroy(3) int pthread_mutexattr_destroy(pthread_mutexattr_t *attr); zruší atributy mutexu, před novým použitím se musí znovu inicializovat vrací vždy 0 Condition variables Condition variable je třetí synchronizační prostředek v Linuxu, který umožňuje implementovat složitější podmínky běhu více vláken. Například funkce vlákna, která vykonává nekonečnou smyčku. Pokud je nastavena určitá vlajka, vykoná se při iteraci nějaká činnost. void* thread_function(void* thread_arg) { while (1) { int flag_is_set; pthread_mutex_lock(&thread_flag_mutex); flag_is_set = thread_flag; pthread_mutex_unlock(&thread_flag_mutex); } if (flag_is_set) do_work (); } return NULL; void set_thread_flag(int flag_value) { pthread_mutex_lock(&thread_flag_mutex); thread_flag = flag_value; pthread_mutex_unlock(&thread_flag_mutex); } Tohle je správně, ale ne dostatečně. Pokud není vlajka nastavena, spotřebuje se spousta času CPU testováním vlajky a zamykáním a odemykáním mutexu. Je potřeba vlákno uspat, dokud se nestane něco, co nastaví vlajku. Condition variable implementuje podmínku, při které vlákno poběží a naopak podmínku, při které bude vlákno blokováno. Pokud vlákno čeká na condition variable, je blokováno, dokud jiné vlákno nesignalizuje condition variable. Condition variable (na rozdíl od semaforu) není čítač, vlákno na ni musí čekat před tím, než je signalizována. Jinak je signál ztracen a vlákno čeká na další. Zpět k příkladu, pokud není vlajka nastavena, vlákno bude čekat na condition variable. Po nastavení vlajky se condition

21 variable signalizuje a blokované vlákno otestuje vlajku znovu (úspěšně). Je tu ale jeden problém: race condition mezi testováním vlajky a čekáním na condition variable. Např. vlákno zjistí, že vlajka není nastavena. Plánovač přepne vlákna, vlajka se nastaví a signalizuje se condition variable. Signál je ztracen, plánovač přepne vlákno zpět a to začne čekat na condition variable, které se možná nedočká. Potřebujeme zamčít mutexem vlajku i condition variable. Každá condition variable proto musí být použita spolu s mutexem: vlákno zamče mutex a otestuje vlajku pokud je vlajka nastavena, odemče mutex a vykoná činnost pokud ne, atomicky odemče mutex a čeká na condition variable pthread_cond_init(3) int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr); inicializuje condition variable na ukazateli cond, atributy cond_attr nejsou v Linuxu implementovány, tzn. zadává se NULL proměnná typu pthread_cond_t může být inicializována také staticky pomocí konstanty PTHREAD_COND_INITIALIZER, např. pro globální a statické proměnné vždy 0, při chybě nenulové číslo pthread_cond_destroy(3) int pthread_cond_destroy(pthread_cond_t *cond); zruší condition variable, na kterou nesmí žádné vlákno čekat, uvolní prostředky systému (v Linuxu nejsou mutexům přiděleny žádné prostředky, tzn. funkce se nemusí používat pro zrušení condition variable) vrací 0, při chybě nenulové číslo pthread_cond_signal(3) pthread_cond_broadcast(3) int pthread_cond_signal(pthread_cond_t *cond); int pthread_cond_broadcast(pthread_cond_t *cond); signalizuje condition variable, odblokuje nejvýše jedno (náhodné) blokované vlákno nebo všechna blokovaná vlákna (pthread_cond_broadcast) vrací 0, při chybě nenulové číslo pthread_cond_wait(3) int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex); atomicky odemče mutex a čeká na condition variable, mutex musí být zamčený při signalizování znovu zamče mutex ještě před odblokováním vlákna je to bod zrušení vlákna, před zrušením zamče mutex vrací 0, při chybě nenulové číslo Při změně podmínky (vlajky), která je chráněna pomocí condition variable, se musí postupovat takto: zamče se mutex pro condition variable změní se podmínka (vlajka) signalizuje se condition variable odemče se mutex Př. Opravte předložený příklad tak, aby se použila condition variable. Condition variable se může použít i bez podmínky, jednoduše pro blokování vlákna, dokud ho jiné "neprobudí". OTÁZKA: Pro tohle se dá použít i semafor. Jaké jsou principiální rozdíly mezi condition variable a semaforem? Další funkce týkající se mutexů nebo condition variables jsou:

22 Windows - Procesy (Processes) Aplikace pro Windows se skládá z jednoho nebo více procesů. Proces je jednoduše řečeno spuštěný program. Každý proces poskytuje zdroje nutné k vykonávání programu. Proces má vituální adresový prostor, kód, data, proměnné prostředí, prioritu, atd. #include <windows.h> - pro všechny funkce Win32 API Vytvoření procesu CreateProcess vytvoří nový proces jako potomka rodičovského procesu, oba běží nezávisle na sobě vrátí strukturu PROCESS_INFORMATION informací o novém procesu do lpprocessinformation, např. handle (který je platný dokud se neuzavře, tedy i po ukončení procesu) vrací nenulovou hodnotu, při chybě 0 vlastnosti nového procesu lze nastavit pomocí struktury STARTUPINFO: pro GUI procesy: výšku, šířku a pozici okna, které se použijí jako defaultní hodnoty funkce CreateWindow, ncmdshow parametr pro funkci ShowWindow pro konzolové procesy velikost okna a bufferu (ve znacích), pozici, barvy textu a pozadí, titulek konzole lpcommandline - příkazový řádek, tj. jméno programu s parametry binherithandles - jestli potomek zdědí handly dwcreationflags - další nastavení, např. CREATE_NEW_CONSOLE - potomek na novou konzoli, nemůže se používat s DETACHED_PROCESS DETACHED_PROCESS - pro konzolové procesy je bez konzole rodiče, nemůže se používat s CREATE_NEW_CONSOLE CREATE_SUSPENDED - hlavní vlákno procesu se vytvoří pozastavené priorita - defaultní NORMAL_PRIORITY_CLASS, pokud má rodič IDLE_PRIORITY_CLASS, tak tato lpstartupinfo - STARTUPINFO struktura lpprocessinformation - PROCESS_INFORMATION struktura PŘÍKLAD Př. Napište program a spusťte z něj nový konzolový proces s prioritou IDLE_PRIORITY_CLASS. CreateProcessAsUser vytvoří nový proces, který poběží pod jiným uživatelem, specifikovaným pomocí htoken GetCurrentProcessId vrací pid procesu Př. Vypište pid procesu. OpenProcess vrací handle procesu na základě pid, při chybě NULL binherithandle - jestli může být handle děděn dwprocessid - id procesu GetCurrentProcess vrací pseudo handle procesu, který je použitelný jen v rámci tohoto procesu!, lze jej "zveřejnit" na normální handle pomocí DuplicateHandle Př. Zjistěte handle, pseudo handle a "zveřejněný" pseudo handle procesu a porovnejte je s handlem z PROCESS_INFORMATION

23 Informace o procesu GetStartupInfo vrací STARTUPINFO strukturu, použitou při vytvoření procesu, do lpstartupinfo Nový proces může od rodiče zdědit různé vlastnosti a zdroje, a rodičovský proces může určit, co se může zdědit. Potomek může dědit: nedědí: handly otevřených souborů, bufferů, rour, procesů, vláken, mutexů, semaforů, mapování souborů proměnné prostředí aktuální adresář konzoli, pokud rodič není bez konzole nebo pokud si potomek nevytvoří novou pseudo handly prioritu GDI nebo USER handly, např. HBITMAP nebo HMENU Aby se handl zdědil, musí se zděditelnost specifikovat při jeho vytváření, otevírání nebo duplikování a při volání funkce CreateProcess s parametrem finherithandles. Zděděný handl je stejný jako původní, změna na jednom se projeví i na druhém. Ukončení procesu ExitProcess ukončí tento proces s návratovým kódem uexitcode TerminateProcess ukončí jiný proces, jehož handle je hprocess, s návratovým kódem uexitcode vrací nenulovou hodnotu, při chybě 0 Proces se též ukončí, když skončí jeho hlavní nebo poslední vlákno. Handly otevřených souborů a jiné jsou při ukončení procesu uzavřeny, ale stále existují, pokud je používají i jiné procesy. Konzolové procesy lze také ukončit pomocí C-C nebo C-Break. GetExitCodeProcess vrací status ukončení procesu, jehož handle je hprocess, do lpexitcode, je STILL_ACTIVE, pokud proces ještě běží, nebo je to návratový kód procesu, který vrací main nebo WinMain funkce vrací nenulovou hodnotu, při chybě 0 Př. Vypište v rodiči návratový kód potomka. TerminateProcess neukončuje korektně vlákna, pro ukončení procesu jiným by se mělo postupovat takto: oba procesy si zaregistrují privátní zprávu pomocí RegisterWindowMessage jeden ukončí druhého posláním této privátní zprávy pomocí BroadcastSystemMessage, př. BroadcastSystemMessage( BSF_IGNORECURRENTTASK, // do not send message to this process BSM_APPLICATIONS, // broadcast only to applications private message, // message registered in functionvious step wparam, // message-specific value lparam ); // message-specific value proces, co přijme zprávu, se ukončí pomocí ExitProcess Při ukončení procesu se neukončují jeho potomci. Další funkce týkající se procesů jsou: