public NestedCommitRecord() { this.committer = null; this.childrenToPropagate = Cons.empty(); this.expectedParentOrecs = Cons.empty(); this.varrayReadsToPropagate = Cons.empty(); this.arrayWritesToPropagate = ReadWriteTransaction.EMPTY_MAP; this.arrayWritesCount = ReadWriteTransaction.EMPTY_MAP; this.commitNumber = 0; this.recordCommitted = true; }
@Override public Cons<VBox[]> initialValue() { return Cons.empty(); } };
@Override protected Cons<ReadBlock> initialValue() { return Cons.empty(); } };
public ParallelNestedTransaction(ReadWriteTransaction parent, boolean multithreaded) { super(parent); super.ancVersions = EMPTY_VERSIONS; this.nestedReads = ReadWriteTransaction.EMPTY_MAP; this.globalReads = Cons.empty(); }
RBTIterator() { this.path = Cons.empty(); }
RBTIterator() { this.path = Cons.empty(); }
public ParallelNestedTransaction(ReadWriteTransaction parent) { super(parent); int[] parentVers = parent.ancVersions; super.ancVersions = new int[parentVers.length + 1]; super.ancVersions[0] = parent.nestedCommitQueue.commitNumber; for (int i = 0; i < parentVers.length; i++) { this.ancVersions[i + 1] = parentVers[i]; } this.nestedReads = new HashMap<VBox, InplaceWrite>(); this.globalReads = Cons.empty(); this.boxesWritten = parent.boxesWritten; }
@Override protected void doCommit() { tryCommit(); // if commit is successful, then reset transaction to a clean state for (VBox[] array : bodiesRead) { returnToPool(array); } bodiesRead = Cons.empty(); arraysRead = Cons.empty(); boxesWritten = EMPTY_MAP; boxesWrittenInPlace = Cons.empty(); perTxValues = EMPTY_MAP; arrayWrites = EMPTY_MAP; arrayWritesCount = EMPTY_MAP; }
@Override public boolean isWriteTransaction() { Cons<ParallelNestedTransaction> emptyCons = Cons.<ParallelNestedTransaction> empty(); return (mergedTxs != emptyCons) || (!boxesWritten.isEmpty()) || (!boxesWrittenInPlace.isEmpty()) || (!arrayWrites.isEmpty()) || (perTxValues != null && !perTxValues.isEmpty()); }
protected void cleanUp() { if (mergedTxs != Cons.<ParallelNestedTransaction> empty()) { for (ParallelNestedTransaction mergedTx : mergedTxs) { mergedTx.cleanUp(); } mergedTxs = null; } }
private static Cons<Method> computePredicatesForClass(Class objClass) { if (objClass != null) { Cons<Method> predicates = computePredicatesForClass(objClass.getSuperclass()); for (Method m : objClass.getDeclaredMethods()) { if (m.isAnnotationPresent(ConsistencyPredicate.class)) { m.setAccessible(true); predicates = predicates.cons(m); } } return predicates; } else { return Cons.empty(); } }
private Cons<GarbageCollectable> doWriteback(int newTxNumber) { GarbageCollectable newLogNode = array.commit(newTxNumber, writesToCommit, logEntryIndexes); return Cons.<GarbageCollectable> empty().cons(newLogNode); } }
protected Cons<GarbageCollectable> writeBackLoop(int newTxNumber, int min, int max, VBox[] vboxes, Object[] values) { Cons<GarbageCollectable> newBodies = Cons.empty(); for (int i = max - 1; i >= min; i--) { VBox vbox = vboxes[i]; Object newValue = values[i]; VBoxBody newBody = vbox.commit((newValue == ReadWriteTransaction.NULL_VALUE) ? null : newValue, newTxNumber); newBodies = newBodies.cons(newBody); } return newBodies; }
protected Iterator<DependenceRecord> getDependenceRecordsToRecheck() { Cons<Iterator<DependenceRecord>> iteratorsList = Cons.empty(); for (VBox box : boxesWritten.keySet()) { Depended dep = DependedVBoxes.getDependedForBoxIfExists(box); if (dep != null) { iteratorsList = iteratorsList.cons(dep.getDependenceRecords().iterator()); } } return new ChainedIterator<DependenceRecord>(iteratorsList.iterator()); }
@Override @Atomic(canFail = false) public void clear() { entries.put((Cons<E>) Cons.empty()); size.putInt(0); }
@Override protected Cons<GarbageCollectable> writeBackLoop(int newTxNumber, int min, int max, jvstm.VBox[] vboxes, Object[] values) { Object newValue = VBox.notLoadedValue(); Cons<GarbageCollectable> newBodies = Cons.empty(); for (int i = max - 1; i >= min; i--) { jvstm.VBox vbox = vboxes[i]; logger.debug("Will commit to vbox {} version {} with value {}", ((VBox) vbox).getId(), newTxNumber, newValue); VBoxBody newBody = vbox.commit(newValue, newTxNumber); newBodies = newBodies.cons(newBody); } return newBodies; }
private E removeExisting(Cons<E> frontElems) { E result = frontElems.first(); frontElems = frontElems.rest(); if (frontElems.isEmpty()) { frontElems = rear.get().reverse(); if (!frontElems.isEmpty()) { // only clear the rear if it had anything rear.put((Cons<E>) Cons.empty()); } } front.put(frontElems); size.dec(); return result; }