[3.14] Enable the tail calling interpreter

[jack-mcivor]

Can the 3.14 images enable the tail call interpreter? IIUC this brings a 5-6% free performance improvement
https://docs.python.org/3.14/using/configure.html#cmdoption-with-tail-call-interp

[tianon]

Our builds don't currently happen with Clang, and this doesn't appear to be supported with GCC (certainly not with the version we're building against).

For JIT (#1043, #947), we need Clang, but I'm not sure what the future of that is or whether that actually uses Clang for the entire build or just for the JIT functionality.

So before we can really consider this, we need to figure out how much work it'd be to switch to Clang, and what the downsides are.

Diff I was testing with:

diff --git a/Dockerfile-linux.template b/Dockerfile-linux.template
index 8b3b8c8..1851ee6 100644
--- a/Dockerfile-linux.template
+++ b/Dockerfile-linux.template
@@ -175,6 +175,9 @@ RUN set -eux; \
        if is_alpine then "" else (
 -}}
                --enable-optimizations \
+{{ if rcVersion | IN("3.9", "3.10", "3.11", "3.12", "3.13") then "" else ( -}}
+               --with-tail-call-interp \
+{{ ) end -}}
 {{ ) end -}}
                --enable-option-checking=fatal \
                --enable-shared \

[erlenekalafo]

It seems we need to clarify which compiler options we are currently using for the builds. Since @tianon mentioned that our builds don’t use Clang, could we explore whether switching to Clang for the 3.14 images would be feasible? Additionally, have we verified if enabling the tail call interpreter has any dependency on specific GCC versions, or if there are any flags we might need to set for it to work effectively with our current setup?

[UfBt12qJNZKcw]

Could we investigate the exact GCC version being used for the 3.14 builds to check compatibility with the tail call interpreter? If there are specific flags or configurations that enable or disable this feature, it would be worth enumerating those in the build process.

[Ix3WUhpgTPE]

To move forward with enabling the tail call interpreter, we should first check the current GCC version being utilized for the 3.14 builds, as @UfBt12qJNZKcw suggested. We can look into whether there are specific flags that might enable this feature, especially if the version is on the cusp of supporting it. Additionally, could we assess the feasibility of transitioning to Clang for the builds, as @erlenekalafo mentioned? It may help us leverage the performance improvements if GCC falls short.