1. Types for Energy Management Yu David Liu State University of New York (SUNY) at Binghamton OOPSLA13 PC Workshop

2. 2 Energy Efficiency in Computing PL & SE efforts PACT, ASPLOS OSDI, SOSP, SenSys, SIGCOMM ISCA, MICRO, HPCA VLSI, DAC operational cost phone battery life sensor network usability system reliability (overheating) environment

3. 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. 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," OOPSLA12. Hybrid Typing: ongoing work

5. 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. 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. 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. 8 Draw draw = new Draw(); Compute cmpt = new Compute(); draw.doDraw(); cmpt.doCompute(); Draw draw = new Draw(); Phases in Programs

9. 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. 10 DVFS in Energy Management Energy = Power * Time Dynamic Voltage & Frequency Scaling (DVFS) Power = c * Frequency * V 2

11. 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. 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 Energy Management through Type-Directed DVFS: 1. tap programmer knowledge 2. tap type systems ability for consistency checking, type propagation and inference

13. 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. 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 elision Type Soundness

15. 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. 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. 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. 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. 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 elision Type Soundness

20. 20 Ongoing Effort: Hybrid Typing class Network { void send() {…} } class Client { … Network n = new Network(); while (…) { n.send(); }}

21. 21 Ongoing Effort: Hybrid Typing class Network { void send() {…} } class Client { … Network @mode(hi) n = new Network(); while (…) { n.send(); }} Hmm..

22. 22 Ongoing Effort: Hybrid Typing class Network { void send() {…} } class Client { … Network @mode(low) n = new Network(); while (…) { n.send(); }} Hmm..

23. 23 Dynamic Types class Network { void send() {…} } class Client { … Network @mode(dynamic) n = new Network(); while (…) { n.send(); }}

24. 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. 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. 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. 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. 28 Q&A