23:13 <alyssa> You don't want to know the lenghts I went to dump this table 😋

23:13 <alyssa> https://rosenzweig.io/LUT.pdf

23:13 <macc24> wow

23:14 <macc24> what is this

23:14 <alyssa> macc24: A page from ~the~ my architecture specification for Valhall.

23:15 <macc24> huh

23:15 <alyssa> (It turns out writing docs is an excellent way to procrastinate on writing code!)

23:15 <macc24> bbl

23:15 <alyssa> I jest.

23:15 <alyssa> If a shader uses a constant value (e.g. `gl_FragColor = foo + 0.2345`), there are 3 possible ways that constant can be encoded in Valhall:

23:16 <alyssa> * Embedded in the command stream directly. This only works for addition. Otherwise you waste an instruction adding 0.

23:17 <alyssa> * Promoted to a uniform and then accessed as a uniform. This is 'free' except uniforms are limited, and this competes with the encoding used by actual uniforms.

23:17 <alyssa> * As a lookup into a fixed table of "common" constants. This is completely free, with the caveat that it only works for a small number of very special values... not that Arm tells us which they are!

23:18 <alyssa> Rather than trying to guess constants and see how the Arm compiler handles them, I wrote a program to dump the lookup table from the hardware itself.

23:19 <HdkR> Nice!

23:20 <alyssa> It's, uh, not pretty. But I started writing an assembler for Valhall, and this was an easy use ... bash script to generate programs that add zero to a given index into the LUT and store them to memory mapped by an OpenCL program, assemble those with my assembler, push it to the device of adb, replace the shader in vivo with panwrap LD_PRELOAD'd, and dump the resulting OpenCL memory to get the value.

23:20 <alyssa> Doing that gave me the 32 special values that are hardcoded into Valhall's silicon, which are in the "Value" column of the linked PDF.

23:21 <alyssa> But it's not enough to know _what_ the values are, we should also understand _why_ these values were picked.

23:21 <alyssa> We can't /know/ what Arm's hardware engineers were thinking, but we can make very firm guesses. So the last column of the table are my interpretations of the values.

23:22 <HdkR> All the integer ones are easy. Scale by N different ways

23:22 <alyssa> Yep.

23:22 <alyssa> Nothing here is terribly surprising :)

23:23 <alyssa> So I took all the data I dumped and stored it as XML with description attributes on the elements*

23:23 <robclark> adreno has a similar thing for encoding float immeds in instructions (or rather, the groups of instructions which can encode immeds).. I call it "FLUT".. I assume they (and arm) just collected a bunch of shaders of useful games/benchmarks and did some scripting to figure out which values show up more frequently

23:24 <HdkR> Loads of people must be multiplying by 0.1 :D

23:24 <robclark> (int immeds you can just directly encode, assuming they fit in the # of bits avail)

23:24 <alyssa> So then all the tooling I'm building up (assembler, disassembler, compiler encoding, and documentation generator) can get access to everything and nothing goes out of sync.

23:25 <alyssa> * the XMPP people are rubbing off

23:25 <alyssa> robclark: Yeah, presumably. Curious thing here is that Valhall doesn't let int immeds be encoded directly, which is why rows 5-15 are "needed" even though it's silly.

23:27 <alyssa> Apple represents the other extreme -- there is no LUT. Instead you only have 8-bit ints for your immediates ... with the twist that floating-point instructions interpret the int as a 3:5 minifloat :-)

23:27 <robclark> yeah, that is a bit silly

23:27 <robclark> fwiw, the FLUT values qcom chose: https://gitlab.freedesktop.org/mesa/mesa/-/blob/main/src/freedreno/isa/ir3-common.xml#L156

23:27 <alyssa> (This does means Apple needs a uniform slot for pi, 1/pi, log(2) ...)

23:28 <alyssa> robclark: You would think if Arm and Qcm were looking at useful games/benchmarks they'd come up with remotely similar lists.. ;-p

23:30 <robclark> from a quick look, there is *some* overlap..

23:56 <macc24> alyssa: maybe arm considers different usecase?

23:57 <anholt> v3d/vc4's small immediates are small integers and float powers of two, no pi or anything.

23:59 <anholt> kind of disappointing, given that their uniforms are so expensive