Makefile

@@ -56,6 +56,7 @@ endif
 # Run package-level unit tests
 .PHONY: test
 test:
+	@echo "Running unit tests..."
 	go test -v ./...
 
 .PHONY: update-deps
@@ -91,26 +92,41 @@ check_static:
 
 .PHONY: check_license
 check_license:
-	@echo "Checking license headers..."
+	@echo "Confirming source files have license headers..."
 	@for f in `find . -type f ! -path './perfspect_202*' ! -path './tools/bin/*' ! -path './internal/script/resources/*' ! -path './scripts/.venv/*' ! -path './test/output/*' ! -path './debug_out/*' \( -name "*.go" -o -name "*.s" -o -name "*.html" -o -name "Makefile" -o -name "*.sh" -o -name "*.Dockerfile" -o -name "*.py" \)`; do \
 		if ! grep -E 'Copyright \(C\) [0-9]{4}-[0-9]{4} Intel Corporation' "$$f" >/dev/null; then echo "Error: license not found: $$f"; fail=1; fi; \
 	done; if [ -n "$$fail" ]; then exit 1; fi
 
 .PHONY: check_lint
 check_lint:
-	@echo "Running golangci-lint..."
+	@echo "Running golangci-lint to check for style issues..."
 	go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest
 	golangci-lint run
 
+.PHONY: check_modernize
+check_modernize:
+	@echo "Running go-modernize to check for modernization opportunities..."
+	go run golang.org/x/tools/gopls/internal/analysis/modernize/cmd/modernize@latest -test ./...
+
+.PHONY: modernize
+modernize:
+	@echo "Running go-modernize to apply modernization opportunities..."
+	go run golang.org/x/tools/gopls/internal/analysis/modernize/cmd/modernize@latest -fix -test ./...
+
 .PHONY: check
-check: check_format check_vet check_static check_license check_lint
+check: check_format check_vet check_static check_license check_lint check_modernize
+
+.PHONY: sweep
+sweep:
+	rm -rf perfspect_2025-*
+	rm -rf debug_out/*
+	rm -rf test/output
+	rm -f __debug_bin*.log
+	rm -f perfspect.log
 
 .PHONY: clean
-clean:
+clean: sweep
 	@echo "Cleaning up..."
 	rm -f perfspect
 	sudo rm -rf dist
 	rm -rf internal/script/resources/x86_64/*
-	rm -rf perfspect_2024-*
-	rm -rf debug_out/*
-	rm -rf test/output

README.md

@@ -77,7 +77,7 @@ To assist in evaluating the health of target systems, the `report` command can r
 | --------- | ----------- |
 | all | runs all benchmarks |
 | speed | runs each [stress-ng](https://github.com/ColinIanKing/stress-ng) cpu-method for 1s each, reports the geo-metric mean of all results. |
-| power | runs stress-ng in two stages: 1) load 1 cpu to 100% for 20s to measure maximum frequency, 2) load all cpus to 100% for 60s. Uses [turbostat](https://github.com/torvalds/linux/tree/master/tools/power/x86/turbostat) to measure power. |
+| power | runs stress-ng to load all cpus to 100% for 60s. Uses [turbostat](https://github.com/torvalds/linux/tree/master/tools/power/x86/turbostat) to measure power. |
 | temperature | runs the same micro benchmark as 'power', but extracts maximum temperature from turbostat output. |
 | frequency | runs [avx-turbo](https://github.com/travisdowns/avx-turbo) to measure scalar and AVX frequencies across processor's cores. **Note:** Runtime increases with core count.  |
 | memory | runs [Intel(r) Memory Latency Checker](https://www.intel.com/content/www/us/en/download/736633/intel-memory-latency-checker-intel-mlc.html) (MLC) to measure memory bandwidth and latency across a load range. **Note: MLC is not included with PerfSpect.** It can be downloaded from [here](https://www.intel.com/content/www/us/en/download/736633/intel-memory-latency-checker-intel-mlc.html). Once downloaded, extract the Linux executable and place it in the perfspect/tools/x86_64 directory. |

build.Dockerfile

@@ -4,10 +4,10 @@
 # image contains build environment for the application
 # build the image (from repo root directory): 
 #    $ docker image build -f build.Dockerfile --tag perfspect-builder:v1 .
-# build the svr-info Go components using this image
+# build the perfspect Go components using this image
 #    $ docker run --rm -v "$PWD":/workdir -w /workdir perfspect-builder:v1 make dist
 
-FROM golang:1.23@sha256:ad5c126b5cf501a8caef751a243bb717ec204ab1aa56dc41dc11be089fafcb4f
+FROM golang:1.24.1@sha256:af0bb3052d6700e1bc70a37bca483dc8d76994fd16ae441ad72390eea6016d03
 WORKDIR /workdir
 # pre-copy/cache go.mod for pre-downloading dependencies and only redownloading them in subsequent builds if they change
 COPY go.mod go.sum ./

builder/build.Dockerfile

@@ -1,19 +1,19 @@
 # Copyright (C) 2021-2024 Intel Corporation
 # SPDX-License-Identifier: BSD-3-Clause
 
-# image contains svr-info release package build environment
+# image contains perfspect release package build environment
 # build image:
-#   $ docker build --build-arg TAG=v1 -f builder/build.Dockerfile --tag svr-info-builder:v1 .
-# build svr-info:
-#   $ docker run --rm -v "$PWD":/localrepo -w /localrepo svr-info-builder:v1 make dist
+#   $ docker build --build-arg TAG=v1 -f builder/build.Dockerfile --tag perfspect-builder:v1 .
+# build perfspect:
+#   $ docker run --rm -v "$PWD":/localrepo -w /localrepo perfspect-builder:v1 make dist
 
 ARG REGISTRY=
 ARG PREFIX=
 ARG TAG=
 # STAGE 1 - image contains pre-built tools components, rebuild the image to rebuild the tools components
 FROM ${REGISTRY}${PREFIX}perfspect-tools:${TAG} AS tools
 
-# STAGE 2 - image contains svr-info's Go components build environment
+# STAGE 2 - image contains perfspect's Go components build environment
 FROM ${REGISTRY}${PREFIX}perfspect-builder:${TAG} AS perfspect
 RUN mkdir /prebuilt
 RUN mkdir /prebuilt/tools

cmd/config/config.go

@@ -14,8 +14,8 @@ import (
 	"perfspect/internal/report"
 	"perfspect/internal/script"
 	"perfspect/internal/target"
-	"perfspect/internal/util"
 	"regexp"
+	"slices"
 	"strconv"
 	"strings"
 
@@ -222,19 +222,24 @@ func validateFlags(cmd *cobra.Command, args []string) error {
 	if cmd.Flags().Lookup(flagEppName).Changed && (flagEpp < 0 || flagEpp > 255) {
 		return fmt.Errorf("invalid epp: %d", flagEpp)
 	}
-	if cmd.Flags().Lookup(flagGovernorName).Changed && !util.StringInList(flagGovernor, governorOptions) {
+	if cmd.Flags().Lookup(flagGovernorName).Changed && !slices.Contains(governorOptions, flagGovernor) {
 		return fmt.Errorf("invalid governor: %s", flagGovernor)
 	}
-	if cmd.Flags().Lookup(flagElcName).Changed && !util.StringInList(flagElc, elcOptions) {
+	if cmd.Flags().Lookup(flagElcName).Changed && !slices.Contains(elcOptions, flagElc) {
 		return fmt.Errorf("invalid elc mode: %s", flagElc)
 	}
+	// common target flags
+	if err := common.ValidateTargetFlags(cmd); err != nil {
+		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+		return err
+	}
 	return nil
 }
 
 func runCmd(cmd *cobra.Command, args []string) error {
 	// appContext is the application context that holds common data and resources.
-	appContext := cmd.Context().Value(common.AppContext{}).(common.AppContext)
-	localTempDir := appContext.TempDir
+	appContext := cmd.Parent().Context().Value(common.AppContext{}).(common.AppContext)
+	localTempDir := appContext.LocalTempDir
 	// get the targets
 	myTargets, targetErrs, err := common.GetTargets(cmd, true, true, localTempDir)
 	if err != nil {
@@ -243,41 +248,36 @@ func runCmd(cmd *cobra.Command, args []string) error {
 		cmd.SilenceUsage = true
 		return err
 	}
-	// check for errors in target connections
-	for _, err := range targetErrs {
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
-			slog.Error(err.Error())
-			cmd.SilenceUsage = true
-			return err
+	// schedule the removal of the temp directory on each target (if the debug flag is not set)
+	if cmd.Parent().PersistentFlags().Lookup("debug").Value.String() != "true" {
+		for _, myTarget := range myTargets {
+			if myTarget.GetTempDirectory() != "" {
+				defer func() {
+					err = myTarget.RemoveTempDirectory()
+					if err != nil {
+						fmt.Fprintf(os.Stderr, "Failed to remove target temp directory: %+v\n", err)
+						slog.Error(err.Error())
+					}
+				}()
+			}
+		}
+	}
+	// check for errors in target creation
+	for i := range targetErrs {
+		if targetErrs[i] != nil {
+			fmt.Fprintf(os.Stderr, "Error: target: %s, %v\n", myTargets[i].GetName(), targetErrs[i])
+			slog.Error(targetErrs[i].Error())
+			// remove target from targets list
+			myTargets = slices.Delete(myTargets, i, i+1)
 		}
 	}
 	if len(myTargets) == 0 {
-		err := fmt.Errorf("no targets specified")
+		err := fmt.Errorf("no targets remain")
 		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
 		slog.Error(err.Error())
 		cmd.SilenceUsage = true
 		return err
 	}
-	// create a temporary directory on each target
-	for _, myTarget := range myTargets {
-		targetTempRoot, _ := cmd.Flags().GetString(common.FlagTargetTempDirName)
-		targetTempDir, err := myTarget.CreateTempDirectory(targetTempRoot)
-		if err != nil {
-			err = fmt.Errorf("failed to create temporary directory: %w", err)
-			fmt.Fprintf(os.Stderr, "Error: %+v\n", err)
-			slog.Error(err.Error())
-			cmd.SilenceUsage = true
-			return err
-		}
-		defer func() {
-			err = myTarget.RemoveDirectory(targetTempDir)
-			if err != nil {
-				fmt.Fprintf(os.Stderr, "Failed to remove target directory: %+v\n", err)
-				slog.Error(err.Error())
-			}
-		}()
-	}
 	// print config prior to changes
 	if err := printConfig(myTargets, localTempDir); err != nil {
 		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
@@ -563,7 +563,7 @@ func setCoreFrequency(coreFrequency float64, myTarget target.Target, localTempDi
 	fmt.Printf("set core frequency to %.1f GHz on %s\n", coreFrequency, myTarget.GetName())
 	freqInt := uint64(coreFrequency * 10)
 	var msr uint64
-	for i := 0; i < 8; i++ {
+	for i := range 8 {
 		msr = msr | freqInt<<uint(i*8)
 	}
 	setScript := script.ScriptDefinition{
@@ -626,7 +626,7 @@ func setUncoreDieFrequency(maxFreq bool, computeDie bool, uncoreFrequency float6
 		return
 	}
 	re := regexp.MustCompile(`Read bits \d+:\d+ value (\d+) from TPMI ID .* for entry (\d+) in instance (\d+)`)
-	for _, line := range strings.Split(outputs[script.UncoreDieTypesFromTPMIScriptName].Stdout, "\n") {
+	for line := range strings.SplitSeq(outputs[script.UncoreDieTypesFromTPMIScriptName].Stdout, "\n") {
 		match := re.FindStringSubmatch(line)
 		if match == nil {
 			continue

cmd/flame/flame.go

@@ -10,7 +10,7 @@ import (
 	"perfspect/internal/common"
 	"perfspect/internal/report"
 	"perfspect/internal/script"
-	"perfspect/internal/util"
+	"slices"
 	"strings"
 
 	"github.com/spf13/cobra"
@@ -121,7 +121,7 @@ func validateFlags(cmd *cobra.Command, args []string) error {
 	// validate format options
 	for _, format := range common.FlagFormat {
 		formatOptions := append([]string{report.FormatAll}, report.FormatHtml, report.FormatTxt, report.FormatJson)
-		if !util.StringInList(format, formatOptions) {
+		if !slices.Contains(formatOptions, format) {
 			err := fmt.Errorf("format options are: %s", strings.Join(formatOptions, ", "))
 			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
 			return err
@@ -132,6 +132,11 @@ func validateFlags(cmd *cobra.Command, args []string) error {
 		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
 		return err
 	}
+	// common target flags
+	if err := common.ValidateTargetFlags(cmd); err != nil {
+		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+		return err
+	}
 	return nil
 }
 

cmd/lock/lock.go

@@ -109,6 +109,11 @@ func validateFlags(cmd *cobra.Command, args []string) error {
 		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
 		return err
 	}
+	// common target flags
+	if err := common.ValidateTargetFlags(cmd); err != nil {
+		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+		return err
+	}
 	return nil
 }
 

cmd/metrics/event_defs.go

@@ -12,8 +12,8 @@ import (
 	"log/slog"
 	"os"
 	"path/filepath"
-	"perfspect/internal/util"
 	"regexp"
+	"slices"
 	"strings"
 
 	mapset "github.com/deckarep/golang-set/v2"
@@ -134,7 +134,7 @@ func isCollectableEvent(event EventDefinition, metadata Metadata) bool {
 	}
 	// PEBS events (not supported on GCP c4 VMs)
 	pebsEventNames := []string{"INT_MISC.UNKNOWN_BRANCH_CYCLES", "UOPS_RETIRED.MS"}
-	if !metadata.SupportsPEBS && util.StringInList(event.Name, pebsEventNames) {
+	if !metadata.SupportsPEBS && slices.Contains(pebsEventNames, event.Name) {
 		slog.Debug("PEBS events not supported on target", slog.String("event", event.Name))
 		return false
 	}
@@ -260,7 +260,7 @@ func expandUncoreGroups(groups []GroupDefinition, metadata Metadata) (expandedGr
 	}
 	for _, group := range groups {
 		device := group[0].Device
-		if util.StringInList(device, deviceTypes) {
+		if slices.Contains(deviceTypes, device) {
 			var newGroups []GroupDefinition
 			if len(metadata.UncoreDeviceIDs[device]) == 0 {
 				slog.Warn("No uncore devices found", slog.String("type", device))

cmd/metrics/event_frame.go

@@ -10,12 +10,9 @@ import (
 	"fmt"
 	"log/slog"
 	"math"
+	"slices"
 	"strconv"
 	"strings"
-
-	"perfspect/internal/util"
-
-	"golang.org/x/exp/slices"
 )
 
 // EventGroup represents a group of perf events and their values
@@ -160,7 +157,7 @@ func coalesceEvents(allEvents []Event, scope string, granularity string, metadat
 		} else if granularity == granularitySocket {
 			// create one list of Events per Socket
 			newEvents := make([][]Event, metadata.SocketCount)
-			for i := 0; i < metadata.SocketCount; i++ {
+			for i := range metadata.SocketCount {
 				newEvents[i] = make([]Event, 0, len(allEvents)/metadata.SocketCount)
 			}
 			// incoming events are labeled with cpu number
@@ -202,7 +199,7 @@ func coalesceEvents(allEvents []Event, scope string, granularity string, metadat
 			// note: if some cores have been off-lined, this may cause an issue because 'perf' seems
 			// to still report events for those cores
 			newEvents := make([][]Event, numCPUs)
-			for i := 0; i < numCPUs; i++ {
+			for i := range numCPUs {
 				newEvents[i] = make([]Event, 0, len(allEvents)/numCPUs)
 			}
 			for _, event := range allEvents {
@@ -213,7 +210,7 @@ func coalesceEvents(allEvents []Event, scope string, granularity string, metadat
 				// handle case where perf returns events for off-lined cores
 				if cpu > len(newEvents)-1 {
 					cpusToAdd := len(newEvents) + 1 - cpu
-					for i := 0; i < cpusToAdd; i++ {
+					for range cpusToAdd {
 						newEvents = append(newEvents, make([]Event, 0, len(allEvents)/numCPUs))
 					}
 				}
@@ -233,7 +230,7 @@ func coalesceEvents(allEvents []Event, scope string, granularity string, metadat
 		var cgroups []string
 		for _, event := range allEvents {
 			var cgroupIdx int
-			if cgroupIdx, err = util.StringIndexInList(event.Cgroup, cgroups); err != nil {
+			if cgroupIdx = slices.Index(cgroups, event.Cgroup); cgroupIdx == -1 {
 				cgroups = append(cgroups, event.Cgroup)
 				cgroupIdx = len(cgroups) - 1
 				allCgroupEvents = append(allCgroupEvents, []Event{})

cmd/metrics/metadata.go

@@ -405,7 +405,7 @@ func getCPUInfo(myTarget target.Target) (cpuInfo []map[string]string, err error)
 		return
 	}
 	oneCPUInfo := make(map[string]string)
-	for _, line := range strings.Split(stdout, "\n") {
+	for line := range strings.SplitSeq(stdout, "\n") {
 		fields := strings.Split(line, ":")
 		if len(fields) < 2 {
 			if len(oneCPUInfo) > 0 {
@@ -560,7 +560,7 @@ func getSupportsFixedEvent(myTarget target.Target, event string, uarch string, n
 		return
 	}
 	var eventList []string
-	for i := 0; i < numGPCounters; i++ {
+	for range numGPCounters {
 		eventList = append(eventList, event)
 	}
 	scriptDef := script.ScriptDefinition{
@@ -580,8 +580,8 @@ func getSupportsFixedEvent(myTarget target.Target, event string, uarch string, n
 		return
 	}
 	// on some VMs we get a count of 0
-	lines := strings.Split(output, "\n")
-	for _, line := range lines {
+	lines := strings.SplitSeq(output, "\n")
+	for line := range lines {
 		tokens := strings.Fields(line)
 		if len(tokens) == 2 && tokens[0] == "0" {
 			supported = false
@@ -656,7 +656,7 @@ func createCPUSocketMap(coresPerSocket int, sockets int, hyperthreading bool) (c
 		totalCPUs *= 2 // hyperthreading doubles the number of logical CPUs
 	}
 	// Assign each CPU to a socket
-	for i := 0; i < totalCPUs; i++ {
+	for i := range totalCPUs {
 		// Assume that the CPUs are evenly distributed between the sockets
 		socket := i / coresPerSocket
 		if hyperthreading {