7 Practical Linux Performance Optimization Techniques Every Engineer Should Know

Linux system performance refers to the effectiveness, stability, and response speed of the operating system when completing tasks. Performance issues often stem from interactions among the OS, hardware, network topology, routing policies, and physical links, requiring comprehensive investigation across applications, OS, hardware, and network layers.

1. Factors affecting Linux system performance

CPU load – high utilization can slow processes and increase latency.

Memory usage – insufficient memory leads to process termination, swapping, and degraded performance.

Disk I/O – heavy I/O load raises response time and reduces throughput.

Network load – increased traffic or latency impacts overall system responsiveness.

Process scheduling – scheduler configuration influences CPU allocation and load balancing.

Filesystem performance – different filesystems and options affect I/O efficiency.

Kernel parameters – tuning TCP/IP, memory management, and cache settings can improve resource utilization.

Resource limits and quotas – proper limits prevent single users or processes from exhausting resources.

Optimizing Linux performance requires a holistic view of these interrelated factors.

2. Quick troubleshooting methods

CPU performance analysis : Use

top

,

vmstat

,

pidstat

,

strace

or

perf

to collect CPU metrics, then correlate with process behavior to pinpoint bottlenecks.

Memory performance analysis : Examine

free

and

vmstat

output, identify high‑memory processes, and investigate leaks or excessive caching.

Disk and filesystem I/O analysis : Run

iostat

to detect I/O saturation, then use

pidstat

,

vmstat

,

strace

, or

lsof

to trace the offending processes.

Network performance analysis : Check interface throughput, packet loss, errors, and soft‑interrupts; analyze routing, fragmentation, and TCP/UDP metrics with tools such as

netstat

,

tcpdump

, or

bcc

.

3. Diagnosing high system load

Run

top

or

htop

and examine the load‑average; values above 70‑80% of CPU cores indicate overload.

Identify processes with high CPU usage via

top

/

htop

.

Check memory pressure with

free

; excessive swap usage signals memory shortage.

Inspect disk I/O using

iotop

.

Review network connections with

netstat

or similar tools.

Search system and application logs for errors.

Utilize

perf

or

strace

for detailed process‑level profiling.

Audit kernel and sysctl parameters to ensure they match workload requirements.

Following these steps helps locate the root cause of load spikes.

4. Finding the top‑5 resource‑hogs

CPU ranking:

ps aux --sort=-%cpu | head -n 5

Memory ranking:

ps aux --sort=-%mem | head -n 6

I/O ranking:

iotop -oP

Additional commands shared by the community:

# ps aux|grep -v USER|sort +2|tail -n 10

# ps aux|grep -v USER|sort +3|tail -n 10

Check disk busy with:

iostat 1 10

5. Why Linux memory statistics may appear inaccurate

The

free

command reports an instantaneous snapshot, while

/proc/meminfo

reflects real‑time changes.

free

includes cached and buffered memory, often making available memory appear lower.

Factors causing discrepancies:

Cache and buffers – counted by

free

but not always by other tools.

Shared memory – may be omitted from per‑process tallies.

Memory reclamation – the kernel can reclaim pages, causing lag between tools.

For precise insight, combine multiple utilities such as

htop

,

nmon

,

sysstat

, and

top

, and analyze trends over time.

6. Current use cases for swap

Memory shortage – provides overflow space when RAM is exhausted.

Hibernate/suspend – stores RAM contents for fast resume.

Virtualization – offers extra memory to guest VMs on an over‑committed host.

Memory reclamation and page replacement – helps the kernel free RAM for critical tasks.

While useful, excessive swapping can degrade performance; proper RAM provisioning is recommended.

7. Linux TCP tuning experiences

Community shared a script (

centos7-os-init.sh

) and several configuration screenshots (shown below).

TCP tuning is divided into three categories:

High request volume : Reduce TIME_WAIT impact by increasing

net.ipv4.tcp_max_tw_buckets

,

net.netfilter.nf_conntrack_max

, decreasing

net.ipv4.tcp_fin_timeout

and

net.netfilter.nf_conntrack_tcp_timeout_time_wait

, enabling

net.ipv4.tcp_tw_reuse

, expanding

net.ipv4.ip_local_port_range

, and raising file descriptor limits via

fs.nr_open

,

fs.file-max

or

LimitNOFILE

.

SYN flood mitigation : Increase half‑open queue with

net.ipv4.tcp_max_syn_backlog

or enable

net.ipv4.tcp_syncookies

(mutually exclusive), and lower

net.ipv4.tcp_synack_retries

.

Long‑lived connections : Shorten keepalive intervals with

net.ipv4.tcp_keepalive_time

,

net.ipv4.tcp_keepalive_intvl

, and reduce probe count via

net.ipv4.tcp_keepalive_probes

.

Effective Linux performance optimization demands a comprehensive understanding of CPU, memory, disk, and network fundamentals, as well as proficiency with monitoring metrics and analysis tools.