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.