private void add(PptTopLevel ppt, ValueTuple vt) { // Add the sample to any splitters if (ppt.has_splitters()) { for (PptSplitter ppt_split : ppt.splitters) { PptConditional ppt_cond = ppt_split.choose_conditional(vt); if (ppt_cond != null) add(ppt_cond, vt); else debug.fine(": sample doesn't pick conditional"); } } // if this is a numbered exit, apply to the combined exit as well if (!(ppt instanceof PptConditional) && ppt.ppt_name.isNumberedExitPoint()) { PptTopLevel parent = all_ppts.get(ppt.ppt_name.makeExit()); if (parent != null) { parent.get_missingOutOfBounds(ppt, vt); add(parent, vt); } } // If the point has no variables, skip it if (ppt.var_infos.length == 0) return; // We should have received sample here before, or there is nothing // to check. // Yoav added: It can be that the different dtrace and inv files have different program points if (false && ppt.num_samples() <= 0) Assert.assertTrue( ppt.num_samples() > 0, "ppt " + ppt.name + " has 0 samples and " + ppt.var_infos.length + " variables"); // Loop through each slice slice_loop: for (Iterator<PptSlice> i = ppt.views_iterator(); i.hasNext(); ) { PptSlice slice = i.next(); if (debug_detail.isLoggable(Level.FINE)) debug_detail.fine( ": processing slice " + slice + "vars: " + Debug.toString(slice.var_infos, vt)); // If any variables are missing, skip this slice for (int j = 0; j < slice.var_infos.length; j++) { VarInfo v = slice.var_infos[j]; int mod = vt.getModified(v); if (v.isMissing(vt)) { if (debug_detail.isLoggable(Level.FINE)) debug_detail.fine(": : Skipping slice, " + v.name() + " missing"); continue slice_loop; } if (v.missingOutOfBounds()) { if (debug_detail.isLoggable(Level.FINE)) debug.fine(": : Skipping slice, " + v.name() + " out of bounds"); continue slice_loop; } } // Loop through each invariant for (Invariant inv : slice.invs) { if (debug_detail.isLoggable(Level.FINE)) debug_detail.fine(": : Processing invariant: " + inv); if (!inv.isActive()) { if (debug_detail.isLoggable(Level.FINE)) debug_detail.fine(": : skipped non-active " + inv); continue; } // Yoav added if (!activeInvariants.contains(inv)) { // System.out.printf ("skipping invariant %s:%s\n", inv.ppt.name(), // inv.format()); continue; } // String invRep = invariant2str(ppt, inv); testedInvariants.add(inv); InvariantStatus status = inv.add_sample(vt, 1); sample_cnt++; if (status != InvariantStatus.NO_CHANGE) { LineNumberReader lnr = FileIO.data_trace_state.reader; String line = (lnr == null) ? "?" : String.valueOf(lnr.getLineNumber()); if (!quiet) { output_stream.println( "At ppt " + ppt.name + ", Invariant '" + inv.format() + "' invalidated by sample " + Debug.toString(slice.var_infos, vt) + "at line " + line + " in file " + FileIO.data_trace_state.filename); } failedInvariants.add(inv); activeInvariants.remove(inv); error_cnt++; } } } }
public static void extract_consequent(PptMap ppts) { // Retrieve Ppt objects in sorted order. // Use a custom comparator for a specific ordering Comparator<PptTopLevel> comparator = new Ppt.NameComparator(); TreeSet<PptTopLevel> ppts_sorted = new TreeSet<PptTopLevel>(comparator); ppts_sorted.addAll(ppts.asCollection()); for (PptTopLevel ppt : ppts_sorted) { extract_consequent_maybe(ppt, ppts); } PrintWriter pw = new PrintWriter(System.out, true); // All conditions at a program point. A TreeSet to enable // deterministic output. TreeSet<String> allConds = new TreeSet<String>(); for (String pptname : pptname_to_conditions.keySet()) { Map<String, Map<String, HashedConsequent>> cluster_to_conditions = pptname_to_conditions.get(pptname); for (Map.Entry</*@KeyFor("cluster_to_conditions")*/ String, Map<String, HashedConsequent>> entry : cluster_to_conditions.entrySet()) { String predicate = entry.getKey(); Map<String, HashedConsequent> conditions = entry.getValue(); StringBuffer conjunctionJava = new StringBuffer(); StringBuffer conjunctionDaikon = new StringBuffer(); StringBuffer conjunctionESC = new StringBuffer(); StringBuffer conjunctionSimplify = new StringBuffer("(AND "); int count = 0; for (Map.Entry</*@KeyFor("conditions")*/ String, HashedConsequent> entry2 : conditions.entrySet()) { count++; String condIndex = entry2.getKey(); HashedConsequent cond = entry2.getValue(); if (cond.fakeFor != null) { count--; continue; } String javaStr = cond.inv.format_using(OutputFormat.JAVA); String daikonStr = cond.inv.format_using(OutputFormat.DAIKON); String escStr = cond.inv.format_using(OutputFormat.ESCJAVA); String simplifyStr = cond.inv.format_using(OutputFormat.SIMPLIFY); allConds.add(combineDummy(condIndex, "<dummy> " + daikonStr, escStr, simplifyStr)); // allConds.add(condIndex); if (count > 0) { conjunctionJava.append(" && "); conjunctionDaikon.append(" and "); conjunctionESC.append(" && "); conjunctionSimplify.append(" "); } conjunctionJava.append(javaStr); conjunctionDaikon.append(daikonStr); conjunctionESC.append(escStr); conjunctionSimplify.append(simplifyStr); } conjunctionSimplify.append(")"); String conj = conjunctionJava.toString(); // Avoid inserting self-contradictory conditions such as "x == 1 && // x == 2", or conjunctions of only a single condition. if (count < 2 || contradict_inv_pattern.matcher(conj).find() || useless_inv_pattern_1.matcher(conj).find() || useless_inv_pattern_2.matcher(conj).find()) { // System.out.println("Suppressing: " + conj); } else { allConds.add( combineDummy( conjunctionJava.toString(), conjunctionDaikon.toString(), conjunctionESC.toString(), conjunctionSimplify.toString())); } } if (allConds.size() > 0) { pw.println(); pw.println("PPT_NAME " + pptname); for (String s : allConds) { pw.println(s); } } allConds.clear(); } pw.flush(); }
private static void checkInvariants() throws IOException { // Read the invariant file PptMap ppts = FileIO.read_serialized_pptmap(inv_file, true); // Yoav: make sure we have unique invariants InvariantFilters fi = InvariantFilters.defaultFilters(); // Set<String> allInvariantsStr = new HashSet<String>(); Set<Invariant> allInvariants = new HashSet<Invariant>(); for (PptTopLevel ppt : ppts.all_ppts()) for (Iterator<PptSlice> i = ppt.views_iterator(); i.hasNext(); ) { PptSlice slice = i.next(); for (Invariant inv : slice.invs) { if (doConf && inv.getConfidence() < Invariant.dkconfig_confidence_limit) { // System.out.printf ("inv ignored (conf): %s:%s\n", inv.ppt.name(), // inv.format()); continue; } if (doFilter && fi.shouldKeep(inv) == null) { // System.out.printf ("inv ignored (filter): %s:%s\n", // inv.ppt.name(), inv.format()); continue; } activeInvariants.add(inv); // String n = invariant2str(ppt, inv); // if (!allInvariants.contains(inv) && allInvariantsStr.contains(n)) throw new // Daikon.TerminationMessage("Two invariants have the same ppt.name+inv.rep:"+n); allInvariants.add(inv); // allInvariantsStr.add(n); } } // Read and process the data trace files FileIO.Processor processor = new InvariantCheckProcessor(); Daikon.FileIOProgress progress = new Daikon.FileIOProgress(); progress.start(); progress.clear(); FileIO.read_data_trace_files(dtrace_files, ppts, processor, false); progress.shouldStop = true; System.out.println(); System.out.printf( "%s: %,d errors found in %,d samples (%s)\n", inv_file, error_cnt, sample_cnt, toPercentage(error_cnt, sample_cnt)); int failedCount = failedInvariants.size(); int testedCount = testedInvariants.size(); String percent = toPercentage(failedCount, testedCount); System.out.println( inv_file + ": " + failedCount + " false positives, out of " + testedCount + ", which is " + percent + "."); if (false) { for (Invariant inv : failedInvariants) { System.out.printf("+%s:%s\n", inv.ppt.name(), inv.format()); } } }