tools/src/cmd/run-cts/node/cmd.go - dawn - Git at Google

 // Copyright 2023 The Dawn & Tint Authors
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
 //
 // 1. Redistributions of source code must retain the above copyright notice, this
 //    list of conditions and the following disclaimer.
 //
 // 2. Redistributions in binary form must reproduce the above copyright notice,
 //    this list of conditions and the following disclaimer in the documentation
 //    and/or other materials provided with the distribution.
 //
 // 3. Neither the name of the copyright holder nor the names of its
 //    contributors may be used to endorse or promote products derived from
 //    this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 package node

 import (
 	"context"
 	"flag"
 	"fmt"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"runtime"
 	"strings"

 	"dawn.googlesource.com/dawn/tools/src/cmd/run-cts/common"
 	"dawn.googlesource.com/dawn/tools/src/cov"
 	"dawn.googlesource.com/dawn/tools/src/fileutils"
 	"dawn.googlesource.com/dawn/tools/src/subcmd"
 )

 type dawnFlags []string

 func (f *dawnFlags) String() string {
 	return strings.Join(*f, "")
 }

 func (f *dawnFlags) Set(value string) error {
 	// Multiple flags must be passed in individually:
 	// -flag=a=b -dawn_node_flag=c=d
 	*f = append(*f, value)
 	return nil
 }

 // Consolidates all the delimiter separated flags with a given prefix into a single flag.
 // Example:
 // Given the flags: ["foo=a", "bar", "foo=b,c"]
 // GlobListFlags("foo=", ",") will transform the flags to: ["bar", "foo=a,b,c"]
 func (f *dawnFlags) GlobListFlags(prefix string, delimiter string) {
 	list := []string{}
 	i := 0
 	for _, flag := range *f {
 		if strings.HasPrefix(flag, prefix) {
 			// Trim the prefix.
 			value := flag[len(prefix):]
 			// Extract the deliminated values.
 			list = append(list, strings.Split(value, delimiter)...)
 		} else {
 			(*f)[i] = flag
 			i++
 		}
 	}
 	(*f) = (*f)[:i]
 	if len(list) > 0 {
 		// Append back the consolidated flags.
 		f.Set(prefix + strings.Join(list, delimiter))
 	}
 }

 // defaultBinPath looks for the binary output directory at <dawn>/out/active.
 // This is used as the default for the --bin command line flag.
 func defaultBinPath() string {
 	if dawnRoot := fileutils.DawnRoot(); dawnRoot != "" {
 		bin := filepath.Join(dawnRoot, "out/active")
 		if info, err := os.Stat(bin); err == nil && info.IsDir() {
 			return bin
 		}
 	}
 	return ""
 }

 type flags struct {
 	common.Flags
 	bin                  string
 	backend              string
 	adapterName          string
 	coverageFile         string
 	isolated             bool
 	build                bool
 	validate             bool
 	dumpShaders          bool
 	fxc                  bool
 	unrollConstEvalLoops bool
 	genCoverage          bool
 	compatibilityMode    bool
 	skipVSCodeInfo       bool
 	dawn                 dawnFlags
 }

 func init() {
 	common.Register(&cmd{})
 }

 type cmd struct {
 	state    common.State
 	flags    flags
 	coverage *common.Coverage
 	query    string
 }

 func (cmd) IsDefaultCommand() {}

 func (cmd) Name() string {
 	return "node"
 }

 func (cmd) Desc() string {
 	return "runs the CTS with dawn.node"
 }

 func (c *cmd) RegisterFlags(ctx context.Context, cfg common.Config) ([]string, error) {
 	unrollConstEvalLoopsDefault := runtime.GOOS != "windows"

 	backendDefault := "default"
 	if vkIcdFilenames := os.Getenv("VK_ICD_FILENAMES"); vkIcdFilenames != "" {
 		backendDefault = "vulkan"
 	}

 	c.flags.Flags.Register()
 	flag.StringVar(&c.flags.bin, "bin", defaultBinPath(), "path to the directory holding cts.js and dawn.node")
 	flag.BoolVar(&c.flags.isolated, "isolate", false, "run each test in an isolated process")
 	flag.BoolVar(&c.flags.build, "build", true, "attempt to build the CTS before running")
 	flag.BoolVar(&c.flags.validate, "validate", false, "enable backend validation")
 	flag.Var(&c.flags.dawn, "flag", "flag to pass to dawn-node as flag=value. multiple flags must be passed in individually")
 	flag.StringVar(&c.flags.backend, "backend", backendDefault, "backend to use: default|null|webgpu|d3d11|d3d12|metal|vulkan|opengl|opengles."+
 		" set to 'vulkan' if VK_ICD_FILENAMES environment variable is set, 'default' otherwise")
 	flag.StringVar(&c.flags.adapterName, "adapter", "", "name (or substring) of the GPU adapter to use")
 	flag.BoolVar(&c.flags.dumpShaders, "dump-shaders", false, "dump WGSL shaders. Enables --verbose")
 	flag.BoolVar(&c.flags.fxc, "fxc", false, "Use FXC instead of DXC. Disables 'use_dxc' Dawn flag")
 	flag.BoolVar(&c.flags.unrollConstEvalLoops, "unroll-const-eval-loops", unrollConstEvalLoopsDefault, "unroll loops in const-eval tests")
 	flag.BoolVar(&c.flags.genCoverage, "coverage", false, "displays coverage data")
 	flag.StringVar(&c.flags.coverageFile, "export-coverage", "", "write coverage data to the given path")
 	flag.BoolVar(&c.flags.compatibilityMode, "compat", false, "run tests in compatibility mode")
 	flag.BoolVar(&c.flags.skipVSCodeInfo, "skip-vs-code-info", false, "skips emitting VS Code information")

 	return []string{"[query]"}, nil
 }

 func (c *cmd) Run(ctx context.Context, cfg common.Config) error {
 	// Process the command line flags
 	if err := c.processFlags(); err != nil {
 		return err
 	}

 	if err := c.maybeInitCoverage(); err != nil {
 		return err
 	}

 	if err := c.state.CTS.Node.BuildIfRequired(c.flags.Verbose); err != nil {
 		return err
 	}

 	// Find all the test cases that match r.query.
 	testCases, err := c.state.CTS.QueryTestCases(c.flags.Verbose, c.query)
 	if err != nil {
 		return fmt.Errorf("failed to gather tests: %w", err)
 	}
 	fmt.Printf("Testing %d test cases...\n", len(testCases))

 	var runner func(ctx context.Context, testCases []common.TestCase, results chan<- common.Result)
 	if c.flags.isolated {
 		fmt.Println("Running in parallel isolated...")
 		runner = c.runTestCasesWithCmdline
 	} else {
 		fmt.Println("Running in parallel with server...")
 		runner = c.runTestCasesWithServers
 	}

 	resultStream := make(chan common.Result, 256)
 	go func() {
 		runner(ctx, testCases, resultStream)
 		close(resultStream)
 	}()

 	results, err := common.StreamResults(ctx,
 		c.flags.Colors,
 		c.state,
 		c.flags.Verbose,
 		c.coverage,
 		len(testCases),
 		resultStream)
 	if err != nil {
 		return err
 	}

 	if err := c.state.Close(results); err != nil {
 		return err
 	}

 	return nil
 }

 func (c *cmd) processFlags() error {
 	// Check mandatory arguments
 	if c.flags.bin == "" {
 		return subcmd.InvalidCLA()
 	}
 	if !fileutils.IsDir(c.flags.bin) {
 		return fmt.Errorf("'%v' is not a directory", c.flags.bin)
 	}
 	for _, file := range []string{"cts.js", "dawn.node"} {
 		if !fileutils.IsFile(filepath.Join(c.flags.bin, file)) {
 			return fmt.Errorf("'%v' does not contain '%v'", c.flags.bin, file)
 		}
 	}

 	// Make paths absolute
 	absBin, err := filepath.Abs(c.flags.bin)
 	if err != nil {
 		return fmt.Errorf("unable to get absolute path for '%v'", c.flags.bin)
 	}
 	c.flags.bin = absBin

 	// The test query is the optional unnamed argument
 	c.query = "webgpu:*"
 	switch len(flag.Args()) {
 	case 0:
 	case 1:
 		c.query = flag.Args()[0]
 	default:
 		return fmt.Errorf("only a single query can be provided")
 	}

 	// For Windows, set the DLL directory to bin so that Dawn loads dxcompiler.dll from there.
 	c.flags.dawn.Set("dlldir=" + c.flags.bin)

 	// Forward the backend and adapter to use, if specified.
 	if c.flags.backend != "default" {
 		fmt.Println("Forcing backend to", c.flags.backend)
 		c.flags.dawn.Set("backend=" + c.flags.backend)
 	}
 	if c.flags.adapterName != "" {
 		c.flags.dawn.Set("adapter=" + c.flags.adapterName)
 	}
 	if c.flags.validate {
 		c.flags.dawn.Set("validate=1")
 	}

 	// While running the CTS, always allow unsafe APIs so they can be tested.
 	c.flags.dawn.Set("enable-dawn-features=allow_unsafe_apis")
 	if c.flags.dumpShaders {
 		c.flags.Verbose = true
 		c.flags.dawn.Set("enable-dawn-features=dump_shaders,disable_symbol_renaming")
 	}
 	if c.flags.fxc {
 		c.flags.dawn.Set("disable-dawn-features=use_dxc")
 	}
 	c.flags.dawn.GlobListFlags("enable-dawn-features=", ",")

 	state, err := c.flags.Process()
 	if err != nil {
 		return err
 	}
 	c.state = *state

 	return nil
 }

 func (c *cmd) maybeInitCoverage() error {
 	if !c.flags.genCoverage && c.flags.coverageFile == "" {
 		return nil
 	}

 	profdata, err := exec.LookPath("llvm-profdata")
 	if err != nil {
 		profdata = ""
 		if runtime.GOOS == "darwin" {
 			profdata = "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/llvm-profdata"
 			if !fileutils.IsExe(profdata) {
 				profdata = ""
 			}
 		}
 	}
 	if profdata == "" {
 		return fmt.Errorf("failed to find llvm-profdata, required for --coverage")
 	}

 	llvmCov := ""
 	turboCov := filepath.Join(c.flags.bin, "turbo-cov"+fileutils.ExeExt)
 	if !fileutils.IsExe(turboCov) {
 		turboCov = ""
 		if path, err := exec.LookPath("llvm-cov"); err == nil {
 			llvmCov = path
 		} else {
 			return fmt.Errorf("failed to find turbo-cov or llvm-cov")
 		}
 	}
 	c.coverage = &common.Coverage{
 		OutputFile: c.flags.coverageFile,
 		Env: &cov.Env{
 			Profdata: profdata,
 			Binary:   filepath.Join(c.flags.bin, "dawn.node"),
 			Cov:      llvmCov,
 			TurboCov: turboCov,
 		},
 	}

 	return nil
 }
	// Copyright 2023 The Dawn & Tint Authors
	//
	// Redistribution and use in source and binary forms, with or without
	// modification, are permitted provided that the following conditions are met:
	//
	// 1. Redistributions of source code must retain the above copyright notice, this
	// list of conditions and the following disclaimer.
	//
	// 2. Redistributions in binary form must reproduce the above copyright notice,
	// this list of conditions and the following disclaimer in the documentation
	// and/or other materials provided with the distribution.
	//
	// 3. Neither the name of the copyright holder nor the names of its
	// contributors may be used to endorse or promote products derived from
	// this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
	// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
	// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

	package node

	import (
	"context"
	"flag"
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"runtime"
	"strings"

	"dawn.googlesource.com/dawn/tools/src/cmd/run-cts/common"
	"dawn.googlesource.com/dawn/tools/src/cov"
	"dawn.googlesource.com/dawn/tools/src/fileutils"
	"dawn.googlesource.com/dawn/tools/src/subcmd"
	)

	type dawnFlags []string

	func (f *dawnFlags) String() string {
	return strings.Join(*f, "")
	}

	func (f *dawnFlags) Set(value string) error {
	// Multiple flags must be passed in individually:
	// -flag=a=b -dawn_node_flag=c=d
	f = append(f, value)
	return nil
	}

	// Consolidates all the delimiter separated flags with a given prefix into a single flag.
	// Example:
	// Given the flags: ["foo=a", "bar", "foo=b,c"]
	// GlobListFlags("foo=", ",") will transform the flags to: ["bar", "foo=a,b,c"]
	func (f *dawnFlags) GlobListFlags(prefix string, delimiter string) {
	list := []string{}
	i := 0
	for _, flag := range *f {
	if strings.HasPrefix(flag, prefix) {
	// Trim the prefix.
	value := flag[len(prefix):]
	// Extract the deliminated values.
	list = append(list, strings.Split(value, delimiter)...)
	} else {
	(*f)[i] = flag
	i++
	}
	}
	(f) = (f)[:i]
	if len(list) > 0 {
	// Append back the consolidated flags.
	f.Set(prefix + strings.Join(list, delimiter))
	}
	}

	// defaultBinPath looks for the binary output directory at <dawn>/out/active.
	// This is used as the default for the --bin command line flag.
	func defaultBinPath() string {
	if dawnRoot := fileutils.DawnRoot(); dawnRoot != "" {
	bin := filepath.Join(dawnRoot, "out/active")
	if info, err := os.Stat(bin); err == nil && info.IsDir() {
	return bin
	}
	}
	return ""
	}

	type flags struct {
	common.Flags
	bin string
	backend string
	adapterName string
	coverageFile string
	isolated bool
	build bool
	validate bool
	dumpShaders bool
	fxc bool
	unrollConstEvalLoops bool
	genCoverage bool
	compatibilityMode bool
	skipVSCodeInfo bool
	dawn dawnFlags
	}

	func init() {
	common.Register(&cmd{})
	}

	type cmd struct {
	state common.State
	flags flags
	coverage *common.Coverage
	query string
	}

	func (cmd) IsDefaultCommand() {}

	func (cmd) Name() string {
	return "node"
	}

	func (cmd) Desc() string {
	return "runs the CTS with dawn.node"
	}

	func (c *cmd) RegisterFlags(ctx context.Context, cfg common.Config) ([]string, error) {
	unrollConstEvalLoopsDefault := runtime.GOOS != "windows"

	backendDefault := "default"
	if vkIcdFilenames := os.Getenv("VK_ICD_FILENAMES"); vkIcdFilenames != "" {
	backendDefault = "vulkan"
	}

	c.flags.Flags.Register()
	flag.StringVar(&c.flags.bin, "bin", defaultBinPath(), "path to the directory holding cts.js and dawn.node")
	flag.BoolVar(&c.flags.isolated, "isolate", false, "run each test in an isolated process")
	flag.BoolVar(&c.flags.build, "build", true, "attempt to build the CTS before running")
	flag.BoolVar(&c.flags.validate, "validate", false, "enable backend validation")
	flag.Var(&c.flags.dawn, "flag", "flag to pass to dawn-node as flag=value. multiple flags must be passed in individually")
	flag.StringVar(&c.flags.backend, "backend", backendDefault, "backend to use: default\|null\|webgpu\|d3d11\|d3d12\|metal\|vulkan\|opengl\|opengles."+
	" set to 'vulkan' if VK_ICD_FILENAMES environment variable is set, 'default' otherwise")
	flag.StringVar(&c.flags.adapterName, "adapter", "", "name (or substring) of the GPU adapter to use")
	flag.BoolVar(&c.flags.dumpShaders, "dump-shaders", false, "dump WGSL shaders. Enables --verbose")
	flag.BoolVar(&c.flags.fxc, "fxc", false, "Use FXC instead of DXC. Disables 'use_dxc' Dawn flag")
	flag.BoolVar(&c.flags.unrollConstEvalLoops, "unroll-const-eval-loops", unrollConstEvalLoopsDefault, "unroll loops in const-eval tests")
	flag.BoolVar(&c.flags.genCoverage, "coverage", false, "displays coverage data")
	flag.StringVar(&c.flags.coverageFile, "export-coverage", "", "write coverage data to the given path")
	flag.BoolVar(&c.flags.compatibilityMode, "compat", false, "run tests in compatibility mode")
	flag.BoolVar(&c.flags.skipVSCodeInfo, "skip-vs-code-info", false, "skips emitting VS Code information")

	return []string{"[query]"}, nil
	}

	func (c *cmd) Run(ctx context.Context, cfg common.Config) error {
	// Process the command line flags
	if err := c.processFlags(); err != nil {
	return err
	}

	if err := c.maybeInitCoverage(); err != nil {
	return err
	}

	if err := c.state.CTS.Node.BuildIfRequired(c.flags.Verbose); err != nil {
	return err
	}

	// Find all the test cases that match r.query.
	testCases, err := c.state.CTS.QueryTestCases(c.flags.Verbose, c.query)
	if err != nil {
	return fmt.Errorf("failed to gather tests: %w", err)
	}
	fmt.Printf("Testing %d test cases...\n", len(testCases))

	var runner func(ctx context.Context, testCases []common.TestCase, results chan<- common.Result)
	if c.flags.isolated {
	fmt.Println("Running in parallel isolated...")
	runner = c.runTestCasesWithCmdline
	} else {
	fmt.Println("Running in parallel with server...")
	runner = c.runTestCasesWithServers
	}

	resultStream := make(chan common.Result, 256)
	go func() {
	runner(ctx, testCases, resultStream)
	close(resultStream)
	}()

	results, err := common.StreamResults(ctx,
	c.flags.Colors,
	c.state,
	c.flags.Verbose,
	c.coverage,
	len(testCases),
	resultStream)
	if err != nil {
	return err
	}

	if err := c.state.Close(results); err != nil {
	return err
	}

	return nil
	}

	func (c *cmd) processFlags() error {
	// Check mandatory arguments
	if c.flags.bin == "" {
	return subcmd.InvalidCLA()
	}
	if !fileutils.IsDir(c.flags.bin) {
	return fmt.Errorf("'%v' is not a directory", c.flags.bin)
	}
	for _, file := range []string{"cts.js", "dawn.node"} {
	if !fileutils.IsFile(filepath.Join(c.flags.bin, file)) {
	return fmt.Errorf("'%v' does not contain '%v'", c.flags.bin, file)
	}
	}

	// Make paths absolute
	absBin, err := filepath.Abs(c.flags.bin)
	if err != nil {
	return fmt.Errorf("unable to get absolute path for '%v'", c.flags.bin)
	}
	c.flags.bin = absBin

	// The test query is the optional unnamed argument
	c.query = "webgpu:*"
	switch len(flag.Args()) {
	case 0:
	case 1:
	c.query = flag.Args()[0]
	default:
	return fmt.Errorf("only a single query can be provided")
	}

	// For Windows, set the DLL directory to bin so that Dawn loads dxcompiler.dll from there.
	c.flags.dawn.Set("dlldir=" + c.flags.bin)

	// Forward the backend and adapter to use, if specified.
	if c.flags.backend != "default" {
	fmt.Println("Forcing backend to", c.flags.backend)
	c.flags.dawn.Set("backend=" + c.flags.backend)
	}
	if c.flags.adapterName != "" {
	c.flags.dawn.Set("adapter=" + c.flags.adapterName)
	}
	if c.flags.validate {
	c.flags.dawn.Set("validate=1")
	}

	// While running the CTS, always allow unsafe APIs so they can be tested.
	c.flags.dawn.Set("enable-dawn-features=allow_unsafe_apis")
	if c.flags.dumpShaders {
	c.flags.Verbose = true
	c.flags.dawn.Set("enable-dawn-features=dump_shaders,disable_symbol_renaming")
	}
	if c.flags.fxc {
	c.flags.dawn.Set("disable-dawn-features=use_dxc")
	}
	c.flags.dawn.GlobListFlags("enable-dawn-features=", ",")

	state, err := c.flags.Process()
	if err != nil {
	return err
	}
	c.state = *state

	return nil
	}

	func (c *cmd) maybeInitCoverage() error {
	if !c.flags.genCoverage && c.flags.coverageFile == "" {
	return nil
	}

	profdata, err := exec.LookPath("llvm-profdata")
	if err != nil {
	profdata = ""
	if runtime.GOOS == "darwin" {
	profdata = "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/llvm-profdata"
	if !fileutils.IsExe(profdata) {
	profdata = ""
	}
	}
	}
	if profdata == "" {
	return fmt.Errorf("failed to find llvm-profdata, required for --coverage")
	}

	llvmCov := ""
	turboCov := filepath.Join(c.flags.bin, "turbo-cov"+fileutils.ExeExt)
	if !fileutils.IsExe(turboCov) {
	turboCov = ""
	if path, err := exec.LookPath("llvm-cov"); err == nil {
	llvmCov = path
	} else {
	return fmt.Errorf("failed to find turbo-cov or llvm-cov")
	}
	}
	c.coverage = &common.Coverage{
	OutputFile: c.flags.coverageFile,
	Env: &cov.Env{
	Profdata: profdata,
	Binary: filepath.Join(c.flags.bin, "dawn.node"),
	Cov: llvmCov,
	TurboCov: turboCov,
	},
	}

	return nil
	}