new StateObjectCollection<>(mergedManagedOperatorState), new StateObjectCollection<>(mergedRawOperatorState), new StateObjectCollection<>(mergedManagedKeyedState), new StateObjectCollection<>(mergedRawKeyedState));
StateObjectCollection.empty(), new StateObjectCollection<>(operatorStateHandles), StateObjectCollection.empty(), new StateObjectCollection<>(keyedStateHandles));
@Override public void discardState() { try { List<StateObject> toDispose = new ArrayList<>( managedOperatorState.size() + rawOperatorState.size() + managedKeyedState.size() + rawKeyedState.size()); toDispose.addAll(managedOperatorState); toDispose.addAll(rawOperatorState); toDispose.addAll(managedKeyedState); toDispose.addAll(rawKeyedState); StateUtil.bestEffortDiscardAllStateObjects(toDispose); } catch (Exception e) { LOG.warn("Error while discarding operator states.", e); } }
private static <T extends StateObject> void performCheck( Future<SnapshotResult<T>> resultFuture, StateObjectCollection<T> jmState, StateObjectCollection<T> tmState) { SnapshotResult<T> snapshotResult; try { snapshotResult = resultFuture.get(); } catch (Exception e) { throw new RuntimeException(e); } Assert.assertEquals( snapshotResult.getJobManagerOwnedSnapshot(), jmState.iterator().next()); Assert.assertEquals( snapshotResult.getTaskLocalSnapshot(), tmState.iterator().next()); }
private static long sumAllSizes(Collection<? extends StateObject> stateObject) { long size = 0L; for (StateObject object : stateObject) { size += getSizeNullSafe(object); } return size; }
@Override public int hashCode() { int result = getManagedOperatorState().hashCode(); result = 31 * result + getRawOperatorState().hashCode(); result = 31 * result + getManagedKeyedState().hashCode(); result = 31 * result + getRawKeyedState().hashCode(); result = 31 * result + (int) (getStateSize() ^ (getStateSize() >>> 32)); return result; }
public OperatorSubtaskState( @Nonnull StateObjectCollection<OperatorStateHandle> managedOperatorState, @Nonnull StateObjectCollection<OperatorStateHandle> rawOperatorState, @Nonnull StateObjectCollection<KeyedStateHandle> managedKeyedState, @Nonnull StateObjectCollection<KeyedStateHandle> rawKeyedState) { this.managedOperatorState = Preconditions.checkNotNull(managedOperatorState); this.rawOperatorState = Preconditions.checkNotNull(rawOperatorState); this.managedKeyedState = Preconditions.checkNotNull(managedKeyedState); this.rawKeyedState = Preconditions.checkNotNull(rawKeyedState); long calculateStateSize = managedOperatorState.getStateSize(); calculateStateSize += rawOperatorState.getStateSize(); calculateStateSize += managedKeyedState.getStateSize(); calculateStateSize += rawKeyedState.getStateSize(); stateSize = calculateStateSize; }
@Override public boolean equals(Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } OperatorSubtaskState that = (OperatorSubtaskState) o; if (getStateSize() != that.getStateSize()) { return false; } if (!getManagedOperatorState().equals(that.getManagedOperatorState())) { return false; } if (!getRawOperatorState().equals(that.getRawOperatorState())) { return false; } if (!getManagedKeyedState().equals(that.getManagedKeyedState())) { return false; } return getRawKeyedState().equals(that.getRawKeyedState()); }
assertEquals(StateObjectCollection.singleton(managedKeyedStateHandle), subtaskState.getManagedKeyedState()); assertEquals(StateObjectCollection.singleton(rawKeyedStateHandle), subtaskState.getRawKeyedState()); assertEquals(StateObjectCollection.singleton(managedOperatorStateHandle), subtaskState.getManagedOperatorState()); assertEquals(StateObjectCollection.singleton(rawOperatorStateHandle), subtaskState.getRawOperatorState());
@Override public void discardState() { try { List<StateObject> toDispose = new ArrayList<>( managedOperatorState.size() + rawOperatorState.size() + managedKeyedState.size() + rawKeyedState.size()); toDispose.addAll(managedOperatorState); toDispose.addAll(rawOperatorState); toDispose.addAll(managedKeyedState); toDispose.addAll(rawKeyedState); StateUtil.bestEffortDiscardAllStateObjects(toDispose); } catch (Exception e) { LOG.warn("Error while discarding operator states.", e); } }
public static Optional<KeyedBackendSerializationProxy<?>> getKeyedBackendSerializationProxy(OperatorState opState) { try { KeyedStateHandle firstHandle = opState.getStates().iterator().next().getManagedKeyedState().iterator() .next(); if (firstHandle instanceof IncrementalKeyedStateHandle) { return Optional.of(getKeyedBackendSerializationProxy( ((IncrementalKeyedStateHandle) firstHandle).getMetaStateHandle())); } else { return Optional.of(getKeyedBackendSerializationProxy((StreamStateHandle) firstHandle)); } } catch (Exception e) { return Optional.empty(); } }