Generic.Unix.Objects.Mod 26 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982
  1. (* Aos, Copyright 2001, Pieter Muller, ETH Zurich *)
  2. MODULE Objects; (** AUTHOR "pjm, G.F."; PURPOSE "Active object runtime support"; *)
  3. IMPORT S := SYSTEM, Trace, Glue, Unix, Machine, Heaps, Modules;
  4. CONST
  5. (*! Process flags, meaningless in Unix ports !!! *)
  6. PleaseHalt* = 10; (* Process requested to Halt itself soon *)
  7. Unbreakable*= 11; (* FINALLY shall not catch HALT exception (PleaseHalt is also set) *)
  8. SelfTermination*=12; (* Indicates the process has requested to terminate ifself (PleaseHalt is also set) *)
  9. Preempted* = 27; (* Has been preempted. *)
  10. Resistant* = 28; (* Can only be destroyed by itself *)
  11. MinPriority* = Unix.ThreadLow;
  12. Low* = Unix.ThreadLow + 1;
  13. Normal* = Unix.ThreadNormal;
  14. High* = Unix.ThreadHigh - 2;
  15. GCPriority* = Unix.ThreadHigh - 1;
  16. Realtime* = Unix.ThreadHigh;
  17. (* Process flag defined by compiler in OPC.CallRecBody *)
  18. Restart* = 0; (* Restart/Destroy process on exception *)
  19. (* Process modes (in UnixAos Running means Running or Ready!) *)
  20. Unknown* = 0; Ready* = 1; Running* = 2; AwaitingLock* = 3;
  21. AwaitingCond* = 4; AwaitingEvent* = 5; Terminated* = 6;
  22. Second* = 1000; (* frequency of ticks increments in Hz *)
  23. DefaultStacksize = 128*1024;
  24. AddrSize = SIZEOF( ADDRESS )
  25. VAR
  26. (* timer *)
  27. timerActivity : TimerActivity;
  28. clock : Clock;
  29. timers : Timer;
  30. timerListMutex : Unix.Mutex_t;
  31. (* processes *)
  32. mainProcess : Process; (* runs the GC *)
  33. root- : Process; (*! Anchor of all instantiated threads in system *)
  34. stacksize: LONGINT; (* stack size of active objects, adjustable via boot parameter *)
  35. processList : Unix.Mutex_t;
  36. createProcess : Unix.Mutex_t;
  37. startProcess : Unix.Mutex_t;
  38. lockMutex : Unix.Mutex_t;
  39. childrunning : Unix.Condition_t;
  40. newProcess: Process;
  41. nextPID: LONGINT;
  42. (* garbage colletion *)
  43. gcFinished: Unix.Condition_t; igc: Unix.Mutex_t;
  44. collect: BOOLEAN;
  45. finalizerCaller : FinalizerCaller;
  46. finCaller : Process;
  47. TYPE
  48. LockT= POINTER TO RECORD
  49. mtx, enter: ADDRESS;
  50. END;
  51. CpuCyclesArray* = ARRAY Machine.MaxCPU OF HUGEINT;
  52. ProtectedObject = POINTER TO RECORD END;
  53. ObjectHeader = Heaps.ProtRecBlock;
  54. ProcessQueue = Heaps.ProcessQueue;
  55. EventHandler* = PROCEDURE {DELEGATE};
  56. Timer* = OBJECT
  57. VAR
  58. next: Timer;
  59. trigger: LONGINT;
  60. handler: EventHandler
  61. END Timer;
  62. TimerActivity = OBJECT
  63. VAR
  64. t, r: Timer; h: EventHandler; restart: BOOLEAN;
  65. PROCEDURE UpdateTicks;
  66. BEGIN {EXCLUSIVE}
  67. Machine.UpdateTicks
  68. END UpdateTicks;
  69. PROCEDURE Restart;
  70. BEGIN {EXCLUSIVE}
  71. restart := TRUE
  72. END Restart;
  73. BEGIN {ACTIVE, SAFE, PRIORITY(High)}
  74. restart := FALSE;
  75. LOOP
  76. t := timers;
  77. IF t # NIL THEN
  78. h := NIL; r := NIL;
  79. BEGIN {EXCLUSIVE}
  80. AWAIT( (Machine.ticks >= t.trigger) OR restart ); restart := FALSE;
  81. IF Machine.ticks >= t.trigger THEN
  82. h := t.handler; r := t
  83. END
  84. END;
  85. IF r # NIL THEN Remove( r ) END;
  86. IF h # NIL THEN (* not canceled *) h END
  87. ELSE
  88. BEGIN{EXCLUSIVE}
  89. AWAIT( restart ); restart := FALSE;
  90. END
  91. END
  92. END
  93. END TimerActivity;
  94. Clock* = OBJECT
  95. BEGIN{ACTIVE}
  96. LOOP
  97. Unix.ThrSleep( 10 );
  98. timerActivity.UpdateTicks
  99. END;
  100. END Clock;
  101. FinalizedCollection* = OBJECT (* base type for collection, extended in Kernel.Mod *)
  102. PROCEDURE RemoveAll*(obj: ANY); (** abstract *)
  103. BEGIN HALT(301) END RemoveAll;
  104. END FinalizedCollection;
  105. FinalizerNode* = POINTER TO RECORD (Heaps.FinalizerNode)
  106. c*: FinalizedCollection (* base type for collection containing object *)
  107. END;
  108. FinalizerCaller = OBJECT (* separate active object that calls finalizers *)
  109. VAR
  110. n: Heaps.FinalizerNode; start: BOOLEAN;
  111. PROCEDURE Activate;
  112. BEGIN {EXCLUSIVE}
  113. start := TRUE
  114. END Activate;
  115. BEGIN {ACTIVE, SAFE, PRIORITY(High)}
  116. finCaller := CurrentProcess( ); start := FALSE;
  117. LOOP
  118. BEGIN {EXCLUSIVE} AWAIT( start ) END;
  119. start := FALSE;
  120. LOOP
  121. n := Heaps.GetFinalizer();
  122. IF n = NIL THEN EXIT END;
  123. IF n IS FinalizerNode THEN
  124. n(FinalizerNode).c.RemoveAll(n.objStrong) (* remove it if it is not removed yet *)
  125. END;
  126. IF n.finalizer # NIL THEN
  127. n.finalizer(n.objStrong) (* may acquire locks *)
  128. END;
  129. END;
  130. END
  131. END FinalizerCaller;
  132. Body = PROCEDURE ( self: ProtectedObject );
  133. Condition = PROCEDURE ( slink: ADDRESS ): BOOLEAN;
  134. Process* = OBJECT (Heaps.ProcessLink)
  135. VAR
  136. threadId- : Unix.Thread_t;
  137. nextProcess- : Process; (* next in list of all processes *)
  138. stackBottom - : ADDRESS;
  139. context*: Unix.McontextDesc;
  140. id- : LONGINT;
  141. body : Body;
  142. mode- : LONGINT; (*states: Unknown, Ready, Running, AwaitingLock, AwaitingCond, AwaitingEvent, Terminated as defined in the constants *)
  143. flags- : SET;
  144. priority- : LONGINT; (* only effective if Aos is running SUID root *)
  145. succ : Process; (* in ProcessQueue *)
  146. obj- : ProtectedObject; (* associated active object *)
  147. condition- : Condition; (* awaited process' condition *)
  148. condFP- : ADDRESS; (* awaited process' condition's context *)
  149. continue : Unix.Condition_t; (* gets signaled when condition yields true *)
  150. waitingOn- : ProtectedObject;
  151. procID- : LONGINT; (* processor ID where running, not used in UnixAos *)
  152. state- : Machine.State; (*! not used in UnixAos! *)
  153. state0 : ARRAY 2048 OF CHAR; (* thread state at body start, used for restart after trap *)
  154. PROCEDURE FindRoots*;
  155. VAR sp, ptr, bp, n, a0, a1, adr: ADDRESS; desc: Modules.ProcedureDescPointer; i: LONGINT; p {UNTRACED}: ANY;
  156. me: Process;
  157. BEGIN
  158. IF mode # Terminated THEN
  159. IF SELF = CurrentProcess() THEN
  160. context.r_sp := Machine.CurrentSP();
  161. context.r_bp := Machine.CurrentBP();
  162. context.r_pc := ADDRESS OF FindRoots;
  163. END;
  164. sp := context.r_sp; bp := context.r_bp; (*pc := context.r_pc;*)
  165. (*
  166. TRACE(context.r_si, context.r_di, context.r_bp, context.r_sp_x);
  167. TRACE(context.r_bx, context.r_dx, context.r_cx, context.r_ax);
  168. TRACE(context.r_pc, context.r_sp, context.fpc);
  169. TRACE(sp, bp, stackBottom);
  170. *)
  171. IF Heaps.GCType= Heaps.HeuristicStackInspectionGC THEN
  172. Heaps.Candidate( context.r_di); Heaps.Candidate( context.r_si );
  173. Heaps.Candidate( context.r_bx ); Heaps.Candidate( context.r_dx);
  174. Heaps.Candidate( context.r_cx ); Heaps.Candidate( context.r_ax);
  175. IF (stackBottom # 0) & (sp # 0) & (sp <= stackBottom) THEN
  176. (*TRACE(sp, stackBottom -sp);*)
  177. Heaps.RegisterCandidates( sp, stackBottom - sp );
  178. END;
  179. ELSIF Heaps.GCType = Heaps.MetaDataForStackGC THEN
  180. IF bp < stackBottom THEN
  181. WHILE (bp # Heaps.NilVal) & (bp > 1024) & (bp < stackBottom) DO (* do not test for bp >= sp: could be wrong temporarily! *)
  182. TRACE(bp);
  183. S.GET(bp, n);
  184. TRACE(n);
  185. IF ODD(n) THEN (* procedure descriptor at bp *)
  186. IF n > 1024 THEN
  187. desc := S.VAL(Modules.ProcedureDescPointer, n-1);
  188. IF desc # NIL THEN
  189. a0 := ADDRESSOF(desc.offsets);
  190. a1 := S.VAL(ADDRESS, desc.offsets);
  191. ASSERT(a0+SIZEOF(ADDRESS)=a1,54321);
  192. FOR i := 0 TO LEN(desc.offsets)-1 DO
  193. adr := bp + desc.offsets[i]; (* pointer at offset *)
  194. S.GET(adr, p); (* load pointer *)
  195. IF p # NIL THEN
  196. Heaps.Mark(p);
  197. END;
  198. END;
  199. END;
  200. END;
  201. S.GET(bp + SIZEOF(ADDRESS), bp);
  202. ELSE (* classical stack frame *)
  203. bp := n;
  204. END;
  205. TRACE(bp);
  206. END;
  207. ASSERT((bp = stackBottom) OR (bp<1024) ,12345);
  208. END;
  209. END;
  210. (*
  211. sp := context.r_sp;
  212. WHILE sp < stackBottom DO
  213. S.GET( sp, ptr );
  214. IF (ptr # 0) & (ptr MOD 8 = 0) THEN Heaps.Candidate( ptr ) END;
  215. INC( sp, AddrSize )
  216. END;
  217. *)
  218. END;
  219. Heaps.Mark( nextProcess )
  220. END FindRoots;
  221. PROCEDURE Cancel;
  222. VAR pt, t: Process; kt: Unix.Thread_t;
  223. BEGIN
  224. IF SELF = CurrentProcess() THEN Exit
  225. ELSE
  226. Machine.Acquire( Machine.X11 ); (* let the thread to be killed first finish its last I/O, if any *)
  227. Unix.MtxLock( processList );
  228. pt := NIL; t := root; kt := 0;
  229. WHILE (t # NIL ) & (t # SELF) DO pt := t; t := t.nextProcess END;
  230. IF t = SELF THEN
  231. kt := threadId;
  232. IF pt = NIL THEN root := t.nextProcess ELSE pt.nextProcess := t.nextProcess END;
  233. END;
  234. Unix.MtxUnlock( processList );
  235. IF kt # 0 THEN Unix.ThrKill( kt ) END;
  236. Machine.Release( Machine.X11 );
  237. END
  238. END Cancel;
  239. PROCEDURE GetPriority( ): LONGINT;
  240. BEGIN
  241. RETURN Unix.ThrGetPriority( threadId )
  242. END GetPriority;
  243. PROCEDURE SetPriority( prio: LONGINT );
  244. VAR pr: LONGINT;
  245. BEGIN
  246. pr := max( Machine.prioLow, min( prio, Machine.prioHigh ) );
  247. Unix.ThrSetPriority( threadId, pr ); (* works only if SUID root *)
  248. priority := GetPriority( )
  249. END SetPriority;
  250. PROCEDURE & Initialize( obj: ProtectedObject; bodyProc: Body; prio: LONGINT; fl: SET; stacksize: LONGINT);
  251. VAR thr: Unix.Thread_t;
  252. BEGIN
  253. SELF.obj := obj; condition := NIL; continue := Unix.ConInit(0);
  254. flags := fl;
  255. priority := prio;
  256. nextProcess := NIL;
  257. IF root # NIL THEN
  258. newProcess := SELF;
  259. ASSERT( bodyProc # NIL );
  260. body := bodyProc;
  261. Unix.MtxLock( startProcess );
  262. thr := Unix.ThrStart( BodyStarter, stacksize );
  263. Unix.ConWait( childrunning, startProcess );
  264. Unix.MtxUnlock( startProcess );
  265. RegisterFinalizer( SELF, FinalizeProcess );
  266. ELSE
  267. (* first process *)
  268. stackBottom := Glue.stackBottom;
  269. threadId := Unix.ThrThis(0);
  270. id := 0; nextPID := 1;
  271. root := SELF;
  272. mainProcess := SELF;
  273. mode := Running;
  274. END;
  275. END Initialize;
  276. END Process;
  277. GCStatusExt = OBJECT(Heaps.GCStatus)
  278. (* called from Heaps.InvokeGC, i.e. this is a hidden upcall. However, it is necessary to take the Machine.Objects lock here since writing
  279. the set of variables here must not be interrupted, i.e. atomic writing of the set of variables is absolutely necessary. They system may hang
  280. if the lock is not taken. *)
  281. PROCEDURE SetgcOngoing(value: BOOLEAN);
  282. VAR p: Heaps.ProcessLink; cur, r: Process; res: LONGINT; num: LONGINT; time: LONGINT;
  283. BEGIN (* serialize writers *)
  284. cur:= CurrentProcess();
  285. IF value THEN
  286. (*collect := TRUE;
  287. TRACE(collect);
  288. collect := FALSE;
  289. *)
  290. Machine.Acquire(Machine.Objects);
  291. Machine.Acquire( Machine.Heaps );
  292. cur.context.r_sp := Machine.CurrentSP();
  293. cur.context.r_bp := Machine.CurrentBP();
  294. cur.context.r_pc := ADDRESS OF GCLoop;
  295. (*
  296. TRACE(cur, cur.threadId, cur.context.r_sp, cur.context.r_bp, cur.context.r_pc);
  297. *)
  298. SuspendActivities;
  299. Heaps.CollectGarbage( Modules.root );
  300. Machine.Release( Machine.Heaps );
  301. Machine.Release(Machine.Objects);
  302. ResumeActivities;
  303. finalizerCaller.Activate;
  304. END;
  305. END SetgcOngoing;
  306. END GCStatusExt;
  307. PROCEDURE BodyStarter;
  308. VAR p{UNTRACED}: Process; res: LONGINT; prevBP: ADDRESS; i: LONGINT;
  309. BEGIN
  310. Unix.MtxLock( startProcess );
  311. p := newProcess; newProcess := NIL;
  312. p.threadId := Unix.ThrThis(0);
  313. p.id := nextPID; INC( nextPID );
  314. p.stackBottom := Machine.CurrentBP( );
  315. S.GET( p.stackBottom, prevBP );
  316. S.PUT( prevBP, S.VAL( ADDRESS, 0 ) ); (* for terminating Reflection.StackTraceBack *)
  317. Unix.MtxLock( processList );
  318. p.nextProcess := root; root := p;
  319. Unix.MtxUnlock( processList );
  320. Unix.ConSignal( childrunning );
  321. Unix.MtxUnlock( startProcess );
  322. p.SetPriority( p.priority );
  323. IF Restart IN p.flags THEN
  324. res := Unix.sigsetjmp( ADDRESSOF( p.state0[0] ), 1 );
  325. END;
  326. p.mode := Running;
  327. p.body( p.obj );
  328. p.mode := Terminated;
  329. Exit
  330. END BodyStarter;
  331. (*--------------------- create, lock, await, unlock -------------------------*)
  332. (* initialize the ObjectHeader, requires lockMutex temporarily *)
  333. PROCEDURE InitProtHeader( hdr: ObjectHeader);
  334. VAR lock: LockT;
  335. BEGIN
  336. (* we cannot hold the lockMute here because allocation can trigger the GC that requires the lock when activating the finalizers *)
  337. NEW(lock);
  338. Unix.MtxLock(lockMutex);
  339. IF hdr.lock = NIL THEN
  340. hdr.lock := lock;
  341. lock.mtx := Unix.MtxInit( 0 ); lock.enter := Unix.ConInit( 0 ); hdr.lockedBy := NIL;
  342. END;
  343. Unix.MtxUnlock(lockMutex);
  344. END InitProtHeader;
  345. PROCEDURE CreateProcess*( body: Body; priority: LONGINT; flags: SET; obj: ProtectedObject );
  346. VAR p: Process; hdr: ObjectHeader;
  347. BEGIN
  348. Unix.MtxLock( createProcess );
  349. S.GET( S.VAL( ADDRESS, obj ) + Heaps.HeapBlockOffset, hdr );
  350. InitProtHeader( hdr );
  351. IF priority = 0 THEN priority := Normal END;
  352. NEW( p, obj, body, priority, flags, stacksize ) ; (* execute BodyStarter as new (posix or solaris) thread *)
  353. Unix.MtxUnlock( createProcess );
  354. RegisterFinalizer( obj, FinalizeActiveObj )
  355. END CreateProcess;
  356. PROCEDURE Lock*( obj: ProtectedObject; exclusive: BOOLEAN );
  357. VAR hdr: ObjectHeader; p: Process; lock: LockT;
  358. BEGIN
  359. ASSERT( exclusive ); (* shared not implemented yet *)
  360. S.GET( S.VAL( ADDRESS, obj ) + Heaps.HeapBlockOffset, hdr );
  361. p := CurrentProcess();
  362. p.mode := AwaitingLock;
  363. (*! we might want to replace the lock mutex by a lock free construct *)
  364. IF hdr.lock = NIL THEN InitProtHeader( hdr ) END;
  365. lock := S.VAL(LockT, hdr.lock);
  366. Unix.MtxLock( lock.mtx );
  367. WHILE hdr.lockedBy # NIL DO
  368. (* wait until threads with complied AWAIT conditions have left the monitor *)
  369. Unix.ConWait( lock.enter, lock.mtx );
  370. END;
  371. p.mode := Running; hdr.lockedBy := p; p.waitingOn := NIL
  372. END Lock;
  373. PROCEDURE Await*( cond: Condition; slink: ADDRESS; obj: ProtectedObject; flags: SET );
  374. VAR hdr: ObjectHeader; p, c: Process; lock: LockT;
  375. BEGIN
  376. IF 1 IN flags THEN (* compiler did not generate IF *)
  377. IF cond( slink ) THEN (* condition already true *) RETURN END
  378. END;
  379. S.GET( S.VAL( ADDRESS, obj ) + Heaps.HeapBlockOffset, hdr ); c := NIL;
  380. lock := S.VAL(LockT, hdr.lock);
  381. IF hdr.awaitingCond.head # NIL THEN c := FindCondition( hdr.awaitingCond ) END;
  382. p := CurrentProcess(); p.succ := NIL; p.condition := cond; p.condFP := slink;
  383. p.waitingOn := obj; p.mode := AwaitingCond;
  384. Put( hdr.awaitingCond, p );
  385. hdr.lockedBy := c;
  386. IF c # NIL THEN Unix.ConSignal( c.continue ) ELSE Unix.ConSignal( lock.enter ) END;
  387. Unix.ConWait( p.continue, lock.mtx );
  388. p.mode := Running; hdr.lockedBy := p; p.waitingOn := NIL
  389. END Await;
  390. PROCEDURE Unlock*( obj: ProtectedObject; dummy: BOOLEAN );
  391. VAR hdr: ObjectHeader; c: Process; lock: LockT;
  392. BEGIN
  393. S.GET( S.VAL( ADDRESS, obj ) + Heaps.HeapBlockOffset, hdr ); c := NIL;
  394. lock := S.VAL(LockT,hdr.lock);
  395. IF hdr.awaitingCond.head # NIL THEN c := FindCondition( hdr.awaitingCond ) END;
  396. hdr.lockedBy := c;
  397. IF c # NIL THEN Unix.ConSignal( c.continue ) ELSE Unix.ConSignal( lock.enter ) END;
  398. Unix.MtxUnlock( lock.mtx );
  399. END Unlock;
  400. PROCEDURE FindCondition( VAR q: ProcessQueue ): Process;
  401. VAR first, cand: Process;
  402. BEGIN
  403. Get( q, first );
  404. IF first.condition( first.condFP ) THEN RETURN first ELSE Put( q, first ) END;
  405. WHILE q.head # first DO
  406. Get( q, cand );
  407. IF cand.condition( cand.condFP ) THEN RETURN cand ELSE Put( q, cand ) END;
  408. END;
  409. RETURN NIL
  410. END FindCondition;
  411. PROCEDURE Get( VAR queue: ProcessQueue; VAR new: Process );
  412. VAR t: Process;
  413. BEGIN
  414. t := queue.head(Process);
  415. IF t # NIL THEN
  416. IF t = queue.tail THEN queue.head := NIL; queue.tail := NIL
  417. ELSE queue.head := t.succ; t.succ := NIL
  418. END
  419. END;
  420. new := t
  421. END Get;
  422. PROCEDURE Put( VAR queue: ProcessQueue; t: Process );
  423. BEGIN
  424. IF queue.head = NIL THEN queue.head := t ELSE queue.tail(Process).succ := t END;
  425. queue.tail := t
  426. END Put;
  427. (*-------------------------------------------------------------------------*)
  428. PROCEDURE Terminate*;
  429. BEGIN
  430. Exit
  431. END Terminate;
  432. PROCEDURE TerminateThis*( p: Process; unbreakable: BOOLEAN );
  433. BEGIN
  434. p.mode := Terminated;
  435. p.Cancel
  436. END TerminateThis;
  437. PROCEDURE SetPriority*( pri: LONGINT ); (* Set the current process' priority. *)
  438. VAR me: Process;
  439. BEGIN
  440. me := CurrentProcess();
  441. me.SetPriority( pri )
  442. END SetPriority;
  443. PROCEDURE Sleep*( ms: LONGINT );
  444. BEGIN
  445. Unix.ThrSleep( ms )
  446. END Sleep;
  447. PROCEDURE Yield*; (* Relinquish control. *)
  448. BEGIN
  449. Unix.ThrYield(0);
  450. END Yield;
  451. (* Return current process. (DEPRECATED, use ActiveObject) *)
  452. PROCEDURE CurrentProcess*( ): Process;
  453. VAR me: Unix.Thread_t; p: Process;
  454. BEGIN
  455. me := Unix.ThrThis(0);
  456. Unix.MtxLock( processList );
  457. p := root;
  458. WHILE (p # NIL) & (p.threadId # me) DO p := p.nextProcess END;
  459. Unix.MtxUnlock( processList );
  460. RETURN p
  461. END CurrentProcess;
  462. (* Return the active object currently executing. *)
  463. PROCEDURE ActiveObject*( ): ANY;
  464. VAR p: Process;
  465. BEGIN
  466. p := CurrentProcess();
  467. RETURN p.obj
  468. END ActiveObject;
  469. (* Return stack bottom of process. For compatibility WinAos/UnixAos/NativeAos *)
  470. PROCEDURE GetStackBottom*(p: Process): ADDRESS;
  471. BEGIN
  472. RETURN p.stackBottom
  473. END GetStackBottom;
  474. PROCEDURE GetProcessID*( ): LONGINT;
  475. VAR p: Process;
  476. BEGIN
  477. p := CurrentProcess();
  478. RETURN p.id;
  479. END GetProcessID;
  480. PROCEDURE GetCpuCycles*( process : Process; VAR cpuCycles: CpuCyclesArray; all: BOOLEAN );
  481. VAR
  482. i,res: LONGINT;
  483. time: Unix.tvPtr;
  484. BEGIN
  485. ASSERT( process # NIL );
  486. NEW(time);
  487. res:=Unix.clock_gettime(3,time); (*constant 3 for clock_thread_cputime_id*)
  488. FOR i := 0 TO Machine.MaxCPU-1 DO
  489. cpuCycles[i] := 0
  490. END;
  491. cpuCycles[0]:=time.usec;
  492. END GetCpuCycles;
  493. (*-----------------------------------------------------------------------*)
  494. PROCEDURE min( a, b: LONGINT ): LONGINT;
  495. BEGIN
  496. IF a <= b THEN RETURN a ELSE RETURN b END
  497. END min;
  498. PROCEDURE max( a, b: LONGINT ): LONGINT;
  499. BEGIN
  500. IF a >= b THEN RETURN a ELSE RETURN b END
  501. END max;
  502. PROCEDURE RegisterFinalizer( obj: ANY; fin: Heaps.Finalizer );
  503. VAR n: Heaps.FinalizerNode;
  504. BEGIN
  505. NEW( n ); n.finalizer := fin; Heaps.AddFinalizer( obj, n );
  506. END RegisterFinalizer;
  507. PROCEDURE FinalizeActiveObj( obj: ANY );
  508. VAR p: Process;
  509. BEGIN
  510. Unix.MtxLock( processList );
  511. p := root;
  512. WHILE (p # NIL) & (p.obj # obj) DO p := p.nextProcess END;
  513. Unix.MtxUnlock( processList );
  514. IF (p # NIL) & (p.obj = obj) THEN
  515. p.mode := Terminated;
  516. Unix.ConDestroy( p.continue ); p.continue := 0;
  517. FinalizeProtObject( obj );
  518. p.Cancel
  519. END;
  520. END FinalizeActiveObj;
  521. PROCEDURE FinalizeProtObject( obj: ANY );
  522. VAR hdr: ObjectHeader; lock: LockT;
  523. BEGIN
  524. S.GET( S.VAL( ADDRESS, obj ) + Heaps.HeapBlockOffset, hdr );
  525. IF hdr.lock # NIL THEN
  526. lock := S.VAL(LockT, hdr.lock);
  527. Unix.MtxDestroy( lock.mtx ); lock.mtx := 0
  528. END
  529. END FinalizeProtObject;
  530. PROCEDURE FinalizeProcess( obj: ANY );
  531. VAR p: Process;
  532. BEGIN
  533. p := obj(Process);
  534. IF p.continue # 0 THEN
  535. Unix.ConDestroy( p.continue ); p.continue := 0
  536. END
  537. END FinalizeProcess;
  538. (* Terminate calling thread. *)
  539. PROCEDURE Exit;
  540. VAR prev, p, me: Process;
  541. BEGIN
  542. me := CurrentProcess();
  543. me.mode := Terminated;
  544. Unix.MtxLock( processList );
  545. prev := NIL; p := root;
  546. WHILE (p # NIL ) & (p # me) DO prev := p; p := p.nextProcess END;
  547. IF p = me THEN
  548. IF prev = NIL THEN root := p.nextProcess ELSE prev.nextProcess := p.nextProcess END;
  549. END;
  550. Unix.MtxUnlock( processList );
  551. Unix.ThrExit(0);
  552. END Exit;
  553. PROCEDURE ExitTrap*;
  554. VAR p: Process;
  555. BEGIN
  556. p := CurrentProcess();
  557. (* restart the object body if it was given the SAFE flag *)
  558. IF Restart IN p.flags THEN
  559. Unix.siglongjmp( ADDRESSOF( p.state0[0] ), 1 )
  560. END;
  561. Exit
  562. END ExitTrap;
  563. (*---------------------------- Timer --------------------------------*)
  564. PROCEDURE Remove( t: Timer ); (* remove timer from list of active timers *)
  565. VAR p, x: Timer;
  566. BEGIN
  567. Unix.MtxLock( timerListMutex );
  568. t.trigger := 0; t.handler := NIL;
  569. IF timers # NIL THEN
  570. IF t = timers THEN
  571. timers := t.next
  572. ELSE
  573. p := timers; x := p.next;
  574. WHILE (x # NIL) & (x # t) DO p := x; x := p.next END;
  575. IF x = t THEN p.next := t.next END
  576. END;
  577. t.next := NIL
  578. END;
  579. Unix.MtxUnlock( timerListMutex )
  580. END Remove;
  581. PROCEDURE Insert( t: Timer );
  582. VAR p, x: Timer;
  583. BEGIN
  584. Unix.MtxLock( timerListMutex );
  585. p := NIL; x := timers;
  586. WHILE (x # NIL) & (x.trigger < t.trigger) DO p := x; x := p.next END;
  587. t.next := x;
  588. IF p = NIL THEN timers := t ELSE p.next := t END;
  589. Unix.MtxUnlock( timerListMutex )
  590. END Insert;
  591. PROCEDURE SetTimeout*( t: Timer; h: EventHandler; ms: LONGINT );
  592. BEGIN
  593. ASSERT( ( t # NIL) & ( h # NIL) );
  594. Remove( t );
  595. IF ms < 1 THEN ms := 1 END;
  596. t.trigger := Machine.ticks + ms; t.handler := h;
  597. Insert( t );
  598. timerActivity.Restart
  599. END SetTimeout;
  600. PROCEDURE SetTimeoutAt*( t: Timer; h: EventHandler; ms: LONGINT );
  601. BEGIN
  602. ASSERT( (t # NIL) & (h # NIL) );
  603. Remove( t );
  604. t.trigger := ms; t.handler := h;
  605. Insert( t );
  606. timerActivity.Restart
  607. END SetTimeoutAt;
  608. PROCEDURE CancelTimeout*( t: Timer );
  609. BEGIN
  610. Remove( t )
  611. END CancelTimeout;
  612. (*-------------------- Garbage Collection ------------------------------------*)
  613. PROCEDURE GetContext(ctxt: Unix.Ucontext);
  614. VAR t: Process; bp: ADDRESS;
  615. BEGIN
  616. t := CurrentProcess();
  617. (*
  618. TRACE(t, t.threadId);
  619. TRACE(Machine.CurrentBP(), ctxt.mc.r_bp);
  620. *)
  621. Unix.CopyContext(ctxt.mc, t.context);
  622. (*
  623. bp := Machine.CurrentBP();
  624. TRACE(bp);
  625. S.GET(bp+4, bp);
  626. TRACE(bp);
  627. t.context.r_bp := bp;
  628. *)
  629. END GetContext;
  630. PROCEDURE SuspendActivities;
  631. VAR t,me: Process; res: LONGINT;
  632. BEGIN
  633. me := CurrentProcess();
  634. t := root;
  635. WHILE t # NIL DO
  636. IF (t # me) THEN
  637. Unix.ThrSuspend(t.threadId );
  638. END;
  639. t := t.nextProcess
  640. END;
  641. (*
  642. VAR t, me: Process;
  643. BEGIN
  644. t := root;
  645. WHILE t # NIL DO
  646. IF (t # mainProcess) & (t # finCaller) THEN Unix.ThrSuspend( t.threadId ) END;
  647. t := t.nextProcess
  648. END;
  649. *)
  650. END SuspendActivities;
  651. PROCEDURE ResumeActivities;
  652. VAR t, me: Process;
  653. BEGIN
  654. me := CurrentProcess();
  655. t := root;
  656. WHILE t # NIL DO
  657. IF (t # me) (* (t # mainProcess) & (t # finCaller)*) THEN Unix.ThrResume( t.threadId ) END;
  658. t := t.nextProcess
  659. END;
  660. END ResumeActivities;
  661. (*
  662. PROCEDURE InvokeGC;
  663. BEGIN
  664. IF Machine.AcquireGC() THEN (* gets released by FinalizerCaller *)
  665. collect := TRUE;
  666. Unix.ConWait( gcFinished, igc )
  667. END;
  668. END InvokeGC;
  669. *)
  670. (*! GCLoop gets called as last procedure in BootConsole (main thread).
  671. The stack of the main thread is not limited by the boot parameter 'StackSize' !!
  672. *)
  673. PROCEDURE GCLoop*; (* Timer and GC activity *)
  674. VAR cur: Process;
  675. BEGIN
  676. RETURN;
  677. (*
  678. cur:= CurrentProcess();
  679. SetPriority( GCPriority );
  680. LOOP
  681. IF collect THEN
  682. TRACE(collect);
  683. collect := FALSE;
  684. Machine.Acquire( Machine.Heaps );
  685. cur.context.r_sp := Machine.CurrentSP();
  686. cur.context.r_bp := Machine.CurrentBP();
  687. cur.context.r_sp := ADDRESS OF GCLoop;
  688. SuspendActivities;
  689. Heaps.CollectGarbage( Modules.root );
  690. Machine.Release( Machine.Heaps );
  691. ResumeActivities;
  692. finalizerCaller.Activate;
  693. (*Unix.ConSignal( gcFinished );*)
  694. ELSE
  695. Unix.ThrSleep( 10 );
  696. END;
  697. timerActivity.UpdateTicks
  698. END
  699. *)
  700. END GCLoop;
  701. PROCEDURE CurrentProcessTime*(): HUGEINT;
  702. BEGIN
  703. RETURN Machine.GetTimer()
  704. END CurrentProcessTime;
  705. PROCEDURE TimerFrequency*(): HUGEINT;
  706. BEGIN
  707. RETURN Machine.mhz * 1000000
  708. END TimerFrequency;
  709. (*----------------------------- initialization ----------------------------------*)
  710. PROCEDURE StartTimerActivity;
  711. BEGIN
  712. timerListMutex := Unix.MtxInit(0); timers := NIL;
  713. NEW( timerActivity );
  714. END StartTimerActivity;
  715. PROCEDURE GetStacksize;
  716. VAR str: ARRAY 32 OF CHAR; i: LONGINT;
  717. BEGIN
  718. Machine.GetConfig( "StackSize", str );
  719. IF str = "" THEN stacksize := DefaultStacksize
  720. ELSE
  721. i := 0; stacksize := Machine.StrToInt( i, str );
  722. stacksize := stacksize * 1024;
  723. END;
  724. IF Glue.debug # {} THEN
  725. Trace.String( "Stacksize of active objects = " );
  726. Trace.Int( stacksize DIV 1024, 0 ); Trace.StringLn( "K" )
  727. END;
  728. END GetStacksize;
  729. PROCEDURE Convert;
  730. VAR p: Process;
  731. BEGIN
  732. (* make current thread the first active object *)
  733. NEW( p, NIL, NIL, 0, {}, 0 );
  734. END Convert;
  735. PROCEDURE Init;
  736. BEGIN
  737. Unix.suspendHandler := GetContext;
  738. (*
  739. Unix.Dlsym( 0, "Unix.MtxInit", ADDRESSOF( Unix.MtxInit ) );
  740. Unix.Dlsym( 0, "Unix.MtxDestroy", ADDRESSOF( Unix.MtxDestroy ) );
  741. Unix.Dlsym( 0, "Unix.MtxLock", ADDRESSOF( Unix.MtxLock ) );
  742. Unix.Dlsym( 0, "Unix.MtxUnlock", ADDRESSOF( Unix.MtxUnlock ) );
  743. Unix.Dlsym( 0, "Unix.ConInit", ADDRESSOF( Unix.ConInit ) );
  744. Unix.Dlsym( 0, "Unix.ConDestroy", ADDRESSOF( Unix.ConDestroy ) );
  745. Unix.Dlsym( 0, "Unix.ConWait", ADDRESSOF( Unix.ConWait ) );
  746. Unix.Dlsym( 0, "Unix.ConSignal", ADDRESSOF( Unix.ConSignal ) );
  747. Unix.Dlsym( 0, "thrStart", ADDRESSOF( thrStart ) );
  748. Unix.Dlsym( 0, "Unix.ThrThis", ADDRESSOF( Unix.ThrThis ) );
  749. Unix.Dlsym( 0, "Unix.ThrSleep", ADDRESSOF( Unix.ThrSleep ) );
  750. Unix.Dlsym( 0, "Unix.ThrYield", ADDRESSOF( Unix.ThrYield ) );
  751. Unix.Dlsym( 0, "Unix.ThrExit", ADDRESSOF( Unix.ThrExit ) );
  752. Unix.Dlsym( 0, "Unix.ThrSuspend", ADDRESSOF( Unix.ThrSuspend ) );
  753. Unix.Dlsym( 0, "Unix.ThrResume", ADDRESSOF( Unix.ThrResume ) );
  754. Unix.Dlsym( 0, "Unix.ThrGetPriority", ADDRESSOF( Unix.ThrGetPriority ) );
  755. Unix.Dlsym( 0, "Unix.ThrSetPriority", ADDRESSOF( Unix.ThrSetPriority ) );
  756. Unix.Dlsym( 0, "thrKill", ADDRESSOF( thrKill ) );
  757. *)
  758. createProcess := Unix.MtxInit( 0 ); processList := Unix.MtxInit( 0 );
  759. startProcess := Unix.MtxInit(0); childrunning := Unix.ConInit(0);
  760. lockMutex := Unix.MtxInit(0);
  761. collect := FALSE;
  762. igc := Unix.MtxInit( 0 ); gcFinished := Unix.ConInit( 0 );
  763. GetStacksize;
  764. Convert;
  765. NEW(clock);
  766. StartTimerActivity;
  767. NEW( finalizerCaller );
  768. Heaps.gcStatus := GCStatusFactory()
  769. END Init;
  770. TYPE
  771. MainThread = OBJECT
  772. VAR exit: BOOLEAN;
  773. PROCEDURE& Init;
  774. BEGIN
  775. exit := FALSE;
  776. END Init;
  777. PROCEDURE Await();
  778. BEGIN{EXCLUSIVE}
  779. AWAIT(exit);
  780. END Await;
  781. END MainThread;
  782. VAR main: MainThread;
  783. PROCEDURE MainThreadSleep;
  784. BEGIN
  785. NEW(main);
  786. main.Await();
  787. Unix.exit(0);
  788. END MainThreadSleep;
  789. PROCEDURE {FINAL} Final;
  790. BEGIN
  791. MainThreadSleep;
  792. END Final;
  793. PROCEDURE GCStatusFactory(): Heaps.GCStatus;
  794. VAR gcStatusExt : GCStatusExt;
  795. BEGIN
  796. ASSERT(Heaps.gcStatus = NIL);
  797. NEW(gcStatusExt);
  798. RETURN gcStatusExt
  799. END GCStatusFactory;
  800. BEGIN
  801. Init;
  802. END Objects.