public boolean canGrow(long procId) { if (procId <= start) { return getEnd() - procId < MAX_NODE_SIZE; } else { return procId - start < MAX_NODE_SIZE; } }
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; }
public boolean contains(final long procId) { return start <= procId && procId <= getEnd(); }
public long getActiveMaxProcId() { long maxProcId = getEnd(); for (int i = deleted.length - 1; i >= 0; --i) { if (deleted[i] == 0) { return maxProcId; } if (deleted[i] != WORD_MASK) { for (int j = BITS_PER_WORD - 1; j >= 0; --j) { if ((deleted[i] & (1L << j)) == 0) { return maxProcId - (BITS_PER_WORD - 1 - j); } } } maxProcId -= BITS_PER_WORD; } return Procedure.NO_PROC_ID; }
@Override public String toString() { return "BitSetNode(" + getStart() + "-" + getEnd() + ")"; }
public void merge(BitSetNode rightNode) { assert start < rightNode.start; int newSize = (int) (rightNode.getEnd() - start + 1) >> ADDRESS_BITS_PER_WORD; long[] newModified = Arrays.copyOf(modified, newSize); System.arraycopy(rightNode.modified, 0, newModified, newSize - rightNode.modified.length, rightNode.modified.length); long[] newDeleted = Arrays.copyOf(deleted, newSize); System.arraycopy(rightNode.deleted, 0, newDeleted, newSize - rightNode.deleted.length, rightNode.deleted.length); if (!partial) { for (int i = deleted.length, n = newSize - rightNode.deleted.length; i < n; i++) { newDeleted[i] = WORD_MASK; } } modified = newModified; deleted = newDeleted; }
public void dump() { System.out.printf("%06d:%06d min=%d max=%d%n", getStart(), getEnd(), getActiveMinProcId(), getActiveMaxProcId()); System.out.println("Modified:"); for (int i = 0; i < modified.length; ++i) { for (int j = 0; j < BITS_PER_WORD; ++j) { System.out.print((modified[i] & (1L << j)) != 0 ? "1" : "0"); } System.out.println(" " + i); } System.out.println(); System.out.println("Delete:"); for (int i = 0; i < deleted.length; ++i) { for (int j = 0; j < BITS_PER_WORD; ++j) { System.out.print((deleted[i] & (1L << j)) != 0 ? "1" : "0"); } System.out.println(" " + i); } System.out.println(); }
private void setDeleteIf(ProcedureStoreTracker tracker, BiFunction<BitSetNode, Long, Boolean> func) { BitSetNode trackerNode = null; for (BitSetNode node : map.values()) { long minProcId = node.getStart(); long maxProcId = node.getEnd(); for (long procId = minProcId; procId <= maxProcId; ++procId) { if (!node.isModified(procId)) { continue; } trackerNode = tracker.lookupClosestNode(trackerNode, procId); if (func.apply(trackerNode, procId)) { node.delete(procId); } } } }
int delta = (int) (newEnd - getEnd()) >> ADDRESS_BITS_PER_WORD; int newSize = modified.length + delta; long[] newModified = Arrays.copyOf(modified, newSize);
if ((procId - leftNode.getEnd()) <= (rightNode.getStart() - procId)) { return growNode(leftNode, procId);
@Test public void testMerge() { BitSetNode node = new BitSetNode(1000, false); assertTrue(node.canMerge(new BitSetNode(1200, false))); assertFalse(node.canMerge(new BitSetNode(10000, false))); BitSetNode rightNode = new BitSetNode(1200, false); node.merge(rightNode); assertTrue(node.isModified(1000)); assertTrue(node.isModified(1200)); for (long i = node.getStart(); i <= node.getEnd(); i++) { if (i != 1000 && i != 1200) { assertEquals(DeleteState.YES, node.isDeleted(i)); } else { assertEquals(DeleteState.NO, node.isDeleted(i)); } } } }
@Test public void testGrow() { BitSetNode node = new BitSetNode(1000, false); // contains, do not need to grow but should not fail assertTrue(node.canGrow(1024)); assertTrue(node.canGrow(900)); assertTrue(node.canGrow(1100)); assertFalse(node.canGrow(100)); assertFalse(node.canGrow(10000)); // grow to right node.grow(1100); assertTrue(node.contains(1100)); assertTrue(node.isModified(1000)); // grow to left node.grow(900); assertTrue(node.contains(900)); assertTrue(node.isModified(1000)); for (long i = node.getStart(); i <= node.getEnd(); i++) { if (i != 1000) { assertEquals(DeleteState.YES, node.isDeleted(i)); } else { assertEquals(DeleteState.NO, node.isDeleted(i)); } } }
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; }
public boolean canGrow(long procId) { if (procId <= start) { return getEnd() - procId < MAX_NODE_SIZE; } else { return procId - start < MAX_NODE_SIZE; } }
public boolean contains(final long procId) { return start <= procId && procId <= getEnd(); }
public long getActiveMaxProcId() { long maxProcId = getEnd(); for (int i = deleted.length - 1; i >= 0; --i) { if (deleted[i] == 0) { return maxProcId; } if (deleted[i] != WORD_MASK) { for (int j = BITS_PER_WORD - 1; j >= 0; --j) { if ((deleted[i] & (1L << j)) == 0) { return maxProcId - (BITS_PER_WORD - 1 - j); } } } maxProcId -= BITS_PER_WORD; } return Procedure.NO_PROC_ID; }
@Override public String toString() { return "BitSetNode(" + getStart() + "-" + getEnd() + ")"; }
public void merge(BitSetNode rightNode) { assert start < rightNode.start; int newSize = (int) (rightNode.getEnd() - start + 1) >> ADDRESS_BITS_PER_WORD; long[] newModified = Arrays.copyOf(modified, newSize); System.arraycopy(rightNode.modified, 0, newModified, newSize - rightNode.modified.length, rightNode.modified.length); long[] newDeleted = Arrays.copyOf(deleted, newSize); System.arraycopy(rightNode.deleted, 0, newDeleted, newSize - rightNode.deleted.length, rightNode.deleted.length); if (!partial) { for (int i = deleted.length, n = newSize - rightNode.deleted.length; i < n; i++) { newDeleted[i] = WORD_MASK; } } modified = newModified; deleted = newDeleted; }
private void setDeleteIf(ProcedureStoreTracker tracker, BiFunction<BitSetNode, Long, Boolean> func) { BitSetNode trackerNode = null; for (BitSetNode node : map.values()) { long minProcId = node.getStart(); long maxProcId = node.getEnd(); for (long procId = minProcId; procId <= maxProcId; ++procId) { if (!node.isModified(procId)) { continue; } trackerNode = tracker.lookupClosestNode(trackerNode, procId); if (func.apply(trackerNode, procId)) { node.delete(procId); } } } }
@Test public void testMerge() { BitSetNode node = new BitSetNode(1000, false); assertTrue(node.canMerge(new BitSetNode(1200, false))); assertFalse(node.canMerge(new BitSetNode(10000, false))); BitSetNode rightNode = new BitSetNode(1200, false); node.merge(rightNode); assertTrue(node.isModified(1000)); assertTrue(node.isModified(1200)); for (long i = node.getStart(); i <= node.getEnd(); i++) { if (i != 1000 && i != 1200) { assertEquals(DeleteState.YES, node.isDeleted(i)); } else { assertEquals(DeleteState.NO, node.isDeleted(i)); } } } }