Lab Activity Plan. John Dalbey CPE /30/2013

Size: px

Start display at page:

Download "Lab Activity Plan. John Dalbey CPE /30/2013"

Clementine Patterson
5 years ago
Views:

1 John Dalbey CPE /3/213 Lab Activity Plan Purpose The purpose of this lab is to demonstrate the performance impacts of autoboxing in Java. The textbook describes how Java will automatically convert a primitive (like an int) into an object (like Integer). But there is a performance penalty for doing this, and I'm curious how severe that penalty is in a real program. My plan is to write a program that uses autoboxing and compare how fast it runs compared to one that doesn't do autoboxing. Procedure Write a method that uses a for loop to increment a counter (int, no autoboxing). Write a second method that does the same thing for a Integer counter (uses autoboxing). Use the system timer to determine how long each loop takes to run for some number of iterations entered by the user. Write a method that fills an array of ints (no autoboxing). Write a second method that fills an ArrayList using autoboxing. Use the system timer to determine how long each method takes to run for some number of items entered by the user. Compare the resulting times to see which is faster. Data Collection (as appropriate) Number of items int counter loop time Integer counter loop time array fill time ArrayList fill time User enters number of items, from 5, - 1 million by increments of 5,. Expected Results In theory, autoboxing should take longer. The book doesn't give a formal analysis of how long, but my reasoning is that autoboxing requires allocation of an object then assigning the primitive to that object. I can only guess that will take about two or three times as long as not using autoboxing. In any case, it should be a constant time operation (big numbers don't take any longer to autobox than small ones), so the curve should be linear. Time Estimate 3 minutes.

2 Lab Report Source code The programs for this experiment are attached. Data Collection The programs were run on a desktop computer with a 3GHz dual core 64-bit CPU and 2GB RAM. The raw data I collected is available at Analysis For each data point, I averaged the values of the three readings. (All times in milliseconds) Number of items int counter loop time Integer counter loop time array fill time ArrayList fill time (Out of memory error on last item) N/A Graph of run times versus number of items Column B Column C Column D Column E

3 The int counter is so fast, it never even takes one millisecond. The data for the Integer counter has a lot of variation in it. but it's clearly a lot longer than the int counter. So that confirms my hypothesis. My guess of "two or three times as long" was apparently very wrong. The array and list fill time data came out a little more consistent. Unfortunately I ran out of memory before I could get long enough run times to produce very stable results. The array fill curve appears linear (increases a constant amount each time). The ArrayList curve might be quadratic, though I don't have an explanation for why that would be. There are no nested loops and autoboxing a value doesn't depend on the size of the list. The difference was very dramatic. An array of 25 million Integers takes about 4 seconds to fill; noticable to the human observer, but using primitive ints it takes much less than one second. Lab time: 17 minutes writing the program and 7 minutes running the experiment, for total of 24 minutes. Conclusion This experiment confirmed that there is a measurable performance impact of autoboxing. The effect probably isn't noticeable to the human observer for small lists (under one million items), but one would need to be cautious in performance critical code with large lists.

4 import java.util.arraylist; import java.util.scanner; /** * Demo of AutoBoxing performance compared to no autoboxing. J. Dalbey */ public class AutoBoxingDemo // keep track of when timer started long starttime; public void runnoautoboxing(int limit) int counter = ; for(int i=; i < limit; i++) counter++; public void runautoboxing(int limit) Integer counter = ; for(int i=; i < limit; i++) counter++; // autoboxing int to Integer public void fillarray(int limit) int[] myarray = new int[limit]; for(int i=; i < limit; i++) myarray[i] = i; public void filllist(int limit) ArrayList<Integer> mylist = new ArrayList<Integer>(); for(int i=; i < limit; i++) mylist.add(i); // autoboxing int to Integer public void starttiming() starttime = System.currentTimeMillis(); public void stoptiming() long endtime = System.currentTimeMillis(); long elapsed = endtime - starttime; System.out.println("Elapsed time: " + elapsed + " ms");

5 public static void main(string[] args) AutoBoxingDemo app = new AutoBoxingDemo(); // Get number of items from user Scanner console = new Scanner(System.in); int limit = console.nextint(); // keep doing experiments until user enters zero while (limit > ) System.out.println("limit: " + limit); // counting loop experiment app.runnoautoboxing(limit); app.runautoboxing(limit); // filling list experiment app.fillarray(limit); app.filllist(limit); System.out.println("-----"); limit = console.nextint();

Lesson 26: ArrayList (W08D1)

Lesson 26: ArrayList (W08D1) Balboa High School Michael Ferraro October 5, 2015 1 / 25 Do Now Prepare PS #4a (paper form) for pick-up! Consider the code below for powiter(), an iterative algorithm that