@Override public boolean get(Keys keys, ValueStream stream, boolean hydrateValues) throws Exception { BolBuffer streamKeyBuffer = new BolBuffer(); BolBuffer streamValueBuffer = hydrateValues ? new BolBuffer() : null; boolean b = pointTx(keys, -1, -1, streamKeyBuffer, streamValueBuffer, stream, hydrateValues ); stats.gets.increment(); return b; }
BolBuffer feedNext(BolBuffer nextHint) throws Exception { nextRawEntry = scanner.next(new BolBuffer(), nextHint); return nextRawEntry; }
public <R> R get(byte[] key, GetMeta<R> getMeta) throws Exception { writeSemaphore.acquire(); try { Meta m = meta.get(); BolBuffer metaValue = m.get(key, new BolBuffer()); return getMeta.metaValue(metaValue); } finally { writeSemaphore.release(); } }
private static void update(ValueIndex<byte[]> index, boolean delete, int count, int modulo, boolean fsync) throws Exception { BolBuffer rawEntryBuffer = new BolBuffer(); BolBuffer keyBuffer = new BolBuffer(); long timestamp = System.currentTimeMillis(); index.append((stream) -> { for (int i = 0; i < count; i++) { if (i % modulo == 0) { stream.stream(i, UIO.intBytes(i), timestamp, delete, version.incrementAndGet(), UIO.intBytes(i)); } } return true; }, fsync, rawEntryBuffer, keyBuffer); }
@Override public Scanner scanner(boolean pointFrom, byte[] from, byte[] to, BolBuffer entryBuffer, BolBuffer entryKeyBuffer) throws Exception { EntryStream entryStream; growSemaphore.acquire(); try { entryStream = rangeMap(from, to); } finally { growSemaphore.release(); } BolBuffer keyBuffer = new BolBuffer(); return new Scanner() { @Override public BolBuffer next(BolBuffer entryBuffer, BolBuffer nextHint) throws Exception { if (entryStream.hasNext()) { return entryStream.next(entryBuffer, keyBuffer, entryBuffer); } return null; } @Override public void close() throws Exception { entryStream.close(); } }; }
BolBuffer entryKeyBuffer) throws Exception { BolBuffer bbFrom = from == null ? null : new BolBuffer(from); BolBuffer bbTo = to == null ? null : new BolBuffer(to); hashIndexMaxCapacity, hashIndexLongPrecision, new BolBuffer(from), new BolBuffer(), new BolBuffer(), true); } else { fp = scan.getInclusiveStartOfRow(new BolBuffer(from), entryBuffer, entryKeyBuffer, false);
@Override public List<Future<Object>> commit(boolean fsync, boolean waitIfToFarBehind) throws Exception { if (memoryIndex.isEmpty()) { return Collections.emptyList(); } if (corrupt) { throw new LABCorruptedException(); } if (closeRequested.get()) { throw new LABClosedException(""); } if (!internalCommit(fsync, new BolBuffer(), new BolBuffer(), new BolBuffer())) { // grr return Collections.emptyList(); } if (waitIfToFarBehind) { return compact(fsync, minDebt, maxDebt, true); } else { return Collections.singletonList(schedule.submit(() -> compact(fsync, minDebt, maxDebt, false))); } }
return new Leaps(index, new BolBuffer(lastKey.copy()), fpIndex, keys, readable1 -> LongBuffer.wrap(startOfEntryIndex));
@Override public void close(boolean flushUncommited, boolean fsync) throws Exception { heapPressure.close(this); if (!closeRequested.compareAndSet(false, true)) { throw new LABClosedException(""); } if (flushUncommited) { internalCommit(fsync, new BolBuffer(), new BolBuffer(), new BolBuffer()); // grr } synchronized (compactLock) { while (ongoingCompactions.get() > 0) { compactLock.wait(); } } commitSemaphore.acquire(Short.MAX_VALUE); try { memoryIndex.closeReadable(); rangeStripedCompactableIndexes.close(); memoryIndex.destroy(); } finally { commitSemaphore.release(Short.MAX_VALUE); } LOG.debug("Closed {}", this); stats.closed.increment(); }
@Override public boolean rangeScan(byte[] from, byte[] to, ValueStream stream, boolean hydrateValues) throws Exception { BolBuffer streamKeyBuffer = new BolBuffer(); BolBuffer streamValueBuffer = hydrateValues ? new BolBuffer() : null; BolBuffer next = interleaveStream.next(new BolBuffer(), null); if (next == null) { break;
@Override public boolean append(AppendEntries entries, BolBuffer keyBuffer) throws Exception { BolBuffer valueBuffer = new BolBuffer(); // Grrrr AppendEntryStream appendEntryStream = (rawEntryBuffer) -> { BolBuffer key = rawhide.key(rawEntryBuffer, keyBuffer); index.compute(rawEntryBuffer, key, valueBuffer, compute, costChangeInBytes); return true; }; return entries.consume(appendEntryStream); }
@Override public boolean rowScan(ValueStream stream, boolean hydrateValues) throws Exception { BolBuffer streamKeyBuffer = new BolBuffer(); BolBuffer streamValueBuffer = hydrateValues ? new BolBuffer() : null; boolean r = rangeTx(true, -1, InterleaveStream interleaveStream = new InterleaveStream(rawhide, interleavingStreamFeeds); try { BolBuffer rawEntry = new BolBuffer(); while (true) { BolBuffer next = interleaveStream.next(rawEntry, null);
@Override public boolean rangesScan(Ranges ranges, ValueStream stream, boolean hydrateValues) throws Exception { BolBuffer streamKeyBuffer = new BolBuffer(); BolBuffer streamValueBuffer = hydrateValues ? new BolBuffer() : null; boolean r = ranges.ranges((index, from, to) -> { return rangeTx(true, index, false, from, to, -1, -1, try { while (true) { BolBuffer next = interleaveStream.next(new BolBuffer(), null); if (next == null) { break;
int keyLength = readable.readInt(offset); offset += 4; keys[i] = readable.sliceIntoBuffer(offset, keyLength, new BolBuffer()); offset += keyLength; int startOfEntryNumBytes = startOfEntryLength * 8; StartOfEntry startOfEntry = (readable1) -> { BolBuffer sliceIntoBuffer = readable1.sliceIntoBuffer(startOfEntryOffset, startOfEntryNumBytes, new BolBuffer()); return sliceIntoBuffer.asLongBuffer(); }; throw new RuntimeException("Encountered length corruption. "); return new Leaps(index, new BolBuffer(lastKey), fpIndex,keys, startOfEntry);
@Override public BolBuffer pointScan(boolean hashIndexEnabled, byte[] key) throws Exception { BolBuffer entryBuffer = new BolBuffer();