Compiler Design Spring 2017

Transcription

1 Compiler Design Spring 2017 Patterns (again) Dr. Zoltán Majó Compiler Group Java HotSpot Virtual Machine Oracle Corporation

2 Why? Remember questionnaire (from the beginning of the semester)? Question 7: Please name three design patterns that you encountered in earlier projects/classes. Answers Mention Visitor pattern: 20% Mention other pattern(s): 25% Blank: 55% 2

3 Why some technical reasons Control flow always difficult to deal with Patterns like Strategy or Iterator raise the level of programming Hide details Easier to read than explicit control flow statements Simpler to write Easier to extend/understand/maintain 3

4 Trivial example Print date using different formats Option 1: Test at each place in the program P where the date is to be printed switch(format): { case (INTERNATIONAL): // print YEAR-MONTH-DAY break; case (BANK): // print MONTH-DAY-YEAR break;... Option 2: Invoke function/method F passed to P F is defined so that the correct format is chosen 4

5 Auxiliary classes import java.util.calendar; import java.util.gregoriancalendar; import java.util.date; class MyDate { int day; int month; int year; // Won t work in long-lived programs MyDate() { Calendar cal = new GregorianCalendar(); year = cal.get(cal.year); month = cal.get(cal.month); day = cal.get(cal.day_of_month); 5

6 Select format 1 (international) interface Print { void print(); class InternationalFormatPrint implements Print { MyDate d_; InternationalFormatPrint(MyDate d) { d_ = d; public void print() { System.out.println(d_.day + "/" + d_.month + "/" + d_.year ); 6

7 Select format 2 (international) class BankFormatPrint implements Print { MyDate d_; BankFormatPrint (MyDate d) { d_ = d; public void print() { System.out.println(d_.month + "/" + d_.day +"/" + d_.year ); 7

8 Example public static void main(string args[]) { MyDate d = new MyDate(); Print p = selectprinter(d); dotheprinting(p); static Print selectprinter(date d) { if (user.input() == b ) { return new BankFormatPrint(d); else { return new InternationalFormatPrint(d); static void dotheprinting(print service) { service.print(); 8

9 Output Test6> java Test6 30/1/1997 Test6> java Test6 1/30/1997 Not a big deal (This is a simple example after all) But the idea is powerful No need to deal with a possibly complicated switch-statement Only passing the printer instance as parameter is needed 9

10 Other advantage: Extensibility Imagine adding support for a new format, e.g., Japanese With Option 1: Extending switch statement is required switch(format): { case (INTERNATIONAL): // print YEAR-MONTH-DAY break; case (BANK): // print MONTH-DAY-YEAR break; case (JAPANESE): // print YEAR-MONTH-DAY break; At all places where formatting is needed Error-prone High risk of introducing inconsistent behavior 10

11 Other advantage: Extensibility Option 2: Requires only adding a new implementation for the Print interface class JapaneseFormatPrint implements Print { MyDate d_; JapaneseFormatPrint(MyDate d) { d_ = d; public void print() { System.out.println(d_.year + "/" + d_.month +"/" + d_.day ); Where new formatting is needed: Pass a JapaneseFormat-Print instance to existing code 11

12 public static void main(string args[]) { MyDate d = new MyDate(); Print p = selectprinter(d); dotheprinting(p); static Print selectprinter(date d) { if (user.input() == b ) { return new BankFormatPrint(d); else if (user.input() == j ){ return new JapaneseFormatPrint(d); else { return new InternationalFormatPrint(d); static void dotheprinting(print service) { service.print(); 12

13 The Strategy pattern You ve just seen an example of the Strategy pattern Context contextinterface() Strategy algorithminterface() ConcreteStrategy1 algorithminterface() ConcreteStrategy2 algorithminterface() ConcreteStrategy3 algorithminterface() 13

14 The Strategy pattern You ve just seen an example of the Strategy pattern MyDate // direct access to fields Print print() BankFormatPrint print() Int lformatprint print() JapaneseFormatPrint print() 14

15 The Strategy pattern Idea: Encapsulate a set of related algorithms into a class hierarchy Benefit: Simplify control-flow (e.g., reduce the need for conditional statements) Benefit: Algorithm can be changed independently of context Benefit: Decouple implementation of algorithm from data structure(s) in context 15

16 Is Strategy really that great? Should we always use Strategy when our program uses at least two different algorithms on one data structure? It depends A pattern is a solution that works well in some settings But not always You have to weight pros/cons 16

17 Pros/cons A switch-statement is not that bad after all If you have a program with two algorithms and a data structure A program will not be changed/extended Don t forget: Change is rather the norm and not an exception Implementing Strategy (often) requires interface/virtual calls (Some) VM engineers: Don t use virtual calls, they re expensive Good for performance, maintenance cost paid later 17

18 An alternative MyDate print() BankFormatDate print() Int lformatdate print() JapaneseFormatDate print() Advantage: Simpler class structure Disadvantage: Mixes MyDate and algorithms that operate on it Can become a problem if algorithms and/or data structure in MyDate complicated 18

19 Working with data structures MyDate: Only three integer fields Direct access to fields sufficient to print date MyDate // direct access to fields Print print() BankFormatPrint print() Int lformatprint print() JapaneseFormatPrint print() 19

20 Working with complex data structures What should we do if the data structure is complex? We could use an iterator to enumerate all elements Example: list of dates class JapaneseFormatPrint implements Print { List<MyDate> list_; JapaneseFormatPrint(List<MyDate> list) { list_ = list; public void print() { Iterator iter; while (iter.hasnext()) { MyDate d = iter.next() System.out.println(d_.year + "/" + d_.month +"/" + d_.day ); 20

21 What about accessing even more complex data structures? There may not be an iterator The order of processing/invoking a method may matter (Just think of trees) Visitor pattern internalizes the logic of visiting the elements 21

22 Visitor Coupling of data structure and access method(s) Powerful in connection with trees Object must be prepared to accept a visitor Example: arithmetic expressions Sums Constants 23

23 Visitor // Data structure abstract class ArithExpr { abstract int accept(visitor v); // Visitor interface Visitor { int forconst(const c); int forsum(sum s); 24

24 class Const extends ArithExpr { private int value; Const (int v) { value = v; int getvalue() { return value; int accept(visitor v) { return v.forconst(this); class Sum extends ArithExpr { ArithExpr left, right; Sum (ArithExpr l, ArithExpr r) { left = l; right = r; ArithExpr getleft() { return left; ArithExpr getright() { return right; int accept(visitor v) { return v.forsum(this); 25

25 Visitor examples class EvalVisitor implements Visitor { public int forconst(const c) { return c.getvalue(); public int forsum(sum s) { return s.getleft().accept(this) + s.getright().accept(this); class CountVisitor implements Visitor { public int forconst(const c) { return 1; public int forsum(sum s) { return s.getleft().accept(this) + s.getright()).accept(this);

26 Example, continued class ShowArithVisitors { public static void main(string[] args) { ArithExpr c2, c3, s1, s2; c2 = new Const(2); c3 = new Const(3); s1 = new Sum(c2,c3); s2 = new Sum(c2, s1); Visitor v1 = new EvalVisitor(); Visitor v2 = new CountVisitor(); System.out.println(s2.accept(v1)); System.out.println(s2.accept(v2));

27 Discussion Who s responsible for traversing the object structure? In our case: the visitor class EvalVisitor implements Visitor { public int forsum(sum s) { return s.getleft().accept(this) + s.getright().accept(this); Could be the object structure as well class Sum extends ArithExpr { int accept(visitor v) { return getleft().accept(v) + getright().accept(v); 29

28 Discussion (cont d) Should we always use the Visitor pattern for programs operating on tree-like object structures? It depends. Visitor beneficial if: Object structure contains objects with different (unrelated) functionality E.g., Const represents a value via the field value Sum is an arithmetic expression with fields left and right 30

29 Discussion (cont d) Should we always use the Visitor pattern for programs operating on tree-like object structures? It depends. Visitor beneficial if: Object structure contains objects with different (unrelated) functionality E.g., Const represents a value via the field value Sum is an arithmetic expression with fields left and right Object structure changes rarely but new operations are added often E.g., JavaLi compiler: IR changes rarely, various implemented in visitors 32

30 Summary Design pattern: A possible way to design (part of) your program (Some) benefits: Simpler code, extensibility, maintainability Not a general solution: You have to weigh pros/cons Patterns we ve talked about: Strategy, Iterator (briefly), Visitor More to come 33

31 Admin issues Design patterns homework (HWP) Out today, due on April 13 No points awarded You ll get feedback for the code you ve submitted Next recitation session: Thursday, March 30 In the lecture room at lecture time CAB G 10:15 Discussion of Homework 3 Symbol table and semantic checker Out on Thursday More about patterns 34