Added a few commodity methods. Removed confusing overload of sizeOf().

Author: dweiss

pom.xml

@@ -12,7 +12,7 @@
   <!-- Project info. -->
   <groupId>com.carrotsearch</groupId>
   <artifactId>java-sizeof</artifactId>
-  <version>0.0.1</version>
+  <version>0.0.2</version>
   <packaging>jar</packaging>
 
   <name>java-sizeof</name>
@@ -55,13 +55,6 @@
       <version>0.3.0</version>
       <scope>test</scope>
     </dependency>
-    
-    <dependency>
-      <groupId>org.apache.lucene</groupId>
-      <artifactId>lucene-core</artifactId>
-      <version>3.5.0</version>
-      <scope>test</scope>
-    </dependency>
   </dependencies>
 
 

src/main/java/com/carrotsearch/sizeof/RamUsageEstimator.java

@@ -290,18 +290,36 @@ public static long alignObjectSize(long size) {
    * should be GCed.</p>
    */
   public static long sizeOf(Object obj) {
-    return measureObjectSize(obj);
+    ArrayList<Object> stack = new ArrayList<Object>();
+    stack.add(obj);
+    return measureSizeOf(stack);
   }
 
   /**
-   * Same as {@link #sizeOf(Object)} but sums up all the arguments.
+   * Same as {@link #sizeOf(Object)} but sums up all the arguments. Not an
+   * overload to prevent accidental parameter conflicts with {@link #sizeOf(Object)}.
    */
-  public static long sizeOf(Object... obj) {
-    long sum = 0;
-    for (Object o : obj) {
-      sum += measureObjectSize(o);
+  public static long sizeOfAll(Object... objects) {
+    return sizeOfAll(Arrays.asList(objects));
+  }
+
+  /**
+   * Same as {@link #sizeOf(Object)} but sums up all the arguments. Not an
+   * overload to prevent accidental parameter conflicts with {@link #sizeOf(Object)}.
+   */
+  public static long sizeOfAll(Iterable<Object> objects) {
+    final ArrayList<Object> stack;
+    if (objects instanceof Collection<?>) {
+      stack = new ArrayList<Object>(((Collection<?>) objects).size());
+    } else {
+      stack = new ArrayList<Object>();
     }
-    return sum;
+
+    for (Object o : objects) {
+      stack.add(o);
+    }
+
+    return measureSizeOf(stack);
   }
 
   /** 
@@ -321,6 +339,28 @@ public static long shallowSizeOf(Object obj) {
     }
   }
 
+  /**
+   * Same as {@link #shallowSizeOf(Object)} but sums up all the arguments. Not an
+   * overload to prevent accidental parameter conflicts with {@link #shallowSizeOf(Object)}.
+   */
+  public static long shallowSizeOfAll(Object... objects) {
+    return shallowSizeOfAll(Arrays.asList(objects));
+  }
+
+  /**
+   * Same as {@link #shallowSizeOf(Object)} but sums up all the arguments. Duplicate
+   * objects are not resolved and will be counted twice. 
+   * Not an overload to prevent accidental parameter conflicts with 
+   * {@link #shallowSizeOf(Object)}.
+   */
+  public static long shallowSizeOfAll(Iterable<Object> objects) {
+    long sum = 0;
+    for (Object o : objects) {
+      sum += shallowSizeOf(o);
+    }
+    return sum;
+  }
+
   /**
    * Returns the shallow instance size in bytes an instance of the given class would occupy.
    * This works with all conventional classes and primitive types, but not with arrays
@@ -378,18 +418,17 @@ private static long shallowSizeOfArray(Object array) {
     return alignObjectSize(size);
   }
 
-  /*
+  /**
    * Non-recursive version of object descend. This consumes more memory than recursive in-depth 
    * traversal but prevents stack overflows on long chains of objects
    * or complex graphs (a max. recursion depth on my machine was ~5000 objects linked in a chain
-   * so not too much).  
+   * so not too much).
+   * 
+   * @param stack Root objects.
    */
-  private static long measureObjectSize(Object root) {
+  private static long measureSizeOf(ArrayList<Object> stack) {
     final IdentityHashSet<Object> seen = new IdentityHashSet<Object>();
     final IdentityHashMap<Class<?>, ClassCache> classCache = new IdentityHashMap<Class<?>, ClassCache>();
-    final ArrayList<Object> stack = new ArrayList<Object>();
-
-    stack.add(root);
 
     long totalSize = 0;
     while (!stack.isEmpty()) {

src/test/java/com/carrotsearch/sizeof/TestEstimationQuality.java

@@ -101,49 +101,6 @@ public long newObject(Object[] vault, int i) {
     });
   }
 
-  /**
-   * Wild class instances (and arrays, etc.).
-   */
-  @Test @Ignore
-  public void testWildClassesOldLuceneEstimator() {
-    estimate(new Allocator() {
-      List<Class<?>> classes = new ArrayList<Class<?>>();
-      HashMap<Class<?>,Long> sizes = new HashMap<Class<?>,Long>();
-      Random random = new Random();
-
-      {
-        final org.apache.lucene.util.RamUsageEstimator rue = 
-            new org.apache.lucene.util.RamUsageEstimator(false);
-        for (Class<?> c : WildClasses.ALL) {
-          try {
-            long estimateRamUsage = rue.estimateRamUsage(c.newInstance());
-            if (estimateRamUsage > 80) {
-              continue;
-            }
-            classes.add(c);
-            sizes.put(c, estimateRamUsage);
-          } catch (Exception e) {
-            throw new RuntimeException(e);
-          }
-        }
-      }
-
-      @Override
-      public long newObject(Object[] vault, int i) {
-        Class<?> c = classes.get(random.nextInt(classes.size()));
-        try {
-          vault[i] = c.newInstance();
-        } catch (Exception e) {
-          throw new RuntimeException(e);
-        }
-        if (!sizes.containsKey(c)) {
-          throw new RuntimeException();
-        }
-        return sizes.get(c);
-      }
-    });
-  }
-
   /**
    * Estimate estimation quality of {@link Allocator}'s objects. 
    */
@@ -173,7 +130,7 @@ public void estimate(Allocator allocator) {
 
     Arrays.fill(vault, null);
 
-    long expectedFree = free - RamUsageEstimator.sizeOf(vault, allocator);
+    long expectedFree = free - RamUsageEstimator.sizeOfAll(vault, allocator);
     double difference = 100.0d * (expectedAllocated - expectedFree) / (double) expectedFree;
     System.out.println(String.format(Locale.ENGLISH, 
         "Expected free: %s, Allocated estimation: %s, Difference: %.2f%% (%s)",