Quiz

Question 1

Linux memory area

Answer 1

• a chunk of virtual memory mapped to a VM area space structure

Question 2

task_struct

Answer 2

• The OS stores process state in a data structure called process control block. There is one per process
  called task_struct in linux

Question 3

mm_struct

Answer 3

kernel’s representation of a process’s address space
important fields:
-mm_users = # of processes using the address space
-mm_count = main reference count; when the kernel operates on an address space, it bumps up the reference counter. all users = 1 count
-mmap and mm_rb: contain all the memory areas in this address space
pgd_t *pgd: physical address of the first thing in the pgd??? do we add the PGD offset to the start address of the PGD?

all of the mm_struct structures of every process are strung together in a doubly linked list via the mmlist field

Question 4

vm_area_struct

Answer 4

describes a single memory area over a CONTIGUOUS VIRTUAL ADDRESS INTERVAL in a given address space
each VMA possesses certain permissions and associated operations
each VMA structure can represent different types of memory areas

important struct fields:
-VMA start (lowest address in the interval)
-vm_end (first byte AFTER the highest address in the interval)
length in bytes of memory area = vm_end - vm_start

Question 5

pgd

Answer 5

the page global directory (pgd) which consists of an array of pgd_t types. The entries in the pgd point to entries in the second level directory, the PMD. The second-level page table is the page middle directory (PMD), which is an array of pmd_t types. Entries in the PMD point to entries in the PTE. Final level = page table; consists of page table entries of type pte_t. Page table entries point to physical pages

Question 6

Difference between segmentation fault and protection fault?

Answer 6

• segmentation fault occurs when request and address is not in the VMA
• protection fault occurs when you don’t have permissions to access that address

Question 7

memory mapping

Answer 7

• structure of data indicating how memory is laid out

Question 8

anonymous file

Answer 8

a temporary file without a descriptor

Question 9

swap file (swap space)

Answer 9

• portion of the memory used for virtual memory

Question 10

shared object

Answer 10

• a file that contains binary code and data that can be loaded into memory and linked dynamically

Question 11

shared area

Answer 11

• virtual memory that are shared by more than one process and then can be used by multiple programs simultaneously. Although virtual memory allows processes to have separate address spaces, there are times when you need processes to share memory.

Question 12

copy-on-write

Answer 12

• copy file and save new only when wrote to otherwise access the same file

Question 13

dynamic memory allocator

Answer 13

Maintains an area of a process’s virtual memory, known as heap

Question 14

allocated memory

Answer 14

• allocated memory is memory that is filled

Question 15

How does the VM system used for the execve function?

Answer 15

The shell stores the environment in memory and passes it to the execve() system call. The child process inherits it as an array pointer called environ

Question 16

What does the mmap function do?

Answer 16

• allows you to comb through a file like it is an array. Asks the kernel to create a new virtual memory area

Question 17

implicit allocator

Answer 17

• implicit allocators implicitly allocates memory

- does not free the space

Question 18

What does malloc do when it cannot satisfy a memory request?

Answer 18

• it returns a NULL

Question 19

How does free work?

Answer 19

It accepts a pointer as its parameter. The free command does two things: The block of memory pointed to by the pointer is unreserved and given back to the free memory on the heap. It can then be reused by later new statements.

Question 20

Throughput

Answer 20

• how many commands per second

Question 21

aggregate payload

Answer 21

• this is all the payloads added together

Question 22

internal fragmentation

Answer 22

• type of fragmentation where the payload is smaller than the block size it is going into

Question 23

external fragmentation

Answer 23

• type of fragmentation where the payload…space cannot be filled
• to explain more the area that is free in the block cannot be filled by the payload

Question 24

Why use dynamic memory allocation?

Answer 24

When you need a lot of memory. Typical stack size is 1 MB, so anything bigger than 50-100KB should better be dynamically allocated, or you’re risking crash. Some platforms can have this limit even lower.

When the memory must live after the function returns. Stack memory gets destroyed when function ends, dynamic memory is freed when you want.

When you’re building a structure (like array, or graph) of size that is unknown (i.e. may get big), dynamically changes or is too hard to precalculate. Dynamic allocation allows your code to naturally request memory piece by piece at any moment and only when you need it. It is not possible to repeatedly request more and more stack space in a for loop.

Question 25

Requirements for explicit allocators? (5)

Answer 25

Handling arbitrary request sequences
Making immediate responses to requests
Using only the heap
Aligning Blocks
Not modifying allocated blocks

Question 26

Utilization

Answer 26

• how much memory is being used; virtual memory is not an unlimited resource

Question 27

free-block organization

Answer 27

How do we keep track of free blocks?

Question 28

Peak utilization

Answer 28

• maximum utilization

Question 29

block splitting

Answer 29

After we place a newly allocated block in some free block, what do we do with the remainder of the free block?

Question 30

block coalescing

Answer 30

What do we do with a block that has just been freed?

Question 31

payload

Answer 31

the actual space an application requested when it called malloc

Question 32

padding

Answer 32

Unused and can be any size; might be part of an allocator’s strategy for combating external fragmentation, OR satisfying the alignment requirement

Question 33

demand-zero page

Answer 33

a physical page of all 0s

Question 34

How is the COW mechanism used for the fork function?

Answer 34

when a fork occurs, the parent process’s pages are not copied for the child process. Instead, the pages are shared between the child and the parent process.