Reviews: Quanto

[Rodrigo Fonseca]

Hi,

please post your reviews to Quanto here. Again, I don't mind
criticism!

Rodrigo

[James Chin]

Paper Title: “Quanto: Tracking Energy in Networked Embedded Systems”

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

Date: 2008 (OSDI ‘08)

Novel Idea: This paper presents Quanto, a network-wide time and energy
profiler for embedded network devices. By combining well-defined
interfaces for hardware power states, fast high-resolution energy
metering, and causal tracking of programmer-defined activities, Quanto
can map how energy and time are spent on nodes and across a network.

Main Result(s): The authors show that being able to take fine-grained
energy consumption measurements as fast as reading a counter allows
developers to precisely quantify the effects of low-level system
implementation decisions, such as using DMA versus direct bus
operations, or the effect of external interference on the power draw
of a low duty-cycle radio.

Impact: Energy is a scarce resource, especially in embedded, battery-
operated systems such as sensor networks. Quanto’s unprecedented
visibility into energy usage will enable empirical evaluation of the
energy-efficiency claims in the literature, provide ground truth for
lightweight approximation techniques like counters, and enable energy-
aware operating systems research.

Evidence: To evaluate the functionality and performance of Quanto, the
authors implemented the framework in TinyOS, a popular sensornet
operating system. Then the authors looked at two simple applications,
Blink and Bounce, that illustrate how Quanto combines activity
tracking, power-state tracking, and energy metering into a complete
energy map of the application. Afterwards, they looked at three case
studies in which Quanto exposes real-world effects and costs of
application design decisions. Finally, they quantified some of the
costs involved in using Quanto itself.

Prior Work: This paper borrows heavily from the literature on energy-
aware operating system, power simulation tools, power/energy metering,
power profiling, resource containers, and distributed tracing.

Competitive Work: This includes the ECOSystem project, the Eon
programming language, and the PowerTOSSIM project.

Reproducibility: The findings appear to be reproducible if one follows
the testing procedures outlined in this paper and has access to the
code for Quanto.

Question: What’s the next step for Quanto in terms of development or
deployment?

Criticism: Actually, I think this paper is very thorough in terms of
Quanto’s implementation and evaluation.

[Visawee]

Paper Title :
Quanto: Tracking Energy in Networked Embedded Systems

Author(s) :

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


Date :

Year 2008


Novel Idea :
Combining well-defined interfaces for hardware power states, fast high-

resolution energy metering, and causal tracking of programmer-defined

activities to provide mapping on when, where, and why energy is
consumed both within a single node and across the network of embedded
system.


Evidence/Main Result(s) :
The authors use two applications, Blink and Bounce, to show how Quanto

combines activity tracking, power-state tracking, and energy metering

into a complete energy map of the applications. Using Quanto on Blink
shows that it can track multiple activities on a single node, and
using Quanto on Bounce shows that it can track activities across
nodes.

The authors also conduct three more case studies of using Quanto.
The first and second case studies show that Quanto is able to give
more visibility into real-world effects and costs of application
design decisions. The last case study shows the cost of using Quanto.
Quanto's logging infrastructure uses 0.12% of the total CPU time, and
consumes 0.08% of the total energy spent on the application.


Impact :
Quanto allows developers to precisely quantify the effects of low-
level system implementation decisions of networked embedded systems.
Quanto might be applied to use for finding energy leaks, tracking
butterfly effects, real time tracking.


Prior Work :
This paper is based on my techniques in the following field of studies
- energy-aware operating systems
- power simulation tools
- power/energy metering
- power profiling
- resource containers
- distributed tracing


Reproducibility :
The results are reproducible if given Quanto code because the
experiments are mentioned in detail in the paper.


Criticism :
- The paper is very well structured and easy to follow. The
experiments and case studies together help in proving the correctness
and usability of Quanto very well.

On Dec 1, 7:56 pm, Rodrigo Fonseca <rodrigo.fons...@gmail.com> wrote:

[Zikai]

Paper Title: Quanto: Tracking Energy in Networked Embedded Systems

Author(s): Rodrigo Fonseca , Prabal Dutta , Philip Levis , Ion
Stoica
Date/Conference: OSDI 08

Novel Idea: (1) Model hardware components as energy sinks with power
states. Based on the modeling, use post-facto regression to
distinguish energy draw of individual hardware components from
aggregate system energy consumption only.
(2) Use a labeling mechanism to causally connect energy usage to high-
level, programmer-defined activities that span different hardware
components and multiple nodes.

Main Results: (1) Design and implement Quanto, a network-wide time and

energy profiler for embedded network devices.

(2) Evaluate Quanto with two simple applications and three case
studies to show Quanto is able to take fine-grained energy consumption
measurements and help developers to precisely understand and quantify
the effects of design decisions. Also costs of logging and
instrumentation are tested.

Impact: Quanto provides unprecedented visibility into energy usage in
embedded network devices and will enable empirical evaluation of the
energy-efficiency claims in literature. It will also provide ground
truth for lightweight approximation techniques like counters and
enable energy-aware operation system research.

Evidence: (1) In Part 4.2, evaluate Quanto with two simple
applications Blink and Bounce to show how Quanto perform activity
tracking, power-state tracking and energy metering on multiple
activities on one node and multiple nodes.
(2) In Part 4.3, evaluate Quanto on three case studies to show it can
help developers to precisely understand and quantify the effects of
design decisions
(3) In Part 4.4, evaluate Quanto’s costs of logging and
instrumentation.

Prior Work: Activity abstraction of a resource principal [2, 19]

Reproducibility: Both the implementation and the evaluation part are
detailed and reproducible.

Question: In Introduction, authors mentioned networks in the wild with
extreme weather conditions like 100 degree temperature shifts.
Meanwhile, to break down energy consumption to hardware components,
Quanto needs to collect a system of equations that is solvable over
time. Is there any guideline on how long the collection period will
be? If Quanto solves the system out then the environment condition
changes greatly (like temperature decreases 100 degree), do we need to
restart the collection and solving procedure? If not, when combing
measurements collected in two diverse environment conditions, will the
errors of the system increase?

Criticism: It will be interesting to see whether Quanto’s methodology
can apply to general networking systems like IP network with a large
number of routers or a data center of commodity servers. Though such
systems have less energy constraint than sensor networks, energy
consumption is still the main source of costs especially for large
data centers and thus network-wide energy profilers will be useful.

[Dimitar]

Quanto: Tracking Energy in Network Embedded
Systems

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

Date: 2008

Novel Idea: The current problem with embedded , battery operated
system is that the energy
consumption can't be precisely measured. The work presented attempts
to solve this problem through
four main research contributions:

Result: The result of the authors work is Quanto, a network-wide time

and energy profiler for embedded

network devices. It is implemented on top of TinyOS with minor
changes that enables developers
to precisely measure and analyze the power draws spent on different
activities.
In order to get the power usage from a node, Quanto uses a simple
switching regulator. Second,
it uses post-facto regression to distinguish the energy draw of
inividual hardware components. It uses
labeling mechanism to connects energy usage to defined activities.
Lastly, activities are track between
different nodes.

Impact: Having the price measurements of energy can greatly influences
programmer's design.

Evaluation: The test cases and the two cases studies presented in the
paper clearly demonstrate
Quanto's usefulness.

Reproducibility : The work presented in the paper and the test cases
are reproducible, but it will
require extensive studies.

Competitive Work: Similar work to Quanto is Eon which also uses real
time energy metering.

Question:
What are the differences between activities used in Quanto to
attribute energy usage to the flows used
in Eon?

Criticism: The ideas in the paper are well presented and I think
the evaluation section is sufficient.

[Sandy Ryza]

Title:
Quanto: Tracking Energy in Networked Embedded Systems

Authors:

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

Date:

OSDI '08

Novel Idea:
The authors present an energy profiled targeting embedded network
devices that measures consumption with energy-sink/power state
granularity. Offline, the system turns measurements into a family of
equations and uses linear regression to identify what energy-sinks
consume what power when . A simple labeling mechanism is used that
connects consumption to programmer-defined activities. The system
works network-wide, tracking the power consumption of activities at
remote nodes.

Main Result(s):
In their case studies, the authors find that they are able to
accurately discover the amount of power consumed by each power state
and activity. Quanto also has a minimal effect on both memory usage
and CPU usage.

Evidence:
The authors implement their system on a custom sensornet node using
the HydroWatch platform. They use measurements from an oscilloscope
to confirm their linearity assumptions, and describe how they
instrumented two small applications: Blink, which flashes LEDs on and
off, and Bounce, which sends packets back and forth between two
nodes. They conduct a case study in which they use Quanto to measure
the energy consumption impact of radio interference on Low Power
Listening. They evaluate the amount of CPU, and memory used on both
the logging and the asynchronous log data transfer.

Prior Work & Competitive Work:
ECOSystem tracks power states to allocate energy usage, but uses
offline profiling, and is confined to a single node. Eon is a
programming language that uses real-time energy metering and annotates
flows through a program with energy states. PowerTOSSIM is built
specifically for TinyOS, and uses a less general power model to
measure the amount of power consumed by software modules. The notions
of causal paths explored in Magpie, Pinpoint, X-Trace, and Pip
contributed to the network-wide, distributed nature of the system.

Reproducibility:
Detailed hardware specs are provided. The paper does not mention
whether or not the code modifications are open-source, they
experiments would likely be mostly reproducible.

Criticism:
It would have been helpful if the paper presented statistics on the
amount of energy consumed by the logging in addition to CPU cycles and
memory usage, as energy is the primary concern of the paper.

Question:
Are there no problems with the labeling system caused by an energy
sink being used by multiple activities at the same time? Is it
impossible for this to happen or am I misunderstanding how something
works?

On Dec 1, 7:56 pm, Rodrigo Fonseca <rodrigo.fons...@gmail.com> wrote:

[Tom Wall]

Quanto: Tracking Energy in Networked Embedded Systems

Rodrigo Fonseca„, Prabal Dutta„, Philip Levis…, and Ion Stoica„
OSDI 2008

Novel Idea:
The paper describes Quanto, a system wide profiler of time and energy.
They incorporate a new type of sensor to allow the OS to cheaply and
accurately measure a system's total energy consumption. By modifying
device drivers to report power state changes to the OS, OS can use
this state information and the total system energy consumption
measurement to accurately analyze power useage by component. Finally,
by adding causal tracking, they can get an measure of the energy
consumption of a particular system operation or activity.

Main Result:
They altered TinyOS and various drivers for the HydroWatch embedded
system in order to support Quanto. Quanto does an accurate breakdown
of how power was consumed amongst both hardware components, nicely
organized into distict system activities.

Evidence:
First, they evaluate Quanto using two test applications Blink and
Bounce. The first is a single node, multiple activity, while the
second application spans multiplenodes. They use Blink and manually
record the current to verify that the iCount measurement works. When
the run Blink with Quanto, it has output very close to the manual
version. Next they demonstrate that quanto can keep tract of inter-
node communication in Bounce. They do three case studies to help
demonstrate Quanto's real world usefulness. Finally the give a quick
performance breakdown: lots of CPU is used for logging, but the CPU is
also idle quite often.

Impact:
This seems like a nice tool to have, but its usefulness will depend
greatly on the system and application being profiled.

Reproducibility:
The paper is mostly high level, and there are lots of details, such
as

Question/Criticism:
How much variety is there in the hardware devices/device drivers for
these types of embedded systems? Are instrumented drivers likely to be
reusable for a variety of systems? The appeal of Quanto may be
diminished if every system needs a rewrite of all drivers.

Did the idea of Quanto come from the work on XTrace?

Future Work:
They mention that they could use counters rather than logging and
offline analysis to get a measure of energy usage. This may not be as
fine grained, but it might be acceptable for some cases, and it gets
rid of the logging overhead.

On Dec 1, 7:56 pm, Rodrigo Fonseca <rodrigo.fons...@gmail.com> wrote:

[Shah]

Title:

Quanto: Tracking Energy in Networked Embedded Systems

Authors:

[1] Rodrigo Fonseca
[2] Prabal Dutta
[3] Philip Levis
[4]Ion Stoica

Source and Date:

Proceedings of the 8th USENIX Conference on Operating systems Design
and Implementation. December 8–10, San Diego, California.

Novel Idea:

The authors present a novel ‘network-wide time and energy profiler for
embedded network devices’ called Quanto.

Main Result:

The scientists present Quanto an energy profiler that addresses the
challenges based on four contributions:

[1] The use of a energy sensor to enable fine-grained measurements.

[2] The use of post-facto regression to distinguish the draw of
individual hardware components.

[3] The description of a novel labeling system.

[4] The extension of the above techniques to to track network-wide
energy usage.

Impact:

This paper has been cited around 25 times and given that energy
consumption is becoming more important, it may grow even more popular.

Evidence:

The authors conduct the following two experiments: Blink and Bouce.
The first employs the ‘hello world’ application that comes aboard
TinyOS to verify that Quanto can indeed measure the aggregate energy
used. The second makes use of Blink, an application that toggles the
color of LED’s to verify the results found from the first part.

Prior Work:

In Section 6, the authors make it clear that their work borrows
heavily from prior work on operating systems, power profiling and
related areas. They then proceed to list several works that may be
loosely labeled as ‘competitive’.

Competitive Work:

The researchers mention ECOSystem and highlight the differences
between it and Quanto. They proceed to list Eon and say why Quanto is
similar to it. On the power simulation front they highlight
PowerTOSSIM. TThey also mention how Quanto is similar to the RIALTO
operating system. Finally, they end with a list of works that have
modeled distributed systems like Magpie, Pinpoint, X-Trace and Pip.

Reproducibility

The authors give a fair amount of detail to make their experiments
reproducible. Since much of the applications are available off the
shelf, it makes material for a large part of their tests available.

Question:

Why did the author choose the name Quanto?

Criticism:

There’s a typo in Section 5.3 - the fourth heading should read

Energy-Aware Scheduling

Ideas for Further Work:

N/A

[Jake Eakle]

	Paper Title

Quanto: Tracking Energy in Networked Embedded Systems

	Author(s)		Rodrigo Fonseca, Prabal Dutta, Philip Levis…, and Ion Stoica
	Date		2008
	Novel Idea		Monitor power use of in embedded systems efficiently and usefully. Existing hardware makes it possible to monitor overall system energy usage efficiently; the novel contribution here is a software strategy for extracting detailed, per-conceptual-unit information from the coarse data it provides.
	Main Result(s)		There are two major components of Quanto: estimating the power consumption of each actual component in each of its 'power states' (usage modes that are known beforehand to be likely to use different and roughly constant amounts of power, and breaking power usage down by programmer-specified activity rather than physical component. The first step is achieved by monitoring the total power draw of the system in each interval for which no power states changed, and then eventually solving a system of equations once enough states have been observed. In order to do this, each device driver must be instrumented to indicate to Quanto when its power state has changed (and what those states are in the first place). The second stage requires the programmer to define a set of activities that they care about, and add a small number of API calls to their code to indicate when each one starts. A system developer who wants eir system to support Quanto must do significantly more work to instrument each supported device to accept activity labels from devices that query them, and pass them on to devices they query. Quanto itself ensures that that TinyOS's task scheduler preserves activities across arbitrarily multiplexed sets of tasks. Quanto adds a field to the default TinyOS node messaging format that allows activity labels to be passed easily across the network as well.
	Impact		This article has been cited a number of times already; two articles that seemed interesting were one that proposed using a similar activity-tracking system in 'micropower mobiscopes' embedded, and IDEA, a system that appears to build off of Quanto in order to implement automated distributed energy management in embedded systems, rather than just usage monitoring.
	Evidence		They evaluate Quanto on two sample TinyOS applications, and more interestingly, in two case studies on more realistic applications. In these, they observed a significant effect of radio interference in a common Low-power Listening setup, and discovered an energy-draining flaw in (I think) a default TinyOS timer behavior. It's not entirely clear from the wording here how wide an impact this flaw actually has.
	Prior Work		Lots and lots, but they mention RIALTO as an especially large stepping stone.
	Reproducibility		They are fairly explicit about their API, but a whole awful lot of device driver instrumentation goes on behind the scenes.
	Question/Criticism		The paper acknowledges that a lot of OS internals and device drivers have to be modified for this to work, but claims that these modifications are 'easy' and doesn't talk about any potential alternatives. Easy as they may be, they still must be done for each platform and device, which may present a significant barrier to non-developer users of networks with devices whose developers have not bothered to provide such support. Is it possible to do more in-depth tracing and analysis to deduce power state transitions from running applications, thus removing the need to modify the drivers? Would such an approach render activity monitoring untenable?
	Ideas for further work		They provide a nice list of enabled research, at least some of which appears to have been begun by others (see 'Impact').

--
A warb degombs the brangy. Your gitch zanks and leils the warb.

[Duy Nguyen]

Title:

Quanto: Tracking Energy in Networked Embedded Systems 

Author(s):

Rodrigo Fonseca et al 

Date:

OSDI 2008 

Novel Idea 

Inspired by XTrace idea, this is a framework for profiling/tracking energy

usage of sensor network devices. It can provide detail information on how 

and which energy is consumed by the devices

Main Result(s) 

A labelling/propagation system is developed to track a device's activity to

a specific power consumption of hardware unit. Energy usage information is

then post-processed by using regression to get a thorough breakdown of energy

consumption over time.

Impact 

I think it has big impact in the context of sensor network devices because

energy is vital to them. Understanding well the energy usage helps to develop

better devices which last longer in tough environment

Evidence 

Blink and Bounce are two simple experimentals that proves Quanto works, more

complex case studies are also experimented.

Prior Work 

The main idea in labelling & propagating is inspired by XTrace.

Reproducibility 

Quanto is implemented in TinyOS which is an open source operating system for

sensor network devices

Question

The cost of logging is pretty high: 71.05% of active CPU time. Is there anyway

to reduce this cost?

[Abhiram Natarajan]

Paper Title: Quanto: Tracking Energy in Network Embedded Systems

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

Date: 2008, OSDI

Novel Idea: Combination of well-defined interfaces for hardware power
states, fast high-resolution energy metering, and causal tracking of
programmer-defined activities to map how energy and time are spent on

nodes and across a network.

Main Result(s): Quanto, a network-wide time and energy profiler for
embedded network devices.

Impact: Quanto facilitates finegrained energy consumption measurements
as fast as reading a counter thus allowing developers to precisely

quantify the effects of low-level system implementation decisions,
such as using DMA versus direct bus operations, or the effect of
external interference on the power draw of a low duty-cycle radio.

Evidence: The evaluation section contains enough evidence of the fact
that Quanto is an extremely valuable system. Specifically, the authors
present case studies that show that Quanto allows a develpoer to

precisely understand and quantify the effectsof design decisions.

Prior Work: ECOSystem, Eon, PowerTOSSIM, Regular Microprocessors,
RIALTO, Resourse Containers, Magpie, Pinpoint, X-Trace and Pip.

Competitive Work: The whole of section 4 is dedicated for competitive
work wherein the authors evaluate and analyse every aspect of Quanto.
The talk about calibration, give examples, perform case studies and
take a very careful look at costs involved.

Reproducibility: They say that the number of lines of code changed
were not much, and they do what looks like sufficient explanation
about the architecture of their system. Getting exact numbers would be
hard, but a prototype of the system should be buildable using Prof.
Fonseca's help.

On Dec 1, 7:56 pm, Rodrigo Fonseca <rodrigo.fons...@gmail.com> wrote:

[Hammurabi Mendes]

Paper Title

Quanto: Tracking Energy in Networked Embedded Systems

Authors

Rodrigo Fonseca, Prabal Dutta, Philip Levis, Ion Stoica

Date

OSDI'08 - Symposium on Operating Systems Design and Implementation

Novel Idea

Using OS-integrated fine grained energy measurements to produce
information that is able to spot how much energy programmer-level
tasks spend on a multi-node network.

Main Results

Quanto uses fine-grained energy measurements in a multi-node
environment to infer causality relations regarding programmer-level
tasks that run in the system. The processes of runtime measurement,
logging and post-processing are decoupled from each other.

Impact

This approach to energy tracking is appropriate in situations where
operational conditions are dynamically enough (or unpredictable
enough) such that simple test-case analysis are not very effective
and/or high-level reasoning about the spending of energy becomes too
difficult.

Evidence

The paper describes clearly the approach to track how much energy is
spent, as well as how "activity tracking" is done in Quanto. The
evaluation is done using the applications "Blink" and "Bounce", two
simple applications in the scenario in question.

Prior Work + Competitive Work

The paper mentions that ECOSystem has similar techniques, but Quanto
measures energy at runtime, different from ECOSystem. They also cite
Eon, which is a programming language and runtime system, that decides
which part of the application is going to run depending on energy
annotations in the program. PowerTOSSIM simulates applications but
using a predefined view of the hardware, and is not concerned with
activity tracking.

They mention that the RIALTO OS introduced the "activity" abstraction
that Quanto borrows from (extending to a network-wide case). Finally
they cite tracing tools such as Magpie, Pinpoint, X-Trace, Pip, and
Causeway, mentioning that they provided ideas to Quanto, which uses
them in the sense of tracking energy expenditures across the network.

Reproducibility

The applications used in the evaluation section are quite simple, so
if the system is available, the experiments are reproducible. I
couldn't find the implementation online though.

Questions + Criticism

[Question] Is there any class of devices that do not expose their
power changes at all and are yet relevant in practice? Is there any
way Quanto could go around this (for instance, if such devices exist,
is there at least a common standard to query its internal state?).

[Criticism] First, I liked the way the output graphic is done -- when
the problem tacked is visualization (tracking energy expenditures, in
this case), the way the information is actually visualized is crucial.
The system seems to do a good work at that. The case studies were
interesting. The third was particularly interesting for me, because it
shows how the MAC fairness would be hurt based only on timing (of the
states), and not energy. I missed some experimental setup that
incorporated many pervasive operational changes at once, like in the
real-case scenarios the paper describes in the introduction. I guess I
stayed with that in mind. But I know that incorporating a (then)
prototypical system into such kind of network is complicated.

On Wed, Dec 1, 2010 at 7:56 PM, Rodrigo Fonseca
<rodrigo...@gmail.com> wrote:

[Joost]

Title: Quanto: Tracking Energy in Networked Embedded Systems

Authors: Rodrigo Fonseca„, Prabal Dutta„, Philip Levis…, and Ion
Stoica
Date: 2008

Novel Idea: As power cost rise and begin to constitute a significant
portion of the cost of system operation, better metrics of tracking
this usage are required. This paper presents a system for doing these
tracking on small devices operating Tiny OS.

Main Results: The authors successfully implemented a system which
tracks power usage of the various hardware components in the device in
question through a variety of power consumption states.
Impact: With the growing prominence of energy as a parameter that
needs to be optimized for cost-efficiency, systems like this will play
larger and larger roles in the marketplace over the coming years.
However, I believe that these measures will not be implemented system
wide but rather on a sampled subset to give statistically significant
results with as little overhead as possible.
Evidence: The authors demonstrated how their system works on two
simple sensor based experiments, Blink and Bounce. While the system
did work with these instances, it would have been nice to see
instances in which the system was subjected to the harsh environments
alluded to at the start of the paper, as well as more complicated
procedures that might involve more complex power usages.
Prior Work: "techniques borrow heavily from the literature on energy-

aware operating system, power simulation tools, power/energy metering,
power profiling, resource containers, and distributed tracing."

Criticism/Question: Given that this is the first step towards a new
system of power monitoring on tiny devices, how has this research
evolved over the past 2 years? Also many of the goals that the
introduction alluded to remain untested in this paper in terms of
disparate climates this system was designed for.

On Dec 1, 7:56 pm, Rodrigo Fonseca <rodrigo.fons...@gmail.com> wrote:

[Siddhartha Jain]

Novel Idea:
The novel idea is to do fine-grained monitoring of power draw of various 
components in a system. This is done by setting up a system of linear equations
where the variables are power drains for the power states of the components and is
based on observing the energy difference over a period of time, doing so for mulitple
times.
The second idea is to use a labeling mechanism to estimate the amount of energy programmer
defined activities were using.

Main Results:
The framework is described and numbers on the overhead and modification to the lines of code
necessary are given. Quanto is evaluated on two applications to show the framework in action.

Evidence:
A lot of modification seems to be necessary for the drivers and the OS. The overhead seems to be
relatively minor though.

Prior Work:
Lots of prior work - Quanto mainly uses ideas from ECOsystem.

Reproducibility:
Not easily reproducible as a ton of details regarding the implementation are would need to be described.

Question:
How much can environmental factors affect energy availability and usage? How easy would it be to
model the affect of such environmental factors?

Ideas for future work:
This is a bit out there but if a reasonably accurate map of the energy consumption for various activities
could be maintained, then could one accurately predict the energy usage given a set of activities?
Could one detect anamolous behavior if the energy usage then differed from the predicted value?

On Wed, Dec 1, 2010 at 7:56 PM, Rodrigo Fonseca <rodrigo...@gmail.com> wrote: