001// Global variables 002 003package daikon; 004 005import static java.util.logging.Level.FINE; 006import static java.util.logging.Level.INFO; 007 008import java.io.PrintWriter; 009import java.util.LinkedHashMap; 010import java.util.List; 011import java.util.Map; 012import java.util.Random; 013import java.util.logging.Logger; 014import java.util.regex.Pattern; 015import java.util.regex.PatternSyntaxException; 016import org.checkerframework.checker.mustcall.qual.Owning; 017import org.checkerframework.checker.nullness.qual.MonotonicNonNull; 018import org.plumelib.util.FuzzyFloat; 019 020public final class Global { 021 022 // There are some other variables in the Daikon class. Probably move 023 // them here eventually. 024 025 static { 026 daikon.config.Configuration.getInstance(); 027 } 028 029 // Don't permit this class to be instantiated 030 private Global() {} 031 032 /////////////////////////////////////////////////////////////////////////// 033 /// Constants 034 /// 035 036 public static final String lineSep = System.lineSeparator(); 037 038 // Regular expressions 039 public static final java.util.regex.Pattern ws_regexp; 040 041 static { 042 try { 043 ws_regexp = Pattern.compile("[ \\t]+"); 044 } catch (PatternSyntaxException e) { 045 // this can't happen 046 throw new Error(e); 047 } 048 } 049 050 public static final Random random = new Random(); 051 052 /////////////////////////////////////////////////////////////////////////// 053 /// Variables 054 /// 055 056 // Perhaps I shouldn't have anything in this category (i.e., no global 057 // variables)? 058 059 /////////////////////////////////////////////////////////////////////////// 060 /// Statistics-gathering 061 /// 062 063 // All these different variables is a little out of control, true. 064 // Maybe turn it into a structure or an array of integers (which is 065 // easier to output and to initialize, both by looping). 066 067 public static final boolean output_statistics = true; 068 069 /// Invariant inference or variable derivation 070 // These I will compute from a final postpass over each Ppt. 071 public static int non_canonical_variables = 0; 072 public static int can_be_missing_variables = 0; 073 public static int canonical_variables = 0; 074 075 /// Variable derivation 076 public static int nonsensical_suppressed_derived_variables = 0; 077 public static int tautological_suppressed_derived_variables = 0; 078 // Can be set by a postpass. (Might be instructive to compute on the 079 // fly, too, to see what I missed.) 080 public static int derived_variables = 0; 081 082 /// Invariant inference 083 public static int implied_noninstantiated_invariants = 0; 084 public static int implied_false_noninstantiated_invariants = 0; 085 public static int subexact_noninstantiated_invariants = 0; 086 // These also appear in falsified_invariants or non_falsified_invariants; 087 // they shouldn't be added to other things. 088 public static int partially_implied_invariants = 0; 089 // instantiated_invariants == falsified_invariants + non_falsified_invariants 090 public static int instantiated_invariants = 0; 091 public static int falsified_invariants = 0; 092 // non_falsified_invariants should be the sum of all the below 093 public static int non_falsified_invariants = 0; 094 public static int too_few_samples_invariants = 0; 095 public static int non_canonical_invariants = 0; 096 public static int obvious_invariants = 0; 097 public static int unjustified_invariants = 0; 098 public static int reported_invariants = 0; 099 100 public static void output_statistics() { 101 if (!output_statistics) { 102 return; 103 } 104 105 System.out.println( 106 "==========================================================================="); 107 System.out.println("Variables:"); 108 System.out.println(" non_canonical_variables = " + non_canonical_variables); 109 System.out.println(" can_be_missing_variables = " + can_be_missing_variables); 110 System.out.println(" canonical_variables = " + canonical_variables); 111 System.out.println( 112 " total variables = " 113 + (non_canonical_variables + can_be_missing_variables + canonical_variables)); 114 115 System.out.println("Derivation:"); 116 System.out.println(" derived_variables = " + derived_variables); 117 System.out.println( 118 " suppressed derived variables = " 119 + (nonsensical_suppressed_derived_variables 120 + tautological_suppressed_derived_variables)); 121 System.out.println( 122 " nonsensical_suppressed_derived_variables = " 123 + nonsensical_suppressed_derived_variables); 124 System.out.println( 125 " tautological_suppressed_derived_variables = " 126 + tautological_suppressed_derived_variables); 127 128 System.out.println("Inference:"); 129 System.out.println( 130 "Non-instantiated: " 131 + ((implied_noninstantiated_invariants + subexact_noninstantiated_invariants) 132 + (implied_false_noninstantiated_invariants + partially_implied_invariants))); 133 System.out.println( 134 " true = " + (implied_noninstantiated_invariants + subexact_noninstantiated_invariants)); 135 System.out.println( 136 " implied_noninstantiated_invariants = " + implied_noninstantiated_invariants); 137 System.out.println( 138 " subexact_noninstantiated_invariants = " + subexact_noninstantiated_invariants); 139 System.out.println( 140 " false = " + (implied_false_noninstantiated_invariants + partially_implied_invariants)); 141 System.out.println( 142 " implied_false_noninstantiated_invariants = " 143 + implied_false_noninstantiated_invariants); 144 System.out.println(" partially_implied_invariants = " + partially_implied_invariants); 145 System.out.println( 146 "Instantiated: " 147 + instantiated_invariants 148 + " = " 149 + (falsified_invariants + non_falsified_invariants)); 150 System.out.println(" falsified_invariants = " + falsified_invariants); 151 System.out.println( 152 " non_falsified_invariants = " 153 + non_falsified_invariants 154 + " = " 155 + ((too_few_samples_invariants + unjustified_invariants) 156 + (non_canonical_invariants + obvious_invariants) 157 + reported_invariants)); 158 System.out.println( 159 " unjustified = " + (too_few_samples_invariants + unjustified_invariants)); 160 System.out.println(" too_few_samples_invariants = " + too_few_samples_invariants); 161 System.out.println(" unjustified_invariants = " + unjustified_invariants); 162 System.out.println(" implied = " + (non_canonical_invariants + obvious_invariants)); 163 System.out.println(" non_canonical_invariants = " + non_canonical_invariants); 164 System.out.println(" obvious_invariants = " + obvious_invariants); 165 System.out.println(" reported_invariants = " + reported_invariants); 166 } 167 168 /////////////////////////////////////////////////////////////////////////// 169 /// Debugging 170 /// Anything that's commented in the false section is now implemented 171 /// via the logger. 172 173 public static boolean debugAll = false; 174 175 static { 176 // Set up debug traces. 177 // Better to do this here than in each separate program. 178 LogHelper.setupLogs(debugAll ? FINE : INFO); 179 } 180 181 /** Debug tracer for debugging statistics output. */ 182 public static final Logger debugStatistics = Logger.getLogger("daikon.statistics"); 183 184 /** Debug tracer for debugging Simplify output. */ 185 public static final Logger debugSimplify = Logger.getLogger("daikon.simplify"); 186 187 /** Debug tracer for debugging derived vars. */ 188 public static Logger debugDerive = Logger.getLogger("daikon.derive"); 189 190 /** Debug tracer for debugging splitting. */ 191 public static Logger debugSplit = Logger.getLogger("daikon.split"); 192 193 /** Debug tracer for debugging general invariant inference. */ 194 public static Logger debugInfer = Logger.getLogger("daikon.infer"); 195 196 /** Debug tracer for debugging invariant suppression. */ 197 public static Logger debugSuppress = Logger.getLogger("daikon.suppress"); 198 199 /** Debug tracer for debugging invariant suppression by using parameters. */ 200 public static Logger debugSuppressParam = Logger.getLogger("daikon.suppress.param"); 201 202 /** Debug tracer for debugging invariant printing. */ 203 public static Logger debugPrint = Logger.getLogger("daikon.print"); 204 205 /** If true, print logging information about printing of dtrace files. */ 206 public static final boolean debugPrintDtrace = false; 207 208 /** Used only if debugPrintDtrace is true. Users need not set this. */ 209 public static @Owning @MonotonicNonNull PrintWriter dtraceWriter = null; 210 211 // Global Fuzzy Float comparator to use 212 public static FuzzyFloat fuzzy = new FuzzyFloat(); 213 214 /* Map of statistics for each ppt. */ 215 public static Map<PptTopLevel, List<PptTopLevel.Stats>> stats_map = new LinkedHashMap<>(); 216}