#186

Build # #186

Build Type

push

Committed by

Commit Message

<a href="https://github.com/apache/datasketches-java/commit/<a class=hub.com/apache/datasketches-java/commit/<a class="double-link" href="https://git"><a class=hub.com/apache/datasketches-java/commit/<a class="double-link" href="https://git"><a class=hub.com/apache/datasketches-java/commit/a2a6c41534c1fb7592e7c636a879e579f2f91178">a2a6c4153">&lt;a href=&quot;https://github.com/apache/datasketches-java/commit/</a><a class="double-link" href="https://github.com/apache/datasketches-java/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/apache/datasketches-java/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/apache/datasketches-java/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/apache/datasketches-java/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/apache/datasketches-java/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/apache/datasketches-java/commit/a2a6c41534c1fb7592e7c636a879e579f2f91178">a2a6c4153</a><a href="https://github.com/apache/datasketches-java/commit/a2a6c41534c1fb7592e7c636a879e579f2f91178">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/apache/datasketches-java/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/apache/datasketches-java/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/apache/datasketches-java/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/apache/datasketches-java/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/apache/datasketches-java/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/apache/datasketches-java/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/apache/datasketches-java/commit/a2a6c41534c1fb7592e7c636a879e579f2f91178&quot;&gt;... (continued)

Run Details

1579 of 1579 new or added lines in 16 files covered. (100.0%)

19151 of 19502 relevant lines covered (98.2%)

0.98 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

99.47

/src/main/java/org/apache/datasketches/kll/KllMemoryValidate.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package org.apache.datasketches.kll;

import static org.apache.datasketches.Family.idToFamily;
import static org.apache.datasketches.kll.KllMemoryValidate.MERRNO.ERR_SRC_NOT_KLL;
import static org.apache.datasketches.kll.KllMemoryValidate.MERRNO.ERR_EMPTYBIT_AND_PREINTS;
import static org.apache.datasketches.kll.KllMemoryValidate.MERRNO.ERR_UPDATABLEBIT_AND_SER_VER;
import static org.apache.datasketches.kll.KllMemoryValidate.MERRNO.ERR_EMPTYBIT_AND_SER_VER;
import static org.apache.datasketches.kll.KllMemoryValidate.MERRNO.ERR_EMPTYBIT_AND_SINGLEBIT;
import static org.apache.datasketches.kll.KllMemoryValidate.MERRNO.ERR_SINGLEBIT_AND_SER_VER;
import static org.apache.datasketches.kll.KllMemoryValidate.MERRNO.ERR_DOUBLEBIT_AND_PREINTS;
import static org.apache.datasketches.kll.KllMemoryValidate.MERRNO.ERR_FLOATBIT_AND_PREINTS;
import static org.apache.datasketches.kll.KllPreambleUtil.DATA_START_ADR_DOUBLE;
import static org.apache.datasketches.kll.KllPreambleUtil.DATA_START_ADR_FLOAT;
import static org.apache.datasketches.kll.KllPreambleUtil.DATA_START_ADR_SINGLE_ITEM;
import static org.apache.datasketches.kll.KllPreambleUtil.PREAMBLE_INTS_DOUBLE;
import static org.apache.datasketches.kll.KllPreambleUtil.PREAMBLE_INTS_EMPTY_SINGLE;
import static org.apache.datasketches.kll.KllPreambleUtil.PREAMBLE_INTS_FLOAT;
import static org.apache.datasketches.kll.KllPreambleUtil.SERIAL_VERSION_EMPTY_FULL;
import static org.apache.datasketches.kll.KllPreambleUtil.SERIAL_VERSION_SINGLE;
import static org.apache.datasketches.kll.KllPreambleUtil.SERIAL_VERSION_UPDATABLE;
import static org.apache.datasketches.kll.KllPreambleUtil.extractDoubleSketchFlag;
import static org.apache.datasketches.kll.KllPreambleUtil.extractDyMinK;
import static org.apache.datasketches.kll.KllPreambleUtil.extractEmptyFlag;
import static org.apache.datasketches.kll.KllPreambleUtil.extractFamilyID;
import static org.apache.datasketches.kll.KllPreambleUtil.extractFlags;
import static org.apache.datasketches.kll.KllPreambleUtil.extractK;
import static org.apache.datasketches.kll.KllPreambleUtil.extractLevelZeroSortedFlag;
import static org.apache.datasketches.kll.KllPreambleUtil.extractM;
import static org.apache.datasketches.kll.KllPreambleUtil.extractN;
import static org.apache.datasketches.kll.KllPreambleUtil.extractNumLevels;
import static org.apache.datasketches.kll.KllPreambleUtil.extractPreInts;
import static org.apache.datasketches.kll.KllPreambleUtil.extractSerVer;
import static org.apache.datasketches.kll.KllPreambleUtil.extractSingleItemFlag;
import static org.apache.datasketches.kll.KllPreambleUtil.extractUpdatableFlag;

import org.apache.datasketches.Family;
import org.apache.datasketches.SketchesArgumentException;
import org.apache.datasketches.kll.KllPreambleUtil.Layout;
import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.WritableMemory;

/**
 * This class performs all the error checking of an incoming Memory object and extracts the key fields in the process.
 * This is used by all sketches that read or import Memory objects.
 *
 * @author lrhodes
 *
 */
final class KllMemoryValidate {
  // first 8 bytes
  final int preInts; // = extractPreInts(srcMem);
  final int serVer;
  final int familyID;
  final String famName;
  final int flags;
  boolean empty;
  boolean singleItem;
  final boolean level0Sorted;
  final boolean doublesSketch;
  final boolean updatable;
  final int k;
  final int m;
  final int memCapacity;

  Layout layout;
  // depending on the layout, the next 8-16 bytes of the preamble, may be filled with assumed values.
  // For example, if the layout is compact & empty, n = 0, if compact and single, n = 1, etc.
  long n;
  // next 4 bytes
  int dyMinK;
  int numLevels;
  // derived
  int capacityItems; //capacity of Items array for exporting and for Updatable form
  int itemsRetained; //actual items retained in Compact form
  int itemsArrStart;
  int sketchBytes;
  Memory levelsArrCompact; //if sk = empty or single, this is derived
  Memory minMaxArrCompact; //if sk = empty or single, this is derived
  Memory itemsArrCompact;  //if sk = empty or single, this is derived
  WritableMemory levelsArrUpdatable;
  WritableMemory minMaxArrUpdatable;
  WritableMemory itemsArrUpdatable;

  KllMemoryValidate(final Memory srcMem) {
    memCapacity = (int) srcMem.getCapacity();
    preInts = extractPreInts(srcMem);
    serVer = extractSerVer(srcMem);

    familyID = extractFamilyID(srcMem);
    if (familyID != Family.KLL.getID()) { memoryValidateThrow(ERR_SRC_NOT_KLL, familyID); }
    famName = idToFamily(familyID).toString();
    flags = extractFlags(srcMem);
    empty = extractEmptyFlag(srcMem);
    level0Sorted  = extractLevelZeroSortedFlag(srcMem);
    singleItem    = extractSingleItemFlag(srcMem);
    doublesSketch = extractDoubleSketchFlag(srcMem);
    updatable    = extractUpdatableFlag(srcMem);
    k = extractK(srcMem);
    m = extractM(srcMem);
    KllHelper.checkM(m);
    KllHelper.checkK(k, m);
    if ((serVer == SERIAL_VERSION_UPDATABLE) ^ updatable) { memoryValidateThrow(ERR_UPDATABLEBIT_AND_SER_VER, 0); }

    if (updatable) { updatableMemoryValidate((WritableMemory) srcMem); }
    else { compactMemoryValidate(srcMem); }
  }

  void compactMemoryValidate(final Memory srcMem) {
    if (empty && singleItem) { memoryValidateThrow(ERR_EMPTYBIT_AND_SINGLEBIT, 0); }
    final int sw = (empty ? 1 : 0) | (singleItem ? 4 : 0) | (doublesSketch ? 8 : 0);
    switch (sw) {
      case 0: { //FLOAT_FULL_COMPACT
        if (preInts != PREAMBLE_INTS_FLOAT) { memoryValidateThrow(ERR_FLOATBIT_AND_PREINTS, preInts); }
        if (serVer != SERIAL_VERSION_EMPTY_FULL) { memoryValidateThrow(ERR_EMPTYBIT_AND_SER_VER, serVer); }
        layout = Layout.FLOAT_FULL_COMPACT;
        n = extractN(srcMem);
        dyMinK = extractDyMinK(srcMem);
        numLevels = extractNumLevels(srcMem);
        int offset = DATA_START_ADR_FLOAT;
        // LEVELS MEM
        final int[] myLevelsArr = new int[numLevels + 1];
        srcMem.getIntArray(offset, myLevelsArr, 0, numLevels); //copies all except the last one
        myLevelsArr[numLevels] = KllHelper.computeTotalItemCapacity(k, m, numLevels); //load the last one
        levelsArrCompact = Memory.wrap(myLevelsArr); //separate from srcMem,
        offset += (int)levelsArrCompact.getCapacity() - Integer.BYTES; // but one larger than srcMem
        // MIN/MAX MEM
        minMaxArrCompact = srcMem.region(offset, 2L * Float.BYTES);
        offset += (int)minMaxArrCompact.getCapacity();
        // ITEMS MEM
        itemsArrStart = offset;
        capacityItems = myLevelsArr[numLevels];
        itemsRetained = capacityItems - myLevelsArr[0];
        final float[] myItemsArr = new float[capacityItems];
        srcMem.getFloatArray(offset, myItemsArr, myLevelsArr[0], itemsRetained);
        itemsArrCompact = Memory.wrap(myItemsArr);
        sketchBytes = offset + itemsRetained * Float.BYTES;
        break;
      }
      case 1: { //FLOAT_EMPTY_COMPACT
        if (preInts != PREAMBLE_INTS_EMPTY_SINGLE) { memoryValidateThrow(ERR_EMPTYBIT_AND_PREINTS, preInts); }
        if (serVer != SERIAL_VERSION_EMPTY_FULL) { memoryValidateThrow(ERR_EMPTYBIT_AND_SER_VER, serVer); }
        layout = Layout.FLOAT_EMPTY_COMPACT;
        n = 0;           //assumed
        dyMinK = k;      //assumed
        numLevels = 1;   //assumed
        // LEVELS MEM
        levelsArrCompact = Memory.wrap(new int[] {k, k});
        // MIN/MAX MEM
        minMaxArrCompact = Memory.wrap(new float[] {Float.NaN, Float.NaN});
        // ITEMS MEM
        capacityItems = k;
        itemsRetained = 0;
        itemsArrCompact = Memory.wrap(new float[k]);
        sketchBytes = DATA_START_ADR_SINGLE_ITEM; //also used for empty
        itemsArrStart = DATA_START_ADR_SINGLE_ITEM;
        break;
      }
      case 4: { //FLOAT_SINGLE_COMPACT
        if (preInts != PREAMBLE_INTS_EMPTY_SINGLE) { memoryValidateThrow(ERR_EMPTYBIT_AND_PREINTS, preInts); }
        if (serVer != SERIAL_VERSION_SINGLE) { memoryValidateThrow(ERR_SINGLEBIT_AND_SER_VER, serVer); }
        layout = Layout.FLOAT_SINGLE_COMPACT;
        n = 1;
        dyMinK = k;
        numLevels = 1;
        // LEVELS MEM
        levelsArrCompact = Memory.wrap(new int[] {k - 1, k});
        final float minMax = srcMem.getFloat(DATA_START_ADR_SINGLE_ITEM);
        // MIN/MAX MEM
        minMaxArrCompact = Memory.wrap(new float[] {minMax, minMax});
        // ITEMS MEM
        capacityItems = k;
        itemsRetained = 1;
        final float[] myFloatItems = new float[k];
        myFloatItems[k - 1] = minMax;
        itemsArrCompact = Memory.wrap(myFloatItems);
        sketchBytes = DATA_START_ADR_SINGLE_ITEM + Float.BYTES;
        itemsArrStart = DATA_START_ADR_SINGLE_ITEM;
        break;
      }
      case 8: { //DOUBLE_FULL_COMPACT
        if (preInts != PREAMBLE_INTS_DOUBLE) { memoryValidateThrow(ERR_DOUBLEBIT_AND_PREINTS, preInts); }
        if (serVer != SERIAL_VERSION_EMPTY_FULL) { memoryValidateThrow(ERR_EMPTYBIT_AND_SER_VER, serVer); }
        layout = Layout.DOUBLE_FULL_COMPACT;
        n = extractN(srcMem);
        dyMinK = extractDyMinK(srcMem);
        numLevels = extractNumLevels(srcMem);
        int offset = DATA_START_ADR_DOUBLE;
        // LEVELS MEM
        final int[] myLevelsArr = new int[numLevels + 1];
        srcMem.getIntArray(offset, myLevelsArr, 0, numLevels); //all except the last one
        myLevelsArr[numLevels] = KllHelper.computeTotalItemCapacity(k, m, numLevels); //load the last one
        levelsArrCompact = Memory.wrap(myLevelsArr); //separate from srcMem
        offset += (int)levelsArrCompact.getCapacity() - Integer.BYTES;
        // MIN/MAX MEM
        minMaxArrCompact = srcMem.region(offset, 2L * Double.BYTES);
        offset += (int)minMaxArrCompact.getCapacity();
        // ITEMS MEM
        itemsArrStart = offset;
        capacityItems = myLevelsArr[numLevels];
        itemsRetained = capacityItems - myLevelsArr[0];
        final double[] myItemsArr = new double[capacityItems];
        srcMem.getDoubleArray(offset, myItemsArr, myLevelsArr[0], itemsRetained);
        itemsArrCompact = Memory.wrap(myItemsArr);
        sketchBytes = offset + itemsRetained * Double.BYTES;
        break;
      }
      case 9: { //DOUBLE_EMPTY_COMPACT
        if (preInts != PREAMBLE_INTS_EMPTY_SINGLE) { memoryValidateThrow(ERR_EMPTYBIT_AND_PREINTS, preInts); }
        if (serVer != SERIAL_VERSION_EMPTY_FULL) { memoryValidateThrow(ERR_EMPTYBIT_AND_SER_VER, serVer); }
        layout = Layout.DOUBLE_EMPTY_COMPACT;
        n = 0;
        dyMinK = k;
        numLevels = 1;

        // LEVELS MEM
        levelsArrCompact = Memory.wrap(new int[] {k, k});
        // MIN/MAX MEM
        minMaxArrCompact = Memory.wrap(new double[] {Double.NaN, Double.NaN});
        // ITEMS MEM
        capacityItems = k;
        itemsRetained = 0;
        itemsArrCompact = Memory.wrap(new double[k]);
        sketchBytes = DATA_START_ADR_SINGLE_ITEM; //also used for empty
        itemsArrStart = DATA_START_ADR_SINGLE_ITEM;
        break;
      }
      case 12: { //DOUBLE_SINGLE_COMPACT
        if (preInts != PREAMBLE_INTS_EMPTY_SINGLE) { memoryValidateThrow(ERR_EMPTYBIT_AND_PREINTS, preInts); }
        if (serVer != SERIAL_VERSION_SINGLE) { memoryValidateThrow(ERR_SINGLEBIT_AND_SER_VER, serVer); }
        layout = Layout.DOUBLE_SINGLE_COMPACT;
        n = 1;
        dyMinK = k;
        numLevels = 1;

        // LEVELS MEM
        levelsArrCompact = Memory.wrap(new int[] {k - 1, k});
        final double minMax = srcMem.getDouble(DATA_START_ADR_SINGLE_ITEM);
        // MIN/MAX MEM
        minMaxArrCompact = Memory.wrap(new double[] {minMax, minMax});
        // ITEMS MEM
        capacityItems = k;
        itemsRetained = 1;
        final double[] myDoubleItems = new double[k];
        myDoubleItems[k - 1] = minMax;
        itemsArrCompact = Memory.wrap(myDoubleItems);
        sketchBytes = DATA_START_ADR_SINGLE_ITEM + Double.BYTES;
        itemsArrStart = DATA_START_ADR_SINGLE_ITEM;
        break;
      }
      default: break; //can't happen
    }
  }

  void updatableMemoryValidate(final WritableMemory wSrcMem) {
    if (doublesSketch) { //DOUBLE_UPDATABLE
      if (preInts != PREAMBLE_INTS_DOUBLE) { memoryValidateThrow(ERR_DOUBLEBIT_AND_PREINTS, preInts); }
      layout = Layout.DOUBLE_UPDATABLE;
      n = extractN(wSrcMem);
      empty = n == 0;       //empty & singleItem are set for convenience
      singleItem = n == 1;  // there is no error checking on these bits
      dyMinK = extractDyMinK(wSrcMem);
      numLevels = extractNumLevels(wSrcMem);

      int offset = DATA_START_ADR_DOUBLE;
      //LEVELS
      levelsArrUpdatable = wSrcMem.writableRegion(offset, (numLevels + 1L) * Integer.BYTES);
      offset += (int)levelsArrUpdatable.getCapacity();
      //MIN/MAX
      minMaxArrUpdatable = wSrcMem.writableRegion(offset, 2L * Double.BYTES);
      offset += (int)minMaxArrUpdatable.getCapacity();
      //ITEMS
      capacityItems = levelsArrUpdatable.getInt((long)numLevels * Integer.BYTES);
      final int itemsArrBytes = capacityItems * Double.BYTES;
      itemsArrStart = offset;
      itemsArrUpdatable = wSrcMem.writableRegion(offset, itemsArrBytes);
      sketchBytes = offset + itemsArrBytes;
    }
    else { //FLOAT_UPDATABLE
      if (preInts != PREAMBLE_INTS_FLOAT) { memoryValidateThrow(ERR_FLOATBIT_AND_PREINTS, preInts); }
      layout = Layout.FLOAT_UPDATABLE;
      n = extractN(wSrcMem);
      empty = n == 0;       //empty & singleItem are set for convenience
      singleItem = n == 1;  // there is no error checking on these bits
      dyMinK = extractDyMinK(wSrcMem);
      numLevels = extractNumLevels(wSrcMem);
      int offset = DATA_START_ADR_FLOAT;
      //LEVELS
      levelsArrUpdatable = wSrcMem.writableRegion(offset, (numLevels + 1L) * Integer.BYTES);
      offset += (int)levelsArrUpdatable.getCapacity();
      //MIN/MAX
      minMaxArrUpdatable = wSrcMem.writableRegion(offset, 2L * Float.BYTES);
      offset += (int)minMaxArrUpdatable.getCapacity();
      //ITEMS
      capacityItems = levelsArrUpdatable.getInt((long)numLevels * Integer.BYTES);
      final int itemsArrBytes = capacityItems * Float.BYTES;
      itemsArrStart = offset;
      itemsArrUpdatable = wSrcMem.writableRegion(offset, itemsArrBytes);
      sketchBytes = itemsArrStart + itemsArrBytes;
    }
  }

  enum MERRNO { ERR_SRC_NOT_KLL, ERR_EMPTYBIT_AND_PREINTS, ERR_EMPTYBIT_AND_SER_VER,
    ERR_SINGLEBIT_AND_SER_VER, ERR_DOUBLEBIT_AND_PREINTS, ERR_FLOATBIT_AND_PREINTS, ERR_UPDATABLEBIT_AND_SER_VER,
    ERR_EMPTYBIT_AND_SINGLEBIT }

  private static void memoryValidateThrow(final MERRNO errType, final int value) {
    String msg = "";
    switch (errType) {
      case ERR_SRC_NOT_KLL: msg = "FamilyID Field must be: " + Family.KLL.getID() + ", NOT: " + value; break;
      case ERR_EMPTYBIT_AND_PREINTS: msg =
          "Empty Bit: 1 -> PreInts: " + PREAMBLE_INTS_EMPTY_SINGLE + ", NOT: " + value; break;
      case ERR_EMPTYBIT_AND_SER_VER: msg =
          "Empty Bit: 1 -> SerVer: " + SERIAL_VERSION_EMPTY_FULL + ", NOT: " + value; break;
      case ERR_SINGLEBIT_AND_SER_VER: msg =
          "Single Item Bit: 1 -> SerVer: " + SERIAL_VERSION_SINGLE + ", NOT: " + value; break;
      case ERR_DOUBLEBIT_AND_PREINTS: msg =
          "Double Sketch Bit: 1 -> PreInts: " + PREAMBLE_INTS_DOUBLE + ", NOT: " + value; break;
      case ERR_FLOATBIT_AND_PREINTS: msg =
          "Double Sketch Bit: 0 -> PreInts: " + PREAMBLE_INTS_FLOAT + ", NOT: " + value; break;
      case ERR_UPDATABLEBIT_AND_SER_VER: msg =
          "((SerVer == 3) ^ (Updatable Bit)) must = 0."; break;
      case ERR_EMPTYBIT_AND_SINGLEBIT: msg =
          "Empty flag bit and SingleItem flag bit cannot both be set. Flags: " + value; break;
      default: msg = "Unknown error"; break;
    }
    throw new SketchesArgumentException(msg);
  }

}


1	/*
2	* Licensed to the Apache Software Foundation (ASF) under one
3	* or more contributor license agreements. See the NOTICE file
4	* distributed with this work for additional information
5	* regarding copyright ownership. The ASF licenses this file
6	* to you under the Apache License, Version 2.0 (the
7	* "License"); you may not use this file except in compliance
8	* with the License. You may obtain a copy of the License at
9	*
10	* http://www.apache.org/licenses/LICENSE-2.0
11	*
12	* Unless required by applicable law or agreed to in writing,
13	* software distributed under the License is distributed on an
14	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15	* KIND, either express or implied. See the License for the
16	* specific language governing permissions and limitations
17	* under the License.
18	*/
19
20	package org.apache.datasketches.kll;
21
22	import static org.apache.datasketches.Family.idToFamily;
23	import static org.apache.datasketches.kll.KllMemoryValidate.MERRNO.ERR_SRC_NOT_KLL;
24	import static org.apache.datasketches.kll.KllMemoryValidate.MERRNO.ERR_EMPTYBIT_AND_PREINTS;
25	import static org.apache.datasketches.kll.KllMemoryValidate.MERRNO.ERR_UPDATABLEBIT_AND_SER_VER;
26	import static org.apache.datasketches.kll.KllMemoryValidate.MERRNO.ERR_EMPTYBIT_AND_SER_VER;
27	import static org.apache.datasketches.kll.KllMemoryValidate.MERRNO.ERR_EMPTYBIT_AND_SINGLEBIT;
28	import static org.apache.datasketches.kll.KllMemoryValidate.MERRNO.ERR_SINGLEBIT_AND_SER_VER;
29	import static org.apache.datasketches.kll.KllMemoryValidate.MERRNO.ERR_DOUBLEBIT_AND_PREINTS;
30	import static org.apache.datasketches.kll.KllMemoryValidate.MERRNO.ERR_FLOATBIT_AND_PREINTS;
31	import static org.apache.datasketches.kll.KllPreambleUtil.DATA_START_ADR_DOUBLE;
32	import static org.apache.datasketches.kll.KllPreambleUtil.DATA_START_ADR_FLOAT;
33	import static org.apache.datasketches.kll.KllPreambleUtil.DATA_START_ADR_SINGLE_ITEM;
34	import static org.apache.datasketches.kll.KllPreambleUtil.PREAMBLE_INTS_DOUBLE;
35	import static org.apache.datasketches.kll.KllPreambleUtil.PREAMBLE_INTS_EMPTY_SINGLE;
36	import static org.apache.datasketches.kll.KllPreambleUtil.PREAMBLE_INTS_FLOAT;
37	import static org.apache.datasketches.kll.KllPreambleUtil.SERIAL_VERSION_EMPTY_FULL;
38	import static org.apache.datasketches.kll.KllPreambleUtil.SERIAL_VERSION_SINGLE;
39	import static org.apache.datasketches.kll.KllPreambleUtil.SERIAL_VERSION_UPDATABLE;
40	import static org.apache.datasketches.kll.KllPreambleUtil.extractDoubleSketchFlag;
41	import static org.apache.datasketches.kll.KllPreambleUtil.extractDyMinK;
42	import static org.apache.datasketches.kll.KllPreambleUtil.extractEmptyFlag;
43	import static org.apache.datasketches.kll.KllPreambleUtil.extractFamilyID;
44	import static org.apache.datasketches.kll.KllPreambleUtil.extractFlags;
45	import static org.apache.datasketches.kll.KllPreambleUtil.extractK;
46	import static org.apache.datasketches.kll.KllPreambleUtil.extractLevelZeroSortedFlag;
47	import static org.apache.datasketches.kll.KllPreambleUtil.extractM;
48	import static org.apache.datasketches.kll.KllPreambleUtil.extractN;
49	import static org.apache.datasketches.kll.KllPreambleUtil.extractNumLevels;
50	import static org.apache.datasketches.kll.KllPreambleUtil.extractPreInts;
51	import static org.apache.datasketches.kll.KllPreambleUtil.extractSerVer;
52	import static org.apache.datasketches.kll.KllPreambleUtil.extractSingleItemFlag;
53	import static org.apache.datasketches.kll.KllPreambleUtil.extractUpdatableFlag;
54
55	import org.apache.datasketches.Family;
56	import org.apache.datasketches.SketchesArgumentException;
57	import org.apache.datasketches.kll.KllPreambleUtil.Layout;
58	import org.apache.datasketches.memory.Memory;
59	import org.apache.datasketches.memory.WritableMemory;
60
61	/**
62	* This class performs all the error checking of an incoming Memory object and extracts the key fields in the process.
63	* This is used by all sketches that read or import Memory objects.
64	*
65	* @author lrhodes
66	*
67	*/
68	final class KllMemoryValidate {
69	// first 8 bytes
70	final int preInts; // = extractPreInts(srcMem);
71	final int serVer;
72	final int familyID;
73	final String famName;
74	final int flags;
75	boolean empty;
76	boolean singleItem;
77	final boolean level0Sorted;
78	final boolean doublesSketch;
79	final boolean updatable;
80	final int k;
81	final int m;
82	final int memCapacity;
83
84	Layout layout;
85	// depending on the layout, the next 8-16 bytes of the preamble, may be filled with assumed values.
86	// For example, if the layout is compact & empty, n = 0, if compact and single, n = 1, etc.
87	long n;
88	// next 4 bytes
89	int dyMinK;
90	int numLevels;
91	// derived
92	int capacityItems; //capacity of Items array for exporting and for Updatable form
93	int itemsRetained; //actual items retained in Compact form
94	int itemsArrStart;
95	int sketchBytes;
96	Memory levelsArrCompact; //if sk = empty or single, this is derived
97	Memory minMaxArrCompact; //if sk = empty or single, this is derived
98	Memory itemsArrCompact; //if sk = empty or single, this is derived
99	WritableMemory levelsArrUpdatable;
100	WritableMemory minMaxArrUpdatable;
101	WritableMemory itemsArrUpdatable;
102
103	KllMemoryValidate(final Memory srcMem) {	1✔
104	memCapacity = (int) srcMem.getCapacity();	1✔
105	preInts = extractPreInts(srcMem);	1✔
106	serVer = extractSerVer(srcMem);	1✔
107
108	familyID = extractFamilyID(srcMem);	1✔
109	if (familyID != Family.KLL.getID()) { memoryValidateThrow(ERR_SRC_NOT_KLL, familyID); }	1✔
110	famName = idToFamily(familyID).toString();	1✔
111	flags = extractFlags(srcMem);	1✔
112	empty = extractEmptyFlag(srcMem);	1✔
113	level0Sorted = extractLevelZeroSortedFlag(srcMem);	1✔
114	singleItem = extractSingleItemFlag(srcMem);	1✔
115	doublesSketch = extractDoubleSketchFlag(srcMem);	1✔
116	updatable = extractUpdatableFlag(srcMem);	1✔
117	k = extractK(srcMem);	1✔
118	m = extractM(srcMem);	1✔
119	KllHelper.checkM(m);	1✔
120	KllHelper.checkK(k, m);	1✔
121	if ((serVer == SERIAL_VERSION_UPDATABLE) ^ updatable) { memoryValidateThrow(ERR_UPDATABLEBIT_AND_SER_VER, 0); }	1✔
122
123	if (updatable) { updatableMemoryValidate((WritableMemory) srcMem); }	1✔
124	else { compactMemoryValidate(srcMem); }	1✔
125	}	1✔
126
127	void compactMemoryValidate(final Memory srcMem) {
128	if (empty && singleItem) { memoryValidateThrow(ERR_EMPTYBIT_AND_SINGLEBIT, 0); }	1✔
129	final int sw = (empty ? 1 : 0) \| (singleItem ? 4 : 0) \| (doublesSketch ? 8 : 0);	1✔
130	switch (sw) {	1✔
131	case 0: { //FLOAT_FULL_COMPACT
132	if (preInts != PREAMBLE_INTS_FLOAT) { memoryValidateThrow(ERR_FLOATBIT_AND_PREINTS, preInts); }	1✔
133	if (serVer != SERIAL_VERSION_EMPTY_FULL) { memoryValidateThrow(ERR_EMPTYBIT_AND_SER_VER, serVer); }	1✔
134	layout = Layout.FLOAT_FULL_COMPACT;	1✔
135	n = extractN(srcMem);	1✔
136	dyMinK = extractDyMinK(srcMem);	1✔
137	numLevels = extractNumLevels(srcMem);	1✔
138	int offset = DATA_START_ADR_FLOAT;	1✔
139	// LEVELS MEM
140	final int[] myLevelsArr = new int[numLevels + 1];	1✔
141	srcMem.getIntArray(offset, myLevelsArr, 0, numLevels); //copies all except the last one	1✔
142	myLevelsArr[numLevels] = KllHelper.computeTotalItemCapacity(k, m, numLevels); //load the last one	1✔
143	levelsArrCompact = Memory.wrap(myLevelsArr); //separate from srcMem,	1✔
144	offset += (int)levelsArrCompact.getCapacity() - Integer.BYTES; // but one larger than srcMem	1✔
145	// MIN/MAX MEM
146	minMaxArrCompact = srcMem.region(offset, 2L * Float.BYTES);	1✔
147	offset += (int)minMaxArrCompact.getCapacity();	1✔
148	// ITEMS MEM
149	itemsArrStart = offset;	1✔
150	capacityItems = myLevelsArr[numLevels];	1✔
151	itemsRetained = capacityItems - myLevelsArr[0];	1✔
152	final float[] myItemsArr = new float[capacityItems];	1✔
153	srcMem.getFloatArray(offset, myItemsArr, myLevelsArr[0], itemsRetained);	1✔
154	itemsArrCompact = Memory.wrap(myItemsArr);	1✔
155	sketchBytes = offset + itemsRetained * Float.BYTES;	1✔
156	break;	1✔
157	}
158	case 1: { //FLOAT_EMPTY_COMPACT
159	if (preInts != PREAMBLE_INTS_EMPTY_SINGLE) { memoryValidateThrow(ERR_EMPTYBIT_AND_PREINTS, preInts); }	1✔
160	if (serVer != SERIAL_VERSION_EMPTY_FULL) { memoryValidateThrow(ERR_EMPTYBIT_AND_SER_VER, serVer); }	1✔
161	layout = Layout.FLOAT_EMPTY_COMPACT;	1✔
162	n = 0; //assumed	1✔
163	dyMinK = k; //assumed	1✔
164	numLevels = 1; //assumed	1✔
165	// LEVELS MEM
166	levelsArrCompact = Memory.wrap(new int[] {k, k});	1✔
167	// MIN/MAX MEM
168	minMaxArrCompact = Memory.wrap(new float[] {Float.NaN, Float.NaN});	1✔
169	// ITEMS MEM
170	capacityItems = k;	1✔
171	itemsRetained = 0;	1✔
172	itemsArrCompact = Memory.wrap(new float[k]);	1✔
173	sketchBytes = DATA_START_ADR_SINGLE_ITEM; //also used for empty	1✔
174	itemsArrStart = DATA_START_ADR_SINGLE_ITEM;	1✔
175	break;	1✔
176	}
177	case 4: { //FLOAT_SINGLE_COMPACT
178	if (preInts != PREAMBLE_INTS_EMPTY_SINGLE) { memoryValidateThrow(ERR_EMPTYBIT_AND_PREINTS, preInts); }	1✔
179	if (serVer != SERIAL_VERSION_SINGLE) { memoryValidateThrow(ERR_SINGLEBIT_AND_SER_VER, serVer); }	1✔
180	layout = Layout.FLOAT_SINGLE_COMPACT;	1✔
181	n = 1;	1✔
182	dyMinK = k;	1✔
183	numLevels = 1;	1✔
184	// LEVELS MEM
185	levelsArrCompact = Memory.wrap(new int[] {k - 1, k});	1✔
186	final float minMax = srcMem.getFloat(DATA_START_ADR_SINGLE_ITEM);	1✔
187	// MIN/MAX MEM
188	minMaxArrCompact = Memory.wrap(new float[] {minMax, minMax});	1✔
189	// ITEMS MEM
190	capacityItems = k;	1✔
191	itemsRetained = 1;	1✔
192	final float[] myFloatItems = new float[k];	1✔
193	myFloatItems[k - 1] = minMax;	1✔
194	itemsArrCompact = Memory.wrap(myFloatItems);	1✔
195	sketchBytes = DATA_START_ADR_SINGLE_ITEM + Float.BYTES;	1✔
196	itemsArrStart = DATA_START_ADR_SINGLE_ITEM;	1✔
197	break;	1✔
198	}
199	case 8: { //DOUBLE_FULL_COMPACT
200	if (preInts != PREAMBLE_INTS_DOUBLE) { memoryValidateThrow(ERR_DOUBLEBIT_AND_PREINTS, preInts); }	1✔
201	if (serVer != SERIAL_VERSION_EMPTY_FULL) { memoryValidateThrow(ERR_EMPTYBIT_AND_SER_VER, serVer); }	1✔
202	layout = Layout.DOUBLE_FULL_COMPACT;	1✔
203	n = extractN(srcMem);	1✔
204	dyMinK = extractDyMinK(srcMem);	1✔
205	numLevels = extractNumLevels(srcMem);	1✔
206	int offset = DATA_START_ADR_DOUBLE;	1✔
207	// LEVELS MEM
208	final int[] myLevelsArr = new int[numLevels + 1];	1✔
209	srcMem.getIntArray(offset, myLevelsArr, 0, numLevels); //all except the last one	1✔
210	myLevelsArr[numLevels] = KllHelper.computeTotalItemCapacity(k, m, numLevels); //load the last one	1✔
211	levelsArrCompact = Memory.wrap(myLevelsArr); //separate from srcMem	1✔
212	offset += (int)levelsArrCompact.getCapacity() - Integer.BYTES;	1✔
213	// MIN/MAX MEM
214	minMaxArrCompact = srcMem.region(offset, 2L * Double.BYTES);	1✔
215	offset += (int)minMaxArrCompact.getCapacity();	1✔
216	// ITEMS MEM
217	itemsArrStart = offset;	1✔
218	capacityItems = myLevelsArr[numLevels];	1✔
219	itemsRetained = capacityItems - myLevelsArr[0];	1✔
220	final double[] myItemsArr = new double[capacityItems];	1✔
221	srcMem.getDoubleArray(offset, myItemsArr, myLevelsArr[0], itemsRetained);	1✔
222	itemsArrCompact = Memory.wrap(myItemsArr);	1✔
223	sketchBytes = offset + itemsRetained * Double.BYTES;	1✔
224	break;	1✔
225	}
226	case 9: { //DOUBLE_EMPTY_COMPACT
227	if (preInts != PREAMBLE_INTS_EMPTY_SINGLE) { memoryValidateThrow(ERR_EMPTYBIT_AND_PREINTS, preInts); }	1✔
228	if (serVer != SERIAL_VERSION_EMPTY_FULL) { memoryValidateThrow(ERR_EMPTYBIT_AND_SER_VER, serVer); }	1✔
229	layout = Layout.DOUBLE_EMPTY_COMPACT;	1✔
230	n = 0;	1✔
231	dyMinK = k;	1✔
232	numLevels = 1;	1✔
233
234	// LEVELS MEM
235	levelsArrCompact = Memory.wrap(new int[] {k, k});	1✔
236	// MIN/MAX MEM
237	minMaxArrCompact = Memory.wrap(new double[] {Double.NaN, Double.NaN});	1✔
238	// ITEMS MEM
239	capacityItems = k;	1✔
240	itemsRetained = 0;	1✔
241	itemsArrCompact = Memory.wrap(new double[k]);	1✔
242	sketchBytes = DATA_START_ADR_SINGLE_ITEM; //also used for empty	1✔
243	itemsArrStart = DATA_START_ADR_SINGLE_ITEM;	1✔
244	break;	1✔
245	}
246	case 12: { //DOUBLE_SINGLE_COMPACT
247	if (preInts != PREAMBLE_INTS_EMPTY_SINGLE) { memoryValidateThrow(ERR_EMPTYBIT_AND_PREINTS, preInts); }	1✔
248	if (serVer != SERIAL_VERSION_SINGLE) { memoryValidateThrow(ERR_SINGLEBIT_AND_SER_VER, serVer); }	1✔
249	layout = Layout.DOUBLE_SINGLE_COMPACT;	1✔
250	n = 1;	1✔
251	dyMinK = k;	1✔
252	numLevels = 1;	1✔
253
254	// LEVELS MEM
255	levelsArrCompact = Memory.wrap(new int[] {k - 1, k});	1✔
256	final double minMax = srcMem.getDouble(DATA_START_ADR_SINGLE_ITEM);	1✔
257	// MIN/MAX MEM
258	minMaxArrCompact = Memory.wrap(new double[] {minMax, minMax});	1✔
259	// ITEMS MEM
260	capacityItems = k;	1✔
261	itemsRetained = 1;	1✔
262	final double[] myDoubleItems = new double[k];	1✔
263	myDoubleItems[k - 1] = minMax;	1✔
264	itemsArrCompact = Memory.wrap(myDoubleItems);	1✔
265	sketchBytes = DATA_START_ADR_SINGLE_ITEM + Double.BYTES;	1✔
266	itemsArrStart = DATA_START_ADR_SINGLE_ITEM;	1✔
267	break;	1✔
268	}
269	default: break; //can't happen
270	}
271	}	1✔
272
273	void updatableMemoryValidate(final WritableMemory wSrcMem) {
274	if (doublesSketch) { //DOUBLE_UPDATABLE	1✔
275	if (preInts != PREAMBLE_INTS_DOUBLE) { memoryValidateThrow(ERR_DOUBLEBIT_AND_PREINTS, preInts); }	1✔
276	layout = Layout.DOUBLE_UPDATABLE;	1✔
277	n = extractN(wSrcMem);	1✔
278	empty = n == 0; //empty & singleItem are set for convenience	1✔
279	singleItem = n == 1; // there is no error checking on these bits	1✔
280	dyMinK = extractDyMinK(wSrcMem);	1✔
281	numLevels = extractNumLevels(wSrcMem);	1✔
282
283	int offset = DATA_START_ADR_DOUBLE;	1✔
284	//LEVELS
285	levelsArrUpdatable = wSrcMem.writableRegion(offset, (numLevels + 1L) * Integer.BYTES);	1✔
286	offset += (int)levelsArrUpdatable.getCapacity();	1✔
287	//MIN/MAX
288	minMaxArrUpdatable = wSrcMem.writableRegion(offset, 2L * Double.BYTES);	1✔
289	offset += (int)minMaxArrUpdatable.getCapacity();	1✔
290	//ITEMS
291	capacityItems = levelsArrUpdatable.getInt((long)numLevels * Integer.BYTES);	1✔
292	final int itemsArrBytes = capacityItems * Double.BYTES;	1✔
293	itemsArrStart = offset;	1✔
294	itemsArrUpdatable = wSrcMem.writableRegion(offset, itemsArrBytes);	1✔
295	sketchBytes = offset + itemsArrBytes;	1✔
296	}	1✔
297	else { //FLOAT_UPDATABLE
298	if (preInts != PREAMBLE_INTS_FLOAT) { memoryValidateThrow(ERR_FLOATBIT_AND_PREINTS, preInts); }	1✔
299	layout = Layout.FLOAT_UPDATABLE;	1✔
300	n = extractN(wSrcMem);	1✔
301	empty = n == 0; //empty & singleItem are set for convenience	1✔
302	singleItem = n == 1; // there is no error checking on these bits	1✔
303	dyMinK = extractDyMinK(wSrcMem);	1✔
304	numLevels = extractNumLevels(wSrcMem);	1✔
305	int offset = DATA_START_ADR_FLOAT;	1✔
306	//LEVELS
307	levelsArrUpdatable = wSrcMem.writableRegion(offset, (numLevels + 1L) * Integer.BYTES);	1✔
308	offset += (int)levelsArrUpdatable.getCapacity();	1✔
309	//MIN/MAX
310	minMaxArrUpdatable = wSrcMem.writableRegion(offset, 2L * Float.BYTES);	1✔
311	offset += (int)minMaxArrUpdatable.getCapacity();	1✔
312	//ITEMS
313	capacityItems = levelsArrUpdatable.getInt((long)numLevels * Integer.BYTES);	1✔
314	final int itemsArrBytes = capacityItems * Float.BYTES;	1✔
315	itemsArrStart = offset;	1✔
316	itemsArrUpdatable = wSrcMem.writableRegion(offset, itemsArrBytes);	1✔
317	sketchBytes = itemsArrStart + itemsArrBytes;	1✔
318	}
319	}	1✔
320
321	enum MERRNO { ERR_SRC_NOT_KLL, ERR_EMPTYBIT_AND_PREINTS, ERR_EMPTYBIT_AND_SER_VER,	1✔
322	ERR_SINGLEBIT_AND_SER_VER, ERR_DOUBLEBIT_AND_PREINTS, ERR_FLOATBIT_AND_PREINTS, ERR_UPDATABLEBIT_AND_SER_VER,	1✔
323	ERR_EMPTYBIT_AND_SINGLEBIT }	1✔
324
325	private static void memoryValidateThrow(final MERRNO errType, final int value) {
326	String msg = "";	1✔
327	switch (errType) {	1✔
328	case ERR_SRC_NOT_KLL: msg = "FamilyID Field must be: " + Family.KLL.getID() + ", NOT: " + value; break;	1✔
329	case ERR_EMPTYBIT_AND_PREINTS: msg =	1✔
330	"Empty Bit: 1 -> PreInts: " + PREAMBLE_INTS_EMPTY_SINGLE + ", NOT: " + value; break;	1✔
331	case ERR_EMPTYBIT_AND_SER_VER: msg =	1✔
332	"Empty Bit: 1 -> SerVer: " + SERIAL_VERSION_EMPTY_FULL + ", NOT: " + value; break;	1✔
333	case ERR_SINGLEBIT_AND_SER_VER: msg =	1✔
334	"Single Item Bit: 1 -> SerVer: " + SERIAL_VERSION_SINGLE + ", NOT: " + value; break;	1✔
335	case ERR_DOUBLEBIT_AND_PREINTS: msg =	1✔
336	"Double Sketch Bit: 1 -> PreInts: " + PREAMBLE_INTS_DOUBLE + ", NOT: " + value; break;	1✔
337	case ERR_FLOATBIT_AND_PREINTS: msg =	1✔
338	"Double Sketch Bit: 0 -> PreInts: " + PREAMBLE_INTS_FLOAT + ", NOT: " + value; break;	1✔
339	case ERR_UPDATABLEBIT_AND_SER_VER: msg =	1✔
340	"((SerVer == 3) ^ (Updatable Bit)) must = 0."; break;	1✔
341	case ERR_EMPTYBIT_AND_SINGLEBIT: msg =	1✔
342	"Empty flag bit and SingleItem flag bit cannot both be set. Flags: " + value; break;	1✔
343	default: msg = "Unknown error"; break;	×
344	}
345	throw new SketchesArgumentException(msg);	1✔
346	}
347
348	}
349

apache / datasketches-java / #186

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous