Realtime Systems Fundamnetals

1. Realtime Systems Fundamnetals B. Ramamurthy

2. Topics for Discussion • Project 1 Review • Kernel and device drivers • Realtime kernel fundamentals (chapter 3)

3. Project 1: Load Embedded XINU into WRT54GL wireless router • We create a little computer out of WR54GL by loading embedded XINU in to its RAM. • Read project 1 handout • Assemble the components needed to add a UART chip to the WRT54GL that will enable you to access WRT54GL storage and devices. • Obtain a cross-compiler to compile embedded XINU kernel into MIPS code for the CPU on WRT54GL. • We have downloaded a Linux-based cross-compiler that will compile the embedded XINU files and generate xinu.boot or variations of this. • Download embedded xinu tar ball and untar it and compile it (gmake) to obtain it to generate the xinu.boot • Lets study the various components of the embedded XINU distribution.

4. Once you have downloaded and extracted the xinu tarball, you will see a basic directory structure: AUTHORS include/ LICENSE README system/ tty/ compile/ lib/ loader/ shell/ test/ uart/ AUTHORS is a brief history of contributors to the XINU operating system in it's varying iterations. compile/ contains the Makefile and other necessities for building the XINU system once you have a cross-compiler. include/ contains all the header files used by XINU. lib/ contains a folder (libxc/) with a Makefile and source for the library, as well as a binary blob which contains the pre-compiled library. LICENSE is the license under which this project falls. loader/ contains assembly files and is where the bootloader will begin execution of O/S code. README is this document. shell/ contains the source for all shell related functions. system/ contains the source for all system functions such as the nulluser process (initialize.c) as well as code to set up a C environment (startup.S). test/ contains a number of testcases (which can be run using the shell command testsuite). tty/ contains the source for the tty driver. uart/ contains the source for the uart driver.

5. Next steps • Connect the serial port of the modified hardware to the serial port of a host computer with xinu.boot code. • Use a serial communication program (we used Hyperterminal) to configure the serial port of the host to the settings: 8 data bits, no parity bit, and 1 stop bit (8N1) with a speed of 115,200 bps. • Use another router to form a local network and assign IP addresses to the router and the host computer. • Power up the WRT54GL. If you send cntrlC (break) characters from host console, you will see it responding with CFE> (common firmware environment for WRT54GL) • The Broadcom Common Firmware Environment (CFE) is a collection of software modules for initialization and bootstrap of designs incorporating Broadcom MIPS64™ processors. Link • Serial port you created is your means to communicate with WRT54GL CFE • Use a TFTP on the host to make the boot images available on the network for XINU to boot. (How?) • ifconfig eth0 –auto (obtain ip address for eth0 of WRT54GL) • boot -elf [host ip]:xinu.boot (initiate a TFTP boot) • Above two commands are given from CFE command line • Once XINU boots (uploads into the RAM), you will see XINU shell. • Now you can run XINU commands: help, ps etc. • Add a simple C program hello.c to print “hello world”. • End of first project.

6. Kernel & Device drivers Servers (application ~, web ~, component ~) Shell XWin Thread lib ftp User applications System call interface Process, memory, file system, network managers. Kernel Device drivers Hardware/controller Devices

7. Real-time Kernels • A process is an abstraction of a running program and a logical unit of work scheduled by the operating system. • A thread is a light weight process that represents of a flow of control thorough a process. • Real-time operating system must provide these specific functions for processes: • Scheduling • Dispatching • Intercommunication and synchronization • Kernel of an operating system provides these functions.

8. Simple kernels • Polled loop: Say a kernel needs to process packets that are transferred into the DMA and a flag is set after transfer: for(;;) { if (packet_here) { process_data(); packet_here=0; } } Excellent for handling high-speed data channels, a processor is dedicated to handling the data channel. Disadvantage: cannot handle bursts

9. Simple kernels: cyclic executives • Illusion of simultaneity by taking advantage of relatively short processes in a continuous loop: for(;;) { process_1(); process_2(); process_3(); … process_n(); } Different rate structures can be achieved by repeating tasks in the list: for(;;) { process_1(); process_2(); process_3(); process_3(); }

10. Cyclic Executives: example: Interactive games • Space invaders: for(;;) { check_for_keypressed(); move_aliens(); check_for_keypressed(); check_collision(); check_for_keypressed(); update_screen(); } } check_keypressed() checks for three button pressings: move tank left or right and fire missiles. If the schedule is carefully constructed we could achieve a very efficient game program with a simple kernel as shown above.

11. void process_a(void){ for(;;) { switch (state_a) { case 1: phase_a1(); | case 2: phase_a2(); | …. case n: phase_an();}}} void process_b(void){ for(;;) { switch (state_b) { case 1: phase_b1(); | case 2: phase_b2(); | …. case n: phase_bn();}}} state_a and state_b are state counters; Communication between coroutines thru’ global variables; Example: the fanous CICS from IBM : Customer Information Control System IBM’s OS/2 uses this in Windows presentation management. Finite state automata and Co-routine based kernels

12. Interrupt driven systems • Main program is a simple loop. • Various tasks in the system are schedules via software or hardware interrupts; • Dispatching performed by interrupt handling routines. • Hardware and software interrupts. • Hardware: asynchronous • Software: typically synchronous • Executing process is suspended, state and context saved and control is transferred to ISR (interrupt service routine)

13. void main() { init(); while(TRUE); } void int1(void){ save (context); taks1(); retore (context);} void int1(void){ save (context); taks1(); restore (context);} Foreground/background systems is a variation of this where main does some useful task in the background; Interrupt driven systems: code example

14. Process scheduling • Scheduling is a very important function in a real-time operating system. • Two types: pre-run-time and run-time • Pre-run-time scheduling: create a feasible schedule offline to meet time constraints, guarantee execution order of processes, and prevents simultaneous accesses to shared resources. • Run-time scheduling: allows events to interrupt processes, on demand allocation of resources , and used complex run-time mechanisms to meet time constraints.

15. Task characteristics of real workload • Each task Ti is characterized by the following temporal parameters: • Precedence constraints: specify any tasks need to precede other tasks. • Release or arrival time: ri,j: jth instance of ith task • Phase Φi: release time of first instant of ith task • Response time: time between activation and completion • Absolute deadline: instant by which task must complete • Relative deadline: maximum allowable response time • Period Pi: maximum length of intervals between the release times of consecutive tasks. • Execution time: the maximum amount of time required to complete a instance of the task assuming all the resources are available. • Lets look at some examples.