コード例 #1
0
ファイル: CFSM.java プロジェクト: hkumbum/FSE-2011-Synoptic
 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();
 }
コード例 #2
0
  @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));
  }
コード例 #3
0
  @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));
  }
コード例 #4
0
ファイル: CFSM.java プロジェクト: hkumbum/FSE-2011-Synoptic
  /**
   * 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);
  }
コード例 #5
0
ファイル: CFSM.java プロジェクト: hkumbum/FSE-2011-Synoptic
  /** 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;
  }
コード例 #6
0
ファイル: CFSM.java プロジェクト: hkumbum/FSE-2011-Synoptic
  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);
  }
コード例 #7
0
ファイル: CFSM.java プロジェクト: hkumbum/FSE-2011-Synoptic
  /**
   * 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;
  }
コード例 #8
0
ファイル: CFSM.java プロジェクト: hkumbum/FSE-2011-Synoptic
  /**
   * 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;
  }