TODO: Simplify threefry2x32 kernel

[abourramouss]

• Steps to reproduce:

(ql:quickload :caten)
(use-package :caten)



(setf (ctx:getenv :JIT) 1)
(setf (ctx:getenv :JIT_DEBUG) 2)

(caten (!rand '(3 3)))

Generates the following kernel:

* (1/1) FUSED_THREEFRY2X32_RANDOM8729 

=====> Lowering to blueprint
{
  val_152 = (0 xor 466688986);
  val_154 = (val_152+4);
  _RNG_COUNTER[0] = (_rng_counter[0]+9); // :reduction=t
  val_153 = (val_152+1);
  for (int _gid0=0;(_gid0<9);_gid0+=1) {
    val_166 = (_gid0+_rng_counter[0]);
    val_171 = (((uint64)(val_166+9)*4294967296) or val_166);
    val_176 = ((uint32)(IDIV(val_171 4294967296) and 4294967295));
    val_180 = (uint32)((float32)val_176*1.9073486e-6);
    val_185 = (((uint32)(val_171 and 4294967295))+val_176);
    val_186 = (val_185 xor ((val_176*8192)+val_180));
    val_191 = (uint32)((float32)val_186*7.6293945e-6);
    val_187 = (val_185+val_186);
    val_193 = (val_187 xor ((val_186*32768)+val_191));
    val_198 = (uint32)((float32)val_193*0.015625);
    val_194 = (val_187+val_193);
    val_200 = (val_194 xor ((val_193*67108864)+val_198));
    val_201 = (val_194+val_200);
    val_206 = (uint32)((float32)val_200*1.4901161e-8);
    val_209 = ((val_201 xor ((val_200*64)+val_206))+val_153);
    val_214 = (uint32)((float32)val_209*3.0517578e-5);
    val_210 = ((val_201)+val_209);
    val_216 = (val_210 xor ((val_209*131072)+val_214));
    val_221 = (uint32)((float32)val_216*0.125);
    val_217 = (val_210+val_216);
    val_223 = (val_217 xor ((val_216*536870912)+val_221));
    val_228 = (uint32)((float32)val_223*1.5258789e-5);
    val_224 = (val_217+val_223);
    val_230 = (val_224 xor ((val_223*65536)+val_228));
    val_231 = (val_224+val_230);
    val_236 = (uint32)((float32)val_230*0.00390625);
    val_239 = ((val_231 xor ((val_230*16777216)+val_236))+2);
    val_244 = (uint32)((float32)val_239*1.9073486e-6);
    val_240 = ((val_231+val_152)+val_239);
    val_246 = (val_240 xor ((val_239*8192)+val_244));
    val_251 = (uint32)((float32)val_246*7.6293945e-6);
    val_247 = (val_240+val_246);
    val_253 = (val_247 xor ((val_246*32768)+val_251));
    val_258 = (uint32)((float32)val_253*0.015625);
    val_254 = (val_247+val_253);
    val_260 = (val_254 xor ((val_253*67108864)+val_258));
    val_261 = (val_254+val_260);
    val_266 = (uint32)((float32)val_260*1.4901161e-8);
    val_269 = ((val_261 xor ((val_260*64)+val_266))+3);
    val_274 = (uint32)((float32)val_269*3.0517578e-5);
    val_270 = ((val_261)+val_269);
    val_276 = (val_270 xor ((val_269*131072)+val_274));
    val_281 = (uint32)((float32)val_276*0.125);
    val_277 = (val_270+val_276);
    val_283 = (val_277 xor ((val_276*536870912)+val_281));
    val_288 = (uint32)((float32)val_283*1.5258789e-5);
    val_284 = (val_277+val_283);
    val_290 = (val_284 xor ((val_283*65536)+val_288));
    val_291 = (val_284+val_290);
    val_296 = (uint32)((float32)val_290*0.00390625);
    val_299 = ((val_291 xor ((val_290*16777216)+val_296))+val_154);
    val_304 = (uint32)((float32)val_299*1.9073486e-6);
    val_300 = ((val_291)+val_299);
    val_306 = (val_300 xor ((val_299*8192)+val_304));
    val_311 = (uint32)((float32)val_306*7.6293945e-6);
    val_307 = (val_300+val_306);
    val_313 = (val_307 xor ((val_306*32768)+val_311));
    val_318 = (uint32)((float32)val_313*0.015625);
    val_314 = (val_307+val_313);
    val_320 = (val_314 xor ((val_313*67108864)+val_318));
    val_327 = (uint32)((float32)val_320*1.4901161e-8);
    val_321 = (val_314+val_320);
    val_323 = (uint64)(val_321+val_152);
    val_344[_gid0] = (((float32)((uint32)((float32)(((uint64)((val_321 xor ((val_320*64)+val_327))+5)*4294967296) or val_323)*2.3283064e-10) and 4294967295)*0.00390625)*5.9604645e-8);
  } // _gid0
}

The idea is to simplify operations like (0 ^ 466688986) by modifying:

https://github.com/hikettei/Caten/blob/main/source/aasm/constant-folding.lisp