use of com.dat3m.dartagnan.solver.caat.predicates.relationGraphs.RelationGraph in project Dat3M by hernanponcedeleon.
the class Reasoner method computeViolationReasons.
// ========================== Reason computation ==========================
public DNF<CAATLiteral> computeViolationReasons(Constraint constraint) {
if (!constraint.checkForViolations()) {
return DNF.FALSE();
}
CAATPredicate pred = constraint.getConstrainedPredicate();
Collection<? extends Collection<? extends Derivable>> violations = constraint.getViolations();
List<Conjunction<CAATLiteral>> reasonList = new ArrayList<>(violations.size());
if (constraint instanceof AcyclicityConstraint) {
// For acyclicity constraints, it is likely that we encounter the same
// edge multiple times (as it can be part of different cycles)
// so we memoize the computed reasons and reuse them if possible.
final RelationGraph constrainedGraph = (RelationGraph) pred;
final int mapSize = violations.stream().mapToInt(Collection::size).sum() * 4 / 3;
final Map<Edge, Conjunction<CAATLiteral>> reasonMap = new HashMap<>(mapSize);
for (Collection<Edge> violation : (Collection<Collection<Edge>>) violations) {
Conjunction<CAATLiteral> reason = violation.stream().map(edge -> reasonMap.computeIfAbsent(edge, key -> computeReason(constrainedGraph, key))).reduce(Conjunction.TRUE(), Conjunction::and);
reasonList.add(reason);
}
} else {
for (Collection<? extends Derivable> violation : violations) {
Conjunction<CAATLiteral> reason = violation.stream().map(edge -> computeReason(pred, edge)).reduce(Conjunction.TRUE(), Conjunction::and);
reasonList.add(reason);
}
}
return new DNF<>(reasonList);
}
use of com.dat3m.dartagnan.solver.caat.predicates.relationGraphs.RelationGraph in project Dat3M by hernanponcedeleon.
the class ExecutionGraph method getOrCreateConstraintFromAxiom.
// =======================================================
// =================== Reading the WMM ====================
private Constraint getOrCreateConstraintFromAxiom(Axiom axiom) {
if (constraintMap.containsKey(axiom)) {
return constraintMap.get(axiom);
}
Constraint constraint;
RelationGraph innerGraph = getOrCreateGraphFromRelation(axiom.getRelation());
if (axiom.isAcyclicity()) {
constraint = new AcyclicityConstraint(innerGraph);
} else if (axiom.isEmptiness()) {
constraint = new EmptinessConstraint(innerGraph);
} else if (axiom.isIrreflexivity()) {
constraint = new IrreflexivityConstraint(innerGraph);
} else {
throw new UnsupportedOperationException("The axiom " + axiom + " is not recognized.");
}
constraintMap.put(axiom, constraint);
return constraint;
}
use of com.dat3m.dartagnan.solver.caat.predicates.relationGraphs.RelationGraph in project Dat3M by hernanponcedeleon.
the class ExecutionGraph method getOrCreateGraphFromRelation.
private RelationGraph getOrCreateGraphFromRelation(Relation rel) {
if (relationGraphMap.containsKey(rel)) {
return relationGraphMap.get(rel);
}
RelationGraph graph;
Class<?> relClass = rel.getClass();
// ===== Filter special relations ======
if (SPECIAL_RELS.contains(rel.getName())) {
switch(rel.getName()) {
case CTRL:
graph = new CtrlDepGraph();
break;
case DATA:
graph = new DataDepGraph();
break;
case ADDR:
graph = new AddrDepGraph();
break;
case CRIT:
graph = new RcuGraph();
break;
default:
throw new UnsupportedOperationException(rel.getName() + " is marked as special relation but has associated graph.");
}
} else if (relClass == RelRf.class) {
graph = new ReadFromGraph();
} else if (relClass == RelLoc.class) {
graph = new LocationGraph();
} else if (relClass == RelPo.class) {
graph = new ProgramOrderGraph();
} else if (relClass == RelCo.class) {
graph = new CoherenceGraph();
} else if (rel.isRecursiveRelation()) {
RecursiveGraph recGraph = new RecursiveGraph();
recGraph.setName(rel.getName() + "_rec");
relationGraphMap.put(rel, recGraph);
recGraph.setConcreteGraph(getOrCreateGraphFromRelation(rel.getInner()));
return recGraph;
} else if (rel.isUnaryRelation()) {
Relation innerRelation = rel.getInner();
RelationGraph innerGraph = getOrCreateGraphFromRelation(innerRelation);
// A safety check because recursion might have computed this RelationGraph already
if (relationGraphMap.containsKey(rel)) {
return relationGraphMap.get(rel);
}
if (relClass == RelInverse.class) {
graph = new InverseGraph(innerGraph);
} else if (relClass == RelTrans.class) {
graph = new TransitiveGraph(innerGraph);
} else if (relClass == RelRangeIdentity.class) {
graph = new RangeIdentityGraph(innerGraph);
} else if (relClass == RelTransRef.class) {
// FIXME: This is very, very sketchy and instead of doing this
// a WmmProcessor should run that transforms the wmm accordingly.
RelTrans relTrans = new RelTrans(innerRelation);
RelationGraph transGraph = getOrCreateGraphFromRelation(relTrans);
graph = new ReflexiveClosureGraph(transGraph);
} else {
throw new UnsupportedOperationException(relClass.toString() + " has no associated graph yet.");
}
} else if (rel.isBinaryRelation()) {
RelationGraph first = getOrCreateGraphFromRelation(rel.getFirst());
RelationGraph second = getOrCreateGraphFromRelation(rel.getSecond());
// A safety check because recursion might have computed this RelationGraph already
if (relationGraphMap.containsKey(rel)) {
return relationGraphMap.get(rel);
}
if (relClass == RelUnion.class) {
graph = new UnionGraph(first, second);
} else if (relClass == RelIntersection.class) {
graph = new IntersectionGraph(first, second);
} else if (relClass == RelComposition.class) {
graph = new CompositionGraph(first, second);
} else if (relClass == RelMinus.class) {
graph = new DifferenceGraph(first, second);
} else {
throw new UnsupportedOperationException(relClass.toString() + " has no associated graph yet.");
}
} else if (rel.isStaticRelation()) {
if (relClass == RelCartesian.class) {
RelCartesian cartRel = (RelCartesian) rel;
SetPredicate lhs = getOrCreateSetFromFilter(cartRel.getFirstFilter());
SetPredicate rhs = getOrCreateSetFromFilter(cartRel.getSecondFilter());
graph = new CartesianGraph(lhs, rhs);
} else if (relClass == RelRMW.class) {
graph = new RMWGraph();
} else if (relClass == RelExt.class) {
graph = new ExternalGraph();
} else if (relClass == RelInt.class) {
graph = new InternalGraph();
} else if (relClass == RelFencerel.class) {
graph = new FenceGraph(((RelFencerel) rel).getFenceName());
} else if (relClass == RelSetIdentity.class) {
SetPredicate set = getOrCreateSetFromFilter(((RelSetIdentity) rel).getFilter());
graph = new SetIdentityGraph(set);
} else if (relClass == RelId.class) {
graph = new IdentityGraph();
} else if (relClass == RelEmpty.class) {
graph = new EmptyGraph();
} else {
// This is a fallback for all unimplemented static graphs
graph = new StaticDefaultWMMGraph(rel);
}
} else {
throw new UnsupportedOperationException(relClass.toString() + " has no associated graph yet.");
}
graph.setName(rel.getName());
relationGraphMap.put(rel, graph);
return graph;
}
use of com.dat3m.dartagnan.solver.caat.predicates.relationGraphs.RelationGraph in project Dat3M by hernanponcedeleon.
the class IntersectionGraph method forwardPropagate.
@Override
@SuppressWarnings("unchecked")
public Collection<Edge> forwardPropagate(CAATPredicate changedSource, Collection<? extends Derivable> added) {
if (changedSource == first || changedSource == second) {
RelationGraph other = (changedSource == first) ? second : first;
Collection<Edge> addedEdges = (Collection<Edge>) added;
List<Edge> newlyAdded = new ArrayList<>();
for (Edge e1 : addedEdges) {
Edge e2 = other.get(e1);
if (e2 != null) {
Edge e = derive(e1, e2);
simpleGraph.add(e);
newlyAdded.add(e);
}
}
return newlyAdded;
} else {
return Collections.emptyList();
}
}
use of com.dat3m.dartagnan.solver.caat.predicates.relationGraphs.RelationGraph in project Dat3M by hernanponcedeleon.
the class ExecutionGraph method constructMappings.
// --------------------------------------------------
private void constructMappings(boolean createOnlyAxiomRelevantGraphs) {
Set<RelationGraph> graphs = new HashSet<>();
Set<Constraint> constraints = new HashSet<>();
for (Axiom axiom : verificationTask.getAxioms()) {
Constraint constraint = getOrCreateConstraintFromAxiom(axiom);
constraints.add(constraint);
}
if (!createOnlyAxiomRelevantGraphs) {
for (Relation rel : verificationTask.getRelationDependencyGraph().getNodeContents()) {
if (!EXCLUDED_RELS.contains(rel.getName())) {
RelationGraph graph = getOrCreateGraphFromRelation(rel);
graphs.add(graph);
}
}
}
caatModel = CAATModel.from(graphs, constraints);
}
Aggregations