< prev index next >

modules/javafx.graphics/src/main/java/com/sun/marlin/DoubleArrayCache.java

Print this page




  82             // update weak reference:
  83             refBuckets = new WeakReference<Bucket[]>(buckets);
  84         }
  85         return buckets;
  86     }
  87 
  88     Reference createRef(final int initialSize) {
  89         return new Reference(this, initialSize);
  90     }
  91 
  92     static final class Reference {
  93 
  94         // initial array reference (direct access)
  95         final double[] initial;
  96         private final boolean clean;
  97         private final DoubleArrayCache cache;
  98 
  99         Reference(final DoubleArrayCache cache, final int initialSize) {
 100             this.cache = cache;
 101             this.clean = cache.clean;
 102             this.initial = createArray(initialSize, clean);
 103             if (DO_STATS) {
 104                 cache.stats.totalInitial += initialSize;
 105             }
 106         }
 107 
 108         double[] getArray(final int length) {
 109             if (length <= MAX_ARRAY_SIZE) {
 110                 return cache.getCacheBucket(length).getArray();
 111             }
 112             if (DO_STATS) {
 113                 cache.stats.oversize++;
 114             }
 115             if (DO_LOG_OVERSIZE) {
 116                 logInfo(getLogPrefix(clean) + "DoubleArrayCache: "
 117                         + "getArray[oversize]: length=\t" + length);
 118             }
 119             return createArray(length, clean);
 120         }
 121 
 122         double[] widenArray(final double[] array, final int usedSize,
 123                           final int needSize)
 124         {
 125             final int length = array.length;
 126             if (DO_CHECKS && length >= needSize) {
 127                 return array;
 128             }
 129             if (DO_STATS) {
 130                 cache.stats.resize++;
 131             }
 132 
 133             // maybe change bucket:
 134             // ensure getNewSize() > newSize:
 135             final double[] res = getArray(ArrayCacheConst.getNewSize(usedSize, needSize));
 136 
 137             // use wrapper to ensure proper copy:
 138             System.arraycopy(array, 0, res, 0, usedSize); // copy only used elements
 139 


 185         {
 186             this.arraySize = arraySize;
 187             this.clean = clean;
 188             this.stats = stats;
 189             this.arrays = new double[capacity][];
 190         }
 191 
 192         double[] getArray() {
 193             if (DO_STATS) {
 194                 stats.getOp++;
 195             }
 196             // use cache:
 197             if (tail != 0) {
 198                 final double[] array = arrays[--tail];
 199                 arrays[tail] = null;
 200                 return array;
 201             }
 202             if (DO_STATS) {
 203                 stats.createOp++;
 204             }
 205             return createArray(arraySize, clean);
 206         }
 207 
 208         void putArray(final double[] array)
 209         {
 210             if (DO_CHECKS && (array.length != arraySize)) {
 211                 logInfo(getLogPrefix(clean) + "DoubleArrayCache: "
 212                         + "bad length = " + array.length);
 213                 return;
 214             }
 215             if (DO_STATS) {
 216                 stats.returnOp++;
 217             }
 218             // fill cache:
 219             if (arrays.length > tail) {
 220                 arrays[tail++] = array;
 221 
 222                 if (DO_STATS) {
 223                     stats.updateMaxSize(tail);
 224                 }
 225             } else if (DO_CHECKS) {
 226                 logInfo(getLogPrefix(clean) + "DoubleArrayCache: "
 227                         + "array capacity exceeded !");
 228             }
 229         }
 230     }
 231 
 232     static double[] createArray(final int length, final boolean clean) {
 233         return new double[length];
 234     }
 235 
 236     static void fill(final double[] array, final int fromIndex,
 237                      final int toIndex, final double value)
 238     {
 239         // clear array data:
 240         Arrays.fill(array, fromIndex, toIndex, value);
 241         if (DO_CHECKS) {
 242             check(array, fromIndex, toIndex, value);
 243         }
 244     }
 245 
 246     public static void check(final double[] array, final int fromIndex,
 247                              final int toIndex, final double value)
 248     {
 249         if (DO_CHECKS) {
 250             // check zero on full array:
 251             for (int i = 0; i < array.length; i++) {
 252                 if (array[i] != value) {


  82             // update weak reference:
  83             refBuckets = new WeakReference<Bucket[]>(buckets);
  84         }
  85         return buckets;
  86     }
  87 
  88     Reference createRef(final int initialSize) {
  89         return new Reference(this, initialSize);
  90     }
  91 
  92     static final class Reference {
  93 
  94         // initial array reference (direct access)
  95         final double[] initial;
  96         private final boolean clean;
  97         private final DoubleArrayCache cache;
  98 
  99         Reference(final DoubleArrayCache cache, final int initialSize) {
 100             this.cache = cache;
 101             this.clean = cache.clean;
 102             this.initial = createArray(initialSize);
 103             if (DO_STATS) {
 104                 cache.stats.totalInitial += initialSize;
 105             }
 106         }
 107 
 108         double[] getArray(final int length) {
 109             if (length <= MAX_ARRAY_SIZE) {
 110                 return cache.getCacheBucket(length).getArray();
 111             }
 112             if (DO_STATS) {
 113                 cache.stats.oversize++;
 114             }
 115             if (DO_LOG_OVERSIZE) {
 116                 logInfo(getLogPrefix(clean) + "DoubleArrayCache: "
 117                         + "getArray[oversize]: length=\t" + length);
 118             }
 119             return createArray(length);
 120         }
 121 
 122         double[] widenArray(final double[] array, final int usedSize,
 123                           final int needSize)
 124         {
 125             final int length = array.length;
 126             if (DO_CHECKS && length >= needSize) {
 127                 return array;
 128             }
 129             if (DO_STATS) {
 130                 cache.stats.resize++;
 131             }
 132 
 133             // maybe change bucket:
 134             // ensure getNewSize() > newSize:
 135             final double[] res = getArray(ArrayCacheConst.getNewSize(usedSize, needSize));
 136 
 137             // use wrapper to ensure proper copy:
 138             System.arraycopy(array, 0, res, 0, usedSize); // copy only used elements
 139 


 185         {
 186             this.arraySize = arraySize;
 187             this.clean = clean;
 188             this.stats = stats;
 189             this.arrays = new double[capacity][];
 190         }
 191 
 192         double[] getArray() {
 193             if (DO_STATS) {
 194                 stats.getOp++;
 195             }
 196             // use cache:
 197             if (tail != 0) {
 198                 final double[] array = arrays[--tail];
 199                 arrays[tail] = null;
 200                 return array;
 201             }
 202             if (DO_STATS) {
 203                 stats.createOp++;
 204             }
 205             return createArray(arraySize);
 206         }
 207 
 208         void putArray(final double[] array)
 209         {
 210             if (DO_CHECKS && (array.length != arraySize)) {
 211                 logInfo(getLogPrefix(clean) + "DoubleArrayCache: "
 212                         + "bad length = " + array.length);
 213                 return;
 214             }
 215             if (DO_STATS) {
 216                 stats.returnOp++;
 217             }
 218             // fill cache:
 219             if (arrays.length > tail) {
 220                 arrays[tail++] = array;
 221 
 222                 if (DO_STATS) {
 223                     stats.updateMaxSize(tail);
 224                 }
 225             } else if (DO_CHECKS) {
 226                 logInfo(getLogPrefix(clean) + "DoubleArrayCache: "
 227                         + "array capacity exceeded !");
 228             }
 229         }
 230     }
 231 
 232     static double[] createArray(final int length) {
 233         return new double[length];
 234     }
 235 
 236     static void fill(final double[] array, final int fromIndex,
 237                      final int toIndex, final double value)
 238     {
 239         // clear array data:
 240         Arrays.fill(array, fromIndex, toIndex, value);
 241         if (DO_CHECKS) {
 242             check(array, fromIndex, toIndex, value);
 243         }
 244     }
 245 
 246     public static void check(final double[] array, final int fromIndex,
 247                              final int toIndex, final double value)
 248     {
 249         if (DO_CHECKS) {
 250             // check zero on full array:
 251             for (int i = 0; i < array.length; i++) {
 252                 if (array[i] != value) {
< prev index next >