avo

I see only two C files in the repo: https://github.com/habedi/hann/blob/main/core/simd_distance.... https://github.com/habedi/hann/blob/main/core/simd_ops.c So fixing to make it compile just with the Go toolchain (probably by rewriting in assembly) seems doable. Using avo to produce assembly: https://github.com/mmcloughlin/avo

It depends on how long the time you spend in your c function is. cgo has a substantial overhead for calling. I tend to prefer just writing ASM functions for critical path code. You can use libraries like https://github.com/mmcloughlin/avo to make it easier to write/maintain.

I would recommend checking out Avo (https://github.com/mmcloughlin/avo) if you're interesting in writing Go assembly programs. It provides type safety and does some checks to ensure you output valid assembly. It can dynamically allocate registers for you and calculate things like stack and frame size so you don't have to do that by hand. It also can handle calling convention details for you, very easy to load an argument into whatever register/location you'd like. I recently ported all of the amd64 assembly in Go's crypto libraries over to Avo. Very useful library for this sort of work!

Generally the inline assembly is hand-written and must follow the platform rules, see "Architecture-specific details" in https://go.dev/doc/asm The few tools that generate that asm, such as https://github.com/mmcloughlin/avo , would also have follow the rules. You're not meant to take C source, crank it through GCC, and slurp that in as inline asm in Go. Background: https://www.youtube.com/watch?v=KINIAgRpkDA

I wonder whether avo could have been useful here?[1] I mention it because it came up the last time we were talking about AVX operations in go.[2, 3] 1 = https://github.com/mmcloughlin/avo 2 = https://news.ycombinator.com/item?id=34465297 3 = https://www.reddit.com/r/golang/comments/10hmh07/how_to_use_...

There is also a Go version inspired by PeachPy https://github.com/mmcloughlin/avo (see https://github.com/mmcloughlin/avo#credits)

I thought the /r/golang comments on this post were pretty useful[1]. They also introduced me to avo[2], a tool for generating x86 assembly from go that I hadn't seen before. There are some examples listed on the avo github page for generating AVX512 instructions with avo. 1 = https://www.reddit.com/r/golang/comments/10hmh07/how_to_use_... 2 = https://github.com/mmcloughlin/avo

You could perhaps just have the Go compiler generate the assembler for your code: go tool compile -S file.go > file_amd64.s Then you could verify it doesn't change over time, and choose to begin maintaining by hand if it makes sense. If you do want to go the route of rolling it yourself, I'd suggest looking into something like Avo: https://github.com/mmcloughlin/avo

Yes! This tripped me up at one point. My comment says "Otherwise we could be in the bizarre special-case of 3-argument CMP instructions." https://github.com/mmcloughlin/avo/blob/0e253b3753beb409b3dd... It gets to the point where the only source of truth is the Go assembler itself. My test suite takes the avo instruction database and generates a massive assembly file with one line per instruction form, then passes this to `go tool asm`.

avo author here. Yes PeachPy was the inspiration for this, as well as asmjit. Both mentioned in the credits: https://github.com/mmcloughlin/avo#credits PeachPy actually has Go output already, and Damian Gryski has used this to great effect: https://github.com/mmcloughlin/avo/issues/40 Unfortunately because PeachPy wasn't initially written with Go in mind there are some rough edges and Go features it simply doesn't support. avo hopes to fill this gap for Go programmers.

Author of avo here. While I did really enjoy working on this project, I still fully agree with you. Go (Plan 9) syntax is not sufficiently different to make it a powerful intermediate representation, hence SSA as you point out. In fact many of the differences are frustrating subtle changes in instruction mnemonics or operand order. This might be okay if there was a canonical instruction database that made all these differences from Intel and AT&T easy to discover. However these exceptions are really recorded in various parts of the golang.org/x/arch/x86 repo. Producing the instruction database for avo was quite a time-consuming process. See: https://github.com/mmcloughlin/avo/blob/master/internal/load... https://github.com/mmcloughlin/avo/issues/23 I've gained a lot more familiarity with the assembler and supporting infrastructure, so I'm