1. Mate: A Tiny Virtual Machine for Sensor Networks Phil Levis and David Culler Presented by Andrew Chien CSE 291 Chien April 22, 2003 (slides courtesy, Phil Levis)

2. CSE 291 Sensor Networks – 4/22/2003 Maté Motivation Overview Architecture, Instructions Viral code Evaluation Conclusion

3. CSE 291 Sensor Networks – 4/22/2003 Motivation Programming complexity »Low level »Error Prone Application flexibility (?) Binary reprogramming takes ~2 minutes »significant energy cost »can lose motes Idea: use a virtual machine – load the programs as structures pointing to lower level libraries

4. CSE 291 Sensor Networks – 4/22/2003 Sensor Network Programming Requirements Small (fit on Motes) Expressive (lots of applications) Concise (programs short for memory and network bandwidth) Resilient (don’t crash the system) Efficient (in sensing and communication) Tailorable – for application-specific operations Simple – in-situ, fast, “autonomous” programming

5. CSE 291 Sensor Networks – 4/22/2003 Maté Overview TinyOS component 7286 bytes code, 603 bytes RAM Three concurrent execution contexts Stack-based bytecode interpreter Code broken into 24 instruction capsules Self-forwarding code Rapid reprogramming Message receive and send contexts

6. CSE 291 Sensor Networks – 4/22/2003 Maté Overview, Continued Three execution contexts »Clock, Receive, Send Seven code capsules »Clock, Receive, Send, Subroutines 0-3 One word heap »gets / sets instructions Two-stack architecture »Operand stack, return address stack

7. CSE 291 Sensor Networks – 4/22/2003 Maté Architecture 0123 Subroutines Clock Send Receive Events gets/sets Code Operand Stack Return Stack Maté PC Mate Context

8. CSE 291 Sensor Networks – 4/22/2003 Maté Instructions 0123 Subroutines Clock Send Receive Events gets/sets Code Operand Stack Return Stack Maté PC Mate Context

9. CSE 291 Sensor Networks – 4/22/2003 Maté Instructions Two-stack architecture One byte per instruction Three classes: basic, s-type, x-type »basic: data, arithmetic, communication, sensing »s-type: used in send/receive contexts »x-type: embedded operands basic 00iiiiiii = instruction s-type 01iiixxxx = argument x-type 1ixxxxxx

10. CSE 291 Sensor Networks – 4/22/2003 Code Snippet: cnt_to_leds gets # Push heap variable on stack pushc 1 # Push 1 on stack add # Pop twice, add, push result copy # Copy top of stack sets # Pop, set heap pushc 7 # Push 0x0007 onto stack and # Take bottom 3 bits of value putled # Pop, set LEDs to bit pattern halt #

11. CSE 291 Sensor Networks – 4/22/2003 cnt_to_leds, Binary gets # 0x1b pushc 1 # 0xc1 add # 0x06 copy # 0x0b sets # 0x1a pushc 7 # 0xc7 and # 0x02 putled # 0x08 halt # 0x00

12. CSE 291 Sensor Networks – 4/22/2003 Sending a Message pushc 1 # Light is sensor 1 sense # Push light reading on stack pushm # Push message buffer on stack clear # Clear message buffer add # Append reading to buffer send # Send message using built-in halt # ad-hoc routing system

13. CSE 291 Sensor Networks – 4/22/2003 Maté Capsules 0123 Subroutines Clock Send Receive Events gets/sets Code Operand Stack Return Stack Maté PC Mate Context

14. CSE 291 Sensor Networks – 4/22/2003 Maté Capsules Hold up to 24 instructions Fit in a single TinyOS AM packet »Installation is atomic Four types: send, receive, clock, subroutine Context-specific: send, receive, clock Called: subroutines 0-3 Version information

15. CSE 291 Sensor Networks – 4/22/2003 Maté Contexts 0123 Subroutines Clock Send Receive Events gets/sets Code Operand Stack Return Stack Maté PC Mate Context

16. CSE 291 Sensor Networks – 4/22/2003 Contexts Each context associated with a capsule Executed in response to event »external: clock, receive »internal: send (in response to sendr ) Execution model »preemptive: clock »non-preemptive: send, receive Every instruction executed as TinyOS task

17. CSE 291 Sensor Networks – 4/22/2003 Viral Code Every capsule has version information Maté installs newer capsules it hears on network Motes can forward their capsules (local broadcast) »forw »forwo

18. CSE 291 Sensor Networks – 4/22/2003 Forwarding: cnt_to_leds gets # Push heap variable on stack pushc 1 # Push 1 on stack add # Pop twice, add, push result copy # Copy top of stack sets # Pop, set heap pushc 7 # Push 0x0007 onto stack and # Take bottom 3 bits of value putled # Pop, set LEDs to bit pattern forw # Forward capsule halt #

19. CSE 291 Sensor Networks – 4/22/2003 Evaluation Code Propagation Execution Rate 42 motes: 3x14 grid 3 hop network »largest cell 30 motes »smallest cell 15 motes

20. CSE 291 Sensor Networks – 4/22/2003 Code Propagation

21. CSE 291 Sensor Networks – 4/22/2003 Code Propagation, Continued (seconds) Network: 1/8Network: 1/4 NewMeanStd. Dev.MeanStd. Dev 1/82382815 1/4104 4 1/27372 1/182125 Network: 1/2Network: 1/1 NewMeanStd. Dev.MeanStd. Dev 1/84524361252 1/41910425280 1/22110226199 1144400339

22. CSE 291 Sensor Networks – 4/22/2003 Maté Instruction Issue Rate ~10,000 instructions per second Task operations are 1/3 of Maté overhead

23. CSE 291 Sensor Networks – 4/22/2003 Energy Consumption Compare with binary reprogramming Maté imposes a CPU overhead Maté provides a reprogramming time savings Energy tradeoff

24. CSE 291 Sensor Networks – 4/22/2003 Case Study: GDI Great Duck Island application Simple sense and send loop Runs every 8 seconds – low duty cycle 19 Maté instructions, 8K binary code Energy tradeoff: if you run GDI application for less than 6 days, Maté saves energy

25. CSE 291 Sensor Networks – 4/22/2003 Summary / Discussion Spectrum of reprogramming »Native code; Bytecode interpreter »How important is flexibility? »Is a viral model reasonable? Security? VM’s provide opportunities, but also overhead »Interpretive overhead is *high* »If operations are large enough (e.g. send), overhead is negligible (3000% to 3%) »What is a realistic mix? »Opportunity for managing heterogeneity and evolution?

26. CSE 291 Sensor Networks – 4/22/2003 Right requirements? Small (fit on Motes) Expressive (lots of applications) Concise (programs short for memory and network bandwidth) Resilient (don’t crash the system) Efficient (in sensing and communication) Tailorable – for application-specific operations Simple – in-situ, fast, “autonomous” programming => and does it meet them?