# 使用smartctl直接查询即可
smartctl -a /dev/sdX

# 可以增加grep快速筛选想要查询的参数，在替换双引号中的即可
smartctl -a /dev/sdX | grep -E "Elements in grown defect list"

# 配合for迅速遍历磁盘，{a..z}则是遍历sda到sdz的所有盘
# 如果盘很多那可以直接写为{a..zz}，则是遍历sda到sdzz共702个盘
# [ -b "/dev/sd$i" ] test命令的简写，判断该设备是不是一个硬盘
# echo "sd$i"是在输出日志前输出盘号，避免不知道是哪个盘的报错
for i in {a..z}; do [ -b "/dev/sd$i" ] && echo "sd$i:" && sudo smartctl -a "/dev/sd$i" | grep "Elements in grown defect list"; done

# 由于硬盘由阵列卡接管，所以需要调用MegaRAID驱动程序才可访问
# /dev/sdX输入你挂载到系统的阵列，例如通常/dev/sda是RAID1系统盘
# 其中megaraid,后面的数字对应该硬盘是该阵列中的第几个盘，从编号0开始是第一个
smartctl -a -d megaraid,0 /dev/sdX

# 同样的grep筛选
smartctl -a -d megaraid,0 /dev/sdX | grep -E "Non-medium error count"

# 遍历快速排查所有盘
for raid in {a..z};do [ -b "/dev/sd$raid" ] && for disk in {0..20};do echo -e "\033[36;1m阵列 sd$raid 中硬盘 $disk 日志: " && smartctl -a -d megaraid,$disk /dev/sd$raid | grep -E "Non-medium error count";done;done

# 上方命令为单行，方便复制粘贴执行，以下是拆解后可读的版本
for raid in {a..z}; do # 遍历sda到sdz的设备
    [ -b "/dev/sd$raid" ] && # 判断是不是硬盘，不是就跳过
    for disk in {0..20}; do # 预设是0到20共21个硬盘，可以自行设置
        echo -e "\033[36;1m阵列 sd$raid 中硬盘 $disk 日志: " # 打印个开头，不然不知道是哪个设备的日志
        smartctl -a -d megaraid,$disk /dev/sd$raid | grep -E "Non-medium error count" # 根据你的需要调整grep筛选的内容
    done
done

log_file="disk_error_$(date +%Y%m%d_%H%M%S).log"; for raid in {a..d}; do [ -b "/dev/sd$raid" ] && for disk in {0..23}; do smartctl -d megaraid,$disk /dev/sd$raid -i >/dev/null 2>&1 && output=$(smartctl -a -d megaraid,$disk /dev/sd$raid) && serial=$(echo "$output" | grep "Serial number:" | awk '{print $3}') && if echo "$output" | grep -q "SSD"; then reallocated_sectors=$(echo "$output" | grep "Reallocated_Sector_Ct" | awk '{print $10}'); reallocated_sectors=${reallocated_sectors:-0}; current_pending=$(echo "$output" | grep "Current_Pending_Sector" | awk '{print $10}'); current_pending=${current_pending:-0}; reported_uncorrect=$(echo "$output" | grep "Reported_Uncorrect" | awk '{print $10}'); reported_uncorrect=${reported_uncorrect:-0}; offline_uncorrect=$(echo "$output" | grep "Offline_Uncorrectable" | awk '{print $10}'); offline_uncorrect=${offline_uncorrect:-0}; crc_errors=$(echo "$output" | grep "CRC_Error_Count" | awk '{print $10}'); crc_errors=${crc_errors:-0}; [ "$reallocated_sectors" -gt 0 ] || [ "$current_pending" -gt 0 ] || [ "$reported_uncorrect" -gt 0 ] || [ "$offline_uncorrect" -gt 0 ] || [ "$crc_errors" -gt 0 ] && echo "$output" >> "$log_file" && echo -e "\033[36;1mRAID \033[32;1msd$raid \033[36;1m中的 SSD 磁盘 \033[32;1m#$disk \033[36;1m(SN:\033[33;1m $serial) 检测到异常：\033[0m\n\033[36;1m05 重分配扇区计数(Reallocated Sector Count)：\033[31;1m$reallocated_sectors\033[0m\n\033[36;1m197 当前待处理扇区(Current Pending Sector Count)：\033[31;1m$current_pending\033[0m\n\033[36;1m已报告的不可纠正错误(Reported Uncorrectable Errors)：\033[31;1m$reported_uncorrect\033[0m\n\033[36;1m离线不可纠正错误(Offline Uncorrectable)：\033[31;1m$offline_uncorrect\033[0m\n\033[36;1m接口CRC错误计数(CRC Error Count)：\033[31;1m$crc_errors\033[0m\n"; else read_uncorrected=$(echo "$output" | grep -A 10 "Error counter log:" | grep "^read:" | awk '{print $NF}'); read_uncorrected=${read_uncorrected:-0}; verify_uncorrected=$(echo "$output" | grep -A 10 "Error counter log:" | grep "^verify:" | awk '{print $NF}'); verify_uncorrected=${verify_uncorrected:-0}; total_uncorrected=$(echo "$output" | grep "Total uncorrected errors" | awk '{print $NF}'); total_uncorrected=${total_uncorrected:-0}; grown_defect_list=$(echo "$output" | grep "Elements in grown defect list" | awk '{print $NF}'); grown_defect_list=${grown_defect_list:-0}; non_medium=$(echo "$output" | grep "Non-medium error count:" | awk '{print $NF}'); non_medium=${non_medium:-0}; [ "$read_uncorrected" -gt 0 ] || [ "$verify_uncorrected" -gt 0 ] || [ "$total_uncorrected" -gt 0 ] || [ "$grown_defect_list" -gt 0 ] || [ "$non_medium" -gt 0 ] && echo "$output" >> "$log_file" && echo -e "\033[36;1mRAID \033[32;1msd$raid \033[36;1m中的 HDD 磁盘 \033[32;1m#$disk \033[36;1m(SN:\033[33;1m $serial) 检测到异常：\033[0m\n\033[36;1m读无法纠正错误(Read total uncorrected errors)：\033[31;1m$read_uncorrected\033[0m\n\033[36;1m校验无法纠正错误(Verify total uncorrected errors)：\033[31;1m$verify_uncorrected\033[0m\n\033[36;1m总无法纠正错误(Total uncorrected errors)：\033[31;1m$total_uncorrected\033[0m\n\033[36;1m已增长缺陷列表元素(Elements in grown defect list)：\033[31;1m$grown_defect_list\033[0m\n\033[36;1m非介质错误(Non-medium error count)：\033[31;1m$non_medium\033[0m\n"; fi; done; done

#!/bin/bash

# 日志文件以日期时间命名
log_file="disk_error_$(date +%Y%m%d_%H%M%S).log"

# 遍历可能的RAID设备（sda, sdb, sdc, sdd）
for raid in {a..d}; do
    if [ -b "/dev/sd$raid" ]; then
        for disk in {0..23}; do
            if smartctl -d megaraid,$disk /dev/sd$raid -i >/dev/null 2>&1; then
                output=$(smartctl -a -d megaraid,$disk /dev/sd$raid)

                serial=$(echo "$output" | grep "Serial number:" | awk '{print $3}')

                if echo "$output" | grep -q "SSD"; then
                    # ================= SSD =================
                    reallocated_sectors=$(echo "$output" | grep "Reallocated_Sector_Ct" | awk '{print $10}')
                    reallocated_sectors=${reallocated_sectors:-0}

                    current_pending=$(echo "$output" | grep "Current_Pending_Sector" | awk '{print $10}')
                    current_pending=${current_pending:-0}

                    reported_uncorrect=$(echo "$output" | grep "Reported_Uncorrect" | awk '{print $10}')
                    reported_uncorrect=${reported_uncorrect:-0}

                    offline_uncorrect=$(echo "$output" | grep "Offline_Uncorrectable" | awk '{print $10}')
                    offline_uncorrect=${offline_uncorrect:-0}

                    crc_errors=$(echo "$output" | grep "CRC_Error_Count" | awk '{print $10}')
                    crc_errors=${crc_errors:-0}

                    if [ "$reallocated_sectors" -gt 0 ] || [ "$current_pending" -gt 0 ] || \
                       [ "$reported_uncorrect" -gt 0 ] || [ "$offline_uncorrect" -gt 0 ] || [ "$crc_errors" -gt 0 ]; then
                        echo "$output" >> "$log_file"
                        echo -e "\033[36;1mRAID \033[32;1msd$raid \033[36;1m中的 SSD 磁盘 \033[32;1m#$disk \033[36;1m(SN:\033[33;1m $serial) 检测到异常：\033[0m\n"
                        echo -e "\033[36;1m05 重分配扇区计数(Reallocated Sector Count)：\033[31;1m$reallocated_sectors\033[0m"
                        echo -e "\033[36;1m197 当前待处理扇区(Current Pending Sector Count)：\033[31;1m$current_pending\033[0m"
                        echo -e "\033[36;1m已报告的不可纠正错误(Reported Uncorrectable Errors)：\033[31;1m$reported_uncorrect\033[0m"
                        echo -e "\033[36;1m离线不可纠正错误(Offline Uncorrectable)：\033[31;1m$offline_uncorrect\033[0m"
                        echo -e "\033[36;1m接口CRC错误计数(CRC Error Count)：\033[31;1m$crc_errors\033[0m\n"
                    fi
                else
                    # ================= HDD =================
                    read_uncorrected=$(echo "$output" | grep -A 10 "Error counter log:" | grep "^read:" | awk '{print $NF}')
                    read_uncorrected=${read_uncorrected:-0}

                    verify_uncorrected=$(echo "$output" | grep -A 10 "Error counter log:" | grep "^verify:" | awk '{print $NF}')
                    verify_uncorrected=${verify_uncorrected:-0}

                    total_uncorrected=$(echo "$output" | grep "Total uncorrected errors" | awk '{print $NF}')
                    total_uncorrected=${total_uncorrected:-0}

                    grown_defect_list=$(echo "$output" | grep "Elements in grown defect list" | awk '{print $NF}')
                    grown_defect_list=${grown_defect_list:-0}

                    non_medium=$(echo "$output" | grep "Non-medium error count:" | awk '{print $NF}')
                    non_medium=${non_medium:-0}

                    if [ "$read_uncorrected" -gt 0 ] || [ "$verify_uncorrected" -gt 0 ] || \
                       [ "$total_uncorrected" -gt 0 ] || [ "$grown_defect_list" -gt 0 ] || [ "$non_medium" -gt 0 ]; then
                        echo "$output" >> "$log_file"
                        echo -e "\033[36;1mRAID \033[32;1msd$raid \033[36;1m中的 HDD 磁盘 \033[32;1m#$disk \033[36;1m(SN:\033[33;1m $serial) 检测到异常：\033[0m\n"
                        echo -e "\033[36;1m读无法纠正错误(Read total uncorrected errors)：\033[31;1m$read_uncorrected\033[0m"
                        echo -e "\033[36;1m校验无法纠正错误(Verify total uncorrected errors)：\033[31;1m$verify_uncorrected\033[0m"
                        echo -e "\033[36;1m总无法纠正错误(Total uncorrected errors)：\033[31;1m$total_uncorrected\033[0m"
                        echo -e "\033[36;1m已增长缺陷列表元素(Elements in grown defect list)：\033[31;1m$grown_defect_list\033[0m"
                        echo -e "\033[36;1m非介质错误(Non-medium error count)：\033[31;1m$non_medium\033[0m\n"
                    fi
                fi
            fi
        done
    fi
done

ls -l /sys/class/block > /tmp/lsblock.txt
perccli64 /call show alilog > /tmp/target.txt
perccli64 /call/eall/sall show all > /tmp/slot.txt

# PD02的timeout
24368: YY-MM-DD HH:MM:SS WARNING:Command timeout on PD 02(e0x20/s2) Path 5000c500cdda6095, CDB: 2a 00 0f 1a ee 00 00 00 80 00
# PD09的timeout
2413: YY-MM-DD HH:MM:SS WARNING:Command timeout on PD 09(e0x20/s9) Path 5000c500cdd04681, CDB: 4d 00 4e 00 00 00 00 00 04 00

# 同时在这份日志顶部部分也输出了RAID控制器和磁盘的详情
# Device Information部分的Slot Number也对应了PD02 PD09

# raid5阵列，挂载为/dev/sdb
# 阵列中disk2存在故障
smartctl -a -d megaraid,2 /dev/sdb

# 批量查询所有阵列所有盘
# 其中a..d是用于遍历/dev/sda-d，根据你的阵列情况调整
# 其中0..10是用于遍历一个阵列下有多少个硬盘，根据你的阵列情况调整
for raid in {a..d};do for disk in {0..10};do smartctl -a -d megaraid,$disk /dev/sd$raid | grep -i "CRC\|Error";done;done

log_file="disk_error_$(date +%Y%m%d_%H%M%S).log"; for raid in {a..d}; do [ -b "/dev/sd$raid" ] && for disk in {0..23}; do smartctl -d megaraid,$disk /dev/sd$raid -i >/dev/null 2>&1 && output=$(smartctl -a -d megaraid,$disk /dev/sd$raid) && serial=$(echo "$output" | grep "Serial number:" | awk '{print $3}') && if echo "$output" | grep -q "SSD"; then reallocated_sectors=$(echo "$output" | grep "Reallocated_Sector_Ct" | awk '{print $10}'); reallocated_sectors=${reallocated_sectors:-0}; current_pending=$(echo "$output" | grep "Current_Pending_Sector" | awk '{print $10}'); current_pending=${current_pending:-0}; reported_uncorrect=$(echo "$output" | grep "Reported_Uncorrect" | awk '{print $10}'); reported_uncorrect=${reported_uncorrect:-0}; offline_uncorrect=$(echo "$output" | grep "Offline_Uncorrectable" | awk '{print $10}'); offline_uncorrect=${offline_uncorrect:-0}; crc_errors=$(echo "$output" | grep "CRC_Error_Count" | awk '{print $10}'); crc_errors=${crc_errors:-0}; [ "$reallocated_sectors" -gt 0 ] || [ "$current_pending" -gt 0 ] || [ "$reported_uncorrect" -gt 0 ] || [ "$offline_uncorrect" -gt 0 ] || [ "$crc_errors" -gt 0 ] && echo "$output" >> "$log_file" && echo -e "\033[36;1mRAID \033[32;1msd$raid \033[36;1m中的 SSD 磁盘 \033[32;1m#$disk \033[36;1m(SN:\033[33;1m $serial) 检测到异常：\033[0m\n\033[36;1m05 重分配扇区计数(Reallocated Sector Count)：\033[31;1m$reallocated_sectors\033[0m\n\033[36;1m197 当前待处理扇区(Current Pending Sector Count)：\033[31;1m$current_pending\033[0m\n\033[36;1m已报告的不可纠正错误(Reported Uncorrectable Errors)：\033[31;1m$reported_uncorrect\033[0m\n\033[36;1m离线不可纠正错误(Offline Uncorrectable)：\033[31;1m$offline_uncorrect\033[0m\n\033[36;1m接口CRC错误计数(CRC Error Count)：\033[31;1m$crc_errors\033[0m\n"; else read_uncorrected=$(echo "$output" | grep -A 10 "Error counter log:" | grep "^read:" | awk '{print $NF}'); read_uncorrected=${read_uncorrected:-0}; verify_uncorrected=$(echo "$output" | grep -A 10 "Error counter log:" | grep "^verify:" | awk '{print $NF}'); verify_uncorrected=${verify_uncorrected:-0}; total_uncorrected=$(echo "$output" | grep "Total uncorrected errors" | awk '{print $NF}'); total_uncorrected=${total_uncorrected:-0}; grown_defect_list=$(echo "$output" | grep "Elements in grown defect list" | awk '{print $NF}'); grown_defect_list=${grown_defect_list:-0}; non_medium=$(echo "$output" | grep "Non-medium error count:" | awk '{print $NF}'); non_medium=${non_medium:-0}; [ "$read_uncorrected" -gt 0 ] || [ "$verify_uncorrected" -gt 0 ] || [ "$total_uncorrected" -gt 0 ] || [ "$grown_defect_list" -gt 0 ] || [ "$non_medium" -gt 0 ] && echo "$output" >> "$log_file" && echo -e "\033[36;1mRAID \033[32;1msd$raid \033[36;1m中的 HDD 磁盘 \033[32;1m#$disk \033[36;1m(SN:\033[33;1m $serial) 检测到异常：\033[0m\n\033[36;1m读无法纠正错误(Read total uncorrected errors)：\033[31;1m$read_uncorrected\033[0m\n\033[36;1m校验无法纠正错误(Verify total uncorrected errors)：\033[31;1m$verify_uncorrected\033[0m\n\033[36;1m总无法纠正错误(Total uncorrected errors)：\033[31;1m$total_uncorrected\033[0m\n\033[36;1m已增长缺陷列表元素(Elements in grown defect list)：\033[31;1m$grown_defect_list\033[0m\n\033[36;1m非介质错误(Non-medium error count)：\033[31;1m$non_medium\033[0m\n"; fi; done; done

#!/bin/bash

# 日志文件以日期时间命名
log_file="disk_error_$(date +%Y%m%d_%H%M%S).log"

# 遍历可能的RAID设备（sda, sdb, sdc, sdd）
for raid in {a..d}; do
    if [ -b "/dev/sd$raid" ]; then
        for disk in {0..23}; do
            if smartctl -d megaraid,$disk /dev/sd$raid -i >/dev/null 2>&1; then
                output=$(smartctl -a -d megaraid,$disk /dev/sd$raid)

                serial=$(echo "$output" | grep "Serial number:" | awk '{print $3}')

                if echo "$output" | grep -q "SSD"; then
                    # ================= SSD =================
                    reallocated_sectors=$(echo "$output" | grep "Reallocated_Sector_Ct" | awk '{print $10}')
                    reallocated_sectors=${reallocated_sectors:-0}

                    current_pending=$(echo "$output" | grep "Current_Pending_Sector" | awk '{print $10}')
                    current_pending=${current_pending:-0}

                    reported_uncorrect=$(echo "$output" | grep "Reported_Uncorrect" | awk '{print $10}')
                    reported_uncorrect=${reported_uncorrect:-0}

                    offline_uncorrect=$(echo "$output" | grep "Offline_Uncorrectable" | awk '{print $10}')
                    offline_uncorrect=${offline_uncorrect:-0}

                    crc_errors=$(echo "$output" | grep "CRC_Error_Count" | awk '{print $10}')
                    crc_errors=${crc_errors:-0}

                    if [ "$reallocated_sectors" -gt 0 ] || [ "$current_pending" -gt 0 ] || \
                       [ "$reported_uncorrect" -gt 0 ] || [ "$offline_uncorrect" -gt 0 ] || [ "$crc_errors" -gt 0 ]; then
                        echo "$output" >> "$log_file"
                        echo -e "\033[36;1mRAID \033[32;1msd$raid \033[36;1m中的 SSD 磁盘 \033[32;1m#$disk \033[36;1m(SN:\033[33;1m $serial) 检测到异常：\033[0m\n"
                        echo -e "\033[36;1m05 重分配扇区计数(Reallocated Sector Count)：\033[31;1m$reallocated_sectors\033[0m"
                        echo -e "\033[36;1m197 当前待处理扇区(Current Pending Sector Count)：\033[31;1m$current_pending\033[0m"
                        echo -e "\033[36;1m已报告的不可纠正错误(Reported Uncorrectable Errors)：\033[31;1m$reported_uncorrect\033[0m"
                        echo -e "\033[36;1m离线不可纠正错误(Offline Uncorrectable)：\033[31;1m$offline_uncorrect\033[0m"
                        echo -e "\033[36;1m接口CRC错误计数(CRC Error Count)：\033[31;1m$crc_errors\033[0m\n"
                    fi
                else
                    # ================= HDD =================
                    read_uncorrected=$(echo "$output" | grep -A 10 "Error counter log:" | grep "^read:" | awk '{print $NF}')
                    read_uncorrected=${read_uncorrected:-0}

                    verify_uncorrected=$(echo "$output" | grep -A 10 "Error counter log:" | grep "^verify:" | awk '{print $NF}')
                    verify_uncorrected=${verify_uncorrected:-0}

                    total_uncorrected=$(echo "$output" | grep "Total uncorrected errors" | awk '{print $NF}')
                    total_uncorrected=${total_uncorrected:-0}

                    grown_defect_list=$(echo "$output" | grep "Elements in grown defect list" | awk '{print $NF}')
                    grown_defect_list=${grown_defect_list:-0}

                    non_medium=$(echo "$output" | grep "Non-medium error count:" | awk '{print $NF}')
                    non_medium=${non_medium:-0}

                    if [ "$read_uncorrected" -gt 0 ] || [ "$verify_uncorrected" -gt 0 ] || \
                       [ "$total_uncorrected" -gt 0 ] || [ "$grown_defect_list" -gt 0 ] || [ "$non_medium" -gt 0 ]; then
                        echo "$output" >> "$log_file"
                        echo -e "\033[36;1mRAID \033[32;1msd$raid \033[36;1m中的 HDD 磁盘 \033[32;1m#$disk \033[36;1m(SN:\033[33;1m $serial) 检测到异常：\033[0m\n"
                        echo -e "\033[36;1m读无法纠正错误(Read total uncorrected errors)：\033[31;1m$read_uncorrected\033[0m"
                        echo -e "\033[36;1m校验无法纠正错误(Verify total uncorrected errors)：\033[31;1m$verify_uncorrected\033[0m"
                        echo -e "\033[36;1m总无法纠正错误(Total uncorrected errors)：\033[31;1m$total_uncorrected\033[0m"
                        echo -e "\033[36;1m已增长缺陷列表元素(Elements in grown defect list)：\033[31;1m$grown_defect_list\033[0m"
                        echo -e "\033[36;1m非介质错误(Non-medium error count)：\033[31;1m$non_medium\033[0m\n"
                    fi
                fi
            fi
        done
    fi
done

# 批量巡检脚本 - 适用于HDD

# 遍历可能的RAID设备（sda, sdb, sdc, sdd）
for raid in {a..d}; do
    # 检查设备是否存在
    if [ -b "/dev/sd$raid" ]; then
        # 遍历每个RAID设备上的物理磁盘（0到23号）
        for disk in {0..23}; do
            # 检查磁盘是否可访问（尝试获取基本信息，输出重定向到/dev/null）
            if smartctl -d megaraid,$disk /dev/sd$raid -i >/dev/null 2>&1; then
                # 获取完整的SMART数据
                output=$(smartctl -a -d megaraid,$disk /dev/sd$raid)

                # 从输出中提取序列号
                serial=$(echo "$output" | grep "Serial number:" | awk '{print $3}')

                # 提取读取无法纠正错误次数（最后一列）
                read_uncorrected=$(echo "$output" | grep -A 10 "Error counter log:" | grep "^read:" | awk '{print $NF}')

                # 提取验证无法纠正错误次数（最后一列）
                verify_uncorrected=$(echo "$output" | grep -A 10 "Error counter log:" | grep "^verify:" | awk '{print $NF}')

                # 提取非介质错误次数（最后一列）
                non_medium=$(echo "$output" | grep "Non-medium error count:" | awk '{print $NF}')

                # 检查是否有任何错误（任一错误计数大于0）
                if [ "$read_uncorrected" -gt 0 ] || [ "$verify_uncorrected" -gt 0 ] || [ "$non_medium" -gt 0 ]; then
                    # 将有错误的磁盘完整SMART数据追加到日志文件
                    echo "$output" >> disk_error.log

                    # 输出格式化错误信息
                    echo -e "\033[36;1mRAID \033[32;1msd$raid \033[36;1m中的 Disk \033[32;1m#$disk \033[36;1m(SN:\033[33;1m $serial) \033[36;1m存在以下错误：\n"
                    echo -e "\033[36;1m读取错误无法纠正次数：\033[31;1m$read_uncorrected\033[36;1m"
                    echo -e "\033[36;1m磁盘自检无法纠错次数：\033[31;1m$verify_uncorrected\033[36;1m"
                    echo -e "\033[36;1m非介质错误次数：\033[31;1m$non_medium\033[36;1m"
                    echo -e "\n"
                fi
            fi
        done
    fi
done

# 整合为一行，一条龙服务
for raid in {a..d}; do if [ -b "/dev/sd$raid" ]; then for disk in {0..23}; do if smartctl -d megaraid,$disk /dev/sd$raid -i >/dev/null 2>&1; then output=$(smartctl -a -d megaraid,$disk /dev/sd$raid); serial=$(echo "$output" | grep "Serial number:" | awk '{print $3}'); read_uncorrected=$(echo "$output" | grep -A 10 "Error counter log:" | grep "^read:" | awk '{print $NF}'); verify_uncorrected=$(echo "$output" | grep -A 10 "Error counter log:" | grep "^verify:" | awk '{print $NF}'); non_medium=$(echo "$output" | grep "Non-medium error count:" | awk '{print $NF}'); if [ "$read_uncorrected" -gt 0 ] || [ "$verify_uncorrected" -gt 0 ] || [ "$non_medium" -gt 0 ]; then echo "$output" >> disk_error.log; echo -e "\033[36;1mRAID \033[32;1msd$raid \033[36;1m中的 Disk \033[32;1m#$disk \033[36;1m(SN:\033[33;1m $serial) \033[36;1m存在以下错误：\n"; echo -e "\033[36;1m读取错误无法纠正次数：\033[31;1m$read_uncorrected\033[36;1m"; echo -e "\033[36;1m磁盘自检无法纠错次数：\033[31;1m$verify_uncorrected\033[36;1m"; echo -e "\033[36;1m非介质错误次数：\033[31;1m$non_medium\033[36;1m"; echo -e "\n"; fi; fi; done; fi; done

# 批量巡检脚本 - 适用于SSD

# 遍历可能的RAID设备（sda, sdb, sdc, sdd）
for raid in {a..d}; do
    # 检查设备是否存在
    if [ -b "/dev/sd$raid" ]; then
        # 遍历每个RAID设备上的物理磁盘（0到23号）
        for disk in {0..23}; do
            # 检查磁盘是否可访问（尝试获取基本信息，输出重定向到/dev/null）
            if smartctl -d megaraid,$disk /dev/sd$raid -i >/dev/null 2>&1; then
                # 获取完整的SMART数据
                output=$(smartctl -a -d megaraid,$disk /dev/sd$raid)

                # 从输出中提取序列号
                serial=$(echo "$output" | grep "Serial number:" | awk '{print $3}')

                # 检测磁盘类型（SSD或HDD）
                if echo "$output" | grep -q "SSD"; then
                    # SSD磁盘：使用Media_and_Data_Integrity_Errors等属性
                    media_errors=$(echo "$output" | grep "Media_and_Data_Integrity_Errors" | awk '{print $10}')
                    media_errors=${media_errors:-0}

                    # 对于SSD，我们主要关注媒体错误和ECC错误
                    uncorrected_errors=$(echo "$output" | grep "Error_Information_Log_Entries" | awk '{print $10}')
                    uncorrected_errors=${uncorrected_errors:-0}

                    # 检查SSD错误
                    if [ "$media_errors" -gt 0 ] || [ "$uncorrected_errors" -gt 0 ]; then
                        echo "$output" >> disk_error.log
                        echo -e "\033[36;1mRAID \033[32;1msd$raid \033[36;1m中的 SSD Disk \033[32;1m#$disk \033[36;1m(SN:\033[33;1m $serial) \033[36;1m存在以下错误：\n"
                        echo -e "\033[36;1m媒体和数据完整性错误：\033[31;1m$media_errors\033[36;1m"
                        echo -e "\033[36;1m错误信息日志条目：\033[31;1m$uncorrected_errors\033[36;1m"
                        echo -e "\n"
                    fi
                else
                    # HDD磁盘：使用原有的错误计数器
                    read_uncorrected=$(echo "$output" | grep -A 10 "Error counter log:" | grep "^read:" | awk '{print $NF}')
                    read_uncorrected=${read_uncorrected:-0}

                    verify_uncorrected=$(echo "$output" | grep -A 10 "Error counter log:" | grep "^verify:" | awk '{print $NF}')
                    verify_uncorrected=${verify_uncorrected:-0}

                    non_medium=$(echo "$output" | grep "Non-medium error count:" | awk '{print $NF}')
                    non_medium=${non_medium:-0}

                    # 检查HDD错误
                    if [ "$read_uncorrected" -gt 0 ] || [ "$verify_uncorrected" -gt 0 ] || [ "$non_medium" -gt 0 ]; then
                        echo "$output" >> disk_error.log
                        echo -e "\033[36;1mRAID \033[32;1msd$raid \033[36;1m中的 HDD Disk \033[32;1m#$disk \033[36;1m(SN:\033[33;1m $serial) \033[36;1m存在以下错误：\n"
                        echo -e "\033[36;1m读取错误无法纠正次数：\033[31;1m$read_uncorrected\033[36;1m"
                        echo -e "\033[36;1m磁盘自检无法纠错次数：\033[31;1m$verify_uncorrected\033[36;1m"
                        echo -e "\033[36;1m非介质错误次数：\033[31;1m$non_medium\033[36;1m"
                        echo -e "\n"
                    fi
                fi
            fi
        done
    fi
done

# 一条龙服务
for raid in {a..d}; do if [ -b "/dev/sd$raid" ]; then for disk in {0..23}; do if smartctl -d megaraid,$disk /dev/sd$raid -i >/dev/null 2>&1; then output=$(smartctl -a -d megaraid,$disk /dev/sd$raid); serial=$(echo "$output" | grep "Serial number:" | awk '{print $3}'); if echo "$output" | grep -q "SSD"; then media_errors=$(echo "$output" | grep "Media_and_Data_Integrity_Errors" | awk '{print $10}'); media_errors=${media_errors:-0}; uncorrected_errors=$(echo "$output" | grep "Error_Information_Log_Entries" | awk '{print $10}'); uncorrected_errors=${uncorrected_errors:-0}; if [ "$media_errors" -gt 0 ] || [ "$uncorrected_errors" -gt 0 ]; then echo "$output" >> disk_error.log; echo -e "\033[36;1mRAID \033[32;1msd$raid \033[36;1m中的 SSD Disk \033[32;1m#$disk \033[36;1m(SN:\033[33;1m $serial) \033[36;1m存在以下错误：\n"; echo -e "\033[36;1m媒体和数据完整性错误：\033[31;1m$media_errors\033[36;1m"; echo -e "\033[36;1m错误信息日志条目：\033[31;1m$uncorrected_errors\033[36;1m"; echo -e "\n"; fi; else read_uncorrected=$(echo "$output" | grep -A 10 "Error counter log:" | grep "^read:" | awk '{print $NF}'); read_uncorrected=${read_uncorrected:-0}; verify_uncorrected=$(echo "$output" | grep -A 10 "Error counter log:" | grep "^verify:" | awk '{print $NF}'); verify_uncorrected=${verify_uncorrected:-0}; non_medium=$(echo "$output" | grep "Non-medium error count:" | awk '{print $NF}'); non_medium=${non_medium:-0}; if [ "$read_uncorrected" -gt 0 ] || [ "$verify_uncorrected" -gt 0 ] || [ "$non_medium" -gt 0 ]; then echo "$output" >> disk_error.log; echo -e "\033[36;1mRAID \033[32;1msd$raid \033[36;1m中的 HDD Disk \033[32;1m#$disk \033[36;1m(SN:\033[33;1m $serial) \033[36;1m存在以下错误：\n"; echo -e "\033[36;1m读取错误无法纠正次数：\033[31;1m$read_uncorrected\033[36;1m"; echo -e "\033[36;1m磁盘自检无法纠错次数：\033[31;1m$verify_uncorrected\033[36;1m"; echo -e "\033[36;1m非介质错误次数：\033[31;1m$non_medium\033[36;1m"; echo -e "\n"; fi; fi; fi; done; fi; done

fio -name=disk_benchmark -size=5G -runtime=5d -time_base -direct=1 -ioengine=libaio -randrepeat=0 -numjobs=32 -group_reporting -bs=4k -rw=randrw -rwmixwrite=30 -directory=/home/test/ -iodepth=64

# 一行代码搞定内存基准、CPU基准、存储基准的全自动测试
# 注意其中的目录和-np 24的参数根据下文内容，改为你自己的
cd /root/memtest/ && for i in {0..2};do ./stream 2>&1 | tee -a mem_$i.log;done && cd /root/hpl/bin/Linux_Intel64/ && for i in {0..2};do mpirun --allow-run-as-root -np 24 --map-by core --bind-to core ./xhpl 2>&1 | tee -a HPL_$i.out;done && cd /root/fio && ./full_auto.v2.2.0

sed -e "s|^mirrorlist=|#mirrorlist=|g" \
    -e "s|^#baseurl=http://mirror.centos.org/centos/\$releasever|baseurl=https://mirrors.tuna.tsinghua.edu.cn/centos-vault/7.9.2009|g" \
    -e "s|^#baseurl=http://mirror.centos.org/\$contentdir/\$releasever|baseurl=https://mirrors.tuna.tsinghua.edu.cn/centos-vault/7.9.2009|g" \
    -i.bak \
    /etc/yum.repos.d/CentOS-*.repo

# 启用bash扩展通配符
shopt -s extglob

# 使用通配符快速删除不带.bak的文件
rm !(*.bak) -f

# 使用for循环快速去掉.bak后缀
for f in *.bak;do mv -- "$f" "${f%.bak}";done

# 更新源
yum makecache
# 安装vim
yum install vim
# 编辑ssh配置文件
vim /etc/ssh/sshd_config
# 设置心跳
# 取消注释，设置为每60秒发送一次心跳重复9999999次
ClientAliveInterval 60
ClientAliveCountMax 99999
# 设置允许root用户登录
# 取消注释并配置为yes
PermitRootLogin yes
# 重启ssh服务
systemctl restart sshd

# 基础环境
# 安装OpenBLAS
# 安装OpenMPI
yum install -y epel-release && yum install gcc gcc-c++ gcc-gfortran cmake python3 zlib* -y && yum install -y openblas openblas-devel && yum install -y openmpi openmpi-devel

# 找到MPI的位置
find /usr -name "mpicc" 2>/dev/null
# 我的输出如下
/usr/lib64/openmpi/bin/mpicc
# 添加MPI到环境变量
echo 'export PATH=/usr/lib64/openmpi/bin:$PATH' >> ~/.bashrc
echo 'export LD_LIBRARY_PATH=/usr/lib64/openmpi/lib:$LD_LIBRARY_PATH' >> ~/.bashrc
source ~/.bashrc
# 临时生效
export PATH=/usr/lib64/openmpi/bin:$PATH
export LD_LIBRARY_PATH=/usr/lib64/openmpi/lib:$LD_LIBRARY_PATH

# 复查一下系统中有没有openblas
ldconfig -p | grep openblas
# 输出通常如下所示
libopenblas64_.so.0 (libc6,x86-64) => /lib64/libopenblas64_.so.0
libopenblas64.so.0 (libc6,x86-64) => /lib64/libopenblas64.so.0
libopenblasp64_.so.0 (libc6,x86-64) => /lib64/libopenblasp64_.so.0
libopenblasp64.so.0 (libc6,x86-64) => /lib64/libopenblasp64.so.0
libopenblasp.so.0 (libc6,x86-64) => /lib64/libopenblasp.so.0
libopenblaso64_.so.0 (libc6,x86-64) => /lib64/libopenblaso64_.so.0
libopenblaso64.so.0 (libc6,x86-64) => /lib64/libopenblaso64.so.0
libopenblaso.so.0 (libc6,x86-64) => /lib64/libopenblaso.so.0
libopenblas.so.0 (libc6,x86-64) => /lib64/libopenblas.so.0

# 下载High Performance Linpack
# 去官网检查最新版https://www.netlib.org/benchmark/hpl/
wget https://www.netlib.org/benchmark/hpl/hpl-2.3.tar.gz
tar xvf hpl-2.3.tar.gz
mv hpl-2.3 hpl
mv hpl ~/
cd ~/hpl

# 从模板创建副本并改动编译器参数
# INTEL使用Make.Linux_Intel64
# AMD使用Make.Linux_ATHLON_FBLAS
cp setup/Make.Linux_ATHLON_FBLAS ./Make.Linux_ATHLON_FBLAS
vim Make.Linux_ATHLON_FBLAS

# 64行的ARCH的名称可以自定义，但没必要，需要和文件名后缀一致，如Make.Linux_ATHLON_FBLAS
# 后续make编译时会用到，如make arch=AMD_OpenBLAS
ARCH = Linux_ATHLON_FBLAS

# 配置openblas通用开源方案，保持测试结果的中立
# 避免MKL和AOCL BLIS/LibFLAME对于INTEL AMD的专项优化
# 修改配置使HPL走CBLAS接口，而不是老的Fortran BLAS
# 在配置文件中找到
HPL_DEFS     = $(F2CDEFS) $(HPL_OPTS) $(HPL_INCLUDES)

# 在末尾加上 -DHPL_CALL_CBLAS
HPL_DEFS     = $(F2CDEFS) $(HPL_OPTS) $(HPL_INCLUDES) -DHPL_CALL_CBLAS

# 找到CCFLAGS，添加-march=native
CCFLAGS      = $(HPL_DEFS) -fomit-frame-pointer -O3 -funroll-loops -W -Wall -march=native

# 默认的配置如下
LAdir        = $(HOME)/netlib/ARCHIVES/Linux_ATHLON
LAinc        =
LAlib        = $(LAdir)/libf77blas.a $(LAdir)/libatlas.a
# 修改为
LAdir   = /usr/lib64/openblas  # 你的 OpenBLAS库路径，find / -name libopenblas*
LAinc   =
LAlib   = -lopenblas

# 改为直接使用mpicc编译
# 修改CC
CC      = mpicc

# 注释掉84-86行左右的三行MP配置
# 在前面加#注释了就行
MPdir        = /usr/local/mpi
MPinc        = -I$(MPdir)/include
MPlib        = $(MPdir)/lib/libmpich.a


# 这部分是针对Intel的编译参数设置，AMD忽略
# --------- start ---------
OMP_DEFS  = -openmp
# 改为
OMP_DEFS  = -fopenmp

CCFLAGS = CCFLAGS  = $(HPL_DEFS) -O3 -w -ansi-alias -i-static -z noexecstack -z relro -z now -nocompchk -Wall
# 修改为
CCFLAGS  = $(HPL_DEFS) -O3 -w -Wall -fopenmp -fno-strict-aliasing -march=native -z noexecstack -z relro -z now

LINKFLAGS = $(CCFLAGS) $(OMP_DEFS) -mt_mpi
#修改为
LINKFLAGS = $(CCFLAGS) $(OMP_DEFS)
# --------- end ---------

# 编译HPL
make -f Make.top build_src arch=Linux_ATHLON_FBLAS
make -f Make.top build_tst arch=Linux_ATHLON_FBLAS


# 编辑HPL.dat
cd bin/Linux_ATHLON_FBLAS
# Intel是Linux_Intel64
cd bin/Linux_Intel64

mv HPL.dat HPL.dat.bak
vim HPL.dat

# HPL.dat范例，参数及其解析详见下方表格
HPLinpack benchmark input file
Innovative Computing Laboratory, University of Tennessee
HPL.out      output file name (if any)
6            device out (6=stdout,7=stderr,file)
1            # of problems sizes (N)
165120         Ns
1            # of NBs
384           NBs
0            PMAP process mapping (0=Row-,1=Column-major)
1            # of process grids (P x Q)
8            Ps
12            Qs
16.0         threshold
1            # of panel fact
2            PFACTs (0=left, 1=Crout, 2=Right)
1            # of recursive stopping criterium
4            NBMINs (>= 1)
1            # of panels in recursion
2            NDIVs
1            # of recursive panel fact.
1            RFACTs (0=left, 1=Crout, 2=Right)
1            # of broadcast
1            BCASTs (0=1rg,1=1rM,2=2rg,3=2rM,4=Lng,5=LnM)
1            # of lookahead depth
1            DEPTHs (>=0)
2            SWAP (0=bin-exch,1=long,2=mix)
64           swapping threshold
0            L1 in (0=transposed,1=no-transposed) form
0            U  in (0=transposed,1=no-transposed) form
1            Equilibration (0=no,1=yes)
8            memory alignment in double (> 0)
##### This line (no. 32) is ignored (it serves as a separator). ######
0                               Number of additional problem sizes for PTRANS
1200 10000 30000                values of N
0                               number of additional blocking sizes for PTRANS
40 9 8 13 13 20 16 32 64        values of NB

# 禁用防火墙
systemctl stop firewalld
setenforce 0
# 开始运行
mpirun --allow-run-as-root -np 96 --map-by core --bind-to core ./xhpl

# 使用htop查看硬件负载
yum install -y htop
htop

# 测试结果范例，其中183行和190行分别是测试结果和误差，附带了注释
================================================================================
HPLinpack 2.3  --  High-Performance Linpack benchmark  --   December 2, 2018
Written by A. Petitet and R. Clint Whaley,  Innovative Computing Laboratory, UTK
Modified by Piotr Luszczek, Innovative Computing Laboratory, UTK
Modified by Julien Langou, University of Colorado Denver
================================================================================

An explanation of the input/output parameters follows:
T/V    : Wall time / encoded variant.
N      : The order of the coefficient matrix A.
NB     : The partitioning blocking factor.
P      : The number of process rows.
Q      : The number of process columns.
Time   : Time in seconds to solve the linear system.
Gflops : Rate of execution for solving the linear system.

The following parameter values will be used:

N      :  165120
NB     :     384
PMAP   : Row-major process mapping
P      :       8
Q      :      12
PFACT  :   Right
NBMIN  :       4
NDIV   :       2
RFACT  :   Crout
BCAST  :  1ringM
DEPTH  :       1
SWAP   : Mix (threshold = 64)
L1     : transposed form
U      : transposed form
EQUIL  : yes
ALIGN  : 8 double precision words

--------------------------------------------------------------------------------

- The matrix A is randomly generated for each test.
- The following scaled residual check will be computed:
      ||Ax-b||_oo / ( eps * ( || x ||_oo * || A ||_oo + || b ||_oo ) * N )
- The relative machine precision (eps) is taken to be               1.110223e-16
- Computational tests pass if scaled residuals are less than                16.0

================================================================================
T/V                N    NB     P     Q               Time                 Gflops
--------------------------------------------------------------------------------
WR11C2R4      165120   384     8    12            1755.82             1.7094e+03
# 这里的1.7094e+03也就是1.7094*10^3 Gflops=1709.4GFlops=1.7094TFlops
HPL_pdgesv() start time Mon Sep 15 12:53:01 2025

HPL_pdgesv() end time   Mon Sep 15 13:22:17 2025

--------------------------------------------------------------------------------
||Ax-b||_oo/(eps*(||A||_oo*||x||_oo+||b||_oo)*N)=   4.65407372e-04 ...... PASSED
# 这里的PASSED说明误差合格，测试有效
# 误差为4.65407372*10^-4=0.00046540737
================================================================================

Finished      1 tests with the following results:
              1 tests completed and passed residual checks,
              0 tests completed and failed residual checks,
              0 tests skipped because of illegal input values.
--------------------------------------------------------------------------------

End of Tests.
================================================================================

# 根据内核数量取近似的能开方的整数
# 例如96核取100开方
# 然后用核数除平方根递归直到整除
96/10=9.6
96/9=10.66
96/8=12
# PQ则为8*12
# 该网格便由8行12列组成，接近正方形，避免了过长的通信路径
# 每个进程需要将分解结果广播给其他进程，所以过长的通信路径就意味着过长的通信开销
# 如图
- - - - - - -
- - - · - - -
- - - - - - -
# 对比过长的通信路径
- - - - - - - - ·- - - - - - -

# 首先查询CPU的L3缓存
# 然后用L3缓存除以核心数，算出每个核心能使用的缓存均值
# 根据float类型占4字节，double类型占8字节计算
# 该性能测试为双精度浮点运算，取8字节
# 先计算每个核心能使用多少字节的缓存
# AMD 9A14 L3 384MB/96核心
384/96=4MB/core
4*1024*1024=4,194,304Byte/core
# 然后除以双精度的8字节，计算出每个核心处理多少个双精度浮点数，也就是NB²
4194304/8=524288NB²
# 然后开方得出NB
524288开方约为724NB
# 为了避免撑爆L3缓存，只取一半值
724/2=362/core
# 现代x86 CPU的Cache Line是固定的64字节
# 为了保证AVX/AVX-512指令能每次搬运时都尽量填满
# 所以寻找64的倍数，且尽量接近L3 Cache的极限
# 这样计算出每个核心计算大概362个NB，每次指令搬运64字节，总共搬运约6次
362/64=5.65625 取整 6
# 计算每次64字节总共6次的整数
64*6=384
# 最终得出NB最优值为384

HPLinpack benchmark input file
Innovative Computing Laboratory, University of Tennessee
HPL.out      output file name (if any)
6            device out (6=stdout,7=stderr,file)
1            # of problems sizes (N)
165120         Ns
1            # of NBs
384           NBs
0            PMAP process mapping (0=Row-,1=Column-major)
1            # of process grids (P x Q)
8            Ps
12            Qs
16.0         threshold
1            # of panel fact
2            PFACTs (0=left, 1=Crout, 2=Right)
1            # of recursive stopping criterium
4            NBMINs (>= 1)
1            # of panels in recursion
2            NDIVs
1            # of recursive panel fact.
1            RFACTs (0=left, 1=Crout, 2=Right)
1            # of broadcast
1            BCASTs (0=1rg,1=1rM,2=2rg,3=2rM,4=Lng,5=LnM)
1            # of lookahead depth
1            DEPTHs (>=0)
2            SWAP (0=bin-exch,1=long,2=mix)
64           swapping threshold
0            L1 in (0=transposed,1=no-transposed) form
0            U  in (0=transposed,1=no-transposed) form
1            Equilibration (0=no,1=yes)
8            memory alignment in double (> 0)
##### This line (no. 32) is ignored (it serves as a separator). ######
0                               Number of additional problem sizes for PTRANS
1200 10000 30000                values of N
0                               number of additional blocking sizes for PTRANS
40 9 8 13 13 20 16 32 64        values of NB

mpirun --allow-run-as-root -np 96 --map-by core --bind-to core ./xhpl
# --allow-run-as-root 允许root用户运行
# -np 96 启动96个MPI进程，与物理内核总数相同，不是线程数
# 如果你是4路每路20核那你就要填80，是所有CPU物理内核总数
# --map-by core MPI进程核CPU逻辑核心进行绑定
# --bind-to core 将每个进程锁定到core上运行，避免cache miss

# 显示的同时输出到文件，方便做为测试记录
mpirun --allow-run-as-root -np 96 --map-by core --bind-to core ./xhpl 2>&1 | tee -a HPL_0.out
# 一条命令实现运行完CPU基准后自动开始执行存储基准测试
# 在xhpl目录运行的
for i in {0..2};do mpirun --allow-run-as-root -np 96 --map-by core --bind-to core ./xhpl 2>&1 | tee -a HPL_$i.out;done && cd /root/fio/ && /root/fio/full_auto.v2.2.0

# 安装编译工具
yum install gcc -y

# 下载源码，或者复制，都行
wget https://www.cs.virginia.edu/stream/FTP/Code/stream.c

# 编译stream
# 其中-DSTREAM_ARRAY_SIZE是设置每个数组的元素数量
# 测试的内存大小 = 物理内存上限 ÷ (数组个数 × 元素字节数)
# 物理内存上限取一半值，避免打到swap，256GB × 1/2 = 128GB = 137438953472 Bytes
# 数组个数 = 4 默认测试 Triad 核心项，需 a/b/c/d 4 个数组
# 元素字节数 = 8 推荐用 double 类型，兼顾精度和硬件带宽适配
# -DSTREAM_ARRAY_SIZE = 137438953472 ÷ (4 × 8) = 137438953472 ÷ 32 = 4294967296
gcc -O3 -fopenmp -DSTREAM_ARRAY_SIZE=4294967296 stream.c -o stream
# 实际编译中这个值太大了，超过程序的限制了，取一半就行了
# -O3编译器优化 -m64强制生成64位可执行文件
# -mcmodel=medium采用64位系统的内存模型，以支持超大全局数组 -fopenmp启用多线程并行框架
# -DTYPE=double定义元素类型为double高精度 -DSTREAM_TYPE=double同步内部的流类型与DTYPE一致
# -DN=2147483648冗余安全参数，用于兼容以N作为数组大小别名的源码
gcc -O3 -fopenmp -m64 -mcmodel=medium -DSTREAM_ARRAY_SIZE=2147483648 -DTYPE=double -DSTREAM_TYPE=double -DN=2147483648 stream.c -o stream


# 运行
./stream

# 直接输出到文件
./stream >> mem_test_0.log

-------------------------------------------------------------
STREAM version $Revision: 5.10 $
-------------------------------------------------------------
This system uses 8 bytes per array element.
-------------------------------------------------------------
Array size = 100000000 (elements), Offset = 0 (elements)
Memory per array = 762.9 MiB (= 0.7 GiB).
Total memory required = 2288.8 MiB (= 2.2 GiB).
Each kernel will be executed 10 times.
 The *best* time for each kernel (excluding the first iteration)
 will be used to compute the reported bandwidth.
-------------------------------------------------------------
Number of Threads requested = 192
Number of Threads counted = 192
-------------------------------------------------------------
Your clock granularity/precision appears to be 1 microseconds.
Each test below will take on the order of 16443 microseconds.
   (= 16443 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------
Function    Best Rate MB/s  Avg time     Min time     Max time
Copy:          254046.3     0.006921     0.006298     0.011713
Scale:         189664.1     0.008491     0.008436     0.008531
Add:           204691.7     0.011839     0.011725     0.011884
Triad:         212674.9     0.011320     0.011285     0.011350
-------------------------------------------------------------
Solution Validates: avg error less than 1.000000e-13 on all three arrays
-------------------------------------------------------------

# 安装fio
yum install fio

# 准备好测试路径或硬盘
# 这里采用指向目录的方式测试
# 如需直接测试硬盘，则指向硬盘即可
# -name=本次测试的名称，自定义即可
# -size=本次测试的文件大小，建议大于内存的2倍，避免某些文件系统使用内存缓存
# 鉴于CentOS 7.9.2009的xfs和参数设置了direct=1，所以size不用大于内存
# -runtime=运行时间，单位支持秒s、分m、时h、天d
# -time_base 即使写入了指定大小的文件，依旧继续重复写入，直到runtime时间结束
# -direct=1设置不使用系统缓存，直写
# -ioengine=libaio直接使用Linux的异步IO引擎
# -randrepeat=0设置每次IO的随机性都不同，模拟真实业务场景
# -numjobs=8设置8个进程，模拟真实业务场景
# -group_reporting多进程的运行结果汇总汇报
# -bs=4k 块大小4k
# -rw=randrw随机读写
# -rwmixwrite=30设置30%写70%读，模拟真实业务场景
# -filename=/root/fio 在/root目录下创建一个名为fio的文件进行测试
# -directory=/dir/上方的filename也可替换为该命令指向目录，会在目录下根据numjobs的数量生成多个文件测试
# 注意下你的目录容量，别装不下size*numjobs的文件
# -iodepth= IO队列深度

# 运行5分钟，采用路径模式8进程写入，模拟最真实的业务场景
fio -name=disk_benchmark -size=10G -runtime=5m -time_base -direct=1 -ioengine=libaio -randrepeat=0 -numjobs=8 -group_reporting -bs=4k -rw=randrw -rwmixwrite=30 -filename=/home/fio -iodepth=1

# 1m顺序混合30%写70%读范例
fio -name=disk_benchmark -size=5G -runtime=15s -time_base -direct=1 -ioengine=libaio -numjobs=8 -group_reporting -bs=1m -rw=rw -rwmixwrite=30 -filename=/home/fio/a -iodepth=1

# 运行结果如下
# 其中第38行则是读取性能的测试结果，55行是写入的性能测试结果，附带了注释说明
disk_benchmark: (g=0): rw=randrw, bs=(R) 4096B-4096B, (W) 4096B-4096B, (T) 4096B-4096B, ioengine=libaio, iodepth=32
...
fio-3.7
Starting 8 processes
disk_benchmark: Laying out IO file (1 file / 5120MiB)
Jobs: 8 (f=8): [m(8)][100.0%][r=339MiB/s,w=144MiB/s][r=86.8k,w=36.0k IOPS][eta 00m:00s]
disk_benchmark: (groupid=0, jobs=8): err= 0: pid=64509: Tue Sep 16 15:11:50 2025
  # 读取性能的测试结果在此，记录IOPS，和MB单位的353MB/s即可
   read: IOPS=86.2k, BW=337MiB/s (353MB/s)(5053MiB/15002msec)
    slat (nsec): min=1110, max=34081k, avg=51710.15, stdev=245614.51
    clat (usec): min=229, max=36569, avg=2081.87, stdev=914.48
    # 读取延迟取lat(total latency)总延迟的值即可，统一用微秒单位
    # Windows按住Alt然后直接按小数字键盘0181即可输出µ
    # Linux则是Ctrl+Shift+U输入00b5
    # MACOS则是Option+m输出µ
     lat (usec): min=237, max=37825, avg=2133.63, stdev=947.08
    clat percentiles (usec):
     |  1.00th=[  545],  5.00th=[  816], 10.00th=[ 1106], 20.00th=[ 1401],
     | 30.00th=[ 1614], 40.00th=[ 1795], 50.00th=[ 1958], 60.00th=[ 2147],
     | 70.00th=[ 2376], 80.00th=[ 2737], 90.00th=[ 3261], 95.00th=[ 3621],
     | 99.00th=[ 4490], 99.50th=[ 4817], 99.90th=[ 5538], 99.95th=[ 5866],
     | 99.99th=[21103]
   bw (  KiB/s): min=39944, max=45384, per=12.50%, avg=43106.80, stdev=948.51, samples=240
   iops        : min= 9986, max=11346, avg=10776.67, stdev=237.13, samples=240
   # 写入性能的测试结果在此，记录IOPS，和MB单位的353MB/s即可
  write: IOPS=37.0k, BW=145MiB/s (152MB/s)(2171MiB/15002msec)
    slat (nsec): min=1470, max=17704k, avg=54444.01, stdev=241994.82
    clat (usec): min=150, max=37077, avg=1887.95, stdev=964.94
    # 写入延迟取lat(total latency)总延迟的值即可，统一用微秒单位
    # Windows按住Alt然后直接按小数字键盘0181即可输出µ
    # Linux则是Ctrl+Shift+U输入00b5
    # MACOS则是Option+m输出µ
     lat (usec): min=153, max=37080, avg=1942.46, stdev=994.98
    clat percentiles (usec):
     |  1.00th=[  400],  5.00th=[  537], 10.00th=[  676], 20.00th=[ 1156],
     | 30.00th=[ 1418], 40.00th=[ 1614], 50.00th=[ 1795], 60.00th=[ 1991],
     | 70.00th=[ 2212], 80.00th=[ 2540], 90.00th=[ 3130], 95.00th=[ 3556],
     | 99.00th=[ 4490], 99.50th=[ 4817], 99.90th=[ 5604], 99.95th=[ 5997],
     | 99.99th=[18744]
   bw (  KiB/s): min=16736, max=19920, per=12.50%, avg=18519.40, stdev=504.91, samples=240
   iops        : min= 4184, max= 4980, avg=4629.82, stdev=126.23, samples=240
  lat (usec)   : 250=0.01%, 500=1.54%, 750=4.81%, 1000=4.07%
  lat (msec)   : 2=44.46%, 4=42.71%, 10=2.39%, 20=0.01%, 50=0.01%
  cpu          : usr=1.15%, sys=8.65%, ctx=508859, majf=0, minf=268
  IO depths    : 1=0.1%, 2=0.1%, 4=0.1%, 8=0.1%, 16=0.1%, 32=100.0%, >=64=0.0%
     submit    : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
     complete  : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.1%, 64=0.0%, >=64=0.0%
     issued rwts: total=1293511,555725,0,0 short=0,0,0,0 dropped=0,0,0,0
     latency   : target=0, window=0, percentile=100.00%, depth=32

Run status group 0 (all jobs):
   READ: bw=337MiB/s (353MB/s), 337MiB/s-337MiB/s (353MB/s-353MB/s), io=5053MiB (5298MB), run=15002-15002msec
  WRITE: bw=145MiB/s (152MB/s), 145MiB/s-145MiB/s (152MB/s-152MB/s), io=2171MiB (2276MB), run=15002-15002msec

Disk stats (read/write):
    dm-2: ios=1288781/553752, merge=0/0, ticks=1713741/644122, in_queue=2391609, util=100.00%, aggrios=1293378/555710, aggrmerge=132/23, aggrticks=1658421/619009, aggrin_queue=2289296, aggrutil=99.74%
  sda: ios=1293378/555710, merge=132/23, ticks=1658421/619009, in_queue=2289296, util=99.74% # 这里的util是硬盘负载，100%负载才说明榨干了硬盘性能

# 解压下载的压缩包
tar -zxvf Geekbench-6.5.0-Linux.tar.gz

# 直接运行即可
./geekbench6

# 如果提示
/root/Geekbench-6.5.0-Linux/geekbench_avx2: /lib64/libm.so.6: version `GLIBC_2.27' not found (required by /root/Geekbench-6.5.0-Linux/geekbench_avx2)

# 系统glibc版本过低，使用旧版本GeekBench
https://cdn.geekbench.com/Geekbench-5.5.1-Linux.tar.gz

# 循环运行100次
for i in {1..100};do "hpl代码";done
# 以我的AMD 9A14为例
for i in {1..100};do mpirun --allow-run-as-root -np 96 --map-by core --bind-to core ./xhpl && echo -e "\033[36;1m第 $i 次运行完成！";done

for i in {1..1000}; do
    echo -e "\033[34;1m=== 第 $i 次运行开始 ===\033[0m"

    # 运行测试并保存输出到临时文件
    # 记得将其替换为你自己的对应命令
    mpirun --allow-run-as-root -np 96 --map-by core --bind-to core ./xhpl > hpl_run_$i.log 2>&1

    # 提取关键指标
    gflops=$(grep -A1 "T/V.*N.*NB.*P.*Q" hpl_run_$i.log | grep -v "T/V\|--" | awk '{print $NF}')
    error=$(grep "||Ax-b||_oo" hpl_run_$i.log | awk -F'= ' '{print $2}' | awk '{print $1}')
    status=$(grep "PASSED\|FAILED" hpl_run_$i.log | awk '{print $NF}')

    # 输出结果
    echo -e "Gflops: \033[32;1m$gflops\033[0m"
    echo -e "Error:  \033[33;1m$error\033[0m"
    echo -e "Status: \033[36;1m$status\033[0m"
    echo -e "\033[36;1m第 $i 次运行完成！\033[0m"
    echo ""

    # 可选：保存汇总结果到文件
    echo "运行$i, $gflops, $error, $status" >> hpl_summary.csv

    # 可选：删除临时日志文件以节省空间
    # rm hpl_run_$i.log
done

# 最终汇总统计
echo -e "\033[35;1m=== 所有运行完成 ===\033[0m"
echo "总运行次数: 1000"
echo "PASSED 次数: $(grep -c "PASSED" hpl_summary.csv)"
echo "FAILED 次数: $(grep -c "FAILED" hpl_summary.csv)"

Media Wearout Indicator: 当前值0 临界值100 - 健康
Reallocated Sector Count: 当前值0 临界值75 - 健康
Available Reservd Spare: 当前值0 临界值100 - 健康