#README
#KOREKTA 17.06.2024 (OSTATNIE SYSOPY PRZED SESJA)
4.1.1.4 Autoliczenie teraz dziala, ale jesli pokazywaloby mniej niz 50%, nalezy wykonac ponownie
        (ewentualnie bez komendy  echo bfq > /sys/block/sda/queue/scheduler)

#KOREKTA 13.05.2024 16:33 
4.1.1.7 (2) Zmiany opisowe
 
#KOREKTA 13.05.2024 16:29
4.1.1.20 Zmiany opisowe
 
#KOREKTA 13.05.2024 15:49
4.1.1.7 (2) Zmiany opisowe
4.1.1.10 HEAP I STACK BYLY NADAL ZAMIENIONE!!!!!!!!!!!!!!!!!!!!!!!
 
#ZAKTUALIZOWANE 13.05.2024 PRZED ODPOWIEDZIA
#!!!!!!!!!!!!!!!WIELOLINIJKOWE ECHO WKLEJAC NARAZ!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
#WSZYSTKO WYKONYWAC JAKO ROOT
#KOMENDY ZE SREDNIKAMI NA KONCU POWINNY BYC WRZUCANE NARAZ
#PRZED KAZDYM ZADANIEM JEST PODANA ILOSC WYMAGANYCH TERMINALI
#KAZDY TERMINAL MA PRZYPISANA CYFRE np. 1:
#Z REGULY TERMINAL 1 JEST DO LISTINGOW A TERMINAL 2 JEST ROBoCZY
#ZALECA SIE ROBIC KAZDY PODPUNKT W ODDZIELNYM TERMINALU (latwiej clearowac), A TERMINAL ROBOCZY (2) MIEC JEDEN DLA WSZYSTKICH
 
 
/////////////////////////////////////////////////////////////KONIEC LISTINGOW/////////////////////////////////////////////////////////////////////////////////////////////////////
 
4.1.1.4 Do czego sluzy klasyfikacja procesow na ograniczone procesorem i ograniczone wejsciem wyjsciem oraz na jakiej podstawie zweryfikowano, ze proces jest ograniczony wejsciem-wyjsciem? 
#ILOSC TERMINALI:  2
    1:
    echo -e "
\033[0;32m-------------------------------------------------------[4.1.1.4]-----------------------------------------------------------------------------\033[0m
    
    \033[0;32mPozwala okreslic w jaki sposob usprawnic realizacje zadan przez proces\033[0m
 
    dodatkowo pozwala okreslic w jakim stanie spedza wiekszosc czasu cyklu zycia.
    \033[0;32mOgraniczone procesorem\033[0m - spedzaja wiekszosc czasu w stanie wykonywanym.
    \033[0;32mOgranioczone wejsciem-wyjsicem\033[0m - spedzaja wiekszosc czasu w stanie zablokowanym
    \033[0;32mStan zablokowany\033[0m - oczekuje na pozostale zasoby systemowe oprocz stron pamieci
 
    \033[0;32m
    zeby wiedziec jak usprawnic realizacje zadania/zadan przez proces. Dla procesow
    ograniczonych procesorem mozemy zwiekszyc przydzial jednostek przetwarzajacych, a w
    procesach ograniczonych wejsciem wyjsciem mozna poprawic warunki realizacji operacji
    dyskowych.
    \033[0m
 
    Jezeli proces zglasza operacje dyskowe to mozemy poprawic warunki realizacji operacji
    dyskowych.
 
    Nie kazda operacje wejscia wyjscia mozna usprawnic, ale operacje dyskowe akurat mozna.
 
    \033[0;32mOperacje dyskowe wejscia wyjscia\033[0m to odczyt i zapis
    
    proces moze przebywac w stanie \033[0;32mzablokowanym, wykonywanym i gotowym do wykonania\033[0m
 
    \033[0;32mReal\033[0m – calkowity czas istnienia procesu – czas cyklu zycia procesu
    \033[0;32mRuntime\033[0m – czas przebywania procesu w stanie wykonywanym (Wirtualny czas zycia procesu)
    \033[0;32mswitches*avg delay\033[0m – czas przebywania procesu w stanie gotowym do wykonania
    \033[0;32mswitches\033[0m – przelaczenia kontekstu, w ktorych ten proces uczestniczyl
    \033[0;32mavg delay\033[0m – sredni czas oczekiwania na przydzial jednostki przetwarzajacej
    "
 
 
 2:
 echo bfq > /sys/block/sda/queue/scheduler
 variable=""$({   time perf sched record timeout 20 dd if=/dev/sda of=/dev/null bs=512K >/dev/null; } 2>&1 | grep real)""
 echo $variable

 1:
 cat /proc/$(pidof dd -s)/status | grep Threads
 ps -o pid,etime,cputime,%cpu $(pidof dd -s)
 pmap -x $(pidof dd -s)
 pmap -X $(pidof dd -s) | grep --color -E "stack|heap|$"

 echo -e "\033[0;32mVSZ\033[0m - rozmiar stron\n \033[0;32mRSZ\033[0m - rozmiar ramek"
 ps -o pid,vsz,rsz $(pidof dd -s)
 cat /proc/$(pidof dd -s)/status | grep Threads

 2:
 #PO ZAKONCZENIU PROCESU W TERMINALU 1 (10s)

 perf sched latency -p | grep -e "Task" -e "dd"

#tu wszystko WKLEJAC RAZEM az do komentarza KONIEC
real=${variable#*0m};
real=${real%%s*};
real=$(tr ',' '.' <<<"$real");
real=$(echo "scale=2; ($real * 1000)" | bc);

variable="$( perf sched latency -p | grep -e "dd")";
runtime=${variable#*|};
runtime=${runtime%%ms*};
variable="$( perf sched latency -p | grep -e "dd")";
avg=${variable#*avg:};
avg=${avg%%ms*};
variable="$( perf sched latency -p | grep -e "dd")";
switches=${variable#*ms |};
switches=${switches%% |*};

lockedTime=$(echo "scale=2; $real - $runtime - ($switches * $avg)" | bc);
lockedPercentage=$(echo "scale=2; $lockedTime / $real * 100" | bc);

echo -e "
Czas w stanie zablkowanym = real - runtime - (switches * avg)
Procent w czasie zablokowanym = Czas w stanie zablokowanym / real * 100%

runtime[ms]:     $runtime ms
avg delay[ms]:      $avg ms
switches:      $switches
real[s]:              $real ms
Czas w stanie zablokowanym: $lockedTime ms
Procent w stanie zablokowanym: \033[0;32m$lockedPercentage\033[0m %
\033[0;32m$lockedPercentage\033[0m % > 50 %, wiec proces jest ograniczony wejsciem-wyjsciem
";
#KONIEC


4.1.1.5 (brakujace). Sekretne pytanie brakujace z wikampa: Jak okreslic cykl zycia procesu i czym jest wirtualny czas zycia procesu? - wymagane zaprezentowania odpowiednich wartosci w listingu
#ILOSC TERMINALI: 1
 1:
 echo -e "
 \033[0;32m-------------------------------------------------------[4.1.1.5]-----------------------------------------------------------------------------\033[0m
 \033[0;32mCykl zycia procesu\033[0m to calkowity czas przez jaki istnial proces (\033[0;32mreal\033[0m)
 \033[0;32mWirtualny czas zycia procesu\033[0m to czas w jakim kod programu byl wykonywany / czas realizacjizadania / czas w stanie wykonywanym (\033[0;32mruntime\033[0m)"
 
 echo bfq > /sys/block/sda/queue/scheduler
 time perf sched record ionice -c 1 -n 0 stress -i 1 -t 3
 perf sched latency -p | grep -e "Task" -e "stress"
 
4.1.1.6 Co reprezentuje wartosc %cpu dla procesu jednowatkowego? - dla jakiego procesu wartosc %cpu moze przekroczyc 100%?
#ILOSC TERMINALI: 2
    1:
    echo -e "
\033[0;32m-------------------------------------------------------[4.1.1.6]-----------------------------------------------------------------------------\033[0m
cputime / etime * 100% -- procent cyklu zycia w kotrym proces przebywal w stanie wykonywanym (suma wirtualnych czasow zycia watku musi byc wiekszy niz czas zycia procesu)
Ta wartosc reprezentuje czas przetwarzania podzielony przez czas zycia procesu.
\033[0;32mstosunek wirtualnego czasu zycia procesu do jego rzeczywistego czasu zycia procesu \033[0m (runtime/real)
 
\033[0;32mReal\033[0m – calkowity czas istnienia procesu – czas cyklu zycia procesu
\033[0;32mRuntime\033[0m – czas przebywania procesu w stanie wykonywanym
 
\033[0;32mMoze przekroczyc 100%\033[0m Dla procesu posiadajacego wiele watkow, ktore wiekszosc czasu spedzaja w stanie wykonywanym
czyli
jesli sumaryczny czas przetwarzania zadan przez watki jest wiekszy niz czas cyklu zycia procesu."
 
#WIELOWATKOWY
    2:
    sysbench --test=cpu --threads=2 --time=70 run
    1:
    echo -e "\033[0;32mWieloowatkowy\033[0m"
    cat /proc/$(pidof sysbench -s)/status | grep Threads
    ps -o pid,cmd,nlwp,%cpu,cputime,etime "$(pidof sysbench -s)" ;ps -o pid,spid,%cpu,cputime,etime -T "$(pidof sysbench -s)" | grep --color -E " %CPU|$" 
 
#JEDNOWATKOWY
    2:
    echo bfq > /sys/block/sda/queue/scheduler
    time perf sched record dd if=/dev/sda of=/dev/null
    #sysbench --test=cpu --threads=1 --time=70 run
    1:
    echo -e "\033[0;32mJednowatkowy\033[0m";
    echo -e "Dla procesu jednowatkowego \033[0;32mnie moze przekroczyc 100%\033[0m";
    cat /proc/$(pidof dd -s)/status | grep Threads;
     #PO CHWILI PRZERWAC DD ZA POMOCA CTRL + C (raz)
    ps -o pid,cmd,nlwp,%cpu,cputime,etime "$(pidof dd -s)" ;ps -o pid,spid,%cpu,cputime,etime -T "$(pidof dd -s)" | grep --color -E " %CPU|$" 
 
4.1.1.7 (1). Co reprezentuje wartosc %mem dla procesu? - wymagane wykazanie w listingach wartosci, na bazie ktorych %mem jest wyliczany
#ILOSC TERMINALI: 2
    1:
    echo -e "
\033[0;32m-------------------------------------------------------[4.1.1.7 (1)]-----------------------------------------------------------------------------\033[0m
    \033[0;32mJest to stosunek pamieci fizycznej ulotnej przydzielonej procesowi do dostepnej (uzytecznej) fizycznej ulotnej pamieci (pamiec fizyczna bez kernela) (RSZ / Total online memory[w tym przypadku 5.8G])\033[0m
    \033[0;32m%MEM\033[0m = RSZ / MEM total * 100%
    \033[0;32mRSS\033[0m (\033[0;32mRSZ\033[0m) - ZBIOR ROBOCZY (working set), zbior ramek dla procesu, tworzy obszar roboczy
    \033[0;32mtotal\033[0m - fizyczna pamiec ulotna maszyny
    \033[0;32mTablica stron\033[0m - zawiera uzywane przez proces \033[0;32mramki ze stronami\033[0m, jest nieciagla i hierarchiczna
    \033[0;32mobszar roboczy\033[0m - zbior ramek
    \033[0;32mlsmem\033[0m - pokazuje calkowita pamiec ulotna fizyczna maszyny
    \033[0;32mfree\033[0m - pokazuje dostepna (uzyteczna) pamiec ulotna [pamiec fizyczna - kernel - zarezerwowana przez system]"
 
    2:
    stress -m 1 -t 60
 
    1:
    lsmem | grep --color -E "Total online memory:|$"
    ps -o pid,%mem,rsz "$(pidof stress -s)" | grep --color -E " %MEM|total|$" ; free -h | grep --color -E "total|$"
 
 
4.1.1.7 (2). Czy calosc jego kodu i danych jest wczytywana z pliku programu ELF oraz plikow bibliotek ELF do fizycznej pamieci ulotnej?  
- wymagane zaprezentowania odpowiednich wartosci dla segmentu danych i tekstu w listingu z mapa pamieci procesu jednowatkowego.
#ILOSC TERMINALI: 2
 
    1:
    echo -e "
\033[0;32m-------------------------------------------------------[4.1.1.7 (2)]-----------------------------------------------------------------------------\033[0m
\033[0;32mNie wszystkie\033[0m, czesc kodu i danych wczytywana jest z segmentow anonimowych.
\033[0;32mr-x\033[0m - zawiera text
Dane:
\033[0;32mrw-\033[0m - zawiera zmienna
\033[0;32mr--\033[0m - zawiera stala
 
Jezeli rozmiar \033[0;32mKbytes\033[0m i \033[0;32mRSS\033[0m sa inne oznacza to, ze nie wszystkie strony zostaly wczytane do ramek
 
czyli \033[0;32mrozmiar stron jest wiekszy od rozmiaru ramek\033[0m
 
Ramki znajduja sie w \033[0;32mzbiorze roboczym (zbiorze ramek)\033[0m
"
    2:
    echo bfq > /sys/block/sda/queue/scheduler
    time perf sched record ionice -c 1 -n 0 stress -i 1 -t 240
 
    1:
    #POKAZUJESZ DOWOLNY SEGMENT (KOLOREM JEST PRZYKLADOWY ZAZNACZONY) TEKSTU LUB DANYCH I ZAZNACZASZ, ZE "Kbytes" JEST WIEKSZE OD "RSS"
    pmap -x $(pidof stress -s)| grep --color -E "Kbytes|RSS|r-x-- libc.so.6|$";
 
 
4.1.1.10. Ktory z segmentow procesu zawiera sterte, a ktory stos? Czy segment sterty/stosu sa anonimowe? - wymagane wskazanie segmentu sterty i stosu w mapie pamieci wybranego procesu.
#ILOSC TERMINALI: 2
    2:
    echo bfq > /sys/block/sda/queue/scheduler
    time perf sched record ionice -c 1 -n 0 stress -i 1 -t 240
 
    1:
    echo -e "
\033[0;32m-------------------------------------------------------[4.1.1.10]-----------------------------------------------------------------------------\033[0m
[\033[0;32mstack\033[0m] - stos (Segment z mapowaniem [ stack ])
[\033[0;32mheap\033[0m] - sterta(Segment z mapowaniem [ heap])
tak, \033[0;32moba sa anoniowe\033[0m, poniewaz ich zawartosc zostala wytworzona przez proces, a nie wczytana z pliku. 
 
\033[0;32mSterta\033[0m zawiera dane wytworzone przez proces np. zmienne lokalne, jest dynamicznie przyznawana procesowi.
 
Zawartosc segmentu procesu \033[0;32mmoze pochodzic z biblioteki\033[0m.
 
\033[0;32mPamiec anonimowa\033[0m lub mapowanie anonimowe reprezentuja pamiec, ktora nie jest obslugiwana przez system plikow.
Takie mapowania sa tworzone niejawnie dla stosu i sterty programu przez jawne wywolanie wywolania systemowego
mmap."
 
pmap -X $(pidof stress -s)| grep --color -E "stack|heap|$"
    
 
4.1.1.12. Jaki rozmiar zajmuja wszystkie strony procesu a jaki wszystkie przydzielone dla procesu ramki oraz kiedy strona jest ladowana do ramki?  - wymagane wskazanie odpowiednich wartosci w listingach
#ILOSC TERMINALI: 2
    2:
    echo bfq > /sys/block/sda/queue/scheduler
    time perf sched record ionice -c 1 -n 0 stress -i 1 -t 240
 
    1:
    echo -e "
\033[0;32m-------------------------------------------------------[4.1.1.12]-----------------------------------------------------------------------------\033[0m
\033[0;32mVSZ\033[0m - rozmiar stron [KiB]
rozmiar wszystkich przydzielonych dla procesu stron (w KiB) (cała pamięć, do której proces ma dostęp, czyli
pamięć wymieciona + pamięć zaalokowana + pamięć bibliotek współdzielonych + pamięć plików wykonywalnych)
 
\033[0;32mRSZ\033[0m - rozmiar ramek [KB]
rozmiar wszystkich przydzielonych dla procesu ramek z jego stronami (w KB) (nie uwzględnia SWAP, ale
uwzględnia pamięć bibliotek współdzielonych, czyli pokazuje tylko stan aktualny ramek w pamięci fizycznej)
 
\033[0;32mStrona jest ladowana do ramki\033[0m (czyli fizycznej strony pamieci) w momencie, gdy proces potrzebuje dostepu do danego obszaru pamieci wirtualnej,
ktory nie jest obecnie obecny w pamieci fizycznej.\n
 
\033[0;32mnie kazda\033[0m strona jest przechowywana w ramce tego procesu\n
gdy proces odwoluje sie do strony pamieci ktorej nie ma w zadnej z jego ramek \033[0;32mwystapi blad strony\033[0m
\033[0;32mkolejnosc odszukiwania strony\033[0m - poza zbiorem roboczym, (gdy wystapi \033[0;32mblad strony\033[0m):
\033[0;32m1.\033[0m swap cache - jesli znajdzie to blad poboczny, aktualizacja zbioru roboczego, pozniej tablicy
stron
\033[0;32m2.\033[0m przestrzeni wymiany swap
\033[0;32m3.\033[0m plik regularny tego programu lub biblioteki
 
\033[0;32mStrona jest ladowana do ramki\033[0m w momencie, gdy program probuje uzyskac dostep do tej strony.
 
To co proces ma w segmentach to jego pamięć wirtualna, każdy segment jest podzielony na strony. Te ze stron, które są
załadowane do ramek to jego rzeczywista fizyczna pamięć ulotna. Strony, które nie są w ramkach, znajdują się w
plikach regularnych programu lub bibliotekach, wykorzystywanych przez proces. Strona. która jest niepotrzebna dla
procesu zmienia oznaczenie na nieaktywną i jej właścicielem zostaje swap cache."
 
    ps -o pid,vsz,rsz $(pidof stress -s) | grep --color -E "VSZ|RSZ|$"
 
 
 
4.1.1.20. Jezeli plik zawierajacy program/biblioteke ELF zostanie usuniety, to skad system operacyjny bedzie doczytywal potrzebne strony, jaki jest zwiazek pomiedzy niezwolnionymi blokami systemu plikow a stronami? - omowienie statystyk wezlow i blokow systemu plikow, aby stwierdzic czy po usunieciu pliku zostaly one zwolnione wraz z usunietym wpisem katalogowym. 
#ILOSC TERMINALI: 2
    2:
    cp /usr/bin/stress /home/tytus/stress
    /home/tytus/stress -c 1
 
    1:
    echo -e "
\033[0;32m-------------------------------------------------------[4.1.1.20]-----------------------------------------------------------------------------\033[0m
    Jezeli plik zawierajacy program/biblioteke ELF zostanie usuniety, to system operacyjny \033[0;32mbedzie doczytywal potrzebne strony Ze swap cache\033[0m
    jezeli nie ma potrzebnej strony w swapcache i strona nie jest wczytana do ramki to z swap.
    
    Zostanie usuniety jedynie wpis katalogowy - \033[0;32mnie zostana zwolnione\033[0m zadne bloki ani wezel zwiazany z tym plikiem
    Bloki nie zostaly zwolnione poniewaz proces korzysta ze wczytanych wczesniej stron programu/biblioteki.
 
    \033[0;32mBloki te blokuje\033[0m mechanizm pamieci wirtualnej, zeby moc doczytac
 
    Bloki i wezel \033[0;32mzostana zwolnione\033[0m, gdy wszystkie procesy korzystajace z tego pliku zostana zakonczone
    Wynika z tego, ze nie każde usunięcie plików w systemie plików spowoduje zwolnienie miejsca,
 
    Niezwolnione bloki systemu plikow to dane przechowywane na dysku, podczas gdy strony w
    pamieci operacyjnej sa ich buforowanymi wersjami w pamieci RAM, co umozliwia szybszy
    dostep do tych danych podczas operacji odczytu i zapisu
 
    \033[0;32mPo usunieciu\033[0m pliku z programem strona znajduje sie w bloku
 
    Blok ma taki sam rozmiar jak strona, przez co \033[0;32mmoze byc odczytywany jako strona\033[0m
    
    Strone jako blok odczytuje \033[0;32mmechanizm pamieci wirtualnej\033[0m"
 
    #TO MUSI BYC ZROBIONE W TRAKCIE TRWANIA PROCESU STRESS (UPEWNIC SIE, ZE DZIALA ^^^)
    stat -f /home/tytus | grep --color -E "wolnych:|$" 
    ls /home/tytus
    rm /home/tytus/stress -f
    stat -f /home/tytus | grep --color -E "wolnych:|$" 
    ls /home/tytus
    killall stress
    #TUTAJ BEDZIE WIECEJ WOLNYCH:
    stat -f /home/tytus | grep --color -E "wolnych:|$" 
4.1.1.21. Z jakiego obszaru pamieci ulotnej wybierane sa niepuste ramki i jakie kryteria musi spelniac ramka wybrana przez algorytm wymiany? - analiza wynikow free –w dotyczaca roznicy w wartosciach pomiedzy kolumna free i available w wierszu mem. 
#ILOSC TERMINALI: 1
    1:
    echo -e "
\033[0;32m-------------------------------------------------------[4.1.1.21]-----------------------------------------------------------------------------\033[0m
    \033[0;32mBierze z swap cache\033[0m
 
    \033[0;32mAlgorytm wymiany\033[0m (algorytm zastępowania stron)  bedzie wybieral przede wszystkim ramki ze stronami niekatywnymi,
    a w szczegolnosci zawierajace strony niezabrudzone i nieanonimowe (czyli ramki które mogą być natychmiastowo wykorzystane).
 
    \033[0;32mMEM free\033[0m - rozmiar wolnej pamięci fizycznej ulotnej (rozmiar wolnych ramek), ale bez ramek z przestrzeni swap-cache
    \033[0;32mMEM available\033[0m - wartość free + ramki ze swap cache zawierające niezabrudzone i nieanonimowe strony (możliwe,
    że jeszcze + ramki z buforów zawierające niezabrudzone strony)
 
    \033[0;32mStrony nieaktywne\033[0m - nie byly ostatnio uzywane (nie bylo do nich w ostatnim czasie odwołań)
 
    \033[0;32mStrony niezabrudzone\033[0m - ich zawartosc nie zmienila sie od momentu wczytania ich do ramki
 
    \033[0;32mstrony nieanonimowe\033[0m - strony ktorych zawartosc zostala wczytana z pliku regularnego z programem lub biblioteka
 
    fakt ze ramka z ta strona nalezy do swap cache oznacza, ze \033[0;32mstrona jest nieaktywna\033[0m
    
    Ramki zawierajace strony niezabrudzone i nieanonimowe moga byc natychmiastowo wykorzystane
    
    Jeśli ramka w swap cache zawiera stronę \033[0;32mzabrudzoną\033[0m lub \033[0;32manonimową\033[0m, to nie możemy załadować do niej strony,
    ponieważ nadpisalibyśmy dane. Dlatego takie strony są utwrwalane w przestrzeni wymiany. Będą to np. strony
    zawierające ramkę tekstu, ponieważ ramka tekstu zawiera kod programu, więc nie może zostać zmieniona. 
    
    Za wczytywanie stron do ramek odpowiada system operacyjny
    
    Jeżeli wartość available jest niska to zachodzi procedura OOM (Out Of Memory)"
 
    free -wh | grep --color -E "free|available|$" 
 
4.1.1.24. Jakie zasoby systemowe trzeba monitorowac i jakie dzialania mozna podjac aby procedura OOM nie byla zastosowana? - wymagane zaprezentowanie odpowiednich wartosci w listingach.
#ILOSC TERMINALI: 1
    1:
    echo -e "
\033[0;32m-------------------------------------------------------[4.1.1.24]-----------------------------------------------------------------------------\033[0m
    Należy regularnie kontrolować stan dostępnej pamięci operacyjnej (mem \033[0;32mused\033[0m i \033[0;32mavailable\033[0m) oraz ile mamy wykorzystanej
    pamięci swap (ilosc wolnych ramek w pamieci, zajetosc przestrzeni wymiany swap)
 
    Jeśli posiadamy mało wolnej ulotnej pamięci fizycznej (available) oraz mało wolnej pamięci przestrzeni wymiany (free),
    możemy spodziewać się podjęcia przez system operacyjny odpowiednich kroków
    
    \033[0;32mW przypadku presji pamieci\033[0m (kiedy brakuje ramek) system stosuje:
    \033[0;32m1.\033[0m wymiatanie stron.
    \033[0;32m2.\033[0m redukcja zbioru roboczego procesu - odebranie czesci przydzielonych procesom ramek
    \033[0;32m3.\033[0m procedura OOM (Out of Memory) - wybierane sa procesy, ktore zostana natychmiast zakonczone
    
    Aby procedura OOM nie była zastosowana możemy:
    \033[0;32m- powiekszyc przestrzen wymiany\033[0m poprzez dodanie pliku wymiany (ale tylko w Linuxie, w Windowsie nie można, bo trzeba by było restartować system
    \033[0;32m- zakonczyc procesy\033[0m, które są nam już niepotrzebne, dzięki czemu będziemy mieli kontrolę nad procesami, które zostaną zamknięte
    \033[0;32m- zapisać stan procesów\033[0m na dysku.
    
    Dlatego też instalowanie systemu bez przestrzeni wymiany swap jest złym pomysłem, ponieważ bez magazynów stron
    przyspierzymy wystąpienie procedury OOM.

    \033[0;32mfree\033[0m - rozmiar wolnej pamieci ulotnej(operacyjnej) ale bez ramek z przestrzeni swap cache (NIE UZYWANA PRZEZ ZADEN URUCHOMIONY PROCES,
        GOTOWA DO ALOKACJI DLA NOWEGO PROCESU)

    \033[0;32mAvailable\033[0m - rozmiar wolnych ramek wraz z ramkami z swap-cache, ktore zawieraja niezabrudzone i nieanonimowe strony
    
    pokaze wartosc free(mem)(rozmiar wolnych ramek) + ramki ze swap cache NIEZABRUDZONE I NIEANONIMOWE strony + z buforow te zabrudzone

    SZACUJE ILOSC PAMIECI MOZLIWA DO PRZYDZIELENIA NOWEMU PROCESOWI, BIERZE POD UWAGE BUFORY I CACHE, KTORE MOGA ZOSTAC ZWOLNIONE PRZEZ INNE PROCESY W RAZIE POTRZEBY
"
 
    free -wh | grep --color -E "free|used|$" 
 
/////////////////////////////////////////////////////////////KONIEC LISTINGOW/////////////////////////////////////////////////////////////////////////////////////////////////////
Z tego co widze to dodatkowe:
 
Blad poboczny wystepeuje gdy strona przechowyana jest w ramce(np. w swap cache) jednak nie wystepuje w zbiorze roboczym, wtedy wymagana jest aktualizacja tablicy stron
 
Blad glowny wymaga zaladowania strony do ramki(np z programu, biblioteki lub sprowadzenia z przestrzeni wymiany swap).
 
Wyswietlanie informacji o biezacych priorytetach I/O dla procesow:
ionice -p <pid>
 
Zmiana algorytmu windy dla dysku:
echo bfq > /sys/block/sda/queue/scheduler
 
ionice -c 1 -n 0
-c 1 (Realtime) to klasa o najwyzszym priorytecie I/O w systemie 
Priorytet 0 to najwyzszy priorytet dla ionice -c 1, zakres (0-7)
 
Algorytmy windy:
Algorytm BFQ dazy do uczciwego podzialu zasobow dyskowych miedzy procesy. Przydziela czas dostepu do dysku kazdemu procesowi w proporcji do jego budzetu. Priorytet I/O: Procesy o wyzszym priorytecie I/O maja wieksze szanse na otrzymanie wiekszego budzetu
///////////////////////////////////////////////////////////////////////////////////////////////////////////////