fixed Objects.CurrentProcess()

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

source/Generic.Darwin.I386.Unix.Mod

@@ -156,6 +156,8 @@ TYPE
 	MutexAttributeType	= ARRAY 12 OF CHAR;	(* 64bit: 16 *)
 	ConditionType		= ARRAY 28 OF CHAR;	(* 64bit: 48 *)
 
+	Key_t* = ADDRESS;
+	
 	Sigset = ARRAY 4 OF CHAR;
 	SignalTrap = PROCEDURE ( sig: LONGINT; mc: Mcontext );
 	
@@ -426,6 +428,10 @@ VAR
 	pthread_detach: PROCEDURE {C} (thr: ADDRESS);
 	pthread_kill: PROCEDURE {C} (thr: ADDRESS; sigid: LONGINT): LONGINT;
 	pthread_cancel: PROCEDURE {C} (thr: ADDRESS);
+	
+	pthread_key_create	: PROCEDURE {C} ( key: ADDRESS; destructor: PROCEDURE {C} ( param: ADDRESS ) ): WORD;
+	pthread_setspecific	: PROCEDURE {C} ( key: Key_t; value: ADDRESS ): WORD;
+	pthread_getspecific	: PROCEDURE {C} ( key: Key_t ): ADDRESS;
 
 	pthread_attr_init: PROCEDURE {C} (attr: ADDRESS);
 	pthread_attr_setscope: PROCEDURE {C}(attr: ADDRESS; set: WORD);
@@ -545,6 +551,25 @@ VAR
 	END getnprocs;
 
 
+	PROCEDURE NewKey*( ): Key_t;
+	VAR
+		key: Key_t;
+	BEGIN
+		ASSERT(pthread_key_create(ADDRESSOF(key), NIL) = 0);
+		RETURN key;
+	END NewKey;
+ 
+	PROCEDURE ReadKey* (key: Key_t): ADDRESS;
+	BEGIN
+		RETURN pthread_getspecific(key);
+	END ReadKey;
+
+	PROCEDURE WriteKey* (key: Key_t; value: ADDRESS);
+	BEGIN
+		ASSERT(pthread_setspecific(key, value) = 0);
+	END WriteKey;
+	
+	
 	PROCEDURE NewMtx*( ): Mutex_t;
 	VAR
 		mtx: Mutex_t;
@@ -1015,6 +1040,10 @@ VAR
 		Dlsym( libp, "pthread_detach", ADDRESSOF(pthread_detach) );
 		Dlsym( libp, "pthread_cancel", ADDRESSOF(pthread_cancel) );
 		Dlsym( libp, "pthread_kill", ADDRESSOF(pthread_kill) );
+		
+		Dlsym( libp, "pthread_key_create", ADDRESSOF( pthread_key_create ) );
+		Dlsym( libp, "pthread_getspecific", ADDRESSOF( pthread_getspecific ) );
+		Dlsym( libp, "pthread_setspecific", ADDRESSOF( pthread_setspecific ) );
 
 		Dlsym( libp, "pthread_sigmask", ADDRESSOF(pthread_sigmask) );
 		Dlsym( libp, "pthread_setcancelstate", ADDRESSOF(pthread_setcancelstate) );

source/Generic.Linux.I386.Unix.Mod

@@ -147,6 +147,8 @@ TYPE
 
 	Condition_t* = ADDRESS;
 	ConditionType = ARRAY 12 OF WORD;
+	
+	Key_t* = ADDRESS;
 
 	Sigset_t= ARRAY 32 OF ADDRESS;
 	SignalTrap = PROCEDURE ( sig: LONGINT; mc: Mcontext );
@@ -419,6 +421,10 @@ VAR
 	pthread_detach: PROCEDURE {C} (thr: ADDRESS);
 	pthread_kill: PROCEDURE {C} (thr: ADDRESS; sigid: LONGINT): LONGINT;
 	pthread_cancel: PROCEDURE {C} (thr: ADDRESS);
+	
+	pthread_key_create	: PROCEDURE {C} ( key: ADDRESS; destructor: PROCEDURE {C} ( param: ADDRESS ) ): WORD;
+	pthread_setspecific	: PROCEDURE {C} ( key: Key_t; value: ADDRESS ): WORD;
+	pthread_getspecific	: PROCEDURE {C} ( key: Key_t ): ADDRESS;
 
 	pthread_attr_init: PROCEDURE {C} (attr: ADDRESS);
 	pthread_attr_setscope: PROCEDURE {C}(attr: ADDRESS; set: WORD);
@@ -528,6 +534,24 @@ VAR
 	BEGIN
 		RETURN sysconf( 0x54 ); (*0x53 for number of processors configured, 0x54 for number of processors online *)
 	END getnprocs;
+ 
+	PROCEDURE NewKey*( ): Key_t;
+	VAR
+		key: Key_t;
+	BEGIN
+		ASSERT(pthread_key_create(ADDRESSOF(key), NIL) = 0);
+		RETURN key;
+	END NewKey;
+ 
+	PROCEDURE ReadKey* (key: Key_t): ADDRESS;
+	BEGIN
+		RETURN pthread_getspecific(key);
+	END ReadKey;
+
+	PROCEDURE WriteKey* (key: Key_t; value: ADDRESS);
+	BEGIN
+		ASSERT(pthread_setspecific(key, value) = 0);
+	END WriteKey;
 
 
 	PROCEDURE NewMtx*( ): Mutex_t;
@@ -1046,6 +1070,10 @@ VAR
 		Dlsym( libp, "pthread_detach", ADDRESSOF(pthread_detach) );
 		Dlsym( libp, "pthread_cancel", ADDRESSOF(pthread_cancel) );
 		Dlsym( libp, "pthread_kill", ADDRESSOF(pthread_kill) );
+		
+		Dlsym( libp, "pthread_key_create", ADDRESSOF( pthread_key_create ) );
+		Dlsym( libp, "pthread_getspecific", ADDRESSOF( pthread_getspecific ) );
+		Dlsym( libp, "pthread_setspecific", ADDRESSOF( pthread_setspecific ) );
 
 		Dlsym( libp, "pthread_sigmask", ADDRESSOF(pthread_sigmask) );
 		Dlsym( libp, "pthread_setcancelstate", ADDRESSOF(pthread_setcancelstate) );

source/Generic.Solaris.I386.Unix.Mod

@@ -163,6 +163,8 @@ TYPE
 	Thread_t* = LONGINT;
 	PthreadAttributeDesc = RECORD attr: ADDRESS END;
 	
+	Key_t* = ADDRESS;
+	
 	Mutex_t* = ADDRESS;
 	MutexDesc = ARRAY 24 OF CHAR;
 	MutexAttributeDesc = RECORD attr: ADDRESS END;
@@ -432,6 +434,10 @@ VAR
 	pthread_cancel	: PROCEDURE {C} ( thr: Thread_t );
 	pthread_self		: PROCEDURE {C} ( ): Thread_t;
 	
+	pthread_key_create:		PROCEDURE {C} ( key: ADDRESS; destructor: PROCEDURE {C} ( param: ADDRESS ) ): WORD;
+	pthread_setspecific:		PROCEDURE {C} ( key: Key_t; value: ADDRESS ): WORD;
+	pthread_getspecific:		PROCEDURE {C} ( key: Key_t ): ADDRESS;
+	
 	pthread_attr_init: PROCEDURE {C} ( attr: ADDRESS );
 	pthread_attr_setscope: PROCEDURE {C} ( attr: ADDRESS; set: WORD );
 	pthread_attr_setdetachstate: PROCEDURE {C} ( attr: ADDRESS; set: WORD );
@@ -567,7 +573,25 @@ VAR
 	BEGIN
 		RETURN sysconf( 15 ); (* 14 for number of processors configured, 15 for number of processors online *)
 	END getnprocs;
+	
+ 
+	PROCEDURE NewKey*( ): Key_t;
+	VAR
+		key: Key_t;
+	BEGIN
+		ASSERT(pthread_key_create(ADDRESSOF(key), NIL) = 0);
+		RETURN key;
+	END NewKey;
+ 
+	PROCEDURE ReadKey* (key: Key_t): ADDRESS;
+	BEGIN
+		RETURN pthread_getspecific(key);
+	END ReadKey;
 
+	PROCEDURE WriteKey* (key: Key_t; value: ADDRESS);
+	BEGIN
+		ASSERT(pthread_setspecific(key, value) = 0);
+	END WriteKey;
 
 	(*------------------------------------------------------------------------------------------------------*)
 	
@@ -1001,6 +1025,10 @@ VAR
 		Dlsym( libp, "pthread_detach", ADDRESSOF( pthread_detach ) );
 		Dlsym( libp, "pthread_cancel", ADDRESSOF( pthread_cancel ) );
 		Dlsym( libp, "pthread_kill", ADDRESSOF( pthread_kill ) );
+		
+		Dlsym( libp, "pthread_key_create", ADDRESSOF( pthread_key_create ) );
+		Dlsym( libp, "pthread_getspecific", ADDRESSOF( pthread_getspecific ) );
+		Dlsym( libp, "pthread_setspecific", ADDRESSOF( pthread_setspecific ) );
 
 		Dlsym( libp, "pthread_sigmask", ADDRESSOF( pthread_sigmask ) );
 		Dlsym( libp, "pthread_setcancelstate", ADDRESSOF( pthread_setcancelstate ) );

source/Generic.Unix.Objects.Mod

@@ -52,7 +52,9 @@ VAR
 	startProcess		: Unix.Mutex_t;
 	lockMutex		: Unix.Mutex_t;
 	childrunning		: Unix.Condition_t;
-		
+	
+	processPointer	: Unix.Key_t;
+	
 	newProcess: Process;
 	nextPID: LONGINT;
 	
@@ -298,6 +300,7 @@ TYPE
 				id := 0;  nextPID := 1;
 				root := SELF;
 				mode := Running;
+				Unix.WriteKey( processPointer, SELF );
 			END;
 		END Initialize;
 				
@@ -339,6 +342,7 @@ TYPE
 	BEGIN
 		Unix.MtxLock( startProcess );
 			p := newProcess;  newProcess := NIL;
+			Unix.WriteKey( processPointer, p );
 			p.id := nextPID;  INC( nextPID );
 			p.stackBottom := Machine.CurrentBP( );
 			S.GET( p.stackBottom, prevBP );
@@ -522,14 +526,8 @@ TYPE
 	
 	(* Return current process. (DEPRECATED, use ActiveObject) *)
 	PROCEDURE CurrentProcess*( ): Process;	
-	VAR me: Unix.Thread_t;  p: Process;
 	BEGIN
-		me := Unix.ThrThis( );
-		Unix.MtxLock( processList );
-		p := root;
-		WHILE (p # NIL) & (p.threadId # me) DO  p := p.nextProcess  END;
-		Unix.MtxUnlock( processList );
-		RETURN p
+		RETURN S.VAL( Process, Unix.ReadKey( processPointer ) )
 	END CurrentProcess;
 	
 	PROCEDURE CurrentContext*(): ANY;
@@ -548,15 +546,6 @@ TYPE
 		IF p # NIL THEN p.context := context END;
 	END SetContext;
 	
-	PROCEDURE CurrentProcess0( ): Process;	
-	VAR me: Unix.Thread_t;  p: Process;
-	BEGIN
-		me := Unix.ThrThis( );
-		p := root;
-		WHILE (p # NIL) & (p.threadId # me) DO  p := p.nextProcess  END;
-		RETURN p
-	END CurrentProcess0;
-
 	
 	(* Return the active object currently executing. *)
 	PROCEDURE ActiveObject*( ): ANY;		
@@ -741,9 +730,7 @@ TYPE
 	PROCEDURE GetContext( ctxt: Unix.Ucontext );
 	VAR t: Process; context: Unix.McontextDesc;
 	BEGIN
-		(*	use CurrentProcess0 here instead of CurrentProcess in order to
-			avoid a possible deadlock *)
-		t := CurrentProcess0( );
+		t := CurrentProcess( );
 		Unix.CopyContext( ctxt.mc, context );
 		t.state.PC := context.r_pc;
 		t.state.BP := context.r_bp;
@@ -884,6 +871,8 @@ TYPE
 		createProcess := Unix.NewMtx( );  processList := Unix.NewMtx( );
 		startProcess := Unix.NewMtx( );  childrunning := Unix.NewCond( ); 
 		lockMutex := Unix.NewMtx( );
+		
+		processPointer := Unix.NewKey( );
 											
 		GetStacksize;  
 		Convert;