Programming Vast Networks of Tiny Devices

David Culler

University of California, Berkeley

Intel Research Berkeley http://webs.cs.berkeley.edu

Programmable network fabric

•

Architectural approach

– – –

new code image pushed through the network as packets assembled and verified in local flash second watch-dog processor reprograms main controller

• •

Viral code approach (Phil Levis)

– – – –

each node runs a tiny virtual machine interpreter captures the high-level behavior of application domain as individual instructions packets are “capsule” sequence of high-level instructions capsules can forward capsules Rich challenges

– – –

security energy trade-offs DOS 11/14/2002 pushc 1 # Light is sensor 1 sense # Push light reading pushm # Push message buffer clear # Clear message buffer add # Append val to buffer send # Send message using AHR forw NEC Intro # Forward capsule

Mate’ Tiny Virtual Machine

• • • •

Comm. centric stack machine

–

7286 bytes code, 603 bytes RAM

–

dynamicly typed Four context types:

–

send, receive, clock, subroutine (4)

–

each 24 instructions Fit in a single TinyOS AM packet

– –

Installation is atomic Self-propagating Version information 11/14/2002 Subroutines Events 0 1 2 3 PC gets/sets Operand Stack Return Stack Mate Context Network Programming Rate NEC Intro

100% 80% 60% 40% 20% 0% 0 20 40 60 80 100 120 140 160 180 200 220 240

Tim e (seconds)

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 11/14/2002 NEC Intro

Higher-level Programming?

• •

Ideally, would specify the desired global behavior Compilers would translate this into local operations

• •

High-Performance Fortran (HPF) analog

– –

program is sequence of parallel operations on large matrices each of the matrices are spread over many processors on a parallel machine

–

compiler translates from global view to local view

»

local operations + message passing

–

highly structured and regular We need a much richer suite of operations on unstructured aggregates on irregular, changing networks NEC Intro 11/14/2002

Sensor Databases – a start

• • •

Relational databases: rich queries described by declarative queries over tables of data

– – – –

select, join, count, sum, ...

user dictates what should be computed query optimizer determines how assumes data presented in complete, tabular form First step: database operations over streams of data

–

incremental query processing Big step: process the query in net

– –

query processing == content-based routing?

energy savings, bandwidth, reliability the sensor NEC Intro 11/14/2002 SELECT AVG(light) GROUP BY roomNo App Query, Trigger TinyDB Data Sensor Network

Motivation: Sensor Nets and In-Network Query Processing

• • • •

Many Sensor Network Applications are Data Oriented Queries Natural and Efficient Data Processing Mechanism

– –

Easy (unlike embedded C code) Enable optimizations through abstraction Aggregates Common Case

–

E.g. Which rooms are in use?

In-network processing a must

– – –

Sensor networks power and bandwidth constrained Communication dominates power cost

Not subject to Moore’s law!

11/14/2002 NEC Intro

SQL Primer

SELECT AVG(light) FROM sensors WHERE sound < 100 GROUP BY roomNo HAVING AVG(light) < 50

• • •

SQL is an established declarative language; not wedded to it

–

Some extensions clearly necessary, e.g. for sample rates We adopt a basic subset: SELECT FROM WHERE {agg n (attr n ), attrs} sensors {selPreds} GROUP BY {attrs} HAVING EPOCH DURATION {havingPreds} s ‘sensors’ relation (table) has

–

One column for each reading-type, or attribute

–

One row for each externalized value

»

May represent an aggregation of several individual readings NEC Intro 11/14/2002

TinyDB Demo (Sam Madden)

11/14/2002 Joe Hellerstein, Sam Madden, Wei Hong, Michael Franklin NEC Intro

Tiny Aggregation (TAG) Approach

• • • •

Push declarative queries into network

–

Impose a hierarchical routing tree onto the network Divide time into

epochs

Every epoch, sensors evaluate query over local sensor data and data from children

–

Aggregate local and child data

– –

Each node transmits just once per epoch Pipelined approach increases throughput Depending on aggregate function, various optimizations can be applied 11/14/2002 NEC Intro

100000 90000 80000 70000 60000 50000 40000 30000 20000 10000 0

Bytes / Epoch vs. Network Diameter

10 20 30 40

Network Diameter

50 COUNT MAX AVERAGE MEDIAN EXTERNAL DISTINCT hypothesis testing 3000

Messages/ Epoch vs. Network Diameter

2500 2000 1500 No Guess Guess = 50 Guess = 90 Snooping 1000 500 0 10 20 30 40

Network Diameter

50

Aggregation Functions

• •

Standard SQL supports “the basic 5”:

–

MIN, MAX, SUM, AVERAGE, and COUNT We support any function conforming to: Agg n ={f merge , f init , f evaluate } F merge {,}



f init {a 0 }



F evaluate {}



aggregate value (Merge associative, commutative!) Example: Average Partial Aggregate AVG merge AVG init {v} {} 1 >,





S 1 2 /C , C 1 2 >}



< S 1 + S 2 , C 1 + C 2 >

Query Propagation

• •

TAG propagation agnostic

–

Any algorithm that can:

»

Deliver the query to all sensors

»

Provide all sensors with one or more duplicate free routes to some root simple flooding approach

–

Query introduced at a root; rebroadcast by all sensors until it reaches leaves

–

Sensors pick parent and level when they hear query

–

Reselect parent after k silent epochs 11/14/2002 NEC Intro

Query 1 P:0, L:1 5 2 P:1, L:2 4 P:2, L:3 3 P:1, L:2 6 P:3, L:3 P:4, L:4

Illustration: Pipelined Aggregation

SELECT COUNT(*) FROM sensors

1 2 3

Depth = d

4 5

NEC Intro 11/14/2002

Illustration: Pipelined Aggregation

SELECT COUNT(*) FROM sensors

Sensor # 1

1

1

1

2

1

3

1

4

1

5 2 1 1 Epoch 1 1 1 4 1 1 3 5

NEC Intro 11/14/2002

Illustration: Pipelined Aggregation

SELECT COUNT(*) FROM sensors

Sensor # 1 2

1 3

1

1 1

2

1 2

3

1 2

4

1 1

5 2 1 3 Epoch 2 1 2 4 2 1 3 5

NEC Intro 11/14/2002

Illustration: Pipelined Aggregation

SELECT COUNT(*) FROM sensors

Sensor # 1 2 3

1 3 4

1

1 1 1

2

1 2 3

3

1 2 2

4

1 1 1

5 2 1 4 Epoch 3 1 3 4 2 1 3 5

NEC Intro 11/14/2002

Illustration: Pipelined Aggregation

SELECT COUNT(*) FROM sensors

Sensor # 1 2 3 4

1 3 4 5

1

1 1 1 1

2

1 2 3 3

3

1 2 2 2

4

1 1 1 1

5 2 1 5 Epoch 4 1 3 4 2 1 3 5

NEC Intro 11/14/2002

Illustration: Pipelined Aggregation

SELECT COUNT(*) FROM sensors

Sensor # 4 5 1 2 3

5 5 1 3 4

1

1 1 1 1 1

2

3 3 1 2 3

3

2 2 1 2 2

4

1 1 1 1 1

5

11/14/2002 NEC Intro

2 1 5 Epoch 5 1 3 4 2 1 3 5

Discussion

• • • • • •

Result is a stream of values

–

Ideal for monitoring scenarios One communication / node / epoch

–

Symmetric power consumption, even at root

1

New value on every epoch

2 –

After d-1 epochs, complete aggregation

4

Given a single loss, network will recover after at most d-1 epochs With time synchronization, nodes can sleep between epochs, except during small communication window Note: Values from different epochs combined

– –

Can be fixed via small cache of past values at each node Cache size at most one reading per child x depth of tree

3 5

NEC Intro 11/14/2002

Testbench & Matlab Integration

• • •

Positioned mica array for controlled studies

– – – – – in situ programming Localization (RF, TOF) Distributed Algorithms Distributed Control Auto Calibration

Out-of band “squid” instrumentation NW Integrated with MatLab

– – –

packets -> matlab events data processing filtering & control 11/14/2002 NEC Intro

Acoustic Time-of-Flight Ranging

• • • • • • •

Sounder/Tone Detect Pair Emit Sounder pulse and RF message Receiver uses message to arm Tone Detector Key Challenges

–

Noisy Environment

–

Calibration On-mote Noise Filter Calibration fundamental to “many cheap” regime

»

variations in tone frequency and amplitude, detector sensitivity Collect many pairs

–

4-parameter model for each pair

–

T(A->B, x) = O A

–

O A , L A + O in message , B O B + (L , L A B + L B local )x no calibration: 76% error joint calibration: 10.1% error 11/14/2002 NEC Intro