Parallel multiplication

You use your int as a byte[4] vector and want a dot-product for the special case of byte[0]==0?

Is there a reason you'd do something so inherently inefficient in the first place, or is this just for fun? [grin]

Quote:

Original post by Trap You use your int as a byte[4] vector and want a dot-product for the special case of byte[0]==0?

No it's not a vector it's an RGB color (with the alpha channel being ignored), and it's not the dot product but a component-wise product.

And it's for fun! (I came up with it while coding tho and might still use it ;))

When you're doing this kind of optimization you need to know the hardware. Can it shift fast? Fast multiplications or should you use tables? Memory bandwidth limited? If you miss the level1-3 caches the CPU may stall for hundreds of clock cycles and _this_ is the bottleneck - not processing the pixels/colors.

The _optimizations_ are often not portable - keep the original, clean code for the future!


You can do this with two multiplications instead of three :-P

Also, you don't need to shift all color components around this much. Draw each of the color components as bit-ranges on a piece of paper _separately_ and figure-out the optimal set of logical operations for each component.

Another thing you can think about: right now there are a lot of dependencies between the different operations that can cause CPU stalls. Try interleaving other stuff in between - possible interleave the same code but processing another color (pixel?) at the same time. Depending on HW, the second pixel might be "free" CPU-wize = 200% faster.

Yet another thing: if this code is the biggest bottleneck, can you preprocess your data to make this code snippet do less work?


HTH


/Marcus

Doesn't MMX do something fancy like this?

Yes, but it depends on how you want to handle overflows.

Why don't you just load every part as an unsigned char, multiply them and store again? Maybe by using a union of 1 int and 4 unsigned chars.

Quote:

Original post by Trap Why don't you just load every part as an unsigned char, multiply them and store again? Maybe by using a union of 1 int and 4 unsigned chars.

That's not one line of code. I'm looking for something that looks "cool", not necessarily readable, like that way to swap two variables in one statement ;)

I profiled that single line variable swap once. It was something like 4 times slower. You ended up with the same number of mov instructions, it just did an XOR between everything.



Keep it simple.