POSIX: IEEE Std 1003.1 2001 (Issue 6, 2004 edition)



Podobne dokumenty
Sygnały. 7. Sygnały (2005/2006)

w odróżnieniu od procesów współdzielą przestrzeń adresową mogą komunikować się za pomocą zmiennych globalnych

procesy odrębne dzielone

Programowanie Współbieżne

Obsługa sygnałów. Tomasz Borzyszkowski

1. Timery i zdarzenia

1. Kolejki komunikatów POSIX

Wielowątkowy serwer TCP

1. Uruchom poniższy program tworzący pojedynczy wątek:

Procesy, pliki, potoki, sygnały - uzupełnienie

1. Procesy i współbieżność

Kolejki komunikatów POSIX

Temat zajęć: Tworzenie i obsługa wątków.

Wątki, sygnały i szeregowanie w systemach UNIX, Linux

Semafory, pamięć dzielona i kolejki komunikatów

J. Ułasiewicz Programowanie aplikacji współbieżnych 1

Programowanie równoległe i rozproszone. Monitory i zmienne warunku. Krzysztof Banaś Programowanie równoległe i rozproszone 1

Programowanie Współbieżne. W Linuxie/Unixie

Sygnały i ich obsługa

Jędrzej Ułasiewicz Programownie aplikacji współbieżnych str. 1. Wątki

SYSTEMY CZASU RZECZYWISTEGO - VxWorks

Mariusz Rudnicki PROGRAMOWANIE SYSTEMÓW CZASU RZECZYWISTEGO CZ.4

13. Kolejki komunikatów POSIX

1. Kolejki komunikatów POSIX

ZAJECIA Z SYSTEMÓW OPERACYJNYCH 2 (Programowanie): funkcje POSIX

UNIX. mgr inż. Marcin Borkowski

Mariusz Rudnicki PROGRAMOWANIE WSPÓŁBIEŻNE I SYSTEMY CZASU RZECZYWISTEGO CZ.4

przerwany proces móg l zareagować na określone zdarzenie. Można je traktować jako software owe wersje przerwań sprz etowych.

Sygnał mechanizm asynchronicznego powiadamiania procesów o zdarzeniach zwykle awaryjnych.

Obsługa plików Procesy

7. Szeregowanie procesów w systemie QNX6 Neutrino

Łącza nienazwane(potoki) Łącza nienazwane mogą być używane tylko pomiędzy procesami ze sobą powiązanymi.

10. Synchronizacja użycia zasobów, Semafory Problem producenta i konsumenta

Poniższe funkcje opisane są w 2 i 3 części pomocy systemowej.

Programowanie równoległe i rozproszone. W1. Wielowątkowość. Krzysztof Banaś Programowanie równoległe i rozproszone 1

1. Timery i zdarzenia

programowanie współbieżne

QNX Neutrino (v 6.3)

Łącza nienazwane(potoki)

1 Timery i zdarzenia

Pliki. Funkcje tworzące pliki i operujące na nich opisane są w części 2 pomocy systemowej. Tworzenie i otwieranie plików:

Problemy współbieżności

Procesy. Systemy Operacyjne 2 laboratorium. Mateusz Hołenko. 9 października 2011

Tworzenie wątków. #include <pthread.h> pthread_t thread;

Obsługa plików. Systemy Operacyjne 2 laboratorium. Mateusz Hołenko. 25 września 2011

# echo przykład przykład. echo przykład

Wykład 5 Przerwania i wywołania systemowe. Wojciech Kwedlo, Systemy Operacyjne II -1- Wydział Informatyki PB

Skrypt do przedmiotu SCZR (Systemy Czasu Rzeczywistego)

Krótki kurs programowania współbieżnego

PROGRAMOWANIE SYSTEMÓW CZASU RZECZYWISTEGO

Wykład 3. Procesy i wątki. Wojciech Kwedlo, Wykład z Systemów Operacyjnych -1- Wydział Informatyki PB

Plan wykładu. Obliczenia równoległe w zagadnieniach inżynierskich. Wykład 1 p. Wzajemne wykluczanie. Procesy współbieżne

Programowanie aplikacji równoległych i rozproszonych. Wykład 1

Instrukcja do laboratorium Systemów Operacyjnych. (semestr drugi)

Plan wykładu. Programowanie aplikacji równoległych i rozproszonych. Wykład 1 p. Wzajemne wykluczanie. Procesy współbieżne

4.2 Sposób korzystania z l acza

Programowanie współbieżne

10. Synchronizacja użycia zasobów, Semafory

Dzisiejszy wykład. Klasa string. wersja prosta wersja ze zliczaniem odwołań. Wyjątki Specyfikator volatile Semafory

Rys. 9-1 Procesy P1 i P2 komunikuję się poprzez wspólny obszar. pamięci.

Systemy Operacyjne ZAAWANSOWANE OPERACJE WEJŚCIA-WYJŚCIA DLA PLIKÓW

7. Szeregowanie procesów w systemie QNX6 Neutrino

Systemy Operacyjne 1 Laboratorium 2 Procesy i sygnały w Linuksie (jeden tydzień) dr inż. Arkadiusz Chrobot

Wykład 5. Synchronizacja (część II) Wojciech Kwedlo, Wykład z Systemów Operacyjnych -1- Wydział Informatyki PB

Procesy, wątki i zasoby

Kolejki FIFO (łącza nazwane)

10. Synchronizacja użycia zasobów, Semafory

Unix: programowanie z użyciem w atków

Unix: programowanie z użyciem w atków

Laboratorium Systemów Operacyjnych. Ćwiczenie 4. Operacje na plikach

UŻYCIE I ZARZĄDZANIE WĄTKAMI

jeszcze dygresja o macierzach...

UŻYCIE I ZARZĄDZANIE WĄTKAMI

synchronizacji procesów

Laboratorium z systemów operacyjnych. System plików - funkcje systemowe. Anna Wojak

10. Synchronizacja użycia zasobów, Semafory

Pliki, potoki, sygnały

Wykład 3: Implementacja programów wbudowanych

4. Komunikacja pomiędzy procesami przez łącza nienazwane i nazwane

Gdy kilka procesów czyta a przynajmniej jeden dokonuje zapisu wynik odczytu zależeć może od sposobu realizacji przeplotu.

synchronizacji procesów

Tworzenie programów równoległych. Krzysztof Banaś Obliczenia równoległe 1

Tworzenie programów równoległych cd. Krzysztof Banaś Obliczenia równoległe 1

Temat zajęć: Obsługa procesów w systemie.

Problem producentakonsumenta

Procesy, zasoby i wątki

Mechanizmy pracy równoległej. Jarosław Kuchta

Procesy, zasoby i wątki

Procesy, zasoby i wątki

J. Ułasiewicz Programowanie aplikacji współbieżnych 1

Procesy i wątki. Krzysztof Banaś Obliczenia równoległe 1

Laboratorium Procesy w systemach UNIX 3.2 Polecenia związane z procesami

Procesy. S. Samolej: Procesy

System operacyjny MACH

1. Utwórz blok pamięci współdzielonej korzystając z poniższego kodu:

Tworzenie programów równoległych. Krzysztof Banaś Obliczenia równoległe 1

J. Ułasiewicz Programowanie aplikacji współbieżnych 1

Systemy operacyjne III

Struktury. Przykład W8_1

Metody komunikacji międzyprocesowej w systemach lokalnych i rozproszonych

Transkrypt:

POSIX: IEEE Std 1003.1 2001 (Issue 6, 2004 edition) Podstawowe rekomendacje przejęte z UNIXa wielodostęp wielozadaniowość system plików terminal gniazda Rekomendacje dla obszaru czasu rzeczywistego strategie szeregowania rozszerzony mechanizm sygnałów synchronizacja i komunikacja zadań kontrola zarządzania pamięcią wspólne obszary pamięci programowe liczniki czasu asynchroniczne operacje wejścia-wyjścia Rts4F.doc 1

Tworzenie i usuwanie procesów Utworzenie kopii procesu pid_t fork( ) Obszar programu Obszar programu Obszar danych Obszar danych Tablica stanu Tablica stanu Wymiana ciała procesu int exec-- ( plik, argumenty, środowisko ) Przykład pid=fork(); if ( p!=0 ) { //... proces macierzysty } else { } exec(new,..,..); //... nowy proces potomny Rts4F.doc 2

Utworzenie nowego procesu POSIX_SPAWN int posix_spawn ( pid_t *pid, char *path, posix_spawn_file_actions_t *actions, posix_spawnattr_t *attr, char *argv[ ], char *envp[ ] ); Zakończenie procesu void exit ( int status ) Oczekiwanie na zakończenie procesu potomnego pid_t wait ( int *status ); pid_t waitpid ( pid_t pid, int *status, int options ); Rts4F.doc 3

Tworzenie i usuwanie wątków Utworzenie wątku int pthread_create ( pthread_t *thread, const pthread_attr_t *attr, void *( *body )(void *), void *arg ) Zakończenie wątku void pthread_exit ( void *value ) Oczekiwanie na zakończenie wątku int pthread_join ( pthread_t thread, void **value ) POSIX_THREADS Rts4F.doc 4

Algorytmy szeregowania Poziomy priorytetu Wywłaszczanie zadań niższych poziomów max (RR) (FIFO) max Strategie szeregowania - algorytm karuzelowy (SCHED_RR) - algorytm kolejkowy (SCHED_FIFO) - serwer sporadyczny (SCHED_SPORADIC) - algorytm dowolny (SCHED_OTHER) Zwolnienie procesora int sched_yield ( ); Rts4F.doc 5

Ustalanie strategii szeregowania (policy) i priorytetu Procesy int sched_setparam ( pid_t pid, struct sched_param *param) int sched_setscheduler ( pid_t pid, int policy, struct sched_param *param ) Wątki int pthread_setschedprio ( pthread_t thread, int prio ) int pthread_setschedparam ( pthread_t thread, int policy, struct sched_param *param ) contentionscope PTHREAD_SCOPE_PROCESS PTHREAD_SCOPE_SYSTEM Rts4F.doc 6

Sygnały Generacja sygnału system operacyjny int kill ( pid_t pid, int sig ) int raise ( int sig ) int pthread_kill ( pthread_t thread, int sig ) Obsługa sygnałów void ( *signal ( int sig, void ( *func ) ( int ) ) ) ( int ) - domyślnie (SIG_DFL) - ignorowanie (SIG_IGN) - przechwycenie void handler ( int signo ) {. } sig_atomic_t sigsetjmp ( ), siglongjmp ( ) Rts4F.doc 7

sig_atomic_t x; main ( ) { if ( sigsetjmp( ) ) { switch ( x ) { case SIGALRM : } fun_1 ( ) { } fun_2 ( ) { } 1 2 3b handler ( int signo ) { x=signo; if (... ) siglongjmp( ); } 3a Rts4F.doc 8

Maskowanie sygnałów sigemptyset ( ), sigfillset ( ), sigaddset ( ), sigdelset ( ) sigprocmask ( ) pthread_sigmask ( ) sigismember ( ), sigpending ( ) sigsuspend ( ) sigwait ( ), sigwaitinfo ( ), sigtimedwait ( ) fun ( ) { signal ( SIGUSR1, &handler ); sigprocmask (... ); pause ( ) }?? handler ( ) { } Rts4F.doc 9

Rodzaje sygnałów (28) si_signo si_code default SIGBUS rodzaj błędu Z Błędny adres fizyczny na magistrali SIGILL rodzaj błędu Z Błędna instrukcja SIGFPE rodzaj błędu Z Błąd operacji arytmetycznej. SIGSEGV rodzaj błędu Z Naruszenie ochrony pamięci SIGABRT Z Nienormalne zakończenie procesu (abort) SIGALRM Z Upływ czasu (alarm clock) SIGKILL Z Usunięcie procesu bez przechwycenia SIGTERM Z Normalne zakończenie procesu (exit) SIGHUP SI_USER Z Zakończenie sesji terminala SIGINT SI_QUEUE Z Przerwanie z terminala SIGQUIT SI_TIMER Z Zakończenie pracy z terminala SIGSTOP SI_MESGQ S Zatrzymanie procesu bez przechwycenia SIGCONT SI_ASYNCIO C Kontynuacja zatrzymanego procesu SIGPIPE Z Zapis do zamkniętego potoku SIGSYS Z Błędne odwołanie do systemu SIGCHLD I Zakończenie procesu potomnego SIGUSR1 Z User-defined signal 1. SIGUSR2 Z User-defined signal 2. SIGRTMIN... SIGRTMAX Rts4F.doc 10

Kolejkowanie sygnałów POSIX_REALTIME_SIGNALS int sigqueue ( pid_t pid, int sig, union sigval value ) int sigaction ( int sig, struct sigaction *act, struct sigaction *oact ) struct sigaction sa_flags SA_SIGINFO sa_handler sa_sigaction void handler ( int signo, siginfo_t *info, void *context ) siginfo_t int si_signo int si_code union sigval si_value union sigval int sival_int void *sival_ptr Rts4F.doc 11

Przykład static sig_atomic_t num, val, code; void funh(int sig, siginfo_t *inf, void *con) { num=sig; val=info->si_value.sival_int; code=info->si_code; } void main( ) { struct sigaction act; sigset_t set; } sigemptyset(&set); sigaddset(&set,sigusr1); sigaddset(&set,sigusr2); act.sa_flags=sa_siginfo; act.sa_mask=set act.sa_sigaction=&funh; sigaction(sigusr1,&act,null); pause(); printf("signo=%d val=%d code=%d\n", num,val,code); Rts4F.doc 12

Zarządzanie pamięcią Blokowanie stron w pamięci int mlockall ( int flags ) int munlockall ( ) POSIX_MEMLOCK int mlock ( void *addr, size_t len ) int munlock ( void *addr, size_t len ) POSIX_MEMLOCK_RANGE Wspólne obszary danych Pamięć operacyjna proces A proces B - włączenie obszaru w przestrzeń adresową - identyfikacja obszaru przez procesy - ograniczenie rodzaju operacji - trwałość obszaru wspólne dane Rts4F.doc 13

Odwzorowanie pliku w pamięci void *mmap ( void *addr, size_t len, int prot, int flags, int file, off_t offset ) POSIX_MAPPED_FILES flags MAP_SHARED, MAP_PRIVATE, MAP_FIXED int munmap ( void *addr, size_t len ) int msync ( void *addr, size_t len, int flags ) flags MS_ASYNC, MS_SYNC, MS_INVALIDATE Dzielony obiekt pamięciowy POSIX_SHARED_MEMORY_OBJECTS int shm_open ( char *name, int oflags, mode_t mode ) int shm_unlink ( char *name ) int close ( int file ) int ftruncate ( int file, off_t length ) Rts4F.doc 14

Narzędzia synchronizacji i komunikacji zadań Semafor POSIX_SEMAPHORES int sem_init ( sem_t *sem, int shared, int value ) int sem_destroy ( sem_t *sem ) int sem_wait ( sem_t *sem ) int sem_post ( sem_t *sem ) int sem_trywait ( sem_t *sem ) int sem_timedwait ( sem_t *sem, struct timespec *abs_timeout) Semafor nazwany sem_t *sem_open ( char *name, int oflag, mode_t mode, unsigned value ) oflags O_CREAT, O_EXCL int sem_close (sem_t *sem ) int sem_unlink ( char *name ) Rts4F.doc 15

Przykład... fd=shm_open( semafor,o_rdwr O_CREAT,0777); size=ltrunc(fd,sizeof(sem_t),seek_set); addr=mmap(0,sizeof(sem_t),prot_read PROT_WRITE, MAP_SHARED,fd,0); sem=(sem_t *)addr; sem_init(sem,1,0); // pshared... fork();... sem_wait(sem);... sem_destroy(sem); munmap(addr,sizeof(sem_t); close(fd); shm_unlink( semafor );... /* drugi proces bez wykorzystania fork() */... fd=shm_open( semafor,o_rdwr); addr=mmap(0,sizeof(sem_t),prot_read PROT_WRITE, MAP_SHARED,fd,0); sem=(sem_t *)addr;... sem_post(sem)... munmap(addr,sizeof(sem_t); close(fd);... Rts4F.doc 16

Muteks Utworzenie int pthread_mutex_init ( pthread_mutex_t *mutex, pthread_mutexattr_t * attr ) pthread_mutex_t mutex=pthread_mutex_initializer; Usunięcie int pthread_mutex_destroy ( pthread_mutex_t *mutex ) Sekcja krytyczna int pthread_mutex_lock ( pthread_mutex_t *mutex )... int pthread_mutex_unlock ( pthread_mutex_t *mutex ) Rts4F.doc 17

Inwersja priorytetów protocol PTHREAD_PRIO_NONE PTHREAD_PRIO_INHERIT PTHREAD_PRIO_PROTECT Ograniczenie oczekiwania int pthread_mutex_trylock ( pthread_mutex_t *mutex ) int pthread_mutex_timedlock ( pthread_mutex_t *mutex, struct timespec *abs_timeout ) Rts4F.doc 18

Zmienna warunkowa 1 2... Producent wpisz wiadomość ( w ); s=s+1; Konsument while ( s == 0 ) czekaj; pobierz wiadomość ( p ); s=s 1; Producent mutex_lock ( m ); wpisz wiadomość ( w ); s=s+1; mutex_unlock ( m ); Konsument mutex_lock ( m ); while ( s == 0 ) czekaj; s=s 1; pobierz wiadomość ( p ); mutex_unlock ( m ); Rts4F.doc 19

Operacje int pthread_cond_init ( pthread_cond_t *cond, pthread_condattr_t * attr ) int pthread_cond_wait ( pthread_cond_t *cond, pthread_mutex_t *mutex ) int pthread_cond_signal ( pthread_cond_t *cond ) int pthread_cond_timedwait ( pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime ) int pthread_cond_broadcast ( pthread_cond_t *cond ) Przykład Producent mutex_lock ( m ); wpisz wiadomość ( w ); s=s+1; if ( s==1) cond_signal ( &c ); mutex_unlock(m); Konsument mutex_lock ( m ); while ( s == 0 ) cond_wait ( &c,&m ); pobierz wiadomość ( w ); s=s 1; mutex_unlock(m); Rts4F.doc 20

Koncepcja monitora Producent.. send ( message );.. Konsument.. receive ( message );.. Pakiet obsługi kolejki // statyczny bufor, licznik s, muteks m i zmienna warunkowa cn send ( char *w ) { mutex_lock ( m ); wpisz wiadomość ( w ); s=s+1; if ( s==1) cond_signal ( &c ); mutex_unlock(m); return; } receive ( char *w ) { mutex_lock ( m ); while ( s == 0 ) cond_wait ( &c,&m ); pobierz wiadomość ( w ); s=s 1; mutex_unlock(m); return; } Rts4F.doc 21

Kolejka wiadomości Proces pomiarowy Proces komunikacyjny Delay(dt) Czytaj zmienne procesu Porównaj z ograniczeniami Receive(Bufor, K) NIE Wartość błędna? TAK Bufor komunikatów Wyślij komunikat TAK send(bufor, K) Receive(Bufor, K): if (jest wiadomość) then weź jedną else zawieś zadanie Send(Bufor, K): if (czeka zadanie) then wznów jedno else wpisz wiadomość Rts4F.doc 22

Operacje POSIX_MESSAGE_PASSING mqd_t mq_open ( char *name, int oflags, mode_t mode, mq_attr *attr ) attr mq_maxmsg, mq_msgsize oflags O_CREAT, O_EXCL, O_RDONLY, O_WRONLY, O_RDWR, O_NONBLOCK int mq_close ( mqd_t mq ) int mq_unlink (char *name ) int mq_send ( mqd_t mq, char *msg, size_t len, unsigned prio ) int mq_timedsend ( mqd_t mq, char *msg, size_t len, unsigned prio, struct timespec *abs_timeout ) ssize_t mq_receive ( mqd_t mq, char *msg, size_t len, unsigned *prio ) ssize_t mq_timedreceive ( mqd_t mq, char *msg, size_t len, unsigned * prio, struct timespec *abs_timeout) Rts4F.doc 23

Zdarzenie notyfikacji int mq_notify ( mqd_t mq, struct sigevent *notification ) struct sigevent int sigev_notify int sigev_signo union sigval sigev_value void(*)(union sigval) sigev_notify_function (pthread_attr_t *) sigev_notify_attributes sigev_notify SIGEV_NONE SIGEV_SIGNAL SIGEV_THREAD Rts4F.doc 24

Uzależnienia czasowe Opóźnienie Przeterminowanie read( ) sem_post(s) awaria? Praca cykliczna while (1) { sleep ( t ); }? Rts4F.doc 25

Opóźnienie unsigned sleep ( unsigned sec ) unsigned alarm (unsigned sec ) POSIX_TIMERS int nanosleep ( struct timespec *rq, struct timespec *rm ) struct timespec time_t tv_sec long tv_nsec Rts4F.doc 26

Liczniki czasu (timer) POSIX_TIMERS td tc tc tc zdarzeni zdarzenie zdarzenie zdarzenie int timer_create ( clockid_t clock, struct sigevent *evp, timer_t *timer ) int timer_delete ( timer_t timer ) int timer_settime ( timer_t timer, int flags, struct itimerspec *value, struct itimerspec *ovalue ) flags TIMER_ABSTIME int timer_getoverrun ( timer_t timer ) int timer_gettime ( timer_t timer, struct itimerspec *value) struct itimerspec struct timespec it_interval struct timespec it_value Rts4F.doc 27

Przykłady Przeterminowanie struct itimerspec time; timer_t timer; timer_create(clock_realtime,null,&timer); time.it_value.tv_sec=0; time.it_value.tv_nsec=50 000 000; time.it_interval.tv_sec=0; time.it_interval.tv_nsec=0; timer_settime(timer,0,time,null); result=read(fd,buf,n); Praca cykliczna time.it_value.tv_sec=0; time.it_value.tv_nsec=1 000 000; time.it_interval.tv_sec=0; time.it_interval.tv_nsec=50 000 000; timer_settime(timer,0,time,null); do { pause(); } while(run) Rts4F.doc 28

Asynchroniczne operacje we/wy struct aiocb POSIX_POSIX_ASYNCHRONOUS_IO int aio_fildes off_t aio_offset void *aio_buf size_t aio_nbytes int aio_reqprio struct sigevent aio_sigevent int aio_lio_opcode Operation to be performed. int aio_read ( struct aiocb *cb ) int aio_write (struct aiocb *cb ) int aio_error ( struct aiocb * ) ssize_t aio_return ( struct aiocb * ) int aio_suspend ( struct aiocb *list[], ll, struct timespec *tt ) Rts4F.doc 29