#153

Build # #153

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/<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/ef869a546c7e93a4d7d1d5a581d079cde611baa2">ef869a546">&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/ef869a546c7e93a4d7d1d5a581d079cde611baa2">ef869a546</a><a href="https://github.com/apache/datasketches-java/commit/ef869a546c7e93a4d7d1d5a581d079cde611baa2">&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/ef869a546c7e93a4d7d1d5a581d079cde611baa2&quot;&gt;ef869a546&lt;/a&gt;&lt;a href=&quot;https://github.com/apache/datasketches-java/commit/ef869a546c7e93a4d7d1d5a581d079cde611baa2&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/apache/datasketches-java/commit/ef869a546c7e93a4d7d1d5a581d079cde611baa2&amp;quot;&amp;gt;&amp;amp;quot;&amp;amp;gt;&am... (continued)

Run Details

33 of 33 new or added lines in 9 files covered. (100.0%)

17905 of 18205 relevant lines covered (98.35%)

0.98 hits per line

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

98.99

/src/main/java/org/apache/datasketches/quantiles/DirectUpdateDoublesSketch.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.quantiles;

import static org.apache.datasketches.quantiles.PreambleUtil.COMBINED_BUFFER;
import static org.apache.datasketches.quantiles.PreambleUtil.EMPTY_FLAG_MASK;
import static org.apache.datasketches.quantiles.PreambleUtil.FLAGS_BYTE;
import static org.apache.datasketches.quantiles.PreambleUtil.MAX_DOUBLE;
import static org.apache.datasketches.quantiles.PreambleUtil.MIN_DOUBLE;
import static org.apache.datasketches.quantiles.PreambleUtil.N_LONG;
import static org.apache.datasketches.quantiles.PreambleUtil.extractFamilyID;
import static org.apache.datasketches.quantiles.PreambleUtil.extractFlags;
import static org.apache.datasketches.quantiles.PreambleUtil.extractK;
import static org.apache.datasketches.quantiles.PreambleUtil.extractN;
import static org.apache.datasketches.quantiles.PreambleUtil.extractPreLongs;
import static org.apache.datasketches.quantiles.PreambleUtil.extractSerVer;
import static org.apache.datasketches.quantiles.PreambleUtil.insertFamilyID;
import static org.apache.datasketches.quantiles.PreambleUtil.insertFlags;
import static org.apache.datasketches.quantiles.PreambleUtil.insertK;
import static org.apache.datasketches.quantiles.PreambleUtil.insertMaxDouble;
import static org.apache.datasketches.quantiles.PreambleUtil.insertMinDouble;
import static org.apache.datasketches.quantiles.PreambleUtil.insertN;
import static org.apache.datasketches.quantiles.PreambleUtil.insertPreLongs;
import static org.apache.datasketches.quantiles.PreambleUtil.insertSerVer;
import static org.apache.datasketches.quantiles.Util.computeBitPattern;

import org.apache.datasketches.Family;
import org.apache.datasketches.SketchesArgumentException;
import org.apache.datasketches.memory.MemoryRequestServer;
import org.apache.datasketches.memory.WritableMemory;

/**
 * Implements the DoublesSketch off-heap.
 *
 * @author Kevin Lang
 * @author Lee Rhodes
 *
 */
final class DirectUpdateDoublesSketch extends DirectUpdateDoublesSketchR {
  MemoryRequestServer memReqSvr = null;


  private DirectUpdateDoublesSketch(final int k) {
    super(k); //Checks k
  }

  /**
   * Obtains a new Direct instance of a DoublesSketch, which may be off-heap.
   *
   * @param k Parameter that controls space usage of sketch and accuracy of estimates.
   * Must be greater than 1 and less than 65536 and a power of 2.
   * @param dstMem the destination Memory that will be initialized to hold the data for this sketch.
   * It must initially be at least (16 * MIN_K + 32) bytes, where MIN_K defaults to 2. As it grows
   * it will request more memory using the MemoryRequest callback.
   * @return a DirectUpdateDoublesSketch
   */
  static DirectUpdateDoublesSketch newInstance(final int k, final WritableMemory dstMem) {
    // must be able to hold at least an empty sketch
    final long memCap = dstMem.getCapacity();
    checkDirectMemCapacity(k, 0, memCap);

    //initialize dstMem
    dstMem.putLong(0, 0L); //clear pre0
    insertPreLongs(dstMem, 2);
    insertSerVer(dstMem, DoublesSketch.DOUBLES_SER_VER);
    insertFamilyID(dstMem, Family.QUANTILES.getID());
    insertFlags(dstMem, EMPTY_FLAG_MASK);
    insertK(dstMem, k);

    if (memCap >= COMBINED_BUFFER) {
      insertN(dstMem, 0L);
      insertMinDouble(dstMem, Double.NaN);
      insertMaxDouble(dstMem, Double.NaN);
    }

    final DirectUpdateDoublesSketch dds = new DirectUpdateDoublesSketch(k);
    dds.mem_ = dstMem;
    return dds;
  }

  /**
   * Wrap this sketch around the given non-compact Memory image of a DoublesSketch.
   *
   * @param srcMem the given non-compact Memory image of a DoublesSketch that may have data
   * @return a sketch that wraps the given srcMem
   */
  static DirectUpdateDoublesSketch wrapInstance(final WritableMemory srcMem) {
    final long memCap = srcMem.getCapacity();

    final int preLongs = extractPreLongs(srcMem);
    final int serVer = extractSerVer(srcMem);
    final int familyID = extractFamilyID(srcMem);
    final int flags = extractFlags(srcMem);
    final int k = extractK(srcMem);

    final boolean empty = (flags & EMPTY_FLAG_MASK) > 0; //Preamble flags empty state
    final long n = empty ? 0 : extractN(srcMem);

    //VALIDITY CHECKS
    checkPreLongs(preLongs);
    Util.checkFamilyID(familyID);
    DoublesUtil.checkDoublesSerVer(serVer, MIN_DIRECT_DOUBLES_SER_VER);
    checkDirectFlags(flags); //Cannot be compact
    Util.checkK(k);
    checkCompact(serVer, flags);
    checkDirectMemCapacity(k, n, memCap);
    checkEmptyAndN(empty, n);

    final DirectUpdateDoublesSketch dds = new DirectUpdateDoublesSketch(k);
    dds.mem_ = srcMem;
    return dds;
  }

  @Override
  public void update(final double dataItem) {
    if (Double.isNaN(dataItem)) { return; }

    final int curBBCount = getBaseBufferCount();
    final int newBBCount = curBBCount + 1; //derived, not stored

    //must check memory capacity before we put anything in it
    final int combBufItemCap = getCombinedBufferItemCapacity();
    if (newBBCount > combBufItemCap) {
      //only changes combinedBuffer when it is only a base buffer
      mem_ = growCombinedMemBuffer(2 * getK());
    }

    final long curN = getN();
    final long newN = curN + 1;

    if (curN == 0) { //set min and max values
      putMaxValue(dataItem);
      putMinValue(dataItem);
    } else {
      if (dataItem > getMaxValue()) { putMaxValue(dataItem); }
      if (dataItem < getMinValue()) { putMinValue(dataItem); }
    }

    mem_.putDouble(COMBINED_BUFFER + ((long) curBBCount * Double.BYTES), dataItem); //put the item
    mem_.putByte(FLAGS_BYTE, (byte) 0); //not compact, not ordered, not empty

    if (newBBCount == (2 * k_)) { //Propagate
      // make sure there will be enough levels for the propagation
      final int curMemItemCap = getCombinedBufferItemCapacity();
      final int itemSpaceNeeded = DoublesUpdateImpl.getRequiredItemCapacity(k_, newN);

      //check mem has capacity to accommodate new level
      if (itemSpaceNeeded > curMemItemCap) {
        // copies base buffer plus old levels, adds space for new level
        mem_ = growCombinedMemBuffer(itemSpaceNeeded);
      }

      // sort base buffer via accessor which modifies the underlying base buffer,
      // then use as one of the inputs to propagate-carry
      final DoublesSketchAccessor bbAccessor = DoublesSketchAccessor.wrap(this, true);
      bbAccessor.sort();

      final long newBitPattern = DoublesUpdateImpl.inPlacePropagateCarry(
              0, // starting level
              null,
              bbAccessor,
              true,
              k_,
              DoublesSketchAccessor.wrap(this, true),
              getBitPattern()
      );

      assert newBitPattern == computeBitPattern(k_, newN); // internal consistency check
      //bit pattern on direct is always derived, no need to save it.
    }
    putN(newN);
  }

  @Override
  public void reset() {
    if (mem_.getCapacity() >= COMBINED_BUFFER) {
      mem_.putByte(FLAGS_BYTE, (byte) EMPTY_FLAG_MASK); //not compact, not ordered
      mem_.putLong(N_LONG, 0L);
      mem_.putDouble(MIN_DOUBLE, Double.NaN);
      mem_.putDouble(MAX_DOUBLE, Double.NaN);
    }
  }

  //Restricted overrides
  //Puts

  @Override
  void putMinValue(final double minValue) {
    assert (mem_.getCapacity() >= COMBINED_BUFFER);
    mem_.putDouble(MIN_DOUBLE, minValue);
  }

  @Override
  void putMaxValue(final double maxValue) {
    assert (mem_.getCapacity() >= COMBINED_BUFFER);
    mem_.putDouble(MAX_DOUBLE, maxValue);
  }

  @Override
  void putN(final long n) {
    assert (mem_.getCapacity() >= COMBINED_BUFFER);
    mem_.putLong(N_LONG, n);
  }

  @Override
  void putCombinedBuffer(final double[] combinedBuffer) {
    mem_.putDoubleArray(COMBINED_BUFFER, combinedBuffer, 0, combinedBuffer.length);
  }

  @Override
  void putBaseBufferCount(final int baseBufferCount) {
    //intentionally a no-op, not kept on-heap, always derived.
  }

  @Override
  void putBitPattern(final long bitPattern) {
    //intentionally a no-op, not kept on-heap, always derived.
  }

  @Override
  double[] growCombinedBuffer(final int curCombBufItemCap, final int itemSpaceNeeded) {
    mem_ = growCombinedMemBuffer(itemSpaceNeeded);
    // copy out any data that was there
    final double[] newCombBuf = new double[itemSpaceNeeded];
    mem_.getDoubleArray(COMBINED_BUFFER, newCombBuf, 0, curCombBufItemCap);
    return newCombBuf;
  }

  //Direct supporting methods

  private WritableMemory growCombinedMemBuffer(final int itemSpaceNeeded) {
    final long memBytes = mem_.getCapacity();
    final int needBytes = (itemSpaceNeeded << 3) + COMBINED_BUFFER; //+ preamble + min & max
    assert needBytes > memBytes;

    memReqSvr = (memReqSvr == null) ? mem_.getMemoryRequestServer() : memReqSvr;
    if (memReqSvr == null) {
      throw new SketchesArgumentException(
          "A request for more memory has been denied, "
          + "or a default MemoryRequestServer has not been provided. Must abort. ");
    }

    final WritableMemory newMem = memReqSvr.request(mem_, needBytes);

    mem_.copyTo(0, newMem, 0, memBytes);

    memReqSvr.requestClose(mem_, newMem);

    return newMem;
  }
}

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.quantiles;
21
22	import static org.apache.datasketches.quantiles.PreambleUtil.COMBINED_BUFFER;
23	import static org.apache.datasketches.quantiles.PreambleUtil.EMPTY_FLAG_MASK;
24	import static org.apache.datasketches.quantiles.PreambleUtil.FLAGS_BYTE;
25	import static org.apache.datasketches.quantiles.PreambleUtil.MAX_DOUBLE;
26	import static org.apache.datasketches.quantiles.PreambleUtil.MIN_DOUBLE;
27	import static org.apache.datasketches.quantiles.PreambleUtil.N_LONG;
28	import static org.apache.datasketches.quantiles.PreambleUtil.extractFamilyID;
29	import static org.apache.datasketches.quantiles.PreambleUtil.extractFlags;
30	import static org.apache.datasketches.quantiles.PreambleUtil.extractK;
31	import static org.apache.datasketches.quantiles.PreambleUtil.extractN;
32	import static org.apache.datasketches.quantiles.PreambleUtil.extractPreLongs;
33	import static org.apache.datasketches.quantiles.PreambleUtil.extractSerVer;
34	import static org.apache.datasketches.quantiles.PreambleUtil.insertFamilyID;
35	import static org.apache.datasketches.quantiles.PreambleUtil.insertFlags;
36	import static org.apache.datasketches.quantiles.PreambleUtil.insertK;
37	import static org.apache.datasketches.quantiles.PreambleUtil.insertMaxDouble;
38	import static org.apache.datasketches.quantiles.PreambleUtil.insertMinDouble;
39	import static org.apache.datasketches.quantiles.PreambleUtil.insertN;
40	import static org.apache.datasketches.quantiles.PreambleUtil.insertPreLongs;
41	import static org.apache.datasketches.quantiles.PreambleUtil.insertSerVer;
42	import static org.apache.datasketches.quantiles.Util.computeBitPattern;
43
44	import org.apache.datasketches.Family;
45	import org.apache.datasketches.SketchesArgumentException;
46	import org.apache.datasketches.memory.MemoryRequestServer;
47	import org.apache.datasketches.memory.WritableMemory;
48
49	/**
50	* Implements the DoublesSketch off-heap.
51	*
52	* @author Kevin Lang
53	* @author Lee Rhodes
54	*
55	*/
56	final class DirectUpdateDoublesSketch extends DirectUpdateDoublesSketchR {	1✔
57	MemoryRequestServer memReqSvr = null;	1✔
58
59
60	private DirectUpdateDoublesSketch(final int k) {
61	super(k); //Checks k	1✔
62	}	1✔
63
64	/**
65	* Obtains a new Direct instance of a DoublesSketch, which may be off-heap.
66	*
67	* @param k Parameter that controls space usage of sketch and accuracy of estimates.
68	* Must be greater than 1 and less than 65536 and a power of 2.
69	* @param dstMem the destination Memory that will be initialized to hold the data for this sketch.
70	* It must initially be at least (16 * MIN_K + 32) bytes, where MIN_K defaults to 2. As it grows
71	* it will request more memory using the MemoryRequest callback.
72	* @return a DirectUpdateDoublesSketch
73	*/
74	static DirectUpdateDoublesSketch newInstance(final int k, final WritableMemory dstMem) {
75	// must be able to hold at least an empty sketch
76	final long memCap = dstMem.getCapacity();	1✔
77	checkDirectMemCapacity(k, 0, memCap);	1✔
78
79	//initialize dstMem
80	dstMem.putLong(0, 0L); //clear pre0	1✔
81	insertPreLongs(dstMem, 2);	1✔
82	insertSerVer(dstMem, DoublesSketch.DOUBLES_SER_VER);	1✔
83	insertFamilyID(dstMem, Family.QUANTILES.getID());	1✔
84	insertFlags(dstMem, EMPTY_FLAG_MASK);	1✔
85	insertK(dstMem, k);	1✔
86
87	if (memCap >= COMBINED_BUFFER) {	1✔
88	insertN(dstMem, 0L);	1✔
89	insertMinDouble(dstMem, Double.NaN);	1✔
90	insertMaxDouble(dstMem, Double.NaN);	1✔
91	}
92
93	final DirectUpdateDoublesSketch dds = new DirectUpdateDoublesSketch(k);	1✔
94	dds.mem_ = dstMem;	1✔
95	return dds;	1✔
96	}
97
98	/**
99	* Wrap this sketch around the given non-compact Memory image of a DoublesSketch.
100	*
101	* @param srcMem the given non-compact Memory image of a DoublesSketch that may have data
102	* @return a sketch that wraps the given srcMem
103	*/
104	static DirectUpdateDoublesSketch wrapInstance(final WritableMemory srcMem) {
105	final long memCap = srcMem.getCapacity();	1✔
106
107	final int preLongs = extractPreLongs(srcMem);	1✔
108	final int serVer = extractSerVer(srcMem);	1✔
109	final int familyID = extractFamilyID(srcMem);	1✔
110	final int flags = extractFlags(srcMem);	1✔
111	final int k = extractK(srcMem);	1✔
112
113	final boolean empty = (flags & EMPTY_FLAG_MASK) > 0; //Preamble flags empty state	1✔
114	final long n = empty ? 0 : extractN(srcMem);	1✔
115
116	//VALIDITY CHECKS
117	checkPreLongs(preLongs);	1✔
118	Util.checkFamilyID(familyID);	1✔
119	DoublesUtil.checkDoublesSerVer(serVer, MIN_DIRECT_DOUBLES_SER_VER);	1✔
120	checkDirectFlags(flags); //Cannot be compact	1✔
121	Util.checkK(k);	1✔
122	checkCompact(serVer, flags);	1✔
123	checkDirectMemCapacity(k, n, memCap);	1✔
124	checkEmptyAndN(empty, n);	1✔
125
126	final DirectUpdateDoublesSketch dds = new DirectUpdateDoublesSketch(k);	1✔
127	dds.mem_ = srcMem;	1✔
128	return dds;	1✔
129	}
130
131	@Override
132	public void update(final double dataItem) {
133	if (Double.isNaN(dataItem)) { return; }	1✔
134
135	final int curBBCount = getBaseBufferCount();	1✔
136	final int newBBCount = curBBCount + 1; //derived, not stored	1✔
137
138	//must check memory capacity before we put anything in it
139	final int combBufItemCap = getCombinedBufferItemCapacity();	1✔
140	if (newBBCount > combBufItemCap) {	1✔
141	//only changes combinedBuffer when it is only a base buffer
142	mem_ = growCombinedMemBuffer(2 * getK());	1✔
143	}
144
145	final long curN = getN();	1✔
146	final long newN = curN + 1;	1✔
147
148	if (curN == 0) { //set min and max values	1✔
149	putMaxValue(dataItem);	1✔
150	putMinValue(dataItem);	1✔
151	} else {
152	if (dataItem > getMaxValue()) { putMaxValue(dataItem); }	1✔
153	if (dataItem < getMinValue()) { putMinValue(dataItem); }	1✔
154	}
155
156	mem_.putDouble(COMBINED_BUFFER + ((long) curBBCount * Double.BYTES), dataItem); //put the item	1✔
157	mem_.putByte(FLAGS_BYTE, (byte) 0); //not compact, not ordered, not empty	1✔
158
159	if (newBBCount == (2 * k_)) { //Propagate	1✔
160	// make sure there will be enough levels for the propagation
161	final int curMemItemCap = getCombinedBufferItemCapacity();	1✔
162	final int itemSpaceNeeded = DoublesUpdateImpl.getRequiredItemCapacity(k_, newN);	1✔
163
164	//check mem has capacity to accommodate new level
165	if (itemSpaceNeeded > curMemItemCap) {	1✔
166	// copies base buffer plus old levels, adds space for new level
167	mem_ = growCombinedMemBuffer(itemSpaceNeeded);	1✔
168	}
169
170	// sort base buffer via accessor which modifies the underlying base buffer,
171	// then use as one of the inputs to propagate-carry
172	final DoublesSketchAccessor bbAccessor = DoublesSketchAccessor.wrap(this, true);	1✔
173	bbAccessor.sort();	1✔
174
175	final long newBitPattern = DoublesUpdateImpl.inPlacePropagateCarry(	1✔
176	0, // starting level
177	null,
178	bbAccessor,
179	true,
180	k_,
181	DoublesSketchAccessor.wrap(this, true),	1✔
182	getBitPattern()	1✔
183	);
184
185	assert newBitPattern == computeBitPattern(k_, newN); // internal consistency check	1✔
186	//bit pattern on direct is always derived, no need to save it.
187	}
188	putN(newN);	1✔
189	}	1✔
190
191	@Override
192	public void reset() {
193	if (mem_.getCapacity() >= COMBINED_BUFFER) {	1✔
194	mem_.putByte(FLAGS_BYTE, (byte) EMPTY_FLAG_MASK); //not compact, not ordered	1✔
195	mem_.putLong(N_LONG, 0L);	1✔
196	mem_.putDouble(MIN_DOUBLE, Double.NaN);	1✔
197	mem_.putDouble(MAX_DOUBLE, Double.NaN);	1✔
198	}
199	}	1✔
200
201	//Restricted overrides
202	//Puts
203
204	@Override
205	void putMinValue(final double minValue) {
206	assert (mem_.getCapacity() >= COMBINED_BUFFER);	1✔
207	mem_.putDouble(MIN_DOUBLE, minValue);	1✔
208	}	1✔
209
210	@Override
211	void putMaxValue(final double maxValue) {
212	assert (mem_.getCapacity() >= COMBINED_BUFFER);	1✔
213	mem_.putDouble(MAX_DOUBLE, maxValue);	1✔
214	}	1✔
215
216	@Override
217	void putN(final long n) {
218	assert (mem_.getCapacity() >= COMBINED_BUFFER);	1✔
219	mem_.putLong(N_LONG, n);	1✔
220	}	1✔
221
222	@Override
223	void putCombinedBuffer(final double[] combinedBuffer) {
224	mem_.putDoubleArray(COMBINED_BUFFER, combinedBuffer, 0, combinedBuffer.length);	1✔
225	}	1✔
226
227	@Override
228	void putBaseBufferCount(final int baseBufferCount) {
229	//intentionally a no-op, not kept on-heap, always derived.
230	}	1✔
231
232	@Override
233	void putBitPattern(final long bitPattern) {
234	//intentionally a no-op, not kept on-heap, always derived.
235	}	1✔
236
237	@Override
238	double[] growCombinedBuffer(final int curCombBufItemCap, final int itemSpaceNeeded) {
239	mem_ = growCombinedMemBuffer(itemSpaceNeeded);	1✔
240	// copy out any data that was there
241	final double[] newCombBuf = new double[itemSpaceNeeded];	1✔
242	mem_.getDoubleArray(COMBINED_BUFFER, newCombBuf, 0, curCombBufItemCap);	1✔
243	return newCombBuf;	1✔
244	}
245
246	//Direct supporting methods
247
248	private WritableMemory growCombinedMemBuffer(final int itemSpaceNeeded) {
249	final long memBytes = mem_.getCapacity();	1✔
250	final int needBytes = (itemSpaceNeeded << 3) + COMBINED_BUFFER; //+ preamble + min & max	1✔
251	assert needBytes > memBytes;	1✔
252
253	memReqSvr = (memReqSvr == null) ? mem_.getMemoryRequestServer() : memReqSvr;	1✔
254	if (memReqSvr == null) {	1✔
255	throw new SketchesArgumentException(	×
256	"A request for more memory has been denied, "
257	+ "or a default MemoryRequestServer has not been provided. Must abort. ");
258	}
259
260	final WritableMemory newMem = memReqSvr.request(mem_, needBytes);	1✔
261
262	mem_.copyTo(0, newMem, 0, memBytes);	1✔
263
264	memReqSvr.requestClose(mem_, newMem);	1✔
265
266	return newMem;	1✔
267	}
268	}

apache / datasketches-java / #153

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