Embedded computing system RTOS BASED DESIGN-2

Transcription

1 UNIT:6 RTOS BASED DESIGN-2 6.1: INTERPROCESS COMMUNICATION MECHANISMS Interprocess communication mechanisms are provided by the operating system as part of the process Abstraction. In general, a process can send a communication in one of two ways: blocking or nonblocking. Blocking: After sending a blocking communication, the process goes into the waiting state until it receives a response. Nonblocking communication: allows the process to continue execution after sending the communication. Both types of communication are useful. There are two major styles of interprocess communication: shared memory message passing. The two are logically equivalent given one, you can build an interface that implements the other Shared Memory Communication Figure 1 illustrates how shared memory communication works in a bus-based system. Two components, such as a CPU and an I/O device, communicate through a shared memory location. FIGURE 1: Shared memory communication implemented on a bus. CSE,JIT Page 1

2 The software on the CPU has been designed to know the address of the shared location, the shared location has also been loaded into the proper register of the I/O device. If, as in the figure, the CPU wants to send data to the device, it writes to the shared location. The I/O device then reads the data from that location. The read and write operations are standard and can be encapsulated in a procedural interface. As an application of shared memory,let us consider the situation of Figure 1 in which the CPU and the I/O device want to communicate through a shared memory block. There must be a flag that tells the CPU when the data from the I/O device is ready. The flag, an additional shared data location, has a value of 0 when the data are not ready and 1 when the data are ready. The CPU, for example, would write the data, and then set the flag location to 1. If the flag is used only by the CPU, then the flag can be implemented using a standard memory write operation. If the same flag is used for bidirectional signaling between the CPU and the I/O device, care must be taken. Consider the following scenario: 1. CPU reads the flag location and sees that it is I/O device reads the flag location and sees that it is CPU sets the flag location to 1 and writes data to the shared location. 4. I/O device erroneously sets the flag to 1 and overwrites the data left by the CPU. The above scenario is caused by a critical timing race between the two programs. To avoid such problems, the microprocessor bus must support an atomic test-and set operation, which is available on a number of microprocessors. The test-and-set operation first reads a location and then sets it to a specified value. It returns the result of the test. If the location was already set, then the additional set has no effect but the test-and-set instruction returns a false result. If the location was not set, the instruction returns true and the location is in fact set. A test-and-set can be used to implement a semaphore, which is a language-level synchronization construct. CSE,JIT Page 2

3 Test-and-set operation The SWP (swap) instruction is used in the ARM to implement atomic test-and-set: SWP Rd,Rm,Rn The SWP instruction takes three operands the memory location pointed to by Rn is loaded and saved into Rd, and the value of Rm is then written into the location pointed to by Rn. When Rd and Rn are the same register, the instruction swaps the register s value and the value stored at the address pointed to by Rd/Rn. For example, consider this code sequence: ADR r0, SEMAPHORE LDR r1, #1 GETFLAG SWP r1,r1,[r0] BNZ GETFLAG HASFLAG... ; get semaphore address ; test-and-set the flag ; no flag yet, try again The program first loads the constant 1 into r1 and the address of the semaphore FLAG1 into register r 2, then reads the semaphore into r0 and writes the 1 value into the semaphore. Thecode then tests whether the semaphore fetched from memory is zero; if it was, the semaphorewas not busy and we can enter the critical region that begins with the HASFLAG label. If theflag was nonzero, we loop back to try to get the flag once again. Example for shared communication: Elastic buffers as shared memory The text compressor of Application provides a good example of a shared memory. As shown below, the text compressor uses the CPU to compress incoming text, which is then sent on a serial line by a UART. CSE,JIT Page 3

4 The input data arrive at a constant rate and are easy to manage. But because the output data are consumed at a variable rate, these data require an elastic buffer. The CPU and output UART share a memory area the CPU writes compressed characters into the buffer and the UART removes them as necessary to fill the serial line. Because the number of bits in the buffer changes constantly, the compression and transmission processes need additional size information. In this case, coordination is simple the CPU writes at one end of the buffer and the UART reads at the other end. The only challenge is to make sure that the UART does not overrun the buffer Message Passing Message passing communication complements the shared memory model. As shown in Figure 6.2, each communicating entity has its own message send/receive unit. Fig 2: Message Passing The message is not stored on the communications link, but rather at the senders/ receivers at the end points. In contrast,shared memory communication can be seen as a memory block used as a communication device,in which all the data are stored in the communication link/memory. Applications in which units operate relatively autonomously are natural candidates for message passing communication. For example, a home control system has one microcontroller per household device lamp, thermostat, faucet, appliance, and so on. The devices must communicate relatively infrequently; furthermore, their physical separation is large enough that we would not naturally think of them as sharing a central pool of memory. Passing communication packets among the devices is a natural way to describe coordination between these devices. Message passing is the natural implementation of communication in many 8-bit microcontrollers that do not normally operate with external memory. CSE,JIT Page 4

5 6.1.3: Signals Another formof interprocess communication commonly used in Unix is the signal. A signal is simple because it does not pass data beyond the existence of the signal itself. A signal is analogous to an interrupt, but it is entirely a software creation. A signal is generated by a process and transmitted to another process by the operating system. A UML signal is actually a generalization of the Unix signal. While a Unix signal carries no parameters other than a condition code,a UML signal is an object. As such, it can carry parameters as object attributes. Figure 6.3 shows the use of a signal in UML. The sigbehavior( ) behavior of the class is responsible for throwing the signal,as indicated by<<send>>.the signal object is indicated by the<<signal>> stereotype. Fig 6.3: Use of a UML signal. CSE,JIT Page 5

6 6.2 EVALUATING OPERATING SYSTEM PERFORMANCE The scheduling policy does not tell us all that we would like to know about the performance of a real system running processes. Our analysis of scheduling policies makes some simplifying assumptions: We have assumed that context switches require zero time. Although it is often reasonable to neglect context switch time when it is much smaller than the process execution time, context switching can add significant delay in some cases. We have assumed that we know the execution time of the processes. We probably determined worst-case or best-case times for the processes in isolation. But,in fact,they interact with each other in the cache. Cache conflicts among processes can drastically degrade process execution time. The zero-time context switch assumption used in the analysis of RMS is not correct we must execute instructions to save and restore context, and we must execute additional instructions to implement the scheduling policy. On the other hand, context switching can be implemented efficiently context switching need not kill performance. The effects of nonzero context switching time must be carefully analyzed in the context of a particular implementation to be sure that the predictions of an ideal scheduling policy are sufficiently accurate : Scheduling and context switching overhead Appearing below is a set of processes and their characteristics. First, let us try to find a schedule assuming that context switching time is zero. Following is a feasible schedule for a sequence of data arrivals that meets all the deadlines: CSE,JIT Page 6

7 Now let us assume that the total time to initiate a process, including context switching and scheduling policy evaluation is one time unit. It is easy to see that there is no feasible schedule for the above release time sequence, since we require a total of 2TP1 +TP2 = 2 x(1 + 3) + (1+3)= 11 time units to execute one period of P2 and two periods of P1. In above Example, overhead was a large fraction of the process execution time and of the periods. In most real-time operating systems, a context switch requires only a few hundred instructions, with only slightly more overhead for a simple real-time scheduler like RMS. When the overhead time is very small relative to the task periods, then the zero-time context switch assumption is often a reasonable approximation. Another important assumption we have made thus far is that process execution time is constant Effects of scheduling on the cache Consider a system containing the following three processes: Each process uses half the cache, so only two processes can be in the cache at the same time. CSE,JIT Page 7

8 Appearing below is a first schedule that uses a least-recently-used cache replacement policy on a process-by-process basis. In the first iteration, we must fill up the cache, but even in subsequent iterations, competition among all three processes ensures that a process is never in the cache when it starts to execute. As a result, we must always use the worst-case execution time. Another schedule in which we have reserved half the cache for P1 is shown below. This leaves P2 and P3 to fight over the other half of the cache. In this case, P2 and P3 still compete, but P1 is always ready. After the first iteration, we can use the average-case execution time for P1, which gives us some spare CPU time that could be used for additional operations. CSE,JIT Page 8

9 6.3 POWER MANAGEMENT AND OPTIMIZATION FOR PROCESSES The RTOS and system architecture can use static and dynamic power management mechanisms to help manage the system s power consumption. A power management policy is a strategy for determining when to perform certain power management operations. A power management policy in general examines the state of the system to determine when to take actions. However, the overall strategy embodied in the policy should be designed based on the characteristics of the static and dynamic power management mechanisms. Going into a low-power mode takes time; generally, the more that is shut off, the longer the delay incurred during restart. Because power-down and power-up are not free, modes should be changed carefully. Determining when to switch into and out of a power-up mode requires an analysis of the overall system activity. Avoiding a power-down mode can cost unnecessary power. Powering down too soon can cause severe performance penalties. Re-entering run mode typically costs a considerable amount of time. A straightforward method is to power up the system when a request is received. This works as long as the delay in handling the request is acceptable. A more sophisticated technique is predictive shutdown. The goal is to predict when the next request will be made and to start the system just before that time, saving the requestor the start-up time. In general, predictive shutdown techniques are probabilistic they make guesses about activity patterns based on a probabilistic model of expected behavior. Because they rely on statistics, they may not always correctly guess the time of the next activity. This can cause two types of problems: The requestor may have to wait for an activity period The system may restart itself when no activity is imminent. As a result, the system will waste power. CSE,JIT Page 9

10 Clearly, the choice of a good probabilistic model of service requests is important. The policy mechanism should also not be too complex, since the power it consumes to make decisions is part of the total system power budget. Several predictive techniques are possible. A very simple technique is to use fixed times. For instance, if the system does not receive inputs during an interval of length Ton, it shuts down; a powered-down system waits for a period Toff before returning to the power-on mode. The L-shaped distribution as illustrated in Figure 6.4. Fig 6.4: L-shaped distribution In this distribution, the idle period after a long active period is usually very short, and the length of the idle period after a short active period is uniformly distributed. Advanced Configuration and Power Interface (ACPI): It is an open industry standard for power management services. It is designed to be compatible with a wide variety of OSs. It was targeted initially to PCs.The role of ACPI in the system is illustrated in Figure 6.5. ACPI provides some basic power management facilities and abstracts the hardware layer, the OS has its own power management module that determines the policy,and the OS then usesacpi to send the required controls to the hardware and to observe the hardware s state as input to the power manager CSE,JIT Page 10

11 Fig 6.5: The advanced configuration and power interface and its relationship to a complete system. ACPI provides some basic power management facilities and abstracts the hardware layer, the OS has its own power management module that determines the policy,and the OS then usesacpi to send the required controls to the hardware and to observe the hardware s state as input to the power manager. ACPI supports the following five basic global power states: 1. G3, the mechanical off state, in which the system consumes no power. 2. G2, the soft off state, which requires a full OS reboot to restore the machine to working condition. This state has four substates: S1, a low wake-up latency state with no loss of system context; S2, a low wake-up latency state with a loss of CPU and system cache state; S3, a low wake-up latency state in which all system state except for main memory is lost; and S4, the lowest-power sleeping state, in which all devices are turned off. 3. G1, the sleeping state, in which the system appears to be off and the time required to return to working condition is inversely proportional to power consumption. 4. G0, the working state, in which the system is fully usable. 5. The legacy state, in which the system does not comply with ACPI. CSE,JIT Page 11

12 6.4 CHOICE OF RTOS The decision of choosing RTOS for embedded system is crucial. A lot of factors needs to be analyzed carefully before making a decision on the selection of RTOS. These factors can be either functional or non functional. The functional or non functional requirements that needs to be analysed in the selection of RTOS for an embedded system design are as follows: Functional requirements 1. Processor support: it is necessary that all RTOSs support all kinds of processor architecture. It is essential to ensure that support by RTOS. 2. Memory requirement: The OS requires ROM memory for holding OS filesand it is normally stored in a non volatile memorylike FLASH. OS also requires working memory RAM for loading the OS services. 3. Real time capabilities: It is not mandatory that OS for all embedded system need to be real time and all embedded OS are real time in behavior. The Task/process scheduling policies plays important role in real time behavior of an OS, Analyse the real time capabilities of OS under consideration and standards met by OS for real time capabilities. 4. Kernel and Interrupt Latency: The kernel of OS may disable interrupts while executing certain services and it may lead to interrupt latency. For an embedded system whose response requirements are high this latency should be minimal. 5. Interprocess communication and Task synchronization: The implementation of interprocess communication and synchronization is OS kernel dependent. Certain Kernels may provide a bunch of options where as other provides limited options. Certain Kernels implement policies for avoiding priority inversion issues in resource sharing. CSE,JIT Page 12

13 6. Modularization Support: It is very useful, if the OS supports modularization in which the developer can choose essential modules recompile the OS for functioning. Example for highly modular operating system is windows CE. 7. Support for networking and communication:- The OS kernel may provide stack implementation and drive support for a bunch of communication interface and networking. Ensure that the OS under consideration provides support for all the interface required by the embedded product. 8. Development language support:- Certain OS include the runtime libraries required for running application written in languages like Java and c#. A Java virtual machine [JVM] customized for OS is essential for running java applications. Similarly.net compact framework [.NETCF] is required for running Microsoft or.net application on top of OS. the OS may include these component as built-in component, if not, check the availability of the same from a third party vendor for OS under consideration. Non Functional Requirements: 1. Custom Developed or Off the shelf: Depending on OS requirements it is possible to development of OS,suiting the embedded system needs or use an off the shelf, readily available OS, which is either a commercial product or an open source product, which is in close match with system requirements. It may be possible to required features by customizing an open source OS. The decision on which to select is purely dependent on development cost, licensing fees for OS, development time and availability of skilled resource. 2. Cost: The total cost for developing or buying OS and maintaining it in terms of commercial products and custom build needs to be evaluated before taking a decision on selection of OS. CSE,JIT Page 13

14 3. Developing and Debugginh tools availibilty: The availability od development and debugging tool is a crucial decision making factor in the selection of an OS for embedded design Certain OS may be superior in performance but, the availability of tools for supporting the development may be be limited. 4. Ease of Use: How easy it is to use a commercial RTOS is another important feature that needs to be considered in the RTOS selection CSE,JIT Page 14

15 TELEPHONE ANSWERING MACHINE The system will store messages in digital form rather than on an analog tape. To make life more interesting, we use a simple algorithm to compress the voice data so that we can make more efficient use of the limited amount of available memory. Theory of Operation and Requirements In addition to studying the compression algorithm, we also need to learn a little about the operation of telephone systems. The compression scheme we will use is known as adaptive differential pulse code modulation (ADPCM). Despite the long name, the technique is relatively simple but can yield 2 compression ratios on voice data. The ADPCM coding scheme is illustrated in Unlike traditional sam- pling, in which each sample shows the magnitude of the signal at a particular time, ADPCM encodes changes in the signal. The samples are expressed in a coding alphabet, whose values are in a relative range that spans both negative and positive values. In this case, the value range is { 3, 2, 1, 1, 2, 3}. Each sample is used to predict the value of the signal at the current instant from the previous value. At each point in time, the sample is chosen such that the error between the predicted value and the actual signal value is minimized. An ADPCM compression system, including an encoder and decoder, is shown in Figure but the terminology starts to make sense after a few uses.) Our interface will send a digital signal to take the phone line off-hook, which will cause analog circuitry to make the nec- essary connection so that voice data can be sent and received during the call. We can now write the requirements for the answering machine. We will assume that the interface is not to the actual phone line but to some circuitry that provides voice samples, off-hook commands, and so on. Such circuitry will let us test our system with a telephone line simulator and then build the analog circuitry necessary to connect to a real phone line. We will use the term outgoing message (OGM) to refer to the message recorded by the owner of the machine and played at the start of every phone call. CSE,JIT Page 15

16 CSE,JIT Page 16

17 The class diagram for the answering machine. In addition to the classes that perform the major functions, we also use classes to describe the incoming and OGMs. As seen below, user interface and the telephone interface. The user and telephone interfaces both appear internally as I/O devices on the CPU bus with the main memory serving as the storage for the messages. CSE,JIT Page 17

18 The software splits into the following seven major pieces: The front panel module handles the buttons and lights. The speaker module handles sending data to the user s speaker. The telephone line module handles off-hook detection and on-hook commands. The telephone input and output modules handle receiving samples from and sending samples to the telephone line. The compression module compresses data and stores it in memory. The decompression module uncompresses data and sends it to the speaker module. We can determine the execution model for these modules based on the rates at which they must work and the ways in which they communicate. The front panel and telephone line modules must regularly test the buttons and phone line, but this can be done at a fairly low rate. As seen below, they can therefore run as polled processes in the software s main loop. CSE,JIT Page 18