1 /*
   2  * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 package sun.java2d.marlin;
  26 
  27 import static sun.java2d.marlin.ArrayCacheConst.ARRAY_SIZES;
  28 import static sun.java2d.marlin.ArrayCacheConst.BUCKETS;
  29 import static sun.java2d.marlin.ArrayCacheConst.MAX_ARRAY_SIZE;
  30 import static sun.java2d.marlin.MarlinUtils.logInfo;
  31 import static sun.java2d.marlin.MarlinUtils.logException;


  32 
  33 import java.lang.ref.WeakReference;
  34 import java.util.Arrays;
  35 
  36 import sun.java2d.marlin.ArrayCacheConst.BucketStats;
  37 import sun.java2d.marlin.ArrayCacheConst.CacheStats;
  38 
  39 /*
  40  * Note that the [BYTE/INT/FLOAT]ArrayCache files are nearly identical except
  41  * for a few type and name differences. Typically, the [BYTE]ArrayCache.java file
  42  * is edited manually and then [INT]ArrayCache.java and [FLOAT]ArrayCache.java
  43  * files are generated with the following command lines:
  44  */
  45 // % sed -e 's/(b\yte)[ ]*//g' -e 's/b\yte/int/g' -e 's/B\yte/Int/g' < B\yteArrayCache.java > IntArrayCache.java
  46 // % sed -e 's/(b\yte)[ ]*/(float) /g' -e 's/b\yte/float/g' -e 's/B\yte/Float/g' < B\yteArrayCache.java > FloatArrayCache.java
  47 
  48 final class ByteArrayCache implements MarlinConst {
  49 
  50     final boolean clean;
  51     private final int bucketCapacity;
  52     private WeakReference<Bucket[]> refBuckets = null;
  53     final CacheStats stats;
  54 
  55     ByteArrayCache(final boolean clean, final int bucketCapacity) {
  56         this.clean = clean;
  57         this.bucketCapacity = bucketCapacity;
  58         this.stats = (DO_STATS) ?
  59             new CacheStats(getLogPrefix(clean) + "ByteArrayCache") : null;
  60     }
  61 
  62     Bucket getCacheBucket(final int length) {
  63         final int bucket = ArrayCacheConst.getBucket(length);
  64         return getBuckets()[bucket];
  65     }
  66 
  67     private Bucket[] getBuckets() {
  68         // resolve reference:
  69         Bucket[] buckets = (refBuckets != null) ? refBuckets.get() : null;
  70 
  71         // create a new buckets ?
  72         if (buckets == null) {
  73             buckets = new Bucket[BUCKETS];
  74 
  75             for (int i = 0; i < BUCKETS; i++) {
  76                 buckets[i] = new Bucket(clean, ARRAY_SIZES[i], bucketCapacity,
  77                         (DO_STATS) ? stats.bucketStats[i] : null);
  78             }
  79 
  80             // update weak reference:
  81             refBuckets = new WeakReference<Bucket[]>(buckets);
  82         }
  83         return buckets;
  84     }
  85 
  86     Reference createRef(final int initialSize) {
  87         return new Reference(this, initialSize);
  88     }
  89 
  90     static final class Reference {
  91 
  92         // initial array reference (direct access)
  93         final byte[] initial;
  94         private final boolean clean;
  95         private final ByteArrayCache cache;
  96 
  97         Reference(final ByteArrayCache cache, final int initialSize) {
  98             this.cache = cache;
  99             this.clean = cache.clean;
 100             this.initial = createArray(initialSize, clean);
 101             if (DO_STATS) {
 102                 cache.stats.totalInitial += initialSize;
 103             }
 104         }
 105 
 106         byte[] getArray(final int length) {
 107             if (length <= MAX_ARRAY_SIZE) {
 108                 return cache.getCacheBucket(length).getArray();
 109             }
 110             if (DO_STATS) {
 111                 cache.stats.oversize++;
 112             }
 113             if (DO_LOG_OVERSIZE) {
 114                 logInfo(getLogPrefix(clean) + "ByteArrayCache: "
 115                         + "getArray[oversize]: length=\t" + length);
 116             }
 117             return createArray(length, clean);
 118         }
 119 
 120         byte[] widenArray(final byte[] array, final int usedSize,
 121                           final int needSize)
 122         {
 123             final int length = array.length;
 124             if (DO_CHECKS && length >= needSize) {
 125                 return array;
 126             }
 127             if (DO_STATS) {
 128                 cache.stats.resize++;
 129             }
 130 
 131             // maybe change bucket:
 132             // ensure getNewSize() > newSize:
 133             final byte[] res = getArray(ArrayCacheConst.getNewSize(usedSize, needSize));
 134 
 135             // use wrapper to ensure proper copy:
 136             System.arraycopy(array, 0, res, 0, usedSize); // copy only used elements
 137 
 138             // maybe return current array:
 139             putArray(array, 0, usedSize); // ensure array is cleared
 140 
 141             if (DO_LOG_WIDEN_ARRAY) {
 142                 logInfo(getLogPrefix(clean) + "ByteArrayCache: "
 143                         + "widenArray[" + res.length
 144                         + "]: usedSize=\t" + usedSize + "\tlength=\t" + length
 145                         + "\tneeded length=\t" + needSize);
 146             }
 147             return res;
 148         }
 149 
 150         byte[] putArray(final byte[] array)
 151         {
 152             // dirty array helper:
 153             return putArray(array, 0, array.length);
 154         }
 155 
 156         byte[] putArray(final byte[] array, final int fromIndex,
 157                         final int toIndex)
 158         {
 159             if (array.length <= MAX_ARRAY_SIZE) {
 160                 if ((clean || DO_CLEAN_DIRTY) && (toIndex != 0)) {
 161                     // clean-up array of dirty part[fromIndex; toIndex[
 162                     fill(array, fromIndex, toIndex, (byte)0);
 163                 }
 164                 // ensure to never store initial arrays in cache:
 165                 if (array != initial) {
 166                     cache.getCacheBucket(array.length).putArray(array);
 167                 }
 168             }
 169             return initial;
 170         }
 171     }
 172 
 173     static final class Bucket {
 174 
 175         private int tail = 0;
 176         private final int arraySize;
 177         private final boolean clean;
 178         private final byte[][] arrays;
 179         private final BucketStats stats;
 180 
 181         Bucket(final boolean clean, final int arraySize,
 182                final int capacity, final BucketStats stats)
 183         {
 184             this.arraySize = arraySize;
 185             this.clean = clean;
 186             this.stats = stats;
 187             this.arrays = new byte[capacity][];
 188         }
 189 
 190         byte[] getArray() {
 191             if (DO_STATS) {
 192                 stats.getOp++;
 193             }
 194             // use cache:
 195             if (tail != 0) {
 196                 final byte[] array = arrays[--tail];
 197                 arrays[tail] = null;
 198                 return array;
 199             }
 200             if (DO_STATS) {
 201                 stats.createOp++;
 202             }
 203             return createArray(arraySize, clean);
 204         }
 205 
 206         void putArray(final byte[] array)
 207         {
 208             if (DO_CHECKS && (array.length != arraySize)) {
 209                 logInfo(getLogPrefix(clean) + "ByteArrayCache: "
 210                         + "bad length = " + array.length);
 211                 return;
 212             }
 213             if (DO_STATS) {
 214                 stats.returnOp++;
 215             }
 216             // fill cache:
 217             if (arrays.length > tail) {
 218                 arrays[tail++] = array;
 219 
 220                 if (DO_STATS) {
 221                     stats.updateMaxSize(tail);
 222                 }
 223             } else if (DO_CHECKS) {
 224                 logInfo(getLogPrefix(clean) + "ByteArrayCache: "
 225                         + "array capacity exceeded !");
 226             }
 227         }
 228     }
 229 
 230     static byte[] createArray(final int length, final boolean clean) {
 231         if (clean) {
 232             return new byte[length];
 233         }
 234        // use JDK9 Unsafe.allocateUninitializedArray(class, length):
 235        return (byte[]) OffHeapArray.UNSAFE.allocateUninitializedArray(byte.class, length);
 236     }
 237 
 238     static void fill(final byte[] array, final int fromIndex,
 239                      final int toIndex, final byte value)
 240     {
 241         // clear array data:
 242         Arrays.fill(array, fromIndex, toIndex, value);
 243         if (DO_CHECKS) {
 244             check(array, fromIndex, toIndex, value);
 245         }
 246     }
 247 
 248     static void check(final byte[] array, final int fromIndex,
 249                       final int toIndex, final byte value)
 250     {
 251         if (DO_CHECKS) {
 252             // check zero on full array:
 253             for (int i = 0; i < array.length; i++) {
 254                 if (array[i] != value) {
 255                     logException("Invalid value at: " + i + " = " + array[i]
 256                             + " from: " + fromIndex + " to: " + toIndex + "\n"
 257                             + Arrays.toString(array), new Throwable());
 258 
 259                     // ensure array is correctly filled:
 260                     Arrays.fill(array, value);
 261 
 262                     return;
 263                 }
 264             }
 265         }
 266     }
 267 
 268     static String getLogPrefix(final boolean clean) {
 269         return (clean) ? "Clean" : "Dirty";
 270     }
 271 }
--- EOF ---