Abstractions for Practical Virtual Machine Replay. Anton Burtsev, David Johnson, Mike Hibler, Eric Eride, John Regehr University of Utah

Size: px

Start display at page:

Download "Abstractions for Practical Virtual Machine Replay. Anton Burtsev, David Johnson, Mike Hibler, Eric Eride, John Regehr University of Utah"

Brittany Cobb
5 years ago
Views:

1 Abstractions for Practical Virtual Machine Replay Anton Burtsev, David Johnson, Mike Hibler, Eric Eride, John Regehr University of Utah

2 2

3 3 Number of systems supporting replay: 0

4 Determinism 4 CPU is deterministic Execution history

5 Determinism 5 Execution history CPU is deterministic Interrupt, device I/O

6 Recording 6 Ability to interpose on external inputs Determinism of the execution environment Instruction-accurate positioning of events Event log

7 Why is it hard? 7 Complex interposition boundary Concurrent reentrant environment

8 Why is it hard? 8 Complex interposition boundary Concurrent reentrant environment Complex instruction counting logic Subtle divergence bugs

9 Why would you really care? 9 Execution analysis Automated debugging

10 10 Abstractions for Practical VM Replay

11 A three-part 11 model Deterministic Environment Replayed System

12 A three-part 12 model Deterministic Environment Replayed System

13 A three-part 13 model Deterministic Environment Replayed System Non-deterministic External World

14 Event types 14 Deterministic updates Replayed System Non-deterministic External World

15 Event types 15 Deterministic updates Synchronous Deterministic Environment Replayed System Non-deterministic External World

16 Event types 16 Deterministic updates Synchronous Asynchronous Deterministic Environment Wall-clock time, IRQs Replayed System Non-deterministic External World

17 Event types 17 Deterministic updates Synchronous Asynchronous Dependent Deterministic Environment Interrupt Injection Non-deterministic External World Replayed System

18 How does it map on an actual 18 system?

19 Interposition functions int trace_<function>(...) { event_t event = {<EVENT_TYPE>,...}; if(replayed_guest()) { if(synchronous(&event)) { // request replay of a specific event } replay_current_events(..., &event, &ret); return ret; } // asynchronous event: suppress the // update but replay "optional" events replay_current_events(...); return OK; } // Pause all virtual CPUs pause_vm(); trace_event(,...); // Emulate original event ret = <original_function>(...); unpause_vm(); return ret; 19

to Xen is 4000 cycles Replay budget of 10-20% (or

20 Lightweight interposition and 20 logging Logging code is on the guest s critical path A typical exit to Xen is 4000 cycles Replay budget of 10-20% (or cycles) Offload everything from the critical path

21 Lock-free, no-allocation, zero-copy 21

22 Device determinizm 22 Determinizing proxies

23 Split devices and shared rings 23

24 Devd: general device interposition 24

25 Instruction-accurate event positioning 25 label: rep... mov shr mov movsl test jne label... Number of instructions since boot Intel has a hardware counter It s not accurate Position = {EIP, branch #, ECX}

26 Execution scheduling 26 Event scheduling types Asynchronous Deterministic Environment Replayed System Non-deterministic External World

27 Execution scheduling 27 Event scheduling types Asynchronous In-place Deterministic Environment Replayed System Non-deterministic External World

28 Execution scheduling 28 Event scheduling types Asynchronous In-place Deterministic Environment Replayed System Non-deterministic External World

29 Execution scheduling 29 Event scheduling types Asynchronous In-place Optional Non-replayable Deterministic Environment Replayed System Retyping async events as synchronous Replay on exit to guest Non-deterministic External World

30 Every step is accompanied with a debugging mechanism 30 Automatic analysis of nondeterminism Page guarding

31 Every step is accompanied with a debugging mechanism 31 Automatic analysis of nondeterminism Page guarding Off-line comparison of execution Intel branch store trace (BTS) facility Record all taken branches in a memory buffer Support for resolving symbols

32 Every step is accompanied with a debugging mechanism 32 Automatic analysis of nondeterminism Page guarding Off-line comparison of execution Intel branch store trace (BTS) facility Record all taken branches in a memory buffer Support for resolving symbols Run-time comparison tools Compare guest s state between original and replay runs Trace from all parts of your system Xen, Domain 0, Guests Support performance tracing Xentrace messages

33 How much overhead? 33

34 32-bit x86 PV-guests xen-unstable near v3.0.4 We rely on working shadow page tables 1-CPU time-traveling guests No SMP replay Dom0 and Xen are SMP of course 34 Test machine 4 cores 1Gbps network 130 MB/s disks

35 CPU-intensive workloads % of normal Xen XenTT 75

36 Systems workloads (Phoronix) % of normal Xen XenTT 36

37 Disk I/O MB/s (higher is better) Xen XenTT 0 Serial write Serial read

38 Network throughput MB/s (higher is better) Xen XenTT 0 TCP Send TCP Receive

39 Network delay 39 ms (lower is better) Xen XenTT 0 Idle Ping 100MB/s stream

40 Log size 40 Raw Compressed (gzip) Linux boot 903 MB 145 MB Idle overnight (12 hours) 2 GB 529 MB Growth rate 167 MB/h (4 GB/day) 44 MB/h (1 GB/day) TCP receive (4 GB stream) Event log 1.8 GB 342 MB Payload log 4.4 GB Payload dependent Disk write (4 GB file) 600 MB 145 MB Disk read (4 GB file) 414 MB 62 MB

41 A tribute (related work) 41 ENIAC (1948) Exdams (1969) The first record-replay system ReVirt ( I ll never work on it again! [ReVirt team member]) VMware ( They did it, but it was a lot of work. [VMware team]) QEMU Lots of simplifying assumptions rr Mozilla

42 Principles (recap) 42 Three-part model Event types General interposition functions Simple locking model Determinizing proxies Active messages Fully-asynchronous logging Debugging tools for scaling development

43 Conclusions 43 Principles are important and will help future implementations Xen is arguably the hardest environment to implement replay KVM + QEMU should be easier I/O delay goes up You can address it with more cores But still cache-coherence has a non-zero cost Branch counters are fragile Our code works on several server CPUs Fails on a laptop with the CPU from the same model/family line Mainstream replay is possible for us as a community

44 44 Thank you. More questions:

Practical Record And Replay Debugging With rr. Robert O'Callahan

Practical Record And Replay Debugging With rr Robert O'Callahan Debugging nondeterminism Deterministic hardware Sources of nondeterminism Record inputs Replay execution Old idea PinPlay Nirvana Jockey