private VariableTrackingPrecision extractValuePrecision(
final ARGReachedSet pReached, ARGState state) {
return (VariableTrackingPrecision)
Precisions.asIterable(pReached.asReachedSet().getPrecision(state))
.filter(VariableTrackingPrecision.isMatchingCPAClass(ValueAnalysisCPA.class))
.get(0);
}
private VariableTrackingPrecision mergeValuePrecisionsForSubgraph(
final ARGState pRefinementRoot, final ARGReachedSet pReached) {
// get all unique precisions from the subtree
Set<VariableTrackingPrecision> uniquePrecisions = Sets.newIdentityHashSet();
for (ARGState descendant : getNonCoveredStatesInSubgraph(pRefinementRoot)) {
uniquePrecisions.add(extractValuePrecision(pReached, descendant));
}
// join all unique precisions into a single precision
VariableTrackingPrecision mergedPrecision = Iterables.getLast(uniquePrecisions);
for (VariableTrackingPrecision precision : uniquePrecisions) {
mergedPrecision = mergedPrecision.join(precision);
}
return mergedPrecision;
}
protected void updateARG(PredicatePrecision pNewPrecision, ARGState pRefinementRoot)
throws InterruptedException {
argUpdate.start();
List<Precision> precisions = new ArrayList<>(2);
List<Predicate<? super Precision>> precisionTypes = new ArrayList<>(2);
precisions.add(pNewPrecision);
precisionTypes.add(Predicates.instanceOf(PredicatePrecision.class));
UnmodifiableReachedSet unmodifiableReached = reached.asReachedSet();
if (isValuePrecisionAvailable(pRefinementRoot)) {
precisions.add(mergeAllValuePrecisionsFromSubgraph(pRefinementRoot, unmodifiableReached));
precisionTypes.add(VariableTrackingPrecision.isMatchingCPAClass(ValueAnalysisCPA.class));
}
reached.removeSubtree(pRefinementRoot, precisions, precisionTypes);
if (sharePredicates) {
reached.updatePrecisionGlobally(
pNewPrecision, Predicates.instanceOf(PredicatePrecision.class));
}
argUpdate.stop();
}
private VariableTrackingPrecision mergeAllValuePrecisionsFromSubgraph(
ARGState refinementRoot, UnmodifiableReachedSet reached) {
VariableTrackingPrecision rootPrecision =
Precisions.extractPrecisionByType(
reached.getPrecision(refinementRoot), VariableTrackingPrecision.class);
// find all distinct precisions to merge them
Set<Precision> precisions = Sets.newIdentityHashSet();
for (ARGState state : refinementRoot.getSubgraph()) {
if (!state.isCovered()) {
// covered states are not in reached set
precisions.add(reached.getPrecision(state));
}
}
for (Precision prec : precisions) {
rootPrecision =
rootPrecision.join(
Precisions.extractPrecisionByType(prec, VariableTrackingPrecision.class));
}
return rootPrecision;
}
@Override
protected void refineUsingInterpolants(
final ARGReachedSet pReached,
final InterpolationTree<ValueAnalysisState, ValueAnalysisInterpolant> pInterpolationTree)
throws InterruptedException {
final boolean predicatePrecisionIsAvailable = isPredicatePrecisionAvailable(pReached);
Map<ARGState, List<Precision>> refinementInformation = new HashMap<>();
Collection<ARGState> refinementRoots =
pInterpolationTree.obtainRefinementRoots(restartStrategy);
for (ARGState root : refinementRoots) {
shutdownNotifier.shutdownIfNecessary();
root = relocateRefinementRoot(root, predicatePrecisionIsAvailable);
if (refinementRoots.size() == 1
&& isSimilarRepeatedRefinement(
pInterpolationTree.extractPrecisionIncrement(root).values())) {
root = relocateRepeatedRefinementRoot(root);
}
List<Precision> precisions = new ArrayList<>(2);
// merge the value precisions of the subtree, and refine it
precisions.add(
mergeValuePrecisionsForSubgraph(root, pReached)
.withIncrement(pInterpolationTree.extractPrecisionIncrement(root)));
// merge the predicate precisions of the subtree, if available
if (predicatePrecisionIsAvailable) {
precisions.add(mergePredicatePrecisionsForSubgraph(root, pReached));
}
refinementInformation.put(root, precisions);
}
for (Entry<ARGState, List<Precision>> info : refinementInformation.entrySet()) {
shutdownNotifier.shutdownIfNecessary();
List<Predicate<? super Precision>> precisionTypes = new ArrayList<>(2);
precisionTypes.add(VariableTrackingPrecision.isMatchingCPAClass(ValueAnalysisCPA.class));
if (predicatePrecisionIsAvailable) {
precisionTypes.add(Predicates.instanceOf(PredicatePrecision.class));
}
pReached.removeSubtree(info.getKey(), info.getValue(), precisionTypes);
}
}