A stress test of both the garbage collector and function calls in general

test/Memory.java

@@ -0,0 +1,170 @@
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.TreeSet;
+
+public class Memory {
+  private static final int ITERATION_COUNT=3;
+
+  private static class Item {
+    private static int instanceCount=0;
+    private final int index;
+    private final int val;
+    public Item(int i) { val = i; index = instanceCount++; }
+    public int value() { return val; }
+    public int index() { return index; }
+  }
+
+  private static void traceFunc(String s) {
+    if (false) {
+      System.out.println(s);
+    }
+  }
+
+  private static void expect(boolean v) {
+    if (! v) throw new RuntimeException();
+  }
+
+  private static int runningSum(Item[] items) {
+    int sum=0;
+    for (Item item : items) {
+      sum += item.value();
+    }
+    return sum;
+  }
+
+  private static int runningSum(Collection<Item> items) {
+    int sum=0;
+    for (Item item : items) {
+      sum += item.value();
+    }
+    return sum;
+  }
+
+  private static final void testArray() {
+    traceFunc("testArray()");
+    Item[] items = new Item[1750];
+
+    for (int iter=1; iter < ITERATION_COUNT; iter++) {
+      for (int i=0; i < 1000; i++) {
+        items[i] = new Item(1);
+      }
+      for (int i=0; i < 500; i++) {
+        items[i+1000] = new Item(4);
+      }
+      for (int i=0; i < 250; i++) {
+        items[i+1500] = new Item(9);
+      }
+      expect(runningSum(items) == (1000*1 + 500*4 + 250*9));
+      Item[] zeroItems = new Item[300];
+      for (int i=0; i < 300; i++) {
+        zeroItems[i] = new Item(0);
+      }
+      System.arraycopy(zeroItems, 0, items, 900, zeroItems.length);
+      for (int i=0; i < 10000; i++) {
+        items[0] = new Item(1);
+      }
+      expect(runningSum(items) == (900*1 + 300*4 + 250*9));
+      for (int i=0; i < 300; i++) {
+        zeroItems[i] = new Item((i+900) < 1000 ? 1 : 4);
+      }
+      for (int i=0; i < 10000; i++) {
+        items[0] = new Item(1);
+      }
+      expect(runningSum(items) == (900*1 + 300*4 + 250*9));
+      System.arraycopy(zeroItems, 0, items, 900, zeroItems.length);
+      expect(runningSum(items) == (1000*1 + 500*4 + 250*9));
+      for (int i=0; i < 1750; i++) {
+        items[i] = null;
+      }
+    }
+  }
+
+  private static final void testHashMap() {
+    traceFunc("testHashMap()");
+    HashMap<Integer, Item> items = new HashMap<Integer, Item>();
+    for (int iter=1; iter < ITERATION_COUNT; iter++) {
+      for (int i=0; i < 1000; i++) {
+        items.put(i, new Item(1));
+      }
+      for (int i=0; i < 500; i++) {
+        items.put(i+1000, new Item(4));
+      }
+      for (int i=0; i < 250; i++) {
+        items.put(i+1500, new Item(9));
+      }
+      expect(runningSum(items.values()) == (1000*1 + 500*4 + 250*9));
+      for (int i = 900; i < 1200; i++) {
+        items.remove(i);
+      }
+      expect(runningSum(items.values()) == (900*1 + 300*4 + 250*9));
+      for (int i = 900; i < 1200; i++) {
+        items.put(i, new Item(i < 1000 ? 1 : 4));
+      }
+      expect(runningSum(items.values()) == (1000*1 + 500*4 + 250*9));
+      items.clear();
+    }
+  }
+
+  private static final void testLinkedList() {
+    traceFunc("testLinkedList()");
+    LinkedList<Item> items = new LinkedList<Item>();
+    for (int iter=1; iter < ITERATION_COUNT; iter++) {
+      for (int i=0; i < 1000; i++) {
+        items.add(new Item(1));
+      }
+      for (int i=0; i < 500; i++) {
+        items.add(new Item(4));
+      }
+      for (int i=0; i < 250; i++) {
+        items.add(new Item(9));
+      }
+      expect(runningSum(items) == (1000*1 + 500*4 + 250*9));
+      for (int i = 1199; i >= 900; i--) {
+        items.remove(i);
+      }
+      expect(runningSum(items) == (900*1 + 300*4 + 250*9));
+      for (int i = 900; i < 1200; i++) {
+        items.add(new Item(i < 1000 ? 1 : 4));
+      }
+      expect(runningSum(items) == (1000*1 + 500*4 + 250*9));
+      items.clear();
+    }
+  }
+
+  private static final void testTreeSet() {
+    traceFunc("testTreeSet()");
+    TreeSet<Item> items = new TreeSet<Item>(new Comparator<Item>() {
+      public int compare(Item i1, Item i2) {
+        int r = i1.value() - i2.value();
+        if (r == 0) {
+          return i1.index() - i2.index();
+        }
+        return r;
+      }
+    });
+    for (int iter=1; iter < ITERATION_COUNT; iter++) {
+      for (int i=0; i < 1000; i++) {
+        items.add(new Item(1));
+      }
+      for (int i=0; i < 500; i++) {
+        items.add(new Item(4));
+      }
+      for (int i=0; i < 250; i++) {
+        items.add(new Item(9));
+      }
+      expect(runningSum(items) == (1000*1 + 500*4 + 250*9));
+      items.clear();
+    }
+  }
+
+  public static void main(String args[]) {
+    for (int i=0; i < 10; i++) {
+      testArray();
+      testHashMap();
+      testLinkedList();
+      testTreeSet();
+    }
+  }
+}