261 lines
10 KiB
C++
261 lines
10 KiB
C++
|
/*
|
||
|
|
* Copyright 2018 Google Inc.
|
||
|
|
*
|
||
|
|
* Use of this source code is governed by a BSD-style license that can be
|
||
|
|
* found in the LICENSE file.
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include "include/gpu/GrDirectContext.h"
|
||
|
|
#include "src/gpu/GrDirectContextPriv.h"
|
||
|
|
#include "src/gpu/GrMemoryPool.h"
|
||
|
|
#include "src/gpu/GrOpFlushState.h"
|
||
|
|
#include "src/gpu/GrOpsTask.h"
|
||
|
|
#include "src/gpu/GrProxyProvider.h"
|
||
|
|
#include "src/gpu/GrRecordingContextPriv.h"
|
||
|
|
#include "src/gpu/ops/GrOp.h"
|
||
|
|
#include "tests/Test.h"
|
||
|
|
#include <iterator>
|
||
|
|
|
||
|
|
// We create Ops that write a value into a range of a buffer. We create ranges from
|
||
|
|
// kNumOpPositions starting positions x kRanges canonical ranges. We repeat each range kNumRepeats
|
||
|
|
// times (with a different value written by each of the repeats).
|
||
|
|
namespace {
|
||
|
|
struct Range {
|
||
|
|
unsigned fOffset;
|
||
|
|
unsigned fLength;
|
||
|
|
};
|
||
|
|
|
||
|
|
static constexpr int kNumOpPositions = 4;
|
||
|
|
static constexpr Range kRanges[] = {{0, 4,}, {1, 2}};
|
||
|
|
static constexpr int kNumRanges = (int)SK_ARRAY_COUNT(kRanges);
|
||
|
|
static constexpr int kNumRepeats = 2;
|
||
|
|
static constexpr int kNumOps = kNumRepeats * kNumOpPositions * kNumRanges;
|
||
|
|
|
||
|
|
static constexpr uint64_t fact(int n) {
|
||
|
|
assert(n > 0);
|
||
|
|
return n > 1 ? n * fact(n - 1) : 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
// How wide should our result buffer be to hold values written by the ranges of the ops.
|
||
|
|
static constexpr unsigned result_width() {
|
||
|
|
unsigned maxLength = 0;
|
||
|
|
for (size_t i = 0; i < kNumRanges; ++i) {
|
||
|
|
maxLength = maxLength > kRanges[i].fLength ? maxLength : kRanges[i].fLength;
|
||
|
|
}
|
||
|
|
return kNumOpPositions + maxLength - 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Number of possible allowable binary chainings among the kNumOps ops.
|
||
|
|
static constexpr int kNumCombinableValues = fact(kNumOps) / fact(kNumOps - 2);
|
||
|
|
using Combinable = std::array<GrOp::CombineResult, kNumCombinableValues>;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The index in Combinable for the result for combining op 'b' into op 'a', i.e. the result of
|
||
|
|
* op[a]->combineIfPossible(op[b]).
|
||
|
|
*/
|
||
|
|
int64_t combinable_index(int a, int b) {
|
||
|
|
SkASSERT(b != a);
|
||
|
|
// Each index gets kNumOps - 1 contiguous bools
|
||
|
|
int64_t aOffset = a * (kNumOps - 1);
|
||
|
|
// Within a's range we have one value each other op, but not one for a itself.
|
||
|
|
int64_t bIdxInA = b < a ? b : b - 1;
|
||
|
|
return aOffset + bIdxInA;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Creates a legal set of combinability results for the ops. The likelihood that any two ops
|
||
|
|
* in a group can merge is randomly chosen.
|
||
|
|
*/
|
||
|
|
static void init_combinable(int numGroups, Combinable* combinable, SkRandom* random) {
|
||
|
|
SkScalar mergeProbability = random->nextUScalar1();
|
||
|
|
std::fill_n(combinable->begin(), kNumCombinableValues, GrOp::CombineResult::kCannotCombine);
|
||
|
|
SkTDArray<int> groups[kNumOps];
|
||
|
|
for (int i = 0; i < kNumOps; ++i) {
|
||
|
|
auto& group = groups[random->nextULessThan(numGroups)];
|
||
|
|
for (int g = 0; g < group.count(); ++g) {
|
||
|
|
int j = group[g];
|
||
|
|
if (random->nextUScalar1() < mergeProbability) {
|
||
|
|
(*combinable)[combinable_index(i, j)] = GrOp::CombineResult::kMerged;
|
||
|
|
} else {
|
||
|
|
(*combinable)[combinable_index(i, j)] = GrOp::CombineResult::kMayChain;
|
||
|
|
}
|
||
|
|
if (random->nextUScalar1() < mergeProbability) {
|
||
|
|
(*combinable)[combinable_index(j, i)] = GrOp::CombineResult::kMerged;
|
||
|
|
} else {
|
||
|
|
(*combinable)[combinable_index(j, i)] = GrOp::CombineResult::kMayChain;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
group.push_back(i);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* A simple test op. It has an integer position, p. When it executes it writes p into an array
|
||
|
|
* of ints at index p and p+1. It takes a bitfield that indicates allowed pair-wise chainings.
|
||
|
|
*/
|
||
|
|
class TestOp : public GrOp {
|
||
|
|
public:
|
||
|
|
DEFINE_OP_CLASS_ID
|
||
|
|
|
||
|
|
static GrOp::Owner Make(GrRecordingContext* context, int value, const Range& range,
|
||
|
|
int result[], const Combinable* combinable) {
|
||
|
|
return GrOp::Make<TestOp>(context, value, range, result, combinable);
|
||
|
|
}
|
||
|
|
|
||
|
|
const char* name() const override { return "TestOp"; }
|
||
|
|
|
||
|
|
void writeResult(int result[]) const {
|
||
|
|
for (const auto& op : ChainRange<TestOp>(this)) {
|
||
|
|
for (const auto& vr : op.fValueRanges) {
|
||
|
|
for (unsigned i = 0; i < vr.fRange.fLength; ++i) {
|
||
|
|
result[vr.fRange.fOffset + i] = vr.fValue;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private:
|
||
|
|
friend class ::GrOp; // for ctor
|
||
|
|
|
||
|
|
TestOp(int value, const Range& range, int result[], const Combinable* combinable)
|
||
|
|
: INHERITED(ClassID()), fResult(result), fCombinable(combinable) {
|
||
|
|
fValueRanges.push_back({value, range});
|
||
|
|
this->setBounds(SkRect::MakeXYWH(range.fOffset, 0, range.fOffset + range.fLength, 1),
|
||
|
|
HasAABloat::kNo, IsHairline::kNo);
|
||
|
|
}
|
||
|
|
|
||
|
|
void onPrePrepare(GrRecordingContext*,
|
||
|
|
const GrSurfaceProxyView& writeView,
|
||
|
|
GrAppliedClip*,
|
||
|
|
const GrXferProcessor::DstProxyView&,
|
||
|
|
GrXferBarrierFlags renderPassXferBarriers,
|
||
|
|
GrLoadOp colorLoadOp) override {}
|
||
|
|
|
||
|
|
void onPrepare(GrOpFlushState*) override {}
|
||
|
|
|
||
|
|
void onExecute(GrOpFlushState*, const SkRect& chainBounds) override {
|
||
|
|
for (auto& op : ChainRange<TestOp>(this)) {
|
||
|
|
op.writeResult(fResult);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
CombineResult onCombineIfPossible(GrOp* t, SkArenaAlloc* arenas, const GrCaps&) override {
|
||
|
|
// This op doesn't use the arenas, but make sure the GrOpsTask is sending it
|
||
|
|
SkASSERT(arenas);
|
||
|
|
(void) arenas;
|
||
|
|
auto that = t->cast<TestOp>();
|
||
|
|
int v0 = fValueRanges[0].fValue;
|
||
|
|
int v1 = that->fValueRanges[0].fValue;
|
||
|
|
auto result = (*fCombinable)[combinable_index(v0, v1)];
|
||
|
|
if (result == GrOp::CombineResult::kMerged) {
|
||
|
|
std::move(that->fValueRanges.begin(), that->fValueRanges.end(),
|
||
|
|
std::back_inserter(fValueRanges));
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
struct ValueRange {
|
||
|
|
int fValue;
|
||
|
|
Range fRange;
|
||
|
|
};
|
||
|
|
std::vector<ValueRange> fValueRanges;
|
||
|
|
int* fResult;
|
||
|
|
const Combinable* fCombinable;
|
||
|
|
|
||
|
|
using INHERITED = GrOp;
|
||
|
|
};
|
||
|
|
} // namespace
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Tests adding kNumOps to an op list with all possible allowed chaining configurations. Tests
|
||
|
|
* adding the ops in all possible orders and verifies that the chained executions don't violate
|
||
|
|
* painter's order.
|
||
|
|
*/
|
||
|
|
DEF_GPUTEST(OpChainTest, reporter, /*ctxInfo*/) {
|
||
|
|
sk_sp<GrDirectContext> dContext = GrDirectContext::MakeMock(nullptr);
|
||
|
|
SkASSERT(dContext);
|
||
|
|
const GrCaps* caps = dContext->priv().caps();
|
||
|
|
static constexpr SkISize kDims = {kNumOps + 1, 1};
|
||
|
|
|
||
|
|
const GrBackendFormat format = caps->getDefaultBackendFormat(GrColorType::kRGBA_8888,
|
||
|
|
GrRenderable::kYes);
|
||
|
|
|
||
|
|
static const GrSurfaceOrigin kOrigin = kTopLeft_GrSurfaceOrigin;
|
||
|
|
auto proxy = dContext->priv().proxyProvider()->createProxy(
|
||
|
|
format, kDims, GrRenderable::kYes, 1, GrMipmapped::kNo, SkBackingFit::kExact,
|
||
|
|
SkBudgeted::kNo, GrProtected::kNo, GrInternalSurfaceFlags::kNone);
|
||
|
|
SkASSERT(proxy);
|
||
|
|
proxy->instantiate(dContext->priv().resourceProvider());
|
||
|
|
|
||
|
|
GrSwizzle writeSwizzle = caps->getWriteSwizzle(format, GrColorType::kRGBA_8888);
|
||
|
|
|
||
|
|
int result[result_width()];
|
||
|
|
int validResult[result_width()];
|
||
|
|
|
||
|
|
int permutation[kNumOps];
|
||
|
|
for (int i = 0; i < kNumOps; ++i) {
|
||
|
|
permutation[i] = i;
|
||
|
|
}
|
||
|
|
// Op order permutations.
|
||
|
|
static constexpr int kNumPermutations = 100;
|
||
|
|
// For a given number of chainability groups, this is the number of random combinability reuslts
|
||
|
|
// we will test.
|
||
|
|
static constexpr int kNumCombinabilitiesPerGrouping = 20;
|
||
|
|
SkRandom random;
|
||
|
|
bool repeat = false;
|
||
|
|
Combinable combinable;
|
||
|
|
GrDrawingManager* drawingMgr = dContext->priv().drawingManager();
|
||
|
|
sk_sp<GrArenas> arenas = sk_make_sp<GrArenas>();
|
||
|
|
for (int p = 0; p < kNumPermutations; ++p) {
|
||
|
|
for (int i = 0; i < kNumOps - 2 && !repeat; ++i) {
|
||
|
|
// The current implementation of nextULessThan() is biased. :(
|
||
|
|
unsigned j = i + random.nextULessThan(kNumOps - i);
|
||
|
|
std::swap(permutation[i], permutation[j]);
|
||
|
|
}
|
||
|
|
// g is the number of chainable groups that we partition the ops into.
|
||
|
|
for (int g = 1; g < kNumOps; ++g) {
|
||
|
|
for (int c = 0; c < kNumCombinabilitiesPerGrouping; ++c) {
|
||
|
|
init_combinable(g, &combinable, &random);
|
||
|
|
GrTokenTracker tracker;
|
||
|
|
GrOpFlushState flushState(dContext->priv().getGpu(),
|
||
|
|
dContext->priv().resourceProvider(),
|
||
|
|
&tracker);
|
||
|
|
GrOpsTask opsTask(drawingMgr,
|
||
|
|
GrSurfaceProxyView(proxy, kOrigin, writeSwizzle),
|
||
|
|
dContext->priv().auditTrail(),
|
||
|
|
arenas);
|
||
|
|
// This assumes the particular values of kRanges.
|
||
|
|
std::fill_n(result, result_width(), -1);
|
||
|
|
std::fill_n(validResult, result_width(), -1);
|
||
|
|
for (int i = 0; i < kNumOps; ++i) {
|
||
|
|
int value = permutation[i];
|
||
|
|
// factor out the repeats and then use the canonical starting position and range
|
||
|
|
// to determine an actual range.
|
||
|
|
int j = value % (kNumRanges * kNumOpPositions);
|
||
|
|
int pos = j % kNumOpPositions;
|
||
|
|
Range range = kRanges[j / kNumOpPositions];
|
||
|
|
range.fOffset += pos;
|
||
|
|
auto op = TestOp::Make(dContext.get(), value, range, result, &combinable);
|
||
|
|
TestOp* testOp = (TestOp*)op.get();
|
||
|
|
testOp->writeResult(validResult);
|
||
|
|
opsTask.addOp(drawingMgr, std::move(op),
|
||
|
|
GrTextureResolveManager(dContext->priv().drawingManager()),
|
||
|
|
*caps);
|
||
|
|
}
|
||
|
|
opsTask.makeClosed(*caps);
|
||
|
|
opsTask.prepare(&flushState);
|
||
|
|
opsTask.execute(&flushState);
|
||
|
|
opsTask.endFlush(drawingMgr);
|
||
|
|
opsTask.disown(drawingMgr);
|
||
|
|
#if 0 // Useful to repeat a random configuration that fails the test while debugger attached.
|
||
|
|
if (!std::equal(result, result + result_width(), validResult)) {
|
||
|
|
repeat = true;
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
(void)repeat;
|
||
|
|
REPORTER_ASSERT(reporter, std::equal(result, result + result_width(), validResult));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|