| #!/bin/sh |
| ############################################################################## |
| # # |
| # Copyright (c) International Business Machines Corp., 2007 # |
| # Sivakumar Chinnaiah, Sivakumar.C@in.ibm.com # |
| # Copyright (c) Linux Test Project, 2016 # |
| # # |
| # This program is free software: you can redistribute it and/or modify # |
| # it under the terms of the GNU General Public License as published by # |
| # the Free Software Foundation, either version 3 of the License, or # |
| # (at your option) any later version. # |
| # # |
| # This program is distributed in the hope that it will be useful, # |
| # but WITHOUT ANY WARRANTY; without even the implied warranty of # |
| # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # |
| # GNU General Public License for more details. # |
| # # |
| # You should have received a copy of the GNU General Public License # |
| # along with this program. If not, see <http://www.gnu.org/licenses/>. # |
| # # |
| ############################################################################## |
| # # |
| # Description: Test Basic functionality of numactl command. # |
| # Test #1: Verifies cpunodebind and membind # |
| # Test #2: Verifies preferred node bind for memory allocation # |
| # Test #3: Verifies share memory allocation on preferred node # |
| # Test #4: Verifies memory interleave on all nodes # |
| # Test #5: Verifies share memory interleave on all nodes # |
| # Test #6: Verifies physcpubind # |
| # Test #7: Verifies localalloc # |
| # Test #8: Verifies memhog # |
| # Test #9: Verifies numa_node_size api # |
| # Test #10:Verifies Migratepages # |
| # Test #11:Verifies hugepage alloacted on specified node # |
| # Test #12:Verifies THP memory allocated on preferred node # |
| # # |
| ############################################################################## |
| |
| TST_CNT=12 |
| TST_SETUP=setup |
| TST_TESTFUNC=test |
| TST_NEEDS_TMPDIR=1 |
| TST_NEEDS_ROOT=1 |
| TST_NEEDS_CMDS="numactl numastat awk" |
| |
| . tst_test.sh |
| |
| # |
| # Extracts the value of given numa node from the `numastat -p` output. |
| # |
| # $1 - Pid number. |
| # $2 - Node number. |
| # |
| extract_numastat_p() |
| { |
| local pid=$1 |
| local node=$(($2 + 2)) |
| |
| echo $(numastat -p $pid |awk '/^Total/ {print $'$node'}') |
| } |
| |
| check_for_support_numa() |
| { |
| local pid=$1 |
| |
| local state=$(awk '{print $3}' /proc/$pid/stat) |
| |
| if [ $state = 'T' ]; then |
| return 0 |
| fi |
| |
| return 1 |
| } |
| |
| setup() |
| { |
| export MB=$((1024*1024)) |
| export PAGE_SIZE=$(tst_getconf PAGESIZE) |
| export HPAGE_SIZE=$(awk '/Hugepagesize:/ {print $2}' /proc/meminfo) |
| |
| total_nodes=0 |
| |
| nodes_list=$(numactl --show | grep nodebind | cut -d ':' -f 2) |
| for node in $nodes_list; do |
| total_nodes=$((total_nodes+1)) |
| done |
| |
| tst_res TINFO "The system contains $total_nodes nodes: $nodes_list" |
| if [ $total_nodes -le 1 ]; then |
| tst_brk TCONF "your machine does not support numa policy |
| or your machine is not a NUMA machine" |
| fi |
| } |
| |
| # Verification of memory allocated on a node |
| test1() |
| { |
| Mem_curr=0 |
| |
| for node in $nodes_list; do |
| numactl --cpunodebind=$node --membind=$node support_numa alloc_1MB & |
| pid=$! |
| |
| TST_RETRY_FUNC "check_for_support_numa $pid" 0 |
| |
| Mem_curr=$(echo "$(extract_numastat_p $pid $node) * $MB" |bc) |
| if [ $(echo "$Mem_curr < $MB" | bc) -eq 1 ]; then |
| tst_res TFAIL \ |
| "NUMA memory allocated in node$node is less than expected" |
| kill -CONT $pid >/dev/null 2>&1 |
| return |
| fi |
| |
| kill -CONT $pid >/dev/null 2>&1 |
| done |
| |
| tst_res TPASS "NUMA local node and memory affinity" |
| } |
| |
| # Verification of memory allocated on preferred node |
| test2() |
| { |
| Mem_curr=0 |
| |
| COUNTER=1 |
| for node in $nodes_list; do |
| |
| if [ $COUNTER -eq $total_nodes ]; then #wrap up for last node |
| Preferred_node=$(echo $nodes_list | cut -d ' ' -f 1) |
| else |
| # always next node is preferred node |
| Preferred_node=$(echo $nodes_list | cut -d ' ' -f $((COUNTER+1))) |
| fi |
| |
| numactl --cpunodebind=$node --preferred=$Preferred_node support_numa alloc_1MB & |
| pid=$! |
| |
| TST_RETRY_FUNC "check_for_support_numa $pid" 0 |
| |
| Mem_curr=$(echo "$(extract_numastat_p $pid $Preferred_node) * $MB" |bc) |
| if [ $(echo "$Mem_curr < $MB" |bc ) -eq 1 ]; then |
| tst_res TFAIL \ |
| "NUMA memory allocated in node$Preferred_node is less than expected" |
| kill -CONT $pid >/dev/null 2>&1 |
| return |
| fi |
| |
| COUNTER=$((COUNTER+1)) |
| kill -CONT $pid >/dev/null 2>&1 |
| done |
| |
| tst_res TPASS "NUMA preferred node policy" |
| } |
| |
| # Verification of share memory allocated on preferred node |
| test3() |
| { |
| Mem_curr=0 |
| COUNTER=1 |
| |
| for node in $nodes_list; do |
| |
| if [ $COUNTER -eq $total_nodes ] #wrap up for last node |
| then |
| Preferred_node=$(echo $nodes_list | cut -d ' ' -f 1) |
| else |
| # always next node is preferred node |
| Preferred_node=$(echo $nodes_list | cut -d ' ' -f $((COUNTER+1))) |
| fi |
| |
| numactl --cpunodebind=$node --preferred=$Preferred_node support_numa alloc_1MB_shared & |
| pid=$! |
| |
| TST_RETRY_FUNC "check_for_support_numa $pid" 0 |
| |
| Mem_curr=$(echo "$(extract_numastat_p $pid $Preferred_node) * $MB" |bc) |
| if [ $(echo "$Mem_curr < $MB" |bc ) -eq 1 ]; then |
| tst_res TFAIL \ |
| "NUMA share memory allocated in node$Preferred_node is less than expected" |
| kill -CONT $pid >/dev/null 2>&1 |
| return |
| fi |
| |
| COUNTER=$((COUNTER+1)) |
| kill -CONT $pid >/dev/null 2>&1 |
| done |
| |
| tst_res TPASS "NUMA share memory allocated in preferred node" |
| } |
| |
| # Verification of memory interleaved on all nodes |
| test4() |
| { |
| Mem_curr=0 |
| # Memory will be allocated using round robin on nodes. |
| Exp_incr=$(echo "$MB / $total_nodes" |bc) |
| |
| numactl --interleave=all support_numa alloc_1MB & |
| pid=$! |
| |
| TST_RETRY_FUNC "check_for_support_numa $pid" 0 |
| |
| for node in $nodes_list; do |
| Mem_curr=$(echo "$(extract_numastat_p $pid $node) * $MB" |bc) |
| |
| if [ $(echo "$Mem_curr < $Exp_incr" |bc ) -eq 1 ]; then |
| tst_res TFAIL \ |
| "NUMA interleave memory allocated in node$node is less than expected" |
| kill -CONT $pid >/dev/null 2>&1 |
| return |
| fi |
| done |
| |
| kill -CONT $pid >/dev/null 2>&1 |
| tst_res TPASS "NUMA interleave policy" |
| } |
| |
| # Verification of shared memory interleaved on all nodes |
| test5() |
| { |
| Mem_curr=0 |
| # Memory will be allocated using round robin on nodes. |
| Exp_incr=$(echo "$MB / $total_nodes" |bc) |
| |
| numactl --interleave=all support_numa alloc_1MB_shared & |
| pid=$! |
| |
| TST_RETRY_FUNC "check_for_support_numa $pid" 0 |
| |
| for node in $nodes_list; do |
| Mem_curr=$(echo "$(extract_numastat_p $pid $node) * $MB" |bc) |
| |
| if [ $(echo "$Mem_curr < $Exp_incr" |bc ) -eq 1 ]; then |
| tst_res TFAIL \ |
| "NUMA interleave share memory allocated in node$node is less than expected" |
| kill -CONT $pid >/dev/null 2>&1 |
| return |
| fi |
| done |
| |
| kill -CONT $pid >/dev/null 2>&1 |
| |
| tst_res TPASS "NUMA interleave policy on shared memory" |
| } |
| |
| # Verification of physical cpu bind |
| test6() |
| { |
| no_of_cpus=0 #no. of cpu's exist |
| run_on_cpu=0 |
| running_on_cpu=0 |
| |
| no_of_cpus=$(tst_ncpus) |
| # not sure whether cpu's can't be in odd number |
| run_on_cpu=$(($((no_of_cpus+1))/2)) |
| numactl --physcpubind=$run_on_cpu support_numa pause & #just waits for sigint |
| pid=$! |
| var=`awk '{ print $2 }' /proc/$pid/stat` |
| while [ $var = '(numactl)' ]; do |
| var=`awk '{ print $2 }' /proc/$pid/stat` |
| tst_sleep 100ms |
| done |
| # Warning !! 39 represents cpu number, on which process pid is currently running and |
| # this may change if Some more fields are added in the middle, may be in future |
| running_on_cpu=$(awk '{ print $39; }' /proc/$pid/stat) |
| if [ $running_on_cpu -ne $run_on_cpu ]; then |
| tst_res TFAIL \ |
| "Process running on cpu$running_on_cpu but expected to run on cpu$run_on_cpu" |
| ROD kill -INT $pid |
| return |
| fi |
| |
| ROD kill -INT $pid |
| |
| tst_res TPASS "NUMA phycpubind policy" |
| } |
| |
| # Verification of local node allocation |
| test7() |
| { |
| Mem_curr=0 |
| |
| for node in $nodes_list; do |
| numactl --cpunodebind=$node --localalloc support_numa alloc_1MB & |
| pid=$! |
| |
| TST_RETRY_FUNC "check_for_support_numa $pid" 0 |
| |
| Mem_curr=$(echo "$(extract_numastat_p $pid $node) * $MB" |bc) |
| if [ $(echo "$Mem_curr < $MB" |bc ) -eq 1 ]; then |
| tst_res TFAIL \ |
| "NUMA localnode memory allocated in node$node is less than expected" |
| kill -CONT $pid >/dev/null 2>&1 |
| return |
| fi |
| |
| kill -CONT $pid >/dev/null 2>&1 |
| done |
| |
| tst_res TPASS "NUMA local node allocation" |
| } |
| |
| check_ltp_numa_test8_log() |
| { |
| grep -m1 -q '.' ltp_numa_test8.log |
| } |
| |
| # Verification of memhog with interleave policy |
| test8() |
| { |
| Mem_curr=0 |
| # Memory will be allocated using round robin on nodes. |
| Exp_incr=$(echo "$MB / $total_nodes" |bc) |
| |
| numactl --interleave=all memhog -r1000000 1MB >ltp_numa_test8.log 2>&1 & |
| pid=$! |
| |
| TST_RETRY_FUNC "check_ltp_numa_test8_log" 0 |
| |
| for node in $nodes_list; do |
| Mem_curr=$(echo "$(extract_numastat_p $pid $node) * $MB" |bc) |
| |
| if [ $(echo "$Mem_curr < $Exp_incr" |bc ) -eq 1 ]; then |
| tst_res TFAIL \ |
| "NUMA interleave memhog in node$node is less than expected" |
| kill -KILL $pid >/dev/null 2>&1 |
| return |
| fi |
| done |
| |
| kill -KILL $pid >/dev/null 2>&1 |
| tst_res TPASS "NUMA MEMHOG policy" |
| } |
| |
| # Function: hardware cheking with numa_node_size api |
| # |
| # Description: - Returns the size of available nodes if success. |
| # |
| # Input: - o/p of numactl --hardware command which is expected in the format |
| # shown below |
| # available: 2 nodes (0-1) |
| # node 0 size: 7808 MB |
| # node 0 free: 7457 MB |
| # node 1 size: 5807 MB |
| # node 1 free: 5731 MB |
| # node distances: |
| # node 0 1 |
| # 0: 10 20 |
| # 1: 20 10 |
| # |
| test9() |
| { |
| RC=0 |
| |
| numactl --hardware > gavail_nodes |
| RC=$(awk '{ if ( NR == 1 ) {print $1;} }' gavail_nodes) |
| if [ $RC = "available:" ]; then |
| RC=$(awk '{ if ( NR == 1 ) {print $3;} }' gavail_nodes) |
| if [ $RC = "nodes" ]; then |
| RC=$(awk '{ if ( NR == 1 ) {print $2;} }' gavail_nodes) |
| tst_res TPASS "NUMA policy on lib NUMA_NODE_SIZE API" |
| else |
| tst_res TFAIL "Failed with numa policy" |
| fi |
| else |
| tst_res TFAIL "Failed with numa policy" |
| fi |
| } |
| |
| # Verification of migratepages |
| test10() |
| { |
| Mem_curr=0 |
| COUNTER=1 |
| |
| for node in $nodes_list; do |
| |
| if [ $COUNTER -eq $total_nodes ]; then |
| Preferred_node=$(echo $nodes_list | cut -d ' ' -f 1) |
| else |
| Preferred_node=$(echo $nodes_list | cut -d ' ' -f $((COUNTER+1))) |
| fi |
| |
| numactl --preferred=$node support_numa alloc_1MB & |
| pid=$! |
| |
| TST_RETRY_FUNC "check_for_support_numa $pid" 0 |
| |
| migratepages $pid $node $Preferred_node |
| |
| Mem_curr=$(echo "$(extract_numastat_p $pid $Preferred_node) * $MB" |bc) |
| if [ $(echo "$Mem_curr < $MB" |bc ) -eq 1 ]; then |
| tst_res TFAIL \ |
| "NUMA migratepages is not working fine" |
| kill -CONT $pid >/dev/null 2>&1 |
| return |
| fi |
| |
| COUNTER=$((COUNTER+1)) |
| kill -CONT $pid >/dev/null 2>&1 |
| done |
| |
| tst_res TPASS "NUMA MIGRATEPAGES policy" |
| } |
| |
| # Verification of hugepage memory allocated on a node |
| test11() |
| { |
| Mem_huge=0 |
| Sys_node=/sys/devices/system/node |
| |
| if [ ! -d "/sys/kernel/mm/hugepages/" ]; then |
| tst_res TCONF "hugepage is not supported" |
| return |
| fi |
| |
| for node in $nodes_list; do |
| Ori_hpgs=$(cat ${Sys_node}/node${node}/hugepages/hugepages-${HPAGE_SIZE}kB/nr_hugepages) |
| New_hpgs=$((Ori_hpgs + 1)) |
| echo $New_hpgs >${Sys_node}/node${node}/hugepages/hugepages-${HPAGE_SIZE}kB/nr_hugepages |
| |
| Chk_hpgs=$(cat ${Sys_node}/node${node}/hugepages/hugepages-${HPAGE_SIZE}kB/nr_hugepages) |
| if [ "$Chk_hpgs" -ne "$New_hpgs" ]; then |
| tst_res TCONF "hugepage is not enough to test" |
| return |
| fi |
| |
| numactl --cpunodebind=$node --membind=$node support_numa alloc_1huge_page & |
| pid=$! |
| TST_RETRY_FUNC "check_for_support_numa $pid" 0 |
| |
| Mem_huge=$(echo $(numastat -p $pid |awk '/^Huge/ {print $'$((node+2))'}')) |
| Mem_huge=$((${Mem_huge%.*} * 1024)) |
| |
| if [ "$Mem_huge" -lt "$HPAGE_SIZE" ]; then |
| tst_res TFAIL \ |
| "NUMA memory allocated in node$node is less than expected" |
| kill -CONT $pid >/dev/null 2>&1 |
| echo $Ori_hpgs >${Sys_node}/node${node}/hugepages/hugepages-${HPAGE_SIZE}kB/nr_hugepages |
| return |
| fi |
| |
| kill -CONT $pid >/dev/null 2>&1 |
| echo $Ori_hpgs >${Sys_node}/node${node}/hugepages/hugepages-${HPAGE_SIZE}kB/nr_hugepages |
| done |
| |
| tst_res TPASS "NUMA local node hugepage memory allocated" |
| } |
| |
| # Verification of THP memory allocated on preferred node |
| test12() |
| { |
| Mem_curr=0 |
| |
| if ! grep -q '\[always\]' /sys/kernel/mm/transparent_hugepage/enabled; then |
| tst_res TCONF "THP is not supported/enabled" |
| return |
| fi |
| |
| COUNTER=1 |
| for node in $nodes_list; do |
| |
| if [ $COUNTER -eq $total_nodes ]; then #wrap up for last node |
| Preferred_node=$(echo $nodes_list | cut -d ' ' -f 1) |
| else |
| # always next node is preferred node |
| Preferred_node=$(echo $nodes_list | cut -d ' ' -f $((COUNTER+1))) |
| fi |
| |
| numactl --cpunodebind=$node --preferred=$Preferred_node support_numa alloc_2HPSZ_THP & |
| pid=$! |
| |
| TST_RETRY_FUNC "check_for_support_numa $pid" 0 |
| |
| Mem_curr=$(echo "$(extract_numastat_p $pid $Preferred_node) * 1024" |bc) |
| if [ $(echo "$Mem_curr < $HPAGE_SIZE * 2" |bc ) -eq 1 ]; then |
| tst_res TFAIL \ |
| "NUMA memory allocated in node$Preferred_node is less than expected" |
| kill -CONT $pid >/dev/null 2>&1 |
| return |
| fi |
| |
| COUNTER=$((COUNTER+1)) |
| kill -CONT $pid >/dev/null 2>&1 |
| done |
| |
| tst_res TPASS "NUMA preferred node policy verified with THP enabled" |
| } |
| |
| tst_run |
