|<Windows Process & Threads: C Run-Time 6 |Main |Windows Process & Threads Programming 2 >|Site Index |Download |

MODULE T

PROCESSES AND THREADS: Win32/WINDOWS APIs

Part 1: Story And Program Examples

What do we have in this Module?

1. The Basic Story

2. Windows NT process

3. Process Execution

4. Basic of Process Creation

5. Process Switching

6. Context Switching

7. Multithreading

My Training Period: yy hours. Before you begin, read someinstruction here.

And the following Figure shows Windows NT OS architecture in a layered structure.

Figure 2: A layered structure of Windows NT OS

The previous Figure illustrates the overall structure of Windows NT.  Its highly modular structure gives Windows NT the flexibility. NT can execute on variety of hardware platforms and supports applications written for a variety of other OSes too. As virtually all OSes, NT separates application-oriented software from OS software.  The latter runs in what is generally referred to as privileged mode or kernel mode. Kernel-mode software has access to system data and to the hardware.  The remaining software, running in user mode, has limited access to system data.  The kernel-mode software is referred to as theNT executive. Whether it is running on a uniprocessor or multiprocessor, a CISC (Intel) or RISC (Motorola) system, most of NT sees the same view of the underlying hardware.  To achieve this independence, the OS system consists of four layers:

1. HAL: Maps between generic hardware commands and responses and those unique to a specific platform such as Intel Pentium, a Motorola PowerPC or the defunct DEC Alpha processor. The HAL makes each machine’s system bus, DMA controller, interrupt controller, system timers and memory module look the same to the kernel. It also delivers the support needed for symmetric multiprocessing (multi processor).  Through the HAL NT system should be platform independent.

2. Kernel: Consists of the most used and most fundamental components of the OS. The kernel manages scheduling andcontext switching, exception and interrupt handling, and multiprocessor synchronization.

3. Subsystems: Include a variety of modules for specific functions, which make use of the basic services provided by the kernel.

4. System services: Provide an interface to user-mode software.

From the Figure also we can see that the I/O Manager subsystem bypasses the HAL to interact directly with the hardware. This is necessary to achieve the efficiency and throughput required for I/O operation.  The protected subsystems are those parts of NT that interact with the end user. A protected subsystem provides a graphical or command-line user interface that defines the look and feel of the OS for a user. Additionally, each protected subsystem provides the application programming interface (API) for that particular operating environment. This means that applications created for a particular operating environment may run unchanged on NT because the OS interface that they see is the same as that for which they were written.  For example, OS/2 based applications may run under the NT OS without modification except may need recompilation.The way in which the executive, the protected subsystems and the applications are structured for NT is by using the client-server computing model which is a common model for distributed computing.

The Windows NT process

The following Figure shows the Windows NT process and its resources relationship.

Figure 3: Windows NT process and its resources

Important characteristics of NT processes are the listed below.

1. NT processes are implemented as objects.

2. An executable process may contain one or more threads.

3. Both process and thread objects have built-in synchronization capabilities.

4. The NT kernel does not maintain any relationship among the processes that it creates, including parent-child relationship.

Figure 3 illustrates the way in which a process relates to the resources it controls or uses. The access token controls whether the process can change its own attributes.  In this case the process does not have a handle opened to its access token. If the process attempts to open such a handle, the security system determines whether this is permitted and therefore whether the process may change its own attributes.A series of blocks defines the virtual address space currently assigned to this process. The process cannot directly modify these structures but must rely on the virtual memory manager, which provides a memory-allocation service for the process. Finally the process includes an object table, which handles to other objects known to this process. One handle exists for each thread contained in this object.  In this figure, there is a single thread shown.  Additionally the process has access to a file object and to a section object that defines a section of shared memory.

Each NT process is represented by an object.  Each process is defined by a number of attributes and encapsulates a number of actions, or services, that it may perform. A process will perform a service upon receipt of the appropriate message. The only way to invoke such a service is by means of messages to a process object that provides that service. When NT creates a new process, it uses the object class, or type defined for the NT process as a template to generate a new object instance. At the time of creation, attributes values are assigned. An NT process must contain at least one thread to execute. The thread may then create other threads. In multiprocessor system, multiple threads from the same process may execute in parallel.Generally, a process, an abstraction of a running program is the most central concept in any OS.  From the OS general view a concept of process having the following two characteristics:

1. Unit of resource ownership: A process is allocated a virtual address space to hold the process image and from time to time the process may be assigned main memory plus control of other resources such as I/O channels, I/O devices and files.

2. Unit of dispatching: A process is an execution path (trace) through one or more programs.  This execution may be interleaved with other processes. Thus a process has an execution state (running, ready etc.) and a dispatching priority and it is the entity that is scheduled and dispatched by the OS.

These two characteristics are independent and could be treated independently by OS.  To distinguish the two characteristics, the unit of dispatching is usually referred to as a thread or lightweight process, whereas the unit of resource ownership is usually still referred to as a process or task.Windows NT support threads within processes.   Threads incorporate some of the functionality traditionally associated with processes.  The distinction refined from the previous list is:

1. Threads: A dispatchable unit of work.  It is the thing that executes sequentially and is interruptible so that the processor can turn to another thread.  From the point of view of scheduling and dispatching, this concept is equivalent to that of a process on most other OSes.

2. Process: A collection of one or more threads and associated system resources such as memory, open files and devices.  This corresponds closely to the concept of a program in execution.  By breaking a single application up into multiple threads, the programmer has great control over the modularity of the application and the timing of application-related events.  From the point of view of the job or application, this concept is equivalent to that of a process on most other OSes.

----------------------------------------------Process & Thread in COM-----------------------------------------

In Component Object Model (COM) of MSDN documentation the process and thread were told something like this: A process is a collection of virtual memory space, code, data, and system resources. Athread is code that is to be serially executed within a process. A processor executes threads, not processes, so each 32-bit application has at least one process, and a process always has at least one thread of execution, known as the primary thread. A process can have multiple threads in addition to the primary thread. Prior to the introduction of multiple threads of execution, applications were all designed to run on a single thread of execution. Processes communicate with one another through messages, using Microsoft's Remote Procedure Call (RPC) technology to pass information to one another. There is no difference to the caller between a call coming from a process on a remote machine and a call coming from another process on the same machine.

When a thread begins to execute, it continues until it is killed or until it is interrupted by a thread with higher priority (by a user action or the kernel's thread scheduler). Each thread can run separate sections of code, or multiple threads can execute the same section of code. Threads executing the same block of code maintain separate stacks. Each thread in a process shares that process's global variables and resources. The thread scheduler determines when and how often to execute a thread, according to a combination of the process's priority class attribute and the thread's base priority. You set a process's priority class attribute by calling the Win32® function SetPriorityClass(), and you set a thread's base priority with a call to SetThreadPriority().Multithreaded applications must avoid two threading problems: deadlocks and races. A deadlock occurs when each thread is waiting for the other to do something. A race condition occurs when one thread finishes before another on which it depends, causing the former to use a bogus value because the latter has not yet supplied a valid one.

------------------------------------------End-----------------------------------------

The life of a process is bounded by its creation and termination.  When a new process is to be added to those that are currently being managed by the operating system, the operating system builds the data structures that are used to manage the process and allocates the address space to be used by the process.  These actions constitute the creation of a new process.  Some of the common events that lead to the creation of a process are listed in the following table.

And the typical reasons for process termination are listed in the following Table.

Generally, a process may be in the following state.  Keep in mind that for implementation specific, process may have other states defined as well.

Process Execution

Most processors that normally associated with the operating system and user programs support at least two modes of execution.  Certain instructions can be executed only in the more privileged mode.  These include reading or altering a control register, such as the program status word, primitive I/O instructions and instruction that relate to memory management.  Additionally certain regions of memory can be accessed only in the more privilege mode such as kernel or system memory area.The more privilege mode is referred to as the system mode/control mode/kernel mode.  This last term refers to the kernel of the operating system, which is a portion of the operating system that encompasses the important system functions.  The less privilege mode often referred to as the user mode because user programs typically execute in this mode.  From application point of view, in UNIX/Linux this privileged mode normally associated with the Root account and in Windows it is the Administrator account. The least privilege normally associated with normal user account.  Between the root and normal user account there are many more accounts that having privileges more than normal user but below the root account. The following table summarizes the tasks typically found in the kernel of an operating system.

In this and some other related Modules, we will just concentrate on the process management.  The reason for using two modes is to protect the operating system and key operating-system tables, such as process control blocks, from interference by user programs.  In the kernel mode, the software has complete control of the processor and all its instructions, registers (processor’s memory) and memory (system’s memory).  This level of control is not necessary and for operating system integrity and safety, is not desirable for user programs.

Basic of Process Creation

To create a process, an operating system generally will obey the following steps:

1. Assign a unique process identifier (PID) to the new process. At this time, a new entry is added to the primary process table, which contains one entry per process.

2. Allocate space for the process.  This includes all elements of the process image such as private user address space (program and data) and for user stack.  If any existing address space is to be shared by this new process, the appropriate linkages must be set up.  Finally space for a process control block must be allocated.

3. The process control block must be initialized. This includes the initial process state, processor control information and priority.  Initially the process may own no resources such as I/O devices and files, unless there is an explicit request for these or unless they are inherited from the parent.

4. The appropriate linkages must be set.  For example, if the operating system maintains each scheduling queue as a linked list, then the new process must be put in the Ready or Ready-suspend list.

5. There may be other data structures to be created or expanded.  For example, the operating system may maintain an accounting file on each process to be used subsequently for billing and/or performance assessment purposes.

Process Switching

Process switching happens when a running process is interrupted and the operating system assigns another process to the Running state and turns control over to that process.  A process switching may happen any time that the operating system has gained control from the currently running process.  The following table lists the possible events that may give control to the operating system.

Generally, the uses of a system call results in placing the user process in the Blocked state.

Context Switching

In the processor’s fetch-execute instruction there is an interrupt cycle. In this case computers provide a mechanism by which other modules such as I/O and memory may interrupt the normal processing order of the processor. Interrupt cycles are provided primarily as a way to improve processing efficiency. In the interrupt cycle, processor checks to see if any interrupts have occurred, which would be indicated by the presence of an interrupt signal.  If no interrupts are pending, the processor proceeds to the fetch cycle and fetches the next instruction of the current program in the current process else the processor does the following:

1. It saves the context of the current program being executed.

2. It sets the program counter to the starting address of an interrupt handler program.

The interrupt handler is typically a short program that performs a few basic tasks related to an interrupt. The processor now proceeds to the fetch cycle and fetches the first instruction of the interrupt handler program, which will service the interrupt. So the context switch happened here.  The context that is saved must include any information that may be altered by the execution of the interrupt handler and that will be needed to resume the program that was interrupted.  This information includes the program counter, other processor registers and stacks information.

Multithreading

Windows NT support concurrency among processes because threads in different processes may execute concurrently. Furthermore, multiple threads within the same process may be allocated to separate processors and execute concurrently.  A multithreaded process achieves concurrency without the overhead of using multiple processes. Threads within the same process can exchange information through shared memory and have access to the shared resources of the process.  The following Figure depicts a general concept of multithreading of server application. A single server process can service a number of clients.  Each client request triggers the creation of a new thread within the server.

Figure 5: An example of the Windows NT multithreaded server

An example of an application that could make use of threads is a server, such as a file server on a LAN. As each new file request comes in, a new thread could be spawned for the file-management program.  Because a server will handle many requests, many threads will be created and destroyed in a short period.  If the server is a multiprocessor, then multiple threads within the same task can be executing simultaneously on different processors.  The thread construct is also useful for single processor to simplify the structure of a program that is logically doing several different functions.

Further reading and digging:

1. Microsoft C references, online MSDN.

2. Microsoft Visual C++, online MSDN.

3. ReactOS - Windows binary compatible OS - C/C++ source code repository, Doxygen.

4. Linux Access Control Lists (ACL) info can be found atAccess Control Lists.

5. For Multi bytes, Unicode characters and Localization please refer to Locale, wide characters & Unicode (Story) and Windows users & groups programming tutorials (Implementation).

6. Structure, enum, union and typedef story can be found C/C++ struct, enum, union & typedef.

7. Check the best selling C / C++ and Windows books at Amazon.com.

 |<Windows Process & Threads: C Run-Time 6 |Main |Windows Process & Threads Programming 2 >|Site Index |Download |