Improve performance of SSE2 no_surf_alpha_opaque_dst blitter

[Starbuck5]

Previously, this blitter used a 2x path if the blit had an even width, and a 1x path if the blit had an odd width. Now it uses a 4x path in all cases, with stride switching to handle excess pixels. ("x" = "pixels at a time" in this parlance, 2x = 2 pixels at a time, etc.)

The 4x strategy was inspired by the AVX blitters. There are operations it can do on 4 pixels at a time (load, store, alpha masking), then it goes into sub batches to process the first 2 pixels and the second 2 pixels.

I measure a 17% time reduction for an 800x100 blit, and a 56% time reduction for a 799x100 blit.

Why are the SSE blitters important? They are our cross platform accelerators. ARM uses them, using sse2neon. If we ever get WASM SIMD working it will use them. AVX2 is still way faster and shinier for x86, but SSE is important. In fact, it might become more important in coming years, such that we might want to raise our target to SSE3/SSE4 to take advantage of more advanced instructions.

Testing

• Add #undef __AVX2__ to simd_blitters_avx2.c to make sure you're testing SSE2 blitters

Performance test script

import pygame
import time

pygame.init()

width = 799

screen = pygame.Surface((width,100), depth=32)
screen.fill((60, 70, 80))

surf = pygame.Surface((width,100), pygame.SRCALPHA)
surf.fill((5,216,77,120))

print(screen, screen.get_shifts(), screen.get_alpha(), screen.get_colorkey())
print(surf, surf.get_shifts(), surf.get_alpha(), surf.get_colorkey())

# blit once before to get rid of any spurious warnings
screen.blit(surf, (0, 0))  

start = time.time()
for _ in range(100000):
    screen.blit(surf, (0, 0))    
print(time.time() - start)

Future things

• It's very scary to me that this function is hardcoded to support ARGB and it seems like it could be called by any 4 byte alpha blit. This PR doesn't change the behavior at all, but I'd like this blitter to support varied alpha channel locations like the modern AVX2 ones.
• This 4x strategy should be relevant to other things in simd_blitters_sse2, like the blend modes.
• In the future this could be more macro-ed up, like our modern AVX2 blitters and the filler codes. It's not ready for that yet. This gets it closer. The other alpha blitters need significant work.

[MyreMylar]

LGTM 👍

My test results using the test program:

Before PR Test Results (multiple runs) - 799x100
--------------------------------------
9.54190182685852
9.535496711730957
9.523637771606445
9.511376142501831

After PR Test Results (multiple runs) - 799x100
--------------------------------------
4.210539102554321
4.189740419387817
4.187772512435913
4.1871418952941895



Before PR Test Results (multiple runs) - 800x600
--------------------------------------
5.045648813247681
5.021234035491943
5.04343843460083
5.013594388961792

After PR Test Results (multiple runs) - 800x600
--------------------------------------
4.173273324966431
4.166048526763916
4.1809751987457275
4.171604871749878

A very good speedup on the odd/large number of trailing pixels per row case.

[novialriptide]

Major performance boosts on the Apple M2 Max

Before

<799x100>
8.609078884124756
8.535655975341797
8.516473054885864

<800x100>
4.360736131668091
4.322415113449097
4.34481406211853

After

<799x100>
3.417734146118164
3.400517702102661
3.3988189697265625

<800x100>
3.435307025909424
3.3835179805755615
3.361617088317871

[Starbuck5]

I have the reviews necessary to merge, but I plan on leaving this open a few more days in case @itzpr3d4t0r wants to take a look.

[itzpr3d4t0r]

Aside from a minor nitpick and a question, this looks good to me, good job!!

[itzpr3d4t0r]

Just curious, could there be a way to reduce the amount of unpacks we do here? like with a shuffle? maybe like get the alpha in a register, shuffle that value in all other positions, and then right shift that? Could that save an instruction?

[itzpr3d4t0r]

Yeah actually when experimenting with premul_alpha() i found out a shuffle is straight up better, replaces multiple instructions with one.

[Starbuck5]

Of course a shuffle would be better, the problem is that SSE2 does not have a byte-level shuffle instruction. SSSE3 does, AVX or AVX2 does.

[Starbuck5]

Also the alpha fetching here is not dynamic to the actual location of the alpha channel. (Same as it's always been in this function).

I'd be willing to trade performance for making this work correctly on different pixelformats.

[Starbuck5]

The question is "what amount of ARM systems justify a 3rd optimization level," where we put in an SSE4.2 level of SIMD for translation of advanced features like byte-level shuffles to NEON.