1 / 28

Types for Energy Management

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. High-Level Questions.

geneva
Download Presentation

Types for Energy Management

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

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

  2. Energy Efficiency in Computing • 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, SenemEzgiEmgin, Yu David Liu, "Energy Types," OOPSLA’12. • Hybrid Typing: ongoing work

  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. 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”

  7. Phases in Programs I/O-bound CPU-bound class Compute{ … void doCompute(){ for(inti = 0; i < N; i++){ pi += factor/(2 * i + 1); factor /= -3.0; }}} class Draw{ … void doDraw(){ for(inti = 0; i < NUM; i++) { canvas.drawL(x[i], y[i],); c.draw(getImg(), rect); }}}

  8. Phases in Programs Draw draw = new Draw(); Draw draw = new Draw(); draw.doDraw(); Compute cmpt = new Compute(); cmpt.doCompute();

  9. 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();

  10. DVFS in Energy Management • Dynamic Voltage & Frequency Scaling(DVFS) Power = c * Frequency * V2 Energy = Power * Time

  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. 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(); CPU frequency scaled through compiler instrumentation CPU frequency scaled through compiler 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

  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 elision • Type Soundness

  15. 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”

  16. Mode-based Energy Management class Renderer{ Renderer(double quality){ intloopNum = 1000 * quality; for(inti = 0; i < loopNum; i++){ render(canvas, i); }} } Objects of different qualities Renderer m1= new Renderer(0.99); Renderer m2= new Renderer(0.5);

  17. Modes as Type Qualifiers modes { low <: hi; } Renderer m1= new Renderer(0.99); Renderer m2= new Renderer(0.5); 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 elision • Type 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 = newNetwork(); while (…) { n.send(); }}

  24. From Dynamic to Static (One Possible Design) class Network { void send() {…} } class Client { … Network@mode(dynamic)n = newNetwork(); 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 = newNetwork(); 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

More Related