private BitSetNode update(BitSetNode node, long procId) { node = lookupClosestNode(node, procId); assert node != null : "expected node to update procId=" + procId; assert node.contains(procId) : "expected procId=" + procId + " in the node"; node.insertOrUpdate(procId); trackProcIds(procId); return node; }
/** * This method is used when restarting where we need to rebuild the ProcedureStoreTracker. The * {@link #delete(long)} method above assume that the {@link BitSetNode} exists, but when restart * this is not true, as we will read the wal files in reverse order so a delete may come first. */ public void setDeleted(long procId, boolean isDeleted) { BitSetNode node = getOrCreateNode(procId); assert node.contains(procId) : "expected procId=" + procId + " in the node=" + node; node.updateState(procId, isDeleted); trackProcIds(procId); }
private BitSetNode insert(BitSetNode node, long procId) { if (node == null || !node.contains(procId)) { node = getOrCreateNode(procId); } node.insertOrUpdate(procId); trackProcIds(procId); return node; }
public static void storeRestart(ProcedureStore procStore, ProcedureStore.ProcedureLoader loader) throws Exception { procStore.stop(false); procStore.start(procStore.getNumThreads()); procStore.recoverLease(); procStore.load(loader); }
private void setDeletedIfPartial(ProcedureStoreTracker tracker, long procId) { if (tracker.isPartial()) { tracker.setDeleted(procId, true); } }
/** * For the global tracker, we will use this method to build the holdingCleanupTracker, as the * modified flags will be cleared after rolling so we only need to test the deleted flags. * @see #setDeletedIfModifiedInBoth(ProcedureStoreTracker) */ public void setDeletedIfDeletedByThem(ProcedureStoreTracker tracker) { setDeleteIf(tracker, (node, procId) -> node == null || !node.contains(procId) || node.isDeleted(procId) == DeleteState.YES); }
public ProcedureWALFile(FileSystem fs, Path logFile, ProcedureWALHeader header, long startPos, long timestamp) { this.fs = fs; this.header = header; this.logFile = logFile; this.startPos = startPos; this.logSize = startPos; this.timestamp = timestamp; tracker.setPartialFlag(true); }
public void insert(long[] procIds) { for (int i = 0; i < procIds.length; ++i) { insert(procIds[i]); } }
/** * Similar with {@link #setDeletedIfModified(long...)}, but here the {@code procId} are given by * the {@code tracker}. If a procedure is modified by us, and also by the given {@code tracker}, * then we mark it as deleted. * @see #setDeletedIfModified(long...) */ public void setDeletedIfModifiedInBoth(ProcedureStoreTracker tracker) { setDeleteIf(tracker, (node, procId) -> node != null && node.isModified(procId)); }
@Override public void start(int numThreads) throws IOException { if (!setRunning(true)) { return; } this.numThreads = numThreads; }
public boolean canMerge(BitSetNode rightNode) { // Can just compare 'starts' since boundaries are aligned to multiples of BITS_PER_WORD. assert start < rightNode.start; return (rightNode.getEnd() - start) < MAX_NODE_SIZE; }
/** * Resets internal state to same as given {@code tracker}. Does deep copy of the bitmap. */ public void resetTo(ProcedureStoreTracker tracker) { resetTo(tracker, false); }
public boolean isModified(long procId) { int bitmapIndex = getBitmapIndex(procId); int wordIndex = bitmapIndex >> ADDRESS_BITS_PER_WORD; if (wordIndex >= modified.length) { return false; } // The left shift of java only takes care of the lowest several bits(5 for int and 6 for long), // so here we can use bitmapIndex directly, without mod 64 return (modified[wordIndex] & (1L << bitmapIndex)) != 0; }
public boolean canGrow(long procId) { if (procId <= start) { return getEnd() - procId < MAX_NODE_SIZE; } else { return procId - start < MAX_NODE_SIZE; } }
void updateState(long procId, boolean isDeleted) { int bitmapIndex = getBitmapIndex(procId); int wordIndex = bitmapIndex >> ADDRESS_BITS_PER_WORD; long value = (1L << bitmapIndex); modified[wordIndex] |= value; if (isDeleted) { deleted[wordIndex] |= value; } else { deleted[wordIndex] &= ~value; } }
public DeleteState isDeleted(final long procId) { int bitmapIndex = getBitmapIndex(procId); int wordIndex = bitmapIndex >> ADDRESS_BITS_PER_WORD; if (wordIndex >= deleted.length) { return DeleteState.MAYBE; } // The left shift of java only takes care of the lowest several bits(5 for int and 6 for long), // so here we can use bitmapIndex directly, without mod 64 return (deleted[wordIndex] & (1L << bitmapIndex)) != 0 ? DeleteState.YES : DeleteState.NO; }