Types for Energy Management
Yu David Liu
State University of New York (SUNY)
at Binghamton
OOPSLA’13 PC Workshop
Energy Efficiency in Computing

operational cost

phone battery life

sensor network
usability

system reliability
(overheating)

environment
PL & SE
efforts
PACT, ASPLOS
OSDI, SOSP,
SenSys,
SIGCOMM
ISCA, MICRO,
HPCA
VLSI, DAC
2
High-Level Questions

What are the principles of energy
management?

recurring themes of software-hardware interactions

recurring themes of static-dynamic interactions

How can the principles be abided by at
software construction time (or through
software lifecycle)?

What is the role of programmers in
energy-efficient computing?
3
This Talk

An energy-aware programming language
design
 Core
Idea: building the principles of
energy management into a type system
 Static
Typing:
Michael Cohen, Haitao Steve Zhu, Senem Ezgi Emgin,
Yu David Liu, "Energy Types," OOPSLA’12.
 Hybrid
Typing: ongoing work
4
Energy Types
A type system to reason about energy
management based on two concepts:
Phase
• A pattern of system (CPU, memory…) utilization
• “math”, “graphics”, “audio”…
Mode
• A level of energy state
• “battery low”, “battery high”, “battery charged”…
5
Energy Types
A type system to reason about energy
management based on two concepts:
Phase
• A pattern of system (CPU, memory…) utilization
• “math”, “graphics”, “audio”…
Mode
• A level of energy state
• “battery low”, “battery high”, “battery charged”
6
Phases in Programs
I/O-bound
class Draw{
CPU-bound
class Compute{
…
…
void doDraw(){
void doCompute(){
for(int i = 0; i < N; i++){
for(int i = 0; i < NUM; i++) {
}}}
canvas.drawL(x[i], y[i],);
pi += factor/(2 * i + 1);
c.draw(getImg(), rect);
factor /= -3.0;
}}}
7
Phases in Programs
Draw draw = new Draw();
draw.doDraw();
Compute cmpt = new Compute();
cmpt.doCompute();
8
Phases as Type Qualifiers
phases { graphics <cpu math}
Draw draw = new Draw();
Draw@phase(graphics)
draw = new Draw();
draw.doDraw();
Compute@phase(math) cmpt = new Compute();
cmpt.doCompute();
9
DVFS in Energy Management
Dynamic Voltage & Frequency Scaling
(DVFS)
Power = c * Frequency * V2
Energy = Power * Time
10
Phase-based Energy Management
 What: divide execution into distinct system
utilization “phases”, and scale down CPU frequency
when a phase is not CPU-bound
 Why: minimum performance degradation with
maximum energy savings
 Energy
Types Solution: use (declared or
inferred) phase types to guide DVFS
A case of software-hardware interaction for
energy management
11
Phases as Type Qualifiers
phases { graphics <cpu math}
Draw draw = new Draw();
Draw@phase(graphics)
draw = new Draw();
draw.doDraw();
CPU
CPU frequency
frequency
scaled
scaled through
through
Compute@phase(math) cmpt = new Compute();
compiler
compiler
instrumentation
instrumentation
cmpt.doCompute();
Energy Management through Type-Directed DVFS:
1. tap programmer knowledge
2. tap type systems’ ability for consistency checking,
type propagation and inference
12
Invariants

Phase distinction: No object can
commit to more than one phase

Phase isolation: an object can only
send messages to an object belonging
to the same phase

Inter-phase messaging is only allowed
through explicit type coercion
Promoting phased behaviors
13
Type System Details
 Based
on region types: phases are regions
 Parametric
polymorphism:

Different objects of the same class can
have different phases

Finer-grained support through method
polymorphism


Explicit form: “generic” phases
Implicit form: polymorphic inference to
allow for arbitrary qualifier elision
 Type
Soundness
14
Energy Types
A type system to reason about energy
management based on two concepts
Phase
• A pattern of CPU and memory utilization
• “math”, “graphics”, “audio”
Mode
• A level of energy state expectation
• “battery low”, “battery high”, “battery charged”
15
Mode-based Energy Management
class Renderer{
Renderer(double quality){
int loopNum = 1000 * quality;
for(int i = 0; i < loopNum; i++){
render(canvas, i);
}}
}
Objects of different qualities
Renderer m1 = new Renderer(0.99);
Renderer m2 = new Renderer(0.5);
16
Modes as Type Qualifiers
modes { low <: hi; }
Renderer m1 = new m1
Renderer(0.99);
Renderer@mode(hi)
= new Renderer(0.99);
Renderer m2 = new Renderer(0.5);
Renderer@mode(low)
m2 = new Renderer(0.5);
Encouraging Application-Specific Energy Savings
17
Invariants

waterfall Invariant: an object can only
send messages to an object of the
same mode, or of a “lower” mode in
the partial order

A program in “high” energy state can
invoke code supposed to be used in “low”
energy state

The other way around requires explicit
type coercion
Regulating Energy States
18
Type System Details
 Based
on region types: modes are regions
 Parametric
polymorphism:

Different objects of the same class can
have different modes

Finer-grained support through method
polymorphism


Explicit form: “generic” modes
Implicit form: polymorphic inference to
allow for arbitrary qualifier elision
 Type
Soundness
19
Ongoing Effort: Hybrid Typing
class Network {
void send() {…}
}
class Client {
…
Network n = new Network();
while (…) {
n.send();
}}
20
Ongoing Effort: Hybrid Typing
class Network {
void send() {…}
}
class Client {
…
Network@mode(hi) n = new Network();
while (…) {
n.send();
}}
Hmm..
21
Ongoing Effort: Hybrid Typing
class Network {
void send() {…}
}
class Client {
…
Network@mode(low) n = new Network();
while (…) {
n.send();
}}
Hmm..
22
Dynamic Types
class Network {
void send() {…}
}
class Client {
…
Network@mode(dynamic) n = new Network();
while (…) {
n.send();
}}
23
From Dynamic to Static (One Possible Design)
class Network {
void send() {…}
}
Client Makes
Decision
class Client {
…
Network@mode(dynamic) n = new Network();
while (…) {
((Network@mode(low))n).send();
}}
Hmm..
24
From Dynamic to Static (Our Design)
class Network {
void send() {…}
~ Network () {
if (…) return hi else return low;
}
Bi-Directional
}
Decision
class Client {
…
Network@mode(dynamic) n = new Network();
while (…) {
attribute n to low { n.send(); }
}}
25
Implementation and Evaluation
 Prototyped
compiler for Android Apps
 Static
typing: benchmarking results
show promising energy savings with
minimal performance loss

For some game benchmarks, 40%
energy savings and 2% performance loss
with phases; application-specific with
modes
 Hybrid
typing: under development
26
Conclusions
 New
language designs may capture and
facilitate complex software/hardware
static/dynamic interactions in energy
management
 Principles
of energy management may
be enforced by type systems
 Energy-aware
programming broadens
the scope of energy optimization by
bringing in programmer knowledge
27
Q&A
28