CN105117310A - Linux system-based memory read-write bandwidth optimization test method - Google Patents

Abstract

The invention discloses a memory read-write bandwidth optimization test method based on a linux system, which relates to a memory optimization test technology. Firstly, the system information is obtained by optimizing the test environment, and then the optimal test parameters and the number of test cycles are set, and the test source code is compiled and run. The script is tested, and finally the test data is obtained, and the optimal data is kept. The invention makes full use of system resources, reduces system consumption caused by cross-node memory access during calculation, realizes the coordinated work of CPU and memory, automatically realizes test optimization, greatly saves time and cost of testing, and can ensure the reliability of test data.

Description

A memory read and write bandwidth optimization test method based on linux system

technical field

The invention relates to a memory optimization test technology, in particular to a memory read-write bandwidth optimization test method based on a linux system.

Background technique

Server board-level design is the most important and complicated link in server design. How to ensure the integrity of power supply and signals at the board level? There will be a complete verification process in the SI test phase. However, due to the complexity of the computer, the SI department is also very concerned. Difficult to cover comprehensively. The system verification department must ensure the reliability and stability of the product's performance at the system level, and ensure the quality of the whole machine to the greatest extent. With the continuous improvement of various systems, the system structure is becoming more and more complex, and the program used for system optimization is wrapped outside the system core. How to cut the surface responsible for the system to ensure the reliability of the product system hardware at the basic level of the system has also become a problem. An important topic and research direction of test verification work.

With the rapid development and application of big data, cloud computing, and high-performance computers, the demand for massive data processing is increasing rapidly. Usually, when the CPU receives an instruction, it first searches for relevant data from the L1 cache (L1Cache) in the CPU. Although the L1 cache runs at the same frequency as the CPU, due to its small capacity, it is impossible to read it every time. hit. At this time, the CPU will continue to look for the next-level secondary cache (L2Cache). For the same reason, if the required data is not in the secondary cache, it will continue to turn to L3Cache, memory and hard disk. Since the amount of data processed by the system is quite huge, almost every operation has to go through the memory, which is also the most frequent component in the entire system.

In this way, the performance and utilization level of the memory determines the performance of the entire computer system to a certain extent. In previous memory bandwidth tests, the amount of cross-node memory access was large, and the CPU utilization rate was low. How to more accurately guarantee the memory bandwidth performance of each product has increasingly become an important task for the testing department.

Contents of the invention

Aiming at the current demand and the shortcomings of the development of the prior art, the present invention provides a memory read-write bandwidth optimization test method based on a linux system.

A kind of memory reading and writing bandwidth optimization test method based on linux system of the present invention, the technical scheme adopted for solving the above-mentioned technical problem is as follows: described memory reading and writing bandwidth optimization test method, at first by optimizing test environment, obtain system information, then set Test the optimal parameters and the number of test cycles, compile the test source code, and run the script for testing, and finally obtain the test data and keep the optimal data.

Preferably, the step of obtaining system information includes: copy info.sh to the root directory, and run info.sh to obtain basic information such as system CPU, memory, BIOS, sockets, cpunode, DIMMnumber, etc., such information automatically It is stored in the system directory for program calling.

Preferably, run the run_stream.sh script to detect the optimal N value under the system configuration.

Preferably, run run_stream.max, the script further optimizes the service program running on the system through the system information obtained earlier, and loops it multiple times, and takes the optimal result and stores it in the file.

A kind of memory reading and writing bandwidth optimization test method based on the linux system of the present invention has the beneficial effect compared with the prior art: utilize the analysis to the test system, shield the influence of the irrelevant service of the system, can maximize the full Utilize system resources to minimize the system consumption caused by cross-node memory access in computing, realize the coordination of CPU and memory, automatically realize test optimization, and realize semi-automated testing. The implementation process is simple and convenient, which greatly saves the time and cost of testing. Ensure the accuracy of the test and the reliability of the test data.

Description of drawings

Accompanying drawing 1 is the implementation figure of described memory reading and writing bandwidth optimization test method.

Detailed ways

In order to make the purpose, technical solution and advantages of the present invention clearer, below in conjunction with specific embodiment, and with reference to accompanying drawing, a kind of memory reading and writing bandwidth optimization test method based on linux system of the present invention is described in further detail.

The memory read-write bandwidth optimization test method based on the linux system of the present invention utilizes four basic operations of data replication, scalar, addition, and compound that are continuously circulated on the order of the user-defined array to perform operations to test the memory bandwidth. Since the user-defined array is generally very large, each step of the calculation will go through the memory, which requires a high quality of data communication between the CPU and the memory, so as to meet the requirements of the memory bandwidth test.

The C code representation of the four basic operations of data copying, scalar, addition and compounding:

Copyc[j]=a[j]; data copy

Scaleb[j]=scalar*c[j]; scalar

Addc[j]=a[j]+b[j]; addition

Triada[j]=b[j]+scalar*c[j]; compound operation

Among them, the Copy operation is to first access a memory unit to read the value, and then write the value to another memory unit; the Scale operation first reads the value from the memory unit, performs a multiplication operation, and then writes the result to into another memory unit; the Add operation first reads two values from the memory unit, performs an addition operation, and then writes the result to another memory unit; the Triad operation reads two values from the memory unit and performs Stored in another memory unit after compound operation.

Based on the Linux platform, the present invention takes the four basic operations of cyclic data copying, scalar, addition and compound operation as the core, realizes the automation of test tuning, saves test time and cost, and ensures test accuracy.

Embodiment: A kind of memory reading and writing bandwidth optimization test method based on linux system described in this embodiment first obtains system information by optimizing the test environment, then sets the optimal test parameters and the number of test cycles, compiles the test source code, and runs the script Test, finally get the test data, and keep the best data.

Accompanying drawing 1 is the implementation figure of described memory reading and writing bandwidth optimization test method, as shown in accompanying drawing 1, the specific implementation process of this test method comprises: prepare test environment and optimize test environment, obtain system information, then set test optimal Parameters and the number of test cycles, compile the test source code, run the script to perform the test cycle multiple times, and finally obtain the test data and keep the optimal data.

To perform this memory read and write bandwidth optimization test method, first prepare the test environment. For the system that supports RDIMM, use all memory channels, and each memory channel uses 1, 2, and 3 memory sticks respectively; software requirements: Intel encoder 13, redhat6. 2 and above;

The optimization settings under BIOS are as follows:

HT Disabled Turbo Mode Enabled NUMA Enabled HW Prefetch Enabled ACL Prefetch Enabled EIST Enabled C-state Disabled

The optimization settings under the OS are as follows:

For RHEL6, leave those services enabled and disable other services.

acpid cpuspeed haldaemon message bus network sshd

Get system information:

Copy info.sh to the root directory to obtain basic information such as system memory, CPU, number of threads, etc.:

Basic code:

#!/bin/sh

#timesynchronize

#ntpdate133.133.133.1

#sntp-Pno-r133.133.133.1/*Set SNTP server address*/

#getprocessormodelname

CPUMODE=`grep "modelname" /proc/cpuinfo|sort-u|tr-s''|awk'BEGIN{FS=":"}{print$2}'`

echo $CPUMODE

#getprocessorfrequency

CPUFREQ=`awk'{printf "%.2f",$1/1000000}'/sys/devices/system/cpu/cpu0/cpufreq/scaling_max_freq`

echo "Frequency:"$CPUFREQGHz

#getcachesize

CACHESIZE=`grep 'cachesize' /proc/cpuinfo|sort -u|awk'{print $4/1024}'`

echo "Cachesize:"$CACHESIZEMB

#getnumberofsockets

NUMSOCK=${1:-`grep 'physicalid' /proc/cpuinfo|sort -u|wc -l`}

echo $NUMSOCKsockets

#getidofeachsocket

socketidlist=`grep "physicalid" /proc/cpuinfo|sort-u|awk'{(es=="")?es=$4:es=es""$4}END{printes}'`

echo "IDsofSockets:"$socketidlist

#getnumberoflogicalcores

NUMPROC=${1:-`grep -c 'processor' /proc/cpuinfo`}

echo ""$NUMPROC logical cores in total

#getnumberofphysicalcorespersocket

NUMPHYSCORE=${1:-`grep 'cpucores' /proc/cpuinfo|sort -u|awk'{print $4}'`}

#TOTALCORES=${1:-`grep 'coreid' /proc/cpuinfo|wc -l`}

#NUMPHYSCORE=`expr $TOTALCORES/$NUMSOCK`

echo ""$NUMPHYSCOREphysicalcorespersocket

#getnumberoflogicalcorespersocket

firstsocket=`echo $socketidlist|cut -d'' -f1`

NUMLOGICORE=${1:-`awk'/physicalid\t:'$firstsocket'/'/proc/cpuinfo|wc -l`}

#or

#NUMLOGICORE=${1:-`expr $NUMPROC/$NUMSOCK`}

echo ""$NUMLOGICORE logical cores per socket

#getnumberofnumanodes

NUMNODE=${1:-`numactl --hardware|awk'/available:/{print $2}'`}

#socketnum=$NUMSOCK

#while(($socketnum>${2:-0}));do

#corenum=`awk'BEGIN{print'$socketnum'*'$NUMLOGICORE'}'/dev/null`

#cpuset=`grep-E"processor|physicalid|coreid|cpuid"/proc/cpuinfo|grep-A2"processor"|awk'BEGIN{FS="\n";RS="--\n"}{print $2,$3,$1}'|awk'{print$4,$8,a[$4$8]++,$11}'|sort-r|awk'NR<='$corenum'{(es=="")? es=$4:es=es","$4}END{prints}'`

#echo $corenum

#echo $cpuset

#socketnum=`expr$socketnum/2`

#done

sudo /usr/sbin/dmidecode -t0,2,17>dmiinfo

#getbaseboardinfo

BOARD=`grep-i-A3"baseboard"dmiinfo|awk'BEGIN{FS=":"}/Manufacturer|ProductName/{(es=="")?es=$2:es=es","$2}END {prints}'`

echoMotherBoard:$BOARD

#getbiosversion

BIOS=`grep-i-A3"biosinfo"dmiinfo|awk'BEGIN{FS=":"}/Version|ReleaseDate/{(es=="")?es=$2:es=es","$2}END {prints}'`

echo "BIOS:" $BIOS

#getmemoryinfo

DIMMNUM=`grep -i-A16 "memorydevice$"dmiinfo|grep -c 'Size:[0-9]'`

DIMMSIZE=`grep -i-A16 "memorydevice$"dmiinfo|grep -m1'Size:[0-9]'|awk'{print$2/1024}'`

DIMMTYPE=`grep-i-A16"memorydevice$"dmiinfo|grep-m1'Type:'|awk'BEGIN{FS=":"}{print$2}'`

DIMMSPEED=`grep -m1 'Speed'dmiinfo|awk'{print$2}'`

DIMMPART=`grep -m1'PartNumber:[[:alnum:]]'dmiinfo|awk'{print$3}'`

rm-fdmiinfo

echoMemory:${DIMMNUM}x${DIMMSIZE}GB ${DIMMTYPE}-${DIMMSPEED}MHz, ${DIMMPART}

#getOSinfo

OS=`[-e /etc/issue]&&head -n1 /etc/issue`

OS=`[-e /etc/issue]&&cat /etc/issue|sed'/^$/d'|head-n1`

echoOS:$OS

KERNEL=`uname-rm`

echo ""Kernel:$KERNEL

MACHINECONF="$CPUMODE,${CPUFREQ}GHz,${CACHESIZE}MB,${DIMMNUM}x${DIMMSIZE}GB${DIMMTYPE}-${DIMMSPEED},$TURBO,$HT,$NUMA"

echo $MACHINECONF

Run info.sh to obtain system CPU, memory, BIOS, sockets, cpunode, DIMMnumber and other information. Such information is automatically saved in the system directory for program calls.

Set the optimal parameters of the test and the number of test cycles, and compile the test source code:

Run the run_stream.sh script, this script can detect the optimal N value under the system configuration in the range of N value 10000000~2000000000:

#!/bin/bash

foriin$(seq1200)/*Cycle 200 times to test the N value, select the best data among them*/

do

echo-n "${i}0000000"/*Multiply the i value by 10000000 as the N value*/

icc-O3-openmp-DSTREAM_ARRAY_SIZE=${i}0000000-opt-prefetch-distance=64,8-opt-streaming-cache-evict=0-ffreestandingstream2.c-ostream2

/*Recompile the edited stream script*/

#./stream2|grep "^Tri"

numactl--physcpubind=0-59./stream2|grep "^Tri"/*Bind CPU physical core, perform stream test, and output the result*/

done.

Run the script to test the loop multiple times, and finally get the test data and keep the best data:

Run run_stream.max, the script further optimizes the service program running on the system through the system information obtained earlier, and loops it multiple times, and saves the optimal result in the stream_omp_v5.4_IC12.0.3.174_80M.csv file:

#!/bin/sh

#SetupenvandrunStream

.~/info.sh/* Run the test preparation stage to copy the info.sh script in the root directory to obtain system information */

mkdir-parchive/*Create an archive folder in the running directory for saving test results*/

#CaptureplatformspecificsCapture platform information

logfile=machine-config-`hostname`.log/*get hostname*/

date>$logfile/*Get time information*/

uname-a>>$logfile/*get system information*/

cat /etc/redhat-release>>$logfile

cat /proc/cpuinfo|grep -i'cpumhz'|uniq>>$logfile/*Get CPU frequency information*/

cat /proc/cpuinfo|grep-icache|uniq>>$logfile/*Get CPU cache information*/

if[-f /proc/pal/cpu0/cache_info];then

cat /proc/pal/cpu0/cache_info|grep -B1Size>>$logfile

the fi

cat/proc/meminfo|grep-i^mem[ft]>>$logfile/*Get the memory information corresponding to the CPU*/

#stream=stream_omp_11.1.073.160M/*Define stream path*/

stream=stream_omp_v5.4_IC12.0.3.174_80M

#_v5.4_IC11.1.073.160M

#LD_LIBRARY_PATH=/usr/local/lib/*Add stream information under system environment variables*/

#LD_LIBRARY_PATH=/root/benchmark/Stream/stream_omp_v5.4_IC12.0.3.174

exportLD_LIBRARY_PATH

exportKMP_AFFINITY=scatter/*add scaterr service*/

exportOMP_NUM_THREADS=$NUMPROC

echonever>/sys/kernel/mm/redhat_transparent_hugepage/enabled/*Enable redhat_transparent_hugepage service*/

cat/sys/kernel/mm/redhat_transparent_hugepage/enabled/*Enable redhat_transparent_hugepage service*/

resfile=$stream-`hostname`-allresult.csv/*Save the test results as corresponding csv files*/

if[!-f "$resfile"];then

echo "TIME,CPU,FREQ,CACHE,MEM,TURBO,HT,NUMA,logicalcores,#ofSockets,Copy,Scale,Add,Triad">>$resfile

the fi

ttime=`date+%y-%m-%d-%H:%M:%S`

runlog=$stream-${NUMSOCK}S${NUMPROC}T-`hostname`-$ttime.log

/*Test record log information*/

#loop=10/*Set the number of loops per run*/

max_triad=0/*Define max_traid to save the maximum value of test results*/

while(($loop>0));do

OMP_NUM_THREADS=$NUMPROCnumactl --physcpubind=${cpuset[NUMSOCK]}-l./$stream|tee-a$runlog

tail -n7 $runlog>temp_result

temp=`awk'/Triad:/{printf("%.0f",$2*10)}'temp_result`

if[$temp-gt$max_triad];then

copy=`awk'/Copy:/{printf("%.1f",$2)}'temp_result`

scale=`awk'/Scale:/{printf("%.1f",$2)}'temp_result`

add=`awk'/Add:/{printf("%.1f",$2)}'temp_result`

triad=`awk'/Triad:/{printf("%.1f",$2)}'temp_result`

max_triad=$temp

the fi

loop=`expr$loop-1`

done

rmtemp_result

echo $ttime, $MACHINECONF, $NUMPROC, $NUMSOCK-Socket, $copy, $scale, $add, $triad>>$resfile/*Copy the test results to the defined folder*/

mv*.logarchive/.

As can be seen from the technical scheme of the memory read-write bandwidth optimization test method described in this embodiment, the test method automatically shields the problem of inaccurate test data caused by the occupation of system resources by many irrelevant services in the system through scripts, and can be analyzed through the system. , to automatically obtain the optimal parameter settings under the system, so as to automatically output the test results, and realize the semi-automation of the memory read and write bandwidth optimization test.

The above-mentioned specific embodiments are only specific cases of the present invention, and the scope of patent protection of the present invention includes but is not limited to the above-mentioned specific embodiments, any claims that meet the claims of the present invention and any ordinary skilled person in the technical field. Appropriate changes or substitutions should fall within the scope of patent protection of the present invention.

Claims (4)

1. A memory read-write bandwidth optimization test method based on linux system, it is characterized in that, at first by optimizing the test environment, obtain system information, then set the test optimal parameters and the number of test cycles, compile the test source code, and run the script to test , and finally get the test data and keep the best data. 2. according to claim 1, a kind of memory reading and writing bandwidth optimization test method based on linux system, it is characterized in that, the step of described obtaining system information comprises: info.sh is copied under the root directory, and run info.sh , to obtain basic information such as system CPU, memory, BIOS, sockets, cpunode, DIMMnumber, etc. Such information is automatically saved in the system directory for program calls. 3. according to claim 2 a kind of memory reading and writing bandwidth optimization test method based on linux system, it is characterized in that, run run_stream.sh script, detect optimal N value under this system configuration. 4. according to claim 3 a kind of memory read-write bandwidth optimization test method based on linux system, it is characterized in that, run run_stream.max, this script is by the system information that obtains in front, further optimizes the service program of system operation, and Cycle multiple times, take the best result and store it in the file.