std::unique_ptr <database>
managerimp::make_database (
std::string const& name,
scheduler& scheduler,
beast::journal journal,
int readthreads,
parameters const& backendparameters,
parameters fastbackendparameters)
{
std::unique_ptr <backend> backend (make_backend (
backendparameters, scheduler, journal));
std::unique_ptr <backend> fastbackend (
(fastbackendparameters.size () > 0)
? make_backend (fastbackendparameters, scheduler, journal)
: nullptr);
return std::make_unique <databaseimp> (name, scheduler, readthreads,
std::move (backend), std::move (fastbackend), journal);
}
static struct _backend* backend(PARSER *p, const char *id)
{
/* default backend */
if (id == NULL) {
return p->backends;
}
struct _backend *b;
for (b = p->backends; b->next != NULL; b = b->next) {
if (strcmp(b->next->id, id) == 0) {
return b->next;
}
}
b->next = make_backend(id);
return b->next;
}
static PARSER* parser_init(const char *file, FILE *io, int reload)
{
PARSER *p = calloc(1, sizeof(PARSER));
if (!p) {
pgr_abort(ABORT_MEMFAIL);
}
p->backends = make_backend(NULL);
p->f = parse_top;
p->l = lexer_init(file, io);
if (!p->l) {
parser_free(p);
return NULL;
}
return p;
}
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ResourceAllocatorTest, reporter, ctxInfo) {
GrProxyProvider* proxyProvider = ctxInfo.grContext()->contextPriv().proxyProvider();
GrResourceProvider* resourceProvider = ctxInfo.grContext()->contextPriv().resourceProvider();
bool orig = resourceProvider->testingOnly_setExplicitlyAllocateGPUResources(true);
struct TestCase {
ProxyParams fP1;
ProxyParams fP2;
bool fExpectation;
};
constexpr bool kRT = true;
constexpr bool kNotRT = false;
constexpr bool kShare = true;
constexpr bool kDontShare = false;
// Non-RT GrSurfaces are never recycled on some platforms.
bool kConditionallyShare = resourceProvider->caps()->reuseScratchTextures();
const GrPixelConfig kRGBA = kRGBA_8888_GrPixelConfig;
const GrPixelConfig kBGRA = kBGRA_8888_GrPixelConfig;
const SkBackingFit kE = SkBackingFit::kExact;
const SkBackingFit kA = SkBackingFit::kApprox;
const GrSurfaceOrigin kTL = kTopLeft_GrSurfaceOrigin;
const GrSurfaceOrigin kBL = kBottomLeft_GrSurfaceOrigin;
//--------------------------------------------------------------------------------------------
TestCase gOverlappingTests[] = {
//----------------------------------------------------------------------------------------
// Two proxies with overlapping intervals and compatible descriptors should never share
// RT version
{ { 64, kRT, kRGBA, kA, 0, kTL }, { 64, kRT, kRGBA, kA, 0, kTL }, kDontShare },
// non-RT version
{ { 64, kNotRT, kRGBA, kA, 0, kTL }, { 64, kNotRT, kRGBA, kA, 0, kTL }, kDontShare },
};
for (auto test : gOverlappingTests) {
sk_sp<GrSurfaceProxy> p1 = make_deferred(proxyProvider, test.fP1);
sk_sp<GrSurfaceProxy> p2 = make_deferred(proxyProvider, test.fP2);
overlap_test(reporter, resourceProvider,
std::move(p1), std::move(p2), test.fExpectation);
}
int k2 = ctxInfo.grContext()->caps()->getRenderTargetSampleCount(2, kRGBA);
int k4 = ctxInfo.grContext()->caps()->getRenderTargetSampleCount(4, kRGBA);
//--------------------------------------------------------------------------------------------
TestCase gNonOverlappingTests[] = {
//----------------------------------------------------------------------------------------
// Two non-overlapping intervals w/ compatible proxies should share
// both same size & approx
{ { 64, kRT, kRGBA, kA, 0, kTL }, { 64, kRT, kRGBA, kA, 0, kTL }, kShare },
{ { 64, kNotRT, kRGBA, kA, 0, kTL }, { 64, kNotRT, kRGBA, kA, 0, kTL }, kConditionallyShare },
// diffs sizes but still approx
{ { 64, kRT, kRGBA, kA, 0, kTL }, { 50, kRT, kRGBA, kA, 0, kTL }, kShare },
{ { 64, kNotRT, kRGBA, kA, 0, kTL }, { 50, kNotRT, kRGBA, kA, 0, kTL }, kConditionallyShare },
// sames sizes but exact
{ { 64, kRT, kRGBA, kE, 0, kTL }, { 64, kRT, kRGBA, kE, 0, kTL }, kShare },
{ { 64, kNotRT, kRGBA, kE, 0, kTL }, { 64, kNotRT, kRGBA, kE, 0, kTL }, kConditionallyShare },
//----------------------------------------------------------------------------------------
// Two non-overlapping intervals w/ different exact sizes should not share
{ { 56, kRT, kRGBA, kE, 0, kTL }, { 54, kRT, kRGBA, kE, 0, kTL }, kDontShare },
// Two non-overlapping intervals w/ _very different_ approx sizes should not share
{ { 255, kRT, kRGBA, kA, 0, kTL }, { 127, kRT, kRGBA, kA, 0, kTL }, kDontShare },
// Two non-overlapping intervals w/ different MSAA sample counts should not share
{ { 64, kRT, kRGBA, kA, k2, kTL },{ 64, kRT, kRGBA, kA, k4, kTL}, k2 == k4 },
// Two non-overlapping intervals w/ different configs should not share
{ { 64, kRT, kRGBA, kA, 0, kTL }, { 64, kRT, kBGRA, kA, 0, kTL }, kDontShare },
// Two non-overlapping intervals w/ different RT classifications should never share
{ { 64, kRT, kRGBA, kA, 0, kTL }, { 64, kNotRT, kRGBA, kA, 0, kTL }, kDontShare },
{ { 64, kNotRT, kRGBA, kA, 0, kTL }, { 64, kRT, kRGBA, kA, 0, kTL }, kDontShare },
// Two non-overlapping intervals w/ different origins should share
{ { 64, kRT, kRGBA, kA, 0, kTL }, { 64, kRT, kRGBA, kA, 0, kBL }, kShare },
};
for (auto test : gNonOverlappingTests) {
sk_sp<GrSurfaceProxy> p1 = make_deferred(proxyProvider, test.fP1);
sk_sp<GrSurfaceProxy> p2 = make_deferred(proxyProvider, test.fP2);
if (!p1 || !p2) {
continue; // creation can fail (i.e., for msaa4 on iOS)
}
non_overlap_test(reporter, resourceProvider,
std::move(p1), std::move(p2), test.fExpectation);
}
{
// Wrapped backend textures should never be reused
TestCase t[1] = {
{ { 64, kNotRT, kRGBA, kE, 0, kTL }, { 64, kNotRT, kRGBA, kE, 0, kTL }, kDontShare }
};
GrBackendTexture backEndTex;
sk_sp<GrSurfaceProxy> p1 = make_backend(ctxInfo.grContext(), t[0].fP1, &backEndTex);
sk_sp<GrSurfaceProxy> p2 = make_deferred(proxyProvider, t[0].fP2);
non_overlap_test(reporter, resourceProvider,
std::move(p1), std::move(p2), t[0].fExpectation);
cleanup_backend(ctxInfo.grContext(), &backEndTex);
}
resourceProvider->testingOnly_setExplicitlyAllocateGPUResources(orig);
}
