12/3 Reviews - Quanto

[Rodrigo]

Please post your reviews here.
I can take well-founded criticism, and it doesn't affect your grade :)

[Kevin Tierney]

Title: Quanto: Tracking Energy in Networked Embedded Systems
Author(s): Fonseca et al
Date: OSDI 2008

Novel Idea
Quanto is a system profiling energy usage on embedded network devices.
Quanto introduces a labeling system to try to map software activities
to power usage in the hardware. The logs of energy usage generated are
stored for offline processing, and using a regression the authors are
able to determine the energy draw of hardware components.

Main Result(s)
Quanto is an easily implementable system that provides insight into
the energy usage of network devices, and using the system can uncover
previously unknown problems with a system.

Impact
Using a program like Quanto, at least during the debugging stages of
developing embedded network devices, seems like it could easily become
standard.

Evidence
The authors present several studies, 2 of simple embedded devices
(blink and bounce) , and then of more complicated case studies.

Prior Work
It seems like the most relevant prior work is x-trace, which is really
similar except is measuring cpu time across networked devices.

Reproducibility
I'm not entirely sure how to implement this, but as long as source
code was available the experiments are reproducible.

Question
Given logs from Quanto, can we calculate its energy usage so as to
know how many joules or watts of energy Quanto consumed?

Criticism
While I am all for omitting ugly implementation details that are
better left to a distribution of source code alongside the paper, I
feel like I know how many lines of code this takes, and that packets
get an extra field with an activity, but beyond that, I'm not so sure
how things are working. For example, if Quanto is purely an OS
modification, I'm not clear on how it instruments calls to LEDs and
other hardware.

Ideas for further work

[Sunil Mallya]

Paper Title

Quanto: Tracking Energy in Networked Embedded

Author(s)
Systems Fonseca, Rodrigo, Dutta, Prabal, Levis, Philip, and Stoica,
Ion

Date
OSDI 2008

Novel Idea

Creating an energy and time profiler to meter energy of a sensor
network system which can provide information about how, what and why
energy was consumed.

Main Result(s)
Quanto tries to address 3 basic challenges i.e Energy metering, Energy
breakdown & Activity tracking.
Energy metering is figuring out how much energy was consumed by a
particular operation, to do this the power state of the energy sinks
have to be determined and device drivers were modified so that these
power states would be exposed, Then using a switching regulator and a
counter (icount) chip the energy measurement is reduced to a simple
counting operation.( each count corresponds to a fixed quanta of
energy).
Energy Breakdown is breaking down the energy consumption with the help
of regression. Essentially energy consumed is broken down into a
online regression which is sum of power consumed by each of the power
states for a particular sink.
Activity tracking connects the causal dots of operations which helps
us track the energy used by higher level user abstractions called
activities. This is done by introducing the abstraction with an
annotation and then associating an activity label with the execution
similar to that done in XTrace system, this label is later propagated
throughout the system and later helps in tracking and logging which
activity consumed what amount of energy.

Impact
Quanto can be used to find energy leaks, track buttery effects on
network-wide actions and support realtime, continuous energy metering.

Ideas for further work
Use quanto to track energy in Cinder systems.
Enable Energy aware Task Scheduling on Sensor network systems.

[Dan Rosenberg]

Paper Title
Quanto: Tracking Energy in Networked Embedded Systems

Authors
Rodrigo Fonseca, et al.

Date
2008

Novel Idea
The authors propose Quanto, a lightweight system for recording fine-grained measurements of energy consumption and correlating these measurements with their causes.

Main Result
Quanto uses the "activity" primitive to allow developers to annotate the causes of energy-using events, and successfully correlates these activity annotations with measurements of actual consumption.

Impact
Quanto may prove extremely useful for developing detailed energy profiles for embedded devices and troubleshooting live embedded systems.

Evidence
The authors convincingly demonstrate that the technique used to measure power consumption is accurate by comparing against a oscilloscope readings.  Blink and Bounce are provided as simple examples of Quanto in action.  Finally, case studies involving the impact of a wireless network on low-power listening, a simple timer-based application, and settings of the radio stack.  In all cases, Quanto provided insight on the cause of anomalies or answered performance questions.  In terms of performance overhead, 71% of active CPU time seems high, but this number is sufficiently addressed.

Prior Work
Quanto expands upon prior work in energy-aware technology, including ECOSystem, PowerTOSSIM, RIALTO, and research in modeling network behavior as causal paths, such as Magpie, Pinpoint, and X-Trace.

Reproducibility
The experiments provided could be reproduced given access to Quanto.  It might be possible to reproduce Quanto if I knew more about hardware and embedded systems.

Criticism
Logging activity data to RAM may work well for a prototype, but would limit the usefulness of Quanto in a real life context, because it would leave operators unable to determine the energy profile of devices that unexpectedly ran out of power early and shut off.  Table 3 (page 9) is mislabeled - switch (c) with (d).

Questions/Ideas for Further Work
I would be interested in seeing further evidence supporting the idea that Quanto could be used specifically to troubleshoot unexpected energy problems - this seems promising.  Quanto is designed for embedded systems, but which of its design principles could be applied to a non-embedded platform?  While the need for energy profiling isn't as strong on non-embedded systems, it may still be interesting to determine which system components demand the most power when subjected to different application loads.

[Spiros E.]

The paper presents Quanto, an instrumentation system for monitoring
energy consumption in distributed systems. The paper focuses on
embedded systems and discusses an instrumentation of TinyOS.

Quanto borrows the notion of activity as the basic unit to which
energy consumption of devices is to be allocated. An application
manually controls the current activity of the system, and the
instrumented system will then appropriately allocate energy
consumption to that activity, as well as track that activity through
network communication and interrupts.From the examples in the paper,
it's unclear whether programmers are meant to set activity on a per-
device basis, or if setting the activity is a global act.

For the purpose of tracking activity between nodes, packets that are
transmitted between nodes are labeled with the origin node and the
task id. The protocol that's instrumented limits the size of these
fields to 16 bits each. I'm curious how much of an issue this is for
the types of systems that Quanto is targeting. Specifically the node
limit seems as though it would be prohibitive to Quanto's use.
However, it would make sense to cut up the available 32 bits
differently depending on the size, and activity granularity demanded
by the system, and nothing inherent in Quanto's design would forbid
that.

On every power state transition Quanto records an estimate of the
energy consumed and the time since the last power state transition, as
well as the active power states. This infomation is logged, and
subsequently used to construct a set of linear equations which are
solved to determine the power consumption of each device in each of
its power states. What guarantees (outside of liner dependences) does
one have that the system will run long enough to collect enough
equations so that they can be solved? Put another way, it seems
asthough we should be interested in the energy consumption of devices
thoughout their use. If for example, we're having a problem with
certain devices on startup that we believe may be related to energy
consumption, they may never run long enough for us to collect enough
information to debug the problem. On a related note, the systems that
are discussed in the paper log this data to RAM. If ever the node
failed, all that energy consumption data would be lost, which would
make it difficult to debug the problem.

The paper says that Quanto takes up 70% of the CPU time of an
application. Though this may be acceptable for the systems Quanto is
targeting, this would suggest that Quanto is not well-suited to
applications with intervals of high CPU utilization.

Given that the Quanto source code is readily available, the evaluation
seems as though it is reproducible. However, in addition to the
experiments conducted, it would have been nice to see an example of
how the data Quanto collects can be used to improve a system.

[Steve Gomez]

Author: R. Fonseca, P. Dutta, P. Levis, and I. Stoica

Paper Title: "Quanto: Tracking Energy in Networked Embedded Systems"

Date: In OSDI 2008

Quanto is a "network-wide time and energy profiler for embedded
network devices". This type of monitoring tool is motivated by the
need for energy efficiency on embedded devices, which are often
battery-operated and move between distinct operating modes (e.g.
sampling from sensors, transmitting data, etc.). Quanto works by
taking fine-grained measurements ("as cheaply as reading a counter")
of aggregate energy use (from which it can distinguish component-wise
energy draw), and causally connects these energy costs to programmer-
defined, high-level activities. The contribution of this project is a
tool that allows high-level profiling of real energy cost, and that
could have a big impact for embedded systems able to be instrumented
for Quanto.

Related work includes energy-aware operating systems like ECOSystem,
which includes first-class abstractions for energy. Quanto takes this
a step further by tracking actually energy at runtime (Quanto uses a
model at runtime, and profiles energy offline), and by tracking energy
use over networked systems instead of single nodes. Other related
work includes Eon, "a programming language and runtime system that
allows paths or flows through the program to be annotated with
different energy states." This is similar to Quanto's association of
energy to high-level activities.

The authors evaluate Quanto with several experiments, and walk through
a few more that show Quanto being helpful for real-world use. I think
I understood most of the charts that communicate the results (I get
the feeling this is much easier for someone closer to this material).
The examples walking through Figures 11 and 12 help to motivate energy
and state transition monitoring.

A criticism I have is that the space of scenarios where the linearity
(or other) assumptions fail (causing bad regression) is not explored
very clearly in this section. When does Quanto really fail? Can we
generalize about this as it relates to classes of systems (i.e. are
some systems doomed, as far as monitoring with Quanto)?

The results of the paper could be reproduced based on the descriptions
with a bit of work. The authors are clear about their interface
abstractions, and walk through many of their methods (e.g. using
multivariate least squares to estimate power use given logs). Some
parts that require less cleverness and more engineering (e.g. TinyOS
instrumentation) are left at a high-level.

A question about future work: how feasible is real-time processing/
regression of the measured times/energy? The authors state that
energy and time intervals are recorded in real-time, but written out
to logs to be processed offline. Quanto is a monitoring tool, so real-
time processing may be less important, but for ECOSystem or Cinder,
which would like to react to energy observations, that type of online
processing would be important. Also, would be there be any benefit
for monitoring (aside from storage resource savings) if Quanto could
process the measurements online (e.g. parameter tuning, adaptive
monitoring)?

[Juexin Wang]

Paper Tile:

Quanto: Tracking Energy in Networked Embedded Systems

Date:
Aug, 2009

Author:
Rodrigo Fonseca,   Prabal Dutta,  Philip Levis,   Ion Stoica

Novel Idea:
-Pre-define the energy cost for hardware and program activities.

Main Results:
-Designed the Quanto, a network-wide time and energy profiler for embedded network devices

 

Impact:
-Quanto, a network-wide time and energy profiler for embedded network devices, allows developers to precisely quantify the effects of low-level system implementation decisions.

 

Evidence
-Device drivers to track and expose hardware power states to the OS. Every time any hardware component changes its power state, the OS records how much energy was used, and how much time has passed.

-Quanto tracks when a hardware component is performing operations on behalf of an activity to account for the resource consumption. Each activity is given a label.
-Activity labels could be transfered across nodes.
-Quanto records events for both power state and activity changes for each hardware resource by logging (locally?)

Reproducibility
Yes. And could also be implemented on platforms other than TinyOS.

Comparative Work
No.

Question

if the developer want to get the total energy consuming of one activity, does he must read all logs of nodes that involved in that activity? Is there a better way to organize this data (or do I carelessly missed this part) for large cooperate tasks in symmetric systems such as WSN?
 

Criticism

-I believe the Quanto is used in simulation platform in developing, so the result is mainly depends on the pre-defined energy sinks rather than realistic. It make sence that the pre-defined value could be used in comparing, but in reality the wireless systems suffer from unstable and connect failure, these could also effect: which algorithm is more efficiency in tough condition.

Ideas for further work
Design the Quanto as an independed middle-ware, suit for as many platforms/simulation environments as possible. Or script it, being ran by nodes together with functional applications when simulating.

On Wed, Dec 2, 2009 at 6:34 PM, Rodrigo <rodrigo...@gmail.com> wrote:

Please post your reviews here.
I can take well-founded criticism, and it doesn't affect your grade :)

--
J.W
Happy to receive ur message

[Dongbo Wang]

Paper Title: Quanto: Tracking Energy in Networked Embedded Systems

Authors: Rodrigo Fonseca, Prabal Dutta, Philip Levis, and Ion Stoica

Date: 2008

Novel Ideas: The way of energy profiling presented in the paper is very interesting. It shows how a complex problem (profiling the energy consumption of activities on sensors) is analyzed and broken into sub problems in different abstraction. 

• First sub-question is how to get the fine-grained measurement of energy consumption for each component. The components have several different operating modes, and different operating modes involve different energy draws. Given this fact, the authors of this paper did not try to figure out a way to individually measure the energy consumption of each component, but keep track of the changes of operating modes, and the changes of overall energy of the whole system. Since the overall energy should be the sum of that of each component, the energy draws of each component at each operating mode can be calculated over time. In this way, only the measurement of the whole system is enough for telling how much energy each component used for a specified period of time.
• The second sub-question is given the knowledge of the energy consumption of each component, how to figure out which activities is responsible for the energy consumption of these components. The paper accomplish this sub-question by tracking activities, figuring out which components are involved in which activities. I think this takes advantage of the tracking research in X-trace.

Finally, all information is merged to answer the original complex question. I like the method of measuring energy consumption of each component. Using different view to see the same question would bring surprise.

Main Result and Impact: The paper implement the framework in TinyOS. As described in the paper, the Quanto is very lightweight, and the simplicity of its measurement provides advantages for system implementation.

Evidence: The paper presents two evaluations for Quanto on single node and nodes in network respectively. The Blink example shows Quanto can reflect the correlation between component and its energy consumption fairly accurately. Bounce shows Quanto's effecitiveness of tracking activities across nodes.

Prior Work: Some early works about measuring energy usage in levels like instructions, processes, events. ECOSsytem, Eon and etc.

Reproducibility: I think the work is possible to be reproduced.

Question and Criticism: none

2009/12/2 Rodrigo <rodrigo...@gmail.com>

[yash]

Paper Title: Quanto- Tracking Energy in Networked Embedded Systems

Authors: Rodrigo Fonseca, Prabal Dutta, and colleagues.

Novel Idea: The paper introduces Quanto, a network-wide time and
energy profiler for embedded network devices for mapping the energy
and time spending on nodes across a network.

Main result: The paper describes Quanto which is designed for energy
conservation by controlling the amount of energy consumed. Simple
modification of few lines of the underlying OS code (TinyOS) is
required to implement Quanto. It works by modifying the device drivers
to intercept all events which change the power state of an energy sink
(functional unit)

Impact: Energy conservation.

Prior work: The are many related works for energy conservation such as
Powerscope, ECOSystem. Quanto, etc.

Question: What does activity mean?

[小柯]

Paper Title:    Quanto: Tracking Energy in Networked Embedded Systems

Authors:        Rodrigo Fonseca
                    Prabal Dutta
                    et al.

Date:           Dec 2008

Novel Idea:
    How to trace the usage of energy of hardware device and activities of embedded network devices? Quanto,
based on simple hardware and some modification on device driver, could make the OS be informed the power state of device and group the energy comsumptioms by labels to gain the comsuption of different activities.

Main Result:
    Quanto is established and evaluated with several examples to show that it could show precisely how much energy is consumed by what activity.

Impact:
    Many researches now focus on energy detection issues requiring only little hardware and software modification, without much efficiency influence on original system.

Evidence:
    Simple terminology definition, concept and energy-consumption formula explanation, followed by experiments an evaluations.

Prior Work:
    Many researches measuring energy usages for different system and on various levels.

Competitive work:


Reproducibility:
    Yes.

Question:
   

Criticism:


Ideas for further work:

2009/12/2 Rodrigo <rodrigo...@gmail.com>

[Andrew Ferguson]

Paper Title
"Quanto: Tracking Energy in Networked Embedded Systems"

Authors

Rodrigo Fonseca, Prabal Dutta, Philip Levis, and Ion Stoica

Date

OSDI 2008

Novel Idea
The novel idea is to record the power state of system components when
the rate of energy consumption changes, as well as the activity upon
which each component is currently working. Then, after assuming a
linear energy relationship, a system of linear equations can be solved
in order to determine how much energy is used by each activity.

Main Results
The paper presents Quanto, a "network-wide time and energy profiler."
It builds on the distributed tracing thinking of systems like X-Trace
in order to answer the question "where have all the joules gone?" The
instrumented operating system logs all energy change operations with
the activity which caused them so that energy resources can be
properly accounted for on a per-activity bases after post-processing.

Impact
It helped get Rodrigo a job, so that's pretty good. :-)

Evidence
The authors provide excellent experimental evidence that Quanto works.
The system is compared with ground truth obtained by an oscilloscope
and matches up perfectly. The two basic examples produce very
reasonable results and the case studies provide useful insights.

Prior Work
The others reference a variety of related prior work including
ECOSystem (energy is a first class resource, but uses offline
profiling and a model at runtime), Eon (solves a similar problem, but
with a new programming language), PowerTOSSIM (simulates TinyOS
applications), hardware metering systems (not available in
deployment), and RIALTO OS which charges resource usage to activities.
Quanto also builds on work in tracing applications such as Magpie,
Pinpoint, X-Trace, and Pip.

Competitive Work
I don't know if there is other work which fits the same needs as Quanto.

Reproducibility
Quanto is publicly available; with appropriate hardware, the
experiments in this paper could be reproduced.

Question
1) The authors write that "some operations do not clearly belong to
specific activities... one option is to give these operations their
own activities..." -- isn't doing so necessary to avoid mis-coloring
the processor on those tasks?
2) Is it possible to reconfigure the 16-bit task field? For example,
64 nodes with 1024 activity ids?

Criticism
I would have appreciated seeing the lines of code measurements also as
a percentage of the lines of code in the enclosing file; without
knowing the TinyOS codebase, it is hard to put these numbers into
perspective. The issue of packet corruption is never addressed: given
its light weight, I don't think there's a checksum on the accounting
measures. Is corruption of the logging messages a problem in practice?
Can they be detected and removed/fixed in post-processing?

Ideas for further work
Can Quanto be extended into situations in which the linearity
assumptions breakdown? At the very least, can Quanto alert the user
that such assumptions may have been broken? What are better, faster
(stronger) ways of storing Quanto's messages? Is there a way to do
approximate accounting with sublinear space requirements?
How does Quanto compare with energy accounting systems in space probes?

[qiao xie]

Paper Tile:   Quanto 

[Novel Idea] 

Quanto traces an activity's energy consumption across multiple nodes in a network and provides information that can help programmers make high-level design decisions. 

[Main Results]

An activity is a set of operations whose resource consumption should be grouped together. Therefore quanto injects labels to messages across network and different hardware components to group information related to an activity. Proxy activity is used before a real activity cannot be determined yet. Quanto is lightweight in terms of running cost and instrumentation cost.

 

[Impact]

Programmers can take into account the energy efficiency when designing their applications, at an early stage and high level.

[Evidence]

They provide mathematics equations to support their energy measurement method.

The system design is showed by figures and clean APIs.

They perform experiments on a single node first then move on to multiple nodes. 

Also a case study is shown to illustrate how Quanto can help programmers make decisions.

[Reproducibility]

Yes. The labeling technique and grouping idea can be applied. 

[Prior Work]

iCount energy meter

[Question]

Activity is not well defined in this paper, can you show more examples of what can be viewed as an activity? 

[Ideas for further work]

Incorporate Quanto functions into a development environment (such as eclipse), to let programmers see the effects of their decisions.

2009/12/2 Rodrigo <rodrigo...@gmail.com>

[Xiyang Liu]

Paper Title
Quanto: Tracking Energy in Networked Embedded Systems

Author(s)

Rodrigo Fonseca, Prabal Dutta, Philip Levis, and Ion Stoica

Date

OSDI'08, Dec. 8-10, 2008

Novel Idea
Quanto tracks the realtime energy use for networked embedded systems.
It models hardware components as energy sinks and formulates the
aggregated energy equations for each time interval which further
solves the actual energy draws of each energy state of every sink.
Quanto employes activity as its resource principal and tracks the
energy usage of activities over components and nodes. A flat activity
label is used along with the propagation of activity to identify it
from the logs.

Main Result(s)
Quanto was implemented in TinyOS framework and verified with Blink and
Bounce applications. The implementation and evaluations showed,
thought limited to several assumptions, Quanto is able to compute
power draws per hardware component and track energy usage for
activities across components and nodes.

Impact
There is a long history of resource tracking and profiling for
distributed systems, but never has energy usage been tracked as the
other first-class objects. However this is important to embedded
systems since energy is a crucial resource for them. Quanto proves it
feasible which enables energy tracking a standard profiling item for
networked embedded systems.

Evidence
The functionalities of Quanto were verified by Blink and Bounce
applications. Performance of Quanto was evaluated in three case
studies.

Prior Work
Quanto reminds me of XTrace, which does the casual path trace for
network requests. They both injects label into network messages and
integrates decentralized logs to produce activity/path traces. The
difference is that XTrace uses hierarchical labels whereas Quanta uses
flat labels because energy tracking does not involve layers.

Reproducibility
Yes. It is easy to find cases satisfying all the assumptions and
reproduce the results.

Question
Real time tracking and equal-energy scheduling are promising.
Calibration once would be enough for constant per-state power draws.
If power draws changes linearly with time, would a real-time
calibration help to reduce the error?

On Dec 2, 6:34 pm, Rodrigo <rodrigo.fons...@gmail.com> wrote: