Lwp and lwp in linux

Lwp and lwp in linux

As mentioned earlier, creating a process in Linux usually contains the following

• Creating a series of data structures needed (such as classic) task_struct , mm_struct, That is, address space, etc.)
• To open physical memory, load code and data into physical memory
• Create a page table, responsible for mapping
• ········

If you create a process, it is nothing more than repeating the above operation, that is, when we create a process, it creates a lot of things from 0 to 1.

If there are three processes, then these three processes each have their own address space, respectively.If the second and third processes point to the address space of the first process, that is, these three processes have the same address space.,as follows

The code area and data segment of our address space will then be three, let these three processes accesses a piece of code area and data segment, respectively.

In this way, the address space of the process 1, or the popular point will appear three execution flows in a main function.Therefore, now we have changed the process of the process, and now there should be the concept of the process should not be just the individual we have known. task_struct ，The whole of the three parts of the above figure is called the process, each so-called «process» is just a execution stream of this whole real process.

(2) Process, threads and lightweight processes

A: Relationship between processes and threads

From the above story, you can find it.The process it is actually entity to assign system resourcesAnd those Task_struct recognized before, nothing more than running on these resources,The minimum unit of the CPU is scheduled to be these execution streams, so we have called threads.。

So the thread is a execution stream of the process. In the address space of the process, all threads use an address space. The relationship between them is 1: N, so we have said that the process we said is actually only one execution stream ( Or only one thread) process

B: There is no thread in the true sense in Linux

The principle of operating system management is to first describe, re-organize, from previous learning we can see, as long as the number, the relationship complex operation, the operating system will have a corresponding data structure, so since the process and thread The relationship is 1: N,The process is managed by the operating system, then the thread should also have a certain data structure to manage.。This idea is correct, However, in Linux, there is no real data structure as Windows, it is used to simulate threads with process.

It is not particularly good to specifically create a data structure for threads. The more complicated structure, the lower the efficiency.

So in the design of the multi-thread in Linux, take into account: Since the processes and threads are scheduled, they have the same properties, why do you need to design additional data structures?So use the process simulation thread in Linux, still adopting task_struct Indicates thread, if there is one task_struct It is said that this is a process of executing a stream, if there are multiple task_struct It is said that this is a plurality of execution flow.

C: Lightweight Process — LWP

So in Linux, all threads are in the same address space. In Linux, there is no process, no thread, what you see is just a lightweight process (LWP), it is light because there may be more Task_Struct to hang up the same address space, it It can also be changed, because it is possible to enjoy an address space yourself. From the nuclear point of view, the basic unit of its scheduling is thread, that is, LWP

It should be noted that although it is a process analog thread, there will still be some data structures in Linux to maintain this information, but such structures are not a structural body that specializes in maintenance threads in the true sense, similar to thread_control_block (TCB)

(3) Advantages and disadvantages of thread

A: Advantages

• Creating a new thread is much smaller than creating a new process
• Compared with the switching between the processes, the switching between the threads requires less work in the operating system.
• The resources occupied by threads are much less than the process.
• Can make full use of multi-processor’s parallel number
• While waiting for the slow I / O operation, the program can perform other computing tasks
• Calculate intensive applications, in order to run on multiprocessor systems, decompose to multiple threads
• I / O intensive application, in order to improve performance, overlap the I / O operation. Threads can wait for different I / O operations at the same time.

B: Disadvantages

• Performance loss: A calculated dense thread that is rarely blocked by external events often cannot share the same processor with the common thread. If calculating the number of intensive threads is more than the processor available, there may be greater performance loss, and the performance loss refers to the increase of additional synchronization and scheduling, and the resources available unchanged
• Reduce robustness: Writing multithreading needs more comprehensive consideration, a multi-threaded program, the possibility of adverse impact due to time allocation or due to sharing variables that should not be shared, or thread is Lack of protectionFor example, if a thread has an error, then all thread will exit all. Because the thread is the execution branch of the process, the thread has an exception, and the process also has an exception, which triggers the signal mechanism, terminating the process, and the process will be terminated, so all thread will exit all.）
• Lack of access control: The process is the basic particle size of access control, and call some system call functions in a thread that affects the entire process.
• Programming is difficult: Writing and debugging (especially debugging) a multi-thread program is more difficult than single-threaded program

(4) Thread VS process

1: The process is the basic unit of resource allocation, thread is the basic unit of CPU scheduling
2: Thread sharing process data, but also has some of its own data

• Thread ID
• A set of registers (hardware context)
• Stack
• errno
• Signal shield word
• Scheduling priority

3: Multiple threads of the process share address space, so text segment, data segment is shared, so a global variable can be accessed. In addition, the following resources are also shared.

• File descriptor table
• Handling method for each signal
• Current work catalog
• User ID and group ID

4: The relationship between processes and threads can be summarized in the following figure

Источник

First, LWP

LWP is called a lightweight process, in a computer operating system, a lightweight process (LWP) is a method of implementing multiple tasks. Compared with the normal process, LWP share all (or most) its logical address space and system resources compared to the thread; LWP has its own process identifier, priority, state, and stack and local storage. District, and other processes have a parent-child relationship; this is the same as the process of system calling vfork () generated with the Unix operating system. In addition, threads can be managed by application management, but also by kernel management, and LWP can only be managed by kernel management and dispatched like a normal process.The Linux kernel is a typical example of supporting LWP.
In most systems, the difference between LWP and normal processes is alsoIt only has a minimum of the statistics required to perform context and schedulers.And this is why it is called lightweight. In general, a process represents an instance of the program, and the LWP represents the execution thread of the program.

Second, the process

2.1 Process Definition

Basic Concept: An execution instance of the program, the program being executed, etc.
Nuclear point of view: Entity to assign allocation system resources (CPU time, memory)

We usually describe the process through the PCB, PCB (Process Control Block), PCB under the Linux operating system is: task_struck.task_struck usually describe the process, is a data structure in the kernel, usually installed in memory.
This information is often included in Task_struct:

Mogle: Describe the unique identifier of this process to distinguish other processes.
Status: task status, exit code, exit signal, etc.
Priority: Priority relative to other processes.
Program Counter: The address of the next instruction that is about to be executed in the program.
Memory pointer: including a pointer to program code and process related data, and a pointer to memory blocks shared with other processes.
Context Data: The data in the register of the processor is executed.
I / O status information: Includes the I / O request displayed, assigned to the I / O device of the process, and a list of files used by the process.
Accounting information: may include the sum of the processor time, the total number of clocks, time limit, account account, etc.

2.2 Creating Processes

2.3 Termination Process

Third, thread

3.1 Creating threads

One execution route in a program is called thread. More accurate definitions are: thread is «a sequence of control sequences in the process» everything has at least one execution thread.
The thread runs inside the process, the essence is running in the Linux system in the process address space, in the eyes of the CPU, the PCB seen is more lighter than traditional processes.
Through the virtual address space of the process, most of the resources of the process can be seen, and the process resources are reasonably assigned to each execution stream, and thread execution streams are formed.

Although most of the resources in the thread sharing process, thread also has its own data:

Thread ID
A set of registers
Stack
errno
Signal shield word
Scheduling priority

3.2 Termination Thread

There are three ways if you need to terminate a thread without terminating the entire process:

1. From the thread function return. This method is not applicable to the main thread, which is equivalent to calling exit from the main function return.
2. Threads can call pthread_ exit to terminate themselves.
3. A thread can call the PTHREAD_ CANCEL to terminate another thread in the same process.

Don’t exit directly with EXIT, exit with exit You will find anything, because the system will treat this thread as a process at this time.
PTHREAD_EXIT function:

3.3 Advantages of thread

Creating a new thread is more than the handoff between a new process, how many threads are switched between threads requires a lot of resources that should be worked in the operating system. There are still many threads.
Can make full use of multi-processors can perform other computing tasks while waiting for the slow I / O operation of the slow I / O operation.
Calculate intensive applications, in order to run on multiprocessor systems, decompose to multiple threads
I / O intensive application, in order to improve performance, overlap the I / O operation. Threads can wait for different I / O operations at the same time

3.4 Disadvantages of thread

Reduce robustness
, Writing multithreading needs more in-depth considerations, in a multi-threaded program, due to the minor deviation on time allocation or the possibility of adversely affecting the variables that sharing the shared, in other words It is lacking between threads.
Lack of access control
, The process is the basic particle size of access control, and call some OS functions in a thread that affects the entire process.
Programming is difficult
, Writing and debugging a multi-threader program is more difficult than single-threaded program

Источник

threads and LWP in Linux

Is this sentence correct: «All threads in Linux are LWP but not all LWP are threads». Actually, I try to understand thread realisation in Linux. pthread_create call clone syscall, but in man clone, I didn’t find any reference to LWP.

So, does Linux have LWP at all?

1 Answer 1

Threads in Linux are nothing but a flow of execution of the process. A process containing multiple execution flows is known as multi-threaded process.

For a non multi-threaded process there is only execution flow that is the main execution flow and hence it is also known as single threaded process. For Linux kernel , there is no concept of thread. Each thread is viewed by kernel as a separate process but these processes are somewhat different from other normal processes. I will explain the difference in following paragraphs.

Threads are often mixed with the term Light Weight Processes or LWPs. The reason dates back to those times when Linux supported threads at user level only. This means that even a multi-threaded application was viewed by kernel as a single process only. This posed big challenges for the library that managed these user level threads because it had to take care of cases that a thread execution did not hinder if any other thread issued a blocking call.

Later on the implementation changed and processes were attached to each thread so that kernel can take care of them. But, as discussed earlier, Linux kernel does not see them as threads, each thread is viewed as a process inside kernel. These processes are known as light weight processes.

The main difference between a light weight process (LWP) and a normal process is that LWPs share the same address space and other resources like open files etc. As some resources are shared so these processes are considered to be light weight as compared to other normal processes and hence the name light weight processes.

So, effectively we can say that threads and light weight processes are the same. It’s just that thread is a term that is used at user level while light weight process is a term used at kernel level.

From implementation point of view, threads are created using functions exposed by POSIX compliant pthread library in Linux. Internally, the clone() function is used to create a normal as well as a light weight process. This means that to create a normal process fork() is used that further calls clone() with appropriate arguments while to create a thread or LWP, a function from pthread library calls clone() with relevant flags. So, the main difference is generated by using different flags that can be passed to clone() function.

Read more about fork() and clone() on their respective man pages.

Источник