Bug 1016678 - Add textured compositor benchmark. r=jrmuizel

--HG--
extra : rebase_source : 11465ad7c287db421fc68022269823b7da992835
This commit is contained in:
Benoit Girard 2014-06-04 18:37:18 -04:00
parent 19d86c1d8f
commit 38d340c6a0

View File

@ -15,6 +15,10 @@
#include <math.h>
#include "GeckoProfiler.h"
#ifdef MOZ_WIDGET_GONK
#include "mozilla/layers/GrallocTextureHost.h"
#endif
#define TEST_STEPS 1000
#define DURATION_THRESHOLD 30
#define THRESHOLD_ABORT_COUNT 5
@ -46,6 +50,45 @@ private:
const char* mTestName;
};
static void
DrawFrameTrivialQuad(Compositor* aCompositor, const gfx::Rect& aScreenRect, size_t aStep, const EffectChain& effects) {
for (size_t i = 0; i < aStep * 10; i++) {
const gfx::Rect& rect = gfx::Rect(i % (int)aScreenRect.width,
(int)(i / aScreenRect.height),
1, 1);
const gfx::Rect& clipRect = aScreenRect;
float opacity = 1.f;
gfx::Matrix transform2d;
gfx::Matrix4x4 transform = gfx::Matrix4x4::From2D(transform2d);
aCompositor->DrawQuad(rect, clipRect, effects, opacity, transform);
}
}
static void
DrawFrameStressQuad(Compositor* aCompositor, const gfx::Rect& aScreenRect, size_t aStep, const EffectChain& effects)
{
for (size_t i = 0; i < aStep * 10; i++) {
const gfx::Rect& rect = gfx::Rect(aScreenRect.width * SimplePseudoRandom(i, 0),
aScreenRect.height * SimplePseudoRandom(i, 1),
aScreenRect.width * SimplePseudoRandom(i, 2),
aScreenRect.height * SimplePseudoRandom(i, 3));
const gfx::Rect& clipRect = aScreenRect;
float opacity = 1.f;
gfx::Matrix transform2d;
transform2d = transform2d.Rotate(SimplePseudoRandom(i, 4) * 70.f);
gfx::Matrix4x4 transform = gfx::Matrix4x4::From2D(transform2d);
aCompositor->DrawQuad(rect, clipRect, effects, opacity, transform);
}
}
class EffectSolidColorBench : public BenchTest {
public:
EffectSolidColorBench()
@ -80,30 +123,22 @@ public:
{}
void DrawFrame(Compositor* aCompositor, const gfx::Rect& aScreenRect, size_t aStep) {
for (size_t i = 0; i < aStep * 10; i++) {
EffectChain effects;
effects.mPrimaryEffect = CreateEffect(aStep);
DrawFrameTrivialQuad(aCompositor, aScreenRect, aStep, effects);
}
TemporaryRef<Effect> CreateEffect(size_t i) {
float red;
float tmp;
red = modf(i * 0.03f, &tmp);
EffectChain effects;
gfxRGBA color(red, 0.4f, 0.4f, 1.0f);
effects.mPrimaryEffect = new EffectSolidColor(gfx::Color(color.r,
color.g,
color.b,
color.a));
const gfx::Rect& rect = gfx::Rect(i % (int)aScreenRect.width,
(int)(i / aScreenRect.height),
1, 1);
const gfx::Rect& clipRect = aScreenRect;
float opacity = 1.f;
gfx::Matrix transform2d;
gfx::Matrix4x4 transform = gfx::Matrix4x4::From2D(transform2d);
aCompositor->DrawQuad(rect, clipRect, effects, opacity, transform);
}
return new EffectSolidColor(gfx::Color(color.r,
color.g,
color.b,
color.a));
}
};
@ -114,32 +149,22 @@ public:
{}
void DrawFrame(Compositor* aCompositor, const gfx::Rect& aScreenRect, size_t aStep) {
for (size_t i = 0; i < aStep * 10; i++) {
EffectChain effects;
effects.mPrimaryEffect = CreateEffect(aStep);
DrawFrameStressQuad(aCompositor, aScreenRect, aStep, effects);
}
TemporaryRef<Effect> CreateEffect(size_t i) {
float red;
float tmp;
red = modf(i * 0.03f, &tmp);
EffectChain effects;
gfxRGBA color(red, 0.4f, 0.4f, 1.0f);
effects.mPrimaryEffect = new EffectSolidColor(gfx::Color(color.r,
color.g,
color.b,
color.a));
const gfx::Rect& rect = gfx::Rect(aScreenRect.width * SimplePseudoRandom(i, 0),
aScreenRect.height * SimplePseudoRandom(i, 1),
aScreenRect.width * SimplePseudoRandom(i, 2),
aScreenRect.height * SimplePseudoRandom(i, 3));
const gfx::Rect& clipRect = aScreenRect;
float opacity = 0.3f;
gfx::Matrix transform2d;
transform2d = transform2d.Rotate(SimplePseudoRandom(i, 4) * 70.f);
gfx::Matrix4x4 transform = gfx::Matrix4x4::From2D(transform2d);
aCompositor->DrawQuad(rect, clipRect, effects, opacity, transform);
}
return new EffectSolidColor(gfx::Color(color.r,
color.g,
color.b,
color.a));
}
};
@ -177,14 +202,194 @@ public:
}
};
class TrivialTexturedQuadBench : public BenchTest {
public:
TrivialTexturedQuadBench()
: BenchTest("Trvial Textured Quad (10s 256x256 quads)")
{}
uint32_t* mBuf;
RefPtr<DataSourceSurface> mSurface;
RefPtr<DataTextureSource> mTexture;
virtual void Setup(Compositor* aCompositor, size_t aStep) {
int bytesPerPixel = 4;
size_t w = 256;
size_t h = 256;
mBuf = (uint32_t *) malloc(w * h * sizeof(uint32_t));
for (size_t i = 0; i < w * h; i++) {
mBuf[i] = 0xFF00008F;
}
mSurface = Factory::CreateWrappingDataSourceSurface(
reinterpret_cast<uint8_t*>(mBuf), w * bytesPerPixel, IntSize(w, h), SurfaceFormat::B8G8R8A8);
mTexture = aCompositor->CreateDataTextureSource();
mTexture->Update(mSurface);
}
void DrawFrame(Compositor* aCompositor, const gfx::Rect& aScreenRect, size_t aStep) {
EffectChain effects;
effects.mPrimaryEffect = CreateEffect(aStep);
DrawFrameTrivialQuad(aCompositor, aScreenRect, aStep, effects);
}
virtual void Teardown(Compositor* aCompositor) {
mSurface = nullptr;
mTexture = nullptr;
free(mBuf);
}
TemporaryRef<Effect> CreateEffect(size_t i) {
RefPtr<TexturedEffect> effect = CreateTexturedEffect(SurfaceFormat::B8G8R8A8, mTexture, Filter::POINT);
return effect;
}
};
class StressTexturedQuadBench : public BenchTest {
public:
StressTexturedQuadBench()
: BenchTest("Stress Textured Quad (10s 256x256 quads)")
{}
uint32_t* mBuf;
RefPtr<DataSourceSurface> mSurface;
RefPtr<DataTextureSource> mTexture;
virtual void Setup(Compositor* aCompositor, size_t aStep) {
int bytesPerPixel = 4;
size_t w = 256;
size_t h = 256;
mBuf = (uint32_t *) malloc(w * h * sizeof(uint32_t));
for (size_t i = 0; i < w * h; i++) {
mBuf[i] = 0xFF00008F;
}
mSurface = Factory::CreateWrappingDataSourceSurface(
reinterpret_cast<uint8_t*>(mBuf), w * bytesPerPixel, IntSize(w, h), SurfaceFormat::B8G8R8A8);
mTexture = aCompositor->CreateDataTextureSource();
mTexture->Update(mSurface);
}
void DrawFrame(Compositor* aCompositor, const gfx::Rect& aScreenRect, size_t aStep) {
EffectChain effects;
effects.mPrimaryEffect = CreateEffect(aStep);
DrawFrameStressQuad(aCompositor, aScreenRect, aStep, effects);
}
virtual void Teardown(Compositor* aCompositor) {
mSurface = nullptr;
mTexture = nullptr;
free(mBuf);
}
virtual TemporaryRef<Effect> CreateEffect(size_t i) {
RefPtr<TexturedEffect> effect = CreateTexturedEffect(SurfaceFormat::B8G8R8A8, mTexture, Filter::POINT);
return effect;
}
};
#ifdef MOZ_WIDGET_GONK
class TrivialGrallocQuadBench : public BenchTest {
public:
TrivialGrallocQuadBench()
: BenchTest("Travial Gralloc Quad (10s 256x256 quads)")
{}
uint32_t* mBuf;
android::sp<android::GraphicBuffer> mGralloc;
RefPtr<TextureSource> mTexture;
virtual void Setup(Compositor* aCompositor, size_t aStep) {
mBuf = nullptr;
int w = 256;
int h = 256;
int32_t format = android::PIXEL_FORMAT_RGBA_8888;;
mGralloc = new android::GraphicBuffer(w, h,
format,
android::GraphicBuffer::USAGE_SW_READ_OFTEN |
android::GraphicBuffer::USAGE_SW_WRITE_OFTEN |
android::GraphicBuffer::USAGE_HW_TEXTURE);
mTexture = new mozilla::layers::GrallocTextureSourceOGL((CompositorOGL*)aCompositor, mGralloc.get(), SurfaceFormat::B8G8R8A8);
}
void DrawFrame(Compositor* aCompositor, const gfx::Rect& aScreenRect, size_t aStep) {
EffectChain effects;
effects.mPrimaryEffect = CreateEffect(aStep);
DrawFrameTrivialQuad(aCompositor, aScreenRect, aStep, effects);
}
virtual void Teardown(Compositor* aCompositor) {
mGralloc = nullptr;
mTexture = nullptr;
free(mBuf);
}
virtual TemporaryRef<Effect> CreateEffect(size_t i) {
RefPtr<TexturedEffect> effect = CreateTexturedEffect(SurfaceFormat::B8G8R8A8, mTexture, Filter::POINT);
return effect;
}
};
class StressGrallocQuadBench : public BenchTest {
public:
StressGrallocQuadBench()
: BenchTest("Stress Gralloc Quad (10s 256x256 quads)")
{}
uint32_t* mBuf;
android::sp<android::GraphicBuffer> mGralloc;
RefPtr<TextureSource> mTexture;
virtual void Setup(Compositor* aCompositor, size_t aStep) {
mBuf = nullptr;
int w = 256;
int h = 256;
int32_t format = android::PIXEL_FORMAT_RGBA_8888;;
mGralloc = new android::GraphicBuffer(w, h,
format,
android::GraphicBuffer::USAGE_SW_READ_OFTEN |
android::GraphicBuffer::USAGE_SW_WRITE_OFTEN |
android::GraphicBuffer::USAGE_HW_TEXTURE);
mTexture = new mozilla::layers::GrallocTextureSourceOGL((CompositorOGL*)aCompositor, mGralloc.get(), SurfaceFormat::B8G8R8A8);
}
void DrawFrame(Compositor* aCompositor, const gfx::Rect& aScreenRect, size_t aStep) {
EffectChain effects;
effects.mPrimaryEffect = CreateEffect(aStep);
DrawFrameStressQuad(aCompositor, aScreenRect, aStep, effects);
}
virtual void Teardown(Compositor* aCompositor) {
mGralloc = nullptr;
mTexture = nullptr;
free(mBuf);
}
virtual TemporaryRef<Effect> CreateEffect(size_t i) {
RefPtr<TexturedEffect> effect = CreateTexturedEffect(SurfaceFormat::B8G8R8A8, mTexture, Filter::POINT);
return effect;
}
};
#endif
static void RunCompositorBench(Compositor* aCompositor, const gfx::Rect& aScreenRect)
{
std::vector<BenchTest*> tests;
tests.push_back(new EffectSolidColorBench());
tests.push_back(new UploadBench());
tests.push_back(new EffectSolidColorTrivialBench());
tests.push_back(new EffectSolidColorStressBench());
tests.push_back(new UploadBench());
tests.push_back(new TrivialTexturedQuadBench());
tests.push_back(new StressTexturedQuadBench());
#ifdef MOZ_WIDGET_GONK
tests.push_back(new TrivialGrallocQuadBench());
tests.push_back(new StressGrallocQuadBench());
#endif
for (size_t i = 0; i < tests.size(); i++) {
BenchTest* test = tests[i];