Modifying the algorithm: 1) Find the first conflict and stop; 2) Perform backward...
authorrtrimana <rtrimana@uci.edu>
Thu, 14 May 2020 21:03:40 +0000 (14:03 -0700)
committerrtrimana <rtrimana@uci.edu>
Thu, 14 May 2020 21:03:40 +0000 (14:03 -0700)
src/main/gov/nasa/jpf/listener/DPORStateReducer.java

index 885add3..bf06232 100644 (file)
@@ -74,12 +74,10 @@ public class DPORStateReducer extends ListenerAdapter {
   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
@@ -296,15 +294,7 @@ public class DPORStateReducer extends ListenerAdapter {
             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);
               }
             }
           }
@@ -318,6 +308,95 @@ public class DPORStateReducer extends ListenerAdapter {
 
   // -- 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
@@ -363,28 +442,7 @@ public class DPORStateReducer extends ListenerAdapter {
     }
   }
 
-  // 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 {
@@ -440,7 +498,8 @@ public class DPORStateReducer extends ListenerAdapter {
     }
     // 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);
@@ -492,10 +551,8 @@ public class DPORStateReducer extends ListenerAdapter {
     // 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
@@ -535,7 +592,8 @@ public class DPORStateReducer extends ListenerAdapter {
     // 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);
@@ -549,23 +607,27 @@ public class DPORStateReducer extends ListenerAdapter {
       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);
@@ -661,22 +723,24 @@ public class DPORStateReducer extends ListenerAdapter {
     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]) {
@@ -684,13 +748,8 @@ public class DPORStateReducer extends ListenerAdapter {
         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) {
@@ -726,7 +785,7 @@ public class DPORStateReducer extends ListenerAdapter {
                // 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
@@ -750,78 +809,137 @@ public class DPORStateReducer extends ListenerAdapter {
                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) ||
@@ -833,25 +951,7 @@ public class DPORStateReducer extends ListenerAdapter {
     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
@@ -860,7 +960,7 @@ public class DPORStateReducer extends ListenerAdapter {
     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;
@@ -876,9 +976,6 @@ public class DPORStateReducer extends ListenerAdapter {
       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;
@@ -887,12 +984,21 @@ public class DPORStateReducer extends ListenerAdapter {
 
   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);
     }
@@ -953,18 +1059,19 @@ public class DPORStateReducer extends ListenerAdapter {
 
   // 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!
@@ -991,46 +1098,47 @@ public class DPORStateReducer extends ListenerAdapter {
 
   // 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);
+//        }
+//      }
+//    }
   }
 }