Can run active objects.

git-svn-id: https://svn.inf.ethz.ch/svn/lecturers/a2/trunk@6899 8c9fc860-2736-0410-a75d-ab315db34111

source/Generic.Linux.I386.Glue.Mod

@@ -198,10 +198,10 @@ SystemTools.FreeDownTo FoxIntermediateBackend ~
 SystemTools.DoCommands
 	Compiler.Compile -p=Linux32G
 		Runtime.Mod Trace.Mod Generic.Linux.I386.Glue.Mod Generic.Linux.I386.Unix.Mod Generic.Unix.I386.Machine.Mod Heaps.Mod  Generic.Modules.Mod 
-		Generic.Unix.Objects.Mod  ~ 
+		Generic.Unix.Objects.Mod  TestLinux.Mod ~ 
 
 	StaticLinker.Link --fileFormat=Raw --fileName=simple_elf --extension=.GofU --displacement=08048000H
-		Runtime Trace Glue Unix Machine Heaps Modules Objects ~
+		Runtime Trace Glue Unix Machine Heaps Modules Objects Test ~
 
 	FSTools.CloseFiles simple_elf ~
 		~ 

source/Generic.Linux.I386.Unix.Mod

@@ -145,7 +145,7 @@ TYPE
 	Condition_t* = ADDRESS;
 	ConditionType = ARRAY 12 OF WORD;
 
-	Sigset_t= ARRAY 2 OF ADDRESS; 
+	Sigset_t= ARRAY 32 OF ADDRESS; 
 
 	
 CONST
@@ -378,7 +378,10 @@ VAR
 	pthread_cond_signal: PROCEDURE {C} (cond: ADDRESS): WORD; 
 	
 	pthread_create: PROCEDURE {C} (newthread: ADDRESS; attr: ADDRESS; start_routine: PROCEDURE {C} (arg: PROCEDURE):ADDRESS; arg:PROCEDURE): WORD;
-	pthread_exit: PROCEDURE {C} (return: ADDRESS);
+	pthread_exit: PROCEDURE {C} (thr: ADDRESS);
+	pthread_detach: PROCEDURE {C} (thr: ADDRESS);
+	pthread_kill: PROCEDURE {C} (thr: ADDRESS; sigid: LONGINT);
+	pthread_cancel: PROCEDURE {C} (thr: ADDRESS);
 
 	pthread_attr_init: PROCEDURE {C} (attr: ADDRESS);
 	pthread_attr_setscope: PROCEDURE {C}(attr: ADDRESS; set: WORD);
@@ -395,6 +398,7 @@ VAR
 	sigaction: PROCEDURE {C} (signum: LONGINT; CONST act, oldact: ADDRESS): LONGINT;
 	sigemptyset: PROCEDURE {C} (set: ADDRESS);
 	sigfillset: PROCEDURE {C} (set: ADDRESS): LONGINT;
+	sigsuspend: PROCEDURE {C} (set: ADDRESS): LONGINT;
 	sigaddset: PROCEDURE {C} (set: ADDRESS; signo: LONGINT);
 	sigdelset: PROCEDURE {C} (set: ADDRESS; signo: LONGINT);
 	nanosleep: PROCEDURE {C} (req, rem: ADDRESS): LONGINT;
@@ -598,7 +602,6 @@ VAR
 	VAR 
 		me: Thread_t;
 		
-		aligner1: ARRAY 32 OF ADDRESS; (* I don't know why this is required but it does not work without ??? *)
 		old, new: Sigset_t;
 
 		param: Sched_param;
@@ -651,7 +654,6 @@ VAR
 		pthread_attr_setstacksize(ADDRESS OF attr, stackSize);
 		TRACE(p);
 		res := pthread_create(ADDRESS OF id, ADDRESS OF attr, Starter, p);
-		FOR i := 0 TO 1000000000 DO END;
 		RETURN id;
 	END ThrStart;
 
@@ -672,87 +674,61 @@ VAR
 	
 	PROCEDURE ThrKill*(thr: Thread_t);
 	BEGIN
-	(*
-    if (thr != mainthread) {
-    	pthread_detach( thr );
-    	if (thr == pthread_self())
-    	    pthread_exit( 0 );
-    	else {
-    	    pthread_cancel( thr );
-        } 
-    }
-    *)
+	    IF (thr # mainthread) THEN
+	    	pthread_detach( thr );
+	    	IF (thr = pthread_self()) THEN
+	    	    pthread_exit( 0 );
+			ELSE
+	    	    pthread_cancel( thr );
+	        END
+	    END;  
     END ThrKill;
 	
 	
+
+
 PROCEDURE {C} resume_handler(sig: LONGINT);
 BEGIN
 END resume_handler;
 
-PROCEDURE {C} suspend_handler(sig: LONGINT);
-BEGIN
-	TRACE("suspend handler"); 
-	(*
-    sigset_t block;
-
-    sigfillset( &block );
-    sigdelset( &block, T_SIGRESUME );
-    suspend_done = 1;
-
-    sigsuspend( &block ); /* await T_SIGRESUME */
-
-    resume_done = 1;
-    *)
-END suspend_handler;
-
 PROCEDURE ThrResume*(thr: Thread_t);
-VAR n: LONGINT;
+VAR n: LONGINT; res: LONGINT;
 BEGIN
-	(*
-	void 
-    int n;
-
-    pthread_mutex_lock( &suspend_mutex );
-    resume_done = 0; n = 1;
+    res := pthread_mutex_lock( ADDRESS OF suspend_mutex );
+    resume_done := 0; n := 1;
     pthread_kill( thr, T_SIGRESUME ); 
-    while (resume_done != 1 && n < 50) { o_thrSleep( 1 ); n++; }
-    pthread_mutex_unlock( &suspend_mutex );
-}
-*)
+    WHILE (resume_done # 1) & (n < 50) DO ThrSleep(1); INC(n) END; 
+    res := pthread_mutex_unlock( ADDRESS OF suspend_mutex );
 END ThrResume;
 
-
-PROCEDURE ThrSuspend*(thr: Thread_t);
-VAR n: LONGINT;
-BEGIN
-	(*
-PROCEDURE ThrResume*(thr: Thread_t);
-VAR n: LONGINT;
+PROCEDURE {C} suspend_handler(sig: LONGINT);
+VAR block: Sigset_t; res: LONGINT;
 BEGIN
-	(*
-	void 
-    int n;
 
-    pthread_mutex_lock( &suspend_mutex );
-    resume_done = 0; n = 1;
-    pthread_kill( thr, T_SIGRESUME ); 
-    while (resume_done != 1 && n < 50) { o_thrSleep( 1 ); n++; }
-    pthread_mutex_unlock( &suspend_mutex );
-}
-*)
-END ThrResume;
+    res := sigfillset( ADDRESS OF block );
+    sigdelset(  ADDRESS OF block, T_SIGRESUME );
+    suspend_done := 1;
+
+    res := sigsuspend(  ADDRESS OF block ); (* await T_SIGRESUME *)
 
+    resume_done := 1;
+END suspend_handler;
 
-}
-*)
+PROCEDURE ThrSuspend*(thr: Thread_t);
+VAR res: LONGINT;
+BEGIN
+    res := pthread_mutex_lock(ADDRESS OF suspend_mutex );
+    suspend_done := 0;
+    pthread_kill( thr, T_SIGSUSPEND );
+    WHILE (suspend_done # 1) DO ThrSleep( 1 ) END;
+    res := pthread_mutex_unlock( ADDRESS OF suspend_mutex );
 END ThrSuspend;
 
 
 TYPE
 	Sigaction = RECORD
 		sa_handler: ADDRESS;
-		sa_mask0: ADDRESS; 
-		sa_mask1: ADDRESS; 
+		sa_mask: Sigset_t;
 		sa_flags: ADDRESS;
 		filler: ADDRESS;
 	END;
@@ -765,6 +741,8 @@ TYPE
 VAR 
 	suspend_mutex: MutexType;
 	mainthread: Thread_t;
+	suspend_done: LONGINT;
+	resume_done: LONGINT;
 
 
 	sasuspend, saresume: Sigaction;
@@ -787,19 +765,19 @@ VAR
 			Perror("ThrInitialize: setparam");
 		END;
 		
-	    TRACE(ADDRESS OF sasuspend.sa_mask0);
-	  (*  
-	    sigemptyset( ADDRESS OF sasuspend.sa_mask0 );
-	    sigaddset(  ADDRESS OF sasuspend.sa_mask0, T_SIGRESUME );
+	    TRACE(ADDRESS OF sasuspend.sa_mask);
+
+	    sigemptyset( ADDRESS OF sasuspend.sa_mask );
+	    sigaddset(  ADDRESS OF sasuspend.sa_mask, T_SIGRESUME );
 	    sasuspend.sa_flags := 0;
 	    sasuspend.sa_handler := suspend_handler;
 	    ASSERT(sigaction( T_SIGSUSPEND, ADDRESS OF sasuspend, NIL ) = 0);
 
-	    sigemptyset( ADDRESS OF saresume.sa_mask0 );
+	    sigemptyset( ADDRESS OF saresume.sa_mask );
 	    saresume.sa_flags := 0;
 	    saresume.sa_handler := resume_handler;
 	    ASSERT(sigaction( T_SIGRESUME, ADDRESS OF saresume, NIL ) = 0);
-	  *)  
+
 	    RETURN TRUE;
 	END ThrInitialize;
 
@@ -941,6 +919,10 @@ VAR
 
 		Dlsym( libp, "pthread_create", ADDRESSOF(pthread_create));
 		Dlsym( libp, "pthread_exit", ADDRESSOF(pthread_exit));
+		Dlsym( libp, "pthread_detach", ADDRESSOF(pthread_detach));
+		Dlsym( libp, "pthread_cancel", ADDRESSOF(pthread_cancel));
+		Dlsym( libp, "pthread_kill", ADDRESSOF(pthread_kill));
+
 		Dlsym( libp, "pthread_sigmask", ADDRESSOF(pthread_sigmask));
 		Dlsym( libp, "pthread_setcancelstate", ADDRESSOF(pthread_setcancelstate));
 		Dlsym( libp, "pthread_setcanceltype", ADDRESSOF(pthread_setcanceltype));
@@ -961,16 +943,10 @@ VAR
 		Dlsym( libc, "sigdelset", ADDRESSOF(sigdelset));
 		Dlsym( libc, "nanosleep", ADDRESSOF(nanosleep));
 		Dlsym( libc, "sigaltstack", ADDRESSOF(sigaltstack));
-				
+		Dlsym( libc, "sigsuspend", ADDRESSOF(sigsuspend));
 				
 		(*
 		Dlsym( libc, "putc", ADDRESSOF(test));
-
-		Dlsym( libc, "sigsuspend", ADDRESSOF(test));
-		Dlsym( libc, "pthread_detach", ADDRESSOF(test));
-		Dlsym( libc, "pthread_cancel", ADDRESSOF(test));
-		Dlsym( libc, "pthread_create", ADDRESSOF(test));
-		Dlsym( libc, "pthread_kill", ADDRESSOF(test));
 		*)
 		
 		Dlsym( libc, "read",		ADDRESSOF( read ) );
@@ -1018,10 +994,10 @@ VAR
 		Dlsym( libc, "readdir",		ADDRESSOF( readdir ) );
 		Dlsym( libc, "closedir",	ADDRESSOF( closedir ) );
 
-(*
-		Dlsym( libc, "sigsetjmp",	ADDRESSOF( sigsetjmp ) );
-		Dlsym( libc, "siglongjmp",	ADDRESSOF( siglongjmp ) );
-*)
+
+		(*Dlsym( libp, "sigsetjmp",	ADDRESSOF( sigsetjmp ) );*)
+		(*Dlsym( libc, "siglongjmp",	ADDRESSOF( siglongjmp ) );*)
+
 
 		Dlsym( libc, "malloc",		ADDRESSOF( malloc ) );
 		Dlsym( libc, "posix_memalign",	ADDRESSOF( posix_memalign ) );

source/Generic.Unix.Objects.Mod

@@ -61,22 +61,6 @@ VAR
 	finalizerCaller	: FinalizerCaller;
 	finCaller			: Process;
 	
-	
-	(* the dummy parameters assure proper stack alignment when compiled with 
-		option "\A" or "--darwinHost" *)
-	(*
-	thrStart: 			PROCEDURE {REALTIME, C} ( p: PROCEDURE;  stackLen: LONGINT ): Unix.Thread_t;
-	Unix.ThrThis: 			PROCEDURE {REALTIME, C} ( dummy: LONGINT ): Unix.Thread_t;
-	Unix.ThrSleep: 			PROCEDURE {REALTIME, C} ( ms: LONGINT );
-	Unix.ThrYield: 			PROCEDURE {REALTIME, C} ( dummy: LONGINT );
-	Unix.ThrExit: 			PROCEDURE {REALTIME, C} ( dummy: LONGINT );
-	Unix.ThrSuspend: 		PROCEDURE {REALTIME, C} ( t: Unix.Thread_t );
-	Unix.ThrResume: 		PROCEDURE {REALTIME, C} ( t: Unix.Thread_t );
-	Unix.ThrSetPriority: 	PROCEDURE {REALTIME, C} ( t: Unix.Thread_t;  prio: LONGINT );
-	Unix.ThrGetPriority: 	PROCEDURE {REALTIME, C} ( t: Unix.Thread_t ): LONGINT;
-	thrKill: 			PROCEDURE {REALTIME, C} ( t: Unix.Thread_t );
-	*)
-	
 
 TYPE
 
@@ -263,11 +247,14 @@ TYPE
 				body := bodyProc;  
 				Unix.MtxLock( startProcess );
 				TRACE(body);
-					thr := Unix.ThrStart( BodyStarter, stacksize );
-				TRACE(body);
-					Unix.ConWait( childrunning, startProcess );
+				thr := Unix.ThrStart( BodyStarter, stacksize );
+				TRACE(1,thr);
+				TRACE(1, childrunning, startProcess);
+				Unix.ConWait( childrunning, startProcess );
 				Unix.MtxUnlock( startProcess );
+				TRACE(2,thr);
 				RegisterFinalizer( SELF, FinalizeProcess );
+				TRACE(3,thr);
 			ELSE 
 				(* first process *)
 				stackBottom := Glue.stackBottom;  
@@ -286,9 +273,11 @@ TYPE
 
 	
 	PROCEDURE BodyStarter;
-	VAR p{UNTRACED}: Process;  res: LONGINT; prevBP: ADDRESS;
+	VAR p{UNTRACED}: Process;  res: LONGINT; prevBP: ADDRESS; i: LONGINT;
 	BEGIN
+		TRACE("Bodystarter running");
 		Unix.MtxLock( startProcess );
+		TRACE("start process");
 			p := newProcess;  newProcess := NIL;
 			p.threadId := Unix.ThrThis(0);  
 			p.id := nextPID;  INC( nextPID );
@@ -303,9 +292,11 @@ TYPE
 		Unix.MtxUnlock( startProcess );
 
 		p.SetPriority( p.priority );
+		(*!
 		IF Restart IN p.flags THEN
 			res := Unix.sigsetjmp( ADDRESSOF( p.state0[0] ), 1 );
 		END;
+		*)
 		p.mode := Running;
 		p.body( p.obj );
 		p.mode := Terminated;
@@ -561,7 +552,7 @@ TYPE
 				IF prev = NIL THEN  root := p.nextProcess  ELSE  prev.nextProcess := p.nextProcess  END;
 			END;
 		Unix.MtxUnlock( processList );
-		Unix.ThrExit(0)
+		Unix.ThrExit(0);
 	END Exit;
 
 	PROCEDURE ExitTrap*;
@@ -792,8 +783,16 @@ TYPE
 		Heaps.InvokeGC := InvokeGC;
 		*)
 	END Init;
+	
+	PROCEDURE {FINAL} Final;
+	BEGIN
+		TRACE("FINAL END ");
+		Machine.Shutdown(FALSE);
+	END Final;
 
 BEGIN
+	TRACE("Objects.Body1");
 	Init;
+	TRACE("Objects.Body2");
 END Objects.