![Page 1: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/1.jpg)
Sensors Network SoftwareSensors Network Software
Qing FangStanford University
Sensing Networking
Computation
CS428CS428
![Page 2: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/2.jpg)
Outline
Why is writing software for sensornet so hard?
Programming platformsTinyOS (Berkeley) – in detailsEm* (UCLA) – very brief
DiscussionNetworking abstractions Programming models
![Page 3: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/3.jpg)
Embedded Networking Systems vs. the Internet –Different set of Goals and Principles
The Internet:
RFC 1958 (“Architectural Principles of the Internet”) reads:
“However, in very general terms, the community believes the goal is connectivity, the tool is the Internet Protocol, and the intelligence is end-to-end rather than hidden in the network…connectivity is its own reward, and is more valuable than any individual application”
EmNets:
The goal is application-specific collaboration among the nodes.
In-network processing rather than end-to-end.
![Page 4: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/4.jpg)
Software Challenges
UncertaintySystem uncertaintyData uncertainty
Lack of a common architecture
Energy constraints – may change over time
![Page 5: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/5.jpg)
Worst of All Worlds
“Text”
Timing-Dependent
Data
Real-WorldSensorInputs
Single- or Few-Threaded
Multi-Threaded
OS Kernels/Device Drivers
MS Wordcat
Robotics SensorNetworks
Distributed,Timing Dependent System
MPI/Linda
DistributedRobotics
Squid
TCP
System Uncertainty
DataUncertainty
Source: Jeremy Elson, Microsoft Research
![Page 6: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/6.jpg)
An Architecture
Is a set of principles that guide where functionality should be implemented along with a set of interfaces, functional components, protocols, and physical hardware that follows those guidelines.
![Page 7: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/7.jpg)
Traditional System Architecture
Well established layers of abstractionsAmple resourcesIndependent applications at endpoints that communicate pt-2-pt through routers
User
System
Physical Layer
Data Link
Network
Transport
Network Stack
Threads
Address Space
Drivers
Files
Application
Application
Routers
![Page 8: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/8.jpg)
A Sensor Network Architecture?
No, don’t have one yet.
We are still at the stage of extracting abstractions.
But, we know what we wantIncorporates current generation of technologyAllows future innovationPromotes interoperability
![Page 9: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/9.jpg)
Sensornet Functional Layer Decomposition – Separation of Concerns
Source: David Culler, et al., Berkeley
![Page 10: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/10.jpg)
TinyOS – Approach
Does not define a particular system/user boundary nor a set of system services.
Provides a framework for defining such boundaries and allows applications to select services and their implementations.
•128kB program flash
•512kB serial flash
![Page 11: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/11.jpg)
TinyOS – Design Considerations
Diversity in design and usage
Robust
inaccessible, critical operation
Concurrency intensive in bursts
streams of sensor data &
network traffic
Highly constrained resources
Applications spread over many small nodes
self-organizing collectives
highly integrated with changing environment and network
������������� ��������������� ������������������� �����������
�������������������
��������� ���� ���� ���� �
efficient modularity
migration across HW/SW boundary
![Page 12: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/12.jpg)
TinyOS – Choices of Programming Primitives
provide framework for concurrency and modularitynever poll, never blockinterleaving flows, events, energy management
allow appropriate abstractions to emerge
![Page 13: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/13.jpg)
TinyOS Features
Microthreaded OS (lightweight thread support)
An event-driven concurrency model without blocking
Two level scheduling structure
Long running tasks that can be interrupted by hardware events
Modularity allows crossover of software components into hardware
![Page 14: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/14.jpg)
The following slides on TinyOS are from David Culler, et al., UC Berkeley
![Page 15: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/15.jpg)
TinyOS ConceptsScheduler + Graph of Components
constrained two-level scheduling model: threads + events
ComponentCommands, Event HandlersTasks (concurrency)Frame (storage)
Constrained Storage Modelframe per component, shared stack, no heap
Very lean multithreadingLayering
Messaging Component
init
Pow
er(m
ode)
TX
_pac
ket(b
uf)
TX
_pac
ket
_don
e
RX
_pac
ket
_don
e (b
uffe
r)
Internal State
init
pow
er(m
ode)
send
_msg
(add
r, ty
pe, d
ata)
msg
_rec
(type
, dat
a)m
sg_s
end_
done
)
internal thread
Commands Events
![Page 16: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/16.jpg)
Application = Graph of Components
RFM
Radio byte
Radio Packet
UART
Serial Packet
ADC
Temp photo
Active Messages
clocksbit
byte
pack
et
Route map router sensor appln
appl
icat
ion
HW
SWExample: ad hoc, multi-hop routing of photo sensor readings
3450 B code226 B data
Graph of cooperatingstate machines on shared stack
![Page 17: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/17.jpg)
TinyOS Execution Model
commands request actionack/nack at every boundarycall cmd or post task
events notify occurrenceHW intrpt at lowest levelmay signal eventscall cmdspost tasks
Tasks provide logical concurrency
preempted by events
Migration of HW/SW boundary
RFM
Radio byte
Radio Packet
bit
byte
pack
et
event-driven bit-pump
event-driven byte-pump
event-driven packet-pump
message-event driven
active message
application comp
encode/decode
crc
data processing
![Page 18: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/18.jpg)
Dynamics of Events and Threads
bit event filtered at byte layer
bit event => end of byte =>
end of packet => end of msg send
thread posted to start
send next message
radio takes clock events to detect recv
![Page 19: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/19.jpg)
Event-Driven Sensor Access Pattern
command result_t StdControl.start() {
return call Timer.start(TIMER_REPEAT, 200);
}
event result_t Timer.fired() {
return call sensor.getData();
}
event result_t sensor.dataReady(uint16_t data) {
display(data)
return SUCCESS;
}
��������������������
Timer Photo LED
![Page 20: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/20.jpg)
TinyOS Execution Contexts
Events generated by interrupts preempt tasksTasks do not preempt tasksBoth essential process state transitions
Hardware
Interrupts
even
ts
commands
Tasks
![Page 21: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/21.jpg)
Typical application use of tasks
event driven data acquisitionschedule task to do computational portion
event result_t sensor.dataReady(uint16_t data) {
putdata(data);
post processData();
return SUCCESS;
}
task void processData() {
int16_t i, sum=0;
for (i=0; i ‹ maxdata; i++)
sum += (rdata[i] ›› 7);
display(sum ›› shiftdata);
}
![Page 22: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/22.jpg)
Tasks in low-level operation
transmit packetsend command schedules task to calculate CRCtask initiated byte-level data pumpevents keep the pump flowing
• receive packet– receive event schedules task to check CRC– task signals packet ready if OK
• byte-level tx/rx– task scheduled to encode/decode each complete byte– must take less time that byte data transfer
![Page 23: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/23.jpg)
Task Scheduling
Currently simple fifo schedulerBounded number of pending tasksWhen idle, shuts down node except clockUses non-blocking task queue data structureSimple event-driven structure + control over complete application/system graph
![Page 24: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/24.jpg)
Tiny Active MessagesSending
Declare buffer storage in a frameRequest TransmissionName a handlerHandle Completion signal
ReceivingDeclare a handlerFiring a handler
Buffer managementstrict ownership exchangetx: done event => reuserx: must rtn a buffer
![Page 25: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/25.jpg)
Sending a messagebool pending;
struct TOS_Msg data;
command result_t IntOutput.output(uint16_t value) {
IntMsg *message = (IntMsg *)data.data;
if (!pending) {
pending = TRUE;
message->val = value;
message->src = TOS_LOCAL_ADDRESS;if (call Send.send(TOS_BCAST_ADDR, sizeof(IntMsg), &data))
return SUCCESS;
pending = FALSE;
}
return FAIL;
}destination length
• Refuses to accept command if buffer is still full or network refuses to accept send command
• User component provide structured msg storage
![Page 26: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/26.jpg)
Send done eventevent result_t IntOutput.sendDone(TOS_MsgPtr msg,
result_t success)
{
if (pending && msg == &data) {
pending = FALSE;
signal IntOutput.outputComplete(success);
}
return SUCCESS;
}
}
![Page 27: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/27.jpg)
Receive Event
Active message automatically dispatched to associated handler
knows the format, no run-time parsingperforms action on message event
Must return free buffer to the systemtypically the incoming buffer if processing complete
event TOS_MsgPtr ReceiveIntMsg.receive(TOS_MsgPtr m) {
IntMsg *message = (IntMsg *)m->data;
call IntOutput.output(message->val);
return m;
}
![Page 28: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/28.jpg)
Programming TinyOS
TinyOS 1.0 is written in an extension of C, called nesCApplications are too!
just additional components composed with the OS components
Provides syntax for TinyOS concurrency and storage model
commands, events, taskslocal frame variable
Rich Compositional Support
![Page 29: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/29.jpg)
CompositionA component specifies a set of interfaces by which it is connected to other components
provides a set of interfaces to othersuses a set of interfaces provided by others
Interfaces are bi-directionalinclude commands and events
Interface methods are the external namespace of the component
Timer Component
StdControl Timer
Clock
provides
uses
provides
interface StdControl;
interface Timer:
uses
interface Clock
![Page 30: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/30.jpg)
ComponentsModules
provide code that implements one or more interfaces and internal behavior
Configurationslink together components to yield new component
Interfacelogically related set of commands and events
StdControl.nc
interface StdControl {
command result_t init();
command result_t start();
command result_t stop();
}
Clock.nc
interface Clock {
command result_t setRate(char interval, char scale);
event result_t fire();
}
![Page 31: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/31.jpg)
Example top level configurationconfiguration SenseToRfm {
// this module does not provide any interface
}
implementation
{
components Main, SenseToInt, IntToRfm, ClockC, Photo as Sensor;
Main.StdControl -> SenseToInt;
Main.StdControl -> IntToRfm;
SenseToInt.Clock -> ClockC;
SenseToInt.ADC -> Sensor;
SenseToInt.ADCControl -> Sensor;
SenseToInt.IntOutput -> IntToRfm;
}
��������������������������������
ClockC Photo
Main
StdControl
ADCControl IntOutputClock ADC
IntToRfm
![Page 32: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/32.jpg)
Nested configurationincludes IntMsg;
configuration IntToRfm
{
provides {
interface IntOutput;
interface StdControl;
}
}
implementation
{
components IntToRfmM, GenericComm as Comm;
IntOutput = IntToRfmM;
StdControl = IntToRfmM;
IntToRfmM.Send -> Comm.SendMsg[AM_INTMSG];
IntToRfmM.SubControl -> Comm;
}
IntToRfmM
GenericComm
StdControl IntOutput
SubControl SendMsg[AM_INTMSG];
![Page 33: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/33.jpg)
IntToRfm Moduleincludes IntMsg;
module IntToRfmM {
uses {interface StdControl as SubControl;interface SendMsg as Send;
}provides {
interface IntOutput;interface StdControl;
}}implementation{
bool pending;struct TOS_Msg data;
command result_t StdControl.init() {pending = FALSE;return call SubControl.init();
}
command result_t StdControl.start()
{ return call SubControl.start(); }
command result_t StdControl.stop()
{ return call SubControl.stop(); }
command result_t IntOutput.output(uint16_t value)
{
...
if (call Send.send(TOS_BCAST_ADDR,sizeof(IntMsg), &data)
return SUCCESS;
...
}
event result_t Send.sendDone(TOS_MsgPtr msg, result_t success)
{
...
![Page 34: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/34.jpg)
A Multihop Routing Example
![Page 35: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/35.jpg)
Supporting HW evolution
Distribution broken intoapps: top-level applicationslib: shared application componentssystem: hardware independent system componentsplatform: hardware dependent system components
Component design so HW and SW look the sameHW/SW boundary can move up and down with minimal changes
![Page 36: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/36.jpg)
TinyOS toolsTOSSIM: a simulator for tinyos programs
ListenRaw, SerialForwarder: java tools to receive raw packets on PC from base node
Oscilloscope: java tool to visualize (sensor) data in real time
Memory usage: breaks down memory usage per component (in contrib)
Peacekeeper: detect RAM corruption due to stack overflows (in lib)
Stopwatch: tool to measure execution time of code block by timestamping at entry and exit
Makedoc and graphviz: generate and visualize component hierarchy
Surge, Deluge, SNMS, TinyDB
![Page 37: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/37.jpg)
TinyOS LimitationsStatic allocation allows for compile-time analysis, but can make programming harder
No support for heterogeneitySupport for other platforms (e.g. stargate)
Support for high data rate apps (e.g. acoustic beamforming)
Interoperability with other software frameworks and languages
Limited visibility
Debugging
Intra-node fault tolerance
Robustness solved in the details of implementation nesC offers only some types of checking
![Page 38: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/38.jpg)
Em*Software environment for sensor networks built from Linux-class devices
Claimed features:
Simulation and emulation tools
Modular, but not strictly layered architecture
Robust, autonomous, remote operation
Fault tolerance within node and between nodes
Reactivity to dynamics in environment and task
High visibility into system: interactive access to all services
![Page 39: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/39.jpg)
Contrasting Emstar and TinyOS
Similar design choicesprogramming framework
Component-based design“Wiring together” modules into an application
event-drivenreactive to “sudden” sensor events or triggers
Differenceshardware platform-dependent constraints
Emstar: Develop without optimizationTinyOS: Develop under severe resource-constraints
operating system and language choicesEmstar: easy to use C language, tightly coupled to linuxTinyOS: an extended C-compiler (nesC), an OS by itself
![Page 40: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/40.jpg)
Em* Transparently Trades-off Scale vs. Reality
Em* code runs transparently at many degrees of “reality”:
high visibility debugging before low-visibility deployment
Reality
Scal
e
Pure Simulation
Data Replay
Portable Array
Deployment
Ceiling Array
![Page 41: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/41.jpg)
Other Platforms
SOS – UCLA
Contiki – Swedish Institute of Computer Science
Virtual machines (Mat�) �UC Berkeley
![Page 42: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/42.jpg)
Go Back to the Architecture Challenge
We need higher level abstractions!Why?
They let you reason about software at a higher level.They let software interoperate better.
CompactConsistentReuse
And this calls for…
![Page 43: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/43.jpg)
Towards Higher Level Abstractions
Better understanding of the applications
More efficient and effective algorithmsDesigning local rules to cause global behavior is hard
![Page 44: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/44.jpg)
The Emerging Networking Abstractions
Singer hop communication – active messageMulti-hop communication
Tree based routingDirected diffusionBroadcastEpidemic protocolsLandmark based routing? �
Power managementTime synchronization
Mechanism vs. policy
![Page 45: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/45.jpg)
Programming Models
TinyOS is no fun to programSplit-phase operation A logically blocking sequence must be written in a state-machine style.
State Machine Model? (ETH)*Token Machine Model? (MIT)*
* In proceedings of IPSN, 2005
![Page 46: Qing Fang Stanford Universitygraphics.stanford.edu/courses/cs428-05-spring/Lectures/... · 2005-05-18 · programming framework Component-based design “Wiring together” modules](https://reader033.vdocuments.net/reader033/viewer/2022060406/5f0f74c77e708231d4444054/html5/thumbnails/46.jpg)
The End