1 / 31

Understanding Client-Server Communication in a Shared Computing Environment

Explore the intricacies of client-server interactions within a single computer system, emphasizing atomicity and memory management techniques. Topics include program execution, processor handling, physical memory, MMU operations, and kernel management. Learn about protected registers, interrupts, and system calls. Discover how bounded buffers and interleaved sending tasks are managed and learn the implications of locking mechanisms on file system operations.

tuyen
Télécharger la présentation

Understanding Client-Server Communication in a Shared Computing Environment

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. L4: Client/server in one computer; atomicity Sam Madden 6.033 Spring 2014

  2. Last Time Program 1 Program 2 Processor 1 Processor 2 0 Physical Memory 232-1

  3. Last Time Program 1 Program 2 Processor 1 Processor 2 MMU Page Table Register MMU Page Table Register 0 Physical Memory Page Table 1 Page Table 2 232-1

  4. Last Time Program 1 Program 2 Processor 1 Processor 2 MMU Page Table Register MMU Page Table Register Page Table 1 0 Physical Memory Page Table 1 Page Table 2 232-1

  5. Last Time Program 1 Program 2 Processor 1 Processor 2 MMU Page Table Register MMU Page Table Register Page Table 1 Page Table 2 0 Physical Memory Page Table 1 Page Table 2 232-1

  6. Last Time Program 1 Program 2 LOAD 0x0000 Processor 1 Processor 2 MMU Page Table Register MMU Page Table Register Page Table 1 Page Table 2 0 Physical Memory 0x0001 Page Table 1 Page Table 2 232-1

  7. Kernel Program 1 Program 2 Kernel Protected Registers Proc1 Page Table Register Proc2 Page Table Register User / Kernel Mode = 0 (user program running, can’t write to protected registers)

  8. Kernel Program 1 Program 2 Interrupt Kernel Protected Registers Proc1 Page Table Register Proc2 Page Table Register User / Kernel Mode = 0 (user program running, can’t write to protected registers)

  9. Kernel Program 1 Program 2 Interrupt Kernel Protected Registers Interrupt Handlers Proc1 Page Table Register Proc2 Page Table Register User / Kernel Mode = 1 (kernel running, can write to protected registers)

  10. Kernel Program 1 Program 2 Interrupt System Call Kernel Protected Registers Interrupt Handlers Proc1 Page Table Register Proc2 Page Table Register User / Kernel Mode = 1 (kernel running, can write to protected registers)

  11. Bounded buffer send send(bb, m): while True: if bb.in – bb.out < N: bb.buf[bb.in mod N] ← m bb.in ← bb.in + 1 return

  12. send(bb, m): while True: if bb.in – bb.out < N: bb.buf[bb.in mod N] ← m bb.in ← bb.in + 1 return receive(bb): while True: if bb.in > bb.out: m ← bb.buf[bb.out mod N] bb.out ← bb.out + 1 return m

  13. send(bb, m): while True: if bb.in – bb.out < N: bb.in ← bb.in + 1 bb.buf[bb.in-1 mod N] ← m return receive(bb): while True: if bb.in > bb.out: m ← bb.buf[bb.out mod N] bb.out ← bb.out + 1 return m

  14. send(bb, m): while True: if bb.in – bb.out < N: bb.buf[bb.in mod N] ← m bb.in ← bb.in + 1 return receive(bb): while True: if bb.in > bb.out: m ← bb.buf[bb.out mod N] bb.out ← bb.out + 1 return m

  15. send(bb, m): while True: if bb.in – bb.out < N: bb.buf[bb.in mod N] ← m bb.in ← bb.in + 1 return Interleaved Send in = 0, out = 0 A: send(bb, m1) B: send(bb, m2)

  16. send(bb, m): while True: if bb.in – bb.out < N: bb.buf[bb.in mod N] ← m bb.in ← bb.in + 1 return Interleaved Send in = 0, out = 0 A: send(bb, m1) read in (0), out (0) B: send(bb, m2)

  17. send(bb, m): while True: if bb.in – bb.out < N: bb.buf[bb.in mod N] ← m bb.in ← bb.in + 1 return Interleaved Send in = 0, out = 0 A: send(bb, m1) read in (0), out (0) B: send(bb, m2) read in (0), out (0)

  18. send(bb, m): while True: if bb.in – bb.out < N: bb.buf[bb.in mod N] ← m bb.in ← bb.in + 1 return Interleaved Send in = 0, out = 0 A: send(bb, m1) read in (0), out (0) write m1 to buf[0] B: send(bb, m2) read in (0), out (0)

  19. send(bb, m): while True: if bb.in – bb.out < N: bb.buf[bb.in mod N] ← m bb.in ← bb.in + 1 return Interleaved Send in = 0, out = 0 A: send(bb, m1) read in (0), out (0) write m1 to buf[0] B: send(bb, m2) read in (0), out (0) write m2 to buf[0]

  20. send(bb, m): while True: if bb.in – bb.out < N: bb.buf[bb.in mod N] ← m bb.in ← bb.in + 1 return Interleaved Send in = 1, out = 0 A: send(bb, m1) read in (0), out (0) write m1 to buf[0] write 1 to in B: send(bb, m2) read in (0), out (0) write m2 to buf[0]

  21. send(bb, m): while True: if bb.in – bb.out < N: bb.buf[bb.in mod N] ← m bb.in ← bb.in + 1 return Interleaved Send in = 1, out = 0 A: send(bb, m1) read in (0), out (0) write m1 to buf[0] write 1 to in B: send(bb, m2) read in (0), out (0) write m2 to buf[0] write 1 to in M1 Lost!

  22. Send with locking send(bb, m): acquire(bb.send_lock) while True: if bb.in – bb.out < N: bb.buf[bb.in mod N] ← m bb.in ← bb.in + 1 release(bb.send_lock) return

  23. Does this send work? send(bb, m): acquire(bb.send_lock) while True: if bb.in – bb.out < N: acquire(bb.send_lock) bb.buf[bb.in mod N] ← m bb.in ← bb.in + 1 release(bb.send_lock) return No!

  24. File system: no concurrency move(dir1, dir2, name): unlink(dir1, inode) link(dir2, inode, name) P1: move(“torrents”, “music”, “bieber.mp3”): P2: move(“torrents”, “music”, “bieber.mp3”):

  25. Coarse-grained locking move(dir1, dir2, name): acquire(fs_lock) unlink(dir1, name) link(dir2, name) release(fs_lock)

  26. Fine-grained locking move(dir1, dir2, name): acquire(dir1.lock) unlink(dir1, name) release(dir1.lock) acquire(dir2.lock) link(dir2, name) release(dir2.lock)

  27. Fine-grained locking move(dir1, dir2, name): acquire(dir1.lock) unlink(dir1, name) release(dir1.lock) acquire(dir2.lock) link(dir2, name) release(dir2.lock) File not indir1 or dir2

  28. Holding multiple locks move(dir1, dir2, name): acquire(dir1.lock) acquire(dir2.lock) unlink(dir1, name) link(dir2, name) release(dir1.lock) release(dir2.lock)

  29. Deadlock A B move(dir1, dir2, a): acquire(dir1.lock) acquire(dir2.lock) unlink(dir1, a) link(dir2, a) release(dir1.lock) release(dir2.lock) move(dir2, dir1, b): acquire(dir2.lock) acquire(dir1.lock) unlink(dir2, b) link(dir1, b) release(dir2.lock) release(dir1.lock)

  30. Avoiding deadlock w/ ordering move(dir1, dir2, name): if dir1.inum < dir2.inum: acquire(dir1.lock) acquire(dir2.lock) else: acquire(dir2.lock) acquire(dir1.lock) unlink(dir1, name) link(dir2, name) release(dir1.lock) release(dir2.lock)

  31. Summary • Client/server in one computer: bounded buffers • Concurrent programming is tricky! • Locks help make several actions look atomic • Before-or-after atomicity

More Related