Copyright 2000 by Barry B. Brey The CPU Scheduling Processes

Transcription

1 Copyright 2000 by Barry B. Brey The CPU Scheduling Processes One method used to schedule processes in a small real-time operating system (RTOS) is via a time slice to switch between various processes. The basic time slice can be of any duration and is somewhat dependent on the execution speed of the microprocessor. For example, at a 100 Mhz clock many instructions execute in one or two clocks on a modern microprocessor. Assuming the machine executes one instruction every two clocks, if we were to choose a time slice of 1 ms. the machine can execute about 50,000 instructions per time slice, which should prove to be adequate for most systems. If a lower clock frequency is employed, then a time slice of 10 ms or even 100 ms is selected. Each time slice is activated by a timer interrupt. The interrupt service procedure must look to a queue to see if a task is available to execute, and if it is, it must start execution of the new task. If no new task is present is must continue executing an old task or enter an idle state waiting for a new task to be queued. The queue is circular and may contain any number of tasks for the system up to some finite limit. For example, it might be a small queue in a small system with 10 entries. The size is determined by the intended overall system and could be much larger or smaller. Each scheduling queue entry must contain a pointer to the process (CS:IP), the entire context state of the machine, possibly some form of a time-to-live entry in case of a deadlock, possibly a priority entry, and possibly an entry that can lengthen the slice activation time. In this example we will not use the priority entry or an entry to lengthen the amount of consecutive time slices allowed a program. Our kernel will strictly service processes on a linear basis or on a round robin as they come from the queue. To implement a scheduler for the embedded system we need to implement procedures or macros to start a new application, kill an application when it completes, and to pause an application if it needs time to access I/O. Each of these will access a scheduling queue located in the memory system at address 0500H since this is available. The scheduling queue will use the following data structure to make creating the queue fairly easy and it will have room for 10 entries. This will allow us to start up to 10 processes at a time. PRESENT DB 0 ; 00H = not and FFH = present RAX DW? ;context RBX DW? RCX DW? RDX DW? RSP DW? RBP DW? RSI DW? RDI DW? RFLAG DW? RIP DW? RCS DW? RDS DW? RES DW? RSS DW? DUMMY1 DW? ;for future use and as a pad to make the DUMMY2 DB? ;entry size 32 bytes (20H bytes)

2 The data structure is copied into memory 10 times to complete the queue structure during system initialization so it contains no active process at initialization. We also need a queue pointer initialized to 500H. The queue pointer is stored at location 4FEH in this example. A possible initialization might appear as follows: PUSH DS MOV AX,0 MOV BX,OFFSET PRESENT 100H MOV CX,10 MOV BYTE PTR DS:[SI],0.UNTILCXZ MOV DS:[4FEH],500H ;set queue pointer POP DS The NEW procedure (installed at INT 60H) to add a process to the queue would search through the 10 entries until it finds a zero in the first byte (PRESENT), which indicates that the entry is empty. If it finds an empty entry, it then places the starting address of the process into RCS and RIP and also a 0200H into the RFLAG location. A 200H in RFLAG makes sure that the interrupt is enabled when the process begins so the system does not crash. NEW waits, if 10 processes are already scheduled, until one process ends. Each process is also assigned stack space in 256 bytes sections beginning at offset address 7600H so the lowest process has stack space 7500H 75FFH, the next has stack space 7600H FFH, etc. The assignment of a stack area could be allocated by a memory manager algorithm. INT60H PROC FAR USES DS AX DX SI MOV AX,0 ;BX = offset, DX = segment ;get stuck if full - 32 MOV CX,10 ;find free entry DEC CX.UNTIL BYTE PTR DS:[SI] == 0 SI == 660H.UNTIL BYTE PTR DS:[SI] == 0 CALL SAVE_STATE MOV WORD PTR DS:[SI+17],200H ;flags MOV DS:[SI+19],BX ;IP MOV DS:[SI+21],DX ;CS MOV AX,SS MOV DS:[SI+27],AX ;SS MOV AX,10 SUB CX,AX SHL AX,8 ADD AX,7500H MOV DS:[SI+9],AX ;SP MOV BYTE PTR DS:[SI],0FFH ;activate process IRET INT60H ENDP

3 The PAUSE procedure is merely a call to the time slice procedure (INT 12H), which bails out of the process and returns control to the time slice procedure so it prematurely ends the time slice for the process. This early out allows other processes to continue before returning to the current process. INT 12H The final control procedure (KILL) located at interrupt vector 61H kills an application by removing it from the scheduling queue by placing a 00H into PRESENT of the queue data structure. INT61 PROC FAR USES DS AX DX SI INT61 ENDP MOV AX,0 MOV SI,DS:[4FEH] ;get queue pointer MOV DS:[SI],0 ;kill it JMP INT12A The time slice interrupt service procedure appears next for an 80188EB using a 10 ms time slice: INT12 PROC FAR USES DS AX DX SI ;timer 1 service MOV AX,0 ;address shared memory MOV SI,DS:[4FEH] ;get current queue pointer CALL SAVE_STATE ;save the current state INT12A: ;get next process.if SI == 660H ;make queue circular.endif.while BYTE PTR DS:[SI]!= FF.IF SI == 660H.ENDIF.ENDW MOV DX,0FF38H ;Timer 1 count register MOV AX,0 ;set count to 0000H OUT DX,AX ;for a complete 10 ms slice MOV DX,0FF02H ;clear interrupt MOV AX,8000H OUT DX,AX JMP LOAD_STATE ;get next processor from queue INT12 ENDP

4 The system startup (placed after system initialization) must be one process that is an infinite wait loop as follows: SYSTEM_START: MOV BX,OFFSET WAITLOOP 100H MOV DX,0F800H INT 60H ;Call NEW to start WAITLOOP thread ADD DS:[4FEH],32 ;only for the this first time STI ;enable interrupts for the first time ;other processes would be started here WAITLOOP: ;system idle loop.while 1 INT 12H ;end slice early.endw Finally we still need the SAVE_STATE and LOAD_STATE procedures to load and save the machine context as we switch from one process to another. SAVE_STATE PROC NEAR MOV DS:[SI+3],BX ;save BX MOV DS:[SI+5],CX ;save CX MOV DS:[SI+9],SP ;save SP MOV DS:[SI+11],BP ;save BP MOV DS:[SI+15],DI ;save DI MOV DS:[SI+25],ES ;save ES MOV DS:[SI+27],SS ;save SS MOV BP,SP ;get SP MOV AX,[BP+2] ;get SI MOV DS:[SI+13] ;save SI MOV AX,[BP+4] ;get DX MOV DS:[SI+7] ;save DX MOV AX,[BP+6] ;get AX MOV DS:[SI+1] ;save AX MOV AX,[BP+8] ;get DS MOV DS:[SI+23] ;save DS MOV AX,[BP+10] ;get flags MOV DS:[SI+17] ;save flags MOV AX,[BP+12] ;get CS MOV DS:[SI+21] ;save CS MOV AX,[BP+23] ;get IP MOV DS:[SI+19] ;save IP RET SAVE_STATE ENDP

5 LOAD_STATE PROC NEAR MOV SS,DS:[SI+27] ;get SS MOV SP,DS:[SI+9] ;get SP MOV AX,DS:[SI+19] ;get IP PUSH AX ;IP to stack MOV AX,DS:[SI+21] ;get CS PUSH AX ;CS to stack MOV AX,DS:[SI+21] ;get flags PUSH AX ;flags to stack MOV AX,DS:[SI+23] ;get DS PUSH AX ;PUSH DS MOV AX,DS:[SI+13] ;get SI PUSH AX ;PUSH SI MOV AX,DS:[SI+1] ;get AX MOV BX,DS:[SI+3] ;get BX MOV CX,DS:[SI+5] ;get CX MOV DX,DS:[SI+7] ;get DX MOV BP,DS:[SI+11] ;get BP MOV DI,DS:[SI+15] ;get DI MOV ES,DS:[SI+25] ;get ES POP SI POP DX POP AX POP DS IRET LOAD_STATE ENDP