DDLFuzzer Class Reference

Public Member Functions
	DDLFuzzer (Fuzz *, ContextType)
	DDLFuzzer ()=delete
	DDLFuzzer (DDLFuzzer &)=delete
DDLFuzzer &	operator= (DDLFuzzer &)=delete
void	run ()
sk_sp< GrPromiseImageTexture >	fulfillPromiseImage (PromiseImageInfo &)
void	releasePromiseImage (PromiseImageInfo &)

Detailed Description

Definition at line 94 of file FuzzDDLThreading.cpp.

Constructor & Destructor Documentation

DDLFuzzer() [1/3]

DDLFuzzer::DDLFuzzer	(	Fuzz *	fuzz,
		ContextType	contextType
	)

Definition at line 128 of file FuzzDDLThreading.cpp.

                                                        : fFuzz(fuzz) {
    sk_gpu_test::ContextInfo ctxInfo = fContextFactory.getContextInfo(contextType);
    sk_gpu_test::TestContext* testCtx = ctxInfo.testContext();
    fContext = ctxInfo.directContext();
    if (!fContext) {
        return;
    }
    SkISize canvasSize = kPromiseImageSize;
    canvasSize.fWidth *= kPromiseImagesPerDDL;
    SkImageInfo ii = SkImageInfo::Make(canvasSize, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
    fSurface = SkSurfaces::RenderTarget(fContext, skgpu::Budgeted::kNo, ii);
    if (!fSurface || !fSurface->characterize(&fSurfaceCharacterization)) {
        return;
    }
 
    testCtx->makeNotCurrent();
    fGpuTaskGroup.add([&]{
        testCtx->makeCurrent();
        fGpuThread = SkGetThreadID();
    });
    fGpuTaskGroup.wait();
    for (int i = 0; i < kPromiseImageCount; ++i) {
        this->initPromiseImage(i);
    }
}

DDLFuzzer() [2/3]

DDLFuzzer::DDLFuzzer ( )

delete

DDLFuzzer() [3/3]

DDLFuzzer::DDLFuzzer ( DDLFuzzer &  )

delete

Member Function Documentation

fulfillPromiseImage()

sk_sp< GrPromiseImageTexture > DDLFuzzer::fulfillPromiseImage

(

PromiseImageInfo &

promiseImage

)

Definition at line 154 of file FuzzDDLThreading.cpp.

                                                                                          {
    using State = PromiseImageInfo::State;
    if (!this->isOnGPUThread()) {
        fFuzz->signalBug();
    }
    bool success = make_fuzz_t<bool>(fFuzz);
    State prior = promiseImage.fState.exchange(State::kTriedToFulfill, std::memory_order_relaxed);
    if (prior != State::kInitial || promiseImage.fTexture != nullptr) {
        fFuzz->signalBug();
    }
    if (!success) {
        return nullptr;
    }
 
    // Try reusing an existing texture if we can and if the fuzzer wills it.
    if (!fReusableTextures.empty() && make_fuzz_t<bool>(fFuzz)) {
        promiseImage.fTexture = std::move(fReusableTextures.front());
        fReusableTextures.pop();
        return promiseImage.fTexture;
    }
 
    bool finishedBECreate = false;
    auto markFinished = [](void* context) {
        *(bool*)context = true;
    };
 
    GrBackendTexture backendTex =
            fContext->createBackendTexture(kPromiseImageSize.width(),
                                           kPromiseImageSize.height(),
                                           kRGBA_8888_SkColorType,
                                           SkColors::kRed,
                                           skgpu::Mipmapped::kNo,
                                           GrRenderable::kYes,
                                           GrProtected::kNo,
                                           markFinished,
                                           &finishedBECreate,
                                           /*label=*/"DDLFuzzer_FulFillPromiseImage");
    SkASSERT_RELEASE(backendTex.isValid());
    while (!finishedBECreate) {
        fContext->checkAsyncWorkCompletion();
    }
 
    promiseImage.fTexture = GrPromiseImageTexture::Make(backendTex);
 
    return promiseImage.fTexture;
}

operator=()

DDLFuzzer & DDLFuzzer::operator= ( DDLFuzzer &  )

delete

releasePromiseImage()

void DDLFuzzer::releasePromiseImage

(

PromiseImageInfo &

promiseImage

)

Definition at line 201 of file FuzzDDLThreading.cpp.

                                                                  {
    using State = PromiseImageInfo::State;
    // TODO: This requirement will go away when we unref promise images off the GPU thread.
    if (!this->isOnGPUThread()) {
        fFuzz->signalBug();
    }
 
    State old = promiseImage.fState.exchange(State::kDone, std::memory_order_relaxed);
    if (promiseImage.fDrawn && old != State::kTriedToFulfill) {
        fFuzz->signalBug();
    }
 
    // If we failed to fulfill, then nothing to be done.
    if (!promiseImage.fTexture) {
        return;
    }
 
    bool reuse = make_fuzz_t<bool>(fFuzz);
    if (reuse) {
        fReusableTextures.push(std::move(promiseImage.fTexture));
    } else {
        fContext->deleteBackendTexture(promiseImage.fTexture->backendTexture());
    }
    promiseImage.fTexture = nullptr;
}

run()

void DDLFuzzer::run

(

)

Definition at line 277 of file FuzzDDLThreading.cpp.

                    {
    if (!fSurface) {
        return;
    }
    fRecordingTaskGroup.batch(kIterationCount, [this](int i) { this->recordAndPlayDDL(); });
    fRecordingTaskGroup.wait();
 
    fGpuTaskGroup.add([this] { fContext->flushAndSubmit(fSurface.get(), GrSyncCpu::kYes); });
 
    fGpuTaskGroup.wait();
 
    fGpuTaskGroup.add([this] {
        while (!fReusableTextures.empty()) {
            sk_sp<GrPromiseImageTexture> gpuTexture = std::move(fReusableTextures.front());
            fContext->deleteBackendTexture(gpuTexture->backendTexture());
            fReusableTextures.pop();
        }
        fContextFactory.destroyContexts();
        // TODO: Release promise images not on the GPU thread.
        fPromiseImages.reset(0);
    });
    fGpuTaskGroup.wait();
}

---

The documentation for this class was generated from the following file:

• third_party/skia/fuzz/FuzzDDLThreading.cpp