ltp-ddt smp_basic

SMP_S_FUNC_DUAL_CORE source functions.sh;

cmd="stress-ng --matrix 4 -t 10s --perf --matrix-size 16 --metrics-brief";

run_and_capture_values "taskset -c 0 $cmd" 's/.+matrix[[:space:]]+([[:digit:]]+)[[:space:]]+.*/\1/p' single_core;

run_and_capture_values "taskset -c 0-1 $cmd" 's/.+matrix[[:space:]]+([[:digit:]]+)[[:space:]]+.*/\1/p' dual_core;

check_array_values dual_core[@] single_core[@] "-gt" 0.9

 

 

run_and_capture_values() {
    local __arrayvalues=$3
    eval $__arrayvalues="($($1 2>&1 | sed -rn $2))"
}

 

run_and_capture_values "taskset -c 0 $cmd" 's/.+matrix[[:space:]]+([[:digit:]]+)[[:space:]]+.*/\1/p' single_core;

 

local __arrayvalues=single_core

eval
$single_core="($(taskset -c 0 stress-ng --matrix 4 -t 10s --perf
--matrix-size 16 --metrics-brief 2>&1 | sed -rn
's/.+matrix[[:space:]]+([[:digit:]]+)[[:space:]]+.*/\1/p'))"

 

 

taskset -c 0 stress-ng --matrix 4 -t 10s --perf --matrix-size 16 --metrics-brief 2>&1 输出：

 

stress-ng: info:  [251] dispatching hogs: 4 matrix

stress-ng: info:  [251] cache allocate: using built-in defaults as unable to determine cache details

stress-ng: info:  [251] cache allocate: default cache size: 2048K

stress-ng: info:  [251] successful run completed in 10.32s

stress-ng: info:  [251] stressor       bogo ops real time  usr time  sys time   bogo ops/s    bogo ops/s

stress-ng: info:  [251]                                       (secs)    (secs)        (secs)      (real time)    (usr+sys time)

stress-ng: info:  [251] matrix            80157     10.04      9.93          0.21           7979.93            7905.03

stress-ng: info: [251] matrix:

stress-ng: info:  [251]                  692737288 CPU Cycles                    67.13 M/sec

stress-ng: info:  [251]                  483721828 Instructions                  46.87 M/sec (0.698 instr. per cycle)

stress-ng: info:  [251]                  167637816 Cache References              16.24 M/sec

stress-ng: info:  [251]                     361004 Cache Misses                  34.98 K/sec ( 0.22%)

stress-ng: info:  [251]                   53225292 Branch Instructions            5.16 M/sec

stress-ng: info:  [251]                    1580816 Branch Misses                  0.15 M/sec ( 2.97%)

stress-ng: info:  [251]                  346474064 Bus Cycles                   33.57 M/sec

stress-ng: info:  [251]                         16 Page Faults Minor              1.55 /sec

stress-ng: info:  [251]                          0 Page Faults Major              0.00 /sec

stress-ng: info:  [251]                        992 Context Switches              96.12 /sec

stress-ng: info:  [251]                          0 CPU Migrations                 0.00 /sec

stress-ng: info:  [251]                          0 Alignment Faults               0.00 /sec

 

sed -rn 's/.+matrix[[:space:]]+([[:digit:]]+)[[:space:]]+.*/\1/p'))"

 

-r ：sed 的动作支持的是延伸型正规表示法的语法。(默认是基础正规表示法语法)

-n ：使用安静(silent)模式。在一般 sed 的用法中，所有来自 STDIN 的数据一般都会被列出到终端上。但如果加上 -n 参数后，则只有经过sed 特殊处理的那一行(或者动作)才会被列出来。

s 替换指定字符 p 表示打印行

.+  .匹配一个非换行符的任意字符  +重复一个或一个以上前一个字符 ab+ a后面至少跟着一个b

matrix[[:space:]]+  matrix后面至少跟着一个空格

([[:digit:]]+)[[:space:]]+    ([[:digit:]]+)后面至少跟着一个空格

.* 代表零个或多个任意字符

()匹配子串，保存匹配的字符

([[:digit:]]+)表示数字 重复一个或一个以上前一个字符（数字）

\1 子串匹配标记

 

实例：

echo idyll  1984  cheung |sed -rn 's/.*+[[:space:]]+([[:digit:]]+)[[:space:]]+([[:alpha:]]+)/\1\2/p'

输出1984cheung

 

sed -rn 's/.+matrix[[:space:]]+([[:digit:]]+)[[:space:]]+.*/\1/p'

80157

 

 

 

sed命令

命令	说明
d	删除，删除选择的行
D	删除模板块的第一行
s	替换指定字符
h	拷贝模板块的内容到内存中的缓冲区
H	追加模板块的内容到内存中的缓冲区
g	获得内存缓冲区的内容，并替代当前模板块中文本
G	获得内存缓冲区的内容，并追加到当前模板块文本的后面
l	列表不能打印字符的清单
n	读取下一个输入行，用下一个命令处理新的行而不是第一个命令
N	追加下一个输入行到模板块后面并在二者间嵌入一个新行，改变当前行号码
p	打印模板块的行
P	打印模板块的第一行
q	退出sed
b label	分支到脚本中带有标记的地方，如果分支不存在则分支到脚本的末尾
r file	从file中读行
t label	if分支，从最后一行开始，条件一旦满足或者T，t命令，将导致分支到带有标号的命令处，或者到脚本的末尾
T label	错误分支，从最后一行开始，一旦发生错误或者T，t命令，将导致分支到带有标号的命令处，或者到脚本的末尾
w file	写并追加模板块到file末尾
W file	写并追加模板块的第一行到file末尾
!	表示后面的命令对所有没有被选定的行发生作用
=	打印当前行号
#	把注释扩展到第一个换行符以前

sed替换标记

 

命令	说明
g	表示行内全面替换
p	表示打印行
w	表示把行写入一个文件
x	表示互换模板块中的文本和缓冲区中的文本
y	表示把一个字符翻译为另外的字符（但是不用于正则表达式）
\1	子串匹配标记
&	已匹配字符串标记

sed元字符集

命令	说明
^	匹配行开始，如：/^sed/匹配所有以sed开头的行。
$	匹配行结束，如：/sed$/匹配所有以sed结尾的行。
.	匹配一个非换行符的任意字符，如：/s.d/匹配s后接一个任意字符，最后是d。
*	匹配0个或多个字符，如：/*sed/匹配所有模板是一个或多个空格后紧跟sed的行。
[]	匹配一个指定范围内的字符，如/[sS]ed/匹配sed和Sed。
[^]	匹配一个不在指定范围内的字符，如：/[^A-RT-Z]ed/匹配不包含A-R和T-Z的一个字母开头，紧跟ed的行。
(..)	匹配子串，保存匹配的字符，如s/(love)able/\1rs，loveable被替换成lovers。
&	保存搜索字符用来替换其他字符，如s/love/&/，love这成love。
<	匹配单词的开始，如:/<love/匹配包含以love开头的单词的行。
>	匹配单词的结束，如/love>/匹配包含以love结尾的单词的行。
x{m}	重复字符x，m次，如：/0{5}/匹配包含5个0的行。
x{m,}	重复字符x，至少m次，如：/0{5,}/匹配至少有5个0的行。
x{m,n}	重复字符x，至少m次，不多于n次，如：/0{5,10}/匹配5~10个0的行。

check_array_values dual_core[@] single_core[@] "-gt" 0.9

 

check_array_values() {
    local multiplier=1
    if [ -n "$4" ]; then
        multiplier=$4
    fi
    local old=("${!1}")
    local new=("${!2}")
    for i in "${!old[@]}"; do
        echo "Checking assertion for index $i"
    echo "->calc: \"${old[$i]}*$multiplier $3 ${new[$i]}\""
        adjusted_value=$(echo "(${old[$i]} * $multiplier)/1" | bc)
        assert [ $adjusted_value $3 ${new[$i]} ]
    done
}

 

multiplier=0.9

local old=("${!1}")  =》local old=("${!dual_core[@]}")

local new=("${!2}") =》local new=("${!single_core[@]}")

 

比较一下：

#  ${数组名}并不会获得所有值，它只会获得到第一个元素的值。即${数组名}等价于${数组名[0]}

 

dual_core=(190 100)

 

check_array_values dual_core[@] single_core[@] "-gt" 0.9

 

local old=${1} =>old=dual_core[@]  #字符串

 

echo ${old[@]}  输出：dual_core[@]

    for i in "${!old[@]}"; do
        echo "${old[$i]}"
    done
输出：dual_core[@]

 

local old=${!1} =>old=${!dual_core[@]}  #带数组下标的遍历，当需要使用到数组的下标时，可以使用${!数组名[@]}

以上理解是错误的，这个！和遍历没有关系，这个是shell脚本中的间接变量引用。

##########################################################################

间接变量引用

如果第一个变量的值是第二个变量的名字，从第一个变量引用第二个变量的值就称为间接变量应用。
variable1的值是variable2，而variable2又是变量名， variable2的值为value，间接变量引用是指通过variable1获 得变量值value的行为
variable1=variable2
variable2=value
bash shell提供了两种格式实现间接变量引用
eval tempvar=$$variable1
tempvar=${!variable1}

1. aaa=123
2. bbb=aaa
3. echo $bbb
4. echo ${!bbb}
5. 输出结果：

   aaa

   123

##############################################################################

echo ${old[@]}  输出：190 100 这是一个整体

    for i in "${!old[@]}"; do
        echo "${old[$i]}"
    done
输出：190 100

这一步比较奇怪，在函数里可以，但是在函数外，是 0 1感觉是序号。

 

local old=("${!1}") =>old=(${!dual_core[@]})=(190 100) #带数组下标的遍历 外面有（）再次成为一个数组

  echo ${old[@]}  输出：190 100 这是数组

    for i in "${!old[@]}"; do
        echo "${old[$i]}"
    done

输出：

190

100

 

 

#!/bin/bash
#数组遍历
 
days=(one two three four)
#for循环遍历
for day in ${days[*]}  #或${days[@]}
do
        echo $day
done
echo "***************"
#for循环带下标遍历 ${!days[@]}==》(0 1 2 3)
for i in ${!days[@]}
do
        echo ${days[$i]}
done

assert [ $adjusted_value $3 ${new[$i]} ] #比较大小

 

assert() {
  eval "${@}"
  if [ $? -ne 0 ]
  then
    echo "Assertion ${@} failed"
    i=0
    while caller $i
    do
      i=$((i+1))
    done
    exit 2
  fi
}

 

关于数组的操作，参考：https://www.cnblogs.com/sco1234/p/8906527.html

 

备用的test.sh

 

#!/bin/sh

dual_core=(190 100)

check_array_values() {
    #local old=${1}
    #local old=${!1}
    local old=("${!1}")
    echo ${old[@]}
    for i in "${!old[@]}"; do
        echo "${old[$i]}"
    done
}

check_array_values dual_core[@]

echo "*************"
new1=${!dual_core[@]}
echo ${new1[@]}
for i in ${!new1[@]}; do
    echo "${new1[$i]}"
done

new=("${!dual_core[@]}")
echo ${new[@]}
for i in ${!new[@]}; do
    echo "${new[$i]}"
done