Section 13.5 - Other Tasking Issues

1. Some operating systems (such as Microsoft Windows 3.1 and many older Unixes) do not support threads (lightweight processes), but instead only support regular processes (sometimes called heavyweight processes). The difference is that threads can share memory, while processes generally do not. On systems which do not support threads, if any task makes an operating system request (say, to get input), all the Ada tasks are usually halted until the operating system completes the request. This is because most Ada compilers in such environments put all of the Ada tasks into a single operating system process and then simulate the tasking inside the process. The operating system can't distinguish between the different Ada tasks in the single process, so all Ada tasks get stopped. As more operating systems become more capable this is becoming less of a problem, and this is generally not a problem for embedded systems (where Ada has complete control over the system or is running on a real-time operating system).
2. Some operating systems make it difficult or inefficient to automatically share time between tasks. The ability to automatically share time between tasks of equal priority is called ``pre-emptive multitasking'' or ``time slicing''. Operating systems that support pre-emptive multitasking are more convenient for programmers. Because some operating systems don't support it well, an Ada compiler is permitted to keep running one task until that task tries to communicate with another task or waits (using the delay statement). This kind of behavior is called "cooperative multitasking", because tasks of equal priority must cooperate to share the CPU. Most people prefer Ada implementations that have preemptive multitasking. If you have to deal with an Ada compiler that only supports cooperative multitasking, consider inserting "delay 0.0" statements in each task in various places to give other tasks a chance to run. Check your compiler documentation; some compilers permit you to choose between pre-emptive and cooperative behavior. Again, most of today's Ada compilers provide the (more general) pre-emptive multitasking behavior.

There's much more about tasking that Lovelace doesn't cover. For example:

• You can create tasks that exist for as long as the program runs, by declaring the task in a package declaration or body (the same way you can declare a global variable).
• Instead of creating a task type and then a task, you can create a task directly.
• Entries are queued in first-in-first-out order, and can be re-queued if desired.

There is no quiz question for this section.

You may go to the next section.

Go back to the previous section	Go up to the outline of lesson 13

The master copy of this file is at "http://www.adahome.com/Tutorials/Lovelace/s13sf.htm".