[wasm] Make back branches faster in the jiterpreter and clean up some code

[kg]

Right now the jiterpreter maintains a local variable tracking whether a backward branch has ever been taken, and flushes it to memory upon abnormal exit to notify the monitoring code whether the trace took any backward branches.

I realized this variable isn't actually necessary, because the design of the jiterpreter's dispatch code ensures that the existing disp variable will only have the value 0 on first execution, and will always have a nonzero value after any backwards branch is taken. So we can just flush disp to memory on abnormal exit instead. This means we don't have to waste valuable cycles setting the flag every time we take a backwards branch, since we're already setting disp.

I also took the opportunity to change things so we pass a NULLcinfo to traces when they're not being monitored. In most scenarios this shouldn't matter, but for hot traces that abnormally exit this will reduce the number of pointless memory writes they do a little bit, and it will also fix the minor problem that in multithreaded scenarios, all traces compete to write to the same dummy static cinfo variable (now they won't perform the write at all).

While adding this optimization I also noticed that conditional back-branches were modifying disp even when the branch wasn't taken, which would raise the cost of each of those branches for no good reason, so I cleaned that up as well.

This makes abnormal exits ~5 bytes longer, but it makes back-branches 1 byte shorter, so it should be a trace size reduction on average.

There were a couple hard-coded offsets in the typescript and I took the opportunity to change them into JiterpMembers as well.

[kg]

Right now the jiterpreter maintains a local variable tracking whether a backward branch has ever been taken, and flushes it to memory upon abnormal exit to notify the monitoring code whether the trace took any backward branches.

I realized this variable isn't actually necessary, because the design of the jiterpreter's dispatch code ensures that the existing disp variable will only have the value 0 on first execution, and will always have a nonzero value after any backwards branch is taken. So we can just flush disp to memory on abnormal exit instead. This means we don't have to waste valuable cycles setting the flag every time we take a backwards branch, since we're already setting disp.

I also took the opportunity to change things so we pass a NULLcinfo to traces when they're not being monitored. In most scenarios this shouldn't matter, but for hot traces that abnormally exit this will reduce the number of pointless memory writes they do a little bit, and it will also fix the minor problem that in multithreaded scenarios, all traces compete to write to the same dummy static cinfo variable (now they won't perform the write at all).

While adding this optimization I also noticed that conditional back-branches were modifying disp even when the branch wasn't taken, which would raise the cost of each of those branches for no good reason, so I cleaned that up as well.

This makes abnormal exits ~5 bytes longer, but it makes back-branches 1 byte shorter, so it should be a trace size reduction on average.

There were a couple hard-coded offsets in the typescript and I took the opportunity to change them into JiterpMembers as well.

[kg]

Right now the jiterpreter maintains a local variable tracking whether a backward branch has ever been taken, and flushes it to memory upon abnormal exit to notify the monitoring code whether the trace took any backward branches.

I realized this variable isn't actually necessary, because the design of the jiterpreter's dispatch code ensures that the existing disp variable will only have the value 0 on first execution, and will always have a nonzero value after any backwards branch is taken. So we can just flush disp to memory on abnormal exit instead. This means we don't have to waste valuable cycles setting the flag every time we take a backwards branch, since we're already setting disp.

I also took the opportunity to change things so we pass a NULLcinfo to traces when they're not being monitored. In most scenarios this shouldn't matter, but for hot traces that abnormally exit this will reduce the number of pointless memory writes they do a little bit, and it will also fix the minor problem that in multithreaded scenarios, all traces compete to write to the same dummy static cinfo variable (now they won't perform the write at all).

While adding this optimization I also noticed that conditional back-branches were modifying disp even when the branch wasn't taken, which would raise the cost of each of those branches for no good reason, so I cleaned that up as well.

This makes abnormal exits ~5 bytes longer, but it makes back-branches 1 byte shorter, so it should be a trace size reduction on average.

There were a couple hard-coded offsets in the typescript and I took the opportunity to change them into JiterpMembers as well.

[kg]

Right now the jiterpreter maintains a local variable tracking whether a backward branch has ever been taken, and flushes it to memory upon abnormal exit to notify the monitoring code whether the trace took any backward branches.

I realized this variable isn't actually necessary, because the design of the jiterpreter's dispatch code ensures that the existing disp variable will only have the value 0 on first execution, and will always have a nonzero value after any backwards branch is taken. So we can just flush disp to memory on abnormal exit instead. This means we don't have to waste valuable cycles setting the flag every time we take a backwards branch, since we're already setting disp.

I also took the opportunity to change things so we pass a NULLcinfo to traces when they're not being monitored. In most scenarios this shouldn't matter, but for hot traces that abnormally exit this will reduce the number of pointless memory writes they do a little bit, and it will also fix the minor problem that in multithreaded scenarios, all traces compete to write to the same dummy static cinfo variable (now they won't perform the write at all).

While adding this optimization I also noticed that conditional back-branches were modifying disp even when the branch wasn't taken, which would raise the cost of each of those branches for no good reason, so I cleaned that up as well.

This makes abnormal exits ~5 bytes longer, but it makes back-branches 1 byte shorter, so it should be a trace size reduction on average.

There were a couple hard-coded offsets in the typescript and I took the opportunity to change them into JiterpMembers as well.

[kg]

Right now the jiterpreter maintains a local variable tracking whether a backward branch has ever been taken, and flushes it to memory upon abnormal exit to notify the monitoring code whether the trace took any backward branches.

I realized this variable isn't actually necessary, because the design of the jiterpreter's dispatch code ensures that the existing disp variable will only have the value 0 on first execution, and will always have a nonzero value after any backwards branch is taken. So we can just flush disp to memory on abnormal exit instead. This means we don't have to waste valuable cycles setting the flag every time we take a backwards branch, since we're already setting disp.

I also took the opportunity to change things so we pass a NULLcinfo to traces when they're not being monitored. In most scenarios this shouldn't matter, but for hot traces that abnormally exit this will reduce the number of pointless memory writes they do a little bit, and it will also fix the minor problem that in multithreaded scenarios, all traces compete to write to the same dummy static cinfo variable (now they won't perform the write at all).

While adding this optimization I also noticed that conditional back-branches were modifying disp even when the branch wasn't taken, which would raise the cost of each of those branches for no good reason, so I cleaned that up as well.

This makes abnormal exits ~5 bytes longer, but it makes back-branches 1 byte shorter, so it should be a trace size reduction on average.

There were a couple hard-coded offsets in the typescript and I took the opportunity to change them into JiterpMembers as well.

[kg]

Right now the jiterpreter maintains a local variable tracking whether a backward branch has ever been taken, and flushes it to memory upon abnormal exit to notify the monitoring code whether the trace took any backward branches.

I realized this variable isn't actually necessary, because the design of the jiterpreter's dispatch code ensures that the existing disp variable will only have the value 0 on first execution, and will always have a nonzero value after any backwards branch is taken. So we can just flush disp to memory on abnormal exit instead. This means we don't have to waste valuable cycles setting the flag every time we take a backwards branch, since we're already setting disp.

I also took the opportunity to change things so we pass a NULLcinfo to traces when they're not being monitored. In most scenarios this shouldn't matter, but for hot traces that abnormally exit this will reduce the number of pointless memory writes they do a little bit, and it will also fix the minor problem that in multithreaded scenarios, all traces compete to write to the same dummy static cinfo variable (now they won't perform the write at all).

While adding this optimization I also noticed that conditional back-branches were modifying disp even when the branch wasn't taken, which would raise the cost of each of those branches for no good reason, so I cleaned that up as well.

This makes abnormal exits ~5 bytes longer, but it makes back-branches 1 byte shorter, so it should be a trace size reduction on average.

There were a couple hard-coded offsets in the typescript and I took the opportunity to change them into JiterpMembers as well.

[kg]

Right now the jiterpreter maintains a local variable tracking whether a backward branch has ever been taken, and flushes it to memory upon abnormal exit to notify the monitoring code whether the trace took any backward branches.

I realized this variable isn't actually necessary, because the design of the jiterpreter's dispatch code ensures that the existing disp variable will only have the value 0 on first execution, and will always have a nonzero value after any backwards branch is taken. So we can just flush disp to memory on abnormal exit instead. This means we don't have to waste valuable cycles setting the flag every time we take a backwards branch, since we're already setting disp.

I also took the opportunity to change things so we pass a NULLcinfo to traces when they're not being monitored. In most scenarios this shouldn't matter, but for hot traces that abnormally exit this will reduce the number of pointless memory writes they do a little bit, and it will also fix the minor problem that in multithreaded scenarios, all traces compete to write to the same dummy static cinfo variable (now they won't perform the write at all).

While adding this optimization I also noticed that conditional back-branches were modifying disp even when the branch wasn't taken, which would raise the cost of each of those branches for no good reason, so I cleaned that up as well.

This makes abnormal exits ~5 bytes longer, but it makes back-branches 1 byte shorter, so it should be a trace size reduction on average.

There were a couple hard-coded offsets in the typescript and I took the opportunity to change them into JiterpMembers as well.

[kg]

Right now the jiterpreter maintains a local variable tracking whether a backward branch has ever been taken, and flushes it to memory upon abnormal exit to notify the monitoring code whether the trace took any backward branches.

I realized this variable isn't actually necessary, because the design of the jiterpreter's dispatch code ensures that the existing disp variable will only have the value 0 on first execution, and will always have a nonzero value after any backwards branch is taken. So we can just flush disp to memory on abnormal exit instead. This means we don't have to waste valuable cycles setting the flag every time we take a backwards branch, since we're already setting disp.

I also took the opportunity to change things so we pass a NULLcinfo to traces when they're not being monitored. In most scenarios this shouldn't matter, but for hot traces that abnormally exit this will reduce the number of pointless memory writes they do a little bit, and it will also fix the minor problem that in multithreaded scenarios, all traces compete to write to the same dummy static cinfo variable (now they won't perform the write at all).

While adding this optimization I also noticed that conditional back-branches were modifying disp even when the branch wasn't taken, which would raise the cost of each of those branches for no good reason, so I cleaned that up as well.

This makes abnormal exits ~5 bytes longer, but it makes back-branches 1 byte shorter, so it should be a trace size reduction on average.

There were a couple hard-coded offsets in the typescript and I took the opportunity to change them into JiterpMembers as well.