import gov.nasa.jpf.vm.bytecode.ReadInstruction;
import gov.nasa.jpf.vm.bytecode.WriteInstruction;
import gov.nasa.jpf.vm.choice.IntChoiceFromSet;
+import gov.nasa.jpf.vm.choice.IntIntervalGenerator;
+import java.awt.*;
import java.io.PrintWriter;
import java.util.*;
// State reduction fields
private Integer[] choices;
+ private Integer[] refChoices;
private IntChoiceFromSet currCG;
private int choiceCounter;
private Integer choiceUpperBound;
// (i.e., hash table that records encountered states)
// VOD graph is updated when the state has not yet been seen
// Current state
- private int stateId;
+ private HashSet<Integer> justVisitedStates;
// Previous choice number
private int prevChoiceValue;
// HashSet that stores references to unused CGs
transition = null;
isBooleanCGFlipped = false;
vodGraphMap = new HashMap<>();
- stateId = -1;
+ justVisitedStates = new HashSet<>();
prevChoiceValue = -1;
cgMap = new HashMap<>();
readWriteFieldsMap = new HashMap<>();
private void initializeStateReduction() {
if (stateReductionMode) {
choices = null;
+ refChoices = null;
currCG = null;
choiceCounter = 0;
choiceUpperBound = 0;
resetReadWriteAnalysis();
backtrackMap.clear();
backtrackSet.clear();
+ stateToEventMap.clear();
+ prevVisitedStates.clear();
+ currVisitedStates.clear();
}
}
icsCG.setNewValues(choices);
icsCG.reset();
// Use a modulo since choiceCounter is going to keep increasing
- int choiceIndex = choiceCounter % (choices.length - 1);
+ int choiceIndex = choiceCounter % choices.length;
icsCG.advance(choices[choiceIndex]);
if (choiceIndex == 0) {
resetReadWriteAnalysis();
return icsCG;
}
+ private Integer[] copyChoices(Integer[] choicesToCopy) {
+
+ Integer[] copyOfChoices = new Integer[choicesToCopy.length];
+ System.arraycopy(choicesToCopy, 0, copyOfChoices, 0, choicesToCopy.length);
+ return copyOfChoices;
+ }
+
+ private void continueExecutingThisTrace(IntChoiceFromSet icsCG) {
+ // We repeat the same trace if a state match is not found yet
+ IntChoiceFromSet setCG = setNewCG(icsCG);
+ unusedCG.add(setCG);
+ }
+
private void initializeChoiceGenerators(IntChoiceFromSet icsCG, Integer[] cgChoices) {
if (choiceCounter <= choiceUpperBound && !cgMap.containsValue(choiceCounter)) {
// Update the choices of the first CG and add '-1'
// Initialize backtrack set that stores all the explored backtrack lists
maxUpperBound = cgChoices.length;
// All the choices are always the same so we only need to update it once
- choices = new Integer[cgChoices.length + 1];
- System.arraycopy(cgChoices, 0, choices, 0, cgChoices.length);
- choices[choices.length - 1] = -1;
+ // Get the choice array and final choice in the array
+ choices = cgChoices;
+ // Make a copy of choices as reference
+ refChoices = copyChoices(choices);
String firstChoiceListString = buildStringFromChoiceList(choices);
backtrackSet.add(firstChoiceListString);
}
IntChoiceFromSet setCG = setNewCG(icsCG);
- cgMap.put(setCG, choices[choiceCounter]);
+ cgMap.put(setCG, refChoices[choiceCounter]);
} else {
- // We repeat the same trace if a state match is not found yet
- IntChoiceFromSet setCG = setNewCG(icsCG);
- unusedCG.add(setCG);
+ continueExecutingThisTrace(icsCG);
+ }
+ }
+
+ private void manageChoiceGeneratorsInSubsequentTraces(IntChoiceFromSet icsCG) {
+ // If this is the first iteration of the trace then set other CGs done
+ if (choiceCounter <= choiceUpperBound) {
+ icsCG.setDone();
+ } else {
+ // If this is the subsequent iterations of the trace then set up new CGs to continue the execution
+ continueExecutingThisTrace(icsCG);
}
- choiceCounter++;
}
@Override
initializeChoiceGenerators(icsCG, cgChoices);
} else {
// Set new CGs to done so that the search algorithm explores the existing CGs
- icsCG.setDone();
+ //icsCG.setDone();
+ manageChoiceGeneratorsInSubsequentTraces(icsCG);
}
}
}
}
+ private void setDoneUnusedCG() {
+ // Set done every CG in the unused CG set
+ for (IntChoiceFromSet cg : unusedCG) {
+ cg.setDone();
+ }
+ unusedCG.clear();
+ }
+
private void resetAllCGs() {
+
+ isResetAfterAnalysis = true;
// Extract the event numbers that have backtrack lists
Set<Integer> eventSet = backtrackMap.keySet();
// Return if there is no conflict at all (highly unlikely)
cg.setDone();
}
}
- // Set done every CG in the unused CG set
- for (IntChoiceFromSet cg : unusedCG) {
- cg.setDone();
- }
- unusedCG.clear();
+ setDoneUnusedCG();
saveVisitedStates();
}
// Basically, we have to check that we have executed all events between two occurrences of such state.
private boolean containsCyclesWithAllEvents(int stId) {
+ // False if the state ID hasn't been recorded
+ if (!stateToEventMap.containsKey(stId)) {
+ return false;
+ }
HashSet<Integer> visitedEvents = stateToEventMap.get(stId);
boolean containsCyclesWithAllEvts = false;
if (checkIfAllEventsInvolved(visitedEvents)) {
currVisitedStates.clear();
}
- private void updateChoices(IntChoiceFromSet icsCG) {
+ private void updateChoicesForNewExecution(IntChoiceFromSet icsCG) {
if (choices == null || choices != icsCG.getAllChoices()) {
currCG = icsCG;
choices = icsCG.getAllChoices();
+ refChoices = copyChoices(choices);
// Reset a few things for the sub-graph
resetReadWriteAnalysis();
choiceCounter = 0;
}
}
+ private void checkAndEnforceFairScheduling(IntChoiceFromSet icsCG) {
+ // Check the next choice and if the value is not the same as the expected then force the expected value
+ int choiceIndex = choiceCounter % refChoices.length;
+ int nextChoice = icsCG.getNextChoice();
+ if (refChoices[choiceIndex] != nextChoice) {
+ int expectedChoice = refChoices[choiceIndex];
+ int currCGIndex = icsCG.getNextChoiceIndex();
+ if ((currCGIndex >= 0) && (currCGIndex < refChoices.length)) {
+ icsCG.setChoice(currCGIndex, expectedChoice);
+ }
+ }
+ }
+
+ private void mapStateToEvent(int nextChoiceValue) {
+ // Update all states with this event/choice
+ // This means that all past states now see this transition
+ Set<Integer> stateSet = stateToEventMap.keySet();
+ for(Integer stateId : stateSet) {
+ HashSet<Integer> eventSet = stateToEventMap.get(stateId);
+ eventSet.add(nextChoiceValue);
+ }
+ }
+
+ private void updateVODGraph(int currChoiceValue) {
+ // Update the graph when we have the current choice value
+ HashSet<Integer> choiceSet;
+ if (vodGraphMap.containsKey(prevChoiceValue)) {
+ // If the key already exists, just retrieve it
+ choiceSet = vodGraphMap.get(prevChoiceValue);
+ } else {
+ // Create a new entry
+ choiceSet = new HashSet<>();
+ vodGraphMap.put(prevChoiceValue, choiceSet);
+ }
+ choiceSet.add(currChoiceValue);
+ prevChoiceValue = currChoiceValue;
+ }
+
+ 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
+ for(Integer stateId : justVisitedStates) {
+ if (prevVisitedStates.contains(stateId) || containsCyclesWithAllEvents(stateId)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
private void exploreNextBacktrackSets(IntChoiceFromSet icsCG) {
// Traverse the sub-graphs
if (isResetAfterAnalysis) {
- // Advance choice counter for sub-graphs
- choiceCounter++;
// Do this for every CG after finishing each backtrack list
// We try to update the CG with a backtrack list if the state has been visited multiple times
- if ((icsCG.getNextChoice() == -1 || choiceCounter > 1) && cgMap.containsKey(icsCG)) {
+ if (icsCG.getNextChoiceIndex() > 0 && cgMap.containsKey(icsCG)) {
int event = cgMap.get(icsCG);
LinkedList<Integer[]> choiceLists = backtrackMap.get(event);
if (choiceLists != null && choiceLists.peekFirst() != null) {
// Set done if this was the last backtrack list
icsCG.setDone();
}
+ setDoneUnusedCG();
saveVisitedStates();
}
} else {
// Update and reset the CG if needed (do this for the first time after the analysis)
// Start backtracking if this is a visited state and it is not a repeating state
resetAllCGs();
- isResetAfterAnalysis = true;
}
}
public void choiceGeneratorAdvanced(VM vm, ChoiceGenerator<?> currentCG) {
if (stateReductionMode) {
+ if (vm.getNextChoiceGenerator() instanceof BooleanChoiceGenerator) {
+ System.out.println("Next CG is a booleanCG");
+ }
// Check the boolean CG and if it is flipped, we are resetting the analysis
if (currentCG instanceof BooleanChoiceGenerator) {
if (!isBooleanCGFlipped) {
if (currentCG instanceof IntChoiceFromSet) {
IntChoiceFromSet icsCG = (IntChoiceFromSet) currentCG;
// Update the current pointer to the current set of choices
- updateChoices(icsCG);
+ updateChoicesForNewExecution(icsCG);
+ // If we don't see a fair scheduling of events/choices then we have to enforce it
+ checkAndEnforceFairScheduling(icsCG);
+ // Map state to event
+ mapStateToEvent(icsCG.getNextChoice());
+ // Update the VOD graph always with the latest
+ updateVODGraph(icsCG.getNextChoice());
// Check if we have seen this state or this state contains cycles that involve all events
- if (prevVisitedStates.contains(stateId) || containsCyclesWithAllEvents(stateId)) {
+ if (terminateCurrentExecution()) {
exploreNextBacktrackSets(icsCG);
}
- // Update the VOD graph always with the latest
- updateVODGraph(icsCG.getNextChoice());
+ justVisitedStates.clear();
+ choiceCounter++;
}
}
}
- private void updateVODGraph(int currChoiceValue) {
- // Update the graph when we have the current choice value
- HashSet<Integer> choiceSet;
- if (vodGraphMap.containsKey(prevChoiceValue)) {
- // If the key already exists, just retrieve it
- choiceSet = vodGraphMap.get(prevChoiceValue);
- } else {
- // Create a new entry
- choiceSet = new HashSet<>();
- vodGraphMap.put(prevChoiceValue, choiceSet);
- }
- choiceSet.add(currChoiceValue);
- prevChoiceValue = currChoiceValue;
- }
-
- private void mapStateToEvent(Search search) {
- // Insert state ID and event choice into the map
- HashSet<Integer> eventSet;
- if (stateToEventMap.containsKey(stateId)) {
- eventSet = stateToEventMap.get(stateId);
- } else {
- eventSet = new HashSet<>();
+ private void checkAndRecordNewState(int stateId) {
+ // Insert state ID into the map if it is new
+ if (!stateToEventMap.containsKey(stateId)) {
+ HashSet<Integer> eventSet = new HashSet<>();
stateToEventMap.put(stateId, eventSet);
}
- eventSet.add(prevChoiceValue);
}
private void updateStateInfo(Search search) {
if (stateReductionMode) {
// Update the state variables
// Line 19 in the paper page 11 (see the heading note above)
- stateId = search.getStateId();
+ int stateId = search.getStateId();
currVisitedStates.add(stateId);
- mapStateToEvent(search);
+ checkAndRecordNewState(stateId);
+ justVisitedStates.add(stateId);
}
}
// Do the analysis to get Read and Write accesses to fields
ReadWriteSet rwSet;
// We already have an entry
- if (readWriteFieldsMap.containsKey(choices[currentChoice])) {
- rwSet = readWriteFieldsMap.get(choices[currentChoice]);
+ if (readWriteFieldsMap.containsKey(refChoices[currentChoice])) {
+ rwSet = readWriteFieldsMap.get(refChoices[currentChoice]);
} else { // We need to create a new entry
rwSet = new ReadWriteSet();
- readWriteFieldsMap.put(choices[currentChoice], rwSet);
+ readWriteFieldsMap.put(refChoices[currentChoice], rwSet);
}
int objectId = ((JVMFieldInstruction) executedInsn).getFieldInfo().getClassInfo().getClassObjectRef();
// Record the field in the map
// When we see a choice list shorter than the upper bound, e.g., [3,2] for choices 0,1,2, and 3,
// then we have to pad the beginning before we store it, because [3,2] actually means [0,1,3,2]
- // First, calculate the difference between this choice list and the upper bound
- // The actual list doesn't include '-1' at the end
- int actualListLength = newChoiceList.length - 1;
+ int actualListLength = newChoiceList.length;
int diff = maxUpperBound - actualListLength;
StringBuilder sb = new StringBuilder();
// Pad the beginning if necessary
}
// Then continue with the actual choice list
// We don't include the '-1' at the end
- for (int i = 0; i < newChoiceList.length - 1; i++) {
+ for (int i = 0; i < newChoiceList.length; i++) {
sb.append(newChoiceList[i]);
}
return sb.toString();
}
int maxListLength = choiceUpperBound + 1;
int listLength = maxListLength - conflictEventNumber;
- Integer[] newChoiceList = new Integer[listLength + 1];
+ Integer[] newChoiceList = new Integer[listLength];
// Put the conflicting event numbers first and reverse the order
- newChoiceList[0] = choices[currentChoice];
- newChoiceList[1] = choices[conflictEventNumber];
+ newChoiceList[0] = refChoices[currentChoice];
+ newChoiceList[1] = refChoices[conflictEventNumber];
// Put the rest of the event numbers into the array starting from the minimum to the upper bound
for (int i = conflictEventNumber + 1, j = 2; j < listLength; i++) {
- if (choices[i] != choices[currentChoice]) {
- newChoiceList[j] = choices[i];
+ if (refChoices[i] != refChoices[currentChoice]) {
+ newChoiceList[j] = refChoices[i];
j++;
}
}
- // Set the last element to '-1' as the end of the sequence
- newChoiceList[newChoiceList.length - 1] = -1;
checkAndAddBacktrackList(backtrackChoiceLists, newChoiceList);
// The start index for the recursion is always 1 (from the main branch)
} else { // This is a sub-graph
if (currCG != null && cgMap.containsKey(currCG)) {
int backtrackListIndex = cgMap.get(currCG);
backtrackChoiceLists = backtrackMap.get(backtrackListIndex);
- int listLength = choices.length;
+ int listLength = refChoices.length;
Integer[] newChoiceList = new Integer[listLength];
// Copy everything before the conflict number
for (int i = 0; i < conflictEventNumber; i++) {
- newChoiceList[i] = choices[i];
+ newChoiceList[i] = refChoices[i];
}
// Put the conflicting events
- newChoiceList[conflictEventNumber] = choices[currentChoice];
- newChoiceList[conflictEventNumber + 1] = choices[conflictEventNumber];
+ newChoiceList[conflictEventNumber] = refChoices[currentChoice];
+ newChoiceList[conflictEventNumber + 1] = refChoices[conflictEventNumber];
// Copy the rest
for (int i = conflictEventNumber + 1, j = conflictEventNumber + 2; j < listLength - 1; i++) {
- if (choices[i] != choices[currentChoice]) {
- newChoiceList[j] = choices[i];
+ if (refChoices[i] != refChoices[currentChoice]) {
+ newChoiceList[j] = refChoices[i];
j++;
}
}
- // Set the last element to '-1' as the end of the sequence
- newChoiceList[newChoiceList.length - 1] = -1;
checkAndAddBacktrackList(backtrackChoiceLists, newChoiceList);
}
}
return false;
}
+ private int getCurrentChoice(VM vm) {
+ ChoiceGenerator<?> currentCG = vm.getChoiceGenerator();
+ // This is the main event CG
+ if (currentCG instanceof IntChoiceFromSet) {
+ return ((IntChoiceFromSet) currentCG).getNextChoiceIndex();
+ } else {
+ // This is the interval CG used in device handlers
+ ChoiceGenerator<?> parentCG = ((IntIntervalGenerator) currentCG).getPreviousChoiceGenerator();
+ return ((IntChoiceFromSet) parentCG).getNextChoiceIndex();
+ }
+ }
+
@Override
public void instructionExecuted(VM vm, ThreadInfo ti, Instruction nextInsn, Instruction executedInsn) {
if (stateReductionMode) {
- if (isInitialized) {
- int currentChoice = (choiceCounter % (choices.length - 1)) - 1;
- if (currentChoice < 0) {
- // We do not compute the conflicts for the choice '-1'
+ // Has to be initialized and a integer CG
+ ChoiceGenerator<?> cg = vm.getChoiceGenerator();
+ if (isInitialized && (cg instanceof IntChoiceFromSet || cg instanceof IntIntervalGenerator)) {
+ int currentChoice = getCurrentChoice(vm);
+ if (currentChoice < 0) { // If choice is -1 then skip
return;
}
// Record accesses from executed instructions
// one by one as this recursively checks backward when backtrack set is revisited and executed.
for (int eventNumber = currentChoice - 1; eventNumber >= 0; eventNumber--) {
// Skip if this event number does not have any Read/Write set
- if (!readWriteFieldsMap.containsKey(choices[eventNumber])) {
+ if (!readWriteFieldsMap.containsKey(refChoices[eventNumber])) {
continue;
}
- ReadWriteSet rwSet = readWriteFieldsMap.get(choices[eventNumber]);
+ ReadWriteSet rwSet = readWriteFieldsMap.get(refChoices[eventNumber]);
int currObjId = ((JVMFieldInstruction) nextInsn).getFieldInfo().getClassInfo().getClassObjectRef();
// 1) Check for conflicts with Write fields for both Read and Write instructions
if (((nextInsn instanceof WriteInstruction || nextInsn instanceof ReadInstruction) &&
// If it has been serviced before, we just skip this
if (recordConflictPair(currentChoice, eventNumber)) {
// Lines 4-8 of the algorithm in the paper page 11 (see the heading note above)
- if (vm.isNewState() || isReachableInVODGraph(choices[currentChoice], choices[currentChoice-1])) {
+ if (vm.isNewState() || isReachableInVODGraph(refChoices[currentChoice], refChoices[currentChoice-1])) {
createBacktrackChoiceList(currentChoice, eventNumber);
// Break if a conflict is found!
break;