/** * TODO soplog - This method is public just to test soplog recovery */ public DiskEntry.RecoveredEntry createRecoveredEntry(byte[] valueBytes, int valueLength, byte userBits, long oplogId, long offsetInOplog, long oplogKeyId, boolean recoverValue, Version version, ByteArrayDataInput in) { DiskEntry.RecoveredEntry re = null; if (recoverValue || EntryBits.isAnyInvalid(userBits) || EntryBits.isTombstone(userBits)) { Object value; if (EntryBits.isLocalInvalid(userBits)) { value = Token.LOCAL_INVALID; valueLength = 0; } else if (EntryBits.isInvalid(userBits)) { value = Token.INVALID; valueLength = 0; } else if (EntryBits.isSerialized(userBits)) { value = DiskEntry.Helper.readSerializedValue(valueBytes, version, in, false); } else if (EntryBits.isTombstone(userBits)) { value = Token.TOMBSTONE; } else { value = valueBytes; } re = new DiskEntry.RecoveredEntry(oplogKeyId, oplogId, offsetInOplog, userBits, valueLength, value); } else { re = new DiskEntry.RecoveredEntry(oplogKeyId, oplogId, offsetInOplog, userBits, valueLength); } return re; }
/** * Returns the offset to the first byte of the value bytes. */ public int getValueOffset() { if (!this.needsValue) return 0; int result = this.deltaIdBytesLength // + 8 /* HACK DEBUG */ + this.drIdLength + 1/* opcode */ + 4/* value length */; if (this.notToUseUserBits == false) { result++; } if (EntryBits.isWithVersions(this.userBits) && this.versionsBytes != null) { result += this.versionsBytes.length; } if (this.lastModifiedTime != 0) { result += this.lmtBytes; } return result; }
private byte calcUserBits(DiskEntry.Helper.ValueWrapper value) { byte userBits = 0x0; if (value.isSerializedObject) { if (value == DiskEntry.Helper.INVALID_VW) { // its the invalid token userBits = EntryBits.setInvalid(userBits, true); } else if (value == DiskEntry.Helper.LOCAL_INVALID_VW) { // its the local-invalid token userBits = EntryBits.setLocalInvalid(userBits, true); } else if (value == DiskEntry.Helper.TOMBSTONE_VW) { // its the tombstone token userBits = EntryBits.setTombstone(userBits, true); } else { userBits = EntryBits.setSerialized(userBits, true); } } return userBits; }
private void initVersionsBytes(VersionTag tag, long lastModifiedTime) throws IOException { if (EntryBits.isWithVersions(this.userBits)) { this.versionsBytes = serializeVersionTag(tag); this.size += this.versionsBytes.length; } else { // persist last modified time for no-versions case this.userBits = EntryBits.setHasLastModifiedTime(this.userBits); initLastModifiedTime(lastModifiedTime); } }
if (EntryBits.isAnyInvalid(userBits)) { if (EntryBits.isInvalid(userBits)) { wrapper.setData(DiskEntry.INVALID_BYTES, userBits, DiskEntry.INVALID_BYTES.length, false/* Can not be reused*/); } else { wrapper.setData(DiskEntry.LOCAL_INVALID_BYTES, userBits, DiskEntry.LOCAL_INVALID_BYTES.length, false/* Can not be reused*/); } else if (EntryBits.isTombstone(userBits)) { wrapper.setData(DiskEntry.TOMBSTONE_BYTES, userBits, DiskEntry.TOMBSTONE_BYTES.length, false/* Can not be reused*/); if (EntryBits.isWithVersions(did.getUserBits())) { userBits = EntryBits.setWithVersions(userBits, true); if (EntryBits.isRecoveredFromDisk(did.getUserBits())) { userBits = EntryBits.setRecoveredFromDisk(userBits, true); if (EntryBits.isWithVersions(did.getUserBits())) { userBits = EntryBits.setWithVersions(userBits, true); userBits = EntryBits.setInvalid(userBits, true); wrapper.setData(DiskEntry.INVALID_BYTES, userBits, DiskEntry.INVALID_BYTES.length, userBits = EntryBits.setLocalInvalid(userBits, true); wrapper.setData(DiskEntry.LOCAL_INVALID_BYTES, userBits, DiskEntry.LOCAL_INVALID_BYTES.length, false /* Cannot be reused */); } else if (value == Token.TOMBSTONE) { userBits = EntryBits.setTombstone(userBits, true); wrapper.setData(DiskEntry.TOMBSTONE_BYTES, userBits,
userBits = EntryBits.setSerialized(userBits, true); did.setUserBits(userBits); assertEquals(userBits, did.getUserBits()); userBits = EntryBits.setInvalid(userBits, true); did.setUserBits(userBits); assertEquals(userBits, did.getUserBits()); userBits = EntryBits.setLocalInvalid(userBits, true); did.setUserBits(userBits); assertEquals(userBits, did.getUserBits()); assertTrue(EntryBits.isSerialized(userBits)); assertTrue(EntryBits.isInvalid(userBits)); assertTrue(EntryBits.isLocalInvalid(userBits)); userBits = EntryBits.setSerialized(userBits, false); did.setUserBits(userBits); assertEquals(userBits, did.getUserBits()); userBits = EntryBits.setInvalid(userBits, false); did.setUserBits(userBits); assertEquals(userBits, did.getUserBits()); userBits = EntryBits.setLocalInvalid(userBits, false); did.setUserBits(userBits); assertFalse(EntryBits.isSerialized(userBits)); assertFalse(EntryBits.isInvalid(userBits)); assertFalse(EntryBits.isLocalInvalid(userBits)); userBits = EntryBits.setSerialized(userBits, true); did.setUserBits(userBits); assertTrue(EntryBits.isSerialized(userBits)); assertFalse(EntryBits.isInvalid(userBits)); assertFalse(EntryBits.isLocalInvalid(userBits));
final boolean withVersions = EntryBits.isWithVersions(userBits); long lastModifiedTime = 0L; if (withVersions) { && !Version.CURRENT.equals(Version.SQLF_11)) { tag = this.createDummyTag(drs, currentTime); userBits = EntryBits.setWithVersions(userBits, true); if (EntryBits.isLastModifiedTime(userBits)) { lastModifiedTime = InternalDataSerializer.readUnsignedVL(dis); CompactionRecord p2cr = null; long crOffset; if (EntryBits.isAnyInvalid(userBits) || EntryBits.isTombstone(userBits)) { if (EntryBits.isInvalid(userBits)) { objValue = DiskEntry.INVALID_BYTES; } else if (EntryBits.isTombstone(userBits)) { objValue = DiskEntry.TOMBSTONE_BYTES; } else { true, version, in, hdos); objValue = sysCb.fromVersionToBytes(objValue, objValue.length, EntryBits.isSerialized(userBits), version, in, hdos); if (EntryBits.isAnyInvalid(userBits) || EntryBits.isTombstone(userBits)) { drs.getDiskRegionView().incInvalidOrTombstoneEntryCount(); de = drs.updateRecoveredEntry(key, de, re); if (de != null && de.getValueAsToken() == Token.TOMBSTONE && !isOldValueToken) {
if (EntryBits.isWithVersions(userBits)) { tag = readVersionsFromOplog(dis); if (drs != null && !drs.getDiskRegionView().getFlags().contains(DiskRegionFlag.IS_WITH_VERSIONING)) { userBits = EntryBits.setWithVersions(userBits, false); } else { if (EntryBits.isAnyInvalid(userBits) || EntryBits.isTombstone(userBits)) { oplogOffset = -1; } else { incSkipped(); } else { if (EntryBits.isAnyInvalid(userBits)) { if (EntryBits.isInvalid(userBits)) { valueBytes = DiskEntry.INVALID_BYTES; } else { valueBytes = DiskEntry.LOCAL_INVALID_BYTES; } else if (EntryBits.isTombstone(userBits)) { valueBytes = DiskEntry.TOMBSTONE_BYTES;
if (EntryBits.isAnyInvalid(userBits) || EntryBits.isTombstone(userBits) || bitOnly || valueLength == 0) { if (EntryBits.isInvalid(userBits)) { bb = new BytesAndBits(DiskEntry.Helper.INVALID_BUFFER, userBits); } else if (EntryBits.isTombstone(userBits)) { bb = new BytesAndBits(DiskEntry.Helper.TOMBSTONE_BUFFER, userBits); } else {
case 1: did.setUserBits(EntryBits .setSerialized(userbits, boolValuePerIteration)); break; case 2: did.setUserBits(EntryBits.setInvalid(userbits, boolValuePerIteration)); break; case 3: did.setUserBits(EntryBits.setLocalInvalid(userbits, boolValuePerIteration)); break; break; case 1: assertEquals(EntryBits.isSerialized(userBits2), boolValuePerIteration); break; case 2: assertEquals(EntryBits.isInvalid(userBits2), boolValuePerIteration); break; case 3: assertEquals(EntryBits.isLocalInvalid(userBits2), boolValuePerIteration); break;
b = EntryBits.setSerialized(b, true); b = EntryBits.setRecoveredFromDisk(b, true); b = EntryBits.setWithVersions(b, true);
boolean withVersions = EntryBits.isWithVersions(userBits); if (withVersions && tag == null) { userBits = EntryBits.setWithVersions(userBits, false); withVersions = false; userBits = EntryBits.setHasLastModifiedTime(userBits); this.krf.dos.writeByte(EntryBits.getPersistentBits(userBits)); InternalDataSerializer.writeArrayLength(valueLength, this.krf.dos); DiskInitFile.writeDiskRegionID(this.krf.dos, diskRegionId); if(!EntryBits.isAnyInvalid(userBits) && !EntryBits.isTombstone(userBits)) { InternalDataSerializer.writeVLOld((valueOffset - this.krf.lastOffset), this.krf.dos);
if (EntryBits.isWithVersions(userBits)) { tag = readVersionsFromOplog(dis); else if (EntryBits.isLastModifiedTime(userBits)) { lastModifiedTime = InternalDataSerializer.readUnsignedVL(dis); if (EntryBits.isAnyInvalid(userBits) || EntryBits.isTombstone(userBits)) { oplogOffset = -1; } else { incSkipped(); } else { if (EntryBits.isAnyInvalid(userBits)) { if (EntryBits.isInvalid(userBits)) { valueBytes = DiskEntry.INVALID_BYTES; } else { valueBytes = DiskEntry.LOCAL_INVALID_BYTES; } else if (EntryBits.isTombstone(userBits)) { valueBytes = DiskEntry.TOMBSTONE_BYTES; .initializeRecoveredEntry(key, re)); drs.getDiskRegionView().incRecoveredEntryCount(); if (EntryBits.isAnyInvalid(userBits) || EntryBits.isTombstone(userBits)) { drs.getDiskRegionView().incInvalidOrTombstoneEntryCount();
deKey = de.getKey(); if (valueOffset < 0) { assert (EntryBits.isAnyInvalid(userBits) || EntryBits.isTombstone(userBits)); if (EntryBits.isWithVersions(userBits) && de.getVersionStamp() != null) { tag = de.getVersionStamp().asVersionTag(); } else if (de.getVersionStamp() != null) {
private void writeOneKeyEntryForKRF(byte[] keyBytes, byte userBits, int valueLength, long diskRegionId, long oplogKeyId, long valueOffset, VersionHolder tag) throws IOException { if (getParent().isValidating()) { return; } if (!getParent().isOfflineCompacting()) { assert (this.krf.dos != null); } else { if (this.krf.dos == null) { // krf already exist, thus not re-opened for write return; } } DataSerializer.writeByteArray(keyBytes, this.krf.dos); this.krf.dos.writeByte(EntryBits.getPersistentBits(userBits)); InternalDataSerializer.writeArrayLength(valueLength, this.krf.dos); DiskInitFile.writeDiskRegionID(this.krf.dos, diskRegionId); if (EntryBits.isWithVersions(userBits) && tag != null) { serializeVersionTag(tag, this.krf.dos); } InternalDataSerializer.writeVLOld(oplogKeyId, this.krf.dos); // skip the invalid entries, theire valueOffset is -1 if (!EntryBits.isAnyInvalid(userBits) && !EntryBits.isTombstone(userBits)) { InternalDataSerializer.writeVLOld((valueOffset - this.krf.lastOffset), this.krf.dos); // save the lastOffset in krf object this.krf.lastOffset = valueOffset; } this.krf.keyNum++; }
dr.getId(), tag, getOplogId()); if (EntryBits.isNeedsValue(userBits)) { id.setValueLength(value.getLength()); } else { if (EntryBits.isAnyInvalid(userBits) || EntryBits.isTombstone(userBits)) { id.setOffsetInOplog(-1); } else {
/** * Returns true if the serialized object is not any token * *@param b the magic entry type byte * @return true if not any token */ public static boolean isSerialized(byte b) { return EntryBits.isSerialized(b); } }
/** * Returns true if the serialized object is a tombstone. * * @param b the magic entry type byte * @return true if a tombstone */ public static boolean isTombstone(byte b) { return EntryBits.isTombstone(b); }
public boolean testIsRecoveredAndClear(DiskId id) { if (!isReadyForRecovery()) return false; if (id == null) return false; synchronized (id) { byte bits = id.getUserBits(); if (EntryBits.isRecoveredFromDisk(bits)) { bits = EntryBits.setRecoveredFromDisk(bits, false); id.setUserBits(bits); return true; } } return false; }
/** * Returns true if the serialized tombstone was garbage collected * * @param b the magic entry type byte * @return true if RemovedPhase2 */ public static boolean isRemovedPhase2(byte b) { return EntryBits.isLocalInvalid(b); }