a start on error inject for SSJava

diff --git a/Robust/src/Benchmarks/SSJava/EyeTracking/makefile b/Robust/src/Benchmarks/SSJava/EyeTracking/makefile
index dbdb323627d93b505561dbde5aaacdd7e406b39e..328bc5dadec2e77bbfcc082c7ea0b22e9383fcef 100644 (file)
--- a/Robust/src/Benchmarks/SSJava/EyeTracking/makefile
+++ b/Robust/src/Benchmarks/SSJava/EyeTracking/makefile
@@ -3,7 +3,7 @@ BUILDSCRIPT=../../../buildscript
 PROGRAM=LEA
 SOURCE_FILES=LEA.java
 
-BSFLAGS= -32bit -ssjava -mainclass $(PROGRAM)  -heapsize-mb 1000   -debug -garbagestats -ssjavadebug -printlinenum -joptimize -optimize
+BSFLAGS= -32bit -ssjava -ssjava-inject-error 1 12345 -mainclass $(PROGRAM)  -heapsize-mb 1000   -debug -garbagestats -ssjavadebug -printlinenum -joptimize #-optimize
 
 default: $(PROGRAM)s.bin
 

diff --git a/Robust/src/IR/Flat/BCXSSJavaInjectError.java b/Robust/src/IR/Flat/BCXSSJavaInjectError.java
new file mode 100644 (file)
index 0000000..d71c9a2
--- /dev/null
+++ b/Robust/src/IR/Flat/BCXSSJavaInjectError.java
@@ -0,0 +1,100 @@
+package IR.Flat;
+import IR.*;
+import IR.Tree.*;
+
+import java.util.*;
+import java.io.*;
+
+import Util.*;
+
+
+public class BCXSSJavaInjectError implements BuildCodeExtension {
+
+  private State state;
+  private BuildCode buildCode;
+  private String nStr             = "__ssjava_inv_error_prob__";
+  private String errorInjectedStr = "__ssjava_error_has_been_injected__";
+
+  public BCXSSJavaInjectError( State state, BuildCode buildCode ) {
+    this.state     = state;
+    this.buildCode = buildCode;
+  }
+
+
+  // the reason for errorInjectionInit is that some code (like static initializers
+  // in the compiled program) actually run before the GENERATED MAIN runs!  Not the
+  // complied program's main, either!  So just rig it so no error injection code runs
+  // until we're sure the random seed is initialized.
+
+  public void additionalCodeGen( PrintWriter outmethodheader,
+                                 PrintWriter outstructs,
+                                 PrintWriter outmethod ) {
+    outmethodheader.println("extern int "+nStr+";");
+    outmethodheader.println("extern int "+errorInjectedStr+";");
+    outmethodheader.println("extern int errorInjectionInit;");
+
+    outmethod.println("int "+nStr+" = "+state.SSJAVA_INV_ERROR_PROB+";");
+    outmethod.println("int "+errorInjectedStr+" = 0;");
+    outmethod.println("int errorInjectionInit = 0;");
+  }
+
+  public void additionalCodeAtTopOfMain( PrintWriter outmethod ) {
+    outmethod.println("  srand("+state.SSJAVA_ERROR_SEED+");");
+    outmethod.println("  errorInjectionInit = 1;");
+  }
+  
+  public void additionalCodePostNode( FlatMethod fm, FlatNode fn, PrintWriter output ) {
+    
+    TempDescriptor injectTarget = null;
+    
+    switch( fn.kind() ) {
+      case FKind.FlatOpNode:
+        FlatOpNode fon = (FlatOpNode) fn;
+        if( fon.getOp().getOp() == Operation.DIV ) {
+          injectTarget = fon.getDest();
+        }
+        break;
+      
+      case FKind.FlatFieldNode:
+        injectTarget = ((FlatFieldNode) fn).getDst();
+        break;
+        
+      case FKind.FlatElementNode:
+        injectTarget = ((FlatElementNode) fn).getDst();
+        break;
+    }
+
+    if( injectTarget != null ) {
+      output.println("if( errorInjectionInit ) {");
+      output.println("  int roll = rand() % "+nStr+";");
+      output.println("  if( !"+errorInjectedStr+" && roll == 0 ) {" );
+      output.println("    "+errorInjectedStr+" = 1;" );
+      output.println("    "+buildCode.generateTemp( fm, injectTarget )+" = 0;" );
+      output.println("    printf(\"SSJAVA: Injecting error ["+injectTarget+
+                     "=%d] at file:%s, func:%s, line:%d \\n\"" + 
+                     ", 0, __FILE__, __func__, __LINE__);");
+      output.println("  }" );
+      output.println("}");
+    }
+  }
+
+
+
+  public void additionalIncludesMethodsImplementation( PrintWriter outmethod ){}
+  public void printExtraArrayFields(PrintWriter outclassdefs){}
+  public void outputTransCode(PrintWriter output){}
+  public void buildCodeSetup(){}
+  public void generateSizeArrayExtensions(PrintWriter outclassdefs){}
+  public void preCodeGenInitialization(){}
+  public void postCodeGenCleanUp(){}
+  public void additionalIncludesMethodsHeader(PrintWriter outmethodheader){}
+  public void additionalIncludesStructsHeader(PrintWriter outstructs){}
+  public void additionalClassObjectFields(PrintWriter outclassdefs){}
+  public void additionalCodeForCommandLineArgs(PrintWriter outmethod, String argsVar){}
+  public void additionalCodeAtBottomOfMain(PrintWriter outmethod){}
+  public void additionalCodeAtTopMethodsImplementation(PrintWriter outmethod){}
+  public void additionalCodeAtTopFlatMethodBody(PrintWriter output, FlatMethod fm){}
+  public void additionalCodePreNode(FlatMethod fm, FlatNode fn, PrintWriter output){}
+  public void additionalCodeNewObject(PrintWriter outmethod, String dstVar, FlatNew flatNew){}
+  public void additionalCodeNewStringLiteral(PrintWriter output, String dstVar){}
+}

diff --git a/Robust/src/IR/Flat/BuildCode.java b/Robust/src/IR/Flat/BuildCode.java
index 435cd34895d44e9e9112d4b9726e4fa32659b8d5..e5179e6229709c1e7a58861ab19f5e0d85f34016 100644 (file)
--- a/Robust/src/IR/Flat/BuildCode.java
+++ b/Robust/src/IR/Flat/BuildCode.java
@@ -217,7 +217,6 @@ public class BuildCode {
       bcx.additionalCodeGen(outmethodheader, outstructs, outmethod);
     }
 
-
     if (state.TASK) {
       /* Output code for tasks */
       outputTaskCode(outtaskdefs, outmethod);

diff --git a/Robust/src/IR/Flat/BuildCodeExtension.java b/Robust/src/IR/Flat/BuildCodeExtension.java
index 53484f64c4b510cf38bf56922790ecd8c004602a..0b20ec427e488b7490ca05b74082ffa5f70d335b 100644 (file)
--- a/Robust/src/IR/Flat/BuildCodeExtension.java
+++ b/Robust/src/IR/Flat/BuildCodeExtension.java
@@ -17,8 +17,8 @@ public interface BuildCodeExtension {
   public void postCodeGenCleanUp();
 
   public void additionalCodeGen(PrintWriter outmethodheader,
-                         PrintWriter outstructs,
-                         PrintWriter outmethod);
+                                PrintWriter outstructs,
+                                PrintWriter outmethod);
 
   public void additionalIncludesMethodsHeader(PrintWriter outmethodheader);
   public void additionalIncludesMethodsImplementation(PrintWriter outmethod);

diff --git a/Robust/src/IR/State.java b/Robust/src/IR/State.java
index 9538ea455c696cd51113121c86d0b74c60953b0a..c7d9a3d67ad3971379b41f8360944ba3e593fc92 100644 (file)
--- a/Robust/src/IR/State.java
+++ b/Robust/src/IR/State.java
@@ -143,7 +143,9 @@ public class State {
   //SSJava
   public boolean SSJAVA=false;
   public boolean SSJAVADEBUG=false;
-
+  public boolean SSJAVA_INJECT_ERROR=false;
+  public int     SSJAVA_INV_ERROR_PROB=0;
+  public int     SSJAVA_ERROR_SEED=0;
 
   public boolean OPTIONAL=false;
   public boolean NOLOOP=false;

diff --git a/Robust/src/Main/Main.java b/Robust/src/Main/Main.java
index 61e898bc814160363e09799ae9fa2247d6bd4d8a..019e7e401fec55f4ddf33ee21300c2fca6d18bfa 100644 (file)
--- a/Robust/src/Main/Main.java
+++ b/Robust/src/Main/Main.java
@@ -368,6 +368,12 @@ public class Main {
         state.SSJAVA = true;
       } else if (option.equals("-ssjavadebug")) {
         state.SSJAVADEBUG = true;
+
+      } else if( option.equals( "-ssjava-inject-error" ) ) {
+        state.SSJAVA_INJECT_ERROR   = true;
+        state.SSJAVA_INV_ERROR_PROB = Integer.parseInt( args[++i] );
+        state.SSJAVA_ERROR_SEED     = Integer.parseInt( args[++i] );
+
       }else if (option.equals("-printlinenum")) {
         state.LINENUM=true;
       } else if (option.equals("-help")) {
@@ -699,6 +705,11 @@ public class Main {
         bc.registerExtension( bcx );
       }
 
+      if( state.SSJAVA_INJECT_ERROR ) {
+        BCXSSJavaInjectError bcx = new BCXSSJavaInjectError( state, bc );
+        bc.registerExtension( bcx );
+      }
+
       bc.buildCode();
       State.logEvent("Done With BuildCode");
 

diff --git a/Robust/src/buildscript b/Robust/src/buildscript
index 31c73f9ac3f68246a75fe40542b3eaefad6402d4..8e1475afeba1754f42c4e8ec64b20232a4eac390 100755 (executable)
--- a/Robust/src/buildscript
+++ b/Robust/src/buildscript
@@ -117,6 +117,7 @@ echo
 echo SSJava options
 echo -ssjava enables SSJava
 echo -ssjavadebug reports interim results
+echo -ssjava-induce-error N S where 1/N is the probability to error at any deref or divide and S is a random seed
 echo
 echo Other options
 echo -jni enable jni
@@ -671,6 +672,12 @@ elif [[ $1 = '-ssjavadebug' ]]
 then
 JAVAOPTS="$JAVAOPTS -ssjavadebug"
 
+elif [[ $1 = '-ssjava-inject-error' ]]
+then
+JAVAOPTS="$JAVAOPTS -ssjava-inject-error $2 $3"
+shift
+shift
+
 elif [[ $1 = '-mempool-detect-misuse' ]]
 then
 EXTRAOPTIONS="$EXTRAOPTIONS -DMEMPOOL_DETECT_MISUSE"