---
# System prepended metadata

title: Systemy operacyjne - Lista 8

---

# Systemy operacyjne - Lista 8

### Zadanie 1

![](https://i.imgur.com/Xzh7M4J.png)
#### Jakie są wady stosowania sbrk do zarządzania rozmiarem sterty przez biblioteczny algorytm zarządzania pamięcią malloc(3)?
- Jedną z wad stosowania wywołania systemowego sbrk(2) do zarządzania rozmiarem sterty przez biblioteczny algorytm zarządzania pamięcią malloc(3) jest to, że sbrk(2) nie umożliwia dzielenia już przydzielonej pamięci na mniejsze fragmenty, co może prowadzić do nieefektywnego wykorzystania pamięci. Ponadto, sbrk(2) nie umożliwia przydzielania pamięci w dowolnym miejscu w przestrzeni użytkownika, co może utrudnić zarządzanie pamięcią w przypadku złożonych struktur danych.

#### Jak można to poprawić przy pomocy mmap i munmap? 
- Aby poprawić te wady, można użyć wywołań systemowych mmap(2) i munmap(2) do zarządzania rozmiarem sterty przez biblioteczny algorytm zarządzania pamięcią malloc(3). Wywołanie mmap(2) pozwala na dzielenie już przydzielonej pamięci na mniejsze fragmenty, a także na przydzielanie pamięci w dowolnym miejscu w przestrzeni użytkownika.

#### Kiedy procedura free może zwrócić pamięć do jądra?
- Aby zwrócić pamięć do jądra, procedura free może wywołać wywołanie systemowe munmap(2), które zwolni określony fragment pamięci w przestrzeni użytkownika i zwróci go do jądra. Alternatywnie, procedura free może przechowywać przydzieloną pamięć w kolejce oczekującej na zwolnienie, a następnie wywołać munmap(2), gdy kolejka osiągnie pewien próg lub w odpowiednim momencie (np. w momencie, gdy system operacyjny próbuje zwolnić pamięć).

### Zadanie 2
![](https://i.imgur.com/54oz2DC.png)

#### Fragmentation is the inability to reuse memory that is free.

**Fragmentacja wewnętrzna** to zjawisko, w którym przydzielona pamięć jest podzielona na mniejsze fragmenty, które nie mogą być wykorzystane do przydzielenia większych bloków pamięci. Fragmentacja wewnętrzna może prowadzić do nieefektywnego wykorzystania pamięci i utrudniać zarządzanie pamięcią w przypadku złożonych struktur danych.

:::spoiler **Wewnętrzna(slajd 12)**
![](https://i.imgur.com/Pw5YkYk.png)
:::

<br>

**Fragmentacja zewnętrzna** to zjawisko, w którym przestrzeń pamięci jest podzielona na wiele nieciągłych fragmentów, z których każdy jest wolny, ale nie można ich połączyć w jeden ciągły obszar, aby przydzielić większy blok pamięci. Fragmentacja zewnętrzna może prowadzić do sytuacji, w której istnieje wolna pamięć, ale nie można jej wykorzystać do przydzielenia większych bloków pamięci.

:::spoiler **Zewnętrzna(slajd 13)**
![](https://i.imgur.com/E7Q6r9w.png)
:::
#### Czemu algorytm malloc nie można stosować kompaktowania?
- Algorytm malloc nie może być stosowany do kompaktowania pamięci, ponieważ kompaktowanie wymaga przeniesienia istniejących bloków pamięci w celu utworzenia ciągłego obszaru wolnej pamięci. Algorytm malloc nie ma wiedzy o konkretnych blokach pamięci i nie może ich przenosić.

#### Na podstawie [6 , §2.3] opowiedz o dwóch głównych przyczynach występowania fragmentacji zewnętrznej.
:::danger
### Przeczytać 6, 2.3
![](https://i.imgur.com/ZH9vHl1.png)
XDDDDD
Główne przyczyny fragmentacji zewnętrznej to:

- External fragmentation means that there are free blocks of memory of some sizes but those are the wrong sizes to satisfy current needs. This happens when objects of one size are freed and then objects of another size are allocated-that is when there is an unfortunate change in the relative prop ortions of objects of one size and objects of a larger size.
- Fragmentation is caused by time-varying behavior especially peaks using different sizes of objects.
:::

### Główne przyczyny fragmentacji:

:::spoiler **Fragmentation is caused by isolated deaths:**
A crucial issue is the creation of free areas whose neighboring areas are not free This is a function of two things which objects are placed in adjacent areas and when those objects die Notice that if the allocator places objects together in memory and they die at the same time with no intervening allocations no fragmentation results the objects are live at the same time using contiguous memory and when they die they free contiguous memory An allocator that can predict which objects will die at approximately the same time can exploit that information to reduce fragmentation by placing those objects in contiguous memory.
:::

:::spoiler **Fragmentation is caused by timevarying behavior:**
Fragmentation arises from changes in the way a program uses memoryfor example freeing small blocks and requesting large ones This much is obvious but it is important to consider patterns in the changing behavior of a program such as the freeing of large numbers of objects and the allocation of large numbers of objects of dierent types Many programs allocate and free dierent kinds of objects in dierent stereotyped ways Some kinds ofobjects accumulate over time but other kinds may be used in bursty patterns This will be discussed in more detail in Section  The allocators job is to exploit these patterns if possible or at least not let the patterns undermine its strategy.
:::

### Zadanie 3
![](https://i.imgur.com/wknk10N.png)

#### Posługując się wykresem wykorzystania pamięci w trakcie życia procesu opowiedz o trzech wzorcach przydziału pamięci występujących w programach [6 , §2.4]: 

##### Pierwsze 3 najlepiej pokazują:

::: spoiler Wykres(Peaks GCC)
![](https://i.imgur.com/5iXuZiV.png)
:::

- Peaks. Many programs use memory in bursty patterns, building up relatively large data structures which are used for the duration of a particular phase, and then discarding most or all of those data structures. Note that the "surviving" data structures are likely to be of different types, because they represent the results of a phase, as opposed to intermediate values which may be represented differently. (A peak is like a ramp but of shorter duration).

::: spoiler Wykres(Ramps Grobner)
![](https://i.imgur.com/SJnJ0kY.png)
:::

- Ramps. Many programs accumulate certain data structures monotonically over time. This maybe because they keep a log of events, or because the problem, solving strategy requires building a large representation, after which a solution can be found quickly.
 
::: spoiler Wykres(Plateus Hypercube)
![](https://i.imgur.com/peWPQKh.png)
:::

- Plateaus. Many programs build up data structures quickly, and then use those data structuresfor long periods (often nearly the whole running time of the program).

##### Reszta wykresów:

:::spoiler Wykres 4(Plateaus)
![](https://i.imgur.com/WwFpwlN.png)
:::

:::spoiler Wykres 5(Ramp->Plateus)
![](https://i.imgur.com/mDSVuG2.png)
:::

:::spoiler Wykres 6(KURLA WSZYSTKO JAK NA WOJNIE RZUCAJA TU WSZYSTKIM)
![](https://i.imgur.com/PDYjZNX.png)
:::



:::danger
::: spoiler co napisał BOT
#### Wzorce przydziału pamięci występujące w programach to:

- Wzorzec przydziału pamięci w krótkim czasie życia - w tym wzorcie bloki pamięci są przydzielane i zwalniane w krótkim czasie, co może prowadzić do dużej fragmentacji zewnętrznej.

- Wzorzec przydziału pamięci w długim czasie życia - w tym wzorcie bloki pamięci są przydzielane i zwalniane w długim czasie, co może prowadzić do nieefektywnego wykorzystania pamięci.

- Wzorzec przydziału pamięci w zmiennym czasie życia - w tym wzorcie bloki pamięci są przydzielane i zwalniane w zmiennym czasie, co może prowadzić do złożonych wzorców fragmentacji zewnętrznej.
:::

#### Na podstawie paragrafu zatytułowanego „Exploiting ordering and size dependencies” wyjaśnij jaki jest związek między czasem życia bloku, a jego rozmiarem:

- Objects allocated at about the same time are likely to die together at the end of a phase,if consecutively-allocated objects are allocated in contiguous memory, they will free contiguous memory.

- Objects of different types may be likely to serve different purposes and die at different times. Size is likely to be related to type and purpose, so avoiding the intermingling of different sizes (and likely types) of objects may reduce the scattering of long-lived objects among short-lived one

##### Conclusions:

This suggests that objects allocated at about the same time should be allocated adjacent to each other in memory, with the possible amendment(poprawką) that different-sized objects should be segregate.

:::danger
::: spoiler co naspisał bot
Istnieje związek między czasem życia bloku a jego rozmiarem, ponieważ dłuższy czas życia bloku może prowadzić do fragmentacji zewnętrznej, a krótszy czas życia bloku może prowadzić do nieefektywnego wykorzystania pamięci.
:::

#### Wyjaśnij różnice między politykami znajdowania wolnych bloków: first-fit, next-fit i best-fit. Na podstawie [6, §3.4] wymień ich słabe i mocne strony:

Polityki znajdowania wolnych bloków to sposoby, w jakie algorytm zarządzania pamięcią wyszukuje wolne bloki pamięci, które mogą zostać przydzielone procesowi. Główne polityki znajdowania wolnych bloków to:

- first-fit - w tej polityce algorytm zarządzania pamięcią wyszukuje pierwszy napotkany wolny blok pamięci, który jest wystarczająco duży, aby przydzielić go procesowi.

- next-fit - w tej polityce algorytm zarządzania pamięcią wyszukuje pierwszy wolny blok pamięci, który znajduje się za ostatnim blokiem pamięci, który został przydzielony procesowi, i który jest wystarczająco duży, aby przydzielić go procesowi.

- best-fit - w tej polityce algorytm zarządzania pamięcią wyszukuje najlepszy wolny blok pamięci, który jest wystarczająco duży, aby przydzielić go procesowi.

#### Słabe strony polityki first-fit to:

- może prowadzić do fragmentacji zewnętrznej, ponieważ nie uwzględnia rozmiaru wolnych bloków pamięci
- może być nieefektywna, ponieważ musi przeszukiwać całą dostępną pamięć, aby znaleźć wolny blok pamięci

#### Mocne strony polityki first-fit to:

- prosta implementacja
- szybkie przydzielanie pamięci

#### Słabe strony polityki next-fit to:

- może prowadzić do fragmentacji zewnętrznej, ponieważ nie uwzględnia rozmiaru wolnych bloków pamięci może być nieefektywna, ponieważ musi przeszukiwać całą dostępną pamięć, aby znaleźć wolny blok pamięci, chyba że znajdzie taki blok za ostatnim przydzielonym blokiem pamięci

#### Mocne strony polityki next-fit to:

- szybsze przydzielanie pamięci niż w polityce first-fit, ponieważ nie musi przeszukiwać całej dostępnej pamięci, jeśli znajdzie wolny blok za ostatnim przydzielonym blokiem pamięci

#### Słabe strony polityki best-fit to:

- wymaga przeszukiwania całej dostępnej pamięci, aby znaleźć najlepszy wolny blok pamięci, co może być czasochłonne
- może prowadzić do fragmentacji zewnętrznej, ponieważ przydziela najmniejszy dostępny wolny blok pamięci, co może powodować powstawanie wolnych fragmentów pamięci

#### Mocne strony polityki best-fit to:

- najlepsze wykorzystanie dostępnej pamięci, ponieważ przydziela najmniejszy dostępny wolny blok pamięci, co minimalizuje ilość niewykorzystanej pamięci
- minimalizuje fragmentację zewnętrzną, ponieważ przydziela najmniejszy dostępny wolny blok pamięci, co zmniejsza ilość wolnych fragmentów pamięci.

Na podstawie powyższych informacji można stwierdzić, że polityka first-fit jest prosta w implementacji i pozwala na szybkie przydzielanie pamięci, ale może prowadzić do fragmentacji zewnętrznej i być nieefektywna w wykorzystaniu dostępnej pamięci. Polityka next-fit jest szybsza niż first-fit, ponieważ nie musi przeszukiwać całej dostępnej pamięci, ale również może prowadzić do fragmentacji zewnętrznej i być nieefektywna w wykorzystaniu dostępnej pamięci. Polityka best-fit jest najlepsza w wykorzystaniu dostępnej pamięci i minimalizuje fragmentację zewnętrzną, ale wymaga przeszukiwania całej dostępnej pamięci, co może być czasochłonne.


### Zadanie 4
![](https://i.imgur.com/3IKZCOd.png)

:::spoiler **Best-fit**
```
początek->
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| A | B | C | D | E | F | G | H | I | J | K | L | M | N | O |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

alloc(4) ->
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| A | B | C | D | E | F | G | H | I | J | K | L | M | N | O |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 6 |   |   |   |   |   |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

alloc(8) ->
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| A | B | C | D | E | F | G | H | I | J | K | L | M | N | O |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 6 | 10|   |   |   |   |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

alloc(4) ->
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| A | B | C | D | E | F | G | H | I | J | K | L | M | N | O |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 6 | 10| 6 |   |   |   |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

alloc(4) ->
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| A | B | C | D | E | F | G | H | I | J | K | L | M | N | O |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 6 | 10| 6 | 6 |   |   |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

alloc(10) ->
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| A | B | C | D | E | F | G | H | I | J | K | L | M | N | O |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 6 | 10| 6 | 6 | 12|   |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

alloc(6) ->
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| A | B | C | D | E | F | G | H | I | J | K | L | M | N | O |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 6 | 10| 6 | 6 | 12| 8 |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

free(C) ->
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| A | B | C | D | E | F | G | H | I | J | K | L | M | N | O |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 6 | 10| -6| 6 | 12| 8 |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

free(B) ->
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| A | B   C | D | E | F | G | H | I | J | K | L | M | N | O |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 6 |  -16  | 6 | 12| 8 |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

free(F) ->
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| A | B   C | D | E | F | G | H | I | J | K | L | M | N | O |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 6 |  -16  | 6 | 12|   |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

alloc(6) ->
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| A | B   C | D | E | F | G | H | I | J | K | L | M | N | O |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 6 |  -16  | 6 | 12|  6|   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

free(D) ->
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| A | B   C   D | E | F | G | H | I | J | K | L | M | N | O |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 6 |    -22    | 12| 6 |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

alloc(18) ->
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| A | B | C   D | E | F | G | H | I | J | K | L | M | N | O |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 6 | 18|  -2   | 12| 6 |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

```
:::

:::spoiler **First-fit**
```
początek->
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| A | B | C | D | E | F | G | H | I | J | K | L | M | N | O |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

alloc(4) ->
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| A | B | C | D | E | F | G | H | I | J | K | L | M | N | O |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 6 |   |   |   |   |   |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

alloc(8) ->
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| A | B | C | D | E | F | G | H | I | J | K | L | M | N | O |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 6 | 10|   |   |   |   |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

alloc(4) ->
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| A | B | C | D | E | F | G | H | I | J | K | L | M | N | O |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 6 | 10| 6 |   |   |   |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

alloc(4) ->
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| A | B | C | D | E | F | G | H | I | J | K | L | M | N | O |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 6 | 10| 6 | 6 |   |   |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

alloc(10) ->
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| A | B | C | D | E | F | G | H | I | J | K | L | M | N | O |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 6 | 10| 6 | 6 | 12|   |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

alloc(6) ->
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| A | B | C | D | E | F | G | H | I | J | K | L | M | N | O |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 6 | 10| 6 | 6 | 12| 8 |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

free(C) ->
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| A | B | C | D | E | F | G | H | I | J | K | L | M | N | O |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 6 | 10| -6| 6 | 12| 8 |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

free(B) ->
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| A | B   C | D | E | F | G | H | I | J | K | L | M | N | O |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 6 |  -16  | 6 | 12| 8 |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

free(F) ->
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| A | B   C | D | E | F | G | H | I | J | K | L | M | N | O |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 6 |  -16  | 6 | 12|   |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

alloc(6) ->
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| A | B | C | D | E | F | G | H | I | J | K | L | M | N | O |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 6 | 8 | -8| 6 | 12|   |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

free(D) ->
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| A | B | C   D | E | F | G | H | I | J | K | L | M | N | O |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 6 | 8 | -14   | 12|   |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

alloc(18) ->
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| A | B | C   D | E | F | G | H | I | J | K | L | M | N | O |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 6 | 8 |  -14  | 12| 18|   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

```
:::
### Zadanie 5
![](https://i.imgur.com/jFoSt72.png)


Algorytm kubełkowy zarządza pamięcią za pomocą wielu list wolnych bloków, gdzie każda lista przechowuje bloki o określonym rozmiarze. Operacja malloc wyszukuje wolny blok na liście odpowiadającej żądanemu rozmiarowi. Jeśli na danej liście nie ma wolnego bloku, to malloc przeszukuje kolejne listy szukając odpowiedniego bloku. Jeśli na żadnej z list nie ma odpowiedniego bloku, to algorytm zwiększa rozmiar obszaru przydzielonego dla algorytmu przydziału i zwraca nowy blok.

Operacja free dodaje blok do odpowiedniej listy wolnych bloków na podstawie jego rozmiaru. W algorytmie kubełkowym węzeł strażnika powinien znajdować się na początku każdej z list wolnych bloków, aby ułatwić przeszukiwanie i dodawanie bloków.

Jeśli zastosować leniwe złączanie wolnych bloków w algorytmie kubełkowym, to może to prowadzić do zwiększenia liczby fragmentów pamięci i utrudnienia w znajdowaniu odpowiednich bloków przez operację malloc. Może to prowadzić również do sytuacji, w której algorytm będzie musiał częściej zwiększać rozmiar obszaru przydzielonego dla algorytmu przydziału, co może być szkodliwe dla wydajności systemu.

### Zadanie 6
![](https://i.imgur.com/u8uj51b.png)

:::spoiler podpowiedź bota
Aby naprawić ten błąd, program «stralloc» powinien sprawdzać, czy wydzielany blok ma wystarczająco dużo miejsca, aby pomieścić znaki zerowe zarówno na końcu ciągu znakowego, jak i na końcu bloku. Można to zrobić np. poprzez dodanie jednego znaku zerowego do maksymalnej długości bloku i sprawdzenie, czy wydzielany blok jest co najmniej o jeden znak dłuższy. W przeciwnym razie procedura «stralloc» powinna zwrócić NULL, aby użytkownik wiedział, że nie udało się przydzielić pamięci.
:::

### Zadanie 7
![](https://i.imgur.com/NK9qgKj.png)


:::spoiler Podpowiedź bota

Aby uzupełnić brakujące fragmenty procedur «alloc_block» i «free_block» w programie «objpool», należy zaimplementować następujące kroki:

#### W procedurze «alloc_block» należy:

- Przeszukać listę aren w poszukiwaniu aren z wolnymi blokami. Jeśli znaleziono taką arenę, to należy przeszukać bitmapę w poszukiwaniu wolnego bloku o rozmiarze odpowiednim dla alokacji.
- Jeśli znaleziono wolny blok, to należy zmienić jego stan na zajęty w bitmapie i zwrócić wskaźnik na ten blok.
- Jeśli nie udało się znaleźć wolnego bloku, to należy utworzyć nową arenę za pomocą mmap(2) i dodać ją do listy aren. Następnie należy zainicjować bitmapę w nowej arenie i zwrócić wskaźnik na pierwszy wolny blok.

#### W procedurze «free_block» należy:

- Sprawdzić, czy wskaźnik na blok jest prawidłowy i czy blok należy do jednej z aren na liście.
:::