| // Copyright 2025 The Go Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style | |
| // license that can be found in the LICENSE file. | |
| // simdgen is an experiment in generating Go <-> asm SIMD mappings. | |
| // | |
| // Usage: simdgen [-xedPath=path] [-q=query] input.yaml... | |
| // | |
| // If -xedPath is provided, one of the inputs is a sum of op-code definitions | |
| // generated from the Intel XED data at path. | |
| // | |
| // If input YAML files are provided, each file is read as an input value. See | |
| // [unify.Closure.UnmarshalYAML] or "go doc unify.Closure.UnmarshalYAML" for the | |
| // format of these files. | |
| // | |
| // TODO: Example definitions and values. | |
| // | |
| // The command unifies across all of the inputs and prints all possible results | |
| // of this unification. | |
| // | |
| // If the -q flag is provided, its string value is parsed as a value and treated | |
| // as another input to unification. This is intended as a way to "query" the | |
| // result, typically by narrowing it down to a small subset of results. | |
| // | |
| // Typical usage: | |
| // | |
| // go run . -xedPath $XEDPATH *.yaml | |
| // | |
| // To see just the definitions generated from XED, run: | |
| // | |
| // go run . -xedPath $XEDPATH | |
| // | |
| // (This works because if there's only one input, there's nothing to unify it | |
| // with, so the result is simply itself.) | |
| // | |
| // To see just the definitions for VPADDQ: | |
| // | |
| // go run . -xedPath $XEDPATH -q '{asm: VPADDQ}' | |
| // | |
| // simdgen can also generate Go definitions of SIMD mappings: | |
| // To generate go files to the go root, run: | |
| // | |
| // go run . -xedPath $XEDPATH -o godefs -goroot $PATH/TO/go go.yaml categories.yaml types.yaml | |
| // | |
| // types.yaml is already written, it specifies the shapes of vectors. | |
| // categories.yaml and go.yaml contains definitions that unifies with types.yaml and XED | |
| // data, you can find an example in ops/AddSub/. | |
| // | |
| // When generating Go definitions, simdgen do 3 "magic"s: | |
| // - It splits masked operations(with op's [Masked] field set) to const and non const: | |
| // - One is a normal masked operation, the original | |
| // - The other has its mask operand's [Const] fields set to "K0". | |
| // - This way the user does not need to provide a separate "K0"-masked operation def. | |
| // | |
| // - It deduplicates intrinsic names that have duplicates: | |
| // - If there are two operations that shares the same signature, one is AVX512 the other | |
| // is before AVX512, the other will be selected. | |
| // - This happens often when some operations are defined both before AVX512 and after. | |
| // This way the user does not need to provide a separate "K0" operation for the | |
| // AVX512 counterpart. | |
| // | |
| // - It copies the op's [ConstImm] field to its immediate operand's [Const] field. | |
| // - This way the user does not need to provide verbose op definition while only | |
| // the const immediate field is different. This is useful to reduce verbosity of | |
| // compares with imm control predicates. | |
| // | |
| // These 3 magics could be disabled by enabling -nosplitmask, -nodedup or | |
| // -noconstimmporting flags. | |
| // | |
| // simdgen right now only supports amd64, -arch=$OTHERARCH will trigger a fatal error. | |
| package main | |
| // Big TODOs: | |
| // | |
| // - This can produce duplicates, which can also lead to less efficient | |
| // environment merging. Add hashing and use it for deduplication. Be careful | |
| // about how this shows up in debug traces, since it could make things | |
| // confusing if we don't show it happening. | |
| // | |
| // - Do I need Closure, Value, and Domain? It feels like I should only need two | |
| // types. | |
| import ( | |
| "cmp" | |
| "flag" | |
| "fmt" | |
| "log" | |
| "maps" | |
| "os" | |
| "path/filepath" | |
| "runtime/pprof" | |
| "slices" | |
| "strings" | |
| "simd/archsimd/_gen/unify" | |
| "gopkg.in/yaml.v3" | |
| ) | |
| var ( | |
| xedPath = flag.String("xedPath", "", "load XED datafiles from `path`") | |
| flagQ = flag.String("q", "", "query: read `def` as another input (skips final validation)") | |
| flagO = flag.String("o", "yaml", "output type: yaml, godefs (generate definitions into a Go source tree") | |
| flagGoDefRoot = flag.String("goroot", ".", "the path to the Go dev directory that will receive the generated files") | |
| FlagNoDedup = flag.Bool("nodedup", false, "disable deduplicating godefs of 2 qualifying operations from different extensions") | |
| FlagNoConstImmPorting = flag.Bool("noconstimmporting", false, "disable const immediate porting from op to imm operand") | |
| FlagArch = flag.String("arch", "amd64", "the target architecture") | |
| Verbose = flag.Bool("v", false, "verbose") | |
| flagDebugXED = flag.Bool("debug-xed", false, "show XED instructions") | |
| flagDebugUnify = flag.Bool("debug-unify", false, "print unification trace") | |
| flagDebugHTML = flag.String("debug-html", "", "write unification trace to `file.html`") | |
| FlagReportDup = flag.Bool("reportdup", false, "report the duplicate godefs") | |
| flagCPUProfile = flag.String("cpuprofile", "", "write CPU profile to `file`") | |
| flagMemProfile = flag.String("memprofile", "", "write memory profile to `file`") | |
| ) | |
| const simdPackage = "simd/archsimd" | |
| func main() { | |
| flag.Parse() | |
| if *flagCPUProfile != "" { | |
| f, err := os.Create(*flagCPUProfile) | |
| if err != nil { | |
| log.Fatalf("-cpuprofile: %s", err) | |
| } | |
| defer f.Close() | |
| pprof.StartCPUProfile(f) | |
| defer pprof.StopCPUProfile() | |
| } | |
| if *flagMemProfile != "" { | |
| f, err := os.Create(*flagMemProfile) | |
| if err != nil { | |
| log.Fatalf("-memprofile: %s", err) | |
| } | |
| defer func() { | |
| pprof.WriteHeapProfile(f) | |
| f.Close() | |
| }() | |
| } | |
| var inputs []unify.Closure | |
| if *FlagArch != "amd64" { | |
| log.Fatalf("simdgen only supports amd64") | |
| } | |
| // Load XED into a defs set. | |
| if *xedPath != "" { | |
| xedDefs := loadXED(*xedPath) | |
| inputs = append(inputs, unify.NewSum(xedDefs...)) | |
| } | |
| // Load query. | |
| if *flagQ != "" { | |
| r := strings.NewReader(*flagQ) | |
| def, err := unify.Read(r, "<query>", unify.ReadOpts{}) | |
| if err != nil { | |
| log.Fatalf("parsing -q: %s", err) | |
| } | |
| inputs = append(inputs, def) | |
| } | |
| // Load defs files. | |
| must := make(map[*unify.Value]struct{}) | |
| for _, path := range flag.Args() { | |
| defs, err := unify.ReadFile(path, unify.ReadOpts{}) | |
| if err != nil { | |
| log.Fatal(err) | |
| } | |
| inputs = append(inputs, defs) | |
| if filepath.Base(path) == "go.yaml" { | |
| // These must all be used in the final result | |
| for def := range defs.Summands() { | |
| must[def] = struct{}{} | |
| } | |
| } | |
| } | |
| // Prepare for unification | |
| if *flagDebugUnify { | |
| unify.Debug.UnifyLog = os.Stderr | |
| } | |
| if *flagDebugHTML != "" { | |
| f, err := os.Create(*flagDebugHTML) | |
| if err != nil { | |
| log.Fatal(err) | |
| } | |
| unify.Debug.HTML = f | |
| defer f.Close() | |
| } | |
| // Unify! | |
| unified, err := unify.Unify(inputs...) | |
| if err != nil { | |
| log.Fatal(err) | |
| } | |
| // Validate results. | |
| // | |
| // Don't validate if this is a command-line query because that tends to | |
| // eliminate lots of required defs and is used in cases where maybe defs | |
| // aren't enumerable anyway. | |
| if *flagQ == "" && len(must) > 0 { | |
| validate(unified, must) | |
| } | |
| // Print results. | |
| switch *flagO { | |
| case "yaml": | |
| // Produce a result that looks like encoding a slice, but stream it. | |
| fmt.Println("!sum") | |
| var val1 [1]*unify.Value | |
| for val := range unified.All() { | |
| val1[0] = val | |
| // We have to make a new encoder each time or it'll print a document | |
| // separator between each object. | |
| enc := yaml.NewEncoder(os.Stdout) | |
| if err := enc.Encode(val1); err != nil { | |
| log.Fatal(err) | |
| } | |
| enc.Close() | |
| } | |
| case "godefs": | |
| if err := writeGoDefs(*flagGoDefRoot, unified); err != nil { | |
| log.Fatalf("Failed writing godefs: %+v", err) | |
| } | |
| } | |
| if !*Verbose && *xedPath != "" { | |
| if operandRemarks == 0 { | |
| fmt.Fprintf(os.Stderr, "XED decoding generated no errors, which is unusual.\n") | |
| } else { | |
| fmt.Fprintf(os.Stderr, "XED decoding generated %d \"errors\" which is not cause for alarm, use -v for details.\n", operandRemarks) | |
| } | |
| } | |
| } | |
| func validate(cl unify.Closure, required map[*unify.Value]struct{}) { | |
| // Validate that: | |
| // 1. All final defs are exact | |
| // 2. All required defs are used | |
| for def := range cl.All() { | |
| if _, ok := def.Domain.(unify.Def); !ok { | |
| fmt.Fprintf(os.Stderr, "%s: expected Def, got %T\n", def.PosString(), def.Domain) | |
| continue | |
| } | |
| if !def.Exact() { | |
| fmt.Fprintf(os.Stderr, "%s: def not reduced to an exact value, why is %s:\n", def.PosString(), def.WhyNotExact()) | |
| fmt.Fprintf(os.Stderr, "\t%s\n", strings.ReplaceAll(def.String(), "\n", "\n\t")) | |
| } | |
| for root := range def.Provenance() { | |
| delete(required, root) | |
| } | |
| } | |
| // Report unused defs | |
| unused := slices.SortedFunc(maps.Keys(required), | |
| func(a, b *unify.Value) int { | |
| return cmp.Or( | |
| cmp.Compare(a.Pos().Path, b.Pos().Path), | |
| cmp.Compare(a.Pos().Line, b.Pos().Line), | |
| ) | |
| }) | |
| for _, def := range unused { | |
| // TODO: Can we say anything more actionable? This is always a problem | |
| // with unification: if it fails, it's very hard to point a finger at | |
| // any particular reason. We could go back and try unifying this again | |
| // with each subset of the inputs (starting with individual inputs) to | |
| // at least say "it doesn't unify with anything in x.yaml". That's a lot | |
| // of work, but if we have trouble debugging unification failure it may | |
| // be worth it. | |
| fmt.Fprintf(os.Stderr, "%s: def required, but did not unify (%v)\n", | |
| def.PosString(), def) | |
| } | |
| } | |