Linux性能调优指南：适应多场景的4285版PDF

Linux

Perfor

需积分: 0 32 浏览量更新于2023-05-20 收藏 4.16MB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

《Linux性能与调优指南》(PDF)是IBM红皮书(Redpaper)系列中的一份文档，编号为REDP-4285-00，发布于2007年7月，适用于基于内核2.6的Linux发行版。这份文档由Eduardo Ciliendo和Takechika Kunimasa共同撰写，旨在帮助用户深入了解Linux操作系统，并提供性能监控工具、操作系统的调优方法以及性能分析技巧。 Linux作为一个开源操作系统，其源代码可供全球开发者在GNU通用公共许可证下自由使用，常见的发行商如Red Hat和Novell提供了各种桌面和服务器版本。随着Linux在全球企业数据中心的广泛应用，其性能优化成为了科学和企业用户关注的重点。由于不同的应用场景对系统性能有不同需求，如气象预报计算和数据库服务，Linux必须具备广泛的适应性和优化能力，以满足各种场景的高效运行。第1章探讨了理解Linux操作系统的基础，包括进程管理。Linux中的进程是系统活动的核心，每个进程都有其生命周期，包括创建、执行、调度和终止。1.1.1节详细解释了什么是进程及其在Linux系统中的角色，强调了理解这些基本概念对于性能优化的重要性。接下来的章节可能会深入讨论如何通过调整系统参数（如内存管理、CPU调度策略、I/O调度等）来提升Linux的性能。这可能涉及使用诸如top、htop、vmstat、iostat等性能监控工具来诊断性能瓶颈。此外，还可能讲解如何使用perf、strace等性能分析工具进行系统级和应用级的性能分析，以便找出并解决潜在问题。对于服务器级别的Linux，文档可能还会涉及网络性能调优，如TCP/IP栈的优化，以及如何利用QoS（Quality of Service）机制来保证关键任务的服务质量。内存管理也是重要的部分，包括交换空间的设置、内核缓存的优化以及内存泄漏的预防。最后，该指南可能还会提醒用户在使用前阅读注意事项，确保遵循最新的安全实践和许可协议，特别是对于美国政府用户，可能受到GSA合同的限制。此外，IBM会定期更新这份文档，以反映最新的技术和最佳实践。《Linux性能与调优指南》提供了深入且实用的信息，不仅适合系统管理员和技术人员，也适用于寻求提升Linux性能的企业和个人。无论是初学者还是经验丰富的用户，都能从中找到针对特定需求的调优策略和方法。

资源详情

资源推荐

2 Linux Performance and Tuning Guidelines

You could tune the I/O subsystem for weeks in vain if the disk subsystem for a 20,000 user

database server consisted of a single IDE drive. Often a new driver or an update to the

application yields impressive performance gains. As we discuss specific details, keep in mind

the whole picture of systems performance. Understanding the way an operating system

manages the system resources helps us understand what subsystems we need to tune in any

application scenario.

The following sections provide a short introduction to the architecture of the Linux operating

system. A complete analysis of the Linux kernel is beyond the scope of this paper. You can

refer to the kernel documentation for a complete reference of the Linux kernel.

In this chapter we cover:

򐂰 1.1, “Linux process management” on page 2

򐂰 1.2, “Linux memory architecture” on page 10

򐂰 1.3, “Linux file systems” on page 15

򐂰 1.4, “Disk I/O subsystem” on page 19

򐂰 1.5, “Network subsystem” on page 26

򐂰 1.6, “Understanding Linux performance metrics” on page 34

1.1 Linux process management

Process management is one of the most important roles of any operating system. Effective

process management enables an application to operate steadily and effectively.

Linux process management implementation is similar to UNIX® implementation. It includes

process scheduling, interrupt handling, signaling, process prioritization, process switching,

process state, process memory, and so on.

In this section, we discuss the fundamentals of the Linux process management

implementation. It helps you understand how the Linux kernel deals with processes that will

have an effect on system performance.

1.1.1 What is a process?

A process is an instance of execution that runs on a processor. The process uses any

resources that the Linux kernel can handle to complete its task.

All processes running on Linux operating system are managed by the task_struct structure,

which is also called a process descriptor. A process descriptor contains all the information

necessary for a single process to run such as process identification, attributes of the process,

and resources which construct the process. If you know the structure of the process, you can

understand what is important for process execution and performance. Figure 1-2 shows the

outline of structures related to process information.

Note: This paper focuses on the performance of the Linux operating system.

4 Linux Performance and Tuning Guidelines

parent process’ process descriptor to the child’s. At this time the entire address space of the

parent process is not copied; both processes share the same address space.

The exec() system call copies the new program to the address space of the child process.

Because both processes share the same address space, writing new program data causes a

page fault exception. At this point, the kernel assigns the new physical page to the child

process.

This deferred operation is called the

Copy On Write. The child process usually executes their

own program rather than the same execution as its parent does. This operation avoids

unnecessary overhead because copying an entire address space is a very slow and

inefficient operation which uses a lot of processor time and resources.

When program execution has completed, the child process terminates with an exit() system

call. The exit() system call releases most of the data structure of the process and notifies

the parent process of the termination sending a signal. At this time, the process is called a

zombie process (refer to “Zombie processes” on page 7).

The child process will not be completely removed until the parent process knows of the

termination of its child process by the wait() system call. As soon as the parent process is

notified of the child process termination, it removes all the data structure of the child process

and release the process descriptor.

1.1.3 Thread

A thread is an execution unit generated in a single process. It runs parallel with other threads

in the same process. They can share the same resources such as memory, address space,

open files, and so on. They can access the same set of application data. A thread is also

called

Light Weight Process (LWP). Because they share resources, each thread should not

change their shared resources at the same time. The implementation of mutual exclusion,

locking, serialization, and so on, are the user application’s responsibility.

From the performance perspective, thread creation is less expensive than process creation

because a thread does not need to copy resources on creation. On the other hand, processes

and threads have similar characteristics in terms of scheduling algorithm. The kernel deals

with both of them in a similar manner.

Figure 1-4 process and thread

In current Linux implementations, a thread is supported with the Portable Operating System

Interface for UNIX (POSIX) compliant library (

pthread). Several thread implementations are

available in the Linux operating system. The following are the widely used.

򐂰 LinuxThreads

Process Process

resource

source

resource

copy

Process

Thread

Thr

Thread

resource

source

resource

share share

Process creation Thread creation

Chapter 1. Understanding the Linux operating system 5

LinuxThreads have been the default thread implementation since Linux kernel 2.0. The

LinuxThread has some noncompliant implementations with the POSIX standard. Native

POSIX Thread Library (NPTL) is taking the place of LinuxThreads. The LinuxThreads will

not be supported in future release of Enterprise Linux distributions.

򐂰 Native POSIX Thread Library (NPTL)

The NPTL was originally developed by Red Hat. NPTL is more compliant with POSIX

standards. By taking advantage of enhancements in kernel 2.6 such as the new clone()

system call, signal handling implementation, and so on, it has better performance and

scalability than LinuxThreads.

NPTL has some incompatibility with LinuxThreads. An application which has a

dependence on LinuxThread might not work with the NPTL implementation.

򐂰 Next Generation POSIX Thread (NGPT)

NGPT is an IBM developed version of POSIX thread library. It is currently under

maintenance operation and no further development is planned.

Using the LD_ASSUME_KERNEL environment variable, you can choose which threads library the

application should use.

1.1.4 Process priority and nice level

Process priority is a number that determines the order in which the process is handled by the

CPU and is determined by dynamic priority and static priority. A process which has higher

process priority has a greater chance of getting permission to run on a processor.

The kernel dynamically adjusts dynamic priority up and down as needed using a heuristic

algorithm based on process behaviors and characteristics. A user process can change the

static priority indirectly through the use of the

nice level of the process. A process which has

higher static priority will have longer time slice (how long the process can run on a processor).

Linux supports nice levels from 19 (lowest priority) to -20 (highest priority). The default value

is 0. To change the nice level of a program to a negative number (which makes it a higher

priority), it is necessary to log on or use su on the root.

1.1.5 Context switching

During process execution, information on the running process is stored in registers on the

processor and its cache. The set of data that is loaded to the register for the executing

process is called the

context. To switch processes, the context of the running process is

stored and the context of the next running process is restored to the register. The process

descriptor and the area called kernel mode stack are used to store the context. This switching

process is called

context switching. Having too much context switching is undesirable

because the processor has to flush its register and cache every time to make room for the

new process. It could cause performance problems.

Figure 1-5 illustrates how the context switching works.

6 Linux Performance and Tuning Guidelines

Figure 1-5 Context switching

1.1.6 Interrupt handling

Interrupt handling is one of the highest priority tasks. Interrupts are usually generated by I/O

devices such as a network interface card, keyboard, disk controller, serial adapter, and so on.

The interrupt handler notifies the Linux kernel of an event (such as keyboard input, ethernet

frame arrival, and so on). It tells the kernel to interrupt process execution and perform

interrupt handling as quickly as possible because some device requires quick

responsiveness. This is critical for system stability. When an interrupt signal arrives to the

kernel, the kernel must switch a current execution process to a new one to handle the

interrupt. This means interrupts cause context switching, and therefore a significant amount

of interrupts could cause performance degradation.

In Linux implementations, there are two types of interrupts. A

hard interrupt is generated for

devices which require responsiveness (disk I/O interrupt, network adapter interrupt, keyboard

interrupt, mouse interrupt). A

soft interrupt is used for tasks which processing can be

deferred (TCP/IP operation, SCSI protocol operation, and so on). You can see information

related to hard interrupts at /proc/interrupts.

In a multi-processor environment, interrupts are handled by each processor. Binding

interrupts to a single physical processor could improve system performance. For more details,

refer to 4.4.2, “CPU affinity for interrupt handling” on page 108.

1.1.7 Process state

Every process has its own state that shows what is currently happening in the process.

Process state changes during process execution. Some of the possible states are as follows:

򐂰 TASK_RUNNING

In this state, a process is running on a CPU or waiting to run in the queue (run queue).

򐂰 TASK_STOPPED

A process suspended by certain signals (for example SIGINT, SIGSTOP) is in this state. The

process is waiting to be resumed by a signal such as SIGCONT.

򐂰 TASK_INTERRUPTIBLE

stack pointer

other registers

EIP register

etc.

CPU

Address space

of process B

Address space

of process A

stack

task_struct

(Process A)

task_struct

(Process B)

Suspend

Resume

Context switch

剩余167页未读，继续阅读

okokokkhero

粉丝: 0
资源: 2

会员权益专享

Linux性能调优指南：适应多场景的4285版PDF

Linux Performance and Tuning Guidelines.pdf

Linux Performance and Tuning Guidelines + linux内核测试指南

linux performance and tuning guidelines redbook_IBM

linux performance tuning pdf

Android PPTS (Power and Performance Tuning Suite) 框图

Android PPTS (Power and Performance Tuning Suite) 的组成

pid controllers: theory, design and tuning pdf

做一个Android PPTS (Power and Performance Tuning Suite) 的框图

oracle performance tuning guide

做一个Android PPTS (Power and Performance Tuning Suite) 的流程图

推荐 一些 linux debug 相关的书籍

Explain how critical gain and critical frequency can be used in PID controller tuning.

hyperparameter Tuning

pid controllers:theory design and tuning

prompt tuning

ERROR: Cannot install tuning==2020.8.28.15.36.59 and tuning==2020.8.28.15.39.17 because these package versions have conflicting dependencies.

类似tuning playbook的repo

深入理解linux内核第三版 中文英文

pid controllers: theory, design, and tuning isbn

高性能spark pdf

会员权益专享

最新资源

推荐一些 linux debug 相关的书籍

深入理解linux内核第三版中文英文