Final

You may use any resource that existed prior to this exam opening, including websites, books, etc; but should not consult friends, tutors, forums, or other interactive help for this exam.

You must not share any information about this exam (even how you felt about it) with any party (even others who have taken it) until after it closes at 2020-05-07 23:59 EDT.

The following ask about adding limitations to computer functionality.

Question 1 (dropped) (see above)

Suppose we want to limit the use of the xorq command to only certain users or operation modes. This would require modification of

the operating system code
the processor hardware

Question 2 (0 / 1 pt; mean 0.78) (see above)

Suppose we want to limit all user-mode programs so they can only access to files have an even number of letters in their names. This would require modification of

78%
⊤
the operating system code
7%
the processor hardware

Question 3 (0 / 1 pt; mean 0.59) (see above)

Suppose we want to throttle bandwidth so each user could only send 1MB of network traffic per minute. This would require modification of

59%
⊤
the operating system code
27%
the processor hardware

The following ask about interrupts and related concepts

Question 4 (0 / 1 pt; mean 0.45) (see above)

What's the difference between an interrupt number and a system call number?

7%
all interrupts use the same system call number
28%
⊤
all system calls use the same interrupt number
34%
½
one communicates hardware to software, the other the other way around

interrupt number is (usually) hardware to software, but system call number is software to software
16%
one is received by the OS, the other by user code
1%
they are two names for the same thing

Question 5 (0.44 / 1 pt; mean 0.71) (see above)

The following are all true of interrupts; which are also true of signals?

49%
⊤
Handling them causes a change in user-vs-kernel permission mode
37%
They are handled by the OS
69%
⊤
They can happen between any pair of instructions
67%
⊤
They have an identifying number
5%
They originate in hardware

We have often noted each of the following things about memory this semester; these questions ask how they have been refined by our understanding of virtual memory

Question 6 (0 / 1 pt; mean 0.27) (see above)

Linux on x86-64 splits memory in half: the lower half is user-mode and the upper half is kernel-mode

29%
This is true of both virtual and physical memory
30%
This is true of physical memory
27%
⊤
This is true of virtual memory

Question 7 (0 / 1 pt; mean 0.78) (see above)

The call stack (the one handled by pushq, callq, etc) grows toward smaller addresses

58%
⊤
This is true of both virtual and physical memory
7%
This is true of physical memory
20%
⊤
This is true of virtual memory

Question 8 (dropped) (see above)

When a process is suspended, allowing other processes to use the processor, its memory is inaccessibly.

This is true of both virtual and physical memory
This is true of physical memory
This is true of virtual memory

Consider the 4-level page table hierarchy we discussed Intel processors using, with a 4K pages, 48-bit virtual addresses, and 52-bit physical addresses

Question 9 (0 / 1 pt; mean 0.58) (see above)

If I run movq (%rax), %rbx when (%rax) is on a page that is not in the TLB, how many memory accesses does the instruction perform? Answer as a base-10 integer, like "1" or "39"

Answer:

Key: 5

Question 10 (0 / 1 pt; mean 0.71) (see above)

If I run movq (%rax), %rbx when (%rax) is on a page that is in the TLB, how many memory accesses does the instruction perform? Answer as a base-10 integer, like "1" or "39"

Answer:

Key: 1

Question 11 (0 / 1 pt; mean 0.53) (see above)

If my code accesses the 50-bit address 0x2100010001000

45%
⊤
it acts like I accessed the 45-bit address 0x100010001000 instead
23%
it causes a fault
18%
½
it works just like accessing any other address

Question 12 (0 / 1 pt; mean 0.53)

If a disk read is performed via Direct Memory Access (DMA),

12%
certain ranges of virutal addresses are handled by the disk instead of by RAM
20%
the disk's write interrupts are routed to RAM directly without user process intervention
53%
⊤
the disk modifies the data in a range of physical addresses without processor involvement

The following ask about the ability of devices on a bus to interact. In particular, assume that a bus-topology network connects the keyboard, disk, network card, and processor.

Assume that any special status a bus-connected component can have (hub position, master status, etc) is held by the processor and not the other components.

Question 13 (0 / 1 pt; mean 0.48) (see above)

Suppose I create a nefarious disk that is programmed to log every keystroke you make. Assume I put any computing power needed for this task inside the disk hardware.

11%
The disk could log keystrokes with no special permissions, but the processor could see it happen.
48%
⊤
The disk could log keystrokes with no special permissions and without the processor knowing about it.
6%
This disk would need to get permission from the keyboard first, but could then do the logging itself.
18%
This disk would need to get permission from the processor first, but could then do the logging itself.
2%
This disk would need to have the processor route the keystroke data to the disk.

Question 14 (dropped) (see above)

Suppose I create a nefarious disk that is programmed to send your files to me over your Internet connection. Assume I put any computing power needed for this task inside the disk hardware, but do not have network connectivity in the disk itself.

The disk could send the request to send the files to the network card directly, but the processor could see it happen.
The disk could send the request to send the files to the network card directly, without the processor knowing about it.
This disk would need to get permission from the network card first, but could then send the data to the network card itself.
This disk would need to get permission from the processor first, but could then send the data to the network card itself.
This disk would need to have the processor route the data to the network card.

HTTPS delivered web requests and replies using TLS, TCP, and IP. The TLS encrypts the request and reply body, but does not encrypt the IP and TCP headers.

Question 15 (0 / 1 pt; mean 0.59) (see above)

Why does TLS not encrypt the IP header?

20%
If it did, the message could be delivered but routing computers could not optmize message flow.
59%
⊤
If it did, the message could not be delivered and decrypted at the other end.
5%
If it did, the message could sometimes be delievered but could not detect and/or recover from delivery errors.
1%
None of the above; this was just a choice, not a design necessity.

Question 16 (0 / 1 pt; mean 0.71) (see above)

Why does TLS not encrypt the TCP header?

10%
If it did, the message could be delivered but routing computers could not optmize message flow.
22%
⊤
If it did, the message could not be delivered and decrypted at the other end.
43%
⊤
If it did, the message could sometimes be delievered but could not detect and/or recover from delivery errors.
11%
½
None of the above; this was just a choice, not a design necessity.

we could have had the OS handle all decrption and then route to the program, but that would mean a program couldn't hide information from the OS and other programs on the same computer or use an encryption method the OS did not yet have built-in

The following ask about digital signatures

Question 17 (0 / 1 pt; mean 0.76) (see above)

Which of the following is used to sign a document?

1%
the recipient's private key
2%
the recipient's public key
1%
the signer's and recipient's shared symmetric key
76%
⊤
the signer's private key
5%
the signer's public key

Question 18 (0 / 1 pt; mean 0.55) (see above)

Which of the following is used to verify the signature of a document?

5%
the recipient's private key
18%
the recipient's public key
6%
the signer's and recipient's shared symmetric key
1%
the signer's private key
55%
⊤
the signer's public key

Question 19 (0 / 1 pt; mean 0.73) (see above)

A digital certificate is

2%
any document with an attached signature
66%
⊤
the key to checking an agent you don't trust's signatures, signed by an agent you do trust
1%
the key to checking an agent you do trust's signatures, signed by an agent you don't trust
14%
½
the key to sending an agent you don't trust your signatures, signed by an agent you do trust
1%
the key to sending an agent you do trust your signatures, signed by an agent you don't trust

The following ask about caches, in particular the memory cache hierarchy

Question 20 (0 / 1 pt; mean 0.81) (see above)

Why do caches have larger blocks that a single access will need?

to distribute memory bandwidth over time
to limit cache lookup processing time
1%
to optimize repeated writes to the same address
81%
⊤
to optimize spatially-local accesses
1%
to optimize temporally-local accesses
1%
to reduce miss rate

Question 21 (0 / 1 pt; mean 0.52) (see above)

Why do caches have multiple lines per set?

to distribute memory bandwidth over time
7%
to limit cache lookup processing time
2%
to optimize repeated writes to the same address
4%
to optimize spatially-local accesses
22%
to optimize temporally-local accesses
51%
⊤
to reduce miss rate

Question 22 (0 / 1 pt; mean 0.51) (see above)

Why do caches have multiple small sets instead of one large one?

1%
to distribute memory bandwidth over time
51%
⊤
to limit cache lookup processing time
1%
to optimize repeated writes to the same address
1%
to optimize spatially-local accesses
16%
to optimize temporally-local accesses
16%
to reduce miss rate

Question 23 (0 / 0.5 pt; mean 0.39) (see above)

Why are some caches write-back?

4%
to distribute memory bandwidth over time
2%
to limit cache lookup processing time
77%
⊤
to optimize repeated writes to the same address
to optimize spatially-local accesses
1%
to optimize temporally-local accesses
1%
to reduce miss rate

Question 24 (0 / 0.5 pt; mean 0.2) (see above)

Why are some caches write-through?

40%
⊤
to distribute memory bandwidth over time
33%
to limit cache lookup processing time
8%
to optimize repeated writes to the same address
2%
to optimize spatially-local accesses
to optimize temporally-local accesses
2%
to reduce miss rate

Question 25 (0 / 1 pt; mean 0.7)

Which of the following best describes Amdahl's Law?

8%
Adding parallelism is the main way hardware becomes faster.
70%
⊤
Speeding up part of a task doesn't make the other parts faster.
The number of transistors on a chip doubles every few years.
4%
Throughput it more important than latency for real workloads.
4%
With enough parallelism, any timing goal can be met.

Question 26 (0.5 / 1 pt; mean 0.89)

Which two of the following correctly describe concurrency and parallelism?

2%
If concurrent, then parallel.
78%
⊤
If not concurrent, then not parallel.
2%
If not parallel, then not concurrent.
83%
⊤
If parallel, then concurrent.

Question 27 (0.5 / 1 pt; mean 0.86)

Which of the following are true of synchronization primitives?

2%
Barriers are commonly used to create mutual exclusion.
80%
⊤
Monitors are commonly used to create mutual exclusion.
8%
One mutex can do everything one reader-writer lock can do.
77%
⊤
One reader-writer lock can do everything one mutex can do.

Most synchronization primitives can be created using several other primitives and a few auxiliary data structures. Which of the following is closest to implementing barriers with other pthreads primitives?

Question 28 (0.57 / 1 pt; mean 0.73) (see above)

The pthread_barrier_t needs a condition variable for threads to wait on, a mutex to lock access to other variables, and which of the following?

29%
a Boolean to show if the barrier may be passed
52%
⊤
a counter to show how many threads are waiting
78%
⊤
a counter to show how many threads this barrier requires before continuing
7%
a list of thread IDs allowed to use the barrier
a list of thread IDs waiting on the barrier

Question 29 (0 / 1 pt; mean 0.72) (see above)

If our pthread_barrier_t was implemented as

lock the mutex
manipulate variables
if (variables suggest should wait) {
    wait on condition variable
} else {
    release all waiting threads
}
unlock the mutex

what would go wrong? Assume the barrier requires at least two threads to continue.

4%
This has a race condition that could not result in a deadlock
23%
⊤
This has a race condition that could result in a deadlock
11%
This has a race condition that could result in one thread waiting too long
48%
⊤
This would always deadlock

Question 30 (0 / 1 pt; mean 0.58) (see above)

If our pthread_barrier_t was implemented as

lock the mutex
manipulate variables
if (variables suggest should wait) {
    unlock the mutex
    wait on condition variable
} else {
    unlock the mutex
    release all waiting threads
}

what would go wrong? Assume the barrier requires at least two threads to continue.

45%
½
This has a race condition that could not result in a deadlock
23%
⊤
This has a race condition that could result in a deadlock
17%
½
This has a race condition that could result in one thread waiting too long
1%
This would always deadlock

The following ask about Dining Philosophers and its solutions documented in Lab 09.

Question 31 (0 / 1 pt; mean 0.25) (see above)

The "arbitrator" solution to dining philosophers ensures there is no deadlock by removing which of the necessary conditions of deadlock?

41%
Circular Wait
31%
½
Hold-and-Wait

I can hold the arbitration mutex while waiting for a chopstick
7%
Mutual Exclusion
4%
No Preemption
None of the above; it allows deadlock
1%
⊤
None of the above; it prevents deadlock without removing any of these conditions

Question 32 (0 / 1 pt; mean 0.61) (see above)

The "resource hirearchy" solution to dining philosophers ensures there is no deadlock by removing which of the necessary conditions of deadlock?

57%
⊤
Circular Wait
11%
Hold-and-Wait
2%
Mutual Exclusion
5%
No Preemption
1%
None of the above; it allows deadlock
8%
½
None of the above; it prevents deadlock without removing any of these conditions

Question 33 (0 / 1 pt; mean 0.83)

Pipelining ____ throughput and ____ latency.

Pipelining decreases throughput and decreases latency.
Pipelining decreases throughput and increases latency.
5%
½
Pipelining increases throughput and decreases latency.
81%
⊤
Pipelining increases throughput and increases latency.

Question 34 (0 / 1 pt; mean 0.8)

Out of order execution ____ throughput and ____ latency.

2%
Out of order execution decreases throughput and decreases latency.
4%
Out of order execution decreases throughput and increases latency.
61%
⊤
Out of order execution increases throughput and decreases latency.

Technically false, but often described as true because it lets us get a head-start on some instructions so the fact that they have a similar or increased latency is compensated by earlier starts
18%
⊤
Out of order execution increases throughput and increases latency.

Technically true: a single instruction has more steps to go through (register renaming, etc) than it would if not out-of-order, requiring more time

Question 35 (0.33 / 1 pt; mean 0.82)

Speculative execution can increase the performance of

72%
⊤
out-of-order processors
80%
⊤
pipelined in-order processors
5%
single-sage processors, like we discussed in COA1

Both Spectre and Meltdown exploits included (a compiled or language-specifc version of) the code

y = arr[(*x) * 4096]

where x was a pointer to an address that should not be accessible, but whose value was leaked by the exploit; arr was a pointer to memory owned by the attacker; and y was a register owned by the attacker.

Question 36 (0 / 1 pt; mean 0.66) (see above)

After running the above code, how do these exploits learn the contents of *x?

12%
By checking the cache presence of *x
66%
⊤
By checking the cache presence of arr[0], arr[4096], arr[8192], ..., arr[255*4096]
1%
By checking the cache presence of y
2%
By checking the contents of arr[0], arr[4096], arr[8192], ..., arr[255*4096]
2%
By checking the contents of y
1%
By checking the page table entry for *x
By checking the page table entry for arr[0], arr[4096], arr[8192], ..., arr[255*4096]
By checking the page table entry for y

Question 37 (0 / 1 pt; mean 0.6) (see above)

Why the 4096 multiplicand?

51%
⊤
So each value has a different cache line
20%
So each value has a different page table entry
4%
To cause 1-byte-integer overflow for all values of *x
To cause 2-byte-integer overflow for some but not all values of *x
10%
⊤
To prevent speculative caching via prefetching
1%
To prevent speculative execution via prediction

Return to course page Return to index