Exam 2

Question 1

Interrupt

Answer 1

The type of exception that is generated by an I/O device. Example: I/O device completes request

Question 2

Trap

Answer 2

The type of exception that occurs intentionally as a result of executing an instruction. Example: User program opens a file

Question 3

Fault

Answer 3

If a process causes an access to data or instruction that is not currently in main memory. Example: Read of a instruction not currently in main memory

Question 4

Abort

Answer 4

If a process causes an access to corrupted data or instructions. Example: Hardware error

Question 5

Concurrent processing (Multitasking)

Answer 5

Single processor executes multiple processes concurrently. Register values for nonexecuting process saved in memory

Question 6

Parallel processing (Multiprocessing)

Answer 6

Parallel processing is a type of concurrent processing where more than one set of instructions is executing simultaneously.

Question 7

Logical control flow

Answer 7

Each program seems to have exclusive use of the CPU, provided by kernel mechanism called context switching.

Question 8

Private virtual address space

Answer 8

Each program seems to have exclusive use of main memory. Provided by kernel mechanism called virtual memory

Question 9

User vs. Kernel mode

Answer 9

In User mode, the executing code has no ability to directly access hardware or reference memory.

In Kernel mode, the executing code has complete and unrestricted access to the underlying hardware.

Question 10

Context Switch

Answer 10

Processes are managed by a shared chunk of memory resident OS code called the kernel. Important: the kernel is not a separate process, but rather runs as part of some existing process. Control flow passes from one process to another via a context switch

Question 11

zombie

Answer 11

When process terminates, it still consumes system resources. Examples: Exit status, various OS tables. Called a “zombie”. Living corpse, half alive and half dead

Question 12

Signal

Answer 12

A small message that notifies a process that an event of some type has occurred in the system

Question 13

Pending Signal

Answer 13

A signal that has been sent but not received yet; there can be at most one pending sending of a particular type. Any more are discarded

Question 14

Blocked Signal

Answer 14

When a signal is blocked, it can be delivered, but the resulting pending signal will not be received until the process unblocks the signal.

Question 15

Sending Signals

Answer 15

Every way to send a signal relies on the idea of a process group. Every process belongs to exactly one group, obtained by the getpgrp function. Setpgid can change process ID

Question 16

Receiving Signals

Answer 16

When the kernel switches a process to user mode, it checks the set of unblocked pending signals, and if there are none, it passes control to the next instruction. If there are pending signals, it forces the process to receive the signal

Question 17

Catching Signals

Answer 17

Signals have default actions that can be overridden with signal handlers

Question 18

sigprocmask, sigfillset, sigemptyset, sigaddset, sigdelset

Answer 18

sigprocmask - Changes the set of currently blocked signals

sigfillset - initializes a signal set to contain all signals

sigemptyset - initialize a signal set to contain NO signals

sigaddset - add a signal s to a set S via sigaddset, S=S∪{s}

sigdelset - remove a signal s from a set via sigdelset, S=S{s}

Question 19

alarm

Answer 19

A function that sends the SIGALRM signal

Arranges for the kernel to send a SIGALRM signal to the calling process in (secs) seconds.

Question 20

atexit

Answer 20

Executed every time an application is about to shut down

Question 21

getpid

Answer 21

Returns the process ID of the calling process. This is often used by routines that generate unique temporary filenames.

Question 22

getppid

Answer 22

Returns the process ID of the parent of the calling process. If the calling process was created by the fork() function and the parent process still exists at the time of the getppid function call, this function returns the process ID of the parent process. Otherwise, this function returns a value of 1 which is the process id for init process.

Question 23

getpgrp, setpgid

Answer 23

getpgrp - Returns the group ID the process belongs to

setgpid - Sets the group ID of the process

Question 24

getpgrp, setpgid

Answer 24

getpgrp - Returns the group ID the process belongs to

setgpid - Sets the group ID of the process

Question 25

setjmp

Answer 25

Saves the current calling environment in the env buffer and returns 0. The calling environment includes the program counter, stack pointer, and GP regs.

Question 26

longjmp

Answer 26

Restores the calling environment from the env buffer and then triggers a return from the most recent setjmp call that initialized env.

Setjmp now returns with the nonzero return value retval

Question 27

Benefits of VM

Answer 27

PAGE 812

o Efficiency of main memory usage
o Simplify memory management
o Memory protection: isolate address spaces (avoid process interference)
o Simplify Linking and Loading

Question 28

Hardware/Software cost of VM

Answer 28

o Address translation
o Page tables (must also be accessed in DRAM cache)
o Translation (both hardware and software if page fault)

Question 29

Working set

Answer 29

Set of active pages since total pagesize might exceed size of physical memory

Question 30

Swap file

Answer 30

a space on a hard disk used as the virtual memory extension of a computer’s real memory

Question 31

Thrasing

Answer 31

When pages are swapped in and out of the working set continuously

Question 32

TLB (Translation Lookaside Buffer)

Answer 32

A small cache of page table entries located in the MMU. Purpose is to decrease cycles required for translating virtual addresses into physical ones

Question 33

DRAM cache organization driven by cost of misses, therefore:

Answer 33

§ large block size
§ write-back (rather than write-through)
§ fully-associative (any memory page can load into any page frame)
§ Complex replacement algorithms—must implement in software

Question 34

How does TLB view a virtual address?

Answer 34

§ VPO – virtual page offset is same as PPO—physical page offset
§ TLBI – TLB index (selects TLB set)
§ TLBT – TLB tag (compare with tags in set)

Question 35

Page Table Entry

Answer 35

An entry in the page table mapping a virtual address space to a fixed offset

Question 36

PTE Content

Answer 36

Contains a valid bit and an n-bit address field

Question 37

How does TLB view a virtual address?

Answer 37

§ VPO – virtual page offset is same as PPO—physical page offset
§ TLBI – TLB index (selects TLB set)
§ TLBT – TLB tag (compare with tags in set)

Question 38

Program Loading with VM

Answer 38

o VM areas are initialized by associating them with disk objects—memory mapping
§ task_struct -> mm_struct -> list of vm_area_struct
§ what is pgd used for?
§ VM areas allows VM to be non-contiguous.
§ segmentation fault is caused by an address access outside any VM area
§ protection fault is caused by access to a valid area but without valid permissions.

Question 39

pgd

Answer 39

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 40

task_struct

Answer 40

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

Question 41

mm_struct

Answer 41

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 42

vm_area_struct

Answer 42

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 43

An area can be backed by

Answer 43

§ regular file
o Initial page byte come from section of disk file
§ anonymous file (e.g. nothing)
o First fault allocates a page full of zeroes called a demand-zero page
o When a page is written to (becomes dirty), like any other page
o Dirty pages are swapped back and forth between memory and a special file called the swap file

Question 44

mmap

Answer 44

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

Question 45

private copy-on-write

Answer 45

As soon as a process attempts to write to some page in the private area, a write will trigger a protection fault, and the fault handler creates a new copy of the page in physical memory, and restores write permissions.

Question 46

shared object

Answer 46

Any writes that the process makes to the area are visible to any other processes that have also mapped the shared object into their virtual memory

Question 47

private object

Answer 47

Changes not visible to other processes, and any writes that the process makes to the area are not reflected back to the object on disk

Question 48

Why dynamic memory allocation? When is this needed?

Answer 48

More portable, often we don’t know the size of certain data structures until the program runs.

Question 49

Explicit vs. implicit allocators

Answer 49

Explicit - Requires the application to explicitly free any allocated blocks, for example, the free() function in CC

Implicit - Require the allocator to detect when an allocated block is no longer being used, and then free the block. AKA, garbage collectors

Question 50

Requirements for explicit allocators

Answer 50

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

Question 51

Allocator throughput

Answer 51

Number of requests that it completes per unit of time

Question 52

Peak memory utilization

Answer 52

How efficiently an allocator uses the heap

Question 53

Aggregate payload

Answer 53

The sum of the payloads of the currently allocated blocks

Question 54

Internal fragmentation

Answer 54

Occurs when an allocated block is larger than the payload

Question 55

External fragmentation

Answer 55

Occurs when there is enough aggregate free memory to satisfy an allocate request, but no single free block is large enough to handle the request

Question 56

Block format

Answer 56

Header, payload, padding.

Header encodes the block size as well as whether the block is allocated or free

Payload - Follows the header and is what the application actually requested

Question 57

Segregated Free Lists

Answer 57

Each array contains blocks of the same size or class size (i.e. power of two).