protected Cons<VArrayEntry<?>> validateNestedArrayReads() { Map<VArrayEntry<?>, VArrayEntry<?>> parentArrayWrites = getRWParent().arrayWrites; Cons<VArrayEntry<?>> parentArrayReads = getRWParent().arraysRead; int maxVersionOnParent = retrieveAncestorVersion(parent); for (VArrayEntry<?> entry : arraysRead) { // If the read was performed on an ancestor of the parent, then // propagate it for further validation if (entry.owner != parent) { parentArrayReads = parentArrayReads.cons(entry); } synchronized (parent) { if (parentArrayWrites != EMPTY_MAP) { // Verify if the parent contains a more recent write for the // read that we performed somewhere in our ancestors VArrayEntry<?> parentWrite = parentArrayWrites.get(entry); if (parentWrite == null) { continue; } if (parentWrite.nestedVersion > maxVersionOnParent) { TransactionSignaller.SIGNALLER.signalCommitFail(parent); } } } } return parentArrayReads; } }
ReadWriteTransaction parent = committer.getRWParent();
private void manualAbort() { ReadWriteTransaction parent = getRWParent(); while (parent != null) { for (ParallelNestedTransaction mergedIntoParent : parent.mergedTxs) { for (VBox vboxMergedIntoParent : mergedIntoParent.boxesWrittenInPlace) { revertOverwrite(vboxMergedIntoParent); } } for (VBox vboxMergedIntoParent : parent.boxesWrittenInPlace) { revertOverwrite(vboxMergedIntoParent); } parent = parent.getRWParent(); } this.orec.version = OwnershipRecord.ABORTED; for (ReadWriteTransaction child : mergedTxs) { child.orec.version = OwnershipRecord.ABORTED; } super.boxesWritten = null; int i = 0; for (ReadBlock block : globalReads) { block.free = true; i++; } blocksFree.get().addAndGet(i); this.globalReads = null; this.nestedReads = null; super.mergedTxs = null; }
@Override protected void tryCommit() { ReadWriteTransaction parent = getRWParent(); NestedCommitRecord lastSeen; NestedCommitRecord newCommit; do { lastSeen = helpCommitAll(parent.nestedCommitQueue); snapshotValidation(lastSeen.commitNumber); Cons<VArrayEntry<?>> varrayReadsToPropagate = validateNestedArrayReads(); newCommit = new NestedCommitRecord(this, this.mergedTxs, parent.mergedTxs, varrayReadsToPropagate, arrayWrites, arrayWritesCount, lastSeen.commitNumber + 1); } while (!lastSeen.next.compareAndSet(null, newCommit)); lastSeen = parent.nestedCommitQueue; while ((lastSeen != null) && (lastSeen.commitNumber <= newCommit.commitNumber)) { if (!lastSeen.recordCommitted) { lastSeen.helpCommit(); parent.nestedCommitQueue = lastSeen; } lastSeen = lastSeen.next.get(); } }
public void helpCommit() { ReadWriteTransaction parent = committer.getRWParent(); Cons<ParallelNestedTransaction> currentParentOrecs = parent.mergedTxs; if (currentParentOrecs == expectedParentOrecs) { committer.orec.nestedVersion = commitNumber; committer.orec.owner = parent; currentParentOrecs = currentParentOrecs.cons(committer); for (ParallelNestedTransaction childrenCommit : childrenToPropagate) { childrenCommit.orec.nestedVersion = commitNumber; childrenCommit.orec.owner = parent; currentParentOrecs = currentParentOrecs.cons(childrenCommit); } propagateVArraysFootprint(); parent.CASmergedTxs(expectedParentOrecs, currentParentOrecs); } }
@Override protected <T> T getLocalArrayValue(VArrayEntry<T> entry) { if (this.arrayWrites != EMPTY_MAP) { VArrayEntry<T> wsEntry = (VArrayEntry<T>) this.arrayWrites.get(entry); if (wsEntry != null) { return (wsEntry.getWriteValue() == null ? (T) NULL_VALUE : wsEntry.getWriteValue()); } } ReadWriteTransaction iter = getRWParent(); while (iter != null) { synchronized (iter) { if (iter.arrayWrites != EMPTY_MAP) { VArrayEntry<T> wsEntry = (VArrayEntry<T>) iter.arrayWrites.get(entry); if (wsEntry == null) { iter = iter.getRWParent(); continue; } if (wsEntry.nestedVersion <= retrieveAncestorVersion(iter)) { this.arraysRead = this.arraysRead.cons(entry); entry.setReadOwner(iter); return (wsEntry.getWriteValue() == null ? (T) NULL_VALUE : wsEntry.getWriteValue()); } else { TransactionSignaller.SIGNALLER.signalCommitFail(iter); } } } iter = iter.getRWParent(); } return null; }