Merging bug 22334 onto default

Author: Matthew Sackman

src/com/rabbitmq/utility/IntAllocator.java

@@ -24,186 +24,209 @@
 //   LLC. Portions created by Rabbit Technologies Ltd are Copyright
 //   (C) 2007-2010 Rabbit Technologies Ltd.
 //
-//   All Rights Reserved.
+//     All Rights Reserved.
 //
-//   Contributor(s): ______________________________________.
+//     Contributor(s): ______________________________________.
 //
 package com.rabbitmq.utility;
 
-import java.util.*;
+import java.util.Arrays;
 
 /**
- * A class for allocating integer IDs in a given range. 
- */ 
+ * A class for allocating integer IDs in a given range.
+ */
 public class IntAllocator{
 
-  // Invariant: Sorted in order of first element. Non-overlapping, non-adjacent.
-  // This could really use being a balanced binary tree. However for normal usages 
-  // it doesn't actually matter.
-  private LinkedList<Interval> intervals = new LinkedList<Interval>();
-
-  private final int[] unsorted;
-  private int unsortedCount = 0;
-
-  /** 
-   * A class representing an inclusive interval from start to end.
-   */
-  private static class Interval{
-    Interval(int start, int end){
-      this.start = start;
-      this.end = end;
+    // Invariant: Sorted in order of first element.
+    // Invariant: Intervals are non-overlapping, non-adjacent.
+    // This could really use being a balanced binary tree. However for normal
+    // usages it doesn't actually matter.
+    private IntervalList base;
+
+    private final int[] unsorted;
+    private int unsortedCount = 0;
+
+    /**
+     * A class representing an inclusive interval from start to end.
+     */
+    private static class IntervalList{
+        IntervalList(int start, int end){
+            this.start = start;
+            this.end = end;
+        }
+
+        int start;
+        int end;
+        IntervalList next;
+
+        int length(){ return end - start + 1; }
     }
 
-    int start;
-    int end;
-
-    int length(){ return end - start + 1; } 
-  }
-
-  /** 
-   * Creates an IntAllocator allocating integer IDs within the inclusive range [start, end]
-   */
-  public IntAllocator(int start, int end){
-    if(start > end) throw new IllegalArgumentException("illegal range [" + start  +", " + end + "]");
-
-    // Fairly arbitrary heuristic for a good size for the unsorted set.
-    unsorted = new int[Math.max(32, (int)Math.sqrt(end - start))];
-    intervals.add(new Interval(start, end));
-  }
-
-  /**
-   * Allocate a fresh integer from the range, or return -1 if no more integers
-   * are available. This operation is guaranteed to run in O(1) 
-   */
-  public int allocate(){
-    if(unsortedCount > 0){
-      return unsorted[--unsortedCount];
-    } else if (!intervals.isEmpty()) {
-      Interval first = intervals.getFirst();
-      if(first.length() == 1) intervals.removeFirst();
-      return first.start++; 
-    } else {
-      return -1;
+    /** Destructively merge two IntervalLists.
+     * Invariant: None of the Intervals in the two lists may overlap
+     * intervals in this list.
+     */
+    public static IntervalList merge(IntervalList x, IntervalList y){
+        if(x == null) return y;
+        if(y == null) return x;
+
+        if(x.end > y.start) return merge(y, x);
+
+        // We now have x, y non-null and x.End < y.Start.
+        if(y.start == x.end + 1){
+            // The two intervals adjoin. Merge them into one and then
+            // merge the tails.
+            x.end = y.end;
+            x.next = merge(x.next, y.next);
+            return x;
+        }
+
+        // y belongs in the tail of x.
+
+        x.next = merge(y, x.next);
+        return x;
+    }
+
+
+    public static IntervalList fromArray(int[] xs, int length){
+        Arrays.sort(xs, 0, length);
+
+        IntervalList result = null;
+        IntervalList current = null;
+
+        int i = 0;
+        while(i < length){
+            int start = i;
+            while((i < length - 1) && (xs[i + 1] == xs[i] + 1))
+                i++;
+
+            IntervalList interval = new IntervalList(xs[start], xs[i]);
+
+            if(result == null){
+                result = interval;
+                current = interval;
+            } else {
+                current.next = interval;
+                current = interval;
+            }
+            i++;
+        }
+        return result;
     }
-  }
-
-  /** 
-   * Make the provided integer available for allocation again. This operation 
-   * runs in amortized O(sqrt(range size)) time: About every sqrt(range size) 
-   * operations  will take O(range_size + number of intervals) to complete and 
-   * the rest run in constant time.
-   * 
-   * No error checking is performed, so if you double free or free an integer
-   * that was not originally allocated the results are undefined. Sorry.
-   */
-  public void free(int id){
-    if(unsortedCount >= unsorted.length){
-      flush();
+
+
+    /**
+    * Creates an IntAllocator allocating integer IDs within the inclusive range
+    * [start, end]
+    */
+    public IntAllocator(int start, int end){
+        if(start > end)
+            throw new IllegalArgumentException("illegal range [" + start    +
+              ", " + end + "]");
+
+        // Fairly arbitrary heuristic for a good size for the unsorted set.
+        unsorted = new int[Math.max(32, (int)Math.sqrt(end - start))];
+        base = new IntervalList(start, end);
     }
-    unsorted[unsortedCount++] = id;
-  }
-
-  /** 
-   * Attempt to reserve the provided ID as if it had been allocated. Returns true 
-   * if it is available, false otherwise. 
-   *
-   * This operation runs in O(id) in the worst case scenario, though it can usually
-   * be expected to perform better than that unless a great deal of fragmentation
-   * has occurred. 
-   */
-  public boolean reserve(int id){
-    flush();
-    ListIterator<Interval> it = intervals.listIterator();
-
-    while(it.hasNext()){
-      Interval i = it.next();
-      if(i.start <= id && id <= i.end){
-        if(i.length() == 1) it.remove();
-        else if(i.start == id) i.start++;
-        else if(i.end == id) i.end--;
-        else {
-          it.add(new Interval(id + 1, i.end));
-          i.end = id - 1;
+
+    /**
+     * Allocate a fresh integer from the range, or return -1 if no more integers
+     * are available. This operation is guaranteed to run in O(1)
+     */
+    public int allocate(){
+        if(unsortedCount > 0){
+            return unsorted[--unsortedCount];
+        } else if (base != null){
+            IntervalList source = base;
+            if(base.length() == 1) base = base.next;
+            return source.start++;
+        } else {
+            return -1;
         }
-        return true;
-      }
     }
 
-    return false;
-  }
-
-  private void flush(){
-    if(unsortedCount == 0) return;
-  
-    Arrays.sort(unsorted);
-   
-    ListIterator<Interval> it = intervals.listIterator();
-
-    int i = 0;
-    while(i < unsortedCount){
-      int start = i;
-      while((i < unsortedCount - 1) && (unsorted[i + 1] == unsorted[i] + 1))
-        i++;
-
-      Interval interval = new Interval(start, i);
-
-      // Scan to an appropriate point in the list to insert this interval
-      // this may well be the end
-      while(it.hasNext()){
-        if(it.next().start > interval.end){
-          it.previous();
-          break;
+    /**
+     * Make the provided integer available for allocation again. This operation
+     * runs in amortized O(sqrt(range size)) time: About every sqrt(range size)
+     * operations will take O(range_size + number of intervals) to complete and
+     * the rest run in constant time.
+     *
+     * No error checking is performed, so if you double free or free an integer
+     * that was not originally allocated the results are undefined. Sorry.
+     */
+    public void free(int id){
+        if(unsortedCount >= unsorted.length){
+            flush();
         }
-      }
-  
-      it.add(interval);
-      i++;
+        unsorted[unsortedCount++] = id;
     }
 
-    normalize();
-    unsortedCount = 0; 
-  }
-
-  private void normalize(){
-    if(intervals.isEmpty()) return;
-    Iterator<Interval> it = intervals.iterator();
-
-    Interval trailing, leading;
-    leading = it.next();
-    while(it.hasNext()){
-      trailing = leading;
-      leading = it.next();
-
-      if(leading.start == trailing.end + 1) {
-        it.remove(); 
-        trailing.end = leading.end;
-      }
-    } 
-  }
-
-  @Override public String toString(){
-    StringBuilder builder = new StringBuilder();
-
-    builder.append("IntAllocator{");
-
-    builder.append("intervals = [");
-    Iterator<Interval> it = intervals.iterator();
-    while(it.hasNext()){
-      Interval i = it.next();
-      builder.append(i.start).append("..").append(i.end);
-      if(it.hasNext()) builder.append(", ");     
+    /**
+     * Attempt to reserve the provided ID as if it had been allocated. Returns
+     * true if it is available, false otherwise.
+     *
+     * This operation runs in O(id) in the worst case scenario, though it can
+     * usually be expected to perform better than that unless a great deal of
+     * fragmentation has occurred.
+     */
+    public boolean reserve(int id){
+        flush();
+
+        IntervalList current = base;
+
+        while(current != null && current.end < id){
+            current = current.next;
+        }
+
+        if(current == null) return false;
+        if(current.start > id) return false;
+
+        if(current.end == id)
+                current.end--;
+        else if(current.start == id)
+            current.start++;
+        else {
+            // The ID is in the middle of this interval.
+            // We need to split the interval into two.
+            IntervalList rest = new IntervalList(id + 1, current.end);
+            current.end = id - 1;
+            rest.next = current.next;
+            current.next = rest;
+        }
+
+        return true;
     }
-    builder.append("]");
 
-    builder.append(", unsorted = [");
-    for(int i = 0; i < unsortedCount; i++){
-      builder.append(unsorted[i]);
-      if( i < unsortedCount - 1) builder.append(", ");
+    public void flush(){
+        if(unsortedCount == 0) return;
+
+        base = merge(base, fromArray(unsorted, unsortedCount));
+        unsortedCount = 0;
     }
-    builder.append("]");
+
+    @Override public String toString(){
+        StringBuilder builder = new StringBuilder();
+
+        builder.append("IntAllocator{");
+
+        builder.append("intervals = [");
+        IntervalList it = base;
+        while(it != null){
+            builder.append(it.start).append("..").append(it.end);
+            if(it.next != null) builder.append(", ");
+            it = it.next;
+        }
+        builder.append("]");
+
+        builder.append(", unsorted = [");
+        for(int i = 0; i < unsortedCount; i++){
+            builder.append(unsorted[i]);
+            if( i < unsortedCount - 1) builder.append(", ");
+        }
+        builder.append("]");
 
 
-    builder.append("}");
-    return builder.toString();
-  }
+        builder.append("}");
+        return builder.toString();
+    }
 }