From: bdemsky <bdemsky>
Date: Tue, 20 Feb 2007 08:48:57 +0000 (+0000)
Subject: adding thread support w/ locks
X-Git-Tag: preEdgeChange~715
X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=19b5f9458018000ffbbbb0c10310dc087e56c2da;p=IRC.git

adding thread support w/ locks
---

diff --git a/Robust/src/IR/Flat/BuildCode.java b/Robust/src/IR/Flat/BuildCode.java
index 20f0892c..1e5c9291 100644
--- a/Robust/src/IR/Flat/BuildCode.java
+++ b/Robust/src/IR/Flat/BuildCode.java
@@ -107,6 +107,9 @@ public class BuildCode {
 
 	// Output the C class declarations
 	// These could mutually reference each other
+	if (state.THREAD)
+	    outclassdefs.println("#include <pthread.h>");
+
 	outclassdefs.println("struct "+arraytype+";");
 
 	Iterator it=state.getClassSymbolTable().getDescriptorsIterator();
@@ -119,9 +122,13 @@ public class BuildCode {
 	    //Print out definition for array type
 	    outclassdefs.println("struct "+arraytype+" {");
 	    outclassdefs.println("  int type;");
-	    outclassdefs.println("  int flag;");
+	    if (state.THREAD) {
+		outclassdefs.println("  pthread_t tid;");
+		outclassdefs.println("  int lockcount;");
+	    }
 		
 	    if (state.TASK) {
+		outclassdefs.println("  int flag;");
 		outclassdefs.println("  void * flagptr;");
 	    }
 	    printClassStruct(typeutil.getClass(TypeUtil.ObjectClass), outclassdefs);
@@ -289,10 +296,8 @@ public class BuildCode {
 		break;
 	    }
 	    if (state.THREAD) {
-		outmethod.println("pthread_mutex_lock(&threadtable);");
-		outmethod.println("threadcount--;");
-		outmethod.println("pthread_mutex_unlock(&threadtable);");
 		outmethod.println("pthread_mutex_lock(&gclistlock);");
+		outmethod.println("threadcount--;");
 		outmethod.println("pthread_cond_signal(&gccond);");
 		outmethod.println("pthread_mutex_unlock(&gclistlock);");
 		outmethod.println("pthread_exit(NULL);");
@@ -722,9 +727,13 @@ public class BuildCode {
 	/* Output class structure */
 	classdefout.println("struct "+cn.getSafeSymbol()+" {");
 	classdefout.println("  int type;");
-	classdefout.println("  int flag;");
+	if (state.THREAD) {
+	    classdefout.println("  pthread_t tid;");
+	    classdefout.println("  int lockcount;");
+	}
 
 	if (state.TASK) {
+	    classdefout.println("  int flag;");
 	    classdefout.println("  void * flagptr;");
 	}
 	printClassStruct(cn, classdefout);
diff --git a/Robust/src/IR/Flat/BuildFlat.java b/Robust/src/IR/Flat/BuildFlat.java
index 3ff20b0f..bce8e4ca 100644
--- a/Robust/src/IR/Flat/BuildFlat.java
+++ b/Robust/src/IR/Flat/BuildFlat.java
@@ -6,10 +6,13 @@ import java.util.*;
 public class BuildFlat {
     State state;
     Hashtable temptovar;
+    MethodDescriptor currmd;
+    TypeUtil typeutil;
 
-    public BuildFlat(State st) {
+    public BuildFlat(State st, TypeUtil typeutil) {
 	state=st;
 	temptovar=new Hashtable();
+	this.typeutil=typeutil;
     }
 
     public Hashtable getMap() {
@@ -67,16 +70,30 @@ public class BuildFlat {
     private void flattenClass(ClassDescriptor cn) {
 	Iterator methodit=cn.getMethods();
 	while(methodit.hasNext()) {
-	    MethodDescriptor md=(MethodDescriptor)methodit.next();
-	    BlockNode bn=state.getMethodBody(md);
-	    FlatNode fn=flattenBlockNode(bn).getBegin();
-	    FlatMethod fm=new FlatMethod(md, fn);
-	    if (!md.isStatic())
-		fm.addParameterTemp(getTempforParam(md.getThis()));
-	    for(int i=0;i<md.numParameters();i++) {
-		fm.addParameterTemp(getTempforParam(md.getParameter(i)));
+	    currmd=(MethodDescriptor)methodit.next();
+	    BlockNode bn=state.getMethodBody(currmd);
+	    NodePair np=flattenBlockNode(bn);
+	    FlatNode fn=np.getBegin();
+	    if (state.THREAD&&currmd.getModifiers().isSynchronized()) {
+		MethodDescriptor memd=(MethodDescriptor)typeutil.getClass("Object").getMethodTable().get("MonitorEnter");
+		TempDescriptor thistd=getTempforVar(currmd.getThis());
+		FlatCall fc=new FlatCall(memd, null, thistd, new TempDescriptor[0]);
+		fc.addNext(fn);
+		fn=fc;
+		if (np.getEnd().kind()!=FKind.FlatReturnNode) {
+		    MethodDescriptor memdex=(MethodDescriptor)typeutil.getClass("Object").getMethodTable().get("MonitorExit");
+		    FlatCall fcunlock=new FlatCall(memdex, null, thistd, new TempDescriptor[0]);
+		    np.getEnd().addNext(fcunlock);
+		}
+	    }
+
+	    FlatMethod fm=new FlatMethod(currmd, fn);
+	    if (!currmd.isStatic())
+		fm.addParameterTemp(getTempforParam(currmd.getThis()));
+	    for(int i=0;i<currmd.numParameters();i++) {
+		fm.addParameterTemp(getTempforParam(currmd.getParameter(i)));
 	    }
-	    state.addFlatCode(md,fm);
+	    state.addFlatCode(currmd,fm);
 	}
     }
 
@@ -741,12 +758,20 @@ public class BuildFlat {
 	}
 
 	FlatReturnNode rnflat=new FlatReturnNode(retval);
+	FlatNode ln=rnflat;
+	if (state.THREAD&&currmd.getModifiers().isSynchronized()) {
+	    MethodDescriptor memd=(MethodDescriptor)typeutil.getClass("Object").getMethodTable().get("MonitorExit");
+	    TempDescriptor thistd=getTempforVar(currmd.getThis());
+	    FlatCall fc=new FlatCall(memd, null, thistd, new TempDescriptor[0]);
+	    fc.addNext(rnflat);
+	    ln=fc;
+	}
 
 	if (cond!=null) {
-	    cond.getEnd().addNext(rnflat);
+	    cond.getEnd().addNext(ln);
 	    return new NodePair(cond.getBegin(),rnflat);
 	} else
-	    return new NodePair(rnflat,rnflat);
+	    return new NodePair(ln,rnflat);
     }
 
     private NodePair flattenTaskExitNode(TaskExitNode ten) {
diff --git a/Robust/src/IR/Tree/BuildIR.java b/Robust/src/IR/Tree/BuildIR.java
index 17eceb26..fbea5fce 100644
--- a/Robust/src/IR/Tree/BuildIR.java
+++ b/Robust/src/IR/Tree/BuildIR.java
@@ -652,16 +652,19 @@ public class BuildIR {
 		ParseNode modn=pnv.elementAt(i);
 		if (isNode(modn,"public"))
 		    m.addModifier(Modifiers.PUBLIC);
-		if (isNode(modn,"protected"))
+		else if (isNode(modn,"protected"))
 		    m.addModifier(Modifiers.PROTECTED);
-		if (isNode(modn,"private"))
+		else if (isNode(modn,"private"))
 		    m.addModifier(Modifiers.PRIVATE);
-		if (isNode(modn,"static"))
+		else if (isNode(modn,"static"))
 		    m.addModifier(Modifiers.STATIC);
-		if (isNode(modn,"final"))
+		else if (isNode(modn,"final"))
 		    m.addModifier(Modifiers.FINAL);
-		if (isNode(modn,"native"))
+		else if (isNode(modn,"native"))
 		    m.addModifier(Modifiers.NATIVE);
+		else if (isNode(modn,"synchronized"))
+		    m.addModifier(Modifiers.SYNCHRONIZED);
+		else throw new Error("Unrecognized Modifier");
 	    }
 	}
 	return m;
diff --git a/Robust/src/IR/Tree/Modifiers.java b/Robust/src/IR/Tree/Modifiers.java
index 827f3acf..d20c7962 100644
--- a/Robust/src/IR/Tree/Modifiers.java
+++ b/Robust/src/IR/Tree/Modifiers.java
@@ -8,7 +8,7 @@ public class Modifiers {
 //	ABSTRACT=16
     public static final int FINAL=32;
     public static final int NATIVE=64;
-//	SYNCHRONIZED=128
+    public static final int SYNCHRONIZED=128;
 //	TRANSIENT=256
 //	VOLATILE=512
 //	STRICTFP=1024
@@ -25,6 +25,12 @@ public class Modifiers {
 
     public void addModifier(int mod) {
 	value|=mod;
+	if (isSynchronized()&&isNative())
+	    throw new Error("Synchronized native methods are not supported");
+    }
+
+    public boolean isSynchronized() {
+	return ((value&SYNCHRONIZED)!=0);
     }
 
     public boolean isStatic() {
@@ -49,6 +55,8 @@ public class Modifiers {
 	    st+="final ";
 	if ((value&NATIVE)!=0)
 	    st+="native ";
+	if ((value&SYNCHRONIZED)!=0)
+	    st+="synchronized ";
 	return st;
     }
 }
diff --git a/Robust/src/IR/Tree/SemanticCheck.java b/Robust/src/IR/Tree/SemanticCheck.java
index 0feb9d0e..5cd747f7 100644
--- a/Robust/src/IR/Tree/SemanticCheck.java
+++ b/Robust/src/IR/Tree/SemanticCheck.java
@@ -686,11 +686,15 @@ public class SemanticCheck {
 	switch(op.getOp()) {
 	case Operation.LOGIC_OR:
 	case Operation.LOGIC_AND:
-	    if (!(ltd.isBoolean()&&rtd.isBoolean()))
+	    if (!(rtd.isBoolean()))
+		throw new Error();
+	    on.setRightType(rtd);
+	case Operation.LOGIC_NOT:
+	    if (!(ltd.isBoolean()))
 		throw new Error();
 	    //no promotion
 	    on.setLeftType(ltd);
-	    on.setRightType(rtd);
+
 	    on.setType(new TypeDescriptor(TypeDescriptor.BOOLEAN));
    	    break;
 
@@ -823,7 +827,7 @@ public class SemanticCheck {
 	    on.setType(lefttype);
 	    break;
 	default:
-	    throw new Error();
+	    throw new Error(op.toString());
 	}
    
 	if (td!=null)
diff --git a/Robust/src/Main/Main.java b/Robust/src/Main/Main.java
index 8fd212eb..4f391128 100644
--- a/Robust/src/Main/Main.java
+++ b/Robust/src/Main/Main.java
@@ -57,7 +57,7 @@ public class Main {
 	  }
       }
       
-      readSourceFile(state, ClassLibraryPrefix+"Object.java");
+
       readSourceFile(state, ClassLibraryPrefix+"System.java");
       readSourceFile(state, ClassLibraryPrefix+"String.java");
       readSourceFile(state, ClassLibraryPrefix+"HashSet.java");
@@ -70,10 +70,12 @@ public class Main {
       readSourceFile(state, ClassLibraryPrefix+"FileOutputStream.java");
       readSourceFile(state, ClassLibraryPrefix+"File.java");
       if (state.TASK) {
+	  readSourceFile(state, ClassLibraryPrefix+"Object.java");
 	  readSourceFile(state, ClassLibraryPrefix+"StartupObject.java");
 	  readSourceFile(state, ClassLibraryPrefix+"Socket.java");
 	  readSourceFile(state, ClassLibraryPrefix+"ServerSocket.java");
       } else {
+	  readSourceFile(state, ClassLibraryPrefix+"ObjectJava.java");
 	  readSourceFile(state, ClassLibraryPrefix+"SocketJava.java");
 	  readSourceFile(state, ClassLibraryPrefix+"ServerSocketJava.java");
       }
@@ -91,7 +93,7 @@ public class Main {
       sc.semanticCheck();
       tu.createFullTable();
 
-      BuildFlat bf=new BuildFlat(state);
+      BuildFlat bf=new BuildFlat(state,tu);
       bf.buildFlat();
       
       BuildCode bc=new BuildCode(state, bf.getMap(), tu);
diff --git a/Robust/src/Parse/java14.cup b/Robust/src/Parse/java14.cup
index d964ee8b..68773750 100644
--- a/Robust/src/Parse/java14.cup
+++ b/Robust/src/Parse/java14.cup
@@ -615,8 +615,8 @@ modifier ::=
 	STATIC {: RESULT=new ParseNode("static"); :} |
 //	ABSTRACT |
 	FINAL {: RESULT=new ParseNode("final"); :}|
-	NATIVE {: RESULT=new ParseNode("native"); :}
-//	SYNCHRONIZED | 
+	NATIVE {: RESULT=new ParseNode("native"); :} |
+	SYNCHRONIZED {: RESULT=new ParseNode("synchronized"); :}
 //	TRANSIENT | 
 //	VOLATILE |
 //	STRICTFP // note that semantic analysis must check that the
diff --git a/Robust/src/Runtime/garbage.c b/Robust/src/Runtime/garbage.c
index bbd2f04f..8b8d7370 100644
--- a/Robust/src/Runtime/garbage.c
+++ b/Robust/src/Runtime/garbage.c
@@ -80,17 +80,12 @@ int moreItems() {
 void collect(struct garbagelist * stackptr) {
 #ifdef THREADS
   needtocollect=1;
+  pthread_mutex_lock(&gclistlock);
   while(1) {
-    pthread_mutex_lock(&gclistlock);
-    pthread_mutex_lock(&threadtable);
     if ((listcount+1)==threadcount) {
-      pthread_mutex_unlock(&threadtable);
-      pthread_mutex_unlock(&gclistlock);      
       break; /* Have all other threads stopped */
     }
-    pthread_mutex_unlock(&threadtable);
     pthread_cond_wait(&gccond, &gclistlock);
-    pthread_mutex_unlock(&gclistlock);
   }
 #endif
 
@@ -260,6 +255,7 @@ void collect(struct garbagelist * stackptr) {
   }
 #ifdef THREADS
   needtocollect=0;
+  pthread_mutex_unlock(&gclistlock);
 #endif
 }
 
@@ -286,9 +282,10 @@ void * tomalloc(int size) {
 void checkcollect(void * ptr) {
   if (needtocollect) {
     struct listitem * tmp=stopforgc((struct garbagelist *)ptr);
-    pthread_mutex_lock(&gclock);
+    pthread_mutex_lock(&gclock); // Wait for GC
     restartaftergc(tmp);
     pthread_mutex_unlock(&gclock);
+
   }
 }
 
diff --git a/Robust/src/Runtime/runtime.c b/Robust/src/Runtime/runtime.c
index 23a43fd3..f45c1be8 100644
--- a/Robust/src/Runtime/runtime.c
+++ b/Robust/src/Runtime/runtime.c
@@ -414,14 +414,6 @@ void injectinstructionfailure() {
 #endif
 }
 
-int CALL01(___Object______hashCode____, struct ___Object___ * ___this___) {
-  return (int) VAR(___this___);
-}
-
-int CALL01(___Object______getType____, struct ___Object___ * ___this___) {
-  return ((int *)VAR(___this___))[0];
-}
-
 void CALL01(___System______printString____L___String___,struct ___String___ * ___s___) {
     struct ArrayObject * chararray=VAR(___s___)->___value___;
     int i;
@@ -436,8 +428,12 @@ void CALL01(___System______printString____L___String___,struct ___String___ * __
 
 #ifdef PRECISE_GC
 void * allocate_new(void * ptr, int type) {
-  void * v=mygcmalloc((struct garbagelist *) ptr, classsize[type]);
-  *((int *)v)=type;
+  struct ___Object___ * v=(struct ___Object___ *) mygcmalloc((struct garbagelist *) ptr, classsize[type]);
+  v->type=type;
+#ifdef THREADS
+  v->tid=0;
+  v->lockcount=0;
+#endif
   return v;
 }
 
@@ -447,6 +443,10 @@ struct ArrayObject * allocate_newarray(void * ptr, int type, int length) {
   struct ArrayObject * v=mygcmalloc((struct garbagelist *) ptr, sizeof(struct ArrayObject)+length*classsize[type]);
   v->type=type;
   v->___length___=length;
+#ifdef THREADS
+  v->tid=0;
+  v->lockcount=0;
+#endif
   return v;
 }
 
diff --git a/Robust/src/Runtime/thread.c b/Robust/src/Runtime/thread.c
index 99e79cef..2f745651 100644
--- a/Robust/src/Runtime/thread.c
+++ b/Robust/src/Runtime/thread.c
@@ -7,18 +7,20 @@
 
 
 #include <stdio.h>
-pthread_mutex_t threadtable;
 int threadcount;
 pthread_mutex_t gclock;
 pthread_mutex_t gclistlock;
 pthread_cond_t gccond;
+pthread_mutex_t objlock;
+pthread_cond_t objcond;
 
 void initializethreads() {
-  pthread_mutex_init(&threadtable,NULL);
   threadcount=1;
   pthread_mutex_init(&gclock, NULL);
   pthread_mutex_init(&gclistlock, NULL);
   pthread_cond_init(&gccond, NULL);
+  pthread_mutex_init(&objlock,NULL);
+  pthread_cond_init(&objcond,NULL);
 }
 
 void initthread(struct ___Thread___ * ___this___) {
@@ -28,18 +30,16 @@ void initthread(struct ___Thread___ * ___this___) {
 #else
   ___Thread______staticStart____L___Thread___(___this___);
 #endif
-  pthread_mutex_lock(&threadtable);
-  threadcount--;
-  pthread_mutex_unlock(&threadtable);
   pthread_mutex_lock(&gclistlock);
+  threadcount--;
   pthread_cond_signal(&gccond);
   pthread_mutex_unlock(&gclistlock);
 }
 
 void CALL01(___Thread______nativeCreate____, struct ___Thread___ * ___this___) {
   pthread_t thread;
-  pthread_mutex_lock(&threadtable);
+  pthread_mutex_lock(&gclistlock);
   threadcount++;
-  pthread_mutex_unlock(&threadtable);
+  pthread_mutex_unlock(&gclistlock);
   pthread_create(&thread, NULL,(void * (*)(void *)) &initthread, VAR(___this___));
 }
diff --git a/Robust/src/Runtime/thread.h b/Robust/src/Runtime/thread.h
index dc728cca..e12a8e06 100644
--- a/Robust/src/Runtime/thread.h
+++ b/Robust/src/Runtime/thread.h
@@ -3,10 +3,11 @@
 #include "methodheaders.h"
 #include "pthread.h"
 
-extern pthread_mutex_t threadtable;
 extern int threadcount;
 extern pthread_mutex_t gclock;
 extern pthread_mutex_t gclistlock;
 extern pthread_cond_t gccond;
+extern pthread_mutex_t objlock;
+extern pthread_cond_t objcond;
 void initthread(struct ___Thread___ * ___this___);
 #endif
diff --git a/Robust/src/buildscript b/Robust/src/buildscript
index 522b8690..0a7f880c 100755
--- a/Robust/src/buildscript
+++ b/Robust/src/buildscript
@@ -155,7 +155,8 @@ INCLUDES="$INCLUDES -I$ROBUSTROOT/Runtime -I. -IRuntime/include \
 FILES="$ROBUSTROOT/Runtime/runtime.c $ROBUSTROOT/Runtime/file.c \
 $ROBUSTROOT/Runtime/Queue.c $ROBUSTROOT/Runtime/SimpleHash.c \
 $ROBUSTROOT/Runtime/option.c $ROBUSTROOT/Runtime/garbage.c \
-$ROBUSTROOT/Runtime/socket.c $ROBUSTROOT/Runtime/GenericHashtable.c"
+$ROBUSTROOT/Runtime/socket.c $ROBUSTROOT/Runtime/GenericHashtable.c \
+$ROBUSTROOT/Runtime/object.c"
 
 if $RECOVERFLAG
 then