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); }