Critiques. Ø Critique #1

Transcription

1 Critiques Ø 1/2 page critiques of research papers Ø Due at 10am on the class day (hard deadline) Ø Yehan in plain txt Ø Back-of-envelop notes - NOT whole essays Ø Guidelines: Ø Critique #1 q D. Gay, P. Levis, R. von Behren, M. Welsh, E. Brewer, and D. Culler, The nesc Language: A Holistic Approach to Networked Embedded Systems, ACM Conference on Programming Language Design and Implementation (PLDI), June q Due on 1/30 (Tuesday) 1

2 IoT Operating Systems Chenyang Lu 2

3 TinyOS and nesc Ø TinyOS: OS for wireless sensor networks. Ø nesc: programming language for TinyOS. Chenyang Lu 3

4 Mica2 Mote Ø Microcontroller: 7.4 MHz, 8 bit Ø Memory: 4KB data, 128 KB program Ø Radio: max 38.4 Kbps Ø Sensors: Light, temperature, acceleration, acoustic, magnetic Ø Power q <1 week on two AA batteries in active mode q >1 year battery life on sleep modes! Ø Contrast to Raspberry Pi: Chenyang Lu 4

5 Epic Core CC2420 radio LoWPAN/IPv6 2.5 x 2.5 cm RAM 10 KB Flash 48 KB TI MSP430 Clock 4/8 MHz I/O (some shared) 8 ADC (12 bit) 2 DAC (12 bit) 1 I2C 1 JTAG 1 1-Wire 2 SPI 2 UART 8 general, 8 interrupt, and 5 special pin connectors 3 V Unique hardware ID 16 MB Flash memory Typical sleep current 9μA at 3V, radio active ~20mA 5

6 TelosB Ø Six major I/O devices Ø Possible Concurrency q I 2 C, SPI, ADC Ø Energy Management q Turn peripherals on only when needed q Turn off otherwise 6

7 Hardware Constraints Severe constraints on power, size, and cost à Ø slow microprocessor Ø low-bandwidth radio Ø limited memory Ø limited hardware parallelism à CPU hit by many interrupts! Ø manage sleep modes in hardware components Chenyang Lu 7

8 Software Challenges Ø Small memory footprint Ø Efficiency - power and processing Ø Concurrency-intensive operations Ø Diversity in applications & platform à efficient modularity q Support reconfigurable hardware and software Chenyang Lu 8

9 Traditional OS Ø Multi-threaded Ø Preemptive scheduling Ø Threads: q ready to run; q executing on the CPU; q waiting for data. executing gets CPU preempted needs data ready gets data needs data waiting Chenyang Lu 9

10 Limitations of Traditional OS Ø Multi-threaded + preemptive scheduling q Preempted threads waste memory q Context switch overhead Ø I/O q Blocking I/O: waste memory on blocked threads q Polling (busy-wait): waste CPU cycles and power Chenyang Lu 10

11 Example: Preemptive Priority Scheduling Ø Each process has a fixed priority (1 highest); Ø P 1 : priority 1; P 2 : priority 2; P 3 : priority 3. P 3 released P 2 released P 1 released P2 P1 P2 P time Chenyang Lu 11

12 Context Switch process 1 process 2... PC registers CPU memory Chenyang Lu CSE 467S 12

13 Existing Embedded OS Name Code Size Target CPU posek 2K Microcontrollers psosystem PII->ARM Thumb VxWorks 286K Pentium -> Strong ARM QNX Nutrino >100K Pentium II -> NEC QNX RealTime 100K Pentium II -> SH4 OS-9 Pentium -> SH4 Chorus OS 10K Pentium -> Strong ARM ARIEL 19K SH2, ARM Thumb Creem 560 bytes ATMEL 8051 Ø QNX context switch = 2400 cycles on x86 Ø posek context switch > 40 µs Ø Creem -> no preemption System architecture directions for network sensors, J. Hill, R. Szewczyk, A. Woo, S. Hollar, D. Culler, K. Pister. ASPLOS Chenyang Lu 13

14 TinyOS Solutions Ø Efficient modularity q Application = scheduler + graph of components q Compiled into one executable q Only needed components are complied/loaded Ø Concurrency: event-driven architecture Main (includes Scheduler) Application (User Components) Actuating Sensing Communication Communication Hardware Abstractions Modified from D. Culler et al., TinyOS boot camp presentation, Feb 2001 Chenyang Lu 14

15 Example: Surge Sur gec BootC StdControl StdControl Sur gep ADC Timer SendMsg Leds StdControl PhotoC ADC StdControl Timer StdControl SendMsg Leds TimerC MultihopC LedsC Chenyang Lu 15

16 Typical Application D. Culler et. Al., TinyOS boot camp presentation, Feb 2001 application sensing application routing Routing Layer messaging Messaging Layer packet Radio Packet byte Radio Byte (MAC) photo Temp SW bit RFM clocks ADC i2c HW Chenyang Lu 16

17 Two-level Scheduling Ø Events handle interrupts q Interrupts trigger lowest level events q Events can signal events, call commands, or post tasks Ø Tasks perform deferred computations Ø Interrupts preempt tasks and interrupts Preempt POST Tasks FIFO events commands commands Hardware Interrupts Time Chenyang Lu 17

18 Multiple Data Flows Ø Respond quickly: sequence of event/command through the component graph. q Immediate execution of function calls q e.g., get bit out of radio before it gets lost. Ø Post tasks for deferred computations. q e.g., encoding. Ø Events preempt tasks to handle new interrupts. Chenyang Lu 18

19 Sending a Message Timing diagram of event propagation (step 0-6 takes about 95 microseconds total) Chenyang Lu 19

20 Scheduling Ø Interrupts preempt tasks q Respond quickly q Event/command implemented as function calls Ø Task cannot preempt tasks q Reduce context switch à efficiency q Single stack à low memory footprint q TinyOS 2 supports pluggable task scheduler (default: FIFO). Ø Scheduler puts processor to sleep when q no event/command is running q task queue is empty Chenyang Lu 20

21 Space Breakdown Code size for ad hoc networking application Bytes Interrupts Message Dispatch Initilization C-Runtime Scheduler: 144 Bytes code Light Sensor Clock Totals: 3430 Bytes code Scheduler 226 Bytes data Led Control Messaging Layer Packet Layer Radio Interface Routing Application Radio Byte Encoder D. Culler et. Al., TinyOS boot camp presentation, Feb 2001 Chenyang Lu 21

22 Power Breakdown Active Idle Sleep CPU 5 ma 2 ma 5 μa Radio 7 ma (TX) 4.5 ma (RX) 5 μa EE-Prom 3 ma 0 0 LED s 4 ma 0 0 Photo Diode 200 μa 0 0 Panasonic CR mah Temperature 200 μa 0 0 q Lithium Battery runs for 35 hours at peak load and years at minimum load! That s three orders of magnitude difference! q A one byte transmission uses the same energy as approx cycles of computation. Chenyang Lu 22

23 Time Breakdown Components Packet reception work breakdown CPU Utilization Energy (nj/bit) AM 0.05% 0.20% 0.33 Packet 1.12% 0.51% 7.58 Radio handler 26.87% 12.16% Radio decode thread 5.48% 2.48% 37.2 RFM 66.48% 30.08% Radio Reception Idle % - Total % % Ø 50 cycle task overhead (6 byte copies) Ø 10 cycle event overhead (1.25 byte copies) Chenyang Lu 23

24 Advantages Ø Small memory footprint q Only needed components are complied/loaded q Single stack for tasks Ø Power efficiency q Put CPU to sleep whenever the task queue is empty q TinyOS 2 (ICEM) provides power management for peripherals. Ø Efficient modularity q Event/command interfaces between components q Event/command implemented as function calls Ø Concurrency-intensive operations q Event/command + tasks Chenyang Lu 24

25 Critiques Ø No protection barrier between kernel and applications Ø No preemptive scheduling à a real-time task may wait for non-urgent ones Ø Static linking à cannot change parts of the code dynamically Ø Virtual memory? Chenyang Lu 25

26 nesc Ø Programming language for TinyOS and applications Ø Support TinyOS components Ø Whole-program analysis at compile time q Improve robustness: detect race conditions q Optimization: function inlining Ø Static language q No function pointer q No malloc q Call graph and variable access are known at compile time Chenyang Lu 26

27 Application Ø Interfaces q provides interface q uses interface Ø Implementation q module: C behavior q configuration: select & wire StdControl TimerP Clock Timer module TimerP { provides { interface StdControl; interface Timer; } uses interface Clock;... } Chenyang Lu 27

28 Interface interface Clock { command error_t setrate(char interval, char scale); event error_t fire(); } interface Send { command error_t send(message_t *msg, uint16_t length); event error_t senddone(message_t *msg, error_t success); } interface ADC { command error_t getdata(); event error_t dataready(uint16_t data); } Bidirectional interface supports split-phase operation Chenyang Lu 28

29 module SurgeP { provides interface StdControl; uses interface ADC; uses interface Timer; uses interface Send; } implementation { bool busy; norace uint16_t sensorreading; async event result_t Timer.fired() { bool localbusy; atomic { localbusy = busy; busy = TRUE; } if (!localbusy) call ADC.getData(); return SUCCESS; } async event result_t ADC.dataReady(uint16_t data) { sensorreading = data; post senddata(); return SUCCESS; }... } Module Chenyang Lu 29

30 Configuration StdControl Timer StdControl Timer TimerP Clock configuration TimerC { provides { interface StdControl; interface Timer; } } implementation { components TimerP, HWClock; TimerC Clock HWClock } StdControl = TimerP.StdControl; Timer = TimerP.Timer; TimerP.Clock -> HWClock.Clock; Chenyang Lu 30

31 Example: Surge Sur gec BootC StdControl StdControl Sur gep ADC Timer SendMsg Leds StdControl PhotoC ADC StdControl Timer StdControl SendMsg Leds TimerC MultihopC LedsC Chenyang Lu 31

32 Concurrency Ø Race condition: concurrent interrupts/tasks update shared variables. Ø Asynchronous code (AC): reachable from at least one interrupt. Ø Synchronous code (SC): reachable from tasks only. Ø Any update of a shared variable from AC is a potential race condition! Chenyang Lu 32

33 A Race Condition module SurgeP {... } implementation { bool busy; norace uint16_t sensorreading; async event result_t Timer.fired() { if (!busy) { busy = TRUE; call ADC.getData(); } return SUCCESS; } task void senddata() { // send sensorreading adcpacket.data = sensorreading; call Send.send(&adcPacket, sizeof adcpacket.data); return SUCCESS; } async event result_t ADC.dataReady(uint16_t data) { sensorreading = data; post senddata(); return SUCCESS; } Chenyang Lu 33

34 Atomic Sections atomic { <Statement list> } Ø Disable interrupt when atomic code is being executed Ø But cannot disable interrupt for long! q No loop q No command/event q Function calls OK, but callee must meet restrictions too Chenyang Lu 34

35 Prevent Race module SurgeP {... } implementation { bool busy; norace uint16_t sensorreading; disable interrupt enable interrupt async event result_t Timer.fired() { bool localbusy; atomic { } localbusy = busy; busy = TRUE; } if (!localbusy) call ADC.getData(); return SUCCESS; test-and-set Chenyang Lu 35

36 nesc Compiler Ø Race-free invariant: any update of a shared variable q is from SC only, or q occurs within an atomic section. Ø Compiler returns error if the invariant is violated. Ø Fix q Make access to shared variables atomic. q Move access to shared variables to tasks. Chenyang Lu 36

37 Results Ø Tested on full TinyOS code, plus applications q 186 modules (121 modules, 65 configurations) q modules/app, 35 average q 17 tasks, 75 events on average (per application) - lots of concurrency! Ø Found 156 races: 103 real q About 6 per 1000 lines of code! Ø Fixed races: q Add atomic sections q Post tasks (move code to task context) Chenyang Lu 37

38 Optimization: Inlining App Code size Code inlined noninlined reduction Data size CPU reduction Surge % % Maté % % TinyDB % % Inlining improves performance and reduces code size. Why? Chenyang Lu 38

39 Overhead for Function Calls Ø Caller: call a function q Push return address to stack q Push parameters to stack q Jump to function Ø Callee: receive a call q Pop parameters from stack Ø Callee: return q Pop return address from stack q Push return value to stack q Jump back to caller Ø Caller: return q Pop return value Many overhead instructions for function calls! Chenyang Lu 39

40 Principles Revisited Ø Support TinyOS components q Interface, modules, configuration Ø Whole-program analysis and optimization q Improve robustness: detect race conditions q Optimization: function inlining q More: memory footprint. Ø Static language q No malloc, no function pointers Chenyang Lu 40

41 Critiques Ø No dynamic memory allocation q Bound memory footprint q Allow offline footprint analysis q How to size buffer when data size varies dynamically? Ø Restriction: no long-running code in q command/event handlers q atomic sections Chenyang Lu 41

42 Commercial IoT OS Ø Contiki: open-source, multi-threaded OS, plain C. Ø Amazon FreeRTOS: open-source FreeRTOS kernel + libraries to securely connect devices to AWS cloud services. Ø Arm Mbed: open-source OS based on an Arm Cortex-M microcontroller. Ø Android Things: SDK similar to traditional Android mobile development and involves writing apps using the Android framework and tools. Ø Windows 10 IoT Core: a version of Windows 10 that is optimized for smaller devices and that runs on both ARM and x86/x64 devices. Chenyang Lu 42

43 Reading Ø D. Gay, P. Levis, R. von Behren, M. Welsh, E. Brewer, and D. Culler, The nesc Language: A Holistic Approach to Networked Embedded Systems. Ø D. Culler, TinyOS: Operating System Design for Wireless Sensor Networks, Sensors, May Ø J. Hill, R. Szewczyk, A. Woo, S. Hollar, D. Culler, and K. Pister, System Architecture Directions for Network Sensors. Ø P. Levis and D. Gay, TinyOS Programming, q Purchase the book online q Download the first half of the published version for free. Ø Chenyang Lu 43