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
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, false);
- }
- }
+ 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 {
}
// Record state ID and choice/event as backtrack point
int stateId = vm.getStateId();
- backtrackPointList.add(new BacktrackPoint(icsCG, stateId, refChoices[choiceIndex]));
+// 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);
// 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
// Save execution state into the Reachability 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) ||
+ // TODO: New algorithm
+/* if (!prevVisitedStates.contains(stateId) ||
choiceCounter <= 1) {
ReachableTrace reachableTrace= new
ReachableTrace(backtrackPointList, readWriteFieldsMap);
rTrace.add(reachableTrace);
}
stateToChoiceCounterMap.put(stateId, choiceCounter);
- analyzeReachabilityAndCreateBacktrackPoints(search.getVM(), stateId);
+ analyzeReachabilityAndCreateBacktrackPoints(search.getVM(), stateId);*/
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);
- }
- backtrackList.addFirst(newChoiceList);
+ backtrackExecList = new LinkedList<>();
+ backtrackMap.put(stateId, backtrackExecList);
+ }
+ // 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, boolean isPastTrace) {
+ private void createBacktrackingPoint(int currentChoice, 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];
- // Put the conflicting event numbers first and reverse the order
- if (isPastTrace) {
- // For past trace we get the choice/event from the list
- newChoiceList[0] = backtrackPointList.get(currentChoice).getChoice();
- } else {
- // We use the actual choices here in case they have been modified/adjusted by the fair scheduling method
- int actualCurrCho = currentChoice % refChoices.length;
- newChoiceList[0] = choices[actualCurrCho];
+ //int firstChoice = choices[actualChoice];
+ ArrayList<BacktrackPoint> pastTrace = execution.getExecutionTrace();
+ ArrayList<BacktrackPoint> currTrace = currentExecution.getExecutionTrace();
+ int backtrackEvent = currTrace.get(currentChoice).getChoice();
+ int stateId = pastTrace.get(conflictChoice).getStateId();
+ // Check if this trace has been done from this state
+ if (isTraceAlreadyConstructed(backtrackEvent, stateId)) {
+ return;
}
- newChoiceList[1] = backtrackPointList.get(confEvtNum).getChoice();
+ // Put the conflicting event numbers first and reverse the order
+ newChoiceList[0] = backtrackEvent;
+ 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
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);
- }
- return rwSet;
- }
-
- private boolean isConflictFound(int eventCounter, int currentChoice, boolean isPastTrace) {
-
- int currActualChoice;
- if (isPastTrace) {
- currActualChoice = backtrackPointList.get(currentChoice).getChoice();
- } else {
- int actualCurrCho = currentChoice % refChoices.length;
- currActualChoice = choices[actualCurrCho];
- }
- // 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) ||
- currActualChoice == backtrackPointList.get(eventCounter).getChoice()) {
- return false;
- }
- // Current R/W set
- ReadWriteSet currRWSet = readWriteFieldsMap.get(currentChoice);
- // R/W set of choice/event that may have a potential conflict
- ReadWriteSet evtRWSet = readWriteFieldsMap.get(eventCounter);
- // 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)) {
- return true;
+ 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 for conflicts with Write fields for Read instructions
- Set<String> currReadSet = currRWSet.getReadSet();
- for(String readField : currReadSet) {
- int currObjId = currRWSet.readFieldObjectId(readField);
- if (evtRWSet.writeFieldExists(readField) && evtRWSet.writeFieldObjectId(readField) == currObjId) {
- return true;
+ // Check if a conflict is found
+ if (isConflictFound(nextInsn, pastChoice, execution, currentChoice, fieldClass)) {
+ createBacktrackingPoint(currentChoice, pastChoice, execution);
+ break; // Stop at the first found conflict
}
}
- // Return false if no conflict is found
- return false;
}
- private boolean isConflictFound(Instruction nextInsn, int eventCounter, int currentChoice, String fieldClass) {
+ private boolean isConflictFound(Instruction nextInsn, int pastChoice, Execution pastExecution,
+ int currentChoice, String fieldClass) {
- 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;
}
- ReadWriteSet rwSet = readWriteFieldsMap.get(eventCounter);
+ 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)) {
+ 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 eventCounter, int currentChoice, boolean isPastTrace) {
+//
+// int currActualChoice;
+// if (isPastTrace) {
+// currActualChoice = backtrackPointList.get(currentChoice).getChoice();
+// } else {
+// int actualCurrCho = currentChoice % refChoices.length;
+// currActualChoice = choices[actualCurrCho];
+// }
+// // 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) ||
+// currActualChoice == backtrackPointList.get(eventCounter).getChoice()) {
+// return false;
+// }
+// // Current R/W set
+// ReadWriteSet currRWSet = readWriteFieldsMap.get(currentChoice);
+// // R/W set of choice/event that may have a potential conflict
+// ReadWriteSet evtRWSet = readWriteFieldsMap.get(eventCounter);
+// // 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)) {
+// return true;
+// }
+// }
+// // Check for conflicts with Write fields for Read instructions
+// Set<String> currReadSet = currRWSet.getReadSet();
+// for(String readField : currReadSet) {
+// int currObjId = currRWSet.readFieldObjectId(readField);
+// if (evtRWSet.writeFieldExists(readField) && evtRWSet.writeFieldObjectId(readField) == currObjId) {
+// return true;
+// }
+// }
+// // Return false if no conflict is found
+// 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;
+// }
+// return false;
+// }
+
+ 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 rwSet;
+ }
+
private boolean isFieldExcluded(String field) {
// Check against "starts-with", "ends-with", and "contains" list
if (excludeThisForItStartsWith(EXCLUDED_FIELDS_STARTS_WITH_LIST, 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;
choices = icsCG.getAllChoices();
refChoices = copyChoices(choices);
// Clear data structures
- backtrackPointList = new ArrayList<>();
- conflictPairMap = new HashMap<>();
- readWriteFieldsMap = new HashMap<>();
stateToChoiceCounterMap = new HashMap<>();
stateToEventMap = new HashMap<>();
isEndOfExecution = false;
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);
}
// 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 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, false) && isNewConflict(conflictChoice, eventCounter)) {
- createBacktrackingPoint(conflictChoice, eventCounter, false);
- }
- }
- conflictChoice++;
- }
+// // 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, false)) {
+//// && isNewConflict(conflictChoice, eventCounter)) {
+// createBacktrackingPoint(conflictChoice, eventCounter, false);
+// }
+// }
+// conflictChoice++;
+// }
}
// TODO: OPTIMIZATION!
// Update the backtrack sets in a previous execution
private void updateBacktrackSetsInPreviousExecution(int stateId) {
- // Don't check a past trace twice!
- HashSet<ReachableTrace> 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<ReachableTrace> rTraces = rGraph.get(stId);
- for (ReachableTrace rTrace : rTraces) {
- if (!checkedTrace.contains(rTrace)) {
- // Find the choice/event that marks the start of the subtrace from the previous execution
- ArrayList<BacktrackPoint> pastBacktrackPointList = rTrace.getPastBacktrackPointList();
- HashMap<Integer, ReadWriteSet> pastReadWriteFieldsMap = rTrace.getPastReadWriteFieldsMap();
- int pastConfChoice = getPastConflictChoice(stId, pastBacktrackPointList);
- int conflictChoice = choiceCounter;
- // Iterate from the starting point until the end of the past execution trace
- while (pastConfChoice < pastBacktrackPointList.size() - 1) { // BacktrackPoint list always has a surplus of 1
- // Get the info of the event from the past execution trace
- BacktrackPoint confBtrackPoint = pastBacktrackPointList.get(pastConfChoice);
- if (isNotChecked(checkedStateIdAndChoice, confBtrackPoint)) {
- ReadWriteSet rwSet = pastReadWriteFieldsMap.get(pastConfChoice);
- // Append this event to the current list and map
- backtrackPointList.add(confBtrackPoint);
- readWriteFieldsMap.put(choiceCounter, rwSet);
- for (int eventCounter = conflictChoice - 1; eventCounter >= 0; eventCounter--) {
- if (isConflictFound(eventCounter, conflictChoice, true) && isNewConflict(conflictChoice, eventCounter)) {
- createBacktrackingPoint(conflictChoice, eventCounter, true);
- }
- }
- // Remove this event to replace it with a new one
- backtrackPointList.remove(backtrackPointList.size() - 1);
- readWriteFieldsMap.remove(choiceCounter);
- }
- pastConfChoice++;
- }
- checkedTrace.add(rTrace);
- }
- }
- }
+// // Don't check a past trace twice!
+// HashSet<ReachableTrace> 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<ReachableTrace> rTraces = rGraph.get(stId);
+// for (ReachableTrace rTrace : rTraces) {
+// if (!checkedTrace.contains(rTrace)) {
+// // Find the choice/event that marks the start of the subtrace from the previous execution
+// ArrayList<BacktrackPoint> pastBacktrackPointList = rTrace.getPastBacktrackPointList();
+// HashMap<Integer, ReadWriteSet> pastReadWriteFieldsMap = rTrace.getPastReadWriteFieldsMap();
+// int pastConfChoice = getPastConflictChoice(stId, pastBacktrackPointList);
+// int conflictChoice = choiceCounter;
+// // Iterate from the starting point until the end of the past execution trace
+// while (pastConfChoice < pastBacktrackPointList.size() - 1) { // BacktrackPoint list always has a surplus of 1
+// // Get the info of the event from the past execution trace
+// BacktrackPoint confBtrackPoint = pastBacktrackPointList.get(pastConfChoice);
+// if (isNotChecked(checkedStateIdAndChoice, confBtrackPoint)) {
+// ReadWriteSet rwSet = pastReadWriteFieldsMap.get(pastConfChoice);
+// // Append this event to the current list and map
+// backtrackPointList.add(confBtrackPoint);
+// readWriteFieldsMap.put(choiceCounter, rwSet);
+// for (int eventCounter = conflictChoice - 1; eventCounter >= 0; eventCounter--) {
+// if (isConflictFound(eventCounter, conflictChoice, true)) {
+// && isNewConflict(conflictChoice, eventCounter)) {
+// createBacktrackingPoint(conflictChoice, eventCounter, true);
+// }
+// }
+// // Remove this event to replace it with a new one
+// backtrackPointList.remove(backtrackPointList.size() - 1);
+// readWriteFieldsMap.remove(choiceCounter);
+// }
+// pastConfChoice++;
+// }
+// checkedTrace.add(rTrace);
+// }
+// }
+// }
}
}
projects / jpf-core.git / commitdiff