code review 201048: draw.Draw fast paths for a nil mask (and RGBA dst).

draw.Draw fast paths for a nil mask (and RGBA dst).

Averaged times (in microseconds) for drawing an 800x600 rectangle
are listed below. The summary is: around a 100x improvement.

draw.Draw call times were typically linear in the number of pixels
touched (i.e. drawing an 800x600 rectangle took 100x as much time as
drawing an 80x60 rectangle).

Before this change, there was only the general-but-slow code path.
When drawing any src with a 50%-opaque mask: 237300 us
When drawing any src with a nil mask: 50100 us

After this change, the 50%-opaque mask case is unchanged.
For an *image.RGBA dst and nil mask and...
...a uniform color (i.e. an image.ColorImage) src: 282 us
...another *image.RGBA src: 615 us.

For the curious, an intermediate implementation detected the special
cases but used simple nested for loops instead of the built-in copy
function. The respective times (compared to 282 and 615 for the
final implementation, or 50100 for the original) were 3110 and 3573.

Times were measured with 8g/8l on my laptop. I haven't tried gccgo
or other architectures.

[nigeltao, 2010-02-04 13:38:22]

Hello r, rsc (cc: golang-dev@googlegroups.com),

I'd like you to review this change.

[rsc, 2010-02-04 19:19:14]

i like it.  a few small generalizations.

if mask == nil can be if mask == nil || isOpaque(mask)
where isOpaque checks for a 1x1 image with an 0xFF returned by RGBA on
pixel 0,0.
(in fact isOpaque could check for mask == nil too.)

the interface check for ColorImage can instead
check for a 1x1 image with an 0xFF returned by RGBA on pixel 0,0
and use the rest of the RGB.

you'll want to split the check for dst being RGBA from the
op == SoverD.  there will be other cases that trigger on RGBA.
in particular i expect that the case you've added would be

if dstIsRGBA && (op == S || op == SoverD && isOpaque(mask))

russ

[nigeltao_gnome, 2010-02-04 22:26:00]

On 5 February 2010 06:19, Russ Cox <rsc@golang.org> wrote:
> if mask == nil can be if mask == nil || isOpaque(mask)
> where isOpaque checks for a 1x1 image with an 0xFF returned by RGBA on
> pixel 0,0.
> (in fact isOpaque could check for mask == nil too.)
>
> the interface check for ColorImage can instead
> check for a 1x1 image with an 0xFF returned by RGBA on pixel 0,0
> and use the rest of the RGB.

The Plan9 implementation, being C, had a single image type, a struct
with two rect fields: one for the slice of the pixel buffer used and
one for the clip (with a repeat bit). IIUC, it was idiomatic for a
draw's src to be 1x1 for the first rect and 1e9x1e9 for the second.

The Go implementation has an Image interface but multiple
implementation types. There aren't two different rects or a repeat
bit, and so far we haven't need even one rect (although this may
change), since the slice dimensions implies the image dimensions.
Accordingly, I don't think checking for a 1x1 is the right thing to
do. Instead, in my model the idiomatic thing is to typecast to an
image.ColorImage.

It's true that a ColorImage doesn't let you do a tiled 256x256
background, for example, but we can add a TiledImage type if we
actually ever need to implement 1990s era geocities pages.


> you'll want to split the check for dst being RGBA from the
> op == SoverD.  there will be other cases that trigger on RGBA.
> in particular i expect that the case you've added would be
>
> if dstIsRGBA && (op == S || op == SoverD && isOpaque(mask))

Yeah, the op == SoverD check should be split, but I was going to do
that when I implemented ops other than SoverD.

[rsc, 2010-02-05 00:17:58]

Oh, right.  No repl here.

LGTM

[r, 2010-02-05 00:21:29]

LGTM

[nigeltao, 2010-02-06 04:57:25]

*** Submitted as http://code.google.com/p/go/source/detail?r=dbfbd65d6549 ***

draw.Draw fast paths for a nil mask (and RGBA dst).

Averaged times (in microseconds) for drawing an 800x600 rectangle
are listed below. The summary is: around a 100x improvement.

draw.Draw call times were typically linear in the number of pixels
touched (i.e. drawing an 800x600 rectangle took 100x as much time as
drawing an 80x60 rectangle).

Before this change, there was only the general-but-slow code path.
When drawing any src with a 50%-opaque mask: 237300 us
When drawing any src with a nil mask: 50100 us

After this change, the 50%-opaque mask case is unchanged.
For an *image.RGBA dst and nil mask and...
...a uniform color (i.e. an image.ColorImage) src: 282 us
...another *image.RGBA src: 615 us.

For the curious, an intermediate implementation detected the special
cases but used simple nested for loops instead of the built-in copy
function. The respective times (compared to 282 and 615 for the
final implementation, or 50100 for the original) were 3110 and 3573.

Times were measured with 8g/8l on my laptop. I haven't tried gccgo
or other architectures.

R=r, rsc
CC=golang-dev
http://codereview.appspot.com/201048