Merge pull request #1 from oneclickvirt/copilot/fix-c078e406-1598-4fa9-b5bc-b525db8b3b03

feat: Add STREAM as highest priority memory test method with automatic fallback

Author: spiritLHLS

.gitignore

@@ -0,0 +1,15 @@
+# Build artifacts
+memorytest
+/cmd/cmd
+*.exe
+
+# Temporary files
+/tmp/
+
+# IDE files
+.vscode/
+.idea/
+
+# OS files
+.DS_Store
+Thumbs.db

README.md

@@ -8,14 +8,21 @@
 
 # 功能(Features)
 
-- [x] 支持使用```sysbench```测试内存的顺序读写IO
-- [x] 支持使用```dd```测试内存的读写IO
+- [x] 支持使用```stream```进行高性能内存带宽测试 (最高优先级)
+- [x] 支持使用```dd```测试内存的读写IO (可选方式)
+- [x] 支持使用```sysbench```测试内存的顺序读写IO (兜底实现)
 - [x] 支持使用```winsat```测试内存的读写性能
 - [x] 支持Go自身静态依赖注入[dd](https://github.com/oneclickvirt/dd)，使用时无额外环境依赖需求
 - [x] 以```-l```指定输出的语言类型，可指定```zh```或```en```，默认不指定时使用中文输出
-- [x] 以```-m```指定测试的方法，可指定```sysbench```或```dd```或```winsat```，默认不指定时使用```sysbench```进行测试
+- [x] 以```-m```指定测试的方法，可指定```stream```或```dd```或```sysbench```或```winsat```，默认不指定时按优先级自动选择测试方法
 - [x] 全平台编译支持，支持无权限测试时使用C重构或自编译的mbw程序模拟大内存COPY块测试内存性能
 
+## 测试方法优先级
+当不指定`-m`参数时，程序按以下优先级自动选择测试方法：
+1. **STREAM** - 如果检测到stream二进制文件，优先使用
+2. **DD** - 如果STREAM不可用，使用DD测试
+3. **Sysbench** - 作为最终的兜底实现
+
 注意：默认不自动安装```sysbench```组件，如需使用请自行安装后再使用本项目，如```apt update && apt install sysbench -y```
 
 # 使用(Usage)
@@ -48,7 +55,7 @@ Usage: memorytest [options]
   -log
         Enable logging
   -m string
-        Specific Test Method (sysbench or dd)
+        Specific Test Method (stream or dd or sysbench or winsat)
   -v    show version
 ```
 

cmd/main.go

@@ -23,7 +23,7 @@ func main() {
 	memorytestFlag.BoolVar(&help, "h", false, "Show help information")
 	memorytestFlag.BoolVar(&showVersion, "v", false, "show version")
 	memorytestFlag.StringVar(&language, "l", "", "Language parameter (en or zh)")
-	memorytestFlag.StringVar(&testMethod, "m", "", "Specific Test Method (sysbench or dd or winsat)")
+	memorytestFlag.StringVar(&testMethod, "m", "", "Specific Test Method (stream or dd or sysbench or winsat)")
 	memorytestFlag.BoolVar(&memory.EnableLoger, "log", false, "Enable logging")
 	memorytestFlag.Parse(os.Args[1:])
 	if help {
@@ -41,13 +41,21 @@ func main() {
 	} else {
 		language = strings.ToLower(language)
 	}
-	if testMethod == "" || strings.ToLower(testMethod) == "sysbench" {
-		testMethod = "sysbench"
-	} else if strings.ToLower(testMethod) == "dd" {
-		testMethod = "dd"
+	// Parse and normalize test method
+	testMethod = strings.ToLower(testMethod)
+	if testMethod == "" {
+		// Use automatic priority: stream > dd > sysbench (with mbw fallback)
+		testMethod = "auto"
 	}
 	if runtime.GOOS == "windows" {
 		switch testMethod {
+		case "stream":
+			if language == "en" {
+				res = "STREAM is not supported on Windows, using Winsat for testing.\n"
+			} else {
+				res = "Windows下不支持STREAM，使用Winsat进行测试。\n"
+			}
+			res += memory.WinsatTest(language)
 		case "dd":
 			res = memory.WindowsDDTest(language)
 			if res == "" || strings.TrimSpace(res) == "" {
@@ -66,7 +74,8 @@ func main() {
 			}
 			res += memory.WinsatTest(language)
 		default:
-			if testMethod != "winsat" && testMethod != "" {
+			// For auto or winsat or any other method
+			if testMethod != "winsat" && testMethod != "auto" {
 				if language == "en" {
 					res = "Detected host is Windows, using Winsat for testing.\n"
 				} else {
@@ -77,14 +86,39 @@ func main() {
 		}
 	} else {
 		switch testMethod {
-		case "sysbench":
-			res = memory.SysBenchTest(language)
-			if res == "" {
-				res = "sysbench test failed, switch to use dd test.\n"
+		case "stream":
+			res = memory.StreamTest(language)
+			if res == "" || strings.TrimSpace(res) == "" {
+				if language == "en" {
+					res = "STREAM test failed, switching to DD for testing.\n"
+				} else {
+					res = "STREAM测试失败，切换使用DD进行测试。\n"
+				}
 				res += memory.DDTest(language)
 			}
 		case "dd":
 			res = memory.DDTest(language)
+		case "sysbench":
+			res = memory.SysBenchTest(language)
+			if res == "" || strings.TrimSpace(res) == "" {
+				if language == "en" {
+					res = "Sysbench test failed, switching to DD for testing.\n"
+				} else {
+					res = "Sysbench测试失败，切换使用DD进行测试。\n"
+				}
+				res += memory.DDTest(language)
+			}
+		case "auto":
+			// Priority: stream > dd > sysbench (with mbw fallback built into each)
+			res = memory.StreamTest(language)
+			if res == "" || strings.TrimSpace(res) == "" {
+				// Stream failed or not available, try DD
+				res = memory.DDTest(language)
+				if res == "" || strings.TrimSpace(res) == "" {
+					// DD failed, try sysbench as final fallback
+					res = memory.SysBenchTest(language)
+				}
+			}
 		default:
 			res = "Unsupported test method"
 		}

memory/macos_linux_mem.go

@@ -484,3 +484,97 @@ func DDTest(language string) string {
 	}
 	return result
 }
+
+// StreamTest 使用 stream 进行内存测试
+func StreamTest(language string) string {
+	if EnableLoger {
+		InitLogger()
+		defer Logger.Sync()
+		Logger.Info("Running STREAM memory test")
+	}
+
+	// Try different stream binary names based on architecture
+	streamBinaries := []string{
+		"./stream-linux-amd64",
+		"./stream",
+		"stream-linux-amd64",
+		"stream",
+	}
+
+	var streamCmd string
+	for _, binary := range streamBinaries {
+		if _, err := os.Stat(binary); err == nil {
+			streamCmd = binary
+			break
+		}
+		// Also check if it's available in PATH
+		if _, err := exec.LookPath(binary); err == nil {
+			streamCmd = binary
+			break
+		}
+	}
+
+	if streamCmd == "" {
+		if EnableLoger {
+			Logger.Warn("STREAM binary not found, falling back to DD test")
+		}
+		return "" // Return empty to indicate fallback needed
+	}
+
+	// Execute STREAM test
+	cmd := exec.Command(streamCmd)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		if EnableLoger {
+			Logger.Error(fmt.Sprintf("STREAM test failed: %v", err))
+		}
+		return "" // Return empty to indicate fallback needed
+	}
+
+	// Parse STREAM output to extract the Function section
+	return parseStreamOutput(string(output), language)
+}
+
+// parseStreamOutput 解析 STREAM 输出，提取 Function 部分
+func parseStreamOutput(output, language string) string {
+	lines := strings.Split(output, "\n")
+	var result strings.Builder
+	
+	// Find the start and end of the Function section
+	inFunctionSection := false
+	functionHeaderFound := false
+	
+	for _, line := range lines {
+		// Look for the Function header line
+		if strings.Contains(line, "Function") && strings.Contains(line, "Best Rate MB/s") {
+			functionHeaderFound = true
+			inFunctionSection = true
+			result.WriteString(line)
+			result.WriteString("\n")
+			continue
+		}
+		
+		// If we found the header, keep collecting lines until we hit a line of dashes or empty line
+		if functionHeaderFound && inFunctionSection {
+			trimmedLine := strings.TrimSpace(line)
+			// Stop when we encounter the ending dashes or validation line
+			if strings.HasPrefix(trimmedLine, "---") || strings.Contains(trimmedLine, "Solution Validates") {
+				break
+			}
+			// Skip empty lines at the beginning, but include data lines
+			if trimmedLine != "" {
+				result.WriteString(line)
+				result.WriteString("\n")
+			}
+		}
+	}
+	
+	if !functionHeaderFound {
+		if EnableLoger {
+			Logger.Error("Could not parse STREAM output - Function section not found")
+		}
+		return "" // Return empty to indicate parsing failed
+	}
+	
+	return result.String()
+}

memory/stream_test.go

@@ -0,0 +1,67 @@
+package memory
+
+import (
+	"testing"
+)
+
+func TestParseStreamOutput(t *testing.T) {
+	// Sample STREAM output based on the problem statement
+	sampleOutput := `-------------------------------------------------------------
+STREAM version $Revision: 5.10 $
+-------------------------------------------------------------
+This system uses 8 bytes per array element.
+-------------------------------------------------------------
+Array size = 10000000 (elements), Offset = 0 (elements)
+Memory per array = 76.3 MiB (= 0.1 GiB).
+Total memory required = 228.9 MiB (= 0.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.
+-------------------------------------------------------------
+Your clock granularity/precision appears to be 1 microseconds.
+Each test below will take on the order of 1008115 microseconds.
+   (= 1008115 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:           21792.8     0.011733     0.007342     0.031549
+Scale:          14821.8     0.019170     0.010795     0.051002
+Add:            16917.9     0.026095     0.014186     0.058414
+Triad:          17097.8     0.024922     0.014037     0.049033
+-------------------------------------------------------------
+Solution Validates: avg error less than 1.000000e-13 on all three arrays
+-------------------------------------------------------------`
+
+	expected := `Function    Best Rate MB/s  Avg time     Min time     Max time
+Copy:           21792.8     0.011733     0.007342     0.031549
+Scale:          14821.8     0.019170     0.010795     0.051002
+Add:            16917.9     0.026095     0.014186     0.058414
+Triad:          17097.8     0.024922     0.014037     0.049033
+`
+
+	result := parseStreamOutput(sampleOutput, "en")
+	
+	if result != expected {
+		t.Errorf("parseStreamOutput failed.\nExpected:\n%s\nGot:\n%s", expected, result)
+	}
+}
+
+func TestParseStreamOutputNoFunction(t *testing.T) {
+	// Test with output that doesn't contain Function section
+	sampleOutput := `-------------------------------------------------------------
+STREAM version $Revision: 5.10 $
+-------------------------------------------------------------
+Some other output without Function section
+-------------------------------------------------------------`
+
+	result := parseStreamOutput(sampleOutput, "en")
+	
+	if result != "" {
+		t.Errorf("parseStreamOutput should return empty string for invalid output, got: %s", result)
+	}
+}