Systemy rozproszone

W. Bartkiewicz

Wykład 3. Procesy i wątki

Pojęcie procesu

• Programu wykonalnego.

• Reprezentacji procesu w jądrze systemu.

• Prywatnej przestrzeni adresowej w pamięci.

• Zasobów systemowych, takich jak pliki, potoki, porty komunikacyjne i zasoby synchronizacyjne, np. semafory.

• Co najmniej jednego wątku, gdzie przez wątek rozumiemy ścieżkę wykonania i reprezentację wątku w jądrze systemu.

Proces składa się z:

• Proces „ciężki” (ang. heavyweight process) uwzględniający wątek oraz środowisko wykonania.

• Proces „lekki” (ang. lightweight process) gdy środowisko wykonania nie jest uwzględniane.

W niektórych systemach operacyjnych i modelach programowania terminem proces określa się po prostu wątek. Wprowadza się wówczas dwa terminy:

Przestrzeń adresowa

• Stanowi najbardziej kosztowny składnik środowiska wykonywania pod względem tworzenia i wykorzystania.

• Ma wielkie rozmiary (zazwyczaj 232 bajtów – 4 GB).

• Aplikacja nigdy nie ma bezpośredniego dostępu do pamięci fizycznej. Przestrzeń adresowa ma więc charakter pamięci wirtualnej. Wątek procesu wykonywany jest, korzystając z adresów wirtualnych w przestrzeni adresowej swojego procesu. Adres wirtualny nie ma związku z lokalizacją w pamięci fizycznej.

• Wszystkie odwołania do pamięci fizycznej za pośrednictwem żądań dostępu z użyciem adresów wirtualnych kontrolowane są przez mechanizm systemowy zwany menedżerem pamięci wirtualnej.

Obszary w przestrzeni adresowej (pamięci wirtualnej)

• Przestrzeń adresowa procesu podzielona na wiele obszarów, oddzielonych niedostępnymi regionami pamięci wirtualnej.

• Obszar jest ciągłym fragmentem pamięci wirtualnej, dostępnej dla wątków procesu będącego jego właścicielem.

• Obszary nie zachodzą na siebie.

• Każdy obszar charakteryzuje się następującymi cechami:– rozpiętością (określoną przez najmniejszy adres wirtualny i rozmiar,

– pozwoleniami, jakie mają do niego wątki procesu (czytanie, pisanie, wykonanie),

– możliwością powiększania i zmniejszania.

Typowe obszary w pamięci wirtualnej

• Stały, niemodyfikowalny obszar zawierający kod programu, nazywany tekstem (ang. text).

• Część pamięci zawierającą zmienne lokalne podprogramów, rozszerzającą się w kierunku mniejszych adresów wirtualnych, nazywaną stosem (ang. stack). Przestrzeń adresowa zawiera odrębny stos dla każdego wątku procesu.

• Część pamięci zawierającą zmienne dynamiczne przydzielane przez program, nazywaną stertą (ang. heap).

• Obszar jądra systemu. Kod i dane jądra mapowane są w przestrzeń adresową każdego procesu, zazwyczaj w tym samym miejscu. W systemie Windows NT/XP dla przykładu procesy zarządzają jedynie 2GB (w wersji serwer 3GB) przestrzeni adresowej. Pozostałe 2GB przeznaczone są dla systemu operacyjnego.

Typowe obszary w pamięci wirtualnej

• Obszary bibliotek dynamicznych. Obraz bibliotek dynamicznych (w przeciwieństwie do tradycyjnych bibliotek statycznych, konsolidowa-nych w jednym obrazie wykonalnym z programem głównym) ładowany jest do pamięci fizycznej tylko raz, a następnie mapowany (odwzorowywany) w przestrzeń adresową procesów z niej korzystających.

• Obszary plików mapowanych, Plik mapowany dostępny jest w pamięci operacyjnej, jako obszar traktowany jako tablica bajtów.

Pamięć wirtualna

• Pozwala ona na uniknięcie defragmentacji pamięci w środowisku wieloprocesowym, bez konieczności fizycznego przesuwania informacji. Ukrywa on rozdrobnioną, strukturę stronicowanej pamięci fizycznej, pozwalając aplikacji widzieć ją jako płaski i ciągły blok kolejnych adresów.

• Umożliwia zwiększenie ilości dostępnej pamięci. Izoluje aplikację od mechanizmów wymiany stron między pamięcią operacyjną i dyskiem.

• Wprowadza ścisłe rozgraniczenie między pamięcią różnych procesów. Każdy proces ma swoją własną przestrzeń adresową. Nie ma więc możliwości uszkodzenia pamięci innego procesu np. na skutek przypadkowego i błędnego zapisu.

• Ułatwia aplikacjom zarządzanie pamięcią. Ukrywa złożony mechanizm zarządzania pamięcią fizyczną, pozwalając widzieć ją jaki płaski obszar adresów.

Organizacja pamięci wirtualnej w MS Windows

Struktura adresu wirtualnego w MS Windows

Adres fizyczny strony w MS Windows

TLB

• Jednostki zarządzania pamięcią zazwyczaj zawierają sprzętową pamięć podręczną, mającą przyśpieszać tłumaczenie adresów wirtualnych na fizyczne, nazywaną ubocznym buforem translacji (ang. TLB – Translation Lookaside Buffer).

• TLB przechowuje po prostu adresy fizyczne ostatnio wykorzystywanych przez proces stron pamięci.

• TLB jest sprzętowo zoptymalizowany w celu szybkiego przeszukiwania pod kątem adresów wirtualnych i lokalizacji odpowiadających im stron fizycznych.

Tworzenie nowego procesu w Unixie

#include <stdio.h>#include <unistd.h>int main(int argc, char *argv[]){ int pid; pid = fork(); if (pid < 0) { /* Blad ! */ fprintf(stderr, "Fork Failed"); exit(-1); } else if (pid == 0) { /* proces potomny */ execlp("/bin/ls","ls",NULL); } else { /* proces rodzicielski */ wait(NULL); printf("Child Complete"); exit(0); }}

• Funkcja fork tworzy nowy proces.– Wywoływana z procesu

rodzicielskiego.

– Powracają z niej proces potomny i rodzicielski.

• Funkcja exec - zastępuje obraz bieżącego procesu nowym programem.– proces wywołujący nigdy nie

wraca z exec (chyba że powstanie błąd).

• Funkcja wait - blokuje proces do momentu zakończenia procesu potomnego.

Procesy w systemie Microsoft Windows

• Procesy w systemie Windows są reprezentowane przez obiekty jądra systemu.

• Wykonywany proces składa się z jednego lub więcej wątków.

• Zarówno obiekty procesów i wątków zawierają mechanizmy synchronizacji.

• Nie istnieje relacja rodzic–potomek pomiędzy procesem tworzącym nowy proces, a nowym procesem.

Cechy procesów systemu Microsoft Windows NT/2000/XP:

Tworzenie nowego procesu w WindowsBOOL CreateProcess( LPCTSTR lpApplicationName, // nazwa pliku wykonalnego LPTSTR lpCommandLine, // linia poleceń LPSECURITY_ATTRIBUTES lpProcessAttributes, // Atrybut zabezpieczeń procesu LPSECURITY_ATTRIBUTES lpThreadAttributes, // Atrybut zabezpieczeń wątku BOOL bInheritHandles, // flaga dziedziczenia uchwytów DWORD dwCreationFlags, // flagi tworzenia procesu LPVOID lpEnvironment, // wskaźnik do zmiennych środowiskowych LPCTSTR lpCurrentDirectory, // nazwa katalogu procesu LPSTARTUPINFO lpStartupInfo, // wskaźnik do struktury STARTUPINFO LPPROCESS_INFORMATION lpProcessInformation // wskaźnik do); // PROCES_INFORMATION

Nowo tworzony proces otrzymuje nową wirtualną przestrzeń adresową, czyli pamięć, stos oraz zasoby. oraz zasoby. Część z zasobów może być dziedziczona.

Każdy nowo tworzony proces posiada identyfikator – Process ID, oraz uchwyt – Process Handle. Mogą one być wykorzystywane do synchronizacji oraz komunikacji międzyprocesowej.

Tworzenie nowego procesu w WindowslpApplicationName – nazwa pliku wykonywalnego wraz ze ścieżką. Gdy

brak ścieżki, założenie, ˙ze program w bieżącym katalogu. Kiedy brak rozszerzenia, automatycznie dodawane jest „exe”. Może być NULL, wtedy pierwszy token łańcucha w lpCommandLine jest nazwą programu. Uwaga dla długich nazw ze spacją, należy używać cudzysłowu, np.:.

CreateProcess(NULL, "\"C:\\Program Files\\MyApp.exe\" -L -S", ...)

lpCommandLine – łańcuch linii polecenia. Gdy lpApplicationName jest NULL, łańcuch ten opisuje plik wykonywalny wraz z parametrami. W przeciwnym przypadku, parametry programu wskazanego wyżej. Gdy lpCommandLine jest NULL – brak linii poleceń.

dwCreationFlags – opcje nowo tworzonego procesu, m.in.: CREATE NEW CONSOLE, CREATE UNICODE ENVIRONMENT, CREATE SUSPENDED. Związane z priorytetem: IDLE PRIORITY CLASS, NORMAL PRIORITY CLASS, HIGH PRIORITY CLASS, REALTIME PRIORITY CLASS. Windows 2000/XP: BELOW NORMAL PRIORITY CLASS, ABOVE NORMAL PRIORITY CLASS.

lpStartupInfo – struktura STARTUPINFO wypełniona informacjami o stanie okna, parametrach konsoli, uchwytach do standardowego we/wy itp. Tworzony proces może odczytać strukturę za pomocą funkcji GetStartupInfo.

Tworzenie nowego procesu w Windowstypedef struct _PROCESS_INFORMATION { HANDLE hProcess; HANDLE hThread; DWORD dwProcessId; DWORD dwThreadId; } PROCESS_INFORMATION;

lpProcessInformation – struktura PROCESS INFORMATION odbiera informacje o nowo tworzonym procesie.

Jeśli nowo tworzone procesy nie dziedziczą uchwytów od procesu rodzicielskiego (nie można przekazać uchwytu), możliwe jest przekazanie Identyfikatora procesu i stosując funkcję OpenProcess(..) utworzyć nowy uchwyt do procesu.

Wszystkie uchwyty muszą być zamknięte gdy nie są potrzebne. Funkcja: CloseHandle.

Tworzenie nowego procesu w Windows – Przykład 1

#include <windows.h>

int main(){ STARTUPINFO si; PROCESS_INFORMATION pi; memset(&si,0,sizeof(si)); si.cb=sizeof(si); CreateProcess(NULL,"calc",NULL,

NULL,FALSE,NORMAL_PRIORITY_CLASS,NULL,NULL,&si,&pi); WaitForSingleObject(pi.hProcess,INFINITE); MessageBox(NULL,"Test","Test",MB_OK); return 0;}

Tworzenie nowego procesu w Windows Przykład 2 – rodzic

#include <windows.h>int main(int argc, char *argv[]) { // CreateProcessMaster.c STARTUPINFO si; PROCESS_INFORMATION pi; int pid; char cmd[128]; pid=GetCurrentProcessId(); sprintf(cmd,"CreateProcessSlave.exe %d",pid); memset(&si,0,sizeof(si)); si.cb=sizeof(si); CreateProcess(NULL,cmd,NULL,NULL,FALSE,

CREATE_NEW_CONSOLE|NORMAL_PRIORITY_CLASS, NULL,NULL,&si,&pi); printf("Master zasypia...\n"); Sleep(5000); printf("Master konczy...\n"); return 0;}

Tworzenie nowego procesu w Windows Przykład 2 – potomek

#include <windows.h>int main(int argc, char *argv[]) { // CreateProcessSlave.c int pid; HANDLE Process; if (argc!=2) return -1; pid=atoi(argv[1]); Process=OpenProcess(PROCESS_QUERY_INFORMATION|SYNCHRONIZE,FALSE,pid); if (Process==NULL) return -1; printf("Oczekiwanie na zakonczenie 'Master'\n"); WaitForSingleObject(Process,INFINITE); printf("Proces 'Master' zakonczony\n"); return 0;}

Tworzenie nowego procesu w Windows – Przydatne funkcje

CreateProcessAsUser – Utworzenie nowego procesu jako określony użytkownik. Najpierw należy się zalogować za pomocą funkcji LogonUser(...).

CreateProcessWithLogon – j.w. połączenie obydwu funkcji.

ExitProcess – Bezwarunkowo kończy proces i wszystkie jego wątki.

TerminateProcess – Bezpiecznie kończy proces i wszystkie jego wątki.

GetExitCodeProcess – Zwraca kod wyjścia procesu.

GetCommandLine – Zwraca parametry linii poleceń procesu.

GetCurrentProcess – Zwraca uchwyt bieżącego procesu.

GetCurrentProcessID – Zwraca identyfikator bieżącego procesu

GetStartUpInfo – Zwraca strukturę uruchomieniową przekazaną do procesu w funkcji CreateProcess(...)

Wątki

• Każdy proces rozpoczyna się z pojedynczym, działającym wątkiem. Istniejące wątki mogą tworzyć nowe. Proces pozostaje aktywny, dopóki każdy z wątków nie zakończy działania lub gdy nie zostanie zakończony cały proces.

• Wszystkie wątki procesu działają w jego przestrzeni adresowej i korzystają z zasobów przydzielonych temu procesowi. Zmienne statyczne (globalne jak i lokalne dla funkcji) dzielone są między wątkami – znajdują się w pamięci danych procesu.

• Każdy wątek ma swój własny obszar stosu. Tak więc zmienne automatyczne (zawsze lokalne dla funkcji) są inne dla każdego wątku.

Tworzenie nowego wątkuHANDLE CreateThread( LPSECURITY_ATTRIBUTES lpThreadAttributes, // SD SIZE_T dwStackSize, // Początkowy rozmiar stosu LPTHREAD_START_ROUTINE lpStartAddress, // Funkcja wątku LPVOID lpParameter, // Parametr wywołania funkcji wątku DWORD dwCreationFlags, // Parametry tworzenia wątku LPDWORD lpThreadId // Identyfikator wątku)dwStackSize – początkowy rozmiar stosu, gdy 0, domyślny rozmiar

lpStartAddress – wskaźnik na funkcję, od której rozpoczyna się działanie wątku:

DWORD WINAPI ThreadProc( LPVOID lpParameter // thread data

);

lpParameter – wartość przekazywana do funkcji wątku (j.w.)

dwCreationFlags – gdy 0, wątek uruchamiany natychmiast, gdy CREATE_SUSPENDED, wątek w stanie zawieszonym. Uruchomienie wstrzymanego wątku: ResumeThread(...)

Kończenie wątkuDziałanie wątku kończy się z chwilą zakończenia funkcji wątku, albo przez wywołanie funkcji ExitThread().

Można wymusić zakończenie innego wątku, poprzez wywołania TerminateThread().

Tworzenie nowego wątku – programy w C, C++

uintptr_t _beginthread( void( __cdecl *start_address )( void * ), unsigned stack_size, void *arglist );

uintptr_t _beginthreadex( void *security, unsigned stack_size, unsigned ( __stdcall *start_address )( void * ), void *arglist, unsigned initflag, unsigned *thrdaddr );

Funkcje te wywołują CreateThread(..) zapewniając prawidłową współpracę ze standardowymi bibliotekami języka C i C++.

Zbiór nagłówkowy: <process.h>.Biblioteki: LIBCMT.LIB (statyczna) lub MSVCRT.LIB (import do MSVCRT.DLL).

Zakończenie wątku:void _endthread( void ); void _endthreadex( unsigned retval );

lub poprzez normalne zakończenie funkcji wątku (return).

Funkcja endthread(..) automatycznie zamyka uchwyt wątku. W przypadku endthreadex(..) należy zamknąć samodzielnie (jak w przypadku CreateThread(..), ExitThread(..)).

Tworzenie nowego wątku – Przykład 1

#include <windows.h>#include <process.h>

HANDLE mainthread;

void beepthread(void *delay) {DWORD exitcode;while (GetExitCodeThread(mainthread,&exitcode)

&& exitcode==STILL_ACTIVE) {MessageBeep(MB_OK);Sleep((int)delay);

}}

void main() {mainthread=GetCurrentThread();_beginthread(beepthread,0,(void*)1000);MessageBox(NULL,"Red Alert","Alert",MB_OK);

}

Tworzenie nowego wątku – Przykład 2

#include <windows.h>#include <stdio.h>#include <process.h>#include "resource.h„

BOOL CALLBACK TimerDlgProc (HWND , UINT , WPARAM , LPARAM);

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine, int iCmdShow) {

DialogBox(hInstance, MAKEINTRESOURCE(IDD_TIMERDLG), NULL, TimerDlgProc);

return 0 ;}

Tworzenie nowego wątku – Przykład 2

bool StopFlag;

VOID CntThread(PVOID pvoid) {long counter = 0;char buf[100];StopFlag = false;while ( !StopFlag ) {

sprintf(buf,"%d",++counter);SetWindowText((HWND)pvoid,buf);if ( counter > 100 ) StopFlag = true;Sleep(100);

}

}

Tworzenie nowego wątku – Przykład 2BOOL CALLBACK TimerDlgProc (HWND hwnd, UINT message,

WPARAM wParam, LPARAM lParam) { switch ( message ) { case WM_INITDIALOG: SetWindowText(GetDlgItem(hwnd, IDC_EDIT1),"0"); return TRUE; case WM_COMMAND: switch ( LOWORD(wParam) ) { case IDC_STARTBTN:

_beginthread(CntThread,0,(PVOID)GetDlgItem(hwnd, IDC_EDIT1));break;

case IDC_STOPBTN:StopFlag = true;break;

case IDCANCEL: case IDOK:

StopFlag = true;EndDialog(hwnd, 0);return TRUE;

} break; } return FALSE;}

Wielozadaniowość i współbieżność

• Wielozadaniowość (ang. multitasking) – zdolność systemu operacyjnego do równoczesnego wykonywania wielu programów.

• Wielowątkowość (ang. multithreading) — zdolność programów do podziału na procesy (wątki), które są wykonywane jednocześnie.

• Podstawowe rodzaje wielozadaniowości:– Z wywłaszczaniem (ang. preemptive multitasking) np.: Unix, Windows

98/NT/2000/XP, MacOS9.

– Bez wywłaszczania (ang. non-preemptive multitasking):

• Wielozadaniowość ze współpracą (ang. cooperative multitasking) np.: MacOS7.x, MacOS8.x, Windows 3.1.

Współbieżność z wywłaszczaniem

• Z punktu widzenia procesora na komputerze wykonywany jest jeden program.

• Z punktu widzenia systemu jednocześnie wykonywanych jest wiele programów.

Współbieżność z wywłaszczaniem

System operacyjny przydziela każdemu wątkowi stosunkowo krótki (dziesiąte milisekund) przedział czasu procesora. Wątek wykonuje się do chwili wyczerpania przedziału czasu, lub do chwili gdy musi poczekać na jakieś zasoby. Następnie wątek jest wywłaszczany, tzn. jest zawieszany i system operacyjny uruchamia drugi wątek, w kolejnym przedziale czasu procesora.

Współbieżność procesów i wątków

• Utworzenie nowego wątku w istniejącym procesie jest tańsze niż utworzenie procesu.

• Przełączanie między wątkami tego samego procesu jest tańsze niż między wątkami różnych procesów.

• Wątki mogą wygodnie korzystać ze wspólnych danych (zmiennych globalnych) i innych zasobów. Procesy wymieniają dane za pośrednictwem metod komunikacji IPC lub pamięci zewnętrznej.

• Z tego samego powodu jednak, wątki nie są wzajemnie przed sobą chronione.

• Przy dostępie do wspólnych zasobów, zarówno współbieżne procesy jak i wątki muszą czasami być synchronizowane. Mechanizmy synchronizacji procesów mogą być bardziej kosztowne niż wątków.

• W środowisku sieciowym utworzenie procesu wymaga wyższych uprawnień, co w pewnych sytuacjach może być problemem.

Koszt tworzenia procesu

• Konieczność utworzenia środowiska, np.:– Utworzenie tablic przestrzeni adresowej.

– Alokacja (bądź przekazanie) zasobów (konieczność otwarcia plików, portów połączeń sieciowych, itp.).

• Koszty długotrwałe, związane z inicjacją środowiska, np.:– Pierwsze odwołania do danych i instrukcji zazwyczaj skutkować będą ich

przeładowaniem między pamięcią i plikiem wymiany.

– Bufor TLB i inne bufory sprzętowe pamięci podręcznej nowego procesu nie będą zawierały żadnych danych. Będzie on je więc musiał stopniowo sprowadzać do pamięci podręcznej w trakcje działania.

• Według publikowanych poglądowych oszacowań, utworzenie procesu może wymagać nawet dziesięć razy więcej czasu niż w przypadku wątku, i to bez kosztów długotrwałych.

Koszt przełączania wątków

• PCB służy do przechowywania informacji o procesie, istotnych z punktu widzenia systemu operacyjnego:– Stan procesu– Identyfikator procesu– Licznik rozkazów– Rejestry procesora– Informacja o przydzielonej pamięci– Informacja o otwartych plikach– Informacja o połączeniach sieciowych– Informacja niezbędna do tworzenia

systemowych struktur danych. System operacyjny posługuje się różnymi kolejkami procesów. Jeżeli kolejki są implementowane jako listy z dowiązaniami, PCB może zawierać dowiązanie (wskaźnik) do następnego elementu w kolejce

Przełączanie kontekstu

• Przepisanie PCB.• Przeładowanie

zawartości TLB i innych buforów sprzętowych pamięci podręcznych.

• Zmiana domeny (ang. domain transition) – przejście do nowego środowiska ochrony (trybu jądra).

• Dla wątków tego samego procesu przełączanie kontekstu występuje tylko podczas kontaktów z jądrem.