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