Boot Procedure. BP (boot processor) Start BIOS Firmware Load A2 Bootfile Initialize modules Module Machine Module Heaps

Transcription

1 Boot rocedure Start BIOS Firmware Load A2 Bootfile Initialize modules Module Machine Module Heaps Module Objects Setup scheduler and self process Module Kernel Start all processors Module Bootconsole read configuration and execute boot commands B (boot processor) 206

2 rocessor Startup Start processor (Bootprocessor) 1. Setup boot program 2. Enter processor IDs into table 3. Send startup message to via AIC 4. Wait with timeout on started flag by Boot program (For each processor) 1. Set 32-bit runtime environment for all processors 2. Initialize control registers, memory management, interrupt handling, AIC 3. Set started flag Machine.StartM 4. Setup Scheduler 5. Bootprocessor proceeds with boot console Machine.Initrocessors, Machine.InitBootage Machine.arseMConfig Machine.Startrocessor Machine.EnterM Objects.Start 207

3 2.3. ACTIVITY MANAGEMENT 208

4 Life Cycle of Activities Running Awaiting Condition Awaiting Lock NIL Ready Terminated 209

5 Runtime Data Structures running array processor id object header object header object header NIL NIL cond lock cond lock cond lock ready queues array interrupt array NIL NIL NIL idle low medium high GC RT priority NIL NIL NIL NIL 4 5 irq no. 210

6 rocess Descriptors TYE rocess = OBJECT stack: Stack; state: rocessstate; preempted: BOOLEAN; condition: Condition; conditionf: ADDRESS; priority: INTEGER; obj: OBJECT; next: rocess END rocess; rocessqueue = RECORD head, tail: rocess END; VAR ready: ARRAY Numriorities OF rocessqueue; running: ARRAY Numrocessors OF rocess; 211

7 rocess Dispatching ROCEDURE Enter (p: rocess); BEGIN ut(ready[p.priority], p); IF p.priority > maxready THEN maxready := p.priority END END Enter; NIL NIL NIL ROCEDURE Select (VAR new: rocess; priority: integer); BEGIN LOO IF maxready < priority THEN new := nil; EXIT END; Get(ready[maxReady], new); IF(new # NIL) OR (maxready = Minriority) THEN EXIT END; maxready := maxready-1 END END Select; NIL NIL NIL 212

8 rocess Creation ROCEDURE Createrocess (body: ADDRESS; priority: INTEGER; obj: OBJECT); VAR p: rocess; BEGIN NEW(p); NewStack(p, body, obj); p.preempted := false; p.obj := obj; p.next := nil; RegisterFinalizer(p, Finalizerocess); Acquire(Objects); (* module lock *) IF priority # 0 THEN p.priority := priority ELSE (* inherit priority of creator *) p.priority := running[rocessorid()].priority END; Enter(p); Release(Objects) END Createrocess; NIL Awaiting Condition Running Ready Awaiting Lock Terminated 213

9 Stack Management Use virtual adressing Allocate stack in page units Use page fault for detecting stack overflow Deallocate stack via garbage collector (in process finalizer) Createrocess age fault Finalize Allocate first frame Allocate another frame Deallocate all frames 214

10 Memory Layout 4GB 3.75 GB Mappings Stacks 3GB Devices VIRTUAL REAL 32MB Heap age Heap 1MB 640KB 4KB 0KB Devices age Heap Unmapped Heap Devices age Heap age Heap System RAM 215

11 Stack Allocation Stack Stack Stack unmapped unmapped unmapped unmapped unmapped initially after extension 216

12 Context Switch Synchronous Explicit Terminate Yield Implicit Awaiting condition Mutual exclusion Asynchronous reemption riority handling Timeslicing 217

13 Synchronous Context Switch (1) ROCEDURE SwitchTo (VAR running: rocess; new: rocess); Call SwitchTo stack bottom Stack Return procedure activation frame fp sp running new retpc dlink stack top 218

14 Synchronous Context Switch (2) cur F Reduced process state new F running new retpc dlink fp sp (fp, sp) (fp, sp) fp sp running new retpc dlink 219

15 Asynchronous Context Switch cur Full process state new fp (fp, sp) (fp, sp) sp Registers saved by interrupt fp sp 220

16 Stack Layout after Interrupt 72.GS 68.FS 64.DS 60.ES ; or haltcode 56.SS 52.ES ; or haltcode 48.EFLAGS 44.CS 40.EI 36.EB ERR ; pushed by processor or glue code, popped by O EB 32.ES0 INT ; pushed by glue code, popped by O EB 28.EAX 24.ECX 20.EDX 16.EBX 12.ES0 08.EB/ERR ; exchanged by glue code 04.ESI 00.EDI state: State via interrupt/ IRETD via Glue Code via USHAD/ OAD 221

17 First Level Interrupt Glue Code USH 0 (depending on interrupt number) XCHG [ES], EB USH IRQnumber JUM FieldIRQ (or FieldInterrupt, depending on interrupt number) 222

18 First Level Interrupt Code (1) ROCEDURE Interrupt; CODE {SYSTEM.i386} ; called by interrupt handler (= glue code) USHAD ; save all registers (EB = error code) LEA EB, [ES+36] ; procedure link MOV EBX, [ES+32] ; EBX = int number LEA EAX, inthandler MOV EAX, [EAX][EBX*4] ; now call all handlers for this interrupt OAD ; now EB = error code O EB ; now EB = INT O EB ; now EB = caller EB IRETD END Interrupt; inthandler int number first first first object handler next handler object next 223

19 Switch Code (1) ROCEDURE Switch (VAR cur: rocess; new: rocess); BEGIN cur.state.s := SYSTEM.GETREG(S); cur.state.f := SYSTEM.GETREG(F); cur := new; IF ~cur.preempted then (* return from call *) SYSTEM.UTREG(S, cur.state.s); SYSTEM.UTREG(F, cur.state.f) Release(Objects); ELSE (* return from interrupt *) cur.preempted := FALSE; SYSTEM.UTREG(S, cur.state.s); ushstate(cur.state.eflags, cur.state.cs, cur.state.ei, cur.state.eax, cur.state.ecx, cur.state.edx, cur.state.ebx, 0, cur.state.eb, cur.state.esi, cur.state.edi ); Release(Objects); JumpState END END Switch; synchronous synchronous/ asynchronous 224

20 Switch Code (2) ROCEDURE -ushstate(eflags: SET; CS, EI, EAX, ECX, EDX, EBX, ES, EB, ESI, EDI: LONGINT); CODE {SYSTEM.i386} (* to omit call protocol *) END ushstate; ROCEDURE -JumpState; CODE {SYSTEM.i386} OAD IRETD END opstate; 225

21 Example 1: Termination ROCEDURE Terminate; VAR new: rocess; BEGIN Acquire(Objects); Select(new, Minriority); Switch(running[rocessorID()], new) END Terminate; NIL Awaiting Condition Running Ready Awaiting Lock Terminated 226

22 Example 2: Yield ROCEDURE Yield; VAR id: INTEGER; new: rocess; BEGIN Acquire(Objects); id := rocessorid(); Select(new, running[id].priority); IF new # NIL THEN Enter(running[id]); Switch(running[id], new) ELSE Release(Objects) END END Yield; NIL Awaiting Condition Running Ready Awaiting Lock Terminated 227

23 Idle Activity in Objects Idle = OBJECT BEGIN{ ACTIVE, SAFE, RIORITY(rioIdle)} LOO REEAT Machine.SpinHint UNTIL maxready > Minriority; Yield END END Idle; 228

24 Example: Timeslicing ROCEDURE Timeslice (VAR state: rocessorstate); VAR id: integer; new: rocess; BEGIN Acquire(Objects); id := rocessorid(); IF running[id].priority # Idle THEN Select(new, running[id].priority); IF new # NIL THEN running[id].preempted := true; CopyState(state, running[id].state); Enter(running[id]); running[id] := new; IF new.preempted then new.preempted := false; CopyState(new.state, state) ELSE SwitchToState(new, state) END END END; Release(Objects) END Timeslice; return from interrupt of new process simulate return from procedure switch NIL asynchronous Awaiting Condition Running Ready Awaiting Lock synchronous/ asynchronous Terminated 229

25 Context Switching Scenarios from (synchronous suspended) Exchange fp, sp to (synchronous suspended) from (running) Call Switch Interrupt copy state copy state Return from Switch Return from interrupt to (running) from (asynchronous suspended) Exchange fp, sp to (asynchronous suspended) 230

26 Synchronization Object locking Condition management 231

27 Object Descriptors ObjectHeader = RECORD headerlock: BOOLEAN; lockedby: rocess; awaitinglock: rocessqueue; awaitingcondition: rocessqueue; Fields added by system to objects with mutual exclusion Type-specific instance fields END; 232

28 Object Locking ROCEDURE Lock (obj: object); VAR r, new: rocess; BEGIN r := running[rocessorid()]; AcquireObject(obj.hdr.headerLock); IF obj.hdr.lockedby = nil THEN obj.hdr.lockedby := r; ReleaseObject(obj.hdr.headerLock); ELSE Acquire(Objects); ut(obj.hdr.awaitinglock, r); ReleaseObject(obj.hdr.headerLock); Select(new, Minriority); SwitchTo(running[rocessorID()], new) END END Lock; NIL Awaiting Condition Running Ready Awaiting Lock Terminated 233

29 Object Unlocking ROCEDURE Unlock (obj: object); Running VAR c: rocess; BEGIN Awaiting Condition Awaiting Lock c := FindCondition(obj.hdr.awaitingCondition) AcquireObject(obj.hdr.headerLock); NIL Ready Terminated IF c = NIL THEN END; Get(obj.hdr.awaitingLock, c); Atomic Lock Transfer Eggshell-Model! obj.hdr.lockedby := c ReleaseObject(obj.hdr.headerLock); IF c # NIL THEN Acquire(Objects); Enter(c); Release(Objects) END; END Unlock; 234

30 Condition Management Condition Type TYE Condition = ROCEDURE(fp: ADDRESS): BOOLEAN; Condition Boxing ROEDURE $Condition(fp: ADDRESS): BOOLEAN; BEGIN RETURN condition from await statement END $Condition; Await Code IF ~$Condition(F) THEN Await($Condition, F, SELF) END 235

31 AWAIT Code ROCEDURE Await (condition: Condition; fp: address; obj: object); VAR r, t, new: rocess; BEGIN AcquireObject(obj.hdr.headerLock); c := FindCondition(obj.hdr.awaitingCondition); IF c = NIL THEN Get(obj.hdr.awaitingLock, c); END; obj.hdr.lockedby := c Acquire(Objects); IF c # NIL THEN Enter(c) END; r := running[rocessorid()]; r.condition := condition; r.conditionf := fp; ut(obj.hdr.awaitingcondition, r); ReleaseObject(obj.hdr.headerLock); Select(new, Minriority); SwitchTo(running[rocessorID()], new) END Await; NIL Awaiting Condition Running Ready Awaiting Lock Terminated 236

32 Condition Evaluation ROCEDURE FindCondition (VAR q: rocessqueue): rocess; VAR first, c: rocess; BEGIN Get(q, first); IF first.condition(first.conditionf) THEN RETURN f END; ut(q, first); WHILE q.head # first DO Get(q, c); IF c.condition(c.conditionf) THEN RETURN c END; ut(q, c) END; RETURN NIL END FindCondition; 237

33 riority Inversion Inversion caused by an immediately shared resource High 2 t Med 3 t Low 1 t Ressource R (Object) 238

34 riority Inheritance High t Med 3 t Low 1 1 t Ressource R (Object) 239

35 riority Inversion Inversion caused by not immediately shared resource High 3 Medium 1 1 Low 2 Ressource X Ressource Y Ressource Z 240

36 riority Inheritance High Medium 1 1 Low 2 2 Ressource X Ressource Y Ressource Z 241

37 Invariants 1 Waits on R1 Is owned by A process waits on a resource if and only if the resource is onwed by a different process 2 5 R3 3 R2 4 I2. A resource is locked by at most one process I1. A process waits on at most one resource 242

38 ossible Transitions process acquires and receives free resource R1 1 waiting processes can neither acquire nor release resources 2 R1 1 rocess tries to acquire locked resource 2 R1 1 R2 process releases resource R1 1 R2 2 R1 waiting process receives resource 2 R1 1 R2 2 R1 243

39 Waitingriorities List (Re-)Setting the waitingon pointer R 2 1 array of number of waiting processes with indicated priority R 2 2 priority I3. Sum of digits equals overal number of waiting processes 244

40 LockedByriorities List (Re-)Setting the lockedby pointer R1 1 1 R R2 1 2 array of number of resources with indicated priority of highestpriority waiting process R2 1 2 I4. Sum of digits equals overal number of owned resources 245

41 Further Rules / Invariants A process that releases a resource does not simultaneously wait on a resource. I5. For each resource, the number of waiting processes and their priorities are available at all times. invariant held during (re-)setting the waitingon pointer I6. For each process, the highest priority of indirectly waiting processes is known at all times invariant held during (re-) setting the lockedby pointer 246

42 Handling riority Inversion (Setting WaitingOn ) R R R R

43 Handling riority Inversion (Resetting LockedBy ) 2 R R

44 Handling riority Inversion Resetting LockedBy : how to preserve initial priorities? 2 R R 1 1?

45 Handling riority Inversion Resource and rocess Initialization Resource is allocated with virtual idle process rocess is allocated with virtual resource of process initial priority R R