Lesson 4d

Question 1

How do you ensure safety when client server? (even on the same machine)?

Answer 1

make sure that the client and server are in different address spaces (protection domains)

Question 2

What is impacted by having separate client server address spaces?

Answer 2

performance

Question 3

what happens in terms of address space during RPC?

Answer 3

The client traps into the kernel and copies to a buffer there. This buffer is sent to the server. On return the server traps into the kernel, fills out a buffer, and returns that to the client. 2 kernel traps, 2 context switches, 1 procedure execution, 4 copying stuff from user address space to kernel

Question 4

what is a main performance concerns when comparing function calls and RPC?

Answer 4

• RPC happens at runtime

- func call happens at compile time (I guess they mean linking and optimization)

Question 5

what is a main concern that needs to be optimized for RPC?

Answer 5

Copying Overhead

Question 6

what makes the RPC msg for the client

Answer 6

client stub

Question 7

Steps in copying overhead

Answer 7

1) client stub on the client stack to RPC msg
2) RPC msg to kernel buffer
3) kernel buffer to server domain
4) server domain to server stub on the server stack

Question 8

what to focus on during optimization

Answer 8

Not one-time cost. Focus on recurring cost

Question 9

Name server for RPC

Answer 9

place where client can find out which procedures are available on the server and retrieve binding information

Question 10

what is the PD of RPC

Answer 10

procedure descriptor contains, Entry Point (address), Stack Size (max space), Number of Calls (simultaneous calls handled)

Question 11

how are address spaces shared

Answer 11

a shared memory region is created that is mapped to the client address space and the server address space

Question 12

where does the server stub copy the arguments when making RPC cheap?

Answer 12

copies from the a-stack (shared memory) into the e-stack (execution stack)

Question 13

where does the server place results (when making RPC cheap)

Answer 13

Back into shared memory (a-stack). User space

Question 14

what happens during the return kernel traps (when making rpc cheap)

Answer 14

thre thread is adjusted to continue where the client left off (re-doctor)

Question 15

different between original rpc copy overhead and cheap version?

Answer 15

Original: rpc msg -> kernel buffer -> server domain -> server stack (4)
New: a-tack -> server stack (2)

Question 16

what does a-stack stand for?

Answer 16

argument stack

Question 17

what is the bo in rpc initial setup

Answer 17

the binding object

Question 18

how are calls made cheap

Answer 18

client fills out the a-stack in shared memory and copies results from shared memory

Question 19

what is copied into kernel when making rpc cheap?

Answer 19

the bo (binding object) during a kernel trap

Question 20

what does the kernel do with the bo?

Answer 20

pulls out the PD (procedure descriptor) if on the same machine uses the client thread, adjust the thread to start at “server” address (from PD) and setup the e-stack (execution stack)

Question 21

where does the copy happen in the cheap version vs the original

Answer 21

in user space vs. kernel space (original)

Question 22

what is a cost hit that comes from moving the a-stack method?

Answer 22

loss of locality

Question 23

How can we take advantage of RPC on SMP

Answer 23

• Preload server domain, - Keep caches warm

Question 24

What do they mean by “pre-load” server domain?

Answer 24

One cpu is tied to one server domain. No other work is done on that processor so the cache stays hot

Question 25

why do we want to use RPC locally for services

Answer 25

When you put services in their own protection domain you are adding protection to the system (integrity)