/** Same as {@link #copy(Reader, int, Mutable, int, int, int)} but using a pre-allocated buffer. */ static void copy(Reader src, int srcPos, Mutable dest, int destPos, int len, long[] buf) { assert buf.length > 0; int remaining = 0; while (len > 0) { final int read = src.get(srcPos, buf, remaining, Math.min(len, buf.length - remaining)); assert read > 0; srcPos += read; len -= read; remaining += read; final int written = dest.set(destPos, buf, 0, remaining); assert written > 0; destPos += written; if (written < remaining) { System.arraycopy(buf, written, buf, 0, remaining - written); } remaining -= written; } while (remaining > 0) { final int written = dest.set(destPos, buf, 0, remaining); destPos += written; remaining -= written; System.arraycopy(buf, written, buf, 0, remaining); } }
@Override public Collection<Accountable> getChildResources() { List<Accountable> resources = new ArrayList<>(); long docBaseDeltaBytes = RamUsageEstimator.shallowSizeOf(docBasesDeltas); for (PackedInts.Reader r : docBasesDeltas) { docBaseDeltaBytes += r.ramBytesUsed(); } resources.add(Accountables.namedAccountable("doc base deltas", docBaseDeltaBytes)); long startPointerDeltaBytes = RamUsageEstimator.shallowSizeOf(startPointersDeltas); for (PackedInts.Reader r : startPointersDeltas) { startPointerDeltaBytes += r.ramBytesUsed(); } resources.add(Accountables.namedAccountable("start pointer deltas", startPointerDeltaBytes)); return Collections.unmodifiableList(resources); }
/** * Copy <code>src[srcPos:srcPos+len]</code> into * <code>dest[destPos:destPos+len]</code> using at most <code>mem</code> * bytes. */ public static void copy(Reader src, int srcPos, Mutable dest, int destPos, int len, int mem) { assert srcPos + len <= src.size(); assert destPos + len <= dest.size(); final int capacity = mem >>> 3; if (capacity == 0) { for (int i = 0; i < len; ++i) { dest.set(destPos++, src.get(srcPos++)); } } else if (len > 0) { // use bulk operations final long[] buf = new long[Math.min(capacity, len)]; copy(src, srcPos, dest, destPos, len, buf); } }
/** * Copy <code>src[srcPos:srcPos+len]</code> into * <code>dest[destPos:destPos+len]</code> using at most <code>mem</code> * bytes. */ public static void copy(Reader src, int srcPos, Mutable dest, int destPos, int len, int mem) { assert srcPos + len <= src.size(); assert destPos + len <= dest.size(); final int capacity = mem >>> 3; if (capacity == 0) { for (int i = 0; i < len; ++i) { dest.set(destPos++, src.get(srcPos++)); } } else if (len > 0) { // use bulk operations final long[] buf = new long[Math.min(capacity, len)]; copy(src, srcPos, dest, destPos, len, buf); } }
/** * Copy <code>src[srcPos:srcPos+len]</code> into * <code>dest[destPos:destPos+len]</code> using at most <code>mem</code> * bytes. */ public static void copy(Reader src, int srcPos, Mutable dest, int destPos, int len, int mem) { assert srcPos + len <= src.size(); assert destPos + len <= dest.size(); final int capacity = mem >>> 3; if (capacity == 0) { for (int i = 0; i < len; ++i) { dest.set(destPos++, src.get(srcPos++)); } } else if (len > 0) { // use bulk operations final long[] buf = new long[Math.min(capacity, len)]; copy(src, srcPos, dest, destPos, len, buf); } }
@Override public long ramBytesUsed() { long res = BASE_RAM_BYTES_USED; res += RamUsageEstimator.shallowSizeOf(docBasesDeltas); for (PackedInts.Reader r : docBasesDeltas) { res += r.ramBytesUsed(); } res += RamUsageEstimator.shallowSizeOf(startPointersDeltas); for (PackedInts.Reader r : startPointersDeltas) { res += r.ramBytesUsed(); } res += RamUsageEstimator.sizeOf(docBases); res += RamUsageEstimator.sizeOf(startPointers); res += RamUsageEstimator.sizeOf(avgChunkDocs); res += RamUsageEstimator.sizeOf(avgChunkSizes); return res; }
@Override public long ramBytesUsed() { long res = BASE_RAM_BYTES_USED; res += RamUsageEstimator.shallowSizeOf(docBasesDeltas); for (PackedInts.Reader r : docBasesDeltas) { res += r.ramBytesUsed(); } res += RamUsageEstimator.shallowSizeOf(startPointersDeltas); for (PackedInts.Reader r : startPointersDeltas) { res += r.ramBytesUsed(); } res += RamUsageEstimator.sizeOf(docBases); res += RamUsageEstimator.sizeOf(startPointers); res += RamUsageEstimator.sizeOf(avgChunkDocs); res += RamUsageEstimator.sizeOf(avgChunkSizes); return res; }
@Override public long ramBytesUsed() { long res = BASE_RAM_BYTES_USED; res += RamUsageEstimator.shallowSizeOf(docBasesDeltas); for (PackedInts.Reader r : docBasesDeltas) { res += r.ramBytesUsed(); } res += RamUsageEstimator.shallowSizeOf(startPointersDeltas); for (PackedInts.Reader r : startPointersDeltas) { res += r.ramBytesUsed(); } res += RamUsageEstimator.sizeOf(docBases); res += RamUsageEstimator.sizeOf(startPointers); res += RamUsageEstimator.sizeOf(avgChunkDocs); res += RamUsageEstimator.sizeOf(avgChunkSizes); return res; }
/** * Copy <code>src[srcPos:srcPos+len]</code> into * <code>dest[destPos:destPos+len]</code> using at most <code>mem</code> * bytes. */ public static void copy(Reader src, int srcPos, Mutable dest, int destPos, int len, int mem) { assert srcPos + len <= src.size(); assert destPos + len <= dest.size(); final int capacity = mem >>> 3; if (capacity == 0) { for (int i = 0; i < len; ++i) { dest.set(destPos++, src.get(srcPos++)); } } else if (len > 0) { // use bulk operations final long[] buf = new long[Math.min(capacity, len)]; copy(src, srcPos, dest, destPos, len, buf); } }
@Override public long ramBytesUsed() { long size = BASE_RAM_BYTES_USED; if (bytesArray != null) { size += bytesArray.length; } else { size += bytes.ramBytesUsed(); } if (packed) { size += nodeRefToAddress.ramBytesUsed(); } else if (nodeAddress != null) { size += nodeAddress.ramBytesUsed(); size += inCounts.ramBytesUsed(); } size += cachedArcsBytesUsed; return size; }
@Override public long ramBytesUsed() { long size = BASE_RAM_BYTES_USED; if (bytesArray != null) { size += bytesArray.length; } else { size += bytes.ramBytesUsed(); } if (packed) { size += nodeRefToAddress.ramBytesUsed(); } else if (nodeAddress != null) { size += nodeAddress.ramBytesUsed(); size += inCounts.ramBytesUsed(); } size += cachedArcsBytesUsed; return size; }
@Override public long ramBytesUsed() { long res = BASE_RAM_BYTES_USED; res += RamUsageEstimator.shallowSizeOf(docBasesDeltas); for (PackedInts.Reader r : docBasesDeltas) { res += r.ramBytesUsed(); } res += RamUsageEstimator.shallowSizeOf(startPointersDeltas); for (PackedInts.Reader r : startPointersDeltas) { res += r.ramBytesUsed(); } res += RamUsageEstimator.sizeOf(docBases); res += RamUsageEstimator.sizeOf(startPointers); res += RamUsageEstimator.sizeOf(avgChunkDocs); res += RamUsageEstimator.sizeOf(avgChunkSizes); return res; }
@Override public Collection<Accountable> getChildResources() { List<Accountable> resources = new ArrayList<>(); long docBaseDeltaBytes = RamUsageEstimator.shallowSizeOf(docBasesDeltas); for (PackedInts.Reader r : docBasesDeltas) { docBaseDeltaBytes += r.ramBytesUsed(); } resources.add(Accountables.namedAccountable("doc base deltas", docBaseDeltaBytes)); long startPointerDeltaBytes = RamUsageEstimator.shallowSizeOf(startPointersDeltas); for (PackedInts.Reader r : startPointersDeltas) { startPointerDeltaBytes += r.ramBytesUsed(); } resources.add(Accountables.namedAccountable("start pointer deltas", startPointerDeltaBytes)); return Collections.unmodifiableList(resources); }
@Override public Collection<Accountable> getChildResources() { List<Accountable> resources = new ArrayList<>(); long docBaseDeltaBytes = RamUsageEstimator.shallowSizeOf(docBasesDeltas); for (PackedInts.Reader r : docBasesDeltas) { docBaseDeltaBytes += r.ramBytesUsed(); } resources.add(Accountables.namedAccountable("doc base deltas", docBaseDeltaBytes)); long startPointerDeltaBytes = RamUsageEstimator.shallowSizeOf(startPointersDeltas); for (PackedInts.Reader r : startPointersDeltas) { startPointerDeltaBytes += r.ramBytesUsed(); } resources.add(Accountables.namedAccountable("start pointer deltas", startPointerDeltaBytes)); return resources; }
private int relativeChunk(int block, int relativeDoc) { int lo = 0, hi = docBasesDeltas[block].size() - 1; while (lo <= hi) { final int mid = (lo + hi) >>> 1; final int midValue = relativeDocBase(block, mid); if (midValue == relativeDoc) { return mid; } else if (midValue < relativeDoc) { lo = mid + 1; } else { hi = mid - 1; } } return hi; }
@Override public Collection<Accountable> getChildResources() { List<Accountable> resources = new ArrayList<>(); long docBaseDeltaBytes = RamUsageEstimator.shallowSizeOf(docBasesDeltas); for (PackedInts.Reader r : docBasesDeltas) { docBaseDeltaBytes += r.ramBytesUsed(); } resources.add(Accountables.namedAccountable("doc base deltas", docBaseDeltaBytes)); long startPointerDeltaBytes = RamUsageEstimator.shallowSizeOf(startPointersDeltas); for (PackedInts.Reader r : startPointersDeltas) { startPointerDeltaBytes += r.ramBytesUsed(); } resources.add(Accountables.namedAccountable("start pointer deltas", startPointerDeltaBytes)); return Collections.unmodifiableList(resources); }
private int relativeChunk(int block, int relativeDoc) { int lo = 0, hi = docBasesDeltas[block].size() - 1; while (lo <= hi) { final int mid = (lo + hi) >>> 1; final int midValue = relativeDocBase(block, mid); if (midValue == relativeDoc) { return mid; } else if (midValue < relativeDoc) { lo = mid + 1; } else { hi = mid - 1; } } return hi; }
private int relativeChunk(int block, int relativeDoc) { int lo = 0, hi = docBasesDeltas[block].size() - 1; while (lo <= hi) { final int mid = (lo + hi) >>> 1; final int midValue = relativeDocBase(block, mid); if (midValue == relativeDoc) { return mid; } else if (midValue < relativeDoc) { lo = mid + 1; } else { hi = mid - 1; } } return hi; }
/** * Bulk get: read at least one and at most <code>len</code> longs starting * from <code>index</code> into <code>arr[off:off+len]</code> and return * the actual number of values that have been read. */ public int get(int index, long[] arr, int off, int len) { assert len > 0 : "len must be > 0 (got " + len + ")"; assert index >= 0 && index < size(); assert off + len <= arr.length; final int gets = Math.min(size() - index, len); for (int i = index, o = off, end = index + gets; i < end; ++i, ++o) { arr[o] = get(i); } return gets; }
@Override public Collection<Accountable> getChildResources() { List<Accountable> resources = new ArrayList<>(); long docBaseDeltaBytes = RamUsageEstimator.shallowSizeOf(docBasesDeltas); for (PackedInts.Reader r : docBasesDeltas) { docBaseDeltaBytes += r.ramBytesUsed(); } resources.add(Accountables.namedAccountable("doc base deltas", docBaseDeltaBytes)); long startPointerDeltaBytes = RamUsageEstimator.shallowSizeOf(startPointersDeltas); for (PackedInts.Reader r : startPointersDeltas) { startPointerDeltaBytes += r.ramBytesUsed(); } resources.add(Accountables.namedAccountable("start pointer deltas", startPointerDeltaBytes)); return Collections.unmodifiableList(resources); }