}
boolean propagateTheChange(Node currentNode) {
- HashSet<Node> changed = new HashSet<Node>(currentNode.getSuccessors());
- HashMap<Node, HashSet<Node>> parentQueueMap = new HashMap<Node, HashSet<Node>>();
- HashSet<Node> parents = new HashSet<Node>();
- parents.add(currentNode);
-
- for (Node node : currentNode.getSuccessors()) {
- parentQueueMap.put(node, parents);
+ HashSet<Node> changed = new HashSet<Node>();
+ boolean isChanged = false;
+
+ // Add the current node to the changed set
+ changed.add(currentNode);
+
+ while(!changed.isEmpty()) {
+ // Get the first element of the changed set and remove it
+ Node nodeToProcess = changed.iterator().next();
+ changed.remove(nodeToProcess);
+
+ // Update all the successors of the node
+ for (Node node : nodeToProcess.getSuccessors()) {
+ isChanged = false;
+ isChanged = updateTheOutSet(nodeToProcess, node);
+ if (isChanged) {
+ changed.add(node);
+ if (checkAllSuccForConflict(node))
+ return true;
}
-
- while(!changed.isEmpty()) {
- // Get the first element of the changed set and remove it
- Node nodeToProcess = changed.iterator().next();
- changed.remove(nodeToProcess);
-
- // Update the changed parents
- parents = parentQueueMap.get(nodeToProcess);
- boolean isChanged = false;
-
- for (Node node : parents) {
- // Update the edge
- isChanged |= updateTheOutSet(node, nodeToProcess);
- }
-
- // Check for a conflict if the outSet of nodeToProcess is changed
- if (isChanged) {
- for (Node node : nodeToProcess.getSuccessors()) {
- HashMap<Transition, ArrayList<NameValuePair>> setSets = nodeToProcess.getOutgoingEdges().get(node).getSetSetMap();
- for (Map.Entry mapElement : setSets.entrySet()) {
- Transition transition = (Transition)mapElement.getKey();
- if (checkForConflict(nodeToProcess, node, transition))
- return true;
- }
- }
- }
-
- // Update the parents list for the successors of the current node
- parents = new HashSet<Node>();
- parents.add(nodeToProcess);
-
- // Checking if the out set has changed or not(Add its successors to the change list!)
- if (isChanged) {
- for (Node i : nodeToProcess.getSuccessors()) {
- if (!changed.contains(i))
- changed.add(i);
-
- // Update the list of updated parents for the current node
- if (parentQueueMap.containsKey(i))
- parentQueueMap.get(i).add(nodeToProcess);
- else
- parentQueueMap.put(i, parents);
- }
- }
}
-
- return false;
+ }
+ return false;
}
String createErrorMessage(NameValuePair pair, HashMap<String, String> valueMap, HashMap<String, Integer> writerMap) {
- String message = "Conflict found between the two apps. App"+pair.getAppNum()+
- " has written the value: "+pair.getValue()+
- " to the variable: "+pair.getVarName()+" while App"
- +writerMap.get(pair.getVarName())+" is overwriting the value: "
- +valueMap.get(pair.getVarName())+" to the same variable!";
- System.out.println(message);
- return message;
+ String message = "Conflict found between the two apps. App"+pair.getAppNum()+
+ " has written the value: "+pair.getValue()+
+ " to the variable: "+pair.getVarName()+" while App"
+ +writerMap.get(pair.getVarName())+" is overwriting the value: "
+ +valueMap.get(pair.getVarName())+" to the same variable!";
+ System.out.println(message);
+ return message;
}
- boolean checkForConflict(Node parentNode, Node currentNode, Transition currentTransition) {
- ArrayList<NameValuePair> setSet = parentNode.getOutgoingEdges().get(currentNode).getSetSetMap().get(currentTransition);
- HashMap<String, String> valueMap = new HashMap<String, String>(); // HashMap from varName to value
- HashMap<String, Integer> writerMap = new HashMap<String, Integer>(); // HashMap from varName to appNum
-
-
- System.out.println("#########################Set Set:");
- for (int i = 0;i < setSet.size();i++) {
- NameValuePair nameValuePair = setSet.get(i);
- String varName = nameValuePair.getVarName();
- String value = nameValuePair.getValue();
- Integer appNum = nameValuePair.getAppNum();
+ boolean checkAllSuccForConflict(Node currentNode) {
+ for (Node node : currentNode.getSuccessors()) {
+ HashMap<Transition, ArrayList<NameValuePair>> setSets = currentNode.getOutgoingEdges().get(node).getSetSetMap();
+ for (Map.Entry mapElement : setSets.entrySet()) {
+ Transition transition = (Transition)mapElement.getKey();
+ if (checkForConflict(currentNode, node, transition))
+ return true;
+ }
+ }
+ return false;
+ }
- System.out.println("varName="+varName+", value="+value+", appNum="+appNum);
+ boolean checkForConflict(Node parentNode, Node currentNode, Transition currentTransition) {
+ ArrayList<NameValuePair> setSet = parentNode.getOutgoingEdges().get(currentNode).getSetSetMap().get(currentTransition);
+ HashMap<String, String> valueMap = new HashMap<String, String>(); // HashMap from varName to value
+ HashMap<String, Integer> writerMap = new HashMap<String, Integer>(); // HashMap from varName to appNum
+ HashMap<String, String> firstValueMap = new HashMap<String, String>(); // HashMap from varName to value - first instruction in transition
+ HashMap<String, Integer> firstWriterMap = new HashMap<String, Integer>(); // HashMap from varName to appNum - first instruction in transition
+
+ // Update the valueMap and writerMap + check for conflict between the elements of setSet
+ for (int i = 0;i < setSet.size();i++) {
+ NameValuePair nameValuePair = setSet.get(i);
+ String varName = nameValuePair.getVarName();
+ String value = nameValuePair.getValue();
+ Integer appNum = nameValuePair.getAppNum();
+ Boolean isManual = nameValuePair.getIsManual();
+
+ if (valueMap.containsKey(varName)) {
+ // Check if we have a same writer
+ if (!writerMap.get(varName).equals(appNum)) {
+ // Check if we have a conflict or not
+ if (!valueMap.get(varName).equals(value)) {
+ errorMessage = createErrorMessage(nameValuePair, valueMap, writerMap);
+ return true;
+ }
}
- System.out.println("+++++++++++++++++++++++++Out Set:");
- for (NameValuePair nameValuePair : currentNode.getOutSet()) {
- String varName = nameValuePair.getVarName();
- String value = nameValuePair.getValue();
- Integer appNum = nameValuePair.getAppNum();
-
- System.out.println("varName="+varName+", value="+value+", appNum="+appNum);
- }
-
- // Update the valueMap and writerMap + check for conflict between the elements of setSet
- for (int i = 0;i < setSet.size();i++) {
- NameValuePair nameValuePair = setSet.get(i);
- String varName = nameValuePair.getVarName();
- String value = nameValuePair.getValue();
- Integer appNum = nameValuePair.getAppNum();
-
- if (valueMap.containsKey(varName)) {
- // Check if we have a same writer
- if (!writerMap.get(varName).equals(appNum)) {
- // Check if we have a conflict or not
- if (!valueMap.get(varName).equals(value)) {
- errorMessage = createErrorMessage(nameValuePair, valueMap, writerMap);
- return true;
- } else { // We have two writers writing the same value
- writerMap.put(varName, 3); // 3 represents both apps
- }
- } else {
- // Check if we have more than one value with the same writer
- if (!valueMap.get(varName).equals(value)) {
- // We have one writer writing more than one value in a same event
- valueMap.put(varName, "twoValue");
- }
- }
- } else {
- valueMap.put(varName, value);
- writerMap.put(varName, appNum);
- }
+ valueMap.put(varName, value);
+ writerMap.put(varName, appNum);
+ } else {
+ valueMap.put(varName, value);
+ writerMap.put(varName, appNum);
+ if (!isManual) {
+ firstValueMap.put(varName, value);
+ firstWriterMap.put(varName, appNum);
}
+ }
+ }
- // Check for conflict between outSet and this transition setSet
- for (NameValuePair i : currentNode.getOutSet()) {
- if (valueMap.containsKey(i.getVarName())) {
- String value = valueMap.get(i.getVarName());
- Integer writer = writerMap.get(i.getVarName());
- if ((value != null)&&(writer != null)) {
- if (!value.equals(i.getValue())&&!writer.equals(i.getAppNum())) {
- // We have different values and different writers
- errorMessage = createErrorMessage(i, valueMap, writerMap);
- return true;
- }
- }
- }
- }
-
- return false;
+ // Check for conflict between outSet and this transition setSet
+ for (NameValuePair i : parentNode.getOutSet()) {
+ if (firstValueMap.containsKey(i.getVarName())) {
+ String value = firstValueMap.get(i.getVarName());
+ Integer writer = firstWriterMap.get(i.getVarName());
+ if ((value != null)&&(writer != null)) {
+ if (!value.equals(i.getValue())&&!writer.equals(i.getAppNum())) {
+ // We have different values and different writers
+ errorMessage = createErrorMessage(i, firstValueMap, firstWriterMap);
+ return true;
+ }
+ }
+ }
+ }
+ return false;
}
boolean updateTheOutSet(Node parentNode, Node currentNode) {
- HashMap<Transition, ArrayList<NameValuePair>> setSets = parentNode.getOutgoingEdges().get(currentNode).getSetSetMap();
- HashSet<String> updatedVarNames = new HashSet<String>();
- Edge currentEdge = parentNode.getOutgoingEdges().get(currentNode);
- HashMap<String, Integer> lastWriter = currentEdge.getLastWriter();
- HashMap<String, String> lastValue = currentEdge.getLastValue();
- HashMap<String, Integer> outSetVarMap = new HashMap<String, Integer>();
- boolean isChanged = false;
-
- for (Map.Entry mapElement : setSets.entrySet()) {
- ArrayList<NameValuePair> setSet = (ArrayList<NameValuePair>)mapElement.getValue();
+ Edge edge = parentNode.getOutgoingEdges().get(currentNode);
+ HashMap<Transition, ArrayList<NameValuePair>> setSets = edge.getSetSetMap();
+ HashSet<String> updatedVarNames = new HashSet<String>();
+ HashSet<String> outSetVarMap = new HashSet<String>();
+ boolean isChanged = false;
+
+ for (Map.Entry mapElement : setSets.entrySet()) {
+ ArrayList<NameValuePair> setSet = (ArrayList<NameValuePair>)mapElement.getValue();
- for (int i = 0;i < setSet.size();i++) {
- updatedVarNames.add(setSet.get(i).getVarName());
- }
- }
-
+ for (int i = 0;i < setSet.size();i++) {
+ updatedVarNames.add(setSet.get(i).getVarName());
+ }
+ }
- for (NameValuePair i : parentNode.getOutSet()) {
- outSetVarMap.put(i.getVarName(), i.getAppNum());
- if (!updatedVarNames.contains(i.getVarName()))
- isChanged |= currentNode.getOutSet().add(i);
- }
+ for (NameValuePair i : parentNode.getOutSet()) {
+ outSetVarMap.add(i.getVarName());
+ if (!updatedVarNames.contains(i.getVarName()))
+ isChanged |= currentNode.getOutSet().add(i);
+ }
+ ArrayList<NameValuePair> lastSetSet = setSets.get(edge.getFinalTransition());
- for (Map.Entry mapElement : setSets.entrySet()) {
- ArrayList<NameValuePair> setSet = (ArrayList<NameValuePair>)mapElement.getValue();
-
- for (int i = 0;i < setSet.size();i++) {
- String varName = setSet.get(i).getVarName();
- Integer writer = lastWriter.get(varName);
- String value = lastValue.get(varName);
-
- if (setSet.get(i).getAppNum().equals(writer)
- && setSet.get(i).getValue().equals(value)) {
- if (outSetVarMap.containsKey(varName)) {
- Integer hashCode = outSetVarMap.get(varName).hashCode() * 31 +
- varName.hashCode();
- currentNode.getOutSet().remove(hashCode);
- }
- isChanged |= currentNode.getOutSet().add(setSet.get(i));
- }
- }
- }
+ for (int i = 0;i < lastSetSet.size();i++) {
+ String var = lastSetSet.get(i).getVarName();
- return isChanged;
+ if (outSetVarMap.contains(var)) {
+ currentNode.getOutSet().remove(lastSetSet.get(i));
+ }
+ isChanged |= currentNode.getOutSet().add(lastSetSet.get(i));
+ }
+ return isChanged;
}
void updateTheEdge(Node currentNode, Transition transition) {
- if (parentNode.getOutgoingEdges().containsKey(currentNode)) {
- Edge currentEdge = parentNode.getOutgoingEdges().get(currentNode);
- if (currentEdge.getSetSetMap().containsKey(transition)) { // Update the transition
- if (manual)
- currentEdge.getSetSetMap().put(transition, tempSetSet);
- else
- currentEdge.getSetSetMap().get(transition).addAll(tempSetSet);
- } else { // Add a new transition
- currentEdge.getSetSetMap().put(transition, tempSetSet);
- }
- } else {
- parentNode.getOutgoingEdges().put(currentNode, new Edge(parentNode, currentNode));
- Edge currentEdge = parentNode.getOutgoingEdges().get(currentNode);
- currentEdge.getSetSetMap().put(transition, tempSetSet);
- }
-
- // Update the last writer and last value for this edge for each varName
- Edge currentEdge = parentNode.getOutgoingEdges().get(currentNode);
- ArrayList<NameValuePair> setSet = currentEdge.getSetSetMap().get(transition);
- for (int i = 0;i < setSet.size();i++) {
- NameValuePair nameValuePair = setSet.get(i);
- currentEdge.getLastWriter().put(nameValuePair.getVarName(), nameValuePair.getAppNum());
- currentEdge.getLastValue().put(nameValuePair.getVarName(), nameValuePair.getValue());
- }
+ if (parentNode.getOutgoingEdges().containsKey(currentNode)) {
+ Edge currentEdge = parentNode.getOutgoingEdges().get(currentNode);
+ if (currentEdge.getSetSetMap().containsKey(transition)) { // Update the transition
+ if (manual)
+ currentEdge.getSetSetMap().put(transition, tempSetSet);
+ else
+ currentEdge.getSetSetMap().get(transition).addAll(tempSetSet);
+ } else { // Add a new transition
+ currentEdge.getSetSetMap().put(transition, tempSetSet);
+ }
+ currentEdge.setFinalTransition(transition);
+ } else {
+ parentNode.getOutgoingEdges().put(currentNode, new Edge(parentNode, currentNode));
+ Edge currentEdge = parentNode.getOutgoingEdges().get(currentNode);
+ currentEdge.getSetSetMap().put(transition, tempSetSet);
+ currentEdge.setFinalTransition(transition);
+ }
}
-
-
static class Node {
- Integer id;
- HashSet<Node> predecessors = new HashSet<Node>();
- HashSet<Node> successors = new HashSet<Node>();
- HashSet<NameValuePair> outSet = new HashSet<NameValuePair>();
- HashMap<Node, Edge> outgoingEdges = new HashMap<Node, Edge>();
-
- Node(Integer id) {
- this.id = id;
- }
+ Integer id;
+ HashSet<Node> predecessors = new HashSet<Node>();
+ HashSet<Node> successors = new HashSet<Node>();
+ HashSet<NameValuePair> outSet = new HashSet<NameValuePair>();
+ HashMap<Node, Edge> outgoingEdges = new HashMap<Node, Edge>();
+
+ Node(Integer id) {
+ this.id = id;
+ }
- Integer getId() {
- return id;
- }
+ Integer getId() {
+ return id;
+ }
- HashSet<Node> getPredecessors() {
- return predecessors;
- }
+ HashSet<Node> getPredecessors() {
+ return predecessors;
+ }
- HashSet<Node> getSuccessors() {
- return successors;
- }
+ HashSet<Node> getSuccessors() {
+ return successors;
+ }
- HashSet<NameValuePair> getOutSet() {
- return outSet;
- }
+ HashSet<NameValuePair> getOutSet() {
+ return outSet;
+ }
- HashMap<Node, Edge> getOutgoingEdges() {
- return outgoingEdges;
- }
+ HashMap<Node, Edge> getOutgoingEdges() {
+ return outgoingEdges;
+ }
}
static class Edge {
- Node source, destination;
- HashMap<String, Integer> lastWriter = new HashMap<String, Integer>();
- HashMap<String, String> lastValue = new HashMap<String, String>();
- HashMap<Transition, ArrayList<NameValuePair>> setSetMap = new HashMap<Transition, ArrayList<NameValuePair>>();
-
- Edge(Node source, Node destination) {
- this.source = source;
- this.destination = destination;
- }
+ Node source, destination;
+ Transition finalTransition;
+ HashMap<String, Integer> lastWriter = new HashMap<String, Integer>();
+ HashMap<String, String> lastValue = new HashMap<String, String>();
+ HashMap<Transition, ArrayList<NameValuePair>> setSetMap = new HashMap<Transition, ArrayList<NameValuePair>>();
+
+ Edge(Node source, Node destination) {
+ this.source = source;
+ this.destination = destination;
+ }
- Node getSource() {
- return source;
- }
+ Node getSource() {
+ return source;
+ }
- Node getDestination() {
- return destination;
- }
+ Node getDestination() {
+ return destination;
+ }
- HashMap<Transition, ArrayList<NameValuePair>> getSetSetMap() {
- return setSetMap;
- }
+ Transition getFinalTransition() {
+ return finalTransition;
+ }
- HashMap<String, Integer> getLastWriter() {
- return lastWriter;
- }
+ void setFinalTransition(Transition transition) {
+ finalTransition = transition;
+ }
- HashMap<String, String> getLastValue() {
- return lastValue;
- }
+ HashMap<Transition, ArrayList<NameValuePair>> getSetSetMap() {
+ return setSetMap;
+ }
+
+ HashMap<String, Integer> getLastWriter() {
+ return lastWriter;
+ }
+
+ HashMap<String, String> getLastValue() {
+ return lastValue;
+ }
}
static class NameValuePair {
- Integer appNum;
- String value;
- String varName;
- boolean isManual;
-
- NameValuePair(Integer appNum, String value, String varName, boolean isManual) {
- this.appNum = appNum;
- this.value = value;
- this.varName = varName;
- this.isManual = isManual;
- }
+ Integer appNum;
+ String value;
+ String varName;
+ boolean isManual;
+
+ NameValuePair(Integer appNum, String value, String varName, boolean isManual) {
+ this.appNum = appNum;
+ this.value = value;
+ this.varName = varName;
+ this.isManual = isManual;
+ }
- void setAppNum(Integer appNum) {
- this.appNum = appNum;
- }
+ void setAppNum(Integer appNum) {
+ this.appNum = appNum;
+ }
- void setValue(String value) {
- this.value = value;
- }
+ void setValue(String value) {
+ this.value = value;
+ }
- void setVarName(String varName) {
- this.varName = varName;
- }
+ void setVarName(String varName) {
+ this.varName = varName;
+ }
- void setIsManual(String varName) {
- this.isManual = isManual;
- }
+ void setIsManual(String varName) {
+ this.isManual = isManual;
+ }
- Integer getAppNum() {
- return appNum;
- }
+ Integer getAppNum() {
+ return appNum;
+ }
- String getValue() {
- return value;
- }
+ String getValue() {
+ return value;
+ }
- String getVarName() {
- return varName;
- }
+ String getVarName() {
+ return varName;
+ }
- boolean getIsManual() {
- return isManual;
- }
+ boolean getIsManual() {
+ return isManual;
+ }
- @Override
- public boolean equals(Object o) {
+ @Override
+ public boolean equals(Object o) {
if (o instanceof NameValuePair) {
NameValuePair other = (NameValuePair) o;
if (varName.equals(other.getVarName()))
return appNum.equals(other.getAppNum());
}
return false;
- }
+ }
- @Override
- public int hashCode() {
- return appNum.hashCode() * 31 + varName.hashCode();
- }
+ @Override
+ public int hashCode() {
+ return appNum.hashCode() * 31 + varName.hashCode();
+ }
}
@Override
// Update the parent node
if (nodes.containsKey(id)) {
- parentNode = nodes.get(id);
+ parentNode = nodes.get(id);
} else {
- parentNode = new Node(id);
+ parentNode = new Node(id);
}
}
// Add the node to the list of nodes
if (nodes.get(id) == null)
- nodes.put(id, new Node(id));
+ nodes.put(id, new Node(id));
Node currentNode = nodes.get(id);
// Updating the predecessors for this node
// Check if parent node is already in successors of the current node or not
if (!(currentNode.getPredecessors().contains(parentNode)))
- currentNode.getPredecessors().add(parentNode);
+ currentNode.getPredecessors().add(parentNode);
// Update the successors for this node
// Check if current node is already in successors of the parent node or not
if (!(parentNode.getSuccessors().contains(currentNode)))
- parentNode.getSuccessors().add(currentNode);
+ parentNode.getSuccessors().add(currentNode);
// Update the outset of the current node and check if it is changed or not to propagate the change
boolean isChanged = updateTheOutSet(parentNode, currentNode);
-
+
// Check if the outSet of this state has changed, update all of its successors' sets if any
- if (isChanged) {
- for (Node node : currentNode.getSuccessors()) {
- HashMap<Transition, ArrayList<NameValuePair>> setSets = currentNode.getOutgoingEdges().get(node).getSetSetMap();
- for (Map.Entry mapElement : setSets.entrySet()) {
- Transition currentTransition = (Transition)mapElement.getKey();
- conflictFound = conflictFound || checkForConflict(currentNode, node, currentTransition);
- }
- }
- conflictFound = conflictFound || propagateTheChange(currentNode);
- }
+ if (isChanged)
+ conflictFound = conflictFound || checkAllSuccForConflict(currentNode) || propagateTheChange(currentNode);
+
// Update the parent node
if (nodes.containsKey(id)) {
- parentNode = nodes.get(id);
+ parentNode = nodes.get(id);
} else {
- parentNode = new Node(id);
+ parentNode = new Node(id);
}
}
// Update the parent node
if (nodes.containsKey(id)) {
- parentNode = nodes.get(id);
+ parentNode = nodes.get(id);
} else {
- parentNode = new Node(id);
+ parentNode = new Node(id);
}
}
// Update the temporary Set set.
NameValuePair temp = new NameValuePair(1, value, var, manual);
if (writer.equals("App2"))
- temp = new NameValuePair(2, value, var, manual);
+ temp = new NameValuePair(2, value, var, manual);
tempSetSet.add(temp);
}
MethodInfo mi = executedInsn.getMethodInfo();
// Find the last load before return and get the value here
if (mi.getName().equals(SET_LOCATION_METHOD) &&
- executedInsn instanceof ALOAD && nextInsn instanceof ARETURN) {
+ executedInsn instanceof ALOAD && nextInsn instanceof ARETURN) {
byte type = getType(ti, executedInsn);
String value = getValue(ti, executedInsn, type);
if (getWriter(ti.getStack(), manualSet) != null)
manual = true;
-
+
// Update the temporary Set set.
writeWriterAndValue(writer, value, var);
}
projects / jpf-core.git / blobdiff