Object Oriented Programming Lecture IX

1. Object Oriented ProgrammingLecture IX Some notes on Java Performance with aspects on execution time and memory consumption

2. Last Lecture • We talked about refactoring strategies • refactoring methods • refactoring by inheritance • refactoring by delegation • Netbeans and GUI forms for Graphic User Interfaces

3. Today’s Talk • Improving performance in Java programs • time consumption • space consumption • Reference to the material in todays lecture: • Peter Sestoft, “Java performance: Reducing time and space consumption”

4. Java Compilers • Java compilers cannot do all kinds of optimization that we are used to in other languages • Compared to a language as C • Java is semantically more restricted and many things have to be done at run-time • operations on objects bound at run-time, dynamic data structures (eg Vector) etc. • It many times cannot be predicted • what is the type of an object or • which object that is being accessed • untill the code is executed

5. What can we do? • With some knowledge about the • semantics of the language • run-time mechanisms in the JVM • how classes in the API are implemented, • we can in some cases avoid expensive run-time JVM operations by how we write the code

6. Time consumption

7. Iterative computing on invariant expressions • Loops and loop-invariant expressions • avoid recomputing loop bounds for expressions when we know the value is static • One example is the size()method for(int i=0; i<size()+1; i++){ … }

8. Iterative computing on invariant expressions • Instead of calling size() everytime the bound is checked: • compute the loop bound once, and bind it to a local variable for(int i=0,stop=size()+1; i<stop; i++){ … }

9. Computing subexpressions • Avoid recomputing the same subexpression more than once • ”Bad” example: if(shapes.elementAt(i).isCircle()); if(shapes.elementAt(i).isSquare());

10. Computing subexpressions • Instead, compute the subexpression once and bind the value to a local variable • ”Good” example: Shape shape = shapes.elementAt(i); if(shape.isCircle()); if(shape.isSquare());

11. Computing on Arrays inloop expressions • For every access in an array, an index (out-of-bounds) check is required to be performed double[] rowsum = new double[n]; for(int i=0; i<n; i++){ for(int j=0; j<m; j++){ rowsum[i]+= arr[i][j]; } }

12. Computing on Arrays inloop expressions • What we can do in this example, is to compute the outer index once double[] rowsum = new double[n]; for(int i=0; i<n; i++){ double[] arri = arr[i]; //copy reference double sum = 0.0; for(int j=0; j<m; j++) sum += arr[j]; //avoid checking i index rowsum[i] = sum; }

13. Constant Fields and Variables • Declare • constant fields as finalstatic • Variables as final • The compiler can inline such code and precompute constant expressions • Examples: finalstaticint x = 10; final Object a;//assigned only once

14. Avoid construction of long if-else chains: if(exp){ ... }elseif(exp){ ... }elseif(exp){ ... } ... else{ ... } Replace with a switch-case expression instead switch(exp){ case a: statement 1 case b: statement 2 Default: statement n } Long If-Else chains

15. What about ”clever one-liners” • Example: int year = 0; double sum = 200.0; double[] balance = newdouble[100]; while((balance[year++] = sum *= 1.05) < 1000.0); • Nothing is gained by such expressions, except that you get a piece of code which noone understands

16. Fields and Variables • There is no run-time overhead for variables declared as local • local variables also improves clarity of the code • In a method • it is faster to access local variables and parameters than accessing static values or instance (class global) variables • In loops • it might be more efficient to copy a global variable into a locally created variable, and use the local inside the loop

17. String Manipulation • Avoid dynamically building strings using the concatenation (+) operator: String s = ””; for(int i=0; i<n; i++){ S += ”#” + i; } • This loop has quadratic execution time and can easily cause heap fragmentation

18. String Manipulation • Instead, use a StringBuilder object StringBuilder sbuf = new StringBuilder; for(int i=0; i<n; i++){ sbuf.append(”#”).append(i); } • However, for a sequence, using ’+’ is ok : • String s = ”(” + x + ”, ” + y + ”)”;

19. Initialized Array variables • Local method variables are initialized upon method entrance • avoid declaring initialized arrays in methods • When initialized array variables or tables need to be used, declare them once as instance global finalstaticint arr = {31,28,31,30,...};

20. Methods • Method calls can be executed faster if methods are declared using private, final or static • For example, accessor methods (like getSize) can often be declared final • there is usually no need for overriding such methods in inheriting sub classes

21. Input and Output • For program input and output (such as file access) • use buffered streams from java.io • BufferedReader, BufferedWriter, BufferedInputStream, BufferedOutputStream • Using buffered streams can speed up input/output up by a factor of 20

22. Bulk Array Operations • Bulk operations means performing operations on whole, or sub blocks of data • For Arrays, there are some special operations which are usually faster than using for-loops • one reason is that only a single bound check is required

23. Bulk Array operations • static void arrayCopy(src, si, dst, di,n) • In java.lang.System • Many bulk methods in java.util.Arrays • equality (compare elements) • fill (initialize elements) • searching • sorting

24. Collection Classes • The collection classes in java.util are well designed and implemented and can improve the speed of a program • When using lists (eg LinkedList, ArrayList…) • Avoid indexed position access, insertion or removal of elements • Those methods do linear search • Example • System.out.println(list.get(i));

25. Scientific Computing • There are several open source libraries available for different fields of computing • For scientific computing • Colt open source library • Linear algebra, matrix computation, statistics, random number generators, mathematical functions • If needing special routines, it is always a good idea to look around of what is available before starting implementation

26. Reducing space consumption

27. JVM memory organization • The stack • method input- and return parameters, local variables • The Heap • for object instances, including strings and arrays • Each thread has a separate stack • each growing and shrinking by the depth of method calls • The heap is joint for all threads • a garbage collector manages the heap deallocation

28. Three important aspects of memory usage • Allocation rate • the rate by which a program creates new objects • high rate costs in time and space • Retention • the amount of live data on the heap, which is reachable from the method stacks anytime • high retention cost space (and garbage collector time) • Fragmentation • creating small chunks of unusable memory • Allocation of dynamically growing objects may cause memory fragmentation • costs time (to search for useable space) and space (wasted fragments)

29. Instance shared variables • Use static declaration for variables shared by all instances of a class • only one field created for all objects • Instead of publicclass Car{ String brand = ”Ferrari” } • we can do this publicclass Car{ finalstatic String brand = ”Ferrari”; }

30. Object allocation • When it is not sure the an object will be used, we can apply lazy allocation • Lazy allocation means that we postpone the allocation of an object untill it is actually needed, but only once

31. Without Lazy Allocation publicclass car{ private Button button = new Jbutton(); public Car(){ … initialize button … } publicfinal Jbutton getButton(){ return button; } }

32. Lazy Allocation publicclass car{ private Button button = null; public Car(){…} publicfinal Jbutton getButton(){ if(button == null){ button = new Jbutton(); …initialize button … } return button; } }

33. Other resources • J. Noble and C. Weir, Small Memory Software, Addison-Wesley, 2001 • A number of design patterns for limited memory systems