GH-113464: Speed up JIT builds

[brandtbucher]

The current JIT build includes the code for every instruction when compiling each stencil, even though only one of the cases is used.

This extracts the desired cases and compiles them each in isolation, which makes JIT builds almost twice as fast (except on Windows, where I suspect we're still bound by subprocess creation time).

• Issue: JIT Compilation #113464

[savannahostrowski]

My only question is how, if at all, memory usage is impacted by this change, given the independent compilation.

Otherwise, this is just a tiny comment about adding a comment.

[savannahostrowski]

Would it be good to add a comment here about why each of these is compiled independently (e.g., because of the performance benefit)? I'm not sure that would be abundantly clear if I just stumbled upon this code.

[brandtbucher]

Good idea, I'll add a comment.

[brandtbucher]

My only question is how, if at all, memory usage is impacted by this change, given the independent compilation.

The good news is that memory usage should go down, though temporary disk usage will go up.

We were always compiling each opcode independently, but all of the other C code for all of the opcodes not being compiled was part of the same file. Now we are writing out files to disk containing just the C code for each opcode.

As an example, before, we would compile this three times and extract the machine code of each opcode afterwards:

_Py_CODEUNIT *
_JIT_ENTRY(...)
{
    // ...
    switch (FOO) {
        case FOO: {
            // Code for FOO...
        }
        case BAR: {
            // Code for BAR (unused here)...
        }
        case BAZ: {
            // Code for BAZ (unused here)...
        }
    }
    // ...
}

_Py_CODEUNIT *
_JIT_ENTRY(...)
{
    // ...
    switch (BAR) {
        case FOO: {
            // Code for FOO (unused here)...
        }
        case BAR: {
            // Code for BAR...
        }
        case BAZ: {
            // Code for BAZ (unused here)...
        }
    }
    // ...
}

_Py_CODEUNIT *
_JIT_ENTRY(...)
{
    // ...
    switch (BAZ) {
        case FOO: {
            // Code for FOO (unused here)...
        }
        case BAR: {
            // Code for BAR (unused here)...
        }
        case BAZ: {
            // Code for BAZ...
        }
    }
    // ...
}

Now, we only include the necessary case each time, so the C compiler doesn't waste time parsing a bunch of dead C code for the other cases

_Py_CODEUNIT *
_JIT_ENTRY(...)
{
    // ...
    switch (FOO) {
        case FOO: {
            // Code for FOO...
        }
    }
    // ...
}

_Py_CODEUNIT *
_JIT_ENTRY(...)
{
    // ...
    switch (BAR) {
        case BAR: {
            // Code for BAR...
        }
    }
    // ...
}

_Py_CODEUNIT *
_JIT_ENTRY(...)
{
    // ...
    switch (BAZ) {
        case BAZ: {
            // Code for BAZ...
        }
    }
    // ...
}

Hopefully that helps explain what's going on here? It's a bit weird.