question on PARI/GP t_INTMOD exponentiation optimization for multiple similar size big exponents with same base

[hermann@stamm-wilbrandt.de]

It all started with me trying to play with J. Brillhart, D. H. Lehmer 
and J. L. Selfridge 1975 paper theorem 1:
https://t5k.org/prove/prove3_1.html

While theorem 1 does not require the same a_i for different prime 
divisors p_i of N-1 to be used, I learned that a primitive root allows 
to be used for all prime divisors of N-1.


I played with prime Euclid numbers https://oeis.org/A014545, for which 
the factorization of N-1 is trivial. A simple sequential replacement of 
znprimroot() is much faster because znprimroot() has to factor N-1 
first, and prime 457th Euclid number is smallest example where GP has to 
spend much time on the factorization:

hermann@7950x:~$ gp -q seq.gp
? #
   timer = 1 (on)
? euclid_prime_find_root(457)
cpu time = 8,368 ms, real time = 8,370 ms.
31
? lift(znprimroot(prime(457)#+1))
cpu time = 1min, 34,734 ms, real time = 1min, 34,744 ms.
31
? #digits(prime(457)#+1)
1368
?


I created a parallel version of my gist which is much faster than 
sequential:
https://gist.github.com/Hermann-SW/a14dc268d533b96afbd52b2a9d3c92e8

hermann@7950x:~$ gp -q par2.gp
? #
   timer = 1 (on)
? euclid_prime_find_root(457)
cpu time = 14,400 ms, real time = 1,216 ms.
31
?


Next I wanted to speedup the parallel computation in passing 
Mod(g,N)^((N-1)/prime(n)) to check function as a base where the slightly 
bigger Mod(g,N)^((N-1)/prime(i)) can be computed from quickly for 
1<=i<n. This is the small diff:

hermann@7950x:~$ diff par2.gp par3.gp
1,2c1,2
< check(En, n, phi, g, i)={
<   parfor(i=1, n, lift(Mod(g, En)^(phi / prime(i))) == 1, r, if(r, 
return(0)));
---
> check(En, n, phi, g, base, i)={
>   parfor(i=1, n, lift(base * Mod(g, En)^(phi / prime(i) - phi / 
> prime(n))) == 1, r, if(r, return(0)));
11c11,12
<       if(check(En, n, phi, g, i), return(g));
---
>       base=Mod(g, En)^(phi / prime(n));
>       if(check(En, n, phi, g, base, i), return(g));
hermann@7950x:~$


I did let run seq.gp over night and hat to abort execution for prime 
2673th Euclid number (with 10,387 decimal digits) after 12.5h. Parallel 
versions completed in 20 minutes (on 16C/32T AMD 7950X CPU), but to my 
surprise the runtime gets worse by my "improvement". First runtime for 
par2.gp, then for par3.gp:

? euclid_prime_find_root(2673)
%5 = 139
? ##
  ***   last result: cpu time 4h, 45min, 45,149 ms, real time 19min, 
46,915 ms.
?

? euclid_prime_find_root(2673)
%4 = 139
? ##
  ***   last result: cpu time 4h, 48min, 3,278 ms, real time 22min, 
14,287 ms.
?


It seems that GP does optimize muliple modular exponentiation with same 
base better than how I tried to do it.

1) What optimization is happening in GP for par2.gp exponentiation?
2) Where in the code base do I have to look for that optimization?


Regards,

Hermann.