private HashSet<Integer> prevVisitedStates; // States visited in the previous execution
private HashMap<Integer, HashSet<Integer>> stateToEventMap;
// Data structure to analyze field Read/Write accesses and conflicts
- private HashMap<Integer, LinkedList<Integer[]>> backtrackMap; // Track created backtracking points
+ private HashMap<Integer, LinkedList<BacktrackExecution>> backtrackMap; // Track created backtracking points
private PriorityQueue<Integer> backtrackStateQ; // Heap that returns the latest state
- private ArrayList<BacktrackPoint> backtrackPointList; // Record backtrack points (CG, state Id, and choice)
- private HashMap<Integer, HashSet<Integer>> conflictPairMap; // Record conflicting events
+ private Execution currentExecution; // Holds the information about the current execution
private HashSet<String> doneBacktrackSet; // Record state ID and trace already constructed
- private HashMap<Integer, ReadWriteSet> readWriteFieldsMap; // Record fields that are accessed
private HashMap<Integer, RestorableVMState> restorableStateMap; // Maps state IDs to the restorable state object
private HashMap<Integer, Integer> stateToChoiceCounterMap; // Maps state IDs to the choice counter
+ //private HashMap<Integer, ArrayList<ReachableTrace>> rGraph; // Create a reachability graph
+ private HashMap<Integer, ArrayList<Execution>> rGraph; // Create a reachability graph for past executions
// Boolean states
private boolean isBooleanCGFlipped;
if (!nextInsn.getMethodInfo().getName().equals("<init>")) {
String fieldClass = ((JVMFieldInstruction) nextInsn).getFieldInfo().getFullName();
if (!isFieldExcluded(fieldClass)) {
- // Check for conflict (go backward from current choice and get the first conflict)
- for (int eventCounter = currentChoice - 1; eventCounter >= 0; eventCounter--) {
- // Check for conflicts with Write fields for both Read and Write instructions
- // Check and record a backtrack set for just once!
- if (isConflictFound(nextInsn, eventCounter, currentChoice, fieldClass) &&
- isNewConflict(currentChoice, eventCounter)) {
- createBacktrackingPoint(currentChoice, eventCounter);
- }
- }
+ findFirstConflictAndCreateBacktrackPoint(currentChoice, nextInsn, fieldClass);
}
}
}
// -- INNER CLASSES
+ // This class compactly stores backtrack execution:
+ // 1) backtrack choice list, and
+ // 2) backtrack execution
+ private class BacktrackExecution {
+ private Integer[] choiceList;
+ private Execution execution;
+
+ public BacktrackExecution(Integer[] choList, Execution exec) {
+ choiceList = choList;
+ execution = exec;
+ }
+
+ public Integer[] getChoiceList() {
+ return choiceList;
+ }
+
+ public Execution getExecution() {
+ return execution;
+ }
+ }
+
+ // This class compactly stores backtrack points:
+ // 1) backtrack state ID, and
+ // 2) backtracking choices
+ private class BacktrackPoint {
+ private IntChoiceFromSet backtrackCG; // CG at this backtrack point
+ private int stateId; // State at this backtrack point
+ private int choice; // Choice chosen at this backtrack point
+
+ public BacktrackPoint(IntChoiceFromSet cg, int stId, int cho) {
+ backtrackCG = cg;
+ stateId = stId;
+ choice = cho;
+ }
+
+ public IntChoiceFromSet getBacktrackCG() { return backtrackCG; }
+
+ public int getStateId() {
+ return stateId;
+ }
+
+ public int getChoice() {
+ return choice;
+ }
+ }
+
+ // This class stores a representation of the execution graph node
+ private class Execution {
+ private ArrayList<BacktrackPoint> executionTrace; // The BacktrackPoint objects of this execution
+ private int parentChoice; // The parent's choice that leads to this execution
+ private Execution parent; // Store the parent for backward DFS to find conflicts
+ private HashMap<Integer, ReadWriteSet> readWriteFieldsMap; // Record fields that are accessed
+
+ public Execution() {
+ executionTrace = new ArrayList<>();
+ parentChoice = -1;
+ parent = null;
+ readWriteFieldsMap = new HashMap<>();
+ }
+
+ public void addBacktrackPoint(BacktrackPoint newBacktrackPoint) {
+ executionTrace.add(newBacktrackPoint);
+ }
+
+ public ArrayList<BacktrackPoint> getExecutionTrace() {
+ return executionTrace;
+ }
+
+ public int getParentChoice() {
+ return parentChoice;
+ }
+
+ public Execution getParent() {
+ return parent;
+ }
+
+ public HashMap<Integer, ReadWriteSet> getReadWriteFieldsMap() {
+ return readWriteFieldsMap;
+ }
+
+ public void setParentChoice(int parChoice) {
+ parentChoice = parChoice;
+ }
+
+ public void setParent(Execution par) {
+ parent = par;
+ }
+ }
+
// This class compactly stores Read and Write field sets
// We store the field name and its object ID
// Sharing the same field means the same field name and object ID
}
}
- // This class compactly stores backtrack points: 1) backtrack state ID, and 2) backtracking choices
- private class BacktrackPoint {
- private IntChoiceFromSet backtrackCG; // CG at this backtrack point
- private int stateId; // State at this backtrack point
- private int choice; // Choice chosen at this backtrack point
-
- public BacktrackPoint(IntChoiceFromSet cg, int stId, int cho) {
- backtrackCG = cg;
- stateId = stId;
- choice = cho;
- }
-
- public IntChoiceFromSet getBacktrackCG() { return backtrackCG; }
-
- public int getStateId() {
- return stateId;
- }
-
- public int getChoice() {
- return choice;
- }
- }
+ // This class stores a compact representation of a reachability graph for past executions
+// private class ReachableTrace {
+// private ArrayList<BacktrackPoint> pastBacktrackPointList;
+// private HashMap<Integer, ReadWriteSet> pastReadWriteFieldsMap;
+//
+// public ReachableTrace(ArrayList<BacktrackPoint> btrackPointList,
+// HashMap<Integer, ReadWriteSet> rwFieldsMap) {
+// pastBacktrackPointList = btrackPointList;
+// pastReadWriteFieldsMap = rwFieldsMap;
+// }
+//
+// public ArrayList<BacktrackPoint> getPastBacktrackPointList() {
+// return pastBacktrackPointList;
+// }
+//
+// public HashMap<Integer, ReadWriteSet> getPastReadWriteFieldsMap() {
+// return pastReadWriteFieldsMap;
+// }
+// }
// -- CONSTANTS
private final static String DO_CALL_METHOD = "doCall";
}
// Record state ID and choice/event as backtrack point
int stateId = vm.getStateId();
- backtrackPointList.add(new BacktrackPoint(icsCG, stateId, refChoices[choiceIndex]));
+ currentExecution.addBacktrackPoint(new BacktrackPoint(icsCG, stateId, refChoices[choiceIndex]));
// Store restorable state object for this state (always store the latest)
RestorableVMState restorableState = vm.getRestorableState();
restorableStateMap.put(stateId, restorableState);
return copyOfChoices;
}
- // --- Functions related to cycle detection
+ // --- Functions related to cycle detection and reachability graph
// Detect cycles in the current execution/trace
// We terminate the execution iff:
// Backtracking
backtrackMap = new HashMap<>();
backtrackStateQ = new PriorityQueue<>(Collections.reverseOrder());
- backtrackPointList = new ArrayList<>();
- conflictPairMap = new HashMap<>();
+ currentExecution = new Execution();
doneBacktrackSet = new HashSet<>();
- readWriteFieldsMap = new HashMap<>();
stateToChoiceCounterMap = new HashMap<>();
+ rGraph = new HashMap<>();
// Booleans
isEndOfExecution = false;
}
}
}
+ private void saveExecutionToRGraph(int stateId) {
+ // Save execution state into the reachability graph only if
+ // (1) It is not a revisited state from a past execution, or
+ // (2) It is just a new backtracking point
+ if (!prevVisitedStates.contains(stateId) ||
+ choiceCounter <= 1) {
+ ArrayList<Execution> reachableExecutions;
+ if (!prevVisitedStates.contains(stateId)) {
+ reachableExecutions = new ArrayList<>();
+ rGraph.put(stateId, reachableExecutions);
+ } else {
+ reachableExecutions = rGraph.get(stateId);
+ }
+ reachableExecutions.add(currentExecution);
+ }
+ }
+
private boolean terminateCurrentExecution() {
// We need to check all the states that have just been visited
// Often a transition (choice/event) can result into forwarding/backtracking to a number of states
HashSet<Integer> eventSet = new HashSet<>();
stateToEventMap.put(stateId, eventSet);
}
- stateToChoiceCounterMap.put(stateId, choiceCounter);
+ saveExecutionToRGraph(stateId);
analyzeReachabilityAndCreateBacktrackPoints(search.getVM(), stateId);
+ stateToChoiceCounterMap.put(stateId, choiceCounter);
justVisitedStates.add(stateId);
currVisitedStates.add(stateId);
}
// --- Functions related to Read/Write access analysis on shared fields
- private void addNewBacktrackPoint(int stateId, Integer[] newChoiceList) {
+ private void addNewBacktrackPoint(int stateId, Integer[] newChoiceList, Execution parentExecution, int parentChoice) {
// Insert backtrack point to the right state ID
- LinkedList<Integer[]> backtrackList;
+ LinkedList<BacktrackExecution> backtrackExecList;
if (backtrackMap.containsKey(stateId)) {
- backtrackList = backtrackMap.get(stateId);
+ backtrackExecList = backtrackMap.get(stateId);
} else {
- backtrackList = new LinkedList<>();
- backtrackMap.put(stateId, backtrackList);
+ backtrackExecList = new LinkedList<>();
+ backtrackMap.put(stateId, backtrackExecList);
}
- backtrackList.addFirst(newChoiceList);
+ // Add the new backtrack execution object
+ Execution newExecution = new Execution();
+ newExecution.setParent(parentExecution);
+ newExecution.setParentChoice(parentChoice);
+ backtrackExecList.addFirst(new BacktrackExecution(newChoiceList, newExecution));
// Add to priority queue
if (!backtrackStateQ.contains(stateId)) {
backtrackStateQ.add(stateId);
return currentChoice;
}
- private void createBacktrackingPoint(int currentChoice, int confEvtNum) {
+ private void createBacktrackingPoint(int backtrackChoice, int conflictChoice, Execution execution) {
// Create a new list of choices for backtrack based on the current choice and conflicting event number
// E.g. if we have a conflict between 1 and 3, then we create the list {3, 1, 0, 2}
// for the original set {0, 1, 2, 3}
Integer[] newChoiceList = new Integer[refChoices.length];
+ //int firstChoice = choices[actualChoice];
+ ArrayList<BacktrackPoint> pastTrace = execution.getExecutionTrace();
+ ArrayList<BacktrackPoint> currTrace = currentExecution.getExecutionTrace();
+ int btrackChoice = currTrace.get(backtrackChoice).getChoice();
+ int stateId = pastTrace.get(conflictChoice).getStateId();
+ // Check if this trace has been done from this state
+ if (isTraceAlreadyConstructed(btrackChoice, stateId)) {
+ return;
+ }
// Put the conflicting event numbers first and reverse the order
- int actualCurrCho = currentChoice % refChoices.length;
- // We use the actual choices here in case they have been modified/adjusted by the fair scheduling method
- newChoiceList[0] = choices[actualCurrCho];
- newChoiceList[1] = backtrackPointList.get(confEvtNum).getChoice();
+ newChoiceList[0] = btrackChoice;
+ newChoiceList[1] = pastTrace.get(conflictChoice).getChoice();
// Put the rest of the event numbers into the array starting from the minimum to the upper bound
for (int i = 0, j = 2; i < refChoices.length; i++) {
if (refChoices[i] != newChoiceList[0] && refChoices[i] != newChoiceList[1]) {
j++;
}
}
- // Get the backtrack CG for this backtrack point
- int stateId = backtrackPointList.get(confEvtNum).getStateId();
- // Check if this trace has been done starting from this state
- if (isTraceAlreadyConstructed(newChoiceList, stateId)) {
- return;
- }
- addNewBacktrackPoint(stateId, newChoiceList);
+ // Parent choice is conflict choice - 1
+ addNewBacktrackPoint(stateId, newChoiceList, execution, conflictChoice - 1);
}
private boolean excludeThisForItContains(String[] excludedStrings, String className) {
// cgMap, backtrackMap, backtrackStateQ are updated simultaneously (checking backtrackStateQ is enough)
if (!backtrackStateQ.isEmpty()) {
// Set done all the other backtrack points
- for (BacktrackPoint backtrackPoint : backtrackPointList) {
+ for (BacktrackPoint backtrackPoint : currentExecution.getExecutionTrace()) {
backtrackPoint.getBacktrackCG().setDone();
}
// Reset the next backtrack point with the latest state
}
// Save all the visited states when starting a new execution of trace
prevVisitedStates.addAll(currVisitedStates);
- currVisitedStates.clear();
// This marks a transitional period to the new CG
isEndOfExecution = true;
}
- private ReadWriteSet getReadWriteSet(int currentChoice) {
- // Do the analysis to get Read and Write accesses to fields
- ReadWriteSet rwSet;
- // We already have an entry
- if (readWriteFieldsMap.containsKey(currentChoice)) {
- rwSet = readWriteFieldsMap.get(currentChoice);
- } else { // We need to create a new entry
- rwSet = new ReadWriteSet();
- readWriteFieldsMap.put(currentChoice, rwSet);
+ private void findFirstConflictAndCreateBacktrackPoint(int currentChoice, Instruction nextInsn, String fieldClass) {
+ // Check for conflict (go backward from current choice and get the first conflict)
+ Execution execution = currentExecution;
+ // Actual choice of the current execution trace
+ //int actualChoice = currentChoice % refChoices.length;
+ // Choice/event we want to check for conflict against (start from actual choice)
+ int pastChoice = currentChoice;
+ // Perform backward DFS through the execution graph
+ while (true) {
+ // Get the next conflict choice
+ if (pastChoice > 0) {
+ // Case #1: check against a previous choice in the same execution for conflict
+ pastChoice = pastChoice - 1;
+ } else { // pastChoice == 0 means we are at the first BacktrackPoint of this execution path
+ // Case #2: check against a previous choice in a parent execution
+ int parentChoice = execution.getParentChoice();
+ if (parentChoice > -1) {
+ // Get the parent execution
+ execution = execution.getParent();
+ pastChoice = execution.getParentChoice();
+ } else {
+ // If parent is -1 then this is the first execution (it has no parent) and we stop here
+ break;
+ }
+ }
+ // Check if a conflict is found
+ if (isConflictFound(nextInsn, fieldClass, currentChoice, pastChoice, execution)) {
+ createBacktrackingPoint(currentChoice, pastChoice, execution);
+ break; // Stop at the first found conflict
+ }
}
- return rwSet;
}
- private boolean isConflictFound(int eventCounter, int currentChoice) {
+ private boolean isConflictFound(Instruction nextInsn, String fieldClass, int currentChoice,
+ int pastChoice, Execution pastExecution) {
- int actualCurrCho = currentChoice % refChoices.length;
+ HashMap<Integer, ReadWriteSet> pastRWFieldsMap = pastExecution.getReadWriteFieldsMap();
+ ArrayList<BacktrackPoint> pastTrace = pastExecution.getExecutionTrace();
+ ArrayList<BacktrackPoint> currTrace = currentExecution.getExecutionTrace();
// Skip if this event does not have any Read/Write set or the two events are basically the same event (number)
- if (!readWriteFieldsMap.containsKey(eventCounter) ||
- choices[actualCurrCho] == backtrackPointList.get(eventCounter).getChoice()) {
+ if (!pastRWFieldsMap.containsKey(pastChoice) ||
+ //choices[actualChoice] == pastTrace.get(pastChoice).getChoice()) {
+ currTrace.get(currentChoice).getChoice() == pastTrace.get(pastChoice).getChoice()) {
+ return false;
+ }
+ HashMap<Integer, ReadWriteSet> currRWFieldsMap = pastExecution.getReadWriteFieldsMap();
+ ReadWriteSet rwSet = currRWFieldsMap.get(pastChoice);
+ int currObjId = ((JVMFieldInstruction) nextInsn).getFieldInfo().getClassInfo().getClassObjectRef();
+ // Check for conflicts with Write fields for both Read and Write instructions
+ if (((nextInsn instanceof WriteInstruction || nextInsn instanceof ReadInstruction) &&
+ rwSet.writeFieldExists(fieldClass) && rwSet.writeFieldObjectId(fieldClass) == currObjId) ||
+ (nextInsn instanceof WriteInstruction && rwSet.readFieldExists(fieldClass) &&
+ rwSet.readFieldObjectId(fieldClass) == currObjId)) {
+ return true;
+ }
+ return false;
+ }
+
+ private boolean isConflictFound(int reachableChoice, int conflictChoice, Execution execution) {
+
+ ArrayList<BacktrackPoint> executionTrace = execution.getExecutionTrace();
+ HashMap<Integer, ReadWriteSet> execRWFieldsMap = execution.getReadWriteFieldsMap();
+ // Skip if this event does not have any Read/Write set or the two events are basically the same event (number)
+ if (!execRWFieldsMap.containsKey(conflictChoice) ||
+ executionTrace.get(reachableChoice).getChoice() == executionTrace.get(conflictChoice).getChoice()) {
return false;
}
// Current R/W set
- ReadWriteSet currRWSet = readWriteFieldsMap.get(currentChoice);
+ ReadWriteSet currRWSet = execRWFieldsMap.get(reachableChoice);
// R/W set of choice/event that may have a potential conflict
- ReadWriteSet evtRWSet = readWriteFieldsMap.get(eventCounter);
+ ReadWriteSet evtRWSet = execRWFieldsMap.get(conflictChoice);
// Check for conflicts with Read and Write fields for Write instructions
Set<String> currWriteSet = currRWSet.getWriteSet();
for(String writeField : currWriteSet) {
int currObjId = currRWSet.writeFieldObjectId(writeField);
if ((evtRWSet.readFieldExists(writeField) && evtRWSet.readFieldObjectId(writeField) == currObjId) ||
- (evtRWSet.writeFieldExists(writeField) && evtRWSet.writeFieldObjectId(writeField) == currObjId)) {
+ (evtRWSet.writeFieldExists(writeField) && evtRWSet.writeFieldObjectId(writeField) == currObjId)) {
return true;
}
}
return false;
}
- private boolean isConflictFound(Instruction nextInsn, int eventCounter, int currentChoice, String fieldClass) {
-
- int actualCurrCho = currentChoice % refChoices.length;
- // Skip if this event does not have any Read/Write set or the two events are basically the same event (number)
- if (!readWriteFieldsMap.containsKey(eventCounter) ||
- choices[actualCurrCho] == backtrackPointList.get(eventCounter).getChoice()) {
- return false;
- }
- ReadWriteSet rwSet = readWriteFieldsMap.get(eventCounter);
- int currObjId = ((JVMFieldInstruction) nextInsn).getFieldInfo().getClassInfo().getClassObjectRef();
- // Check for conflicts with Write fields for both Read and Write instructions
- if (((nextInsn instanceof WriteInstruction || nextInsn instanceof ReadInstruction) &&
- rwSet.writeFieldExists(fieldClass) && rwSet.writeFieldObjectId(fieldClass) == currObjId) ||
- (nextInsn instanceof WriteInstruction && rwSet.readFieldExists(fieldClass) &&
- rwSet.readFieldObjectId(fieldClass) == currObjId)) {
- return true;
+ private ReadWriteSet getReadWriteSet(int currentChoice) {
+ // Do the analysis to get Read and Write accesses to fields
+ ReadWriteSet rwSet;
+ // We already have an entry
+ HashMap<Integer, ReadWriteSet> currReadWriteFieldsMap = currentExecution.getReadWriteFieldsMap();
+ if (currReadWriteFieldsMap.containsKey(currentChoice)) {
+ rwSet = currReadWriteFieldsMap.get(currentChoice);
+ } else { // We need to create a new entry
+ rwSet = new ReadWriteSet();
+ currReadWriteFieldsMap.put(currentChoice, rwSet);
}
- return false;
+ return rwSet;
}
private boolean isFieldExcluded(String field) {
return false;
}
- private boolean isNewConflict(int currentEvent, int eventNumber) {
- HashSet<Integer> conflictSet;
- if (!conflictPairMap.containsKey(currentEvent)) {
- conflictSet = new HashSet<>();
- conflictPairMap.put(currentEvent, conflictSet);
- } else {
- conflictSet = conflictPairMap.get(currentEvent);
- }
- // If this conflict has been recorded before, we return false because
- // we don't want to save this backtrack point twice
- if (conflictSet.contains(eventNumber)) {
- return false;
- }
- // If it hasn't been recorded, then do otherwise
- conflictSet.add(eventNumber);
- return true;
- }
-
- private boolean isTraceAlreadyConstructed(Integer[] choiceList, int stateId) {
+ private boolean isTraceAlreadyConstructed(int firstChoice, int stateId) {
// Concatenate state ID and only the first event in the string, e.g., "1:1 for the trace 10234 at state 1"
// TODO: THIS IS AN OPTIMIZATION!
// This is the optimized version because after we execute, e.g., the trace 1:10234, we don't need to try
StringBuilder sb = new StringBuilder();
sb.append(stateId);
sb.append(':');
- sb.append(choiceList[0]);
+ sb.append(firstChoice);
// Check if the trace has been constructed as a backtrack point for this state
if (doneBacktrackSet.contains(sb.toString())) {
return true;
choiceCounter = 0;
choices = icsCG.getAllChoices();
refChoices = copyChoices(choices);
- // Clearing data structures
- conflictPairMap.clear();
- readWriteFieldsMap.clear();
- stateToEventMap.clear();
+ // Clear data structures
+ currVisitedStates = new HashSet<>();
+ stateToChoiceCounterMap = new HashMap<>();
+ stateToEventMap = new HashMap<>();
isEndOfExecution = false;
- backtrackPointList.clear();
}
}
private void setBacktrackCG(int stateId, IntChoiceFromSet backtrackCG) {
// Set a backtrack CG based on a state ID
- LinkedList<Integer[]> backtrackChoices = backtrackMap.get(stateId);
- backtrackCG.setNewValues(backtrackChoices.removeLast()); // Get the last from the queue
+ LinkedList<BacktrackExecution> backtrackExecutions = backtrackMap.get(stateId);
+ BacktrackExecution backtrackExecution = backtrackExecutions.removeLast();
+ backtrackCG.setNewValues(backtrackExecution.getChoiceList()); // Get the last from the queue
backtrackCG.setStateId(stateId);
backtrackCG.reset();
+ // Update current execution with this new execution
+ Execution newExecution = backtrackExecution.getExecution();
+ if (newExecution.getParentChoice() == -1) {
+ // If it is -1 then that means we should start from the end of the parent trace for backward DFS
+ ArrayList<BacktrackPoint> parentTrace = newExecution.getParent().getExecutionTrace();
+ newExecution.setParentChoice(parentTrace.size() - 1);
+ }
+ currentExecution = newExecution;
// Remove from the queue if we don't have more backtrack points for that state
- if (backtrackChoices.isEmpty()) {
+ if (backtrackExecutions.isEmpty()) {
backtrackMap.remove(stateId);
backtrackStateQ.remove(stateId);
}
// 3) at least 2 choices/events have been explored (choiceCounter > 1),
// 4) the matched state has been encountered in the current execution, and
// 5) state > 0 (state 0 is for boolean CG)
- if (!vm.isNewState() && !isEndOfExecution && choiceCounter > 1 &&
- currVisitedStates.contains(stateId) && (stateId > 0)) {
- // Find the choice/event that marks the start of this cycle: first choice we explore for conflicts
- int conflictChoice = stateToChoiceCounterMap.get(stateId);
- int currentChoice = choiceCounter - 1;
- // Find conflicts between choices/events in this cycle (we scan forward in the cycle, not backward)
- while (conflictChoice < currentChoice) {
- for (int eventCounter = conflictChoice + 1; eventCounter <= currentChoice; eventCounter++) {
- if (isConflictFound(eventCounter, conflictChoice) && isNewConflict(conflictChoice, eventCounter)) {
- createBacktrackingPoint(conflictChoice, eventCounter);
+ if (!vm.isNewState() && !isEndOfExecution && choiceCounter > 1 && (stateId > 0)) {
+ if (currVisitedStates.contains(stateId)) {
+ // Update the backtrack sets in the cycle
+ updateBacktrackSetsInCycle(stateId);
+ } /* else if (prevVisitedStates.contains(stateId)) { // We visit a state in a previous execution
+ // Update the backtrack sets in a previous execution
+ updateBacktrackSetsInPreviousExecution(stateId);
+ }*/
+ }
+ }
+
+ // Get the start event for the past execution trace when there is a state matched from a past execution
+ private int getPastConflictChoice(int stateId, ArrayList<BacktrackPoint> pastBacktrackPointList) {
+ // Iterate and find the first occurrence of the state ID
+ // It is guaranteed that a choice should be found because the state ID is in the list
+ int pastConfChoice = 0;
+ for(int i = 0; i<pastBacktrackPointList.size(); i++) {
+ BacktrackPoint backtrackPoint = pastBacktrackPointList.get(i);
+ int stId = backtrackPoint.getStateId();
+ if (stId == stateId) {
+ pastConfChoice = i;
+ break;
+ }
+ }
+ return pastConfChoice;
+ }
+
+ // Get a sorted list of reachable state IDs starting from the input stateId
+ private ArrayList<Integer> getReachableStateIds(Set<Integer> stateIds, int stateId) {
+ // Only include state IDs equal or greater than the input stateId: these are reachable states
+ ArrayList<Integer> sortedStateIds = new ArrayList<>();
+ for(Integer stId : stateIds) {
+ if (stId >= stateId) {
+ sortedStateIds.add(stId);
+ }
+ }
+ Collections.sort(sortedStateIds);
+ return sortedStateIds;
+ }
+
+ // Update the backtrack sets in the cycle
+ private void updateBacktrackSetsInCycle(int stateId) {
+ // Find the choice/event that marks the start of this cycle: first choice we explore for conflicts
+ int reachableChoice = stateToChoiceCounterMap.get(stateId);
+ int cycleEndChoice = choiceCounter - 1;
+ // Find conflicts between choices/events in this cycle (we scan forward in the cycle, not backward)
+ while (reachableChoice < cycleEndChoice) {
+ for (int conflictChoice = reachableChoice + 1; conflictChoice <= cycleEndChoice; conflictChoice++) {
+ if (isConflictFound(reachableChoice, conflictChoice, currentExecution)) {
+ createBacktrackingPoint(reachableChoice, conflictChoice, currentExecution);
+ }
+ }
+ reachableChoice++;
+ }
+ }
+
+ // TODO: OPTIMIZATION!
+ // Check and make sure that state ID and choice haven't been explored for this trace
+ private boolean isNotChecked(HashMap<Integer, HashSet<Integer>> checkedStateIdAndChoice,
+ BacktrackPoint backtrackPoint) {
+ int stateId = backtrackPoint.getStateId();
+ int choice = backtrackPoint.getChoice();
+ HashSet<Integer> choiceSet;
+ if (checkedStateIdAndChoice.containsKey(stateId)) {
+ choiceSet = checkedStateIdAndChoice.get(stateId);
+ if (choiceSet.contains(choice)) {
+ // State ID and choice found. It has been checked!
+ return false;
+ }
+ } else {
+ choiceSet = new HashSet<>();
+ checkedStateIdAndChoice.put(stateId, choiceSet);
+ }
+ choiceSet.add(choice);
+
+ return true;
+ }
+
+ // Update the backtrack sets in a previous execution
+ private void updateBacktrackSetsInPreviousExecution(int stateId) {
+ // Don't check a past trace twice!
+ HashSet<Execution> checkedTrace = new HashSet<>();
+ // Don't check the same event twice for a revisited state
+ HashMap<Integer, HashSet<Integer>> checkedStateIdAndChoice = new HashMap<>();
+ // Get sorted reachable state IDs
+ ArrayList<Integer> reachableStateIds = getReachableStateIds(rGraph.keySet(), stateId);
+ // Iterate from this state ID until the biggest state ID
+ for(Integer stId : reachableStateIds) {
+ // Find the right reachability graph object that contains the stateId
+ ArrayList<Execution> rExecutions = rGraph.get(stId);
+ for (Execution rExecution : rExecutions) {
+ if (!checkedTrace.contains(rExecution)) {
+ // Find the choice/event that marks the start of the subtrace from the previous execution
+ ArrayList<BacktrackPoint> pastExecutionTrace = rExecution.getExecutionTrace();
+ HashMap<Integer, ReadWriteSet> pastReadWriteFieldsMap = rExecution.getReadWriteFieldsMap();
+ int pastConfChoice = getPastConflictChoice(stId, pastExecutionTrace);
+ int conflictChoice = choiceCounter;
+ // Iterate from the starting point until the end of the past execution trace
+ while (pastConfChoice < pastExecutionTrace.size() - 1) { // BacktrackPoint list always has a surplus of 1
+ // Get the info of the event from the past execution trace
+ BacktrackPoint confBtrackPoint = pastExecutionTrace.get(pastConfChoice);
+ if (isNotChecked(checkedStateIdAndChoice, confBtrackPoint)) {
+ ReadWriteSet rwSet = pastReadWriteFieldsMap.get(pastConfChoice);
+ // Append this event to the current list and map
+ ArrayList<BacktrackPoint> currentTrace = currentExecution.getExecutionTrace();
+ HashMap<Integer, ReadWriteSet> currRWFieldsMap = currentExecution.getReadWriteFieldsMap();
+ currentTrace.add(confBtrackPoint);
+ currRWFieldsMap.put(choiceCounter, rwSet);
+ for (int pastChoice = conflictChoice - 1; pastChoice >= 0; pastChoice--) {
+ if (isConflictFound(conflictChoice, pastChoice, rExecution)) {
+ createBacktrackingPoint(conflictChoice, pastChoice, rExecution);
+ }
+ }
+ // Remove this event to replace it with a new one
+ currentTrace.remove(currentTrace.size() - 1);
+ currRWFieldsMap.remove(choiceCounter);
+ }
+ pastConfChoice++;
}
+ checkedTrace.add(rExecution);
}
- conflictChoice++;
}
}
}
projects / jpf-core.git / blobdiff