AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Remove gpu shader optimatization for solid white or trans black colors

Browse Source 
Running test on the added bench which draws a grid of all white paths, all blue paths, or alternating checkered white/blue paths.

With optimization in (ms):
         White       Blue        Checkered
Linux    ~80         ~80         ~160
N7       ~800        ~1100       ~1500
Moto-e   ~830        ~1100       ~2500

Without optimization in (ms):
         White       Blue        Checkered
Linux    ~80         ~80         ~80
N7       ~1100       ~1100       ~1100
Moto-e   ~1100       ~1100       ~1500

BUG=skia:

Committed: https://skia.googlesource.com/skia/+/5f78d2251a440443c9eaa321dad058d7a32bfef7

R=bsalomon@google.com

Author: egdaniel@google.com

Review URL: https://codereview.chromium.org/375823005
This commit is contained in:
egdaniel 2014-07-21 11:37:28 -07:00 committed by Commit bot
parent 5b7c7c4ed3
commit 02cafcc1bf
11 changed files with 242 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

200
bench/AlternatingColorPatternBench.cpp Normal file
View File

@ -0,0 +1,200 @@
/*
* Copyright 2014 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "Benchmark.h"
#include "SkCanvas.h"
#include "SkGradientShader.h"
#include "SkPaint.h"
#include "SkString.h"
enum ColorPattern {
kWhite_ColorPattern,
kBlue_ColorPattern,
kOpaqueBitmap_ColorPattern,
kAlphaBitmap_ColorPattern,
};
static const struct ColorPatternData{
SkColor fColor;
bool fIsBitmap;
const char* fName;
} gColorPatterns[] = {
// Keep this in same order as ColorPattern enum
{ SK_ColorWHITE, false, "white" }, // kWhite_ColorPattern
{ SK_ColorBLUE, false, "blue" }, // kBlue_ColorPattern
{ SK_ColorWHITE, true, "obaqueBitMap" }, // kOpaqueBitmap_ColorPattern
{ 0x10000000, true, "alphaBitmap" }, // kAlphaBitmap_ColorPattern
};
enum DrawType {
kRect_DrawType,
kPath_DrawType,
};
static void makebm(SkBitmap* bm, int w, int h) {
bm->allocN32Pixels(w, h);
bm->eraseColor(SK_ColorTRANSPARENT);
SkCanvas canvas(*bm);
SkScalar s = SkIntToScalar(SkMin32(w, h));
static const SkPoint kPts0[] = { { 0, 0 }, { s, s } };
static const SkPoint kPts1[] = { { s/2, 0 }, { s/2, s } };
static const SkScalar kPos[] = { 0, SK_Scalar1/2, SK_Scalar1 };
static const SkColor kColors0[] = {0x80F00080, 0xF0F08000, 0x800080F0 };
static const SkColor kColors1[] = {0xF08000F0, 0x8080F000, 0xF000F080 };
SkPaint paint;
paint.setShader(SkGradientShader::CreateLinear(kPts0, kColors0, kPos,
SK_ARRAY_COUNT(kColors0), SkShader::kClamp_TileMode))->unref();
canvas.drawPaint(paint);
paint.setShader(SkGradientShader::CreateLinear(kPts1, kColors1, kPos,
SK_ARRAY_COUNT(kColors1), SkShader::kClamp_TileMode))->unref();
canvas.drawPaint(paint);
}
/**
* This bench draws a grid of either rects or filled paths, with two alternating color patterns.
* This color patterns are passed in as enums to the class. The options are:
* 1) solid white color
* 2) solid blue color
* 3) opaque bitmap
* 4) partial alpha bitmap
* The same color pattern can be set for both arguments to create a uniform pattern on all draws.
*
* The bench is used to test a few things. First it can test any optimizations made for a specific
* color pattern (for example drawing an opaque bitmap versus one with partial alpha). Also it can
* be used to test the cost of program switching and/or batching when alternating between different
* patterns when on the gpu.
*/
class AlternatingColorPatternBench : public Benchmark {
public:
enum {
NX = 5,
NY = 5,
NUM_DRAWS = NX * NY,
};
SkShader* fBmShader;
SkPath fPaths[NUM_DRAWS];
SkRect fRects[NUM_DRAWS];
SkColor fColors[NUM_DRAWS];
SkShader* fShaders[NUM_DRAWS];
SkString fName;
ColorPatternData fPattern1;
ColorPatternData fPattern2;
DrawType fDrawType;
SkBitmap fBmp;
AlternatingColorPatternBench(ColorPattern pattern1, ColorPattern pattern2, DrawType drawType)
: fBmShader(NULL) {
fPattern1 = gColorPatterns[pattern1];
fPattern2 = gColorPatterns[pattern2];
fName.printf("colorPattern_%s_%s_%s",
fPattern1.fName, fPattern2.fName,
kRect_DrawType == drawType ? "rect" : "path");
fDrawType = drawType;
}
virtual ~AlternatingColorPatternBench() {
SkSafeUnref(fBmShader);
}
protected:
virtual const char* onGetName() SK_OVERRIDE {
return fName.c_str();
}
virtual void onPreDraw() {
int w = 40;
int h = 40;
makebm(&fBmp, w, h);
fBmShader = SkShader::CreateBitmapShader(fBmp,
SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode);
int offset = 2;
int count = 0;
for (int j = 0; j < NY; ++j) {
for (int i = 0; i < NX; ++i) {
int x = (w + offset) * i;
int y = (h * offset) * j;
if (kRect_DrawType == fDrawType) {
fRects[count].set(SkIntToScalar(x), SkIntToScalar(y),
SkIntToScalar(x + w), SkIntToScalar(y + h));
} else {
fPaths[count].moveTo(SkIntToScalar(x), SkIntToScalar(y));
fPaths[count].rLineTo(SkIntToScalar(w), 0);
fPaths[count].rLineTo(0, SkIntToScalar(h));
fPaths[count].rLineTo(SkIntToScalar(-w + 1), 0);
}
if (0 == count % 2) {
fColors[count] = fPattern1.fColor;
fShaders[count] = fPattern1.fIsBitmap ? fBmShader : NULL;
} else {
fColors[count] = fPattern2.fColor;
fShaders[count] = fPattern2.fIsBitmap ? fBmShader : NULL;
}
++count;
}
}
}
virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkPaint paint;
paint.setAntiAlias(false);
paint.setFilterLevel(SkPaint::kLow_FilterLevel);
for (int i = 0; i < loops; ++i) {
for (int j = 0; j < NUM_DRAWS; ++j) {
paint.setColor(fColors[j]);
paint.setShader(fShaders[j]);
if (kRect_DrawType == fDrawType) {
canvas->drawRect(fRects[j], paint);
} else {
canvas->drawPath(fPaths[j], paint);
}
}
}
}
private:
typedef Benchmark INHERITED;
};
DEF_BENCH( return SkNEW_ARGS(AlternatingColorPatternBench,
(kWhite_ColorPattern, kWhite_ColorPattern,
kPath_DrawType)); )
DEF_BENCH( return SkNEW_ARGS(AlternatingColorPatternBench,
(kBlue_ColorPattern, kBlue_ColorPattern,
kPath_DrawType)); )
DEF_BENCH( return SkNEW_ARGS(AlternatingColorPatternBench,
(kWhite_ColorPattern, kBlue_ColorPattern,
kPath_DrawType)); )
DEF_BENCH( return SkNEW_ARGS(AlternatingColorPatternBench,
(kOpaqueBitmap_ColorPattern, kOpaqueBitmap_ColorPattern,
kPath_DrawType)); )
DEF_BENCH( return SkNEW_ARGS(AlternatingColorPatternBench,
(kAlphaBitmap_ColorPattern, kAlphaBitmap_ColorPattern,
kPath_DrawType)); )
DEF_BENCH( return SkNEW_ARGS(AlternatingColorPatternBench,
(kOpaqueBitmap_ColorPattern, kAlphaBitmap_ColorPattern,
kPath_DrawType)); )
DEF_BENCH( return SkNEW_ARGS(AlternatingColorPatternBench,
(kOpaqueBitmap_ColorPattern, kOpaqueBitmap_ColorPattern,
kRect_DrawType)); )
DEF_BENCH( return SkNEW_ARGS(AlternatingColorPatternBench,
(kAlphaBitmap_ColorPattern, kAlphaBitmap_ColorPattern,
kRect_DrawType)); )
DEF_BENCH( return SkNEW_ARGS(AlternatingColorPatternBench,
(kOpaqueBitmap_ColorPattern, kAlphaBitmap_ColorPattern,
kRect_DrawType)); )

12
expectations/gm/ignored-tests.txt
View File

@ -33,6 +33,18 @@
## epoger will rebaseline by 25 Dec 2013
#gradtext
# egdaniel: removing a gpu shader optimization causes some single pixel changes in gm
# cl: https://codereview.chromium.org/375823005/#ps210001
coloremoji
complexclip2
complexclip2_path_bw
complexclip2_rrect_bw
gradients_view_perspective
imagefiltersbase
inverse_paths
xfermodes3
verylargebitmap
# reed: bitmapfilters changed (labels) with hide_config CL, just need rebaselines
bitmapfilters

1
gyp/bench.gypi
View File

@ -23,6 +23,7 @@
'../bench/Benchmark.h',
'../bench/AAClipBench.cpp',
'../bench/AlternatingColorPatternBench.cpp',
'../bench/BitmapBench.cpp',
'../bench/BitmapRectBench.cpp',
'../bench/BitmapScaleBench.cpp',

9
src/gpu/GrDrawState.cpp
View File

@ -409,6 +409,15 @@ GrDrawState::BlendOptFlags GrDrawState::calcBlendOpts(bool forceCoverage,
return kNone_BlendOpt;
}
bool GrDrawState::canIgnoreColorAttribute() const {
if (fBlendOptFlags & kInvalid_BlendOptFlag) {
this->getBlendOpts();
}
return SkToBool(fBlendOptFlags & (GrDrawState::kEmitTransBlack_BlendOptFlag |
GrDrawState::kEmitCoverage_BlendOptFlag));
}
////////////////////////////////////////////////////////////////////////////////
void GrDrawState::AutoViewMatrixRestore::restore() {

6
src/gpu/GrDrawState.h
View File

@ -550,6 +550,12 @@ public:
fBlendOptFlags = kInvalid_BlendOptFlag;
}
/**
* We don't use suplied vertex color attributes if our blend mode is EmitCoverage or
* EmitTransBlack
*/
bool canIgnoreColorAttribute() const;
/**
* Determines what optimizations can be applied based on the blend. The coefficients may have
* to be tweaked in order for the optimization to work. srcCoeff and dstCoeff are optional

11
src/gpu/gl/GrGLProgram.cpp
View File

@ -154,7 +154,7 @@ void GrGLProgram::setColor(const GrDrawState& drawState,
GrColor color,
SharedGLState* sharedState) {
const GrGLProgramDesc::KeyHeader& header = fDesc.getHeader();
if (!drawState.hasColorVertexAttribute()) {
if (!drawState.hasColorVertexAttribute() || drawState.canIgnoreColorAttribute()) {
switch (header.fColorInput) {
case GrGLProgramDesc::kAttribute_ColorInput:
SkASSERT(-1 != header.fColorAttributeIndex);
@ -178,12 +178,8 @@ void GrGLProgram::setColor(const GrDrawState& drawState,
}
sharedState->fConstAttribColorIndex = -1;
break;
case GrGLProgramDesc::kSolidWhite_ColorInput:
case GrGLProgramDesc::kTransBlack_ColorInput:
sharedState->fConstAttribColorIndex = -1;
break;
default:
SkFAIL("Unknown color type.");
SkFAIL("Unexpected color type.");
}
} else {
sharedState->fConstAttribColorIndex = -1;
@ -218,11 +214,10 @@ void GrGLProgram::setCoverage(const GrDrawState& drawState,
sharedState->fConstAttribCoverageIndex = -1;
break;
case GrGLProgramDesc::kSolidWhite_ColorInput:
case GrGLProgramDesc::kTransBlack_ColorInput:
sharedState->fConstAttribCoverageIndex = -1;
break;
default:
SkFAIL("Unknown coverage type.");
SkFAIL("Unexpected coverage type.");
}
} else {
sharedState->fConstAttribCoverageIndex = -1;

18
src/gpu/gl/GrGLProgramDesc.cpp
View File

@ -66,6 +66,7 @@ bool GrGLProgramDesc::Build(const GrDrawState& drawState,
bool skipColor = SkToBool(blendOpts & (GrDrawState::kEmitTransBlack_BlendOptFlag |
GrDrawState::kEmitCoverage_BlendOptFlag));
int firstEffectiveColorStage = 0;
bool inputColorIsUsed = true;
if (!skipColor) {
@ -99,11 +100,6 @@ bool GrGLProgramDesc::Build(const GrDrawState& drawState,
bool requiresLocalCoordAttrib = !(skipCoverage && skipColor) &&
drawState.hasLocalCoordAttribute();
bool colorIsTransBlack = SkToBool(blendOpts & GrDrawState::kEmitTransBlack_BlendOptFlag);
bool colorIsSolidWhite = (blendOpts & GrDrawState::kEmitCoverage_BlendOptFlag) ||
(!requiresColorAttrib && 0xffffffff == drawState.getColor()) ||
(!inputColorIsUsed);
bool readsDst = false;
bool readFragPosition = false;
// We use vertexshader-less shader programs only when drawing paths.
@ -192,11 +188,7 @@ bool GrGLProgramDesc::Build(const GrDrawState& drawState,
#endif
bool defaultToUniformInputs = GR_GL_NO_CONSTANT_ATTRIBUTES || gpu->caps()->pathRenderingSupport();
if (colorIsTransBlack) {
header->fColorInput = kTransBlack_ColorInput;
} else if (colorIsSolidWhite) {
header->fColorInput = kSolidWhite_ColorInput;
} else if (defaultToUniformInputs && !requiresColorAttrib) {
if (defaultToUniformInputs && !requiresColorAttrib && inputColorIsUsed) {
header->fColorInput = kUniform_ColorInput;
} else {
header->fColorInput = kAttribute_ColorInput;
@ -205,11 +197,9 @@ bool GrGLProgramDesc::Build(const GrDrawState& drawState,
bool covIsSolidWhite = !requiresCoverageAttrib && 0xffffffff == drawState.getCoverageColor();
if (skipCoverage) {
header->fCoverageInput = kTransBlack_ColorInput;
} else if (covIsSolidWhite || !inputCoverageIsUsed) {
if ((covIsSolidWhite || !inputCoverageIsUsed) && !skipCoverage) {
header->fCoverageInput = kSolidWhite_ColorInput;
} else if (defaultToUniformInputs && !requiresCoverageAttrib) {
} else if (defaultToUniformInputs && !requiresCoverageAttrib && inputCoverageIsUsed) {
header->fCoverageInput = kUniform_ColorInput;
} else {
header->fCoverageInput = kAttribute_ColorInput;

1
src/gpu/gl/GrGLProgramDesc.h
View File

@ -100,7 +100,6 @@ private:
// Specifies where the initial color comes from before the stages are applied.
enum ColorInput {
kSolidWhite_ColorInput,
kTransBlack_ColorInput,
kAttribute_ColorInput,
kUniform_ColorInput,

6
src/gpu/gl/GrGLShaderBuilder.cpp
View File

@ -164,10 +164,6 @@ bool GrGLShaderBuilder::genProgram(const GrEffectStage* colorStages[],
this->addUniform(GrGLShaderBuilder::kFragment_Visibility, kVec4f_GrSLType, "Color",
&name);
inputColor = GrGLSLExpr4(name);
} else if (GrGLProgramDesc::kSolidWhite_ColorInput == header.fColorInput) {
inputColor = GrGLSLExpr4(1);
} else if (GrGLProgramDesc::kTransBlack_ColorInput == header.fColorInput) {
inputColor = GrGLSLExpr4(0);
}
if (GrGLProgramDesc::kUniform_ColorInput == header.fCoverageInput) {
@ -178,8 +174,6 @@ bool GrGLShaderBuilder::genProgram(const GrEffectStage* colorStages[],
inputCoverage = GrGLSLExpr4(name);
} else if (GrGLProgramDesc::kSolidWhite_ColorInput == header.fCoverageInput) {
inputCoverage = GrGLSLExpr4(1);
} else if (GrGLProgramDesc::kTransBlack_ColorInput == header.fCoverageInput) {
inputCoverage = GrGLSLExpr4(0);
}
if (k110_GrGLSLGeneration != fGpu->glslGeneration()) {

4
src/gpu/gl/GrGpuGL_program.cpp
View File

@ -353,9 +353,12 @@ void GrGpuGL::setupGeometry(const DrawInfo& info, size_t* indexOffsetInBytes) {
uint32_t usedAttribArraysMask = 0;
const GrVertexAttrib* vertexAttrib = this->getDrawState().getVertexAttribs();
bool canIgnoreColorAttrib = this->getDrawState().canIgnoreColorAttribute();
for (int vertexAttribIndex = 0; vertexAttribIndex < vertexAttribCount;
++vertexAttribIndex, ++vertexAttrib) {
if (kColor_GrVertexAttribBinding != vertexAttrib->fBinding || !canIgnoreColorAttrib) {
usedAttribArraysMask |= (1 << vertexAttribIndex);
GrVertexAttribType attribType = vertexAttrib->fType;
attribState->set(this,
@ -367,6 +370,7 @@ void GrGpuGL::setupGeometry(const DrawInfo& info, size_t* indexOffsetInBytes) {
stride,
reinterpret_cast<GrGLvoid*>(
vertexOffsetInBytes + vertexAttrib->fOffset));
}
}
attribState->disableUnusedArrays(this, usedAttribArraysMask);
}

5
tests/GLProgramsTest.cpp
View File

@ -73,8 +73,9 @@ bool GrGLProgramDesc::setRandom(SkRandom* random,
// if the effects have used up all off the available attributes,
// don't try to use color or coverage attributes as input
do {
header->fColorInput = static_cast<GrGLProgramDesc::ColorInput>(
random->nextULessThan(kColorInputCnt));
uint32_t colorRand = random->nextULessThan(2);
header->fColorInput = (0 == colorRand) ? GrGLProgramDesc::kAttribute_ColorInput :
GrGLProgramDesc::kUniform_ColorInput;
} while (GrDrawState::kMaxVertexAttribCnt <= currAttribIndex &&
kAttribute_ColorInput == header->fColorInput);