public void resetTo(final ProcedureStoreTracker tracker, final boolean resetDelete) { this.partial = tracker.partial; this.minUpdatedProcId = tracker.minUpdatedProcId; this.maxUpdatedProcId = tracker.maxUpdatedProcId; this.keepDeletes = tracker.keepDeletes; for (Map.Entry<Long, BitSetNode> entry : tracker.map.entrySet()) { map.put(entry.getKey(), new BitSetNode(entry.getValue(), resetDelete)); } }
public void delete(long procId) { Map.Entry<Long, BitSetNode> entry = map.floorEntry(procId); assert entry != null : "expected node to delete procId=" + procId; BitSetNode node = entry.getValue(); assert node.contains(procId) : "expected procId in the node"; node.delete(procId); if (!keepDeletes && node.isEmpty()) { // TODO: RESET if (map.size() == 1) map.remove(entry.getKey()); } trackProcIds(procId); }
/** * If {@link #partial} is false, returns state from the bitmap. If no state is found for * {@code procId}, returns YES. * If partial is true, tracker doesn't have complete view of system state, so it returns MAYBE * if there is no update for the procedure or if it doesn't have a state in bitmap. Otherwise, * returns state from the bitmap. */ public DeleteState isDeleted(long procId) { Map.Entry<Long, BitSetNode> entry = map.floorEntry(procId); if (entry != null && entry.getValue().contains(procId)) { BitSetNode node = entry.getValue(); DeleteState state = node.isDeleted(procId); return partial && !node.isUpdated(procId) ? DeleteState.MAYBE : state; } return partial ? DeleteState.MAYBE : DeleteState.YES; }
if (leftEntry != null) { leftNode = leftEntry.getValue(); if (leftNode.contains(procId)) { return leftNode; leftCanGrow = leftNode.canGrow(procId); if (rightEntry != null) { rightNode = rightEntry.getValue(); rightCanGrow = rightNode.canGrow(procId); if (leftNode != null) { if (leftNode.canMerge(rightNode)) { if ((procId - leftNode.getEnd()) <= (rightNode.getStart() - procId)) { BitSetNode node = new BitSetNode(procId, partial); map.put(node.getStart(), node); return node;
if (leftEntry != null) { leftNode = leftEntry.getValue(); if (leftNode.contains(procId)) { return leftNode; leftCanGrow = leftNode.canGrow(procId); if (rightEntry != null) { rightNode = rightEntry.getValue(); rightCanGrow = rightNode.canGrow(procId); if (leftNode != null) { if (leftNode.canMerge(rightNode)) { if ((procId - leftNode.getEnd()) <= (rightNode.getStart() - procId)) { return growNode(leftNode, procId); BitSetNode node = new BitSetNode(procId, partial); map.put(node.getStart(), node); return node;
public void grow(final long procId) { int delta, offset; if (procId < start) { // add to head long newStart = alignDown(procId); delta = (int)(start - newStart) >> ADDRESS_BITS_PER_WORD; offset = delta; start = newStart; } else { // Add to tail long newEnd = alignUp(procId + 1); delta = (int)(newEnd - getEnd()) >> ADDRESS_BITS_PER_WORD; offset = 0; } long[] newBitmap; int oldSize = updated.length; newBitmap = new long[oldSize + delta]; for (int i = 0; i < newBitmap.length; ++i) { newBitmap[i] = 0; } System.arraycopy(updated, 0, newBitmap, offset, oldSize); updated = newBitmap; newBitmap = new long[deleted.length + delta]; for (int i = 0; i < newBitmap.length; ++i) { newBitmap[i] = partial ? 0 : WORD_MASK; } System.arraycopy(deleted, 0, newBitmap, offset, oldSize); deleted = newBitmap; }
public void grow(final long procId) { int delta, offset; if (procId < start) { // add to head long newStart = alignDown(procId); delta = (int)(start - newStart) >> ADDRESS_BITS_PER_WORD; offset = delta; start = newStart; } else { // Add to tail long newEnd = alignUp(procId + 1); delta = (int)(newEnd - getEnd()) >> ADDRESS_BITS_PER_WORD; offset = 0; } long[] newBitmap; int oldSize = updated.length; newBitmap = new long[oldSize + delta]; for (int i = 0; i < newBitmap.length; ++i) { newBitmap[i] = 0; } System.arraycopy(updated, 0, newBitmap, offset, oldSize); updated = newBitmap; newBitmap = new long[deleted.length + delta]; for (int i = 0; i < newBitmap.length; ++i) { newBitmap[i] = partial ? 0 : WORD_MASK; } System.arraycopy(deleted, 0, newBitmap, offset, oldSize); deleted = newBitmap; }
/** * @param active list of active proc ids. To mark them as non-deleted, since by default a proc * id is always marked deleted. */ BitSetNode buildBitSetNode(long[] active, long[] updated, long[] deleted) { BitSetNode bitSetNode = new BitSetNode(0L, false); for (long i : active) { bitSetNode.update(i); } bitSetNode.resetUpdates(); for (long i : updated) { bitSetNode.update(i); } for (long i : deleted) { bitSetNode.delete(i); } return bitSetNode; }
public void setDeletedIfSet(final ProcedureStoreTracker tracker) { BitSetNode trackerNode = null; for (BitSetNode node: map.values()) { final long minProcId = node.getStart(); final long maxProcId = node.getEnd(); for (long procId = minProcId; procId <= maxProcId; ++procId) { if (!node.isUpdated(procId)) continue; trackerNode = tracker.lookupClosestNode(trackerNode, procId); if (trackerNode == null || !trackerNode.contains(procId) || trackerNode.isUpdated(procId)) { // the procedure was removed or updated node.delete(procId); } } } }
boolean isDeleted(BitSetNode n, long procId) { return n.isDeleted(procId) == ProcedureStoreTracker.DeleteState.YES; }
@InterfaceAudience.Private public void setDeleted(final long procId, final boolean isDeleted) { BitSetNode node = getOrCreateNode(procId); assert node.contains(procId) : "expected procId=" + procId + " in the node=" + node; node.updateState(procId, isDeleted); }
public void insert(long procId) { BitSetNode node = getOrCreateNode(procId); node.update(procId); trackProcIds(procId); }
public BitSetNode(final long procId, final boolean partial) { start = alignDown(procId); int count = 1; updated = new long[count]; deleted = new long[count]; for (int i = 0; i < count; ++i) { updated[i] = 0; deleted[i] = partial ? 0 : WORD_MASK; } this.partial = partial; updateState(procId, false); }
public static BitSetNode convert(ProcedureProtos.ProcedureStoreTracker.TrackerNode data) { long start = data.getStartId(); int size = data.getUpdatedCount(); long[] updated = new long[size]; long[] deleted = new long[size]; for (int i = 0; i < size; ++i) { updated[i] = data.getUpdated(i); deleted[i] = data.getDeleted(i); } return new BitSetNode(start, updated, deleted); }
public DeleteState isDeleted(long procId) { Map.Entry<Long, BitSetNode> entry = map.floorEntry(procId); if (entry != null && entry.getValue().contains(procId)) { BitSetNode node = entry.getValue(); DeleteState state = node.isDeleted(procId); return partial && !node.isUpdated(procId) ? DeleteState.MAYBE : state; } return partial ? DeleteState.MAYBE : DeleteState.YES; }
public boolean isUpdated(long procId) { final Map.Entry<Long, BitSetNode> entry = map.floorEntry(procId); return entry != null && entry.getValue().contains(procId) && entry.getValue().isUpdated(procId); }
private BitSetNode update(BitSetNode node, final 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.update(procId); trackProcIds(procId); return node; }
public void resetUpdates() { for (Map.Entry<Long, BitSetNode> entry : map.entrySet()) { entry.getValue().resetUpdates(); } minUpdatedProcId = Long.MAX_VALUE; maxUpdatedProcId = Long.MIN_VALUE; }
public void resetToProto(final ProcedureProtos.ProcedureStoreTracker trackerProtoBuf) { reset(); for (ProcedureProtos.ProcedureStoreTracker.TrackerNode protoNode: trackerProtoBuf.getNodeList()) { final BitSetNode node = new BitSetNode(protoNode); map.put(node.getStart(), node); } }