public CFSM(int numProcesses, List<ChannelId> channelIds) {
super(numProcesses, channelIds);
fsms = Util.newList(Collections.nCopies(numProcesses, (FSM) null));
unSpecifiedPids = numProcesses;
firstSyntheticChIndex = Integer.MAX_VALUE;
localEventsChIndex = Integer.MAX_VALUE;
invs = Util.newList();
}
@Before
public void setUp() throws Exception {
super.setUp();
cids = Util.newList(2);
cid1 = new ChannelId(1, 2, 0);
cid2 = new ChannelId(2, 1, 1);
cids.add(cid1);
cids.add(cid2);
chStates = Util.newList(2);
chStates.add(new ChState<DistEventType>(cid1));
chStates.add(new ChState<DistEventType>(cid2));
}
@Test
public void createEmpty() {
mc = ImmutableMultiChState.fromChannelIds(cids);
mc2 = ImmutableMultiChState.fromChannelIds(cids);
// Make sure that the two instance pointers are identical, because of
// internal caching.
assertTrue(mc == mc2);
assertTrue(mc.equals(mc2));
assertTrue(mc.hashCode() == mc2.hashCode());
// Now, attempt to create the same mc/mc2 instances, but by building
// them from more explicit state instances.
mc3 = ImmutableMultiChState.fromChannelStates(chStates);
assertTrue(mc == mc3);
assertTrue(mc.equals(mc3));
cids = Util.newList(2);
cid1 = new ChannelId(1, 2, 0);
cid2 = new ChannelId(2, 2, 1);
cids.add(cid1);
cids.add(cid2);
mc3 = ImmutableMultiChState.fromChannelIds(cids);
assertFalse(mc == mc3);
assertFalse(mc.equals(mc3));
}
/**
* Augment this CFSM with an "eventually happens e" invariant for model checking. This procedure
* is slightly different from binary invariants. In particular, we do not trace an 'initial' event
* and instead just trace the event e.
*/
private void augmentWithInvTracing(EventuallyHappens inv) {
DistEventType e1 = inv.getEvent();
assert alphabet.contains(e1);
assert e1.getPid() < fsms.size();
assert !invs.contains(invs);
invs.add(inv);
int scmId = this.channelIds.size();
if (firstSyntheticChIndex > scmId) {
firstSyntheticChIndex = scmId;
}
// Create and add a new invariant-specific channel.
ChannelId invCid = new InvChannelId(inv, scmId);
this.channelIds.add(invCid);
// Update the FSM corresponding to e1.
Set<FSMState> visited = Util.newSet();
FSM f1 = this.fsms.get(e1.getPid());
DistEventType e1Tracer1 = DistEventType.SynthSendEvent(e1, invCid, true);
DistEventType e1Tracer2 = DistEventType.SynthSendEvent(e1, invCid, false);
addSendToEventTx(f1, e1, e1Tracer1, e1Tracer2, visited);
this.alphabet.add(e1Tracer1);
this.alphabet.add(e1Tracer2);
inv.setFirstSynthTracers(e1Tracer1, e1Tracer2);
inv.setSecondSynthTracers(null, null);
}
/** Returns the bad states for all invariants that augment this CFSM. */
public List<BadState> getBadStates() {
assert !invs.isEmpty();
// TODO: Sub-optimality -- we are needlessly creating many lists by
// calling getBadState(inv) repeatedly.
List<BadState> ret = Util.newList();
for (BinaryInvariant inv : invs) {
ret.addAll(getBadStates(inv));
}
return ret;
}
private Set<CFSMState> deriveAllPermsOfStates(IFSMToStateSetFn<FSMState> fn) {
if (numProcesses == 1) {
Set<CFSMState> ret = Util.newSet();
for (FSMState s : fn.eval(fsms.get(0))) {
ret.add(new CFSMState(s));
}
return ret;
}
assert numProcesses > 1;
// Permutations for processes 0 and 1.
List<List<FSMState>> perms = Util.get2DPermutations(fn.eval(fsms.get(0)), fn.eval(fsms.get(1)));
// Permutations for process with pid >= 2.
int i = 2;
while (i != numProcesses) {
// Modifies perms in place.
perms = Util.get2DPermutations(perms, fn.eval(fsms.get(i)));
i += 1;
}
return CFSMState.CFSMStatesFromFSMListLists(perms);
}
/**
* Generates a Promela representation of this CFSM, to be used with SPIN. The never claim is not
* specified here and it is appended to the CFSM elsewhere.
*/
public String toPromelaString(List<BinaryInvariant> invariants, int chanCapacity) {
assert unSpecifiedPids == 0;
String ret = "/* Spin-promela Multiple invariants */\n\n";
// Message types:
//
// mtype is global and can only be declared once.
// There is also limit of 255 for the size of mtype.
// This outputs a set of event types for the CFSM.
ret += "/* Message types: */\n";
ret += "mtype = { ";
Set<String> eventTypes = Util.newSet();
for (DistEventType e : alphabet) {
eventTypes.add(e.getPromelaEType());
}
ret += StringUtils.join(eventTypes, ", ");
ret += " };\n"; // End mtype declaration.
ret += "\n\n";
// Define the channels:
ret += "/* Channels: */\n\n";
// Specifying channels as an array to work with inlines.
ret +=
String.format("chan channel[%d] = [%d] of { mtype };\n", channelIds.size(), chanCapacity);
// The following block defines EMPTYCHANNELCHECK as a conditional that
// checks if all the channels are empty. This is used in the never claim
// to make sure our channels are empty before terminating.
String emptyChannelCheck = "";
for (int i = 0; i < channelIds.size(); i++) {
ret += "/* Channel " + channelIds.get(i).toString() + " */\n";
if (i != 0) {
emptyChannelCheck += " && ";
}
emptyChannelCheck += "empty(channel[" + i + "])";
}
ret += String.format("#define EMPTYCHANNELCHECK (%s)\n", emptyChannelCheck);
ret += "\n\n";
// Tracks if the current states of each of the FSM are terminal.
ret += "bit terminal[" + numProcesses + "];\n";
// ENDSTATECHECK is the conditional used by the never claim to
// check the terminal states in all CFSMs. The never claim has this to
// ensure that the processes are in a proper terminal state when the
// never claim is done.
String endStateCheck = "";
for (int pid = 0; pid < numProcesses; pid++) {
// Set up the terminal check conditional.
if (pid != 0) {
endStateCheck += " && ";
}
endStateCheck += "terminal[" + pid + "]";
}
ret += String.format("#define ENDSTATECHECK (%s)\n", endStateCheck);
// Event type definitions for type tracking
// OTHEREVENTs are used for other transitions so we do not accidentally
// trigger an "a NFby b". This can happen when a == b. This invariant
// can be accepted if a transition happens that does not call
// setRecentEvent. OTHEREVENT does not match any event we are interested
// in tracking so it is safe to use during these transitions.
ret += "#define OTHEREVENT (0)\n";
// Event types we're actively tracking.
ret += "#define LOCAL (1)\n";
ret += "#define SEND (2)\n";
ret += "#define RECV (3)\n";
// Custom datatype to assist in tracking recent event.
ret += "typedef myEvent {\n";
// The type of event: LOCAL, SEND or RECV
ret += " byte type;\n";
// id is the process id if the type is LOCAL and the channel id if the
// type is SEND or RECV.
ret += " byte id;\n";
// The event itself. These are the previously defined mtypes.
ret += " mtype event;\n";
ret += "};\n";
// Declaration of event tracker.
ret += "myEvent recentEvent;\n";
// Custom inline function to update most recent event.
ret += "inline setRecentEvent(event_type, owner_id, event_message) {\n";
ret += " d_step{\n";
ret += " recentEvent.type = event_type;\n";
ret += " recentEvent.id = owner_id;\n";
ret += " recentEvent.event = event_message;\n";
ret += " };\n";
ret += "}\n";
// Each of the FSMs in the CFSM:
for (int pid = 0; pid < numProcesses; pid++) {
String labelPrefix = "state" + Integer.toString(pid);
FSM f = fsms.get(pid);
ret += "active proctype p" + Integer.toString(pid) + "(){\n";
ret += f.toPromelaString(invariants, labelPrefix);
ret += "}\n\n";
}
ret += "\n\n";
for (BinaryInvariant inv : invariants) {
ret += "/* " + inv.toString() + "*/\n";
ret += inv.promelaNeverClaim();
ret += "\n\n";
}
return ret;
}
/**
* Returns a set of bad states that correspond to a specific invariant that is augmenting this
* CFSM. Each invariant corresponds to (possibly multiple) bad states. A bad states is a
* combination of FSM states and a sequence of regular expressions that describe the contents of
* each of the queues in the CFSM. For an invariant I, a bad state B has the property that if B is
* reachable in the CFSM then I is falsified. That is, the path to reach B is the counter-example
* for I.
*/
public List<BadState> getBadStates(BinaryInvariant inv) {
assert invs.contains(inv);
// Without invariants there are no bad states.
if (invs.isEmpty()) {
return Collections.emptyList();
}
List<BadState> badStates = Util.newList();
Set<CFSMState> accepts = this.getAcceptStates();
if (accepts.isEmpty()) {
assert !accepts.isEmpty();
}
List<String> qReList = Util.newList(channelIds.size());
// Set non-synthetic queues reg-exps to accept the empty string.
for (int i = 0; i < firstSyntheticChIndex; i++) {
qReList.add("_");
}
int invIndex = invs.indexOf(inv);
// Set the synthetic queue reg-exps.
for (int i = firstSyntheticChIndex; i < channelIds.size(); i++) {
if (i == firstSyntheticChIndex + invIndex) {
// The invariant we care about checking.
qReList.add(inv.scmBadStateQRe());
} else if (i == localEventsChIndex) {
// Add an RE for the local events queue.
Set<String> localEvents = this.alphabet.getLocalEventScmStrings();
if (!localEvents.isEmpty()) {
String localEventsQueueRe = "(";
for (String eLocal : localEvents) {
localEventsQueueRe += eLocal + " | ";
}
// Remove the last occurrence of the "|" character.
localEventsQueueRe = localEventsQueueRe.substring(0, localEventsQueueRe.length() - 3);
localEventsQueueRe += ")^*";
qReList.add(localEventsQueueRe);
} else {
// If there are no local events then the queue RE is the
// empty string, since no corresponding local event messages
// will be generated.
qReList.add("_");
}
} else {
// Initialize non-inv invariant synthetic queues to accept
// everything that their alphabet permits.
qReList.add(inv.someSynthEventsQRe());
}
}
// For each accept, generate a bad state <accept, qReList>.
for (CFSMState accept : accepts) {
badStates.add(new BadState(accept, qReList));
}
return badStates;
}
