Shulou(Shulou.com)06/02 Report--

This article mainly explains "how to test the CPU, memory, IO and network pressure of Linux". Interested friends may wish to have a look. The method introduced in this paper is simple, fast and practical. Let's let the editor take you to learn how to test Linux's CPU, memory, IO, and network stress.

First, conduct a simple test of CPU:

1. Calculate the special function through the bc command

Example: calculate pi

Echo "scale=5000; 4yoga (1)" | bc-l-Q

MATH LIBRARY

If bc is invoked with the-l option, a math library is preloaded and the default scale is set to 20.

The math functions will calculate their results to the scale set at the time of their call. The math

Library defines the following functions:

S (x) The sine of x, x is in radians. Positive metaphysical function

C (x) The cosine of x, x is in radians. Cosmetic function

A (x) The arctangent of x, arctangent returns radians. Inverse tangent function

L (x) The natural logarithm of x. Log function (base 2)

The exponential function of e (x) The exponential function of raising e to the value x. E

J (NMagnex) The bessel function of integer order n of x. Bessel function

2. Tool 2: Super Pi for linux

Super PI uses the floating-point computing power of CPU to calculate π (pi), so it is widely used by overclocking players to test the stability of the system and the time it takes for CPU to calculate a specific digit of pi.

Download page: ftp://pi.super-computing.org/

Wget ftp://pi.super-computing.org/Linux/super_pi.tar.gz

Tar-xzvf super_pi.tar.gz

. / super_pi 20

20 is the number of digits Indicates how many azimuths to calculate, such as 1m after the decimal point.

Second, do a simple test on the memory:

Tool: memtester

Official: http://pyropus.ca/software/memtester/

Wget http://pyropus.ca/software/memtester/old-versions/memtester-4.3.0.tar.gz

Tar-xzvf memtester-4.3.0.tar.gz

Cd memtester-4.3.0

Make & & make install

Usage: Usage:. / memtester [- p physaddrbase [- d device]] [B | K | M | G] [loops]

Example: memtester 1G 5

Third, conduct a simple test of IO:

1. Use dd to test:

Time dd if=/dev/zero of=test bs=1M count=4096

Use top and iostat to check wa% and write hard disk speed

2. Use the fio command to test:

FIO is a very good tool for testing IOPS. It is used for stress testing and verification of hardware. It supports 13 different Imax O engines.

Including: sync,mmap, libaio, posixaio, SG v3, splice, null, network, syslet, guasi, solarisaio and so on.

Description:

The name of the filename=/dev/sdb1 test file, usually selecting the data directory of the disk to be tested.

The direct=1 testing process bypasses the machine's native buffer. Make the test results more realistic.

Rw=randwrite tests random written iThink O

Rw=randrw tests random write and read IMaple O

The block file size of bs=16k single io is 16k.

Bsrange=512-2048 same as above, specify the size range of the data block

The test file size of size=5g this time is 5g, which is tested with 4k io each time.

The test thread of numjobs=30 this time is 30. 0.

The runtime=1000 test time is 1000 seconds. If you don't write, you will continue to write 5g files in 4k each time.

Ioengine=psync io engine uses pync mode

Rwmixwrite=30 accounts for 30% in mixed read-write mode.

Group_reporting summarizes the information about each process for displaying the results.

In addition

Lockmem=1g uses only 1g of memory for testing.

Zero_buffers initializes the system buffer with 0.

Nrfiles=8 the number of files generated by each process.

Read randomly:

Fio-filename=/dev/sda3-direct=1-iodepth 1-thread-rw=randread-ioengine=psync-bs=4k-size=2G-numjobs=10-runtime=100 group_reporting name=mytest

Read sequentially:

Fio-filename=/dev/sda3-direct=1-iodepth 1-thread-rw=read-ioengine=psync-bs=4k-size=2G-numjobs=10-runtime=100 group_reporting name=mytest

Write randomly:

Fio-filename=/dev/sda3-direct=1-iodepth 1-thread-rw=randwrite-ioengine=psync-bs=4k-size=2G-numjobs=10-runtime=100 group_reporting name=mytest

Write sequentially:

Fio-filename=/dev/sda3-direct=1-iodepth 1-thread-rw=write-ioengine=psync-bs=4k-size=2G-numjobs=10-runtime=100 group_reporting name=mytest

Mixed random read and write:

Fio-filename=/dev/sda3-direct=1-iodepth 1-thread-rw=randrw-rwmixread=70-ioengine=psync-bs=4k-size=2G-numjobs=10 runtime=100 group_reporting name=mytest ioscheduler=noop

3. Iozone test

IOZONE is a testing tool that is mainly used to test the performance of operating system file systems. The scope of testing of this tool mainly includes write, Re-write, Read, Re-Read, Random Read, Random Write, Random Mix, Backwards Read, Record Rewrite, Strided Read, Fwrite, Frewrite, Fread, Freread, Mmap, Async IWeiO

Using iozone, you can test the performance of file operations in the case of multithreading, multi-cpu, and specifying the size of cpu cache space and synchronous or asynchronous Imax O read-write mode.

(0=write/rewrite, 1=read/re-read, 2=random-read/write

3=Read-backwards, 4=Re-write-record, 5=stride-read, 6=fwrite/re-fwrite, 7=fread/Re-fread

8=random mix, 9=pwrite/Re-pwrite, 10=pread/Re-pread, 11=pwritev/Re-pwritev, 12=preadv/Re-preadv).

Write: test the performance of writing to a new file. When a new file is written, not only the data in those files needs to be stored, but also the additional information used to locate the specific location of the data stored in the storage medium. This additional information is called "metadata". It includes catalog information, allocated space, and other data related to the file but not the data contained in the file. Thanks to this extra information, the performance of Write is usually lower than that of Re-write.

Re-write: tests the performance of writing to an existing file. When an existing file is written, less work is required because the metadata already exists. The performance of Re-write is generally higher than that of Write.

Read: test the performance of reading an existing file.

Re-Read: test the performance of reading a recently read file. Re-Read performance is higher because the operating system usually caches data from recently read files. This cache can be used to read to improve performance.

Random Read: test the performance of reading random offsets in a file. Many factors may affect system performance in this case, such as operating system cache size, number of disks, seek latency, and others.

Random Write: test the performance of writing random offsets in a file. Similarly, there are many factors that may affect system performance in this case, such as the size of the operating system cache, the number of disks, seek latency, and others.

Random Mix: test the performance of reading and writing random offsets in a file. Many factors may affect the performance of the system in this case, such as the size of the operating system cache, the number of disks, seek latency, and others. This test can only be done in throughput test mode. Each thread / process runs a read or write test. This distributed read / write test is based on round robin mode. It is best to use more than one thread / process to perform this test.

Backwards Read: test the performance of reading a file in reverse order. This method of reading files may seem ridiculous, but in fact, some applications do. MSC Nastran is an example of an application that reads files in reverse order. The files it reads are very large (from G to T). Although many operating systems use special implementations to optimize the speed of reading files sequentially, few operating systems notice and enhance the performance of reading files in reverse order.

Record Rewrite: test the performance of writing and overwriting specific blocks in a file. Something interesting might happen to this block. If this block is small enough (smaller than the CPU data cache), the measured performance will be very high. If it is larger than the CPU data cache and smaller than TLB, what is measured is the performance of another phase. If it is larger than both, but smaller than the operating system cache, the performance is another phase. If it is bigger than the operating system cache, it is a different result.

Strided Read: test the performance of skip reading a file. Examples are as follows: read 4Kbytes at 0 offset, then interval 200Kbytes, read 4Kbytes, then interval 200Kbytes, and so on. The mode at this time is to read the 4Kbytes, interval the 200Kbytes, and repeat the pattern. This is another typical application behavior, which is often done by applications that use data structures in files and access specific areas of that data structure.

Many operating systems do not notice this behavior or make some optimizations for this type of access. Similarly, this access behavior can lead to some interesting performance anomalies. One example is that in a data-fragmented file system, the jump of an application causes a particular disk to become a performance bottleneck.

Fwrite: test the performance of calling the library function fwrite () to write the file. This is a library routine that performs caching and blocking writes. Cached in user space. If an application wants to write a very small transport block, the caching and blocking Icano function in the fwrite () function can enhance the performance of the application by reducing the actual operating system calls and increasing the size of the transfer blocks when the operating system calls.

This test is to write a new file, so metadata writing is also necessary.

Frewrite: test the performance of calling the library function fwrite () to write the file. This is also a library routine that performs caching and blocking writes. Is cached in user space. If an application wants to write a very small transport block, the caching and blocking Icano function in the fwrite () function can enhance the application's performance by reducing the actual operating system calls and increasing the size of the transfer blocks when the operating system calls.

This test is written to an existing file, and the performance of the test is higher because there is no metadata operation.

Fread: test the performance of calling the library function fread () to read the file. This is a library routine that performs caching and blocking reads. Cached in user space. If an application wants to read a very small transport block, the caching and blocking Icano function in the fwrite () function can enhance the performance of the application by reducing the actual operating system calls and increasing the size of the transfer blocks when the operating system calls.

Several special tests:

Mmap: many operating systems support the use of mmap () to map a file to the user address space. After mapping, the read and write to memory will be synchronized to the file. This is convenient for applications that want to use files as memory blocks. One example is that a block in memory will be saved in the file system as a file at the same time.

Tool: IOzone

Official: http://www.iozone.org/

Tar-xvf iozone3_429.tar

Cd iozone3_429/src/current

Make

Make linux-ia64

Parameters:

-an is used to use fully automatic mode. Generate a report that includes all test operations, using block sizes from 4k to 16m and file sizes from 64k to 512m

-R produces an output log in execl format.

-b will produce the log file name of the binary execl.

-the file size of the test.

-Q specifies the maximum file block size (the-Q 64k here includes 4K, 8K, 16K, 32K, 64K)

-r refers to the size of the file block tested (unlike-Q,-r 64k is only tested for 64k)

-an is tested on the desired file system, but only-a will be fully tested, which will take a long time, and it is best to specify the test range with-I.

-g specifies the maximum test file size.

-n specifies the minimum test file size.

-f specify the name of the test file, which will be deleted automatically after completion (this file must be specified on the hard drive you want to test)

-C displays the throughput of each node.

-C test includes file closing time

-t specify the number of threads

-D uses msync (MS_ASYNC) for mmap files. This tells the operating system that all data in mmap space needs to be written to disk asynchronously.

-G uses msync (MS_SYNC) for mmap files. This tells the operating system that all data in mmap space needs to be written to disk synchronously.

Tests for file systems can be performed by clicking on several actions:

Example: iozone-a-n 512m-g 4G-I 0-I 1-I 5-f / mnt/iozone-Rb. / iozone.xls

Conduct a comprehensive test. The minimum test file is 512m until the test reaches 4G. Test read,write, and Strided Read. The test place is under mnt. Generate a file for Excel

1. Synchronous Ithumb O read and write test under multithreading

Tests were carried out on 128K, 16M, 256m, 2G file size, 8 processes, 64 processes, and 128 processes, respectively.

The main test items are write and repeat, read and repeat, read and write immediately, read backward, click and write in the file, point read in the large interval file, click and write in the file, and record the size of 1m cpu cache 2048kbyte.

1.1 128k file performance test:

The test command is:

Iozone-s 128k-I 0-I 1-I 2-I 3-I 4-I 5-I 8-t 8-G-o-B-Rb iozone.xls

Iozone-s 128k-I 0-I 1-I 2-I 3-I 4-I 5-I 8-t 64-G-o-B-Rb iozone.xls

Iozone-s 128k-I 0-I 1-I 2-I 3-I 4-I 5-I 8-t 128-G-o-B-Rb iozone.xls

1.2 16m file performance test

The test command is:

Iozone-s 16M-I 0-I 1-I 2-I 3-I 4-I 5-I 8-t 8-G-o-B-Rb iozone.xls

Iozone-s 16M-I 0-I 1-I 2-I 3-I 4-I 5-I 8-t 64-G-o-B-Rb iozone.xls

Iozone-s 16M-I 0-I 1-I 2-I 3-I 4-I 5-I 8-t 128-G-o-B-Rb iozone.xls

Performance Test of 1.3 256m File

The test command is:

Iozone-s 256m-I 0-I 1-I 2-I 3-I 4-I 5-I 8-t 8-G-o-B-Rb iozone.xls

Iozone-s 256m-I 0-I 1-I 2-I 3-I 4-I 5-I 8-t 64-G-o-B-Rb iozone.xls

Iozone-s 256m-I 0-I 1-I 2-I 3-I 4-I 5-I 8-t 128-G-o-B-Rb iozone.xls

1.42G file performance test

The test command is:

Iozone-s 2G-I 0-I 1-I 2-I 3-I 4-I 5-I 8-t 8-G-o-B-Rb iozone.xls

Iozone-s 2G-I 0-I 1-I 2-I 3-I 4-I 5-I 8-t 64-G-o-B-Rb iozone.xls

Iozone-s 2G-I 0-I 1-I 2-I 3-I 4-I 5-I 8-t 128-G-o-B-Rb iozone.xls

2. Asynchronous Ithumb O read and write test under multithreading

Tests were carried out on 128K, 16M, 256m, 2G file size, 8 processes, 64 processes, and 128 processes, respectively.

The main test items are write and repeat, read and repeat, read and write immediately, read backward, click and write in the file, click and write in the file at large intervals, and read and write immediately in the file.

2.1 128k file performance test:

The test command is:

Iozone-s 128k-I 0-I 1-I 2-I 3-I 4-I 5-I 8-t 8-D-o-B-Rb iozone.xls

Iozone-s 128k-I 0-I 1-I 2-I 3-I 4-I 5-I 8-t 64-D-o-B-Rb iozone.xls

Iozone-s 128k-I 0-I 1-I 2-I 3-I 4-I 5-I 8-t 128-D-o-B-Rb iozone.xls

2.2 16m file performance test

The test command is:

Iozone-s 16M-I 0-I 1-I 2-I 3-I 4-I 5-I 8-t 8-D-o-B-Rb iozone.xls

Iozone-s 16M-I 0-I 1-I 2-I 3-I 4-I 5-I 8-t 64-D-o-B-Rb iozone.xls

Iozone-s 16M-I 0-I 1-I 2-I 3-I 4-I 5-I 8-t 128-D-o-B-Rb iozone.xls

2.3 256m file performance test

The test command is:

Iozone-s 256m-I 0-I 1-I 2-I 3-I 4-I 5-I 8-t 8-D-o-B-Rb iozone.xls

Iozone-s 256m-I 0-I 1-I 2-I 3-I 4-I 5-I 8-t 64-D-o-B-Rb iozone.xls

Iozone-s 256m-I 0-I 1-I 2-I 3-I 4-I 5-I 8-t 128-D-o-B-Rb iozone.xls

Performance Test of 2.42G File

The test command is:

Iozone-s 2G-I 0-I 1-I 2-I 3-I 4-I 5-I 8-t 8-D-o-B-Rb iozone.xls

Iozone-s 2G-I 0-I 1-I 2-I 3-I 4-I 5-I 8-t 64-D-o-B-Rb iozone.xls

Iozone-s 2G-I 0-I 1-I 2-I 3-I 4-I 5-I 8-t 128-D-o-B-Rb iozone.xls

4. Network testing tool iperf:

Iperf is a network performance testing tool. Iperf can test the bandwidth quality of TCP and UDP. Iperf can measure the maximum TCP bandwidth and has a variety of parameters and UDP characteristics. Iperf can report bandwidth, delay jitter and packet loss.

Description of usage and parameters of Iperf

Parameter description

-s starts in server mode, eg:iperf-s

-c host starts in client mode, host is the server side address, eg:iperf-c 222.35.11.23

General parameter

-f [k | m | K | M] indicates that the report is displayed in Kbits, Mbits, KBytes and MBytes, respectively. The default is Mbits, and eg:iperf-c 222.35.11.23-f K

-I sec displays the reporting interval in seconds, eg:iperf-c 222.35.11.23-I 2

-l buffer size. The default is 8KB, egegpuriperf-c 222.35.11.23-l 16.

-m displays the maximum Mtu value of tcp

-o output reports and error messages to file eg:iperf-c 222.35.11.23-o c:\ iperflog.txt

-p specifies the port used by the server or the port connected by the client eg:iperf-s-p 9999bot iperf-c 222.35.11.23-p 9999

-u uses udp protocol

-w specifies the TCP window size. The default is 8KB.

-B bind a host address or interface (use this parameter when the host has more than one address or interface)

-C is compatible with older versions (used when server and client versions are different)

-M sets the maximum mtu value of TCP packets

-N sets TCP no delay

-V transmits ipv6 packets

Special parameters for server

-D runs ipserf,eg:iperf-s-D as a service

-R stops the iperf service, for-DJ egperf-s-R

Special parameters for client end

-d simultaneous two-way transmission test

-n specifies the number of bytes transferred, eg:iperf-c 222.35.11.23-n 100000

-r do two-way transmission test alone

-t test time, default 10 seconds, eg:iperf-c 222.35.11.23-t 5

-F specifies the files to be transferred

-T specifies the ttl value

5. Apache ab stress test:

Ab is a performance testing tool for Apache Hypertext transfer Protocol (HTTP). The design intention is to describe the execution performance of the currently installed Apache, mainly to show how many requests your installed Apache can handle per second

Ab is a performance testing tool for Apache Hypertext transfer Protocol (HTTP). It is designed to describe the execution performance of the currently installed Apache, mainly to show how many requests your installed Apache can handle per second.

Summary

Ab [- An auth-username] [- c concurrency] [- C cookie-name=value] [- d] [- e csv-file] [- g gnuplot-file] [- h] [- H custom-header] [- I] [- k] [- n requests] [- p POST-file] [- P proxy-auth-username] [- Q] [- s] [- S] ] [- t timelimit] [- T content-type] [- v verbosity] [- V] [- w] [- x-attributes] [- X proxy []] [- y-attributes] [- z-attributes] [http://]hostname[:port]/path]

Option

-An auth-username:password

Provide BASIC authentication trust to the server. The user name and password are separated by a: and sent in base64 code. This string is sent regardless of whether the server needs it (that is, whether the 401 authentication requirement code is sent).

-c concurrency

The number of requests generated at a time. The default is one at a time.

-C cookie-name=value

Append a Cookie: line to the request. Its typical form is a parameter pair of name=value. This parameter can be repeated.

-d

The message "percentage served within XX [ms] table" is not displayed (support for previous versions).

-e csv-file

Produces a comma-separated (CSV) file that contains the appropriate percentage of time (in subtle terms) required to process each appropriate percentage of requests (from 1% to 100%). Because this format is "binary", it is more useful than the 'gnuplot' format.

-g gnuplot-file

Write all test results to a 'gnuplot' or TSV (delimited by Tab) file. This file can be easily imported into Gnuplot, IDL, Mathematica, Igor or even Excel. One of the first behavior titles.

-h

Shows how to use it.

-H custom-header

Attach additional header information to the request. The typical form of this parameter is a valid header line containing pairs of fields and values separated by colons (for example, "Accept-Encoding: zip/zop;8bit").

-I

Execute the HEAD request instead of the GET.

-k

Enable the HTTP KeepAlive feature, that is, to execute multiple requests in a HTTP session. By default, the KeepAlive feature is not enabled.

-n requests

The number of requests executed in the test session. By default, only one request is executed, but usually the result is not representative.

-p POST-file

A file that contains data that requires POST.

-P proxy-auth-username:password

Provide BASIC authentication trust to a transit agent. The user name and password are separated by a: and sent in base64 code. This string is sent regardless of whether the server needs it (that is, whether the 401 authentication requirement code is sent).

-Q

If the number of requests processed is greater than 150, ab outputs a progress count on stderr for every 10 or 100 requests processed. This-Q flag suppresses this information.

S

Used in compilation (ab-h displays relevant information) when SSL's protected https is used instead of the http protocol. This function is experimental and crude. You'd better not use it.

-S

The median and standard deviation values are not displayed, and no warning or error messages are displayed when the mean and median values are 1 to 2 times the standard deviation value. By default, values such as minimum / mean / maximum are displayed. Provide support for previous versions.

-t timelimit

The maximum number of seconds that the test was conducted. Its internal implied value is-n 50000. It can limit the testing of the server to a fixed total time. By default, there is no time limit.

-T content-type

The Content-type header information used by POST data.

-v verbosity

Set the detail level of the display information-4 or greater to display header information, 3 or greater to display response codes (404200, etc.), and 2 or greater to display warnings and other information.

-V

Display the version number and exit.

-w

Output the results in the format of an HTML table. By default, it is a table with two columns wide on a white background.

-x-attributes

The string that sets the property. This property is filled in.

-X proxy [: port]

Use a proxy server for requests.

-y-attributes

The string that sets the property.

-z-attributes

The string that sets the property.

Example: ab-c 1000-n 1000 http://127.0.0.1/sw3560/index.html

This is ApacheBench, Version 2.0.40-dev apache-2.0

Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/

Copyright 2006 The Apache Software Foundation, http://www.apache.org/

Benchmarking 127.0.0.1 (be patient)

Completed 100 requests

Completed 200 requests

Completed 300 requests

Completed 400 requests

Completed 500 requests

Completed 600 requests

Completed 700 requests

Completed 800 requests

Completed 900 requests

Finished 1000 requests

Server Software: Apache/2.2.3

Server Hostname: 127.0.0.1

Server Port: 80

Document Path: / sw3560/index.html

Document Length: 5767 bytes

Concurrency Level: 1000 # concurrent users

Time taken for tests: 3.85301 seconds # indicates the total time it takes for all these requests to be processed and completed Complete requests: 1000

Failed requests: 0

Write errors: 0

Total transferred: 6034000 bytes # Total length of response data for all requests

HTML transferred: 5767000 bytes # the sum of body data in the response data of all requests

Requests per second: 324.12 [# / sec] (mean) # emphasis: throughput, which is equal to Complete requests / Time taken for tests (equivalent to transactions per second in LR, and mean in parentheses indicates that this is an average)

Time per request: 3085.301 [ms] (mean) # average request waiting time for users, which is equal to Time taken for tests / (Complete requests / Concurrency Level) [equivalent to the average transaction response time in LR]

Time per request: 3.085 [ms] (mean, across all concurrent requests)

# the average request processing time of the server is equal to Time taken for tests / Complete requests (the average actual elapsed time of each request)

Transfer rate: 1909.70 [Kbytes/sec] received

# the length of the request to get data from the server per unit time is equal to Total transferred / Time taken for tests, which is a good indication of the bandwidth requirement of the server when its processing capacity reaches its limit.

Connection Times (ms)

Min mean [+ /-sd] median max

Connect: 0 30 16.6 30 59

Processing: 21 924 975.9 612 3027

Waiting: 20 923 976.0 612 3026

Total: 21 954 987.4 637 3084

Percentage of the requests served within a certain time (ms)

50% 637

66% 1437

75% 1455

80% 1462

90% 3068

95% 3076

98% 3081

99% 3083

3084 (longest request)

# used to describe the distribution of processing time for each request, for example, 50%, 15%, the request processing time is no more than 1 second (the processing time here refers to: Time per request)

At this point, I believe you have a deeper understanding of "how to test Linux's CPU, memory, IO, and network pressure". You might as well do it in practice. Here is the website, more related content can enter the relevant channels to inquire, follow us, continue to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.