Types for Energy Management
Yu David Liu
State University of New York (SUNY)
at Binghamton
OOPSLA’13 PC Workshop
2
Energy Efficiency in Computing
PL & SEefforts
PACT, ASPLOS
OSDI, SOSP, SenSys,
SIGCOMM
ISCA, MICRO, HPCA
VLSI, DAC
operational cost phone battery
life sensor network
usability system
reliability (overheating)
environment
3
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?
4
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
5
Energy Types
Phase• A pattern of system (CPU, memory…) utilization
• “math”, “graphics”, “audio”…
• A level of energy state
• “battery low”, “battery high”, “battery charged”…
Mode
A type system to reason about energy management based on
two concepts:
6
Energy Types
Phase• A pattern of system (CPU, memory…) utilization
• “math”, “graphics”, “audio”…
• A level of energy state
• “battery low”, “battery high”, “battery charged”
Mode
A type system to reason about energy management based on
two concepts:
7
CPU-bound
class Compute{
…
void doCompute(){
for(int i = 0; i < N; i++){
pi += factor/(2 * i + 1);
factor /= -3.0;
}}}
class Draw{
…
void doDraw(){
for(int i = 0; i < NUM; i++) {
canvas.drawL(x[i], y[i],);
c.draw(getImg(), rect);
}}}
I/O-bound
Phases in Programs
8
Draw draw = new Draw();
Compute cmpt = new Compute();
draw.doDraw();
cmpt.doCompute();
Draw draw = new Draw();
Phases in Programs
9
Draw draw = new Draw();
Compute@phase(math) cmpt = new Compute();
draw.doDraw();
cmpt.doCompute();
Draw@phase(graphics) draw = new Draw();
phases { graphics <cpu math}
Phases as Type Qualifiers
10
DVFS in Energy Management
Energy = Power * Time
Dynamic Voltage & Frequency Scaling (DVFS)
Power = c * Frequency * V2
11
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
12
Draw draw = new Draw();
Compute@phase(math) cmpt = new Compute();
draw.doDraw();
cmpt.doCompute();
Draw@phase(graphics) draw = new Draw();
phases { graphics <cpu math}
Phases as Type Qualifiers
CPU frequency scaled through
compiler instrumentation
CPU frequency scaled through
compiler instrumentation
Energy Management through Type-Directed DVFS:
1. tap programmer knowledge
2. tap type systems’ ability for consistency checking, type propagation and inference
13
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
14
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 elisionType Soundness
15
Energy Types
Phase• A pattern of CPU and memory utilization
• “math”, “graphics”, “audio”
• A level of energy state expectation
• “battery low”, “battery high”, “battery charged”
Mode
A type system to reason about energy management based on
two concepts
16
Renderer m1 = new Renderer(0.99);Renderer m2 = new Renderer(0.5);
Objects of different qualities
Mode-based Energy Management
class Renderer{ Renderer(double quality){ int loopNum = 1000 * quality; for(int i = 0; i < loopNum; i++){ render(canvas, i); }}}
17
Renderer m1 = new Renderer(0.99);
Renderer m2 = new Renderer(0.5);
Modes as Type Qualifiers
modes { low <: hi; }
Renderer@mode(hi) m1 = new Renderer(0.99);
Renderer@mode(low) m2 = new Renderer(0.5);
Encouraging Application-Specific Energy Savings
18
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
19
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 elisionType Soundness
20
Ongoing Effort: Hybrid Typing
class Network { void send() {…}}
class Client {…Network n = new Network();while (…) { n.send();}}
21
Ongoing Effort: Hybrid Typing
class Network { void send() {…}}
class Client {…Network@mode(hi) n = new Network();while (…) { n.send();}}
Hmm..
22
Ongoing Effort: Hybrid Typing
class Network { void send() {…}}
class Client {…Network@mode(low) n = new Network();while (…) { n.send();}}
Hmm..
23
Dynamic Types
class Network { void send() {…}}
class Client {…Network@mode(dynamic) n = new Network();while (…) { n.send();}}
24
From Dynamic to Static (One Possible Design)
class Network { void send() {…}}
class Client {…Network@mode(dynamic) n = new Network();while (…) { ((Network@mode(low))n).send();}}
Client Makes
Decision
Hmm..
25
From Dynamic to Static (Our Design)
class Network { void send() {…} ~ Network () { if (…) return hi else return low; }}
class Client {…Network@mode(dynamic) n = new Network();while (…) { attribute n to low { n.send(); }}}
Bi-Directional
Decision
26
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
27
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
28
Q&A